@shelchin/threadx 0.1.0

package/dist/mock-worker.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/protocol.ts", "../src/mock-worker.ts"],
+  "sourcesContent": [
+    "/**\n * Communication protocol types between main thread and worker\n */\n\n// ============ Main Thread → Worker ============\n\nexport interface CallMessage {\n  $type: 'CALL';\n  $id: number;\n  method: string;\n  args: unknown[];\n}\n\nexport interface CancelMessage {\n  $type: 'CANCEL';\n  $id: number;\n}\n\nexport type MainToWorkerMessage = CallMessage | CancelMessage;\n\n// ============ Worker → Main Thread ============\n\nexport interface ReadyMessage {\n  $type: 'READY';\n  methods: string[];\n}\n\nexport interface ResolveMessage {\n  $type: 'RESOLVE';\n  $id: number;\n  value: unknown;\n}\n\nexport interface RejectMessage {\n  $type: 'REJECT';\n  $id: number;\n  error: SerializedError;\n}\n\nexport interface YieldMessage {\n  $type: 'YIELD';\n  $id: number;\n  value: unknown;\n}\n\nexport interface DoneMessage {\n  $type: 'DONE';\n  $id: number;\n}\n\nexport type WorkerToMainMessage =\n  | ReadyMessage\n  | ResolveMessage\n  | RejectMessage\n  | YieldMessage\n  | DoneMessage;\n\n// ============ Error Serialization ============\n\nexport interface SerializedError {\n  name: string;\n  message: string;\n  stack?: string;\n}\n\nexport function serializeError(error: unknown): SerializedError {\n  if (error instanceof Error) {\n    return {\n      name: error.name,\n      message: error.message,\n      stack: error.stack,\n    };\n  }\n  return {\n    name: 'Error',\n    message: String(error),\n  };\n}\n",
+    "/**\n * Mock Worker for testing\n * Simulates Worker message passing in the same thread\n */\n\nimport type { MainToWorkerMessage, WorkerToMainMessage } from './protocol.js';\nimport { serializeError } from './protocol.js';\n\ntype MessageHandler = (event: MessageEvent<WorkerToMainMessage>) => void;\n\nexport interface MockWorkerMethods {\n  [key: string]: (...args: unknown[]) => unknown;\n}\n\n/**\n * Create a mock Worker that runs in the same thread\n * Useful for testing without actual Worker threads\n */\nexport function createMockWorker(methods: MockWorkerMethods): Worker {\n  let onmessageHandler: MessageHandler | null = null;\n  let onerrorHandler: ((event: ErrorEvent) => void) | null = null;\n  let isTerminated = false;\n\n  // Track active generators for cancellation\n  const activeGenerators = new Map<number, Generator | AsyncGenerator>();\n\n  const mockWorker = {\n    postMessage(data: MainToWorkerMessage, _transfer?: Transferable[]) {\n      if (isTerminated) return;\n\n      // Simulate async message passing\n      queueMicrotask(async () => {\n        if (isTerminated) return;\n\n        if (data.$type === 'CANCEL') {\n          const gen = activeGenerators.get(data.$id);\n          if (gen && 'return' in gen && typeof gen.return === 'function') {\n            try {\n              gen.return(undefined);\n            } catch {\n              // Ignore\n            }\n          }\n          activeGenerators.delete(data.$id);\n          return;\n        }\n\n        if (data.$type === 'CALL') {\n          const { $id, method, args } = data;\n          const fn = methods[method];\n\n          if (!fn) {\n            sendMessage({\n              $type: 'REJECT',\n              $id,\n              error: { name: 'Error', message: `Method '${method}' not found` },\n            });\n            return;\n          }\n\n          try {\n            const result = fn(...args);\n\n            // Check if generator\n            if (isGenerator(result)) {\n              activeGenerators.set($id, result);\n\n              try {\n                for await (const value of result as AsyncIterable<unknown>) {\n                  if (!activeGenerators.has($id) || isTerminated) break;\n                  sendMessage({ $type: 'YIELD', $id, value });\n                }\n\n                if (activeGenerators.has($id) && !isTerminated) {\n                  sendMessage({ $type: 'DONE', $id });\n                }\n              } finally {\n                activeGenerators.delete($id);\n              }\n            } else {\n              const value = await result;\n              if (!isTerminated) {\n                sendMessage({ $type: 'RESOLVE', $id, value });\n              }\n            }\n          } catch (error) {\n            if (!isTerminated) {\n              sendMessage({ $type: 'REJECT', $id, error: serializeError(error) });\n            }\n          }\n        }\n      });\n    },\n\n    set onmessage(handler: MessageHandler | null) {\n      onmessageHandler = handler;\n    },\n\n    get onmessage() {\n      return onmessageHandler;\n    },\n\n    set onerror(handler: ((event: ErrorEvent) => void) | null) {\n      onerrorHandler = handler;\n    },\n\n    get onerror() {\n      return onerrorHandler;\n    },\n\n    terminate() {\n      isTerminated = true;\n      activeGenerators.clear();\n    },\n\n    addEventListener() {},\n    removeEventListener() {},\n    dispatchEvent() {\n      return true;\n    },\n  };\n\n  function sendMessage(message: WorkerToMainMessage) {\n    if (onmessageHandler && !isTerminated) {\n      onmessageHandler({ data: message } as MessageEvent<WorkerToMainMessage>);\n    }\n  }\n\n  function isGenerator(value: unknown): value is Generator | AsyncGenerator {\n    if (value === null || typeof value !== 'object') return false;\n    return (\n      typeof (value as Generator).next === 'function' &&\n      (typeof (value as Generator)[Symbol.iterator] === 'function' ||\n        typeof (value as AsyncGenerator)[Symbol.asyncIterator] === 'function')\n    );\n  }\n\n  // Send READY message after a microtask (simulating Worker startup)\n  queueMicrotask(() => {\n    if (!isTerminated) {\n      sendMessage({ $type: 'READY', methods: Object.keys(methods) });\n    }\n  });\n\n  return mockWorker as unknown as Worker;\n}\n\n/**\n * Create a mock Worker that delays READY message\n */\nexport function createSlowStartWorker(methods: MockWorkerMethods, delay: number): Worker {\n  const worker = createMockWorker(methods);\n  const originalOnmessage = Object.getOwnPropertyDescriptor(worker, 'onmessage');\n\n  // Intercept the first READY message and delay it\n  let readyDelayed = false;\n  let pendingReady: WorkerToMainMessage | null = null;\n  let actualHandler: MessageHandler | null = null;\n\n  Object.defineProperty(worker, 'onmessage', {\n    set(handler: MessageHandler | null) {\n      actualHandler = handler;\n      if (originalOnmessage?.set) {\n        originalOnmessage.set.call(worker, (event: MessageEvent<WorkerToMainMessage>) => {\n          if (!readyDelayed && event.data.$type === 'READY') {\n            pendingReady = event.data;\n            readyDelayed = true;\n            setTimeout(() => {\n              if (actualHandler && pendingReady) {\n                actualHandler({ data: pendingReady } as MessageEvent<WorkerToMainMessage>);\n              }\n            }, delay);\n          } else if (actualHandler) {\n            actualHandler(event);\n          }\n        });\n      }\n    },\n    get() {\n      return actualHandler;\n    },\n  });\n\n  return worker;\n}\n\n/**\n * Create a mock Worker that fails on initialization\n */\nexport function createFailingWorker(errorMessage: string): Worker {\n  let onerrorHandler: ((event: ErrorEvent) => void) | null = null;\n\n  const mockWorker = {\n    postMessage() {},\n    set onmessage(_handler: MessageHandler | null) {},\n    get onmessage() {\n      return null;\n    },\n    set onerror(handler: ((event: ErrorEvent) => void) | null) {\n      onerrorHandler = handler;\n      // Trigger error after microtask\n      queueMicrotask(() => {\n        if (onerrorHandler) {\n          onerrorHandler({ message: errorMessage } as ErrorEvent);\n        }\n      });\n    },\n    get onerror() {\n      return onerrorHandler;\n    },\n    terminate() {},\n    addEventListener() {},\n    removeEventListener() {},\n    dispatchEvent() {\n      return true;\n    },\n  };\n\n  return mockWorker as unknown as Worker;\n}\n"
+  ],
+  "mappings": ";AAiEO,SAAS,cAAc,CAAC,OAAiC;AAAA,EAC9D,IAAI,iBAAiB,OAAO;AAAA,IAC1B,OAAO;AAAA,MACL,MAAM,MAAM;AAAA,MACZ,SAAS,MAAM;AAAA,MACf,OAAO,MAAM;AAAA,IACf;AAAA,EACF;AAAA,EACA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS,OAAO,KAAK;AAAA,EACvB;AAAA;;;AC1DK,SAAS,gBAAgB,CAAC,SAAoC;AAAA,EACnE,IAAI,mBAA0C;AAAA,EAC9C,IAAI,iBAAuD;AAAA,EAC3D,IAAI,eAAe;AAAA,EAGnB,MAAM,mBAAmB,IAAI;AAAA,EAE7B,MAAM,aAAa;AAAA,IACjB,WAAW,CAAC,MAA2B,WAA4B;AAAA,MACjE,IAAI;AAAA,QAAc;AAAA,MAGlB,eAAe,YAAY;AAAA,QACzB,IAAI;AAAA,UAAc;AAAA,QAElB,IAAI,KAAK,UAAU,UAAU;AAAA,UAC3B,MAAM,MAAM,iBAAiB,IAAI,KAAK,GAAG;AAAA,UACzC,IAAI,OAAO,YAAY,OAAO,OAAO,IAAI,WAAW,YAAY;AAAA,YAC9D,IAAI;AAAA,cACF,IAAI,OAAO,SAAS;AAAA,cACpB,MAAM;AAAA,UAGV;AAAA,UACA,iBAAiB,OAAO,KAAK,GAAG;AAAA,UAChC;AAAA,QACF;AAAA,QAEA,IAAI,KAAK,UAAU,QAAQ;AAAA,UACzB,QAAQ,KAAK,QAAQ,SAAS;AAAA,UAC9B,MAAM,KAAK,QAAQ;AAAA,UAEnB,IAAI,CAAC,IAAI;AAAA,YACP,YAAY;AAAA,cACV,OAAO;AAAA,cACP;AAAA,cACA,OAAO,EAAE,MAAM,SAAS,SAAS,WAAW,oBAAoB;AAAA,YAClE,CAAC;AAAA,YACD;AAAA,UACF;AAAA,UAEA,IAAI;AAAA,YACF,MAAM,SAAS,GAAG,GAAG,IAAI;AAAA,YAGzB,IAAI,YAAY,MAAM,GAAG;AAAA,cACvB,iBAAiB,IAAI,KAAK,MAAM;AAAA,cAEhC,IAAI;AAAA,gBACF,iBAAiB,SAAS,QAAkC;AAAA,kBAC1D,IAAI,CAAC,iBAAiB,IAAI,GAAG,KAAK;AAAA,oBAAc;AAAA,kBAChD,YAAY,EAAE,OAAO,SAAS,KAAK,MAAM,CAAC;AAAA,gBAC5C;AAAA,gBAEA,IAAI,iBAAiB,IAAI,GAAG,KAAK,CAAC,cAAc;AAAA,kBAC9C,YAAY,EAAE,OAAO,QAAQ,IAAI,CAAC;AAAA,gBACpC;AAAA,wBACA;AAAA,gBACA,iBAAiB,OAAO,GAAG;AAAA;AAAA,YAE/B,EAAO;AAAA,cACL,MAAM,QAAQ,MAAM;AAAA,cACpB,IAAI,CAAC,cAAc;AAAA,gBACjB,YAAY,EAAE,OAAO,WAAW,KAAK,MAAM,CAAC;AAAA,cAC9C;AAAA;AAAA,YAEF,OAAO,OAAO;AAAA,YACd,IAAI,CAAC,cAAc;AAAA,cACjB,YAAY,EAAE,OAAO,UAAU,KAAK,OAAO,eAAe,KAAK,EAAE,CAAC;AAAA,YACpE;AAAA;AAAA,QAEJ;AAAA,OACD;AAAA;AAAA,QAGC,SAAS,CAAC,SAAgC;AAAA,MAC5C,mBAAmB;AAAA;AAAA,QAGjB,SAAS,GAAG;AAAA,MACd,OAAO;AAAA;AAAA,QAGL,OAAO,CAAC,SAA+C;AAAA,MACzD,iBAAiB;AAAA;AAAA,QAGf,OAAO,GAAG;AAAA,MACZ,OAAO;AAAA;AAAA,IAGT,SAAS,GAAG;AAAA,MACV,eAAe;AAAA,MACf,iBAAiB,MAAM;AAAA;AAAA,IAGzB,gBAAgB,GAAG;AAAA,IACnB,mBAAmB,GAAG;AAAA,IACtB,aAAa,GAAG;AAAA,MACd,OAAO;AAAA;AAAA,EAEX;AAAA,EAEA,SAAS,WAAW,CAAC,SAA8B;AAAA,IACjD,IAAI,oBAAoB,CAAC,cAAc;AAAA,MACrC,iBAAiB,EAAE,MAAM,QAAQ,CAAsC;AAAA,IACzE;AAAA;AAAA,EAGF,SAAS,WAAW,CAAC,OAAqD;AAAA,IACxE,IAAI,UAAU,QAAQ,OAAO,UAAU;AAAA,MAAU,OAAO;AAAA,IACxD,OACE,OAAQ,MAAoB,SAAS,eACpC,OAAQ,MAAoB,OAAO,cAAc,cAChD,OAAQ,MAAyB,OAAO,mBAAmB;AAAA;AAAA,EAKjE,eAAe,MAAM;AAAA,IACnB,IAAI,CAAC,cAAc;AAAA,MACjB,YAAY,EAAE,OAAO,SAAS,SAAS,OAAO,KAAK,OAAO,EAAE,CAAC;AAAA,IAC/D;AAAA,GACD;AAAA,EAED,OAAO;AAAA;AAMF,SAAS,qBAAqB,CAAC,SAA4B,OAAuB;AAAA,EACvF,MAAM,SAAS,iBAAiB,OAAO;AAAA,EACvC,MAAM,oBAAoB,OAAO,yBAAyB,QAAQ,WAAW;AAAA,EAG7E,IAAI,eAAe;AAAA,EACnB,IAAI,eAA2C;AAAA,EAC/C,IAAI,gBAAuC;AAAA,EAE3C,OAAO,eAAe,QAAQ,aAAa;AAAA,IACzC,GAAG,CAAC,SAAgC;AAAA,MAClC,gBAAgB;AAAA,MAChB,IAAI,mBAAmB,KAAK;AAAA,QAC1B,kBAAkB,IAAI,KAAK,QAAQ,CAAC,UAA6C;AAAA,UAC/E,IAAI,CAAC,gBAAgB,MAAM,KAAK,UAAU,SAAS;AAAA,YACjD,eAAe,MAAM;AAAA,YACrB,eAAe;AAAA,YACf,WAAW,MAAM;AAAA,cACf,IAAI,iBAAiB,cAAc;AAAA,gBACjC,cAAc,EAAE,MAAM,aAAa,CAAsC;AAAA,cAC3E;AAAA,eACC,KAAK;AAAA,UACV,EAAO,SAAI,eAAe;AAAA,YACxB,cAAc,KAAK;AAAA,UACrB;AAAA,SACD;AAAA,MACH;AAAA;AAAA,IAEF,GAAG,GAAG;AAAA,MACJ,OAAO;AAAA;AAAA,EAEX,CAAC;AAAA,EAED,OAAO;AAAA;AAMF,SAAS,mBAAmB,CAAC,cAA8B;AAAA,EAChE,IAAI,iBAAuD;AAAA,EAE3D,MAAM,aAAa;AAAA,IACjB,WAAW,GAAG;AAAA,QACV,SAAS,CAAC,UAAiC;AAAA,QAC3C,SAAS,GAAG;AAAA,MACd,OAAO;AAAA;AAAA,QAEL,OAAO,CAAC,SAA+C;AAAA,MACzD,iBAAiB;AAAA,MAEjB,eAAe,MAAM;AAAA,QACnB,IAAI,gBAAgB;AAAA,UAClB,eAAe,EAAE,SAAS,aAAa,CAAe;AAAA,QACxD;AAAA,OACD;AAAA;AAAA,QAEC,OAAO,GAAG;AAAA,MACZ,OAAO;AAAA;AAAA,IAET,SAAS,GAAG;AAAA,IACZ,gBAAgB,GAAG;AAAA,IACnB,mBAAmB,GAAG;AAAA,IACtB,aAAa,GAAG;AAAA,MACd,OAAO;AAAA;AAAA,EAEX;AAAA,EAEA,OAAO;AAAA;",
+  "debugId": "A291C1DCC73E48BC64756E2164756E21",
+  "names": []
+}

