@shelchin/threadx 0.1.0

package/dist/index.js

@@ -0,0 +1,382 @@
+// src/errors.ts
+class WorkerError extends Error {
+  workerStack;
+  constructor(serialized, callSite) {
+    super(serialized.message);
+    this.name = serialized.name || "WorkerError";
+    this.workerStack = serialized.stack;
+    if (callSite?.stack) {
+      this.stack = `${this.name}: ${this.message}
+` + `    at Worker
+` + callSite.stack.split(`
+`).slice(1).join(`
+`);
+    }
+  }
+}
+
+class TimeoutError extends Error {
+  constructor(method, timeout) {
+    super(`Call to '${method}' timed out after ${timeout}ms`);
+    this.name = "TimeoutError";
+  }
+}
+
+class InitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InitError";
+  }
+}
+
+class UnsupportedRuntimeError extends Error {
+  constructor(runtime) {
+    super(`ThreadX is not supported on ${runtime}. Supported runtimes: Browser, Bun, Deno`);
+    this.name = "UnsupportedRuntimeError";
+  }
+}
+
+// src/transfer.ts
+var TRANSFER = Symbol("threadx.transfer");
+function t(value, transferables) {
+  return {
+    [TRANSFER]: true,
+    value,
+    transferables: transferables ?? [value]
+  };
+}
+function isTransferDescriptor(value) {
+  return typeof value === "object" && value !== null && TRANSFER in value;
+}
+function prepareArgs(args) {
+  const transfer = [];
+  const processedArgs = args.map((arg) => {
+    if (isTransferDescriptor(arg)) {
+      transfer.push(...arg.transferables);
+      return arg.value;
+    }
+    return arg;
+  });
+  return { args: processedArgs, transfer };
+}
+
+// src/wrap.ts
+var DEFAULT_TIMEOUT = 30000;
+var proxyInternals = new WeakMap;
+function createAsyncIterable(worker, id, pending, timeout, method) {
+  const buffer = [];
+  let waitingResolve = null;
+  let waitingReject = null;
+  let isDone = false;
+  let error = null;
+  const callSite = new Error;
+  let timeoutId;
+  if (timeout > 0) {
+    timeoutId = setTimeout(() => {
+      const timeoutError = new TimeoutError(method, timeout);
+      error = timeoutError;
+      if (waitingReject) {
+        waitingReject(timeoutError);
+        waitingResolve = null;
+        waitingReject = null;
+      }
+      pending.delete(id);
+      worker.postMessage({ $type: "CANCEL", $id: id });
+    }, timeout);
+  }
+  pending.set(id, {
+    push: (value) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+          const timeoutError = new TimeoutError(method, timeout);
+          error = timeoutError;
+          if (waitingReject) {
+            waitingReject(timeoutError);
+            waitingResolve = null;
+            waitingReject = null;
+          }
+          pending.delete(id);
+          worker.postMessage({ $type: "CANCEL", $id: id });
+        }, timeout);
+      }
+      if (waitingResolve) {
+        waitingResolve({ value, done: false });
+        waitingResolve = null;
+        waitingReject = null;
+      } else {
+        buffer.push(value);
+      }
+    },
+    done: () => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      isDone = true;
+      if (waitingResolve) {
+        waitingResolve({ value: undefined, done: true });
+        waitingResolve = null;
+        waitingReject = null;
+      }
+    },
+    error: (err) => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      error = err;
+      if (waitingReject) {
+        waitingReject(err);
+        waitingResolve = null;
+        waitingReject = null;
+      }
+    },
+    method,
+    callSite
+  });
+  return {
+    [Symbol.asyncIterator]() {
+      return {
+        async next() {
+          if (buffer.length > 0) {
+            return { value: buffer.shift(), done: false };
+          }
+          if (error) {
+            throw error;
+          }
+          if (isDone) {
+            return { value: undefined, done: true };
+          }
+          return new Promise((resolve, reject) => {
+            waitingResolve = resolve;
+            waitingReject = reject;
+          });
+        },
+        async return() {
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          pending.delete(id);
+          worker.postMessage({ $type: "CANCEL", $id: id });
+          return { value: undefined, done: true };
+        }
+      };
+    }
+  };
+}
+function wrap(worker, options) {
+  const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+  let state = "init";
+  let id = 0;
+  const pendingCalls = new Map;
+  const pendingStreams = new Map;
+  const queue = [];
+  let methods = new Set;
+  function flushQueue() {
+    for (const { message, transfer } of queue) {
+      worker.postMessage(message, transfer);
+    }
+    queue.length = 0;
+  }
+  function deserializeError(serialized, callSite) {
+    return new WorkerError(serialized, callSite);
+  }
+  worker.onmessage = (event) => {
+    const msg = event.data;
+    if (msg.$type === "READY") {
+      state = "ready";
+      methods = new Set(msg.methods);
+      flushQueue();
+      return;
+    }
+    if (msg.$type === "RESOLVE") {
+      const call = pendingCalls.get(msg.$id);
+      if (call) {
+        if (call.timeoutId)
+          clearTimeout(call.timeoutId);
+        call.resolve(msg.value);
+        pendingCalls.delete(msg.$id);
+      }
+      return;
+    }
+    if (msg.$type === "REJECT") {
+      const call = pendingCalls.get(msg.$id);
+      if (call) {
+        if (call.timeoutId)
+          clearTimeout(call.timeoutId);
+        call.reject(deserializeError(msg.error, call.callSite));
+        pendingCalls.delete(msg.$id);
+        return;
+      }
+      const stream = pendingStreams.get(msg.$id);
+      if (stream) {
+        stream.error(deserializeError(msg.error, stream.callSite));
+        pendingStreams.delete(msg.$id);
+      }
+      return;
+    }
+    if (msg.$type === "YIELD") {
+      const stream = pendingStreams.get(msg.$id);
+      if (stream) {
+        stream.push(msg.value);
+      }
+      return;
+    }
+    if (msg.$type === "DONE") {
+      const stream = pendingStreams.get(msg.$id);
+      if (stream) {
+        stream.done();
+        pendingStreams.delete(msg.$id);
+      }
+      return;
+    }
+  };
+  function rejectAllPending(error) {
+    for (const call of pendingCalls.values()) {
+      if (call.timeoutId)
+        clearTimeout(call.timeoutId);
+      call.reject(error);
+    }
+    pendingCalls.clear();
+    for (const stream of pendingStreams.values()) {
+      if (stream.timeoutId)
+        clearTimeout(stream.timeoutId);
+      stream.error(error);
+    }
+    pendingStreams.clear();
+    queue.length = 0;
+  }
+  worker.onerror = (event) => {
+    const error = new InitError(event.message || "Worker error");
+    rejectAllPending(error);
+    state = "dead";
+  };
+  const proxy = new Proxy({}, {
+    get(_, prop) {
+      if (prop === "$state")
+        return state;
+      if (prop === "$pending")
+        return pendingCalls.size + pendingStreams.size;
+      if (prop === "$worker")
+        return worker;
+      if (typeof prop === "symbol")
+        return;
+      return (...args) => {
+        const currentId = ++id;
+        const { args: processedArgs, transfer } = prepareArgs(args);
+        const message = {
+          $type: "CALL",
+          $id: currentId,
+          method: prop,
+          args: processedArgs
+        };
+        const callSite = new Error;
+        let isStreaming = false;
+        let streamIterable = null;
+        let internalPromise = null;
+        let promiseResolve = null;
+        let promiseReject = null;
+        function getInternalPromise() {
+          if (!internalPromise) {
+            internalPromise = new Promise((resolve, reject) => {
+              promiseResolve = resolve;
+              promiseReject = reject;
+            });
+          }
+          return internalPromise;
+        }
+        let timeoutId;
+        if (timeout > 0) {
+          timeoutId = setTimeout(() => {
+            if (!isStreaming) {
+              const timeoutError = new TimeoutError(prop, timeout);
+              getInternalPromise();
+              if (promiseReject) {
+                promiseReject(timeoutError);
+              }
+              pendingCalls.delete(currentId);
+            }
+          }, timeout);
+        }
+        pendingCalls.set(currentId, {
+          resolve: (value) => {
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            getInternalPromise();
+            if (promiseResolve) {
+              promiseResolve(value);
+            }
+          },
+          reject: (error) => {
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            getInternalPromise();
+            if (promiseReject) {
+              promiseReject(error);
+            }
+          },
+          method: prop,
+          callSite,
+          timeoutId
+        });
+        if (state === "ready") {
+          worker.postMessage(message, transfer);
+        } else if (state === "init") {
+          queue.push({ message, transfer });
+        } else {
+          const error = new InitError("Worker is terminated");
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          pendingCalls.delete(currentId);
+          return Promise.reject(error);
+        }
+        const dualResult = {
+          then(onfulfilled, onrejected) {
+            return getInternalPromise().then(onfulfilled, onrejected);
+          },
+          catch(onrejected) {
+            return getInternalPromise().catch(onrejected);
+          },
+          finally(onfinally) {
+            return getInternalPromise().finally(onfinally);
+          },
+          [Symbol.asyncIterator]() {
+            if (!isStreaming) {
+              isStreaming = true;
+              const call = pendingCalls.get(currentId);
+              if (call?.timeoutId)
+                clearTimeout(call.timeoutId);
+              pendingCalls.delete(currentId);
+              streamIterable = createAsyncIterable(worker, currentId, pendingStreams, timeout, prop);
+            }
+            return streamIterable[Symbol.asyncIterator]();
+          }
+        };
+        return dualResult;
+      };
+    }
+  });
+  proxyInternals.set(proxy, {
+    setState: (newState) => {
+      state = newState;
+    },
+    rejectAll: rejectAllPending
+  });
+  return proxy;
+}
+function kill(proxy) {
+  const internals = proxyInternals.get(proxy);
+  if (internals) {
+    const error = new InitError("Worker is terminated");
+    internals.rejectAll(error);
+    internals.setState("dead");
+  }
+  proxy.$worker.terminate();
+}
+export {
+  wrap,
+  t,
+  kill,
+  WorkerError,
+  UnsupportedRuntimeError,
+  TimeoutError,
+  InitError
+};
+
+//# debugId=0606BCFD2676783C64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../src/errors.ts", "../src/transfer.ts", "../src/wrap.ts"],
+  "sourcesContent": [
+    "import type { SerializedError } from './protocol.js';\n\n/**\n * Error thrown when Worker execution fails\n */\nexport class WorkerError extends Error {\n  /** Stack trace from the Worker side */\n  workerStack?: string;\n\n  constructor(serialized: SerializedError, callSite?: Error) {\n    super(serialized.message);\n    this.name = serialized.name || 'WorkerError';\n    this.workerStack = serialized.stack;\n\n    // Combine stacks: Worker error + call site\n    if (callSite?.stack) {\n      this.stack = `${this.name}: ${this.message}\\n` +\n        `    at Worker\\n` +\n        callSite.stack.split('\\n').slice(1).join('\\n');\n    }\n  }\n}\n\n/**\n * Error thrown when a call times out\n */\nexport class TimeoutError extends Error {\n  constructor(method: string, timeout: number) {\n    super(`Call to '${method}' timed out after ${timeout}ms`);\n    this.name = 'TimeoutError';\n  }\n}\n\n/**\n * Error thrown when Worker initialization fails\n */\nexport class InitError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'InitError';\n  }\n}\n\n/**\n * Error thrown on unsupported runtime\n */\nexport class UnsupportedRuntimeError extends Error {\n  constructor(runtime: string) {\n    super(`ThreadX is not supported on ${runtime}. Supported runtimes: Browser, Bun, Deno`);\n    this.name = 'UnsupportedRuntimeError';\n  }\n}\n",
+    "/**\n * Transferable marking utility\n */\n\n/** Symbol to identify transfer descriptors */\nexport const TRANSFER = Symbol('threadx.transfer');\n\n/** Descriptor for transferable values */\nexport interface TransferDescriptor<T = unknown> {\n  [TRANSFER]: true;\n  value: T;\n  transferables: Transferable[];\n}\n\n/**\n * Mark a value as Transferable for zero-copy transfer to Worker\n *\n * @example\n * // Single transferable\n * const buffer = new ArrayBuffer(1024)\n * await worker.process(t(buffer))\n * // buffer.byteLength === 0 (transferred)\n *\n * @example\n * // Object with specified transferables\n * const data = { image: buffer, meta: info }\n * await worker.process(t(data, [buffer]))\n */\nexport function t<T extends Transferable>(value: T): TransferDescriptor<T>;\nexport function t<T>(value: T, transferables: Transferable[]): TransferDescriptor<T>;\nexport function t<T>(value: T, transferables?: Transferable[]): TransferDescriptor<T> {\n  return {\n    [TRANSFER]: true,\n    value,\n    transferables: transferables ?? [value as unknown as Transferable],\n  };\n}\n\n/**\n * Check if a value is a transfer descriptor\n */\nexport function isTransferDescriptor(value: unknown): value is TransferDescriptor {\n  return typeof value === 'object' && value !== null && TRANSFER in value;\n}\n\n/**\n * Process arguments to extract transferables\n */\nexport function prepareArgs(args: unknown[]): { args: unknown[]; transfer: Transferable[] } {\n  const transfer: Transferable[] = [];\n  const processedArgs = args.map((arg) => {\n    if (isTransferDescriptor(arg)) {\n      transfer.push(...arg.transferables);\n      return arg.value;\n    }\n    return arg;\n  });\n  return { args: processedArgs, transfer };\n}\n",
+    "/**\n * Main thread API for ThreadX\n */\n\nimport type { WorkerToMainMessage, CallMessage, CancelMessage, SerializedError } from './protocol.js';\nimport { WorkerError, TimeoutError, InitError } from './errors.js';\nimport { prepareArgs } from './transfer.js';\nimport type { WorkerState, WrapOptions, WrappedWorker } from './types.js';\n\n/** Default timeout in milliseconds */\nconst DEFAULT_TIMEOUT = 30000;\n\n/** Internal state for kill() to access */\ninterface InternalState {\n  setState: (state: WorkerState) => void;\n  rejectAll: (error: Error) => void;\n}\n\n/** WeakMap to store internal state for each proxy */\nconst proxyInternals = new WeakMap<object, InternalState>();\n\n/** Pending RPC call */\ninterface PendingCall {\n  resolve: (value: unknown) => void;\n  reject: (error: Error) => void;\n  method: string;\n  callSite: Error;\n  timeoutId?: ReturnType<typeof setTimeout>;\n}\n\n/** Pending streaming call */\ninterface PendingStream {\n  push: (value: unknown) => void;\n  done: () => void;\n  error: (error: Error) => void;\n  method: string;\n  callSite: Error;\n  timeoutId?: ReturnType<typeof setTimeout>;\n}\n\n/** Queued call before ready */\ninterface QueuedCall {\n  message: CallMessage;\n  transfer: Transferable[];\n}\n\n/**\n * Create an AsyncIterable for streaming results\n */\nfunction createAsyncIterable<T>(\n  worker: Worker,\n  id: number,\n  pending: Map<number, PendingStream>,\n  timeout: number,\n  method: string\n): AsyncIterable<T> {\n  // Buffer for values received before consumed\n  const buffer: T[] = [];\n  // Resolvers waiting for values\n  let waitingResolve: ((result: IteratorResult<T>) => void) | null = null;\n  let waitingReject: ((error: Error) => void) | null = null;\n  let isDone = false;\n  let error: Error | null = null;\n\n  // Capture call site for better stack traces\n  const callSite = new Error();\n\n  // Set up timeout\n  let timeoutId: ReturnType<typeof setTimeout> | undefined;\n  if (timeout > 0) {\n    timeoutId = setTimeout(() => {\n      const timeoutError = new TimeoutError(method, timeout);\n      error = timeoutError;\n      if (waitingReject) {\n        waitingReject(timeoutError);\n        waitingResolve = null;\n        waitingReject = null;\n      }\n      pending.delete(id);\n      // Send cancel to worker\n      worker.postMessage({ $type: 'CANCEL', $id: id } satisfies CancelMessage);\n    }, timeout);\n  }\n\n  // Register pending stream handler\n  pending.set(id, {\n    push: (value: unknown) => {\n      // Reset timeout on each yield\n      if (timeoutId) {\n        clearTimeout(timeoutId);\n        timeoutId = setTimeout(() => {\n          const timeoutError = new TimeoutError(method, timeout);\n          error = timeoutError;\n          if (waitingReject) {\n            waitingReject(timeoutError);\n            waitingResolve = null;\n            waitingReject = null;\n          }\n          pending.delete(id);\n          worker.postMessage({ $type: 'CANCEL', $id: id } satisfies CancelMessage);\n        }, timeout);\n      }\n\n      if (waitingResolve) {\n        waitingResolve({ value: value as T, done: false });\n        waitingResolve = null;\n        waitingReject = null;\n      } else {\n        buffer.push(value as T);\n      }\n    },\n    done: () => {\n      if (timeoutId) clearTimeout(timeoutId);\n      isDone = true;\n      if (waitingResolve) {\n        waitingResolve({ value: undefined as T, done: true });\n        waitingResolve = null;\n        waitingReject = null;\n      }\n    },\n    error: (err: Error) => {\n      if (timeoutId) clearTimeout(timeoutId);\n      error = err;\n      if (waitingReject) {\n        waitingReject(err);\n        waitingResolve = null;\n        waitingReject = null;\n      }\n    },\n    method,\n    callSite,\n  });\n\n  return {\n    [Symbol.asyncIterator]() {\n      return {\n        async next(): Promise<IteratorResult<T>> {\n          // Return buffered value if available\n          if (buffer.length > 0) {\n            return { value: buffer.shift()!, done: false };\n          }\n\n          // Return error if set\n          if (error) {\n            throw error;\n          }\n\n          // Return done if finished\n          if (isDone) {\n            return { value: undefined as T, done: true };\n          }\n\n          // Wait for next value\n          return new Promise((resolve, reject) => {\n            waitingResolve = resolve;\n            waitingReject = reject;\n          });\n        },\n\n        async return(): Promise<IteratorResult<T>> {\n          // Called when for-await is broken\n          if (timeoutId) clearTimeout(timeoutId);\n          pending.delete(id);\n          // Send cancel to worker\n          worker.postMessage({ $type: 'CANCEL', $id: id } satisfies CancelMessage);\n          return { value: undefined as T, done: true };\n        },\n      };\n    },\n  };\n}\n\n/**\n * Wrap a Worker for seamless RPC communication\n *\n * @example\n * import { wrap } from '@shelchin/threadx'\n * import type * as CalcMethods from './calc.worker'\n *\n * const calc = wrap<typeof CalcMethods>(new Worker('./calc.worker.js'))\n *\n * // Call like a regular async function\n * const result = await calc.add(1, 2)\n *\n * // Streaming with for-await\n * for await (const progress of calc.process(data)) {\n *   console.log(progress)\n * }\n */\nexport function wrap<T>(worker: Worker, options?: WrapOptions): WrappedWorker<T> {\n  const timeout = options?.timeout ?? DEFAULT_TIMEOUT;\n\n  // State\n  let state: WorkerState = 'init';\n  let id = 0;\n  const pendingCalls = new Map<number, PendingCall>();\n  const pendingStreams = new Map<number, PendingStream>();\n  const queue: QueuedCall[] = [];\n  let methods: Set<string> = new Set();\n\n  // Flush queued calls after ready\n  function flushQueue(): void {\n    for (const { message, transfer } of queue) {\n      worker.postMessage(message, transfer);\n    }\n    queue.length = 0;\n  }\n\n  // Deserialize error from worker\n  function deserializeError(serialized: SerializedError, callSite: Error): Error {\n    return new WorkerError(serialized, callSite);\n  }\n\n  // Handle messages from worker\n  worker.onmessage = (event: MessageEvent<WorkerToMainMessage>) => {\n    const msg = event.data;\n\n    // Handle ready message\n    if (msg.$type === 'READY') {\n      state = 'ready';\n      methods = new Set(msg.methods);\n      flushQueue();\n      return;\n    }\n\n    // Handle RPC responses\n    if (msg.$type === 'RESOLVE') {\n      const call = pendingCalls.get(msg.$id);\n      if (call) {\n        if (call.timeoutId) clearTimeout(call.timeoutId);\n        call.resolve(msg.value);\n        pendingCalls.delete(msg.$id);\n      }\n      return;\n    }\n\n    if (msg.$type === 'REJECT') {\n      const call = pendingCalls.get(msg.$id);\n      if (call) {\n        if (call.timeoutId) clearTimeout(call.timeoutId);\n        call.reject(deserializeError(msg.error, call.callSite));\n        pendingCalls.delete(msg.$id);\n        return;\n      }\n\n      // Also check streaming calls\n      const stream = pendingStreams.get(msg.$id);\n      if (stream) {\n        stream.error(deserializeError(msg.error, stream.callSite));\n        pendingStreams.delete(msg.$id);\n      }\n      return;\n    }\n\n    // Handle streaming responses\n    if (msg.$type === 'YIELD') {\n      const stream = pendingStreams.get(msg.$id);\n      if (stream) {\n        stream.push(msg.value);\n      }\n      return;\n    }\n\n    if (msg.$type === 'DONE') {\n      const stream = pendingStreams.get(msg.$id);\n      if (stream) {\n        stream.done();\n        pendingStreams.delete(msg.$id);\n      }\n      return;\n    }\n  };\n\n  // Function to reject all pending calls (including queued)\n  function rejectAllPending(error: Error): void {\n    // Reject pending RPC calls\n    for (const call of pendingCalls.values()) {\n      if (call.timeoutId) clearTimeout(call.timeoutId);\n      call.reject(error);\n    }\n    pendingCalls.clear();\n\n    // Reject pending streams (with timeout cleanup)\n    for (const stream of pendingStreams.values()) {\n      if (stream.timeoutId) clearTimeout(stream.timeoutId);\n      stream.error(error);\n    }\n    pendingStreams.clear();\n\n    // Clear queued calls - they'll never be sent\n    queue.length = 0;\n  }\n\n  // Handle worker errors\n  worker.onerror = (event) => {\n    const error = new InitError(event.message || 'Worker error');\n    rejectAllPending(error);\n    state = 'dead';\n  };\n\n  // Create proxy\n  const proxy = new Proxy({} as WrappedWorker<T>, {\n    get(_, prop: string | symbol) {\n      // State hooks\n      if (prop === '$state') return state;\n      if (prop === '$pending') return pendingCalls.size + pendingStreams.size;\n      if (prop === '$worker') return worker;\n\n      // Symbol properties\n      if (typeof prop === 'symbol') return undefined;\n\n      // Method call\n      return (...args: unknown[]) => {\n        const currentId = ++id;\n        const { args: processedArgs, transfer } = prepareArgs(args);\n\n        const message: CallMessage = {\n          $type: 'CALL',\n          $id: currentId,\n          method: prop,\n          args: processedArgs,\n        };\n\n        // Check if we know it's a streaming method (we don't at compile time)\n        // So we need a heuristic or always return a promise that can be iterated\n        // For simplicity, we'll use a convention: methods starting with $ or\n        // containing 'stream', 'progress', 'iterate' are streaming\n        // Actually, let's just return a special object that can be both awaited and iterated\n\n        // Better approach: Return a \"dual\" object that works as both Promise and AsyncIterable\n        // The user's code pattern determines which is used\n\n        // Simpler approach for now: all methods return Promise\n        // Streaming methods must be called with forAwait pattern explicitly\n        // We detect streaming by checking if YIELD messages come back\n\n        // Actually, the cleanest approach: return an object that:\n        // - Has .then() for promise behavior\n        // - Has [Symbol.asyncIterator]() for streaming behavior\n        // The first YIELD or RESOLVE determines which path\n\n        const callSite = new Error();\n\n        // Create a dual-mode response object\n        let isStreaming = false;\n        let streamIterable: AsyncIterable<unknown> | null = null;\n\n        // Create internal promise once (to support multiple .then() calls)\n        let internalPromise: Promise<unknown> | null = null;\n        let promiseResolve: ((value: unknown) => void) | null = null;\n        let promiseReject: ((error: Error) => void) | null = null;\n\n        // Lazily create the internal promise\n        function getInternalPromise(): Promise<unknown> {\n          if (!internalPromise) {\n            internalPromise = new Promise<unknown>((resolve, reject) => {\n              promiseResolve = resolve;\n              promiseReject = reject;\n            });\n          }\n          return internalPromise;\n        }\n\n        // Set up timeout for RPC mode\n        let timeoutId: ReturnType<typeof setTimeout> | undefined;\n        if (timeout > 0) {\n          timeoutId = setTimeout(() => {\n            if (!isStreaming) {\n              const timeoutError = new TimeoutError(prop, timeout);\n              // Ensure promise exists before rejecting\n              getInternalPromise();\n              if (promiseReject) {\n                promiseReject(timeoutError);\n              }\n              pendingCalls.delete(currentId);\n            }\n          }, timeout);\n        }\n\n        // Register pending call\n        pendingCalls.set(currentId, {\n          resolve: (value) => {\n            if (timeoutId) clearTimeout(timeoutId);\n            // Ensure promise exists before resolving\n            getInternalPromise();\n            if (promiseResolve) {\n              promiseResolve(value);\n            }\n          },\n          reject: (error) => {\n            if (timeoutId) clearTimeout(timeoutId);\n            // Ensure promise exists before rejecting\n            getInternalPromise();\n            if (promiseReject) {\n              promiseReject(error);\n            }\n          },\n          method: prop,\n          callSite,\n          timeoutId,\n        });\n\n        // Send or queue the message\n        if (state === 'ready') {\n          worker.postMessage(message, transfer);\n        } else if (state === 'init') {\n          queue.push({ message, transfer });\n        } else {\n          // Worker is dead\n          const error = new InitError('Worker is terminated');\n          if (timeoutId) clearTimeout(timeoutId);\n          pendingCalls.delete(currentId);\n          return Promise.reject(error);\n        }\n\n        // Return dual-mode object\n        const dualResult = {\n          // Promise interface - use shared internal promise\n          then<TResult1 = unknown, TResult2 = never>(\n            onfulfilled?: ((value: unknown) => TResult1 | PromiseLike<TResult1>) | null,\n            onrejected?: ((reason: Error) => TResult2 | PromiseLike<TResult2>) | null\n          ): Promise<TResult1 | TResult2> {\n            return getInternalPromise().then(onfulfilled, onrejected) as Promise<TResult1 | TResult2>;\n          },\n\n          catch<TResult = never>(\n            onrejected?: ((reason: Error) => TResult | PromiseLike<TResult>) | null\n          ): Promise<unknown | TResult> {\n            return getInternalPromise().catch(onrejected);\n          },\n\n          finally(onfinally?: (() => void) | null): Promise<unknown> {\n            return getInternalPromise().finally(onfinally);\n          },\n\n          // AsyncIterable interface\n          [Symbol.asyncIterator](): AsyncIterator<unknown> {\n            // Switch to streaming mode\n            if (!isStreaming) {\n              isStreaming = true;\n\n              // Remove from pendingCalls, add to pendingStreams\n              const call = pendingCalls.get(currentId);\n              if (call?.timeoutId) clearTimeout(call.timeoutId);\n              pendingCalls.delete(currentId);\n\n              // Create streaming iterable\n              streamIterable = createAsyncIterable(\n                worker,\n                currentId,\n                pendingStreams,\n                timeout,\n                prop\n              );\n            }\n\n            return streamIterable![Symbol.asyncIterator]();\n          },\n        };\n\n        return dualResult;\n      };\n    },\n  });\n\n  // Register internal state for kill()\n  proxyInternals.set(proxy, {\n    setState: (newState: WorkerState) => {\n      state = newState;\n    },\n    rejectAll: rejectAllPending,\n  });\n\n  return proxy;\n}\n\n/**\n * Terminate a wrapped worker\n */\nexport function kill<T>(proxy: WrappedWorker<T>): void {\n  const internals = proxyInternals.get(proxy);\n  if (internals) {\n    const error = new InitError('Worker is terminated');\n    internals.rejectAll(error);\n    internals.setState('dead');\n  }\n  proxy.$worker.terminate();\n}\n"
+  ],
+  "mappings": ";AAKO,MAAM,oBAAoB,MAAM;AAAA,EAErC;AAAA,EAEA,WAAW,CAAC,YAA6B,UAAkB;AAAA,IACzD,MAAM,WAAW,OAAO;AAAA,IACxB,KAAK,OAAO,WAAW,QAAQ;AAAA,IAC/B,KAAK,cAAc,WAAW;AAAA,IAG9B,IAAI,UAAU,OAAO;AAAA,MACnB,KAAK,QAAQ,GAAG,KAAK,SAAS,KAAK;AAAA,IACjC;AAAA,IACA,SAAS,MAAM,MAAM;AAAA,CAAI,EAAE,MAAM,CAAC,EAAE,KAAK;AAAA,CAAI;AAAA,IACjD;AAAA;AAEJ;AAAA;AAKO,MAAM,qBAAqB,MAAM;AAAA,EACtC,WAAW,CAAC,QAAgB,SAAiB;AAAA,IAC3C,MAAM,YAAY,2BAA2B,WAAW;AAAA,IACxD,KAAK,OAAO;AAAA;AAEhB;AAAA;AAKO,MAAM,kBAAkB,MAAM;AAAA,EACnC,WAAW,CAAC,SAAiB;AAAA,IAC3B,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA;AAEhB;AAAA;AAKO,MAAM,gCAAgC,MAAM;AAAA,EACjD,WAAW,CAAC,SAAiB;AAAA,IAC3B,MAAM,+BAA+B,iDAAiD;AAAA,IACtF,KAAK,OAAO;AAAA;AAEhB;;;AC9CO,IAAM,WAAW,OAAO,kBAAkB;AAyB1C,SAAS,CAAI,CAAC,OAAU,eAAuD;AAAA,EACpF,OAAO;AAAA,KACJ,WAAW;AAAA,IACZ;AAAA,IACA,eAAe,iBAAiB,CAAC,KAAgC;AAAA,EACnE;AAAA;AAMK,SAAS,oBAAoB,CAAC,OAA6C;AAAA,EAChF,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,YAAY;AAAA;AAM7D,SAAS,WAAW,CAAC,MAAgE;AAAA,EAC1F,MAAM,WAA2B,CAAC;AAAA,EAClC,MAAM,gBAAgB,KAAK,IAAI,CAAC,QAAQ;AAAA,IACtC,IAAI,qBAAqB,GAAG,GAAG;AAAA,MAC7B,SAAS,KAAK,GAAG,IAAI,aAAa;AAAA,MAClC,OAAO,IAAI;AAAA,IACb;AAAA,IACA,OAAO;AAAA,GACR;AAAA,EACD,OAAO,EAAE,MAAM,eAAe,SAAS;AAAA;;;AC/CzC,IAAM,kBAAkB;AASxB,IAAM,iBAAiB,IAAI;AA8B3B,SAAS,mBAAsB,CAC7B,QACA,IACA,SACA,SACA,QACkB;AAAA,EAElB,MAAM,SAAc,CAAC;AAAA,EAErB,IAAI,iBAA+D;AAAA,EACnE,IAAI,gBAAiD;AAAA,EACrD,IAAI,SAAS;AAAA,EACb,IAAI,QAAsB;AAAA,EAG1B,MAAM,WAAW,IAAI;AAAA,EAGrB,IAAI;AAAA,EACJ,IAAI,UAAU,GAAG;AAAA,IACf,YAAY,WAAW,MAAM;AAAA,MAC3B,MAAM,eAAe,IAAI,aAAa,QAAQ,OAAO;AAAA,MACrD,QAAQ;AAAA,MACR,IAAI,eAAe;AAAA,QACjB,cAAc,YAAY;AAAA,QAC1B,iBAAiB;AAAA,QACjB,gBAAgB;AAAA,MAClB;AAAA,MACA,QAAQ,OAAO,EAAE;AAAA,MAEjB,OAAO,YAAY,EAAE,OAAO,UAAU,KAAK,GAAG,CAAyB;AAAA,OACtE,OAAO;AAAA,EACZ;AAAA,EAGA,QAAQ,IAAI,IAAI;AAAA,IACd,MAAM,CAAC,UAAmB;AAAA,MAExB,IAAI,WAAW;AAAA,QACb,aAAa,SAAS;AAAA,QACtB,YAAY,WAAW,MAAM;AAAA,UAC3B,MAAM,eAAe,IAAI,aAAa,QAAQ,OAAO;AAAA,UACrD,QAAQ;AAAA,UACR,IAAI,eAAe;AAAA,YACjB,cAAc,YAAY;AAAA,YAC1B,iBAAiB;AAAA,YACjB,gBAAgB;AAAA,UAClB;AAAA,UACA,QAAQ,OAAO,EAAE;AAAA,UACjB,OAAO,YAAY,EAAE,OAAO,UAAU,KAAK,GAAG,CAAyB;AAAA,WACtE,OAAO;AAAA,MACZ;AAAA,MAEA,IAAI,gBAAgB;AAAA,QAClB,eAAe,EAAE,OAAmB,MAAM,MAAM,CAAC;AAAA,QACjD,iBAAiB;AAAA,QACjB,gBAAgB;AAAA,MAClB,EAAO;AAAA,QACL,OAAO,KAAK,KAAU;AAAA;AAAA;AAAA,IAG1B,MAAM,MAAM;AAAA,MACV,IAAI;AAAA,QAAW,aAAa,SAAS;AAAA,MACrC,SAAS;AAAA,MACT,IAAI,gBAAgB;AAAA,QAClB,eAAe,EAAE,OAAO,WAAgB,MAAM,KAAK,CAAC;AAAA,QACpD,iBAAiB;AAAA,QACjB,gBAAgB;AAAA,MAClB;AAAA;AAAA,IAEF,OAAO,CAAC,QAAe;AAAA,MACrB,IAAI;AAAA,QAAW,aAAa,SAAS;AAAA,MACrC,QAAQ;AAAA,MACR,IAAI,eAAe;AAAA,QACjB,cAAc,GAAG;AAAA,QACjB,iBAAiB;AAAA,QACjB,gBAAgB;AAAA,MAClB;AAAA;AAAA,IAEF;AAAA,IACA;AAAA,EACF,CAAC;AAAA,EAED,OAAO;AAAA,KACJ,OAAO,cAAc,GAAG;AAAA,MACvB,OAAO;AAAA,aACC,KAAI,GAA+B;AAAA,UAEvC,IAAI,OAAO,SAAS,GAAG;AAAA,YACrB,OAAO,EAAE,OAAO,OAAO,MAAM,GAAI,MAAM,MAAM;AAAA,UAC/C;AAAA,UAGA,IAAI,OAAO;AAAA,YACT,MAAM;AAAA,UACR;AAAA,UAGA,IAAI,QAAQ;AAAA,YACV,OAAO,EAAE,OAAO,WAAgB,MAAM,KAAK;AAAA,UAC7C;AAAA,UAGA,OAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AAAA,YACtC,iBAAiB;AAAA,YACjB,gBAAgB;AAAA,WACjB;AAAA;AAAA,aAGG,OAAM,GAA+B;AAAA,UAEzC,IAAI;AAAA,YAAW,aAAa,SAAS;AAAA,UACrC,QAAQ,OAAO,EAAE;AAAA,UAEjB,OAAO,YAAY,EAAE,OAAO,UAAU,KAAK,GAAG,CAAyB;AAAA,UACvE,OAAO,EAAE,OAAO,WAAgB,MAAM,KAAK;AAAA;AAAA,MAE/C;AAAA;AAAA,EAEJ;AAAA;AAoBK,SAAS,IAAO,CAAC,QAAgB,SAAyC;AAAA,EAC/E,MAAM,UAAU,SAAS,WAAW;AAAA,EAGpC,IAAI,QAAqB;AAAA,EACzB,IAAI,KAAK;AAAA,EACT,MAAM,eAAe,IAAI;AAAA,EACzB,MAAM,iBAAiB,IAAI;AAAA,EAC3B,MAAM,QAAsB,CAAC;AAAA,EAC7B,IAAI,UAAuB,IAAI;AAAA,EAG/B,SAAS,UAAU,GAAS;AAAA,IAC1B,aAAa,SAAS,cAAc,OAAO;AAAA,MACzC,OAAO,YAAY,SAAS,QAAQ;AAAA,IACtC;AAAA,IACA,MAAM,SAAS;AAAA;AAAA,EAIjB,SAAS,gBAAgB,CAAC,YAA6B,UAAwB;AAAA,IAC7E,OAAO,IAAI,YAAY,YAAY,QAAQ;AAAA;AAAA,EAI7C,OAAO,YAAY,CAAC,UAA6C;AAAA,IAC/D,MAAM,MAAM,MAAM;AAAA,IAGlB,IAAI,IAAI,UAAU,SAAS;AAAA,MACzB,QAAQ;AAAA,MACR,UAAU,IAAI,IAAI,IAAI,OAAO;AAAA,MAC7B,WAAW;AAAA,MACX;AAAA,IACF;AAAA,IAGA,IAAI,IAAI,UAAU,WAAW;AAAA,MAC3B,MAAM,OAAO,aAAa,IAAI,IAAI,GAAG;AAAA,MACrC,IAAI,MAAM;AAAA,QACR,IAAI,KAAK;AAAA,UAAW,aAAa,KAAK,SAAS;AAAA,QAC/C,KAAK,QAAQ,IAAI,KAAK;AAAA,QACtB,aAAa,OAAO,IAAI,GAAG;AAAA,MAC7B;AAAA,MACA;AAAA,IACF;AAAA,IAEA,IAAI,IAAI,UAAU,UAAU;AAAA,MAC1B,MAAM,OAAO,aAAa,IAAI,IAAI,GAAG;AAAA,MACrC,IAAI,MAAM;AAAA,QACR,IAAI,KAAK;AAAA,UAAW,aAAa,KAAK,SAAS;AAAA,QAC/C,KAAK,OAAO,iBAAiB,IAAI,OAAO,KAAK,QAAQ,CAAC;AAAA,QACtD,aAAa,OAAO,IAAI,GAAG;AAAA,QAC3B;AAAA,MACF;AAAA,MAGA,MAAM,SAAS,eAAe,IAAI,IAAI,GAAG;AAAA,MACzC,IAAI,QAAQ;AAAA,QACV,OAAO,MAAM,iBAAiB,IAAI,OAAO,OAAO,QAAQ,CAAC;AAAA,QACzD,eAAe,OAAO,IAAI,GAAG;AAAA,MAC/B;AAAA,MACA;AAAA,IACF;AAAA,IAGA,IAAI,IAAI,UAAU,SAAS;AAAA,MACzB,MAAM,SAAS,eAAe,IAAI,IAAI,GAAG;AAAA,MACzC,IAAI,QAAQ;AAAA,QACV,OAAO,KAAK,IAAI,KAAK;AAAA,MACvB;AAAA,MACA;AAAA,IACF;AAAA,IAEA,IAAI,IAAI,UAAU,QAAQ;AAAA,MACxB,MAAM,SAAS,eAAe,IAAI,IAAI,GAAG;AAAA,MACzC,IAAI,QAAQ;AAAA,QACV,OAAO,KAAK;AAAA,QACZ,eAAe,OAAO,IAAI,GAAG;AAAA,MAC/B;AAAA,MACA;AAAA,IACF;AAAA;AAAA,EAIF,SAAS,gBAAgB,CAAC,OAAoB;AAAA,IAE5C,WAAW,QAAQ,aAAa,OAAO,GAAG;AAAA,MACxC,IAAI,KAAK;AAAA,QAAW,aAAa,KAAK,SAAS;AAAA,MAC/C,KAAK,OAAO,KAAK;AAAA,IACnB;AAAA,IACA,aAAa,MAAM;AAAA,IAGnB,WAAW,UAAU,eAAe,OAAO,GAAG;AAAA,MAC5C,IAAI,OAAO;AAAA,QAAW,aAAa,OAAO,SAAS;AAAA,MACnD,OAAO,MAAM,KAAK;AAAA,IACpB;AAAA,IACA,eAAe,MAAM;AAAA,IAGrB,MAAM,SAAS;AAAA;AAAA,EAIjB,OAAO,UAAU,CAAC,UAAU;AAAA,IAC1B,MAAM,QAAQ,IAAI,UAAU,MAAM,WAAW,cAAc;AAAA,IAC3D,iBAAiB,KAAK;AAAA,IACtB,QAAQ;AAAA;AAAA,EAIV,MAAM,QAAQ,IAAI,MAAM,CAAC,GAAuB;AAAA,IAC9C,GAAG,CAAC,GAAG,MAAuB;AAAA,MAE5B,IAAI,SAAS;AAAA,QAAU,OAAO;AAAA,MAC9B,IAAI,SAAS;AAAA,QAAY,OAAO,aAAa,OAAO,eAAe;AAAA,MACnE,IAAI,SAAS;AAAA,QAAW,OAAO;AAAA,MAG/B,IAAI,OAAO,SAAS;AAAA,QAAU;AAAA,MAG9B,OAAO,IAAI,SAAoB;AAAA,QAC7B,MAAM,YAAY,EAAE;AAAA,QACpB,QAAQ,MAAM,eAAe,aAAa,YAAY,IAAI;AAAA,QAE1D,MAAM,UAAuB;AAAA,UAC3B,OAAO;AAAA,UACP,KAAK;AAAA,UACL,QAAQ;AAAA,UACR,MAAM;AAAA,QACR;AAAA,QAoBA,MAAM,WAAW,IAAI;AAAA,QAGrB,IAAI,cAAc;AAAA,QAClB,IAAI,iBAAgD;AAAA,QAGpD,IAAI,kBAA2C;AAAA,QAC/C,IAAI,iBAAoD;AAAA,QACxD,IAAI,gBAAiD;AAAA,QAGrD,SAAS,kBAAkB,GAAqB;AAAA,UAC9C,IAAI,CAAC,iBAAiB;AAAA,YACpB,kBAAkB,IAAI,QAAiB,CAAC,SAAS,WAAW;AAAA,cAC1D,iBAAiB;AAAA,cACjB,gBAAgB;AAAA,aACjB;AAAA,UACH;AAAA,UACA,OAAO;AAAA;AAAA,QAIT,IAAI;AAAA,QACJ,IAAI,UAAU,GAAG;AAAA,UACf,YAAY,WAAW,MAAM;AAAA,YAC3B,IAAI,CAAC,aAAa;AAAA,cAChB,MAAM,eAAe,IAAI,aAAa,MAAM,OAAO;AAAA,cAEnD,mBAAmB;AAAA,cACnB,IAAI,eAAe;AAAA,gBACjB,cAAc,YAAY;AAAA,cAC5B;AAAA,cACA,aAAa,OAAO,SAAS;AAAA,YAC/B;AAAA,aACC,OAAO;AAAA,QACZ;AAAA,QAGA,aAAa,IAAI,WAAW;AAAA,UAC1B,SAAS,CAAC,UAAU;AAAA,YAClB,IAAI;AAAA,cAAW,aAAa,SAAS;AAAA,YAErC,mBAAmB;AAAA,YACnB,IAAI,gBAAgB;AAAA,cAClB,eAAe,KAAK;AAAA,YACtB;AAAA;AAAA,UAEF,QAAQ,CAAC,UAAU;AAAA,YACjB,IAAI;AAAA,cAAW,aAAa,SAAS;AAAA,YAErC,mBAAmB;AAAA,YACnB,IAAI,eAAe;AAAA,cACjB,cAAc,KAAK;AAAA,YACrB;AAAA;AAAA,UAEF,QAAQ;AAAA,UACR;AAAA,UACA;AAAA,QACF,CAAC;AAAA,QAGD,IAAI,UAAU,SAAS;AAAA,UACrB,OAAO,YAAY,SAAS,QAAQ;AAAA,QACtC,EAAO,SAAI,UAAU,QAAQ;AAAA,UAC3B,MAAM,KAAK,EAAE,SAAS,SAAS,CAAC;AAAA,QAClC,EAAO;AAAA,UAEL,MAAM,QAAQ,IAAI,UAAU,sBAAsB;AAAA,UAClD,IAAI;AAAA,YAAW,aAAa,SAAS;AAAA,UACrC,aAAa,OAAO,SAAS;AAAA,UAC7B,OAAO,QAAQ,OAAO,KAAK;AAAA;AAAA,QAI7B,MAAM,aAAa;AAAA,UAEjB,IAA0C,CACxC,aACA,YAC8B;AAAA,YAC9B,OAAO,mBAAmB,EAAE,KAAK,aAAa,UAAU;AAAA;AAAA,UAG1D,KAAsB,CACpB,YAC4B;AAAA,YAC5B,OAAO,mBAAmB,EAAE,MAAM,UAAU;AAAA;AAAA,UAG9C,OAAO,CAAC,WAAmD;AAAA,YACzD,OAAO,mBAAmB,EAAE,QAAQ,SAAS;AAAA;AAAA,WAI9C,OAAO,cAAc,GAA2B;AAAA,YAE/C,IAAI,CAAC,aAAa;AAAA,cAChB,cAAc;AAAA,cAGd,MAAM,OAAO,aAAa,IAAI,SAAS;AAAA,cACvC,IAAI,MAAM;AAAA,gBAAW,aAAa,KAAK,SAAS;AAAA,cAChD,aAAa,OAAO,SAAS;AAAA,cAG7B,iBAAiB,oBACf,QACA,WACA,gBACA,SACA,IACF;AAAA,YACF;AAAA,YAEA,OAAO,eAAgB,OAAO,eAAe;AAAA;AAAA,QAEjD;AAAA,QAEA,OAAO;AAAA;AAAA;AAAA,EAGb,CAAC;AAAA,EAGD,eAAe,IAAI,OAAO;AAAA,IACxB,UAAU,CAAC,aAA0B;AAAA,MACnC,QAAQ;AAAA;AAAA,IAEV,WAAW;AAAA,EACb,CAAC;AAAA,EAED,OAAO;AAAA;AAMF,SAAS,IAAO,CAAC,OAA+B;AAAA,EACrD,MAAM,YAAY,eAAe,IAAI,KAAK;AAAA,EAC1C,IAAI,WAAW;AAAA,IACb,MAAM,QAAQ,IAAI,UAAU,sBAAsB;AAAA,IAClD,UAAU,UAAU,KAAK;AAAA,IACzB,UAAU,SAAS,MAAM;AAAA,EAC3B;AAAA,EACA,MAAM,QAAQ,UAAU;AAAA;",
+  "debugId": "0606BCFD2676783C64756E2164756E21",
+  "names": []
+}

