path-key 3.1.1: default

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify path-key.default in pkg:npm/path-key@3.1.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/path-key@3.1.1
Demonstrate these symbols/APIs:
  - path-key.default

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:217958415f9d3a2e0702d2b20a51c821ce14e7ef5ba31750cb1c524cbaecb718","contract":["pathKey.default is identical to the callable pathKey export","pathKey.default returns 'PATH' by default on POSIX platforms","pathKey.default returns 'PATH' for explicit POSIX platforms like linux and darwin","pathKey.default returns the exact matching key name from env on win32","pathKey.default returns the last defined PATH key when multiple case variants exist on win32","pathKey.default falls back to 'Path' on win32 when no PATH variable exists in env","pathKey.default respects custom platform and env options without mutating them"],"goal":"verify path-key.default in pkg:npm/path-key@3.1.1","kind":"HOW","packages":["pkg:npm/path-key@3.1.1"],"schemaVersion":1,"symbols":["path-key.default"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/path-key@3.1.1"],"schemaVersion":1,"subject":"pkg:npm/path-key@3.1.1","symbols":["path-key.default"],"verifierAdapter":"node-typescript@1"}

import pathKey from 'path-key';

/**
 * Resolves the platform-specific PATH environment variable key name using pathKey.default.
 *
 * @param {object} [options] - Configuration options.
 * @param {object} [options.env] - Custom environment variables map.
 * @param {string} [options.platform] - Target OS platform identifier.
 * @returns {string} The resolved PATH key name.
 */
export function resolvePathKey(options) {
  const fn = pathKey.default || pathKey;
  return fn(options);
}

/**
 * Retrieves the PATH value from a given environment using the resolved key name.
 *
 * @param {object} [env=process.env] - Environment variables map.
 * @param {object} [options={}] - Additional options for key resolution.
 * @returns {string|undefined} Value of the PATH environment variable.
 */
export function getPathFromEnv(env = process.env, options = {}) {
  const key = resolvePathKey({ ...options, env });
  return env[key];
}

export { pathKey };
export default pathKey;

{
  "name": "sample-path-key-default",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-path-key-default",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "path-key": "3.1.1"
      }
    },
    "node_modules/path-key": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    }
  }
}

{
  "name": "sample-path-key-default",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room code sample verifying path-key.default in path-key@3.1.1",
  "type": "module",
  "main": "index.js",
  "license": "MIT-0",
  "dependencies": {
    "path-key": "3.1.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify path-key.default in pkg:npm/path-key@3.1.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/path-key@3.1.1"
  ],
  "symbols": [
    "path-key.default"
  ]
}

import assert from 'node:assert/strict';
import pathKey from 'path-key';
import { resolvePathKey, getPathFromEnv } from '../index.js';

// 1. pathKey.default is identical to the callable pathKey export
{
  assert.equal(typeof pathKey, 'function', 'pathKey must be a function');
  assert.equal(typeof pathKey.default, 'function', 'pathKey.default must be a function');
  assert.equal(pathKey.default, pathKey, 'pathKey.default must strictly equal pathKey');
}

// 2. pathKey.default returns 'PATH' by default on POSIX platforms
{
  const defaultKey = pathKey.default();
  assert.equal(typeof defaultKey, 'string', 'pathKey.default() must return a string');
  assert.equal(defaultKey, 'PATH', 'default environment on linux must resolve to PATH');
  assert.equal(resolvePathKey(), 'PATH', 'resolvePathKey() helper must resolve to PATH by default');
}

// 3. pathKey.default returns 'PATH' for explicit POSIX platforms like linux and darwin
{
  assert.equal(pathKey.default({ platform: 'linux' }), 'PATH');
  assert.equal(pathKey.default({ platform: 'darwin' }), 'PATH');
  assert.equal(pathKey.default({ platform: 'aix' }), 'PATH');
  assert.equal(pathKey.default({ platform: 'freebsd' }), 'PATH');
  assert.equal(pathKey.default({ platform: 'openbsd' }), 'PATH');
  assert.equal(pathKey.default({ platform: 'sunos' }), 'PATH');
  assert.equal(pathKey.default({ platform: 'android' }), 'PATH');

  const customEnv = { Path: 'bin/custom', PATH: 'bin/posix' };
  assert.equal(pathKey.default({ platform: 'linux', env: customEnv }), 'PATH');
  assert.equal(resolvePathKey({ platform: 'linux', env: customEnv }), 'PATH');
}

// 4. pathKey.default returns the exact matching key name from env on win32
{
  assert.equal(pathKey.default({ platform: 'win32', env: { Path: 'bin/dir' } }), 'Path');
  assert.equal(pathKey.default({ platform: 'win32', env: { PATH: 'bin/dir' } }), 'PATH');
  assert.equal(pathKey.default({ platform: 'win32', env: { path: 'bin/dir' } }), 'path');
  assert.equal(pathKey.default({ platform: 'win32', env: { PaTh: 'bin/dir' } }), 'PaTh');
  assert.equal(resolvePathKey({ platform: 'win32', env: { Path: 'bin/dir' } }), 'Path');
}

// 5. pathKey.default returns the last defined PATH key when multiple case variants exist on win32
{
  const multiEnv = {
    Path: 'first-entry',
    PATH: 'second-entry',
    path: 'third-entry',
  };
  assert.equal(pathKey.default({ platform: 'win32', env: multiEnv }), 'path');
}

// 6. pathKey.default falls back to 'Path' on win32 when no PATH variable exists in env
{
  const emptyEnv = {};
  assert.equal(pathKey.default({ platform: 'win32', env: emptyEnv }), 'Path');

  const unrelatedEnv = {
    USER_NAME: 'testuser',
    HOME_DIR: 'home/user',
    APP_ENV: 'testing',
  };
  assert.equal(pathKey.default({ platform: 'win32', env: unrelatedEnv }), 'Path');
  assert.equal(resolvePathKey({ platform: 'win32', env: unrelatedEnv }), 'Path');
}

// 7. pathKey.default respects custom platform and env options without mutating them
{
  const testEnv = Object.freeze({ Path: 'bin/test' });
  const options = Object.freeze({ platform: 'win32', env: testEnv });
  const resolved = pathKey.default(options);
  assert.equal(resolved, 'Path');
  assert.equal(getPathFromEnv(testEnv, { platform: 'win32' }), 'bin/test');
}

console.log('All path-key.default contract tests passed successfully.');