package/dist/protocol.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Communication protocol types between main thread and worker
+ */
+export interface CallMessage {
+    $type: 'CALL';
+    $id: number;
+    method: string;
+    args: unknown[];
+}
+export interface CancelMessage {
+    $type: 'CANCEL';
+    $id: number;
+}
+export type MainToWorkerMessage = CallMessage | CancelMessage;
+export interface ReadyMessage {
+    $type: 'READY';
+    methods: string[];
+}
+export interface ResolveMessage {
+    $type: 'RESOLVE';
+    $id: number;
+    value: unknown;
+}
+export interface RejectMessage {
+    $type: 'REJECT';
+    $id: number;
+    error: SerializedError;
+}
+export interface YieldMessage {
+    $type: 'YIELD';
+    $id: number;
+    value: unknown;
+}
+export interface DoneMessage {
+    $type: 'DONE';
+    $id: number;
+}
+export type WorkerToMainMessage = ReadyMessage | ResolveMessage | RejectMessage | YieldMessage | DoneMessage;
+export interface SerializedError {
+    name: string;
+    message: string;
+    stack?: string;
+}
+export declare function serializeError(error: unknown): SerializedError;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,aAAa,CAAC;AAI9D,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,SAAS,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,eAAe,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,MAAM,mBAAmB,GAC3B,YAAY,GACZ,cAAc,GACd,aAAa,GACb,YAAY,GACZ,WAAW,CAAC;AAIhB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAY9D"}