package/dist/mock-worker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Mock Worker for testing
+ * Simulates Worker message passing in the same thread
+ */
+export interface MockWorkerMethods {
+    [key: string]: (...args: unknown[]) => unknown;
+}
+/**
+ * Create a mock Worker that runs in the same thread
+ * Useful for testing without actual Worker threads
+ */
+export declare function createMockWorker(methods: MockWorkerMethods): Worker;
+/**
+ * Create a mock Worker that delays READY message
+ */
+export declare function createSlowStartWorker(methods: MockWorkerMethods, delay: number): Worker;
+/**
+ * Create a mock Worker that fails on initialization
+ */
+export declare function createFailingWorker(errorMessage: string): Worker;
+//# sourceMappingURL=mock-worker.d.ts.map

package/dist/mock-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-worker.d.ts","sourceRoot":"","sources":["../src/mock-worker.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,WAAW,iBAAiB;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;CAChD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CA+HnE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAkCvF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CA8BhE"}

package/dist/mock-worker.js

@@ -0,0 +1,184 @@
+// src/protocol.ts
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  return {
+    name: "Error",
+    message: String(error)
+  };
+}
+
+// src/mock-worker.ts
+function createMockWorker(methods) {
+  let onmessageHandler = null;
+  let onerrorHandler = null;
+  let isTerminated = false;
+  const activeGenerators = new Map;
+  const mockWorker = {
+    postMessage(data, _transfer) {
+      if (isTerminated)
+        return;
+      queueMicrotask(async () => {
+        if (isTerminated)
+          return;
+        if (data.$type === "CANCEL") {
+          const gen = activeGenerators.get(data.$id);
+          if (gen && "return" in gen && typeof gen.return === "function") {
+            try {
+              gen.return(undefined);
+            } catch {}
+          }
+          activeGenerators.delete(data.$id);
+          return;
+        }
+        if (data.$type === "CALL") {
+          const { $id, method, args } = data;
+          const fn = methods[method];
+          if (!fn) {
+            sendMessage({
+              $type: "REJECT",
+              $id,
+              error: { name: "Error", message: `Method '${method}' not found` }
+            });
+            return;
+          }
+          try {
+            const result = fn(...args);
+            if (isGenerator(result)) {
+              activeGenerators.set($id, result);
+              try {
+                for await (const value of result) {
+                  if (!activeGenerators.has($id) || isTerminated)
+                    break;
+                  sendMessage({ $type: "YIELD", $id, value });
+                }
+                if (activeGenerators.has($id) && !isTerminated) {
+                  sendMessage({ $type: "DONE", $id });
+                }
+              } finally {
+                activeGenerators.delete($id);
+              }
+            } else {
+              const value = await result;
+              if (!isTerminated) {
+                sendMessage({ $type: "RESOLVE", $id, value });
+              }
+            }
+          } catch (error) {
+            if (!isTerminated) {
+              sendMessage({ $type: "REJECT", $id, error: serializeError(error) });
+            }
+          }
+        }
+      });
+    },
+    set onmessage(handler) {
+      onmessageHandler = handler;
+    },
+    get onmessage() {
+      return onmessageHandler;
+    },
+    set onerror(handler) {
+      onerrorHandler = handler;
+    },
+    get onerror() {
+      return onerrorHandler;
+    },
+    terminate() {
+      isTerminated = true;
+      activeGenerators.clear();
+    },
+    addEventListener() {},
+    removeEventListener() {},
+    dispatchEvent() {
+      return true;
+    }
+  };
+  function sendMessage(message) {
+    if (onmessageHandler && !isTerminated) {
+      onmessageHandler({ data: message });
+    }
+  }
+  function isGenerator(value) {
+    if (value === null || typeof value !== "object")
+      return false;
+    return typeof value.next === "function" && (typeof value[Symbol.iterator] === "function" || typeof value[Symbol.asyncIterator] === "function");
+  }
+  queueMicrotask(() => {
+    if (!isTerminated) {
+      sendMessage({ $type: "READY", methods: Object.keys(methods) });
+    }
+  });
+  return mockWorker;
+}
+function createSlowStartWorker(methods, delay) {
+  const worker = createMockWorker(methods);
+  const originalOnmessage = Object.getOwnPropertyDescriptor(worker, "onmessage");
+  let readyDelayed = false;
+  let pendingReady = null;
+  let actualHandler = null;
+  Object.defineProperty(worker, "onmessage", {
+    set(handler) {
+      actualHandler = handler;
+      if (originalOnmessage?.set) {
+        originalOnmessage.set.call(worker, (event) => {
+          if (!readyDelayed && event.data.$type === "READY") {
+            pendingReady = event.data;
+            readyDelayed = true;
+            setTimeout(() => {
+              if (actualHandler && pendingReady) {
+                actualHandler({ data: pendingReady });
+              }
+            }, delay);
+          } else if (actualHandler) {
+            actualHandler(event);
+          }
+        });
+      }
+    },
+    get() {
+      return actualHandler;
+    }
+  });
+  return worker;
+}
+function createFailingWorker(errorMessage) {
+  let onerrorHandler = null;
+  const mockWorker = {
+    postMessage() {},
+    set onmessage(_handler) {},
+    get onmessage() {
+      return null;
+    },
+    set onerror(handler) {
+      onerrorHandler = handler;
+      queueMicrotask(() => {
+        if (onerrorHandler) {
+          onerrorHandler({ message: errorMessage });
+        }
+      });
+    },
+    get onerror() {
+      return onerrorHandler;
+    },
+    terminate() {},
+    addEventListener() {},
+    removeEventListener() {},
+    dispatchEvent() {
+      return true;
+    }
+  };
+  return mockWorker;
+}
+export {
+  createSlowStartWorker,
+  createMockWorker,
+  createFailingWorker
+};
+
+//# debugId=A291C1DCC73E48BC64756E2164756E21