queasy 0.3.0 → 0.3.1

package/dist/types.d.ts

@@ -0,0 +1,92 @@
+import type { RedisClientOptions, RedisClusterOptions } from 'redis';
+type SingleNodeOptions = Pick<RedisClientOptions, 'url' | 'socket' | 'username' | 'password' | 'database'>;
+export type RedisOptions = SingleNodeOptions | {
+    rootNodes: SingleNodeOptions[];
+    defaults?: Partial<SingleNodeOptions>;
+    nodeAddressMap?: RedisClusterOptions['nodeAddressMap'];
+};
+/**
+ * Core job identification and data
+ */
+export interface JobCoreOptions {
+    /** Job ID (auto-generated if not provided) */
+    id?: string;
+    /** Job data (any JSON-serializable value) */
+    data?: any;
+    /** Wall clock timestamp (ms) before which job must not run */
+    runAt?: number;
+}
+/**
+ * Update behavior flags
+ */
+export interface JobUpdateOptions {
+    /** Whether to replace data of waiting job with same ID */
+    updateData?: boolean;
+    /** How to update runAt */
+    updateRunAt?: boolean | 'if_later' | 'if_earlier';
+    /** Whether to reset retry_count and stall_count to 0 */
+    resetCounts?: boolean;
+}
+/**
+ * Complete options accepted by dispatch()
+ */
+export type JobOptions = JobCoreOptions & JobUpdateOptions;
+/**
+ * Job runtime state
+ */
+export interface JobState {
+    /** Number of times this job has been retried */
+    retryCount: number;
+    /** Number of times this job has stalled */
+    stallCount: number;
+}
+/**
+ * Complete job representation passed to handlers
+ */
+export type Job = Required<JobCoreOptions> & JobState;
+/**
+ * Handler options
+ */
+export interface HandlerOptions {
+    /** Maximum number of retries before permanent failure */
+    maxRetries?: number;
+    /** Maximum number of stalls before permanent failure */
+    maxStalls?: number;
+    /** Minimum backoff in milliseconds */
+    minBackoff?: number;
+    /** Maximum backoff in milliseconds */
+    maxBackoff?: number;
+    /** Size of the job (as a percent of total worker capacity) */
+    size?: number;
+    /** Maximum processing duration before considering stalled */
+    timeout?: number;
+    /** Priority of this queue (vs other queues) */
+    priority?: number;
+}
+/**
+ * Options for listen() - queue-level retry strategy
+ */
+export interface ListenOptions extends HandlerOptions {
+    /** Path to failure handler module (optional) */
+    failHandler?: string;
+    /** Retry options of the fail job */
+    failRetryOptions?: HandlerOptions;
+}
+export type ExecMessage = {
+    op: 'exec';
+    queue: string;
+    handlerPath: string;
+    job: Job;
+};
+export type DoneMessage = {
+    op: 'done';
+    jobId: string;
+    error?: {
+        name: string;
+        message: string;
+        retryAt?: number;
+        kind?: 'retriable' | 'permanent' | 'stall';
+    };
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAC;AAErE,KAAK,iBAAiB,GAAG,IAAI,CACzB,kBAAkB,EAClB,KAAK,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,CAC1D,CAAC;AAEF,MAAM,MAAM,YAAY,GAClB,iBAAiB,GACjB;IACI,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACtC,cAAc,CAAC,EAAE,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;CAC1D,CAAC;AAER;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,8CAA8C;IAC9C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAE7C,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,0DAA0D;IAC1D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,0BAA0B;IAC1B,WAAW,CAAC,EAAE,OAAO,GAAG,UAAU,GAAG,YAAY,CAAC;IAClD,wDAAwD;IACxD,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,QAAQ;IACrB,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,QAAQ,CAAC,cAAc,CAAC,GAAG,QAAQ,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,cAAc;IACjD,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,oCAAoC;IACpC,gBAAgB,CAAC,EAAE,cAAc,CAAC;CACrC;AAED,MAAM,MAAM,WAAW,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,GAAG,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,OAAO,CAAC;KAC9C,CAAC;CACL,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function generateId(length?: number): string;
+export declare function parseVersion(version: string | null | undefined): number[];
+export declare function compareSemver(a: number[], b: number[]): -1 | 0 | 1;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,MAAM,SAAK,GAAG,MAAM,CAO9C;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,EAAE,CAIzE;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAMlE"}

package/dist/utils.js

@@ -0,0 +1,24 @@
+export function generateId(length = 20) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let id = '';
+    for (let i = 0; i < length; i++) {
+        id += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return id;
+}
+export function parseVersion(version) {
+    const parsed = String(version).split('.').map(Number);
+    if (parsed.some((n) => Number.isNaN(n)))
+        return [0];
+    return parsed;
+}
+export function compareSemver(a, b) {
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+        if (a[i] !== b[i])
+            return a[i] < b[i] ? -1 : 1;
+    }
+    if (a.length !== b.length)
+        return a.length < b.length ? -1 : 1;
+    return 0;
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,UAAU,CAAC,MAAM,GAAG,EAAE;IAClC,MAAM,KAAK,GAAG,gEAAgE,CAAC;IAC/E,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC9B,EAAE,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACjE,CAAC;IACD,OAAO,EAAE,CAAC;AACd,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,OAAkC;IAC3D,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACtD,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpD,OAAO,MAAM,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,CAAW,EAAE,CAAW;IAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACpD,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC;IACD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/D,OAAO,CAAC,CAAC;AACb,CAAC"}

package/dist/worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":""}

package/dist/worker.js

@@ -0,0 +1,42 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { pathToFileURL } from 'node:url';
+import { parentPort, setEnvironmentData } from 'node:worker_threads';
+import { PermanentError } from "./errors.js";
+if (!parentPort)
+    throw new Error('Worker cannot be executed directly.');
+setEnvironmentData('queasy_worker_context', true);
+parentPort.on('message', async (msg) => {
+    const { handlerPath, job } = msg;
+    try {
+        const mod = await import(__rewriteRelativeImportExtension(pathToFileURL(handlerPath).href));
+        if (typeof mod.handle !== 'function') {
+            throw new Error(`Unable to load handler ${handlerPath}`);
+        }
+        await mod.handle(job.data, job);
+        send({ op: 'done', jobId: job.id });
+    }
+    catch (err) {
+        const { message, name, retryAt } = err;
+        send({
+            op: 'done',
+            jobId: job.id,
+            error: {
+                name,
+                message,
+                retryAt,
+                kind: err instanceof PermanentError ? 'permanent' : 'retriable',
+            },
+        });
+    }
+});
+function send(message) {
+    parentPort?.postMessage(message);
+}
+//# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":";;;;;;;;AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7C,IAAI,CAAC,UAAU;IAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;AACxE,kBAAkB,CAAC,uBAAuB,EAAE,IAAI,CAAC,CAAC;AAElD,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,GAAgB,EAAE,EAAE;IAChD,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;IACjC,IAAI,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,MAAM,kCAAC,aAAa,CAAC,WAAW,CAAC,CAAC,IAAI,EAAC,CAAC;QAC1D,IAAI,OAAO,GAAG,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,0BAA0B,WAAW,EAAE,CAAC,CAAC;QAC7D,CAAC;QAED,MAAM,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAChC,IAAI,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;IACxC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACX,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,GAAmC,CAAC;QAEvE,IAAI,CAAC;YACD,EAAE,EAAE,MAAM;YACV,KAAK,EAAE,GAAG,CAAC,EAAE;YACb,KAAK,EAAE;gBACH,IAAI;gBACJ,OAAO;gBACP,OAAO;gBACP,IAAI,EAAE,GAAG,YAAY,cAAc,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW;aAClE;SACJ,CAAC,CAAC;IACP,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,SAAS,IAAI,CAAC,OAAoB;IAC9B,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;AACrC,CAAC"}

package/fuzztest/{fuzz.js → fuzz.ts}

@@ -1,7 +1,7 @@
 /**
  * Fuzz test orchestrator.
  *
- * - Spawns NUM_PROCESSES child processes, each running fuzztest/process.js
+ * - Spawns NUM_PROCESSES child processes, each running fuzztest/process.ts
  * - Dispatches seed periodic jobs at startup
  * - Reads events from the fuzz:events Redis stream
  * - Checks system invariants after each event
@@ -10,12 +10,14 @@
  */
 
 import { fork } from 'node:child_process';
+import type { ChildProcess } from 'node:child_process';
 import { createWriteStream } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createClient } from 'redis';