package/dist/protocol.js

@@ -0,0 +1,19 @@
+// 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)
+  };
+}
+export {
+  serializeError
+};
+
+//# debugId=285A9B781F2A586864756E2164756E21

package/dist/protocol.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/protocol.ts"],
+  "sourcesContent": [
+    "/**\n * Communication protocol types between main thread and worker\n */\n\n// ============ Main Thread → Worker ============\n\nexport interface CallMessage {\n  $type: 'CALL';\n  $id: number;\n  method: string;\n  args: unknown[];\n}\n\nexport interface CancelMessage {\n  $type: 'CANCEL';\n  $id: number;\n}\n\nexport type MainToWorkerMessage = CallMessage | CancelMessage;\n\n// ============ Worker → Main Thread ============\n\nexport interface ReadyMessage {\n  $type: 'READY';\n  methods: string[];\n}\n\nexport interface ResolveMessage {\n  $type: 'RESOLVE';\n  $id: number;\n  value: unknown;\n}\n\nexport interface RejectMessage {\n  $type: 'REJECT';\n  $id: number;\n  error: SerializedError;\n}\n\nexport interface YieldMessage {\n  $type: 'YIELD';\n  $id: number;\n  value: unknown;\n}\n\nexport interface DoneMessage {\n  $type: 'DONE';\n  $id: number;\n}\n\nexport type WorkerToMainMessage =\n  | ReadyMessage\n  | ResolveMessage\n  | RejectMessage\n  | YieldMessage\n  | DoneMessage;\n\n// ============ Error Serialization ============\n\nexport interface SerializedError {\n  name: string;\n  message: string;\n  stack?: string;\n}\n\nexport function serializeError(error: unknown): SerializedError {\n  if (error instanceof Error) {\n    return {\n      name: error.name,\n      message: error.message,\n      stack: error.stack,\n    };\n  }\n  return {\n    name: 'Error',\n    message: String(error),\n  };\n}\n"
+  ],
+  "mappings": ";AAiEO,SAAS,cAAc,CAAC,OAAiC;AAAA,EAC9D,IAAI,iBAAiB,OAAO;AAAA,IAC1B,OAAO;AAAA,MACL,MAAM,MAAM;AAAA,MACZ,SAAS,MAAM;AAAA,MACf,OAAO,MAAM;AAAA,IACf;AAAA,EACF;AAAA,EACA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS,OAAO,KAAK;AAAA,EACvB;AAAA;",
+  "debugId": "285A9B781F2A586864756E2164756E21",
+  "names": []
+}

