reusify 1.1.0

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/reusify@1.1.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/reusify@1.1.0

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:7d33e3ce370cbaf8d9d5cb353a14a4d6bdff1371bab5ee088baf26ed3b76f9c2","contract":["reusify(Constructor) creates an object pool with get() and release() methods","pool.get() returns an instance of Constructor with next property reset to null","pool.release(obj) returns the allocated object back to the pool for reuse","subsequent pool.get() cycles return previously released instances"],"goal":"verify pkg:npm/reusify@1.1.0","kind":"HOW","packages":["pkg:npm/reusify@1.1.0"],"schemaVersion":1},"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/reusify@1.1.0"],"schemaVersion":1,"subject":"pkg:npm/reusify@1.1.0","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-3520361263",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "dependencies": {
        "reusify": "1.1.0"
      }
    },
    "node_modules/reusify": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
      "license": "MIT",
      "engines": {
        "iojs": ">=1.0.0",
        "node": ">=0.10.0"
      }
    }
  }
}

{
  "name": "sample-3520361263",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification for reusify",
  "main": "test/contract.js",
  "scripts": {
    "test": "node test/contract.js"
  },
  "dependencies": {
    "reusify": "1.1.0"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/reusify@1.1.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/reusify@1.1.0"
  ]
}

const assert = require('assert');
const reusify = require('reusify');

function PooledTask() {
  this.next = null;
  this.id = 0;
  this.payload = null;
}

// 1. Factory initialization creates a pool with get and release methods
const pool = reusify(PooledTask);
assert.strictEqual(typeof pool.get, 'function', 'pool.get must be a function');
assert.strictEqual(typeof pool.release, 'function', 'pool.release must be a function');

// 2. Initial retrieval from pool returns an instance of PooledTask
const taskA = pool.get();
assert(taskA instanceof PooledTask, 'pool.get() returns PooledTask instance');
assert.strictEqual(taskA.next, null, 'next property must be null upon retrieval');
assert.strictEqual(taskA.id, 0);

taskA.id = 42;
taskA.payload = 'task-a';

// 3. Releasing taskA back to the pool
pool.release(taskA);

// 4. Next get() returns the preallocated queue head
const taskB = pool.get();
assert(taskB instanceof PooledTask, 'pool.get() returns PooledTask instance');
assert.strictEqual(taskB.id, 0, 'preallocated instance has initial property values');
assert.notStrictEqual(taskB, taskA, 'taskB is distinct from taskA');

// 5. Subsequent get() retrieves the previously released taskA
const reusedTaskA = pool.get();
assert.strictEqual(reusedTaskA, taskA, 'pool.get() returns the released instance');
assert.strictEqual(reusedTaskA.id, 42, 'reused instance retains its modified property');
assert.strictEqual(reusedTaskA.payload, 'task-a');
assert.strictEqual(reusedTaskA.next, null, 'next property is reset to null upon retrieval');

// 6. Multi-object release and FIFO retrieval
taskB.id = 100;
reusedTaskA.id = 200;

pool.release(taskB);
pool.release(reusedTaskA);

const taskC = pool.get();
assert.strictEqual(taskC.id, 0);

const reusedTaskB = pool.get();
assert.strictEqual(reusedTaskB, taskB);
assert.strictEqual(reusedTaskB.id, 100);

const reusedTaskA2 = pool.get();
assert.strictEqual(reusedTaskA2, taskA);
assert.strictEqual(reusedTaskA2.id, 200);