@types/gensync 1.0.5

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 pkg:npm/%40types/gensync@1.0.5
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/%40types/gensync@1.0.5
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:e00b22ef5d218eb90caf96fac4e0ebbb03982c3476a996fd92ae83041e8ace45","constraints":{"executionContext":"node"},"contract":["package manifest specifies index.d.ts type declarations and TypeScript version","declares gensync main function signature accepting generator function or options","declares Handler, Handled, Callback, and Gensync interface with sync, async, and errback methods","declares SyncOptions, AsyncOptions, ErrbackOptions, and Options type definitions","declares all and race generator combinator functions for arrays and iterables"],"goal":"verify pkg:npm/%40types/gensync@1.0.5","kind":"HOW","packages":["pkg:npm/%40types/gensync@1.0.5"],"schemaVersion":1},"contractCommand":["node","test/contract.mjs"],"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/%40types/gensync@1.0.5"],"schemaVersion":1,"subject":"pkg:npm/%40types/gensync@1.0.5","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-types-gensync",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-types-gensync",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "@types/gensync": "1.0.5"
      }
    },
    "node_modules/@types/gensync": {
      "version": "1.0.5",
      "resolved": "https://registry.npmjs.org/@types/gensync/-/gensync-1.0.5.tgz",
      "integrity": "sha512-MbsRCT7mTikHwKZ0X+LVUTLRrZZRLipTuXEO9qOYO+zmjMVk81axyClMROf6uoPD9MRVu46bx8zoR0Ad9q3NAg==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-types-gensync",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "license": "MIT-0",
  "dependencies": {
    "@types/gensync": "1.0.5"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/%40types/gensync@1.0.5",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40types/gensync@1.0.5"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
import fs from 'node:fs';
import path from 'node:path';

const require = createRequire(import.meta.url);

// 1. Resolve @types/gensync package manifest and verify type declaration entry points
const pkgPath = require.resolve('@types/gensync/package.json');
const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));

assert.equal(pkg.name, '@types/gensync', 'Package name must be @types/gensync');
assert.equal(pkg.version, '1.0.5', 'Package version must be 1.0.5');
assert.equal(pkg.types, 'index.d.ts', 'Package types entry must point to index.d.ts');
assert.equal(pkg.typeScriptVersion, '5.3', 'TypeScript version must be 5.3');

const typesDir = path.dirname(pkgPath);
const dtsContent = fs.readFileSync(path.join(typesDir, 'index.d.ts'), 'utf8');

// 2. Verify gensync main function declaration and module export
assert.ok(
  dtsContent.includes('declare function gensync<A extends unknown[], R, E = any>('),
  'gensync function declaration must accept type parameters A, R, E'
);
assert.ok(
  dtsContent.includes('generatorFnOrOptions: ((...args: A) => Generator<gensync.Handler, R>) | gensync.Options<A, R, E>'),
  'gensync function parameter must accept generator function or Options'
);
assert.ok(
  dtsContent.includes('): gensync.Gensync<A, R, E>;'),
  'gensync function return type must be gensync.Gensync<A, R, E>'
);
assert.ok(
  dtsContent.includes('export = gensync;'),
  'CommonJS export = gensync declaration must be present'
);

// 3. Verify Handler, Handled, Callback, and Gensync interface
assert.ok(
  dtsContent.includes('type Handler<R = any> = Generator<Handler, R>;'),
  'Handler type alias must be declared as Generator<Handler, R>'
);
assert.ok(
  dtsContent.includes('type Handled<T> = T extends Handler<infer U> ? U : never;'),
  'Handled type alias must unwrap Handler type'
);
assert.ok(
  dtsContent.includes('type Callback<R, E = any> = [R] extends [void] ? (err: E) => void : (err: E, result: R) => void;'),
  'Callback type alias must handle void and non-void results'
);
assert.ok(
  dtsContent.includes('interface Gensync<A extends unknown[], R, E = any> {'),
  'Gensync interface must be declared'
);
assert.ok(
  dtsContent.includes('(...args: A): Handler<R>;') &&
  dtsContent.includes('sync(...args: A): R;') &&
  dtsContent.includes('async(...args: A): Promise<R>;') &&
  dtsContent.includes('errback(...args: [...args: A, callback: Callback<R, E>]): void;'),
  'Gensync interface must declare invocation, sync, async, and errback methods'
);

// 4. Verify Options interfaces: SyncOptions, AsyncOptions, ErrbackOptions, and Options
assert.ok(
  dtsContent.includes('interface SyncOptions<A extends unknown[], R> {') &&
  dtsContent.includes('sync: (...args: A) => R;') &&
  dtsContent.includes('name?: string | undefined;') &&
  dtsContent.includes('arity?: number | undefined;'),
  'SyncOptions interface must declare sync, name, and arity fields'
);
assert.ok(
  dtsContent.includes('interface AsyncOptions<A extends unknown[], R> extends Omit<SyncOptions<A, R>, "async"> {') &&
  dtsContent.includes('async: (...args: A) => Promise<R>;'),
  'AsyncOptions interface must extend SyncOptions with async field'
);
assert.ok(
  dtsContent.includes('interface ErrbackOptions<A extends unknown[], R, E = any> extends Omit<SyncOptions<A, R>, "errback"> {') &&
  dtsContent.includes('errback: (...args: [...A, Callback<R, E>]) => void;'),
  'ErrbackOptions interface must extend SyncOptions with errback field'
);
assert.ok(
  dtsContent.includes('type Options<A extends unknown[], R, E = any> ='),
  'Options union type must be declared'
);

// 5. Verify all and race generator combinator functions
assert.ok(
  dtsContent.includes('function all<T extends readonly Handler[] | []>(args: T): Handler<{ -readonly [P in keyof T]: Handled<T[P]> }>;') &&
  dtsContent.includes('function all<T>(args: Iterable<Handler<T>>): Handler<T[]>;'),
  'all combinator function overloads must be declared'
);
assert.ok(
  dtsContent.includes('function race<T extends readonly Handler[] | []>(args: T): Handler<Handled<T[number]>>;') &&
  dtsContent.includes('function race<T>(args: Iterable<Handler<T>>): Handler<T>;'),
  'race combinator function overloads must be declared'
);

console.log('Contract tests passed successfully.');