package/dist/test-fail.worker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Failing Worker - throws immediately on load (for InitError testing)
+ */
+export {};
+//# sourceMappingURL=test-fail.worker.d.ts.map

package/dist/test-fail.worker.d.ts.map

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

package/dist/test-fail.worker.js

@@ -0,0 +1,4 @@
+// src/test-fail.worker.ts
+throw new Error("Worker script failed to load");
+
+//# debugId=4343472169047D3F64756E2164756E21

package/dist/test-fail.worker.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/test-fail.worker.ts"],
+  "sourcesContent": [
+    "/**\n * Failing Worker - throws immediately on load (for InitError testing)\n */\n\nthrow new Error('Worker script failed to load');\n"
+  ],
+  "mappings": ";AAIA,MAAM,IAAI,MAAM,8BAA8B;",
+  "debugId": "4343472169047D3F64756E2164756E21",
+  "names": []
+}

package/dist/test.worker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Test Worker - contains all methods needed for unit tests
+ */
+export {};
+//# sourceMappingURL=test.worker.d.ts.map

package/dist/test.worker.d.ts.map

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

package/dist/test.worker.js

@@ -0,0 +1,198 @@
+// 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/transfer.ts
+var TRANSFER = Symbol("threadx.transfer");
+function isTransferDescriptor(value) {
+  return typeof value === "object" && value !== null && TRANSFER in value;
+}
+
+// src/worker.ts
+function isSyncGenerator(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  return typeof value.next === "function" && typeof value[Symbol.iterator] === "function" && typeof value[Symbol.asyncIterator] !== "function";
+}
+function isAsyncGenerator(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  return typeof value.next === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+function isGenerator(value) {
+  return isSyncGenerator(value) || isAsyncGenerator(value);
+}
+function postMessage(message, value) {
+  if (isTransferDescriptor(value)) {
+    self.postMessage(message, value.transferables);
+  } else {
+    self.postMessage(message);
+  }
+}
+function expose(methods) {
+  const methodNames = Object.keys(methods);
+  const activeGenerators = new Map;
+  self.postMessage({ $type: "READY", methods: methodNames });
+  self.onmessage = async (event) => {
+    const msg = event.data;
+    if (msg.$type === "CANCEL") {
+      const gen = activeGenerators.get(msg.$id);
+      if (gen && "return" in gen && typeof gen.return === "function") {
+        try {
+          gen.return(undefined);
+        } catch {}
+      }
+      activeGenerators.delete(msg.$id);
+      return;
+    }
+    if (msg.$type === "CALL") {
+      const { $id, method, args } = msg;
+      const fn = methods[method];
+      if (!fn) {
+        postMessage({
+          $type: "REJECT",
+          $id,
+          error: { name: "Error", message: `Method '${method}' not found` }
+        });
+        return;
+      }
+      try {
+        const result = fn(...args);
+        if (isGenerator(result) || isAsyncGenerator(result)) {
+          activeGenerators.set($id, result);
+          try {
+            for await (const value of result) {
+              if (!activeGenerators.has($id)) {
+                break;
+              }
+              postMessage({ $type: "YIELD", $id, value }, value);
+            }
+            if (activeGenerators.has($id)) {
+              postMessage({ $type: "DONE", $id });
+            }
+          } finally {
+            activeGenerators.delete($id);
+          }
+        } else {
+          const value = await result;
+          postMessage({ $type: "RESOLVE", $id, value }, value);
+        }
+      } catch (error) {
+        postMessage({
+          $type: "REJECT",
+          $id,
+          error: serializeError(error)
+        });
+      }
+    }
+  };
+}
+
+// src/test.worker.ts
+var pendingResolvers = new Map;
+expose({
+  add(a, b) {
+    return a + b;
+  },
+  multiply(a, b) {
+    return a * b;
+  },
+  async fetchData(id) {
+    await new Promise((r) => setTimeout(r, 10));
+    return { id, name: "test" };
+  },
+  getTime() {
+    return 1234567890;
+  },
+  doSomething() {
+    return;
+  },
+  getNull() {
+    return null;
+  },
+  transform(data) {
+    return {
+      result: data.items.map((n) => `${data.prefix}${n}`),
+      count: data.items.length
+    };
+  },
+  failingMethod() {
+    throw new Error("Something went wrong");
+  },
+  throwTypeError() {
+    throw new TypeError("Invalid type");
+  },
+  async slowMethod() {
+    await new Promise((r) => setTimeout(r, 1000));
+    return "done";
+  },
+  async fastMethod() {
+    await new Promise((r) => setTimeout(r, 10));
+    return "fast";
+  },
+  method() {
+    return "result";
+  },
+  *countdown(from) {
+    for (let i = from;i >= 0; i--) {
+      yield i;
+    }
+  },
+  async* asyncStream(count) {
+    for (let i = 0;i < count; i++) {
+      await new Promise((r) => setTimeout(r, 5));
+      yield i * 10;
+    }
+  },
+  async* infiniteStream() {
+    let i = 0;
+    while (true) {
+      await new Promise((r) => setTimeout(r, 10));
+      yield i++;
+    }
+  },
+  async* slowStream() {
+    let i = 0;
+    while (true) {
+      await new Promise((r) => setTimeout(r, 100));
+      yield i++;
+    }
+  },
+  *empty() {},
+  *failingGenerator() {
+    yield 1;
+    yield 2;
+    throw new Error("Generator failed");
+  },
+  slowMethodWithCallback() {
+    return new Promise((resolve) => {
+      pendingResolvers.set("slowMethodWithCallback", () => resolve(42));
+    });
+  },
+  resolveSlowMethod() {
+    const resolver = pendingResolvers.get("slowMethodWithCallback");
+    if (resolver) {
+      resolver();
+      pendingResolvers.delete("slowMethodWithCallback");
+    }
+  },
+  processBuffer(buffer) {
+    return buffer.byteLength;
+  },
+  combineBuffers(buf1, buf2) {
+    return buf1.byteLength + buf2.byteLength;
+  }
+});
+
+//# debugId=E72E1A6102C7BF2D64756E2164756E21

package/dist/test.worker.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/protocol.ts", "../src/transfer.ts", "../src/worker.ts", "../src/test.worker.ts"],
+  "sourcesContent": [
+    "/**\n * Communication protocol types between main thread and worker\n */\n\n// ============ Main Thread → Worker ============\n\nexport interface CallMessage {\n  $type: 'CALL';\n  $id: number;\n  method: string;\n  args: unknown[];\n}\n\nexport interface CancelMessage {\n  $type: 'CANCEL';\n  $id: number;\n}\n\nexport type MainToWorkerMessage = CallMessage | CancelMessage;\n\n// ============ Worker → Main Thread ============\n\nexport interface ReadyMessage {\n  $type: 'READY';\n  methods: string[];\n}\n\nexport interface ResolveMessage {\n  $type: 'RESOLVE';\n  $id: number;\n  value: unknown;\n}\n\nexport interface RejectMessage {\n  $type: 'REJECT';\n  $id: number;\n  error: SerializedError;\n}\n\nexport interface YieldMessage {\n  $type: 'YIELD';\n  $id: number;\n  value: unknown;\n}\n\nexport interface DoneMessage {\n  $type: 'DONE';\n  $id: number;\n}\n\nexport type WorkerToMainMessage =\n  | ReadyMessage\n  | ResolveMessage\n  | RejectMessage\n  | YieldMessage\n  | DoneMessage;\n\n// ============ Error Serialization ============\n\nexport interface SerializedError {\n  name: string;\n  message: string;\n  stack?: string;\n}\n\nexport function serializeError(error: unknown): SerializedError {\n  if (error instanceof Error) {\n    return {\n      name: error.name,\n      message: error.message,\n      stack: error.stack,\n    };\n  }\n  return {\n    name: 'Error',\n    message: String(error),\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 * Worker-side API for ThreadX\n */\n\nimport type { MainToWorkerMessage, WorkerToMainMessage } from './protocol.js';\nimport { serializeError } from './protocol.js';\nimport { isTransferDescriptor } from './transfer.js';\n\n// Re-export t() for Worker-side use\nexport { t } from './transfer.js';\n\ntype AnyFunction = (...args: unknown[]) => unknown;\ntype MethodMap = Record<string, AnyFunction>;\n\n/**\n * Check if a value is a Generator (sync)\n * Uses duck typing - checks for next() and Symbol.iterator\n */\nfunction isSyncGenerator(value: unknown): value is Generator {\n  if (value === null || typeof value !== 'object') return false;\n  return (\n    typeof (value as Generator).next === 'function' &&\n    typeof (value as Generator)[Symbol.iterator] === 'function' &&\n    // Exclude AsyncGenerator (which also has next and Symbol.iterator)\n    typeof (value as AsyncGenerator)[Symbol.asyncIterator] !== 'function'\n  );\n}\n\n/**\n * Check if a value is an AsyncGenerator\n * Uses duck typing - checks for next() and Symbol.asyncIterator\n */\nfunction isAsyncGenerator(value: unknown): value is AsyncGenerator {\n  if (value === null || typeof value !== 'object') return false;\n  return (\n    typeof (value as AsyncGenerator).next === 'function' &&\n    typeof (value as AsyncGenerator)[Symbol.asyncIterator] === 'function'\n  );\n}\n\n/**\n * Check if a value is any kind of Generator (sync or async)\n */\nfunction isGenerator(value: unknown): value is Generator | AsyncGenerator {\n  return isSyncGenerator(value) || isAsyncGenerator(value);\n}\n\n/**\n * Post a message with optional transferables\n */\nfunction postMessage(message: WorkerToMainMessage, value?: unknown): void {\n  if (isTransferDescriptor(value)) {\n    self.postMessage(message, value.transferables);\n  } else {\n    self.postMessage(message);\n  }\n}\n\n/**\n * Expose methods to the main thread\n *\n * @example\n * import { expose } from '@shelchin/threadx/worker'\n *\n * expose({\n *   add(a: number, b: number) {\n *     return a + b\n *   },\n *\n *   async heavyTask(data: ArrayBuffer) {\n *     // Long running computation...\n *     return result\n *   },\n *\n *   *progress(total: number) {\n *     for (let i = 0; i <= total; i++) {\n *       yield i\n *     }\n *   }\n * })\n */\nexport function expose<T extends MethodMap>(methods: T): void {\n  const methodNames = Object.keys(methods);\n\n  // Track active generators for cancellation\n  const activeGenerators = new Map<number, Generator | AsyncGenerator>();\n\n  // Send ready message\n  self.postMessage({ $type: 'READY', methods: methodNames } satisfies WorkerToMainMessage);\n\n  // Handle incoming messages\n  self.onmessage = async (event: MessageEvent<MainToWorkerMessage>) => {\n    const msg = event.data;\n\n    // Handle cancellation\n    if (msg.$type === 'CANCEL') {\n      const gen = activeGenerators.get(msg.$id);\n      if (gen && 'return' in gen && typeof gen.return === 'function') {\n        try {\n          gen.return(undefined);\n        } catch {\n          // Ignore errors during cancellation\n        }\n      }\n      activeGenerators.delete(msg.$id);\n      return;\n    }\n\n    // Handle method call\n    if (msg.$type === 'CALL') {\n      const { $id, method, args } = msg;\n      const fn = methods[method];\n\n      // Method not found\n      if (!fn) {\n        postMessage({\n          $type: 'REJECT',\n          $id,\n          error: { name: 'Error', message: `Method '${method}' not found` },\n        });\n        return;\n      }\n\n      try {\n        const result = fn(...args);\n\n        // Handle Generator/AsyncGenerator → streaming\n        if (isGenerator(result) || isAsyncGenerator(result)) {\n          activeGenerators.set($id, result);\n\n          try {\n            // Use for-await to handle both sync and async generators\n            for await (const value of result as AsyncIterable<unknown>) {\n              // Check if cancelled\n              if (!activeGenerators.has($id)) {\n                break;\n              }\n              postMessage({ $type: 'YIELD', $id, value }, value);\n            }\n\n            // Only send DONE if not cancelled\n            if (activeGenerators.has($id)) {\n              postMessage({ $type: 'DONE', $id });\n            }\n          } finally {\n            activeGenerators.delete($id);\n          }\n        } else {\n          // Handle Promise/value → single response\n          const value = await result;\n          postMessage({ $type: 'RESOLVE', $id, value }, value);\n        }\n      } catch (error) {\n        postMessage({\n          $type: 'REJECT',\n          $id,\n          error: serializeError(error),\n        });\n      }\n    }\n  };\n}\n",
+    "/**\n * Test Worker - contains all methods needed for unit tests\n */\n\nimport { expose } from './worker.js';\n\n// For testing pending resolution\nlet pendingResolvers: Map<string, () => void> = new Map();\n\nexpose({\n  // === Basic RPC ===\n  add(a: number, b: number): number {\n    return a + b;\n  },\n\n  multiply(a: number, b: number): number {\n    return a * b;\n  },\n\n  async fetchData(id: number): Promise<{ id: number; name: string }> {\n    await new Promise((r) => setTimeout(r, 10));\n    return { id, name: 'test' };\n  },\n\n  getTime(): number {\n    return 1234567890;\n  },\n\n  doSomething(): void {\n    return undefined;\n  },\n\n  getNull(): null {\n    return null;\n  },\n\n  transform(data: { items: number[]; prefix: string }): { result: string[]; count: number } {\n    return {\n      result: data.items.map((n) => `${data.prefix}${n}`),\n      count: data.items.length,\n    };\n  },\n\n  // === Error handling ===\n  failingMethod(): void {\n    throw new Error('Something went wrong');\n  },\n\n  throwTypeError(): void {\n    throw new TypeError('Invalid type');\n  },\n\n  // === Timeout ===\n  async slowMethod(): Promise<string> {\n    await new Promise((r) => setTimeout(r, 1000));\n    return 'done';\n  },\n\n  async fastMethod(): Promise<string> {\n    await new Promise((r) => setTimeout(r, 10));\n    return 'fast';\n  },\n\n  method(): string {\n    return 'result';\n  },\n\n  // === Streaming (generators) ===\n  *countdown(from: number) {\n    for (let i = from; i >= 0; i--) {\n      yield i;\n    }\n  },\n\n  async *asyncStream(count: number) {\n    for (let i = 0; i < count; i++) {\n      await new Promise((r) => setTimeout(r, 5));\n      yield i * 10;\n    }\n  },\n\n  async *infiniteStream() {\n    let i = 0;\n    while (true) {\n      await new Promise((r) => setTimeout(r, 10));\n      yield i++;\n    }\n  },\n\n  // Slow stream for timeout testing - yields every 100ms\n  async *slowStream() {\n    let i = 0;\n    while (true) {\n      await new Promise((r) => setTimeout(r, 100));\n      yield i++;\n    }\n  },\n\n  *empty() {\n    // yields nothing\n  },\n\n  *failingGenerator() {\n    yield 1;\n    yield 2;\n    throw new Error('Generator failed');\n  },\n\n  // === State hooks ===\n  slowMethodWithCallback(): Promise<number> {\n    return new Promise<number>((resolve) => {\n      pendingResolvers.set('slowMethodWithCallback', () => resolve(42));\n    });\n  },\n\n  resolveSlowMethod(): void {\n    const resolver = pendingResolvers.get('slowMethodWithCallback');\n    if (resolver) {\n      resolver();\n      pendingResolvers.delete('slowMethodWithCallback');\n    }\n  },\n\n  // === Transferables ===\n  processBuffer(buffer: ArrayBuffer): number {\n    return buffer.byteLength;\n  },\n\n  combineBuffers(buf1: ArrayBuffer, buf2: ArrayBuffer): number {\n    return buf1.byteLength + buf2.byteLength;\n  },\n});\n"
+  ],
+  "mappings": "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",
+  "debugId": "E72E1A6102C7BF2D64756E2164756E21",
+  "names": []
+}

