@angular-helpers/worker-http 21.2.0 → 21.2.2

package/README.md

@@ -110,6 +110,7 @@ transport.terminate();
 
 - Round-robin pool (`maxInstances`) for parallel request handling
 - Lazy worker instantiation — no worker created until first request
+- **Support for SharedWorker** — set `mode: 'shared'` to share worker instances across multiple tabs, reducing memory usage and sharing interceptor state (like cache).
 - **Cancellation that actually aborts `fetch()`** — unsubscribing posts a
   cancel message; the worker-side message loop threads an `AbortSignal` all
   the way into `fetch()` so the in-flight HTTP request is truly aborted

package/fesm2022/angular-helpers-worker-http-backend.mjs

@@ -245,7 +245,17 @@ class WorkerHttpBackend extends HttpBackend {
             return existing;
         const specs = this.resolveSpecsFor(config.id);
         const transport = createWorkerTransport({
-            workerFactory: () => new Worker(config.workerUrl, { type: 'module' }),
+            workerFactory: () => {
+                if (config.mode === 'shared') {
+                    return new SharedWorker(config.workerUrl, {
+                        type: 'module',
+                        name: config.name ?? config.id,
+                    });
+                }
+                return new Worker(config.workerUrl, { type: 'module' });
+            },
+            mode: config.mode,
+            sharedWorkerName: config.name ?? config.id,
             maxInstances: config.maxInstances ?? 1,
             initMessage: specs.length > 0 ? { type: 'init-interceptors', specs } : undefined,
             streamsPolyfill: this.streamsPolyfill,

package/fesm2022/angular-helpers-worker-http-interceptors.mjs

@@ -78,20 +78,27 @@ async function executeFetch(req, signal) {
 }
 
 /**
- * Wires up the worker's `self.onmessage` handler around a built request chain.
- *
- * Owns the per-request `AbortController` map for cancellation support. Posts
- * `response` / `error` messages back to the main thread.
- *
- * Returns a disposer that restores `self.onmessage` to whatever it was before
- * (mainly useful for the configurable pipeline, which swaps the handler when
- * receiving the init message).
+ * Common loop logic for handling requests/cancellation on a port.
  */
-function attachRequestLoop(chain) {
+function attachPortLoop(port, chain) {
     const controllers = new Map();
-    const previous = self.onmessage;
-    self.onmessage = async (event) => {
-        const { type, requestId, payload } = event.data ?? {};
+    let responseBuffer = [];
+    let flushScheduled = false;
+    function scheduleFlush() {
+        if (flushScheduled)
+            return;
+        flushScheduled = true;
+        queueMicrotask(() => {
+            flushScheduled = false;
+            if (!responseBuffer.length)
+                return;
+            const responses = responseBuffer;
+            responseBuffer = [];
+            port.postMessage({ type: 'batch-response', responses });
+        });
+    }
+    const processMessage = async (msg) => {
+        const { type, requestId, payload } = msg;
         if (type === 'cancel') {
             controllers.get(requestId)?.abort();
             controllers.delete(requestId);
@@ -104,25 +111,39 @@ function attachRequestLoop(chain) {
         controllers.set(requestId, controller);
         try {
             const response = await chain(payload, controller.signal);
-            self.postMessage({ type: 'response', requestId, result: response });
+            responseBuffer.push({ type: 'response', requestId, result: response });
+            scheduleFlush();
         }
         catch (error) {
-            self.postMessage({
+            responseBuffer.push({
                 type: 'error',
                 requestId,
                 error: {
-                    message: error instanceof Error ? error.message : String(error),
-                    name: error instanceof Error ? error.name : 'UnknownError',
-                    stack: error instanceof Error ? error.stack : undefined,
+                    message: error?.message ?? String(error),
+                    name: error?.name ?? 'UnknownError',
+                    stack: error?.stack,
                 },
             });
+            scheduleFlush();
         }
         finally {
             controllers.delete(requestId);
         }
     };
+    const messageHandler = (event) => {
+        const data = event.data ?? {};
+        if (data.type === 'batch') {
+            for (const msg of data.messages || []) {
+                processMessage(msg).catch(console.error);
+            }
+        }
+        else {
+            processMessage(data).catch(console.error);
+        }
+    };
+    port.addEventListener('message', messageHandler);
     return () => {
-        self.onmessage = previous;
+        port.removeEventListener('message', messageHandler);
         for (const controller of controllers.values()) {
             controller.abort();
         }
@@ -130,6 +151,36 @@ function attachRequestLoop(chain) {
     };
 }
 
+/**
+ * Wires up the worker's request handler around a built request chain.
+ *
+ * Automatically detects if running in a Dedicated Worker or Shared Worker context
+ * and attaches the appropriate listeners.
+ */
+function attachRequestLoop(chain) {
+    const disposers = [];
+    // Shared Worker context
+    if ('onconnect' in self) {
+        const connectHandler = (event) => {
+            const port = event.ports[0];
+            disposers.push(attachPortLoop(port, chain));
+            port.start();
+        };
+        self.addEventListener('connect', connectHandler);
+        disposers.push(() => self.removeEventListener('connect', connectHandler));
+    }
+    else {
+        // Dedicated Worker context
+        disposers.push(attachPortLoop(self, chain));
+    }
+    return () => {
+        for (const dispose of disposers) {
+            dispose();
+        }
+        disposers.length = 0;
+    };
+}
+
 /**
  * Creates and registers a worker-side HTTP pipeline.
  *
@@ -638,4 +689,4 @@ function workerCustom(name, config) {
  * Generated bundle index. Do not edit.
  */
 
-export { cacheInterceptor, composeInterceptors, contentIntegrityInterceptor, createConfigurableWorkerPipeline, createWorkerPipeline, hmacSigningInterceptor, loggingInterceptor, rateLimitInterceptor, registerInterceptor, resolveSpec, retryInterceptor, workerCache, workerContentIntegrity, workerCustom, workerHmacSigning, workerLogging, workerRateLimit, workerRetry };
+export { attachPortLoop, attachRequestLoop, cacheInterceptor, composeInterceptors, contentIntegrityInterceptor, createConfigurableWorkerPipeline, createWorkerPipeline, hmacSigningInterceptor, loggingInterceptor, rateLimitInterceptor, registerInterceptor, resolveSpec, retryInterceptor, workerCache, workerContentIntegrity, workerCustom, workerHmacSigning, workerLogging, workerRateLimit, workerRetry };

package/fesm2022/angular-helpers-worker-http-serializer.mjs

@@ -298,7 +298,8 @@ async function createAutoSerializer(config) {
         },
         deserialize(payload) {
             let resolved = payload;
-            if (payload.data instanceof ArrayBuffer) {
+            if (payload.data instanceof ArrayBuffer ||
+                Object.prototype.toString.call(payload.data) === '[object ArrayBuffer]') {
                 const str = new TextDecoder().decode(payload.data);
                 resolved = { ...payload, data: str };
             }

package/fesm2022/angular-helpers-worker-http-transport.mjs

@@ -136,65 +136,105 @@ class WorkerHttpTimeoutError extends Error {
     }
 }
 
+/**
+ * Wraps a Worker or SharedWorker into a unified TransportPort interface.
+ */
+function wrapWorker(worker) {
+    if ('port' in worker) {
+        const port = worker.port;
+        return {
+            postMessage: (msg, transfer) => port.postMessage(msg, transfer),
+            addEventListener: (type, listener) => port.addEventListener(type, listener),
+            removeEventListener: (type, listener) => port.removeEventListener(type, listener),
+            start: () => port.start(),
+            terminate: () => port.close(),
+        };
+    }
+    return worker;
+}
+
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 /**
  * Creates a typed, Observable-based transport for communicating with a web worker.
- *
- * Features:
- * - Request/response correlation via `requestId`
- * - Cancellation on Observable unsubscribe (also aborts `fetch()` in the worker)
- * - Per-request timeout (default 30 s) rejecting with `WorkerHttpTimeoutError`
- * - Optional worker pool with round-robin dispatch
- * - Lazy worker creation (default)
- * - Opt-in transferable detection (`transferDetection: 'auto'`) for zero-copy
- *   `ArrayBuffer` / stream payloads
- *
- * @example
- * ```typescript
- * const transport = createWorkerTransport<MyRequest, MyResponse>({
- *   workerFactory: () => new Worker(new URL('./my.worker.ts', import.meta.url), { type: 'module' }),
- *   maxInstances: 2,
- * });
- *
- * transport.execute(request).subscribe({
- *   next: (response) => console.log(response),
- *   error: (err) => console.error(err),
- * });
- * ```
  */
 function createWorkerTransport(config) {
-    const workers = [];
+    const instances = [];
     let roundRobinIndex = 0;
     let terminated = false;
+    const batchBuffer = new Map();
+    const batchTransferables = new Map();
+    let flushScheduled = false;
+    function scheduleFlush() {
+        if (flushScheduled)
+            return;
+        flushScheduled = true;
+        queueMicrotask(() => {
+            flushScheduled = false;
+            for (const [instance, messages] of batchBuffer.entries()) {
+                const transferables = batchTransferables.get(instance) || [];
+                instance.postMessage({ type: 'batch', messages }, transferables);
+            }
+            batchBuffer.clear();
+            batchTransferables.clear();
+        });
+    }
+    function dispatchToWorker(instance, msg, transferables) {
+        if (!batchBuffer.has(instance)) {
+            batchBuffer.set(instance, []);
+        }
+        batchBuffer.get(instance).push(msg);
+        if (transferables?.length) {
+            if (!batchTransferables.has(instance)) {
+                batchTransferables.set(instance, []);
+            }
+            batchTransferables.get(instance).push(...transferables);
+        }
+        scheduleFlush();
+    }
+    const mode = config.mode ?? 'worker';
+    const sharedWorkerName = config.sharedWorkerName ?? 'worker-http';
     const maxInstances = Math.min(config.maxInstances ?? 1, typeof navigator !== 'undefined' ? (navigator.hardwareConcurrency ?? 4) : 1);
     const requestTimeout = config.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
     const transferDetection = config.transferDetection ?? 'none';
     const streamsPolyfill = config.streamsPolyfill ?? false;
     let polyfillLoaded = false;
-    function createWorker() {
+    function createInstance(index) {
+        let worker;
         if (config.workerFactory) {
-            return config.workerFactory();
+            worker = config.workerFactory();
         }
-        if (config.workerUrl) {
+        else if (config.workerUrl) {
             const url = typeof config.workerUrl === 'string'
                 ? new URL(config.workerUrl, document.baseURI)
                 : config.workerUrl;
-            return new Worker(url, { type: 'module' });
+            if (mode === 'shared') {
+                const name = maxInstances > 1 ? `${sharedWorkerName}-${index}` : sharedWorkerName;
+                worker = new SharedWorker(url, { type: 'module', name });
+            }
+            else {
+                worker = new Worker(url, { type: 'module' });
+            }
+        }
+        else {
+            throw new Error('Either workerFactory or workerUrl must be provided');
         }
-        throw new Error('Either workerFactory or workerUrl must be provided');
+        return wrapWorker(worker);
     }
-    function getOrCreateWorker() {
-        if (workers.length < maxInstances) {
-            const worker = createWorker();
+    function getOrCreateInstance() {
+        if (instances.length < maxInstances) {
+            const instance = createInstance(instances.length);
+            if (instance.start) {
+                instance.start();
+            }
             if (config.initMessage) {
-                worker.postMessage(config.initMessage);
+                instance.postMessage(config.initMessage);
             }
-            workers.push(worker);
-            return worker;
+            instances.push(instance);
+            return instance;
         }
-        const worker = workers[roundRobinIndex % workers.length];
+        const instance = instances[roundRobinIndex % instances.length];
         roundRobinIndex++;
-        return worker;
+        return instance;
     }
     function execute(request, options) {
         if (terminated) {
@@ -206,25 +246,22 @@ function createWorkerTransport(config) {
         const externalSignal = options?.signal;
         const effectiveTimeout = options?.timeout ?? requestTimeout;
         return new Observable((subscriber) => {
-            // Fail-fast: if the caller's signal was already aborted before we even
-            // touched a worker, surface it immediately with no postMessage roundtrip.
             if (externalSignal?.aborted) {
                 subscriber.error(new WorkerHttpAbortError(externalSignal.reason));
                 return () => undefined;
             }
-            // Lazy-load polyfill on first request if enabled
             if (streamsPolyfill && !polyfillLoaded) {
                 loadStreamsPolyfill().catch((err) => {
                     console.warn('[worker-http] Streams polyfill failed to load:', err);
                 });
             }
-            const worker = getOrCreateWorker();
+            const instance = getOrCreateInstance();
             let settled = false;
             let timeoutHandle;
             let abortListener;
             const cleanup = () => {
-                worker.removeEventListener('message', messageHandler);
-                worker.removeEventListener('error', errorHandler);
+                instance.removeEventListener('message', messageHandler);
+                instance.removeEventListener('error', errorHandler);
                 if (timeoutHandle !== undefined) {
                     clearTimeout(timeoutHandle);
                     timeoutHandle = undefined;
@@ -234,8 +271,7 @@ function createWorkerTransport(config) {
                     abortListener = undefined;
                 }
             };
-            const messageHandler = (event) => {
-                const data = event.data;
+            const handleResponse = (data) => {
                 if (data.requestId !== requestId)
                     return;
                 if (settled)
@@ -243,14 +279,24 @@ function createWorkerTransport(config) {
                 settled = true;
                 cleanup();
                 if (data.type === 'error') {
-                    const err = data.error;
-                    subscriber.error(new Error(err.message));
+                    subscriber.error(new Error(data.error.message));
                 }
                 else {
                     subscriber.next(data.result);
                     subscriber.complete();
                 }
             };
+            const messageHandler = (event) => {
+                const data = event.data;
+                if (data.type === 'batch-response') {
+                    const match = data.responses.find((r) => r.requestId === requestId);
+                    if (match)
+                        handleResponse(match);
+                }
+                else {
+                    handleResponse(data);
+                }
+            };
             const errorHandler = (event) => {
                 if (settled)
                     return;
@@ -258,14 +304,14 @@ function createWorkerTransport(config) {
                 cleanup();
                 subscriber.error(new Error(event.message ?? 'Worker error'));
             };
-            worker.addEventListener('message', messageHandler);
-            worker.addEventListener('error', errorHandler);
+            instance.addEventListener('message', messageHandler);
+            instance.addEventListener('error', errorHandler);
             if (transferDetection === 'auto') {
                 const transferables = detectTransferables(request);
-                worker.postMessage({ type: 'request', requestId, payload: request }, transferables);
+                dispatchToWorker(instance, { type: 'request', requestId, payload: request }, transferables);
             }
             else {
-                worker.postMessage({ type: 'request', requestId, payload: request });
+                dispatchToWorker(instance, { type: 'request', requestId, payload: request });
             }
             if (effectiveTimeout > 0 && Number.isFinite(effectiveTimeout)) {
                 timeoutHandle = setTimeout(() => {
@@ -273,15 +319,10 @@ function createWorkerTransport(config) {
                         return;
                     settled = true;
                     cleanup();
-                    // Ask the worker to abort any in-flight work for this id. The
-                    // cancellation fix wires this through to `fetch()`.
-                    worker.postMessage({ type: 'cancel', requestId });
+                    dispatchToWorker(instance, { type: 'cancel', requestId });
                     subscriber.error(new WorkerHttpTimeoutError(effectiveTimeout));
                 }, effectiveTimeout);
             }
-            // External AbortSignal: surface a typed abort error and cancel the
-            // worker-side fetch. Distinct from a silent unsubscribe (no error) and
-            // from a timeout (different error type).
             if (externalSignal) {
                 abortListener = () => {
                     if (settled)
@@ -289,25 +330,20 @@ function createWorkerTransport(config) {
                     settled = true;
                     const reason = externalSignal.reason;
                     cleanup();
-                    worker.postMessage({ type: 'cancel', requestId });
+                    dispatchToWorker(instance, { type: 'cancel', requestId });
                     subscriber.error(new WorkerHttpAbortError(reason));
                 };
                 externalSignal.addEventListener('abort', abortListener, { once: true });
             }
-            // Teardown: send cancel message on unsubscribe
             return () => {
                 if (settled)
                     return;
                 settled = true;
                 cleanup();
-                worker.postMessage({ type: 'cancel', requestId });
+                dispatchToWorker(instance, { type: 'cancel', requestId });
             };
         });
     }
-    /**
-     * Lazy-loads the streams polyfill if enabled and not already loaded.
-     * Called before operations that might involve stream transfer.
-     */
     async function loadStreamsPolyfill() {
         if (!streamsPolyfill || polyfillLoaded) {
             return;
@@ -320,25 +356,26 @@ function createWorkerTransport(config) {
             polyfillLoaded = true;
         }
         catch (err) {
-            // Log warning but don't block request — streams will fail naturally
             console.warn('[worker-http] Failed to load streams polyfill:', err);
         }
     }
     function terminate() {
         terminated = true;
-        for (const worker of workers) {
-            worker.terminate();
+        for (const instance of instances) {
+            if (instance.terminate) {
+                instance.terminate();
+            }
         }
-        workers.length = 0;
+        instances.length = 0;
     }
     return {
         execute,
         terminate,
         get isActive() {
-            return !terminated && workers.length > 0;
+            return !terminated && instances.length > 0;
         },
         get activeInstances() {
-            return workers.length;
+            return instances.length;
         },
     };
 }
@@ -347,4 +384,4 @@ function createWorkerTransport(config) {
  * Generated bundle index. Do not edit.
  */
 
-export { WorkerHttpAbortError, WorkerHttpTimeoutError, createWorkerTransport, detectTransferables };
+export { WorkerHttpAbortError, WorkerHttpTimeoutError, createWorkerTransport, detectTransferables, wrapWorker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/worker-http",
-  "version": "21.2.0",
+  "version": "21.2.2",
   "description": "Angular HTTP over Web Workers — off-main-thread HTTP pipelines with configurable interceptors, WebCrypto security, and pluggable serialization",
   "schematics": "./schematics/collection.json",
   "exports": {
@@ -102,6 +102,7 @@
   "module": "fesm2022/angular-helpers-worker-http.mjs",
   "typings": "types/angular-helpers-worker-http.d.ts",
   "sideEffects": false,
+  "type": "module",
   "dependencies": {
     "tslib": "^2.3.0"
   }

package/types/angular-helpers-worker-http-backend.d.ts

@@ -27,6 +27,19 @@ interface WorkerConfig {
     workerUrl: URL;
     /** Maximum worker instances in the pool (default: 1) */
     maxInstances?: number;
+    /**
+     * Execution mode for the worker.
+     *
+     * - `'worker'` (default) — Dedicated Web Worker. Each tab has its own worker instance.
+     * - `'shared'` — Shared Web Worker. Multiple tabs share the same worker instances.
+     */
+    mode?: 'worker' | 'shared';
+    /**
+     * Name for the SharedWorker. Required when `mode: 'shared'` to ensure multiple
+     * tabs connect to the same worker instance. If `maxInstances > 1`, names are
+     * suffixed with the instance index (e.g. `api-1`, `api-2`).
+     */
+    name?: string;
 }
 /**
  * URL-pattern to worker auto-routing rule.

package/types/angular-helpers-worker-http-interceptors.d.ts

@@ -223,6 +223,21 @@ declare function resolveSpec(spec: WorkerInterceptorSpec): WorkerInterceptorFn;
  */
 declare function createConfigurableWorkerPipeline(): void;
 
+type RequestHandler = (req: SerializableRequest, signal?: AbortSignal) => Promise<SerializableResponse>;
+
+/**
+ * Wires up the worker's request handler around a built request chain.
+ *
+ * Automatically detects if running in a Dedicated Worker or Shared Worker context
+ * and attaches the appropriate listeners.
+ */
+declare function attachRequestLoop(chain: RequestHandler): () => void;
+
+/**
+ * Common loop logic for handling requests/cancellation on a port.
+ */
+declare function attachPortLoop(port: MessagePort | any, chain: RequestHandler): () => void;
+
 /**
  * Creates a retry interceptor with exponential backoff.
  *
@@ -362,5 +377,5 @@ declare function workerContentIntegrity(config?: ContentIntegrityConfig): Worker
  */
 declare function workerCustom(name: string, config?: unknown): WorkerInterceptorSpec;
 
-export { cacheInterceptor, composeInterceptors, contentIntegrityInterceptor, createConfigurableWorkerPipeline, createWorkerPipeline, hmacSigningInterceptor, loggingInterceptor, rateLimitInterceptor, registerInterceptor, resolveSpec, retryInterceptor, workerCache, workerContentIntegrity, workerCustom, workerHmacSigning, workerLogging, workerRateLimit, workerRetry };
+export { attachPortLoop, attachRequestLoop, cacheInterceptor, composeInterceptors, contentIntegrityInterceptor, createConfigurableWorkerPipeline, createWorkerPipeline, hmacSigningInterceptor, loggingInterceptor, rateLimitInterceptor, registerInterceptor, resolveSpec, retryInterceptor, workerCache, workerContentIntegrity, workerCustom, workerHmacSigning, workerLogging, workerRateLimit, workerRetry };
 export type { CacheConfig, ContentIntegrityConfig, HmacInterceptorConfig, LoggingConfig, RateLimitConfig, RetryConfig, SerializableHmacConfig, SerializableLoggingConfig, SerializableRequest, SerializableResponse, WorkerInterceptorFn, WorkerInterceptorInitMessage, WorkerInterceptorSpec };

package/types/angular-helpers-worker-http-transport.d.ts

@@ -9,16 +9,16 @@ import { Observable } from 'rxjs';
  */
 interface WorkerTransportConfig {
     /**
-     * Factory function that creates a new Worker instance.
-     * The `new Worker(new URL(...))` call MUST be in your app code (not a library)
-     * for Angular CLI to bundle the worker correctly.
+     * Factory function that creates a new Worker or SharedWorker instance.
+     * The `new Worker(...)` or `new SharedWorker(...)` call MUST be in your app code
+     * (not a library) for Angular CLI to bundle the worker correctly.
      *
      * @example
      * ```typescript
      * workerFactory: () => new Worker(new URL('./echo.worker.ts', import.meta.url), { type: 'module' })
      * ```
      */
-    workerFactory?: () => Worker;
+    workerFactory?: () => Worker | SharedWorker;
     /**
      * URL to a pre-transpiled worker file.
      * Use this when workers are built separately (e.g., with Vite) and distributed
@@ -32,6 +32,19 @@ interface WorkerTransportConfig {
      * ```
      */
     workerUrl?: string | URL;
+    /**
+     * Execution mode for the worker.
+     *
+     * - `'worker'` (default) — Dedicated Web Worker. Each tab has its own worker instance.
+     * - `'shared'` — Shared Web Worker. Multiple tabs share the same worker instances.
+     */
+    mode?: 'worker' | 'shared';
+    /**
+     * Name for the SharedWorker. Required when `mode: 'shared'` to ensure multiple
+     * tabs connect to the same worker instance. If `maxInstances > 1`, names are
+     * suffixed with the instance index (e.g. `api-1`, `api-2`).
+     */
+    sharedWorkerName?: string;
     /** Maximum number of worker instances in the pool (default: 1) */
     maxInstances?: number;
     /**
@@ -139,28 +152,6 @@ interface WorkerTransport<TRequest = unknown, TResponse = unknown> {
 
 /**
  * Creates a typed, Observable-based transport for communicating with a web worker.
- *
- * Features:
- * - Request/response correlation via `requestId`
- * - Cancellation on Observable unsubscribe (also aborts `fetch()` in the worker)
- * - Per-request timeout (default 30 s) rejecting with `WorkerHttpTimeoutError`
- * - Optional worker pool with round-robin dispatch
- * - Lazy worker creation (default)
- * - Opt-in transferable detection (`transferDetection: 'auto'`) for zero-copy
- *   `ArrayBuffer` / stream payloads
- *
- * @example
- * ```typescript
- * const transport = createWorkerTransport<MyRequest, MyResponse>({
- *   workerFactory: () => new Worker(new URL('./my.worker.ts', import.meta.url), { type: 'module' }),
- *   maxInstances: 2,
- * });
- *
- * transport.execute(request).subscribe({
- *   next: (response) => console.log(response),
- *   error: (err) => console.error(err),
- * });
- * ```
  */
 declare function createWorkerTransport<TRequest = unknown, TResponse = unknown>(config: WorkerTransportConfig): WorkerTransport<TRequest, TResponse>;
 
@@ -235,5 +226,22 @@ declare class WorkerHttpAbortError extends Error {
  */
 declare function detectTransferables(payload: unknown): Transferable[];
 
-export { WorkerHttpAbortError, WorkerHttpTimeoutError, createWorkerTransport, detectTransferables };
-export type { WorkerErrorResponse, WorkerExecuteOptions, WorkerMessage, WorkerResponse, WorkerTransport, WorkerTransportConfig };
+/**
+ * Common interface for communication ports.
+ * Unifies Worker and SharedWorker (MessagePort).
+ */
+interface TransportPort {
+    postMessage(message: any, transfer?: Transferable[]): void;
+    addEventListener(type: string, listener: any): void;
+    removeEventListener(type: string, listener: any): void;
+    terminate?(): void;
+    start?(): void;
+}
+
+/**
+ * Wraps a Worker or SharedWorker into a unified TransportPort interface.
+ */
+declare function wrapWorker(worker: Worker | SharedWorker): TransportPort;
+
+export { WorkerHttpAbortError, WorkerHttpTimeoutError, createWorkerTransport, detectTransferables, wrapWorker };
+export type { TransportPort, WorkerErrorResponse, WorkerExecuteOptions, WorkerMessage, WorkerResponse, WorkerTransport, WorkerTransportConfig };