tinypool 1.1.1

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/tinypool@1.1.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/tinypool@1.1.1

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:9292f8f9ea676a7760810dca0a42fc010defcea6dd8c5ad5192b0ed83e485c2b","contract":["createWorkerPool initializes Tinypool instance with worker filename","runNamedTask routes execution to specific named export functions in worker","runCancellableTask aborts execution when AbortSignal is triggered and throws AbortError","recyclePool refreshes worker threads and continues processing subsequent tasks","completed count tracks total number of finished tasks","destroy gracefully closes worker pool and clears active worker threads"],"goal":"verify pkg:npm/tinypool@1.1.1","kind":"HOW","packages":["pkg:npm/tinypool@1.1.1"],"schemaVersion":1},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/tinypool@1.1.1"],"schemaVersion":1,"subject":"pkg:npm/tinypool@1.1.1","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-tinypool",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-tinypool",
      "version": "1.0.0",
      "dependencies": {
        "tinypool": "1.1.1"
      }
    },
    "node_modules/tinypool": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
      "license": "MIT",
      "engines": {
        "node": "^18.0.0 || >=20.0.0"
      }
    }
  }
}

{
  "name": "sample-tinypool",
  "version": "1.0.0",
  "type": "module",
  "private": true,
  "description": "Clean-room verification of tinypool named task routing and signal cancellation",
  "main": "src/index.js",
  "dependencies": {
    "tinypool": "1.1.1"
  }
}

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

import { Tinypool } from 'tinypool';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const __dirname = path.dirname(fileURLToPath(import.meta.url));

/**
 * Creates and initializes a Tinypool worker pool instance.
 * @param {object} [options] - Options passed to Tinypool constructor
 * @returns {Tinypool} Initialized worker pool
 */
export function createWorkerPool(options = {}) {
  const defaultWorker = path.resolve(__dirname, 'worker.js');
  return new Tinypool({
    filename: defaultWorker,
    minThreads: 1,
    maxThreads: 2,
    ...options
  });
}

/**
 * Executes a named worker function task on the pool.
 * @param {Tinypool} pool - Worker pool instance
 * @param {string} name - Named export function name
 * @param {object} payload - Task payload
 * @returns {Promise<any>} Task execution result
 */
export async function runNamedTask(pool, name, payload) {
  return pool.run(payload, { name });
}

/**
 * Executes a cancellable task on the worker pool with an AbortSignal.
 * @param {Tinypool} pool - Worker pool instance
 * @param {string} name - Named export function name
 * @param {object} payload - Task payload
 * @param {AbortSignal} signal - Abort signal for task cancellation
 * @returns {Promise<any>} Task execution result
 */
export async function runCancellableTask(pool, name, payload, signal) {
  return pool.run(payload, { name, signal });
}

/**
 * Recycles worker threads in the pool.
 * @param {Tinypool} pool - Worker pool instance
 * @returns {Promise<void>}
 */
export async function recyclePool(pool) {
  return pool.recycleWorkers();
}

export function transformText({ text, mode }) {
  if (mode === 'uppercase') {
    return text.toUpperCase();
  }
  if (mode === 'reverse') {
    return text.split('').reverse().join('');
  }
  return text;
}

export function computeSum({ numbers }) {
  if (!Array.isArray(numbers)) {
    throw new TypeError('numbers must be an array');
  }
  return numbers.reduce((acc, n) => acc + n, 0);
}

export async function delayedEcho({ value, delayMs = 200 }) {
  await new Promise((resolve) => setTimeout(resolve, delayMs));
  return value;
}

export default function defaultHandler(task) {
  return { handled: true, payload: task };
}

import assert from 'node:assert';
import {
  createWorkerPool,
  runNamedTask,
  runCancellableTask,
  recyclePool
} from '../src/index.js';
import { Tinypool } from 'tinypool';

// 1. Verification of worker pool creation and instance
const pool = createWorkerPool();
assert.ok(pool instanceof Tinypool, 'pool should be an instance of Tinypool');
assert.strictEqual(typeof pool.run, 'function', 'pool should have a run method');

try {
  // 2. Named export function routing
  const upper = await runNamedTask(pool, 'transformText', { text: 'hello world', mode: 'uppercase' });
  assert.strictEqual(upper, 'HELLO WORLD', 'transformText uppercase should return HELLO WORLD');

  const reversed = await runNamedTask(pool, 'transformText', { text: 'abcde', mode: 'reverse' });
  assert.strictEqual(reversed, 'edcba', 'transformText reverse should return edcba');

  const sum = await runNamedTask(pool, 'computeSum', { numbers: [10, 20, 30, 40] });
  assert.strictEqual(sum, 100, 'computeSum should return 100');

  // Default export handling
  const def = await pool.run({ key: 'test-value' });
  assert.deepStrictEqual(def, { handled: true, payload: { key: 'test-value' } });

  // 3. Task cancellation via AbortSignal
  const controller = new AbortController();
  const cancellablePromise = runCancellableTask(pool, 'delayedEcho', { value: 'aborted-val', delayMs: 400 }, controller.signal);
  setTimeout(() => controller.abort(), 30);

  await assert.rejects(
    async () => {
      await cancellablePromise;
    },
    (err) => {
      return err.name === 'AbortError' || (err.message && err.message.includes('aborted'));
    },
    'Task should reject with AbortError when AbortSignal fires'
  );

  // 4. Worker recycling
  await recyclePool(pool);
  const postRecycle = await runNamedTask(pool, 'transformText', { text: 'after recycle', mode: 'uppercase' });
  assert.strictEqual(postRecycle, 'AFTER RECYCLE', 'Worker pool should function normally after recycling');

  // 5. Completed task count tracking
  assert.ok(pool.completed >= 4, 'pool.completed should track completed tasks count');

  // 6. Graceful shutdown
  assert.ok(pool.threads.length >= 1, 'Pool should have active worker threads');
  await pool.destroy();
  assert.strictEqual(pool.threads.length, 0, 'Pool threads should be empty after destroy');

  console.log('Contract tests passed successfully.');
} finally {
  if (pool.threads.length > 0) {
    await pool.destroy();
  }
}