package/dist/transfer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Transferable marking utility
+ */
+/** Symbol to identify transfer descriptors */
+export declare const TRANSFER: unique symbol;
+/** Descriptor for transferable values */
+export interface TransferDescriptor<T = unknown> {
+    [TRANSFER]: true;
+    value: T;
+    transferables: Transferable[];
+}
+/**
+ * Mark a value as Transferable for zero-copy transfer to Worker
+ *
+ * @example
+ * // Single transferable
+ * const buffer = new ArrayBuffer(1024)
+ * await worker.process(t(buffer))
+ * // buffer.byteLength === 0 (transferred)
+ *
+ * @example
+ * // Object with specified transferables
+ * const data = { image: buffer, meta: info }
+ * await worker.process(t(data, [buffer]))
+ */
+export declare function t<T extends Transferable>(value: T): TransferDescriptor<T>;
+export declare function t<T>(value: T, transferables: Transferable[]): TransferDescriptor<T>;
+/**
+ * Check if a value is a transfer descriptor
+ */
+export declare function isTransferDescriptor(value: unknown): value is TransferDescriptor;
+/**
+ * Process arguments to extract transferables
+ */
+export declare function prepareArgs(args: unknown[]): {
+    args: unknown[];
+    transfer: Transferable[];
+};
+//# sourceMappingURL=transfer.d.ts.map