-import { Client } from '../src/index.js';
-import { readEvents, STREAM_KEY } from './shared/stream.js';
+import type { RedisClientType } from 'redis';
+import { Client } from '../src/index.ts';
+import { STREAM_KEY, readEvents } from './shared/stream.ts';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -35,47 +37,61 @@ const LOG_FILE = join(__dirname, '..', 'fuzz-output.log');
 
 const logStream = createWriteStream(LOG_FILE, { flags: 'a' });
 
-function log(level, msg, data = {}) {
-    const entry = JSON.stringify({ time: new Date().toISOString(), level, msg, data });
-    if (level === 'error') process.stdout.write(`VIOLATION: ${entry}\n`);
-    else process.stdout.write(`${entry}\n`);
+function log(level: string, msg: string, data: Record<string, unknown> = {}): void {
+    let entry = `${process.uptime().toFixed(2)} ${level.toUpperCase().padEnd(5)}`;
+    const { type = '', queue = '', id = '', ...rest } = data;
+    entry = `${entry} ${msg.padEnd(10)} ${(type as string).padEnd(10)} ${(queue as string).padEnd(15)} ${(id as string).padEnd(15)} ${JSON.stringify(rest)}`;
+    process.stdout.write(`${entry}\n`);
     logStream.write(`${entry}\n`);
 }
 
 // ── Invariant state ────────────────────────────────────────────────────────────
 
-/** @type {Map<string, {queue: string, startedAt: number, runAt: number, pid: number}>} */
-const activeJobs = new Map();
+interface ActiveJob {
+    queue: string;
+    startedAt: number;
+    runAt: number;
+    pid: number;
+}
+
+interface WaitingJob {
+    id: string;
+    runAt: number;
+    dispatchedAt: number;
+}
 
-/** @type {Set<string>} */
-const succeededJobs = new Set();
+const activeJobs = new Map<string, ActiveJob>();
+const succeededJobs = new Set<string>();
 
 /**
  * Per-queue: list of {id, runAt, dispatchedAt} for jobs seen but not yet started.
  * Used to check priority ordering.
- * @type {Map<string, {id: string, runAt: number, dispatchedAt: number}[]>}
  */
-const waitingByQueue = new Map();
+const waitingByQueue = new Map<string, WaitingJob[]>();
 
-/** @type {Map<string, number>} last start event timestamp per queue */
-const lastStartPerQueue = new Map();
+/** last start event timestamp per queue */
+const lastStartPerQueue = new Map<string, number>();
 
 let violationCount = 0;
 let eventCount = 0;
 
-function violation(invariant, msg, data = {}) {
+function violation(invariant: string, msg: string, data: Record<string, unknown> = {}): void {
     violationCount++;
     log('error', `[${invariant}] ${msg}`, data);
 }
 
 // ── Invariant checks ───────────────────────────────────────────────────────────
 
+interface IpcDequeueMsg {
+    queue: string;
+    jobId: string;
+    runAt: number;
+}
+
 /**
  * Called when a child process dequeues a job (via IPC).
- * @param {number} pid
- * @param {{queue: string, jobId: string, runAt: number}} msg
  */
-function onIpcDequeue(pid, msg) {
+function onIpcJobStart(pid: number, msg: IpcDequeueMsg): void {
     const { jobId: id, queue, runAt } = msg;
 
     // Mutual exclusion: job must not already be active
@@ -92,13 +108,12 @@ function onIpcDequeue(pid, msg) {
 
 /**
  * Called when a child process finishes/retries/fails a job (via IPC).
- * @param {string} jobId
  */
-function onIpcJobDone(jobId) {
+function onIpcJobDone(jobId: string): void {
     activeJobs.delete(jobId);
 }
 
-function onStart(event) {
+function onStart(event: Record<string, string>): void {
     const { id, queue, runAt: runAtStr, startedAt: startedAtStr } = event;
     const runAt = Number(runAtStr);
     const startedAt = Number(startedAtStr);
@@ -148,12 +163,12 @@ function onStart(event) {
     if (waitingByQueue.has(queue)) {
         waitingByQueue.set(
             queue,
-            waitingByQueue.get(queue).filter((w) => w.id !== id)
+            (waitingByQueue.get(queue) ?? []).filter((w) => w.id !== id)
         );
     }
 }
 
-function onFinish(event) {
+function onFinish(event: Record<string, string>): void {
     succeededJobs.add(event.id);
 }
 
@@ -161,9 +176,8 @@ function onFinish(event) {
  * Called when a child process exits. Clears all active jobs belonging to that
  * PID so they don't trigger spurious MutualExclusion violations when the
  * queasy sweep retries them and a new process picks them up.
- * @param {number} pid
  */
-function onProcessExit(pid) {
+function onProcessExit(pid: number): void {
     for (const [id, entry] of activeJobs) {
         if (entry.pid === pid) {
             activeJobs.delete(id);
@@ -174,7 +188,7 @@ function onProcessExit(pid) {
 /**
  * Called periodically to check queue progress and priority starvation.
  */
-function checkProgress() {
+function checkProgress(): void {
     const now = Date.now();
     for (const [queue, lastStart] of lastStartPerQueue) {
         const idle = now - lastStart;
@@ -209,7 +223,7 @@ function checkProgress() {
 
 // ── Event dispatch ─────────────────────────────────────────────────────────────
 
-function handleEvent(event) {
+function handleEvent(event: Record<string, string>): void {
     eventCount++;
     const { type } = event;
     log('info', 'event', event);
@@ -231,7 +245,7 @@ function handleEvent(event) {
 
 // ── Summary ────────────────────────────────────────────────────────────────────
 
-function printSummary() {
+function printSummary(): void {
     const summary = {
         events: eventCount,
         violations: violationCount,
@@ -240,26 +254,19 @@ function printSummary() {
         lastStartPerQueue: Object.fromEntries(lastStartPerQueue),
     };
     log('info', 'Summary', summary);
-    console.log(`\n=== Fuzz Summary ===`);
-    console.log(`  Events processed : ${eventCount}`);
-    console.log(`  Violations found : ${violationCount}`);
-    console.log(`  Active jobs      : ${activeJobs.size}`);
-    console.log(`  Succeeded jobs   : ${succeededJobs.size}`);
-    console.log('===================\n');
 }
 
 // ── Child process management ───────────────────────────────────────────────────
 
-/** @type {Set<import('node:child_process').ChildProcess>} */
-const processes = new Set();
+const processes = new Set<ChildProcess>();
 
-function spawnProcess() {
-    const child = fork(join(__dirname, 'process.js'));
+function spawnProcess(): ChildProcess {
+    const child = fork(join(__dirname, 'process.ts'));
     processes.add(child);
 
-    child.on('message', (msg) => {
+    child.on('message', (msg: { type: string; queue: string; jobId: string; runAt: number }) => {
         if (msg.type === 'dequeue') {
-            onIpcDequeue(child.pid, msg);
+            onIpcJobStart(child.pid!, msg);
         } else if (msg.type === 'finish' || msg.type === 'retry' || msg.type === 'fail') {
             onIpcJobDone(msg.jobId);
         }
@@ -268,7 +275,7 @@ function spawnProcess() {
     child.on('exit', (code, signal) => {
         processes.delete(child);
         log('info', 'Child process exited', { pid: child.pid, code, signal });
-        onProcessExit(child.pid);
+        onProcessExit(child.pid!);
         setTimeout(spawnProcess, PROCESS_RESTART_DELAY_MS);
     });
 
@@ -279,7 +286,7 @@ function spawnProcess() {
     return child;
 }
 
-function killRandomProcess() {
+function killRandomProcess(): void {
     const list = [...processes];
     if (list.length === 0) return;
     const target = list[Math.floor(Math.random() * list.length)];
@@ -289,18 +296,15 @@ function killRandomProcess() {
 
 // ── Redis setup ────────────────────────────────────────────────────────────────
 
-const redis = createClient();
-const dispatchRedis = createClient();
-
+const redis = createClient() as RedisClientType;
 await redis.connect();
-await dispatchRedis.connect();
 
 // Clean up state from previous runs
 await redis.del(STREAM_KEY);
 log('info', 'Cleared fuzz:events stream from previous run');
 
 // Dispatch seed periodic jobs (await ready to avoid Function not found race)
-const dispatchClient = await new Promise((resolve) => new Client(dispatchRedis, 0, resolve));
+const dispatchClient = await new Promise<Client>((resolve) => new Client({}, 0, resolve));
 const periodicQueue = dispatchClient.queue('{fuzz}:periodic', true);
 
 for (let i = 0; i < NUM_PERIODIC_JOBS; i++) {
@@ -311,9 +315,7 @@ for (let i = 0; i < NUM_PERIODIC_JOBS; i++) {
 
 // ── Spawn child processes ──────────────────────────────────────────────────────
 
-for (let i = 0; i < NUM_PROCESSES; i++) {
-    spawnProcess();
-}
+for (let i = 0; i < NUM_PROCESSES; i++) spawnProcess();
 
 // Periodically kill a random process to simulate crashes
 const crashTimer = setInterval(killRandomProcess, CRASH_INTERVAL_MS);

package/fuzztest/handlers/{cascade-a.js → cascade-a.ts}

@@ -5,27 +5,23 @@
 
 import { BroadcastChannel } from 'node:worker_threads';
 import { createClient } from 'redis';
-import { Client, PermanentError } from '../../src/index.js';
-import { pickChaos } from '../shared/chaos.js';
-import { emitEvent } from '../shared/stream.js';
+import type { RedisClientType } from 'redis';
+import { Client, PermanentError } from '../../src/index.ts';
+import type { Job } from '../../src/types.ts';
+import { pickChaos } from '../shared/chaos.ts';
+import { emitEvent } from '../shared/stream.ts';
 
-const redis = createClient();
-const eventRedis = createClient();
-
-await redis.connect();
+const eventRedis = createClient() as RedisClientType;
 await eventRedis.connect();
 
 // Dispatch-only queasy client (await ready to avoid Function not found race)
-const client = await new Promise((resolve) => new Client(redis, 0, resolve));
+const client = await new Promise<Client>((resolve) => new Client({}, 0, resolve));
 const cascadeBQueue = client.queue('{fuzz}:cascade-b', true);
 
 const crashChannel = new BroadcastChannel('fuzz-crash');
 
-/**
- * @param {any} data
- * @param {import('../../src/types.js').Job} job
- */
-export async function handle(_data, job) {
+// biome-ignore lint/suspicious/noExplicitAny: Job data is arbitrary
+export async function handle(_data: any, job: Job): Promise<void> {
     const startedAt = Date.now();
     await emitEvent(eventRedis, {
         type: 'start',
@@ -71,7 +67,7 @@ export async function handle(_data, job) {
     // Normal completion: dispatch 1-2 cascade-b jobs
     const count = Math.random() < 0.5 ? 1 : 2;
     const runAtOffset = Math.random() * 2000;
-    const dispatchPromises = [];
+    const dispatchPromises: Promise<string>[] = [];
     for (let i = 0; i < count; i++) {
         dispatchPromises.push(
             cascadeBQueue.dispatch(
@@ -88,7 +84,7 @@ export async function handle(_data, job) {
         type: 'finish',
         queue: '{fuzz}:cascade-a',
         id: job.id,
-        finishedAt: String(Date.now()),
+        finishedAt: process.uptime().toFixed(2),
         dispatched: ids.join(','),
     });
 }

package/fuzztest/handlers/{cascade-b.js → cascade-b.ts}

@@ -5,20 +5,19 @@
 
 import { BroadcastChannel } from 'node:worker_threads';
 import { createClient } from 'redis';
-import { PermanentError } from '../../src/index.js';
-import { pickChaos } from '../shared/chaos.js';
-import { emitEvent } from '../shared/stream.js';
+import type { RedisClientType } from 'redis';
+import { PermanentError } from '../../src/index.ts';
+import type { Job } from '../../src/types.ts';
+import { pickChaos } from '../shared/chaos.ts';
+import { emitEvent } from '../shared/stream.ts';
 
-const eventRedis = createClient();
+const eventRedis = createClient() as RedisClientType;
 await eventRedis.connect();
 
 const crashChannel = new BroadcastChannel('fuzz-crash');
 
-/**
- * @param {any} data
- * @param {import('../../src/types.js').Job} job
- */
-export async function handle(_data, job) {
+// biome-ignore lint/suspicious/noExplicitAny: Job data is arbitrary
+export async function handle(_data: any, job: Job): Promise<void> {
     const startedAt = Date.now();
     await emitEvent(eventRedis, {
         type: 'start',

package/fuzztest/handlers/{fail-handler.js → fail-handler.ts}

@@ -9,26 +9,21 @@
  */
 
 import { createClient } from 'redis';
-import { Client } from '../../src/index.js';
-import { emitEvent } from '../shared/stream.js';
+import type { RedisClientType } from 'redis';
+import { Client } from '../../src/index.ts';
+import type { Job } from '../../src/types.ts';
+import { emitEvent } from '../shared/stream.ts';
 
-const redis = createClient();
-const eventRedis = createClient();
-
-await redis.connect();
+const eventRedis = createClient() as RedisClientType;
 await eventRedis.connect();
 
 // Dispatch-only queasy client (await ready to avoid Function not found race)
-const client = await new Promise((resolve) => new Client(redis, 0, resolve));
+const client = await new Promise<Client>((resolve) => new Client({}, 0, resolve));
 
 // Queue references (keys already include braces)
 const periodicQueue = client.queue('{fuzz}:periodic', true);
 
-/**
- * @param {[string, any, {message: string}]} data
- * @param {import('../../src/types.js').Job} job
- */
-export async function handle(data, job) {
+export async function handle(data: [string, unknown, { message: string }], job: Job): Promise<void> {
     const [originalId, originalData, error] = data;
 
     await emitEvent(eventRedis, {

package/fuzztest/handlers/{periodic.js → periodic.ts}

@@ -6,28 +6,24 @@
 
 import { BroadcastChannel } from 'node:worker_threads';
 import { createClient } from 'redis';
-import { Client, PermanentError } from '../../src/index.js';
-import { pickChaos } from '../shared/chaos.js';
-import { emitEvent } from '../shared/stream.js';
+import type { RedisClientType } from 'redis';
+import { Client, PermanentError } from '../../src/index.ts';
+import type { Job } from '../../src/types.ts';
+import { pickChaos } from '../shared/chaos.ts';
+import { emitEvent } from '../shared/stream.ts';
 
-const redis = createClient();
-const eventRedis = createClient();
-
-await redis.connect();
+const eventRedis = createClient() as RedisClientType;
 await eventRedis.connect();
 
 // Dispatch-only queasy client (await ready to avoid Function not found race)
-const client = await new Promise((resolve) => new Client(redis, 0, resolve));
+const client = await new Promise<Client>((resolve) => new Client({}, 0, resolve));
 const periodicQueue = client.queue('{fuzz}:periodic', true);
 const cascadeAQueue = client.queue('{fuzz}:cascade-a', true);
 
 const crashChannel = new BroadcastChannel('fuzz-crash');
 
-/**
- * @param {any} data
- * @param {import('../../src/types.js').Job} job
- */
-export async function handle(data, job) {
+// biome-ignore lint/suspicious/noExplicitAny: Job data is arbitrary
+export async function handle(data: any, job: Job): Promise<void> {
     const startedAt = Date.now();
     await emitEvent(eventRedis, {
         type: 'start',
@@ -71,8 +67,8 @@ export async function handle(data, job) {
     }
 
     // Normal completion: dispatch a cascade-a job and re-queue self
-    const cascadeRunAt = Date.now() + Math.random() * 2000;
-    const selfDelay = 1000 + Math.random() * 4000;
+    const cascadeRunAt = 0;
+    const selfDelay = 500;
 
     const [cascadeId] = await Promise.all([
         cascadeAQueue.dispatch({ from: job.id }, { runAt: cascadeRunAt }),