undici-types 8.3.0: name

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 undici-types.name in pkg:npm/undici-types@8.3.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/undici-types@8.3.0
Demonstrate these symbols/APIs:
  - undici-types.name
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

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:c62f9bc3bc4f78e1b3c63c9596bdca308651c2f89193ec876517e787d7fdcde1","constraints":{"executionContext":"node"},"contract":["undici-types package.json declares name undici-types and version 8.3.0","undici-types errors.d.ts declares base UndiciError class with name property of type string","undici-types errors.d.ts declares timeout error classes with literal name properties ConnectTimeoutError, HeadersTimeoutError, HeadersOverflowError, and BodyTimeoutError","undici-types errors.d.ts declares validation and abort error classes with literal name properties InvalidArgumentError, InvalidReturnValueError, and AbortError","undici-types errors.d.ts declares client state error classes with literal name properties ClientDestroyedError and ClientClosedError","undici-types errors.d.ts declares network and protocol error classes with literal name properties SocketError, NotSupportedError, ResponseError, and ResponseExceededMaxSizeError","undici-types errors.d.ts declares pool and proxy error classes with literal name properties MissingUpstreamError, SecureProxyConnectionError, Socks5ProxyError, and MaxOriginsReachedError","undici-types mock-errors.d.ts declares MockNotMatchedError with literal name property MockNotMatchedError","undici-types index.d.ts exports errors and mockErrors namespaces and Undici namespace includes typed errors and mockErrors members"],"goal":"verify undici-types.name in pkg:npm/undici-types@8.3.0","kind":"HOW","packages":["pkg:npm/undici-types@8.3.0"],"schemaVersion":1,"symbols":["undici-types.name"]},"contractCommand":["node","test/contract.js"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/undici-types@8.3.0"],"schemaVersion":1,"subject":"pkg:npm/undici-types@8.3.0","symbols":["undici-types.name"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-undici-types-name",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-undici-types-name",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "undici-types": "8.3.0"
      }
    },
    "node_modules/undici-types": {
      "version": "8.3.0",
      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz",
      "integrity": "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-undici-types-name",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification sample for undici-types.name",
  "main": "src/index.js",
  "scripts": {
    "test": "node test/contract.js"
  },
  "dependencies": {
    "undici-types": "8.3.0"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify undici-types.name in pkg:npm/undici-types@8.3.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/undici-types@8.3.0"
  ],
  "symbols": [
    "undici-types.name"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

const fs = require('node:fs');
const path = require('node:path');

/**
 * Resolves the path to a file within the undici-types package.
 * @param {string} [subPath='index.d.ts'] - Relative declaration file path
 * @returns {string} Absolute path to the resolved file
 */
function resolvePackagePath(subPath = 'index.d.ts') {
  const pkgJsonPath = require.resolve('undici-types/package.json');
  const pkgDir = path.dirname(pkgJsonPath);
  return path.join(pkgDir, subPath);
}

/**
 * Reads and parses the undici-types package.json metadata.
 * @returns {object} Parsed package.json object
 */
function getPackageMetadata() {
  const pkgJsonPath = resolvePackagePath('package.json');
  return JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
}

/**
 * Reads the text content of a declaration file from undici-types.
 * @param {string} [subPath='index.d.ts'] - Relative declaration file path
 * @returns {string} Text content of the declaration file
 */
function readDeclarationFile(subPath = 'index.d.ts') {
  const filePath = resolvePackagePath(subPath);
  return fs.readFileSync(filePath, 'utf8');
}

/**
 * Validates error and package name declarations in undici-types.
 * @returns {object} Validation results for error names and package name
 */
function inspectNameDeclarations() {
  const pkg = getPackageMetadata();
  const errorsContent = readDeclarationFile('errors.d.ts');
  const mockErrorsContent = readDeclarationFile('mock-errors.d.ts');
  const indexContent = readDeclarationFile('index.d.ts');

  return {
    packageName: pkg.name,
    packageVersion: pkg.version,
    hasBaseUndiciErrorName: errorsContent.includes('export class UndiciError extends Error') && errorsContent.includes('name: string'),
    hasConnectTimeoutErrorName: errorsContent.includes("name: 'ConnectTimeoutError'"),
    hasHeadersTimeoutErrorName: errorsContent.includes("name: 'HeadersTimeoutError'"),
    hasHeadersOverflowErrorName: errorsContent.includes("name: 'HeadersOverflowError'"),
    hasBodyTimeoutErrorName: errorsContent.includes("name: 'BodyTimeoutError'"),
    hasResponseErrorName: errorsContent.includes("name: 'ResponseError'"),
    hasInvalidArgumentErrorName: errorsContent.includes("name: 'InvalidArgumentError'"),
    hasInvalidReturnValueErrorName: errorsContent.includes("name: 'InvalidReturnValueError'"),
    hasAbortErrorName: errorsContent.includes("name: 'AbortError'"),
    hasClientDestroyedErrorName: errorsContent.includes("name: 'ClientDestroyedError'"),
    hasClientClosedErrorName: errorsContent.includes("name: 'ClientClosedError'"),
    hasSocketErrorName: errorsContent.includes("name: 'SocketError'"),
    hasNotSupportedErrorName: errorsContent.includes("name: 'NotSupportedError'"),
    hasMissingUpstreamErrorName: errorsContent.includes("name: 'MissingUpstreamError'"),
    hasHTTPParserErrorName: errorsContent.includes("name: 'HTTPParserError'"),
    hasResponseExceededMaxSizeErrorName: errorsContent.includes("name: 'ResponseExceededMaxSizeError'"),
    hasRequestRetryErrorName: errorsContent.includes("name: 'RequestRetryError'"),
    hasSecureProxyConnectionErrorName: errorsContent.includes("name: 'SecureProxyConnectionError'"),
    hasMaxOriginsReachedErrorName: errorsContent.includes("name: 'MaxOriginsReachedError'"),
    hasSocks5ProxyErrorName: errorsContent.includes("name: 'Socks5ProxyError'"),
    hasMessageSizeExceededErrorName: errorsContent.includes("name: 'MessageSizeExceededError'"),
    hasMockNotMatchedErrorName: mockErrorsContent.includes("name: 'MockNotMatchedError'"),
    hasErrorsExport: indexContent.includes("errors,") && indexContent.includes("mockErrors,"),
    hasErrorsNamespaceExport: indexContent.includes("const errors: typeof import('./errors').default") && indexContent.includes("const mockErrors: typeof import('./mock-errors').default")
  };
}

module.exports = {
  resolvePackagePath,
  getPackageMetadata,
  readDeclarationFile,
  inspectNameDeclarations
};

const assert = require('node:assert');
const {
  getPackageMetadata,
  readDeclarationFile,
  inspectNameDeclarations
} = require('../src/index.js');

// 1. undici-types package.json declares name undici-types and version 8.3.0
const pkg = getPackageMetadata();
assert.strictEqual(pkg.name, 'undici-types', 'Package name must be undici-types');
assert.strictEqual(pkg.version, '8.3.0', 'Package version must be 8.3.0');

// 2. undici-types errors.d.ts declares base UndiciError class with name property of type string
const errorsContent = readDeclarationFile('errors.d.ts');
assert.strictEqual(errorsContent.includes('export class UndiciError extends Error'), true);
assert.strictEqual(errorsContent.includes('name: string'), true);

// 3. undici-types errors.d.ts declares timeout error classes with literal name properties ConnectTimeoutError, HeadersTimeoutError, HeadersOverflowError, and BodyTimeoutError
assert.strictEqual(errorsContent.includes("name: 'ConnectTimeoutError'"), true);
assert.strictEqual(errorsContent.includes("name: 'HeadersTimeoutError'"), true);
assert.strictEqual(errorsContent.includes("name: 'HeadersOverflowError'"), true);
assert.strictEqual(errorsContent.includes("name: 'BodyTimeoutError'"), true);

// 4. undici-types errors.d.ts declares validation and abort error classes with literal name properties InvalidArgumentError, InvalidReturnValueError, and AbortError
assert.strictEqual(errorsContent.includes("name: 'InvalidArgumentError'"), true);
assert.strictEqual(errorsContent.includes("name: 'InvalidReturnValueError'"), true);
assert.strictEqual(errorsContent.includes("name: 'AbortError'"), true);

// 5. undici-types errors.d.ts declares client state error classes with literal name properties ClientDestroyedError and ClientClosedError
assert.strictEqual(errorsContent.includes("name: 'ClientDestroyedError'"), true);
assert.strictEqual(errorsContent.includes("name: 'ClientClosedError'"), true);

// 6. undici-types errors.d.ts declares network and protocol error classes with literal name properties SocketError, NotSupportedError, ResponseError, and ResponseExceededMaxSizeError
assert.strictEqual(errorsContent.includes("name: 'SocketError'"), true);
assert.strictEqual(errorsContent.includes("name: 'NotSupportedError'"), true);
assert.strictEqual(errorsContent.includes("name: 'ResponseError'"), true);
assert.strictEqual(errorsContent.includes("name: 'ResponseExceededMaxSizeError'"), true);

// 7. undici-types errors.d.ts declares pool and proxy error classes with literal name properties MissingUpstreamError, SecureProxyConnectionError, Socks5ProxyError, and MaxOriginsReachedError
assert.strictEqual(errorsContent.includes("name: 'MissingUpstreamError'"), true);
assert.strictEqual(errorsContent.includes("name: 'SecureProxyConnectionError'"), true);
assert.strictEqual(errorsContent.includes("name: 'Socks5ProxyError'"), true);
assert.strictEqual(errorsContent.includes("name: 'MaxOriginsReachedError'"), true);

// 8. undici-types mock-errors.d.ts declares MockNotMatchedError with literal name property MockNotMatchedError
const mockErrorsContent = readDeclarationFile('mock-errors.d.ts');
assert.strictEqual(mockErrorsContent.includes("export class MockNotMatchedError extends Errors.UndiciError"), true);
assert.strictEqual(mockErrorsContent.includes("name: 'MockNotMatchedError'"), true);

// 9. undici-types index.d.ts exports errors and mockErrors namespaces and Undici namespace includes typed errors and mockErrors members
const indexContent = readDeclarationFile('index.d.ts');
assert.strictEqual(indexContent.includes("import errors from './errors'"), true);
assert.strictEqual(indexContent.includes("import mockErrors from './mock-errors'"), true);
assert.strictEqual(indexContent.includes("export { Dispatcher,"), true);
assert.strictEqual(indexContent.includes("errors,"), true);
assert.strictEqual(indexContent.includes("mockErrors,"), true);
assert.strictEqual(indexContent.includes("const errors: typeof import('./errors').default"), true);
assert.strictEqual(indexContent.includes("const mockErrors: typeof import('./mock-errors').default"), true);

// 10. Verify inspection helper
const inspection = inspectNameDeclarations();
assert.strictEqual(inspection.packageName, 'undici-types');
assert.strictEqual(inspection.packageVersion, '8.3.0');
assert.strictEqual(inspection.hasBaseUndiciErrorName, true);
assert.strictEqual(inspection.hasConnectTimeoutErrorName, true);
assert.strictEqual(inspection.hasMockNotMatchedErrorName, true);
assert.strictEqual(inspection.hasErrorsExport, true);
assert.strictEqual(inspection.hasErrorsNamespaceExport, true);

console.log('All undici-types.name contract tests passed successfully.');