package/dist/transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../src/transfer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,8CAA8C;AAC9C,eAAO,MAAM,QAAQ,eAA6B,CAAC;AAEnD,yCAAyC;AACzC,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,OAAO;IAC7C,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;IACT,aAAa,EAAE,YAAY,EAAE,CAAC;CAC/B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,CAAC,CAAC,CAAC,SAAS,YAAY,EAAE,KAAK,EAAE,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC;AAC3E,wBAAgB,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC;AASrF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEhF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG;IAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAAC,QAAQ,EAAE,YAAY,EAAE,CAAA;CAAE,CAU1F"}

package/dist/transfer.js

@@ -0,0 +1,31 @@
+// 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 };
+}
+export {
+  t,
+  prepareArgs,
+  isTransferDescriptor,
+  TRANSFER
+};
+
+//# debugId=43C12BB8E9DAF14864756E2164756E21

package/dist/transfer.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/transfer.ts"],
+  "sourcesContent": [
+    "/**\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"
+  ],
+  "mappings": ";AAKO,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;",
+  "debugId": "43C12BB8E9DAF14864756E2164756E21",
+  "names": []
+}

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Type utilities for ThreadX
+ */
+/**
+ * Worker state
+ */
+export type WorkerState = 'init' | 'ready' | 'dead';
+/**
+ * Options for wrap()
+ */
+export interface WrapOptions {
+    /** Default timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Debug name for logging */
+    name?: string;
+}
+/**
+ * Marker interface for TransferDescriptor (avoids circular import)
+ * Must include the symbol marker to ensure type safety
+ */
+interface TransferMarker<T> {
+    readonly [key: symbol]: true;
+    readonly value: T;
+    readonly transferables: Transferable[];
+}
+/**
+ * Allow a parameter to be the original type or wrapped in TransferDescriptor
+ */
+type MaybeTransfer<T> = T | TransferMarker<T>;
+/**
+ * Convert each parameter to allow TransferDescriptor wrapping
+ */
+type TransferableArgs<A extends unknown[]> = {
+    [K in keyof A]: MaybeTransfer<A[K]>;
+};
+/**
+ * Convert a function type to its wrapped version:
+ * - Generator<T> → AsyncIterable<T>
+ * - AsyncGenerator<T> → AsyncIterable<T>
+ * - T | Promise<T> → Promise<T>
+ * - Parameters can be wrapped with t() for transfer
+ */
+export type Promisify<T> = T extends (...args: infer A) => Generator<infer Y, unknown, unknown> ? (...args: TransferableArgs<A>) => AsyncIterable<Y> : T extends (...args: infer A) => AsyncGenerator<infer Y, unknown, unknown> ? (...args: TransferableArgs<A>) => AsyncIterable<Y> : T extends (...args: infer A) => infer R ? (...args: TransferableArgs<A>) => Promise<Awaited<R>> : never;
+/**
+ * Convert a module of functions to wrapped versions
+ */
+export type WrapModule<T> = {
+    [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: Promisify<T[K]>;
+};
+/**
+ * The wrapped worker proxy type with state hooks
+ */
+export type WrappedWorker<T> = WrapModule<T> & {
+    /** Current worker state */
+    readonly $state: WorkerState;
+    /** Number of pending calls */
+    readonly $pending: number;
+    /** Original Worker instance (escape hatch) */
+    readonly $worker: Worker;
+};
+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;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6BAA6B;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,UAAU,cAAc,CAAC,CAAC;IACxB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,aAAa,EAAE,YAAY,EAAE,CAAC;CACxC;AAED;;GAEG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;AAE9C;;GAEG;AACH,KAAK,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI;KAC1C,CAAC,IAAI,MAAM,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACpC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,GAC3F,CAAC,GAAG,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,GAClD,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,cAAc,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,GACvE,CAAC,GAAG,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,GAClD,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC,GACrC,CAAC,GAAG,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACrD,KAAK,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;KAEzB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACpF,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG;IAC7C,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,8BAA8B;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+
+//# debugId=738E8C95A4978BED64756E2164756E21

package/dist/types.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "738E8C95A4978BED64756E2164756E21",
+  "names": []
+}

package/dist/worker.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Worker-side API for ThreadX
+ */
+export { t } from './transfer.js';
+type AnyFunction = (...args: unknown[]) => unknown;
+type MethodMap = Record<string, AnyFunction>;
+/**
+ * Expose methods to the main thread
+ *
+ * @example
+ * import { expose } from '@shelchin/threadx/worker'
+ *
+ * expose({
+ *   add(a: number, b: number) {
+ *     return a + b
+ *   },
+ *
+ *   async heavyTask(data: ArrayBuffer) {
+ *     // Long running computation...
+ *     return result
+ *   },
+ *
+ *   *progress(total: number) {
+ *     for (let i = 0; i <= total; i++) {
+ *       yield i
+ *     }
+ *   }
+ * })
+ */
+export declare function expose<T extends MethodMap>(methods: T): void;
+//# 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":"AAAA;;GAEG;AAOH,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAElC,KAAK,WAAW,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;AACnD,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AA8C7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,SAAS,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,CAgF5D"}