@wordpress/worker-threads 1.0.1-next.v.202602200903.0

package/README.md

@@ -0,0 +1,132 @@
+# Worker Threads
+
+Utilities for type-safe Web Worker communication with RPC (Remote Procedure Call).
+
+This package provides a simple and efficient way to communicate between the main thread and Web Workers, automatically handling:
+
+- Promise-based async method calls
+- Automatic transferable detection (ArrayBuffer, etc.)
+- Type-safe API with full TypeScript support
+- Error propagation from worker to main thread
+
+## Installation
+
+Install the module:
+
+```bash
+npm install @wordpress/worker-threads
+```
+
+## Usage
+
+### Worker Thread
+
+Create a worker file that exposes methods to the main thread:
+
+```typescript
+// worker.ts
+import { expose } from '@wordpress/worker-threads/worker';
+
+const api = {
+    async processImage( buffer: ArrayBuffer, quality: number ): Promise<ArrayBuffer> {
+        // ... image processing logic
+        return resultBuffer;
+    },
+
+    async calculateSum( a: number, b: number ): Promise<number> {
+        return a + b;
+    },
+};
+
+expose( api );
+
+// Export the type for use with wrap() on the main thread
+export type WorkerAPI = typeof api;
+```
+
+### Main Thread
+
+Wrap the worker to get a type-safe proxy:
+
+```typescript
+// main.ts
+import { wrap, terminate } from '@wordpress/worker-threads';
+import type { WorkerAPI } from './worker';
+
+// Create the worker
+const worker = new Worker( new URL( './worker.js', import.meta.url ), {
+    type: 'module',
+} );
+
+// Wrap it to get the RPC proxy
+const api = wrap<WorkerAPI>( worker );
+
+// Call methods as async functions
+const result = await api.processImage( imageBuffer, 0.82 );
+const sum = await api.calculateSum( 1, 2 );
+
+// Clean up when done
+terminate( api );
+```
+
+## API Reference
+
+### Main Thread API
+
+#### `wrap<T>( worker: Worker ): Remote<T>`
+
+Wraps a Worker to provide a type-safe RPC interface. The returned proxy object allows calling methods on the worker as if they were local async functions.
+
+#### `terminate( remote: Remote<unknown> ): void`
+
+Terminates a wrapped worker and cleans up resources. Any pending calls will be rejected.
+
+### Worker Thread API
+
+#### `expose<T>( target: T ): void`
+
+Exposes an object's methods to be called from the main thread. Should be called once in the worker script.
+
+### Types
+
+#### `Remote<T>`
+
+A type that converts all methods of `T` to their async versions. Each method returns `Promise<Awaited<ReturnType>>`.
+
+## Features
+
+### Automatic Transferable Detection
+
+The package automatically detects and transfers `ArrayBuffer` and other transferable objects, providing zero-copy performance for large data:
+
+```typescript
+// ArrayBuffers are automatically transferred, not copied
+const result = await api.processImage( largeImageBuffer );
+```
+
+### Error Handling
+
+Errors thrown in the worker are properly propagated to the main thread:
+
+```typescript
+try {
+    await api.riskyOperation();
+} catch ( error ) {
+    console.error( 'Worker error:', error.message );
+}
+```
+
+### TypeScript Support
+
+Full type inference for method signatures:
+
+```typescript
+// TypeScript knows the return type and parameter types
+const result: ArrayBuffer = await api.processImage( buffer, 0.82 );
+```
+
+## Contributing to this package
+
+This is an individual package that's part of the Gutenberg project. The project is organized as a monorepo. It's made up of multiple self-contained software packages, each with a specific purpose. The packages in this monorepo are published to [npm](https://www.npmjs.com/) and used by [WordPress](https://make.wordpress.org/core/) as well as other software projects.
+
+To find out more about contributing to this package or Gutenberg as a whole, please read the project's main [contributor guide](https://github.com/WordPress/gutenberg/tree/HEAD/CONTRIBUTING.md).

package/build/index.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/worker-threads/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  expose: () => import_worker_thread.expose,
+  terminate: () => import_main_thread2.terminate,
+  wrap: () => import_main_thread.wrap
+});
+module.exports = __toCommonJS(index_exports);
+var import_main_thread = require("./main-thread.cjs");
+var import_main_thread2 = require("./main-thread.cjs");
+var import_worker_thread = require("./worker-thread.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expose,
+  terminate,
+  wrap
+});
+//# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["/**\n * Main entry point for @wordpress/worker-threads.\n *\n * This module provides utilities for type-safe Web Worker communication\n * using an RPC (Remote Procedure Call) pattern. It allows you to call\n * methods on a worker as if they were local async functions.\n *\n * @example\n * Main thread usage:\n * ```typescript\n * import { wrap, terminate } from '@wordpress/worker-threads';\n * import type { WorkerAPI } from './worker';\n *\n * const worker = new Worker(new URL('./worker.js', import.meta.url));\n * const api = wrap<WorkerAPI>(worker);\n *\n * const result = await api.processData(data);\n *\n * terminate(api);\n * ```\n *\n * Worker thread usage:\n * ```typescript\n * import { expose } from '@wordpress/worker-threads';\n *\n * const api = {\n *   async processData(data: ArrayBuffer): Promise<ArrayBuffer> {\n *     // ... processing\n *     return result;\n *   }\n * };\n *\n * expose(api);\n * export type WorkerAPI = typeof api;\n * ```\n */\n\n/**\n * Wraps a Worker to provide a type-safe RPC interface.\n */\nexport { wrap } from './main-thread';\n\n/**\n * Terminates a wrapped worker and cleans up resources.\n */\nexport { terminate } from './main-thread';\n\n/**\n * Exposes an object's methods to be called from the main thread.\n * This should be called in the worker script.\n */\nexport { expose } from './worker-thread';\n\n/**\n * Type that converts all methods to async versions.\n */\nexport type { Remote } from './types';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwCA,yBAAqB;AAKrB,IAAAA,sBAA0B;AAM1B,2BAAuB;",
+  "names": ["import_main_thread"]
+}

package/build/main-thread.cjs

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/worker-threads/src/main-thread.ts
+var main_thread_exports = {};
+__export(main_thread_exports, {
+  terminate: () => terminate,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(main_thread_exports);
+var import_comctx = require("comctx");
+var import_types = require("./types.cjs");
+var WorkerInjectAdapter = class {
+  worker;
+  constructor(worker) {
+    this.worker = worker;
+  }
+  sendMessage = (message, transfer) => {
+    this.worker.postMessage(message, transfer);
+  };
+  onMessage = (callback) => {
+    const handler = (event) => callback(event.data);
+    this.worker.addEventListener("message", handler);
+    return () => this.worker.removeEventListener("message", handler);
+  };
+};
+var remoteWorkers = /* @__PURE__ */ new WeakMap();
+function wrap(worker) {
+  const [, inject] = (0, import_comctx.defineProxy)(() => ({}), {
+    namespace: "__wordpress_worker__",
+    heartbeatCheck: false,
+    transfer: true
+  });
+  const comctxRemote = inject(new WorkerInjectAdapter(worker));
+  remoteWorkers.set(comctxRemote, worker);
+  const proxy = new Proxy(comctxRemote, {
+    get(target, prop) {
+      if (prop === import_types.WORKER_SYMBOL) {
+        return worker;
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+  remoteWorkers.set(proxy, worker);
+  return proxy;
+}
+function terminate(remote) {
+  const worker = remote[import_types.WORKER_SYMBOL];
+  if (!worker) {
+    return;
+  }
+  remoteWorkers.delete(remote);
+  worker.terminate();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  terminate,
+  wrap
+});
+//# sourceMappingURL=main-thread.cjs.map

package/build/main-thread.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/main-thread.ts"],
+  "sourcesContent": ["/**\n * External dependencies\n */\nimport {\n\tdefineProxy,\n\ttype Adapter,\n\ttype SendMessage,\n\ttype OnMessage,\n} from 'comctx';\n\n/**\n * Internal dependencies\n */\nimport { WORKER_SYMBOL, type Remote, type WithWorker } from './types';\n\n/**\n * Adapter for injecting (main thread calling worker).\n */\nclass WorkerInjectAdapter implements Adapter {\n\tprivate worker: Worker;\n\n\tconstructor( worker: Worker ) {\n\t\tthis.worker = worker;\n\t}\n\n\tsendMessage: SendMessage = ( message, transfer ) => {\n\t\tthis.worker.postMessage( message, transfer );\n\t};\n\n\tonMessage: OnMessage = ( callback ) => {\n\t\tconst handler = ( event: MessageEvent ) => callback( event.data );\n\t\tthis.worker.addEventListener( 'message', handler );\n\t\treturn () => this.worker.removeEventListener( 'message', handler );\n\t};\n}\n\n/**\n * WeakMap to store workers for each remote proxy.\n */\nconst remoteWorkers = new WeakMap< object, Worker >();\n\n/**\n * Wraps a Worker to provide a type-safe RPC interface.\n *\n * The returned proxy object allows calling methods on the worker as if they\n * were local async functions. Each method call is automatically serialized,\n * sent to the worker, and the result is returned as a Promise.\n *\n * @example\n * ```typescript\n * const worker = new Worker(new URL('./worker.js', import.meta.url));\n * const api = wrap<MyWorkerAPI>(worker);\n *\n * // Call worker methods as async functions\n * const result = await api.processData(data);\n * ```\n *\n * @param worker - The Worker instance to wrap.\n * @return A proxy object with all exposed methods as async functions.\n */\nexport function wrap< T extends object >( worker: Worker ): Remote< T > {\n\t// Create the inject function using defineProxy with an empty object\n\t// (the actual implementation is on the worker side).\n\tconst [ , inject ] = defineProxy( () => ( {} ) as T, {\n\t\tnamespace: '__wordpress_worker__',\n\t\theartbeatCheck: false,\n\t\ttransfer: true,\n\t} );\n\n\t// Create the proxy using the injector.\n\tconst comctxRemote = inject( new WorkerInjectAdapter( worker ) );\n\n\t// Store the worker reference.\n\tremoteWorkers.set( comctxRemote as object, worker );\n\n\t// Create a wrapper proxy that adds WORKER_SYMBOL support.\n\tconst proxy = new Proxy( comctxRemote as Remote< T > & WithWorker, {\n\t\tget( target, prop: string | symbol ) {\n\t\t\t// Return the worker for the WORKER_SYMBOL.\n\t\t\tif ( prop === WORKER_SYMBOL ) {\n\t\t\t\treturn worker;\n\t\t\t}\n\n\t\t\t// Delegate all other property access to the comctx remote.\n\t\t\treturn Reflect.get( target, prop );\n\t\t},\n\t} );\n\n\t// Store the worker for the proxy as well.\n\tremoteWorkers.set( proxy, worker );\n\n\treturn proxy;\n}\n\n/**\n * Terminates a wrapped worker and cleans up resources.\n *\n * After calling terminate, any pending calls will be rejected and the\n * worker will be stopped.\n *\n * @example\n * ```typescript\n * const api = wrap<MyWorkerAPI>(worker);\n * // ... use the API ...\n * terminate(api); // Clean up when done\n * ```\n *\n * @param remote - The wrapped worker proxy returned by wrap().\n */\nexport function terminate( remote: Remote< unknown > ): void {\n\t// Get the worker from the proxy.\n\tconst worker = ( remote as unknown as WithWorker )[ WORKER_SYMBOL ];\n\n\tif ( ! worker ) {\n\t\treturn;\n\t}\n\n\t// Clean up the worker reference.\n\tremoteWorkers.delete( remote as object );\n\n\t// Terminate the worker.\n\tworker.terminate();\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAKO;AAKP,mBAA4D;AAK5D,IAAM,sBAAN,MAA6C;AAAA,EACpC;AAAA,EAER,YAAa,QAAiB;AAC7B,SAAK,SAAS;AAAA,EACf;AAAA,EAEA,cAA2B,CAAE,SAAS,aAAc;AACnD,SAAK,OAAO,YAAa,SAAS,QAAS;AAAA,EAC5C;AAAA,EAEA,YAAuB,CAAE,aAAc;AACtC,UAAM,UAAU,CAAE,UAAyB,SAAU,MAAM,IAAK;AAChE,SAAK,OAAO,iBAAkB,WAAW,OAAQ;AACjD,WAAO,MAAM,KAAK,OAAO,oBAAqB,WAAW,OAAQ;AAAA,EAClE;AACD;AAKA,IAAM,gBAAgB,oBAAI,QAA0B;AAqB7C,SAAS,KAA0B,QAA8B;AAGvE,QAAM,CAAE,EAAE,MAAO,QAAI,2BAAa,OAAQ,CAAC,IAAU;AAAA,IACpD,WAAW;AAAA,IACX,gBAAgB;AAAA,IAChB,UAAU;AAAA,EACX,CAAE;AAGF,QAAM,eAAe,OAAQ,IAAI,oBAAqB,MAAO,CAAE;AAG/D,gBAAc,IAAK,cAAwB,MAAO;AAGlD,QAAM,QAAQ,IAAI,MAAO,cAA0C;AAAA,IAClE,IAAK,QAAQ,MAAwB;AAEpC,UAAK,SAAS,4BAAgB;AAC7B,eAAO;AAAA,MACR;AAGA,aAAO,QAAQ,IAAK,QAAQ,IAAK;AAAA,IAClC;AAAA,EACD,CAAE;AAGF,gBAAc,IAAK,OAAO,MAAO;AAEjC,SAAO;AACR;AAiBO,SAAS,UAAW,QAAkC;AAE5D,QAAM,SAAW,OAAmC,0BAAc;AAElE,MAAK,CAAE,QAAS;AACf;AAAA,EACD;AAGA,gBAAc,OAAQ,MAAiB;AAGvC,SAAO,UAAU;AAClB;",
+  "names": []
+}

package/build/types.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/worker-threads/src/types.ts
+var types_exports = {};
+__export(types_exports, {
+  WORKER_SYMBOL: () => WORKER_SYMBOL
+});
+module.exports = __toCommonJS(types_exports);
+var WORKER_SYMBOL = /* @__PURE__ */ Symbol("worker");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORKER_SYMBOL
+});
+//# sourceMappingURL=types.cjs.map

package/build/types.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/types.ts"],
+  "sourcesContent": ["/**\n * Converts a type to its \"remote\" version where all methods become async.\n *\n * This type transformation ensures that when calling methods on a wrapped\n * worker, the return types are properly wrapped in Promises.\n */\nexport type Remote< T > = {\n\t[ K in keyof T ]: T[ K ] extends ( ...args: infer A ) => infer R\n\t\t? ( ...args: A ) => Promise< Awaited< R > >\n\t\t: never;\n};\n\n/**\n * Internal symbol used to store the worker reference on the proxy.\n */\nexport const WORKER_SYMBOL = Symbol( 'worker' );\n\n/**\n * Interface for objects that have an associated worker.\n */\nexport interface WithWorker {\n\t[ WORKER_SYMBOL ]: Worker;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,IAAM,gBAAgB,uBAAQ,QAAS;",
+  "names": []
+}

package/build/worker-thread.cjs

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/worker-threads/src/worker-thread.ts
+var worker_thread_exports = {};
+__export(worker_thread_exports, {
+  expose: () => expose
+});
+module.exports = __toCommonJS(worker_thread_exports);
+var import_comctx = require("comctx");
+var WorkerProvideAdapter = class {
+  sendMessage = (message, transfer) => {
+    self.postMessage(message, { transfer });
+  };
+  onMessage = (callback) => {
+    const handler = (event) => callback(event.data);
+    self.addEventListener("message", handler);
+    return () => self.removeEventListener("message", handler);
+  };
+};
+function expose(target) {
+  const [provide] = (0, import_comctx.defineProxy)(() => target, {
+    namespace: "__wordpress_worker__",
+    heartbeatCheck: false,
+    transfer: true
+  });
+  provide(new WorkerProvideAdapter());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expose
+});
+//# sourceMappingURL=worker-thread.cjs.map

package/build/worker-thread.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/worker-thread.ts"],
+  "sourcesContent": ["/**\n * External dependencies\n */\nimport {\n\tdefineProxy,\n\ttype Adapter,\n\ttype SendMessage,\n\ttype OnMessage,\n} from 'comctx';\n\n/**\n * Adapter for providing (worker exposing methods to main thread).\n */\nclass WorkerProvideAdapter implements Adapter {\n\tsendMessage: SendMessage = ( message, transfer ) => {\n\t\tself.postMessage( message, { transfer } );\n\t};\n\n\tonMessage: OnMessage = ( callback ) => {\n\t\tconst handler = ( event: MessageEvent ) => callback( event.data );\n\t\tself.addEventListener( 'message', handler );\n\t\treturn () => self.removeEventListener( 'message', handler );\n\t};\n}\n\n/**\n * Exposes an object's methods to be called from the main thread.\n *\n * This function should be called in the worker script to make methods\n * available for RPC calls. Only methods (functions) on the object will\n * be exposed; other properties are ignored.\n *\n * @example\n * ```typescript\n * // worker.ts\n * import { expose } from '@wordpress/worker-threads/worker';\n *\n * const api = {\n *   async processImage(buffer: ArrayBuffer): Promise<ArrayBuffer> {\n *     // ... processing logic\n *     return resultBuffer;\n *   },\n *\n *   async calculateSum(a: number, b: number): Promise<number> {\n *     return a + b;\n *   }\n * };\n *\n * expose(api);\n *\n * // Export the type for use with wrap() on main thread\n * export type WorkerAPI = typeof api;\n * ```\n *\n * @param target - Object containing methods to expose to the main thread.\n */\nexport function expose< T extends object >( target: T ): void {\n\t// Create the provide function using defineProxy with the target.\n\tconst [ provide ] = defineProxy( () => target, {\n\t\tnamespace: '__wordpress_worker__',\n\t\theartbeatCheck: false,\n\t\ttransfer: true,\n\t} );\n\n\t// Start providing the target through the adapter.\n\tprovide( new WorkerProvideAdapter() );\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAKO;AAKP,IAAM,uBAAN,MAA8C;AAAA,EAC7C,cAA2B,CAAE,SAAS,aAAc;AACnD,SAAK,YAAa,SAAS,EAAE,SAAS,CAAE;AAAA,EACzC;AAAA,EAEA,YAAuB,CAAE,aAAc;AACtC,UAAM,UAAU,CAAE,UAAyB,SAAU,MAAM,IAAK;AAChE,SAAK,iBAAkB,WAAW,OAAQ;AAC1C,WAAO,MAAM,KAAK,oBAAqB,WAAW,OAAQ;AAAA,EAC3D;AACD;AAiCO,SAAS,OAA4B,QAAkB;AAE7D,QAAM,CAAE,OAAQ,QAAI,2BAAa,MAAM,QAAQ;AAAA,IAC9C,WAAW;AAAA,IACX,gBAAgB;AAAA,IAChB,UAAU;AAAA,EACX,CAAE;AAGF,UAAS,IAAI,qBAAqB,CAAE;AACrC;",
+  "names": []
+}

package/build-module/index.mjs

@@ -0,0 +1,10 @@
+// packages/worker-threads/src/index.ts
+import { wrap } from "./main-thread.mjs";
+import { terminate } from "./main-thread.mjs";
+import { expose } from "./worker-thread.mjs";
+export {
+  expose,
+  terminate,
+  wrap
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["/**\n * Main entry point for @wordpress/worker-threads.\n *\n * This module provides utilities for type-safe Web Worker communication\n * using an RPC (Remote Procedure Call) pattern. It allows you to call\n * methods on a worker as if they were local async functions.\n *\n * @example\n * Main thread usage:\n * ```typescript\n * import { wrap, terminate } from '@wordpress/worker-threads';\n * import type { WorkerAPI } from './worker';\n *\n * const worker = new Worker(new URL('./worker.js', import.meta.url));\n * const api = wrap<WorkerAPI>(worker);\n *\n * const result = await api.processData(data);\n *\n * terminate(api);\n * ```\n *\n * Worker thread usage:\n * ```typescript\n * import { expose } from '@wordpress/worker-threads';\n *\n * const api = {\n *   async processData(data: ArrayBuffer): Promise<ArrayBuffer> {\n *     // ... processing\n *     return result;\n *   }\n * };\n *\n * expose(api);\n * export type WorkerAPI = typeof api;\n * ```\n */\n\n/**\n * Wraps a Worker to provide a type-safe RPC interface.\n */\nexport { wrap } from './main-thread';\n\n/**\n * Terminates a wrapped worker and cleans up resources.\n */\nexport { terminate } from './main-thread';\n\n/**\n * Exposes an object's methods to be called from the main thread.\n * This should be called in the worker script.\n */\nexport { expose } from './worker-thread';\n\n/**\n * Type that converts all methods to async versions.\n */\nexport type { Remote } from './types';\n"],
+  "mappings": ";AAwCA,SAAS,YAAY;AAKrB,SAAS,iBAAiB;AAM1B,SAAS,cAAc;",
+  "names": []
+}

package/build-module/main-thread.mjs

@@ -0,0 +1,52 @@
+// packages/worker-threads/src/main-thread.ts
+import {
+  defineProxy
+} from "comctx";
+import { WORKER_SYMBOL } from "./types.mjs";
+var WorkerInjectAdapter = class {
+  worker;
+  constructor(worker) {
+    this.worker = worker;
+  }
+  sendMessage = (message, transfer) => {
+    this.worker.postMessage(message, transfer);
+  };
+  onMessage = (callback) => {
+    const handler = (event) => callback(event.data);
+    this.worker.addEventListener("message", handler);
+    return () => this.worker.removeEventListener("message", handler);
+  };
+};
+var remoteWorkers = /* @__PURE__ */ new WeakMap();
+function wrap(worker) {
+  const [, inject] = defineProxy(() => ({}), {
+    namespace: "__wordpress_worker__",
+    heartbeatCheck: false,
+    transfer: true
+  });
+  const comctxRemote = inject(new WorkerInjectAdapter(worker));
+  remoteWorkers.set(comctxRemote, worker);
+  const proxy = new Proxy(comctxRemote, {
+    get(target, prop) {
+      if (prop === WORKER_SYMBOL) {
+        return worker;
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+  remoteWorkers.set(proxy, worker);
+  return proxy;
+}
+function terminate(remote) {
+  const worker = remote[WORKER_SYMBOL];
+  if (!worker) {
+    return;
+  }
+  remoteWorkers.delete(remote);
+  worker.terminate();
+}
+export {
+  terminate,
+  wrap
+};
+//# sourceMappingURL=main-thread.mjs.map

package/build-module/main-thread.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/main-thread.ts"],
+  "sourcesContent": ["/**\n * External dependencies\n */\nimport {\n\tdefineProxy,\n\ttype Adapter,\n\ttype SendMessage,\n\ttype OnMessage,\n} from 'comctx';\n\n/**\n * Internal dependencies\n */\nimport { WORKER_SYMBOL, type Remote, type WithWorker } from './types';\n\n/**\n * Adapter for injecting (main thread calling worker).\n */\nclass WorkerInjectAdapter implements Adapter {\n\tprivate worker: Worker;\n\n\tconstructor( worker: Worker ) {\n\t\tthis.worker = worker;\n\t}\n\n\tsendMessage: SendMessage = ( message, transfer ) => {\n\t\tthis.worker.postMessage( message, transfer );\n\t};\n\n\tonMessage: OnMessage = ( callback ) => {\n\t\tconst handler = ( event: MessageEvent ) => callback( event.data );\n\t\tthis.worker.addEventListener( 'message', handler );\n\t\treturn () => this.worker.removeEventListener( 'message', handler );\n\t};\n}\n\n/**\n * WeakMap to store workers for each remote proxy.\n */\nconst remoteWorkers = new WeakMap< object, Worker >();\n\n/**\n * Wraps a Worker to provide a type-safe RPC interface.\n *\n * The returned proxy object allows calling methods on the worker as if they\n * were local async functions. Each method call is automatically serialized,\n * sent to the worker, and the result is returned as a Promise.\n *\n * @example\n * ```typescript\n * const worker = new Worker(new URL('./worker.js', import.meta.url));\n * const api = wrap<MyWorkerAPI>(worker);\n *\n * // Call worker methods as async functions\n * const result = await api.processData(data);\n * ```\n *\n * @param worker - The Worker instance to wrap.\n * @return A proxy object with all exposed methods as async functions.\n */\nexport function wrap< T extends object >( worker: Worker ): Remote< T > {\n\t// Create the inject function using defineProxy with an empty object\n\t// (the actual implementation is on the worker side).\n\tconst [ , inject ] = defineProxy( () => ( {} ) as T, {\n\t\tnamespace: '__wordpress_worker__',\n\t\theartbeatCheck: false,\n\t\ttransfer: true,\n\t} );\n\n\t// Create the proxy using the injector.\n\tconst comctxRemote = inject( new WorkerInjectAdapter( worker ) );\n\n\t// Store the worker reference.\n\tremoteWorkers.set( comctxRemote as object, worker );\n\n\t// Create a wrapper proxy that adds WORKER_SYMBOL support.\n\tconst proxy = new Proxy( comctxRemote as Remote< T > & WithWorker, {\n\t\tget( target, prop: string | symbol ) {\n\t\t\t// Return the worker for the WORKER_SYMBOL.\n\t\t\tif ( prop === WORKER_SYMBOL ) {\n\t\t\t\treturn worker;\n\t\t\t}\n\n\t\t\t// Delegate all other property access to the comctx remote.\n\t\t\treturn Reflect.get( target, prop );\n\t\t},\n\t} );\n\n\t// Store the worker for the proxy as well.\n\tremoteWorkers.set( proxy, worker );\n\n\treturn proxy;\n}\n\n/**\n * Terminates a wrapped worker and cleans up resources.\n *\n * After calling terminate, any pending calls will be rejected and the\n * worker will be stopped.\n *\n * @example\n * ```typescript\n * const api = wrap<MyWorkerAPI>(worker);\n * // ... use the API ...\n * terminate(api); // Clean up when done\n * ```\n *\n * @param remote - The wrapped worker proxy returned by wrap().\n */\nexport function terminate( remote: Remote< unknown > ): void {\n\t// Get the worker from the proxy.\n\tconst worker = ( remote as unknown as WithWorker )[ WORKER_SYMBOL ];\n\n\tif ( ! worker ) {\n\t\treturn;\n\t}\n\n\t// Clean up the worker reference.\n\tremoteWorkers.delete( remote as object );\n\n\t// Terminate the worker.\n\tworker.terminate();\n}\n"],
+  "mappings": ";AAGA;AAAA,EACC;AAAA,OAIM;AAKP,SAAS,qBAAmD;AAK5D,IAAM,sBAAN,MAA6C;AAAA,EACpC;AAAA,EAER,YAAa,QAAiB;AAC7B,SAAK,SAAS;AAAA,EACf;AAAA,EAEA,cAA2B,CAAE,SAAS,aAAc;AACnD,SAAK,OAAO,YAAa,SAAS,QAAS;AAAA,EAC5C;AAAA,EAEA,YAAuB,CAAE,aAAc;AACtC,UAAM,UAAU,CAAE,UAAyB,SAAU,MAAM,IAAK;AAChE,SAAK,OAAO,iBAAkB,WAAW,OAAQ;AACjD,WAAO,MAAM,KAAK,OAAO,oBAAqB,WAAW,OAAQ;AAAA,EAClE;AACD;AAKA,IAAM,gBAAgB,oBAAI,QAA0B;AAqB7C,SAAS,KAA0B,QAA8B;AAGvE,QAAM,CAAE,EAAE,MAAO,IAAI,YAAa,OAAQ,CAAC,IAAU;AAAA,IACpD,WAAW;AAAA,IACX,gBAAgB;AAAA,IAChB,UAAU;AAAA,EACX,CAAE;AAGF,QAAM,eAAe,OAAQ,IAAI,oBAAqB,MAAO,CAAE;AAG/D,gBAAc,IAAK,cAAwB,MAAO;AAGlD,QAAM,QAAQ,IAAI,MAAO,cAA0C;AAAA,IAClE,IAAK,QAAQ,MAAwB;AAEpC,UAAK,SAAS,eAAgB;AAC7B,eAAO;AAAA,MACR;AAGA,aAAO,QAAQ,IAAK,QAAQ,IAAK;AAAA,IAClC;AAAA,EACD,CAAE;AAGF,gBAAc,IAAK,OAAO,MAAO;AAEjC,SAAO;AACR;AAiBO,SAAS,UAAW,QAAkC;AAE5D,QAAM,SAAW,OAAmC,aAAc;AAElE,MAAK,CAAE,QAAS;AACf;AAAA,EACD;AAGA,gBAAc,OAAQ,MAAiB;AAGvC,SAAO,UAAU;AAClB;",
+  "names": []
+}

package/build-module/types.mjs

@@ -0,0 +1,6 @@
+// packages/worker-threads/src/types.ts
+var WORKER_SYMBOL = /* @__PURE__ */ Symbol("worker");
+export {
+  WORKER_SYMBOL
+};
+//# sourceMappingURL=types.mjs.map

package/build-module/types.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/types.ts"],
+  "sourcesContent": ["/**\n * Converts a type to its \"remote\" version where all methods become async.\n *\n * This type transformation ensures that when calling methods on a wrapped\n * worker, the return types are properly wrapped in Promises.\n */\nexport type Remote< T > = {\n\t[ K in keyof T ]: T[ K ] extends ( ...args: infer A ) => infer R\n\t\t? ( ...args: A ) => Promise< Awaited< R > >\n\t\t: never;\n};\n\n/**\n * Internal symbol used to store the worker reference on the proxy.\n */\nexport const WORKER_SYMBOL = Symbol( 'worker' );\n\n/**\n * Interface for objects that have an associated worker.\n */\nexport interface WithWorker {\n\t[ WORKER_SYMBOL ]: Worker;\n}\n"],
+  "mappings": ";AAeO,IAAM,gBAAgB,uBAAQ,QAAS;",
+  "names": []
+}

package/build-module/worker-thread.mjs

@@ -0,0 +1,26 @@
+// packages/worker-threads/src/worker-thread.ts
+import {
+  defineProxy
+} from "comctx";
+var WorkerProvideAdapter = class {
+  sendMessage = (message, transfer) => {
+    self.postMessage(message, { transfer });
+  };
+  onMessage = (callback) => {
+    const handler = (event) => callback(event.data);
+    self.addEventListener("message", handler);
+    return () => self.removeEventListener("message", handler);
+  };
+};
+function expose(target) {
+  const [provide] = defineProxy(() => target, {
+    namespace: "__wordpress_worker__",
+    heartbeatCheck: false,
+    transfer: true
+  });
+  provide(new WorkerProvideAdapter());
+}
+export {
+  expose
+};
+//# sourceMappingURL=worker-thread.mjs.map

package/build-module/worker-thread.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/worker-thread.ts"],
+  "sourcesContent": ["/**\n * External dependencies\n */\nimport {\n\tdefineProxy,\n\ttype Adapter,\n\ttype SendMessage,\n\ttype OnMessage,\n} from 'comctx';\n\n/**\n * Adapter for providing (worker exposing methods to main thread).\n */\nclass WorkerProvideAdapter implements Adapter {\n\tsendMessage: SendMessage = ( message, transfer ) => {\n\t\tself.postMessage( message, { transfer } );\n\t};\n\n\tonMessage: OnMessage = ( callback ) => {\n\t\tconst handler = ( event: MessageEvent ) => callback( event.data );\n\t\tself.addEventListener( 'message', handler );\n\t\treturn () => self.removeEventListener( 'message', handler );\n\t};\n}\n\n/**\n * Exposes an object's methods to be called from the main thread.\n *\n * This function should be called in the worker script to make methods\n * available for RPC calls. Only methods (functions) on the object will\n * be exposed; other properties are ignored.\n *\n * @example\n * ```typescript\n * // worker.ts\n * import { expose } from '@wordpress/worker-threads/worker';\n *\n * const api = {\n *   async processImage(buffer: ArrayBuffer): Promise<ArrayBuffer> {\n *     // ... processing logic\n *     return resultBuffer;\n *   },\n *\n *   async calculateSum(a: number, b: number): Promise<number> {\n *     return a + b;\n *   }\n * };\n *\n * expose(api);\n *\n * // Export the type for use with wrap() on main thread\n * export type WorkerAPI = typeof api;\n * ```\n *\n * @param target - Object containing methods to expose to the main thread.\n */\nexport function expose< T extends object >( target: T ): void {\n\t// Create the provide function using defineProxy with the target.\n\tconst [ provide ] = defineProxy( () => target, {\n\t\tnamespace: '__wordpress_worker__',\n\t\theartbeatCheck: false,\n\t\ttransfer: true,\n\t} );\n\n\t// Start providing the target through the adapter.\n\tprovide( new WorkerProvideAdapter() );\n}\n"],
+  "mappings": ";AAGA;AAAA,EACC;AAAA,OAIM;AAKP,IAAM,uBAAN,MAA8C;AAAA,EAC7C,cAA2B,CAAE,SAAS,aAAc;AACnD,SAAK,YAAa,SAAS,EAAE,SAAS,CAAE;AAAA,EACzC;AAAA,EAEA,YAAuB,CAAE,aAAc;AACtC,UAAM,UAAU,CAAE,UAAyB,SAAU,MAAM,IAAK;AAChE,SAAK,iBAAkB,WAAW,OAAQ;AAC1C,WAAO,MAAM,KAAK,oBAAqB,WAAW,OAAQ;AAAA,EAC3D;AACD;AAiCO,SAAS,OAA4B,QAAkB;AAE7D,QAAM,CAAE,OAAQ,IAAI,YAAa,MAAM,QAAQ;AAAA,IAC9C,WAAW;AAAA,IACX,gBAAgB;AAAA,IAChB,UAAU;AAAA,EACX,CAAE;AAGF,UAAS,IAAI,qBAAqB,CAAE;AACrC;",
+  "names": []
+}

package/build-types/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Main entry point for @wordpress/worker-threads.
+ *
+ * This module provides utilities for type-safe Web Worker communication
+ * using an RPC (Remote Procedure Call) pattern. It allows you to call
+ * methods on a worker as if they were local async functions.
+ *
+ * @example
+ * Main thread usage:
+ * ```typescript
+ * import { wrap, terminate } from '@wordpress/worker-threads';
+ * import type { WorkerAPI } from './worker';
+ *
+ * const worker = new Worker(new URL('./worker.js', import.meta.url));
+ * const api = wrap<WorkerAPI>(worker);
+ *
+ * const result = await api.processData(data);
+ *
+ * terminate(api);
+ * ```
+ *
+ * Worker thread usage:
+ * ```typescript
+ * import { expose } from '@wordpress/worker-threads';
+ *
+ * const api = {
+ *   async processData(data: ArrayBuffer): Promise<ArrayBuffer> {
+ *     // ... processing
+ *     return result;
+ *   }
+ * };
+ *
+ * expose(api);
+ * export type WorkerAPI = typeof api;
+ * ```
+ */
+/**
+ * Wraps a Worker to provide a type-safe RPC interface.
+ */
+export { wrap } from './main-thread';
+/**
+ * Terminates a wrapped worker and cleans up resources.
+ */
+export { terminate } from './main-thread';
+/**
+ * Exposes an object's methods to be called from the main thread.
+ * This should be called in the worker script.
+ */
+export { expose } from './worker-thread';
+/**
+ * Type that converts all methods to async versions.
+ */
+export type { Remote } from './types';
+//# sourceMappingURL=index.d.ts.map

package/build-types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;GAEG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC;;GAEG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C;;;GAGG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC;;GAEG;AACH,YAAY,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC"}

package/build-types/main-thread.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Internal dependencies
+ */
+import { type Remote } from './types';
+/**
+ * Wraps a Worker to provide a type-safe RPC interface.
+ *
+ * The returned proxy object allows calling methods on the worker as if they
+ * were local async functions. Each method call is automatically serialized,
+ * sent to the worker, and the result is returned as a Promise.
+ *
+ * @example
+ * ```typescript
+ * const worker = new Worker(new URL('./worker.js', import.meta.url));
+ * const api = wrap<MyWorkerAPI>(worker);
+ *
+ * // Call worker methods as async functions
+ * const result = await api.processData(data);
+ * ```
+ *
+ * @param worker - The Worker instance to wrap.
+ * @return A proxy object with all exposed methods as async functions.
+ */
+export declare function wrap<T extends object>(worker: Worker): Remote<T>;
+/**
+ * Terminates a wrapped worker and cleans up resources.
+ *
+ * After calling terminate, any pending calls will be rejected and the
+ * worker will be stopped.
+ *
+ * @example
+ * ```typescript
+ * const api = wrap<MyWorkerAPI>(worker);
+ * // ... use the API ...
+ * terminate(api); // Clean up when done
+ * ```
+ *
+ * @param remote - The wrapped worker proxy returned by wrap().
+ */
+export declare function terminate(remote: Remote<unknown>): void;
+//# sourceMappingURL=main-thread.d.ts.map

package/build-types/main-thread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-thread.d.ts","sourceRoot":"","sources":["../src/main-thread.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,OAAO,EAAiB,KAAK,MAAM,EAAmB,MAAM,SAAS,CAAC;AA4BtE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAE,CAAC,SAAS,MAAM,EAAI,MAAM,EAAE,MAAM,GAAI,MAAM,CAAE,CAAC,CAAE,CAgCtE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAE,MAAM,EAAE,MAAM,CAAE,OAAO,CAAE,GAAI,IAAI,CAa3D"}

package/build-types/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a type to its "remote" version where all methods become async.
+ *
+ * This type transformation ensures that when calling methods on a wrapped
+ * worker, the return types are properly wrapped in Promises.
+ */
+export type Remote<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> : never;
+};
+/**
+ * Internal symbol used to store the worker reference on the proxy.
+ */
+export declare const WORKER_SYMBOL: unique symbol;
+/**
+ * Interface for objects that have an associated worker.
+ */
+export interface WithWorker {
+    [WORKER_SYMBOL]: Worker;
+}
+//# sourceMappingURL=types.d.ts.map

package/build-types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAE,CAAC,IAAK;KACvB,CAAC,IAAI,MAAM,CAAC,GAAI,CAAC,CAAE,CAAC,CAAE,SAAS,CAAE,GAAG,IAAI,EAAE,MAAM,CAAC,KAAM,MAAM,CAAC,GAC7D,CAAE,GAAG,IAAI,EAAE,CAAC,KAAM,OAAO,CAAE,OAAO,CAAE,CAAC,CAAE,CAAE,GACzC,KAAK;CACR,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,eAAqB,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B,CAAE,aAAa,CAAE,EAAE,MAAM,CAAC;CAC1B"}