@angular-helpers/worker-http 21.1.0 → 21.2.2

package/README.md

@@ -88,6 +88,9 @@ Then follow the setup in the `/backend` section below.
 
 A framework-agnostic, type-safe bridge between the main thread and a Web Worker. Wraps `postMessage` with request/response correlation, Observable API, and automatic cancellation on unsubscribe.
 
+<details>
+<summary><strong>API and examples</strong></summary>
+
 ```typescript
 import { createWorkerTransport } from '@angular-helpers/worker-http/transport';
 
@@ -107,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
@@ -146,12 +150,17 @@ transport.execute(request).subscribe({
 });
 ```
 
+</details>
+
 ---
 
 ### `/interceptors` — Worker-side pipeline
 
 Pure-function interceptors that run inside the worker. No Angular DI, no DOM access — just `(req, next) => Promise<response>`.
 
+<details>
+<summary><strong>Setup, built-in interceptors, and custom interceptors</strong></summary>
+
 #### Setup in your worker file
 
 ```typescript
@@ -283,11 +292,22 @@ export const authTokenInterceptor: WorkerInterceptorFn = (req, next) => {
 };
 ```
 
+</details>
+
 ---
 
 ### `/serializer` — Pluggable serialization
 
-Handles the `postMessage` serialization boundary. Structured clone is zero-overhead but loses `Date`, `Map`, `Set` fidelity. `seroval` preserves full type fidelity. The auto-serializer picks the best strategy per payload.
+Handles the `postMessage` serialization boundary. Three strategies, each with a clear sweet spot:
+
+- `structuredCloneSerializer` — zero overhead, default
+- `createToonSerializer()` — 30–60% smaller for uniform arrays of objects
+- `createSerovalSerializer()` — full type fidelity (`Date`, `Map`, `Set`, circular refs)
+
+The auto-serializer picks the best strategy per payload.
+
+<details>
+<summary><strong>Per-strategy API and examples</strong></summary>
 
 #### `structuredCloneSerializer` (default)
 
@@ -316,14 +336,49 @@ const original = serializer.deserialize(payload);
 // original.tags instanceof Set → true
 ```
 
+#### `createToonSerializer()` — Token-Oriented Object Notation
+
+Requires `@toon-format/toon` as an optional peer dependency (`npm install @toon-format/toon`).
+
+[TOON](https://toonformat.dev) declares object keys once and emits values as CSV-like rows. For uniform arrays of objects (the most common API response shape — `User[]`, `Product[]`, paginated lists), it cuts payload size by **30–60%** compared to JSON, with negligible parsing overhead.
+
+```typescript
+import { createToonSerializer } from '@angular-helpers/worker-http/serializer';
+
+const serializer = await createToonSerializer();
+
+const payload = serializer.serialize([
+  { id: 1, name: 'Alice', role: 'admin' },
+  { id: 2, name: 'Bob', role: 'member' },
+  { id: 3, name: 'Carol', role: 'member' },
+  { id: 4, name: 'Dave', role: 'guest' },
+  { id: 5, name: 'Eve', role: 'admin' },
+]);
+
+// payload.data is a TOON string:
+//   [5]{id,name,role}:
+//     1,Alice,admin
+//     2,Bob,member
+//     3,Carol,member
+//     4,Dave,guest
+//     5,Eve,admin
+```
+
+**When TOON shines**: uniform arrays of objects with primitive values (numbers, strings, booleans, nulls) at depth-1.
+
+**When TOON does NOT help**: payloads with `Date`, `Map`, `Set`, nested objects, or single objects — use `seroval` or structured clone instead.
+
 #### `createAutoSerializer()` — Smart auto-detection
 
-Automatically picks the best strategy per payload. The factory is async (pre-loads `seroval` during initialization), but the returned serializer is fully synchronous.
+Automatically picks the best strategy per payload. The factory is async (pre-loads `seroval` and `@toon-format/toon` during initialization, both optional), but the returned serializer is fully synchronous.
 
-**Detection logic (depth-1):**
+**Detection logic (depth-1, top-down, first match wins):**
 
-- Contains `Date`, `Map`, `Set`, or `RegExp` at the top level or as direct array/object values → `seroval`
-- Otherwise → structured clone (zero overhead)
+1. Contains `Date`, `Map`, `Set`, or `RegExp` at the top level or as direct array/object values → `seroval`
+2. Uniform array of plain objects with primitive values, length ≥ 5 → `toon`
+3. Otherwise → structured clone (zero overhead)
+
+The TOON threshold is conservative (length ≥ 5). Smaller arrays don't justify the encoding overhead.
 
 Payloads larger than `transferThreshold` (default: 100 KiB) are encoded to `ArrayBuffer` and transferred zero-copy.
 
@@ -346,12 +401,17 @@ auto.serialize(hugeDataset); // transferables: [ArrayBuffer]
 
 > **Depth-1 limitation**: `[{ createdAt: new Date() }]` — the `Date` is inside a nested object; not detected at depth-1. For deeply nested complex types, use `createSerovalSerializer()` directly.
 
+</details>
+
 ---
 
 ### `/crypto` — WebCrypto primitives
 
 Standalone WebCrypto utilities. Useful in both workers and the main thread, but workers provide memory isolation for key material.
 
+<details>
+<summary><strong>HMAC, AES, hashing examples</strong></summary>
+
 #### `createHmacSigner(config)`
 
 ```typescript
@@ -386,12 +446,17 @@ const hasher = createContentHasher();
 const hash = await hasher.hash('SHA-256', data); // → hex string
 ```
 
+</details>
+
 ---
 
 ### `/backend` — Angular `HttpBackend` replacement
 
 Drop-in replacement for Angular's `HttpBackend` that transparently routes `HttpClient` requests to Web Workers. Use `WorkerHttpClient` exactly like `HttpClient` — the routing is invisible to application code.
 
+<details>
+<summary><strong>Configuration, providers, and consumer code</strong></summary>
+
 ```typescript
 // app.config.ts
 import {
@@ -480,13 +545,18 @@ manual control.
 - `matchWorkerRoute(url, routes)` — pure utility to test routing rules
 - `WORKER_HTTP_SIGNAL`, `WORKER_HTTP_TIMEOUT` — `HttpContextToken`s used internally by `WorkerHttpClient`; set them directly on the `HttpContext` if you're using `HttpClient` rather than the wrapper.
 
+</details>
+
 ---
 
 ## Telemetry
 
-Main-thread extension point for APM / metrics. `withTelemetry(...)` registers
-a subscriber that fires synchronously at three lifecycle points of every
-request handled by `WorkerHttpBackend`:
+Main-thread extension point for APM / metrics. `withTelemetry(...)` registers a subscriber that fires synchronously at three lifecycle points of every request handled by `WorkerHttpBackend` (`onRequest`, `onResponse`, `onError`).
+
+<details>
+<summary><strong>Subscriber semantics, examples, and event interface</strong></summary>
+
+Lifecycle points:
 
 - **`onRequest`** — after worker resolution, before dispatch
 - **`onResponse`** — when a successful response is emitted
@@ -553,12 +623,17 @@ interface WorkerHttpTelemetryEventBase {
 // onError    adds: kind: 'error',    error,  durationMs
 ```
 
+</details>
+
 ---
 
 ### `/esbuild-plugin` — Interceptor auto-bundling
 
 An esbuild plugin that automatically discovers and bundles interceptor files into your worker builds. When using Angular with a custom webpack/esbuild configuration, this ensures your interceptors are included in the worker bundle without manual imports.
 
+<details>
+<summary><strong>Plugin options and example</strong></summary>
+
 ```typescript
 // esbuild.config.ts
 import { workerHttpPlugin } from '@angular-helpers/worker-http/esbuild-plugin';
@@ -585,12 +660,17 @@ export default {
 
 Discovered interceptors are merged with explicit ones. Test files (`.spec.ts`, `.test.ts`) are automatically excluded.
 
+</details>
+
 ---
 
 ### `/streams-polyfill` — Safari transferable streams
 
 Safari 16-17 lack native transferable `ReadableStream`/`TransformStream` support. This ponyfill enables stream transfer in workers for those browsers, loaded lazily only when needed.
 
+<details>
+<summary><strong>Setup and bundle impact</strong></summary>
+
 ```typescript
 // Enable in your app config (main thread)
 import { withWorkerStreamsPolyfill } from '@angular-helpers/worker-http/backend';
@@ -608,12 +688,16 @@ provideWorkerHttpClient(
 
 **Bundle impact:** Zero for modern browsers. The polyfill is lazy-loaded only on affected Safari versions when streams are actually used.
 
+</details>
+
 ---
 
 ## SSR + hydration
 
-Worker HTTP integrates transparently with Angular SSR. The two problems SSR
-creates for worker-based HTTP are handled out of the box:
+Worker HTTP integrates transparently with Angular SSR. SSR's two problems for worker-based HTTP — missing `Worker` global on the server and the post-hydration re-fetch — are both handled out of the box.
+
+<details>
+<summary><strong>How SSR fallback and the transfer cache work</strong></summary>
 
 **1. Workers do not exist on the server.**
 During SSR, `typeof Worker === 'undefined'`. `WorkerHttpBackend` detects this
@@ -663,6 +747,8 @@ To customise which headers are captured or to cache `POST` requests, pass
 `withHttpTransferCacheOptions(...)` to `provideClientHydration()` — both are
 re-exported from `@angular/platform-browser`.
 
+</details>
+
 ---
 
 ## Design principles
@@ -677,13 +763,14 @@ re-exported from `@angular/platform-browser`.
 
 ## Serialization strategy decision guide
 
-| Payload type                         | Recommended serializer                 | Reason                      |
-| ------------------------------------ | -------------------------------------- | --------------------------- |
-| Simple objects, arrays of primitives | `structuredCloneSerializer` (default)  | Zero overhead               |
-| Objects with `Date`, `Map`, `Set`    | `createSerovalSerializer()`            | Full type fidelity          |
-| Unknown payload shape                | `createAutoSerializer()`               | Depth-1 auto-detect         |
-| Large arrays (> 100 KiB)             | `createAutoSerializer()`               | Auto ArrayBuffer transfer   |
-| Deeply nested complex types          | `createSerovalSerializer()` explicitly | Auto-detect is depth-1 only |
+| Payload type                               | Recommended serializer                 | Reason                      |
+| ------------------------------------------ | -------------------------------------- | --------------------------- |
+| Simple objects, arrays of primitives       | `structuredCloneSerializer` (default)  | Zero overhead               |
+| Uniform array of plain objects (≥ 5 items) | `createToonSerializer()`               | 30–60% size reduction       |
+| Objects with `Date`, `Map`, `Set`          | `createSerovalSerializer()`            | Full type fidelity          |
+| Unknown payload shape                      | `createAutoSerializer()`               | Depth-1 auto-detect         |
+| Large arrays (> 100 KiB)                   | `createAutoSerializer()`               | Auto ArrayBuffer transfer   |
+| Deeply nested complex types                | `createSerovalSerializer()` explicitly | Auto-detect is depth-1 only |
 
 ---
 
@@ -701,9 +788,12 @@ Server-Side Rendering (SSR) is supported via automatic fallback to the main thre
 
 ## Benchmarks
 
-A reproducible benchmark suite ships with the demo app at
-[`/demo/worker-http-benchmark`](../../src/app/demo/worker-http-benchmark) and compares three
-transport modes across four workloads:
+A reproducible benchmark suite ships with the demo app at [`/demo/worker-http-benchmark`](../../src/app/demo/worker-http-benchmark).
+
+<details>
+<summary><strong>Modes, workloads, metrics, and how to run</strong></summary>
+
+It compares three transport modes across four workloads:
 
 | Mode            | What it measures                                           |
 | --------------- | ---------------------------------------------------------- |
@@ -739,6 +829,8 @@ npm start
 Numbers vary by hardware, browser, and current system load — always run a scenario several times
 and watch the trend, not a single value.
 
+</details>
+
 ---
 
 ## Related documentation

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

@@ -71,6 +71,138 @@ async function createSerovalSerializer() {
     };
 }
 
+let cachedToon = null;
+async function loadToon() {
+    if (!cachedToon) {
+        try {
+            // Dynamic import via variable — keeps @toon-format/toon as optional peer dep (no static reference)
+            const id = '@toon-format/toon';
+            cachedToon = (await import(/* @vite-ignore */ id));
+        }
+        catch {
+            throw new Error('@toon-format/toon is required as a peer dependency. ' +
+                'Install it with: npm install @toon-format/toon');
+        }
+    }
+    return cachedToon;
+}
+/**
+ * Creates a `WorkerSerializer` backed by `@toon-format/toon` (Token-Oriented Object Notation).
+ *
+ * TOON is a compact, schema-aware encoding of the JSON data model that declares object
+ * keys once and emits values as CSV-like rows. It typically reduces size by **30–60%**
+ * for uniform arrays of objects (e.g. `User[]`, `Product[]`, paginated lists), with
+ * negligible parsing overhead.
+ *
+ * **When to use it**:
+ * - Worker↔main `postMessage` payloads dominated by uniform arrays of objects
+ * - Cases where `structuredClone` cost is dominated by repeated key strings
+ *
+ * **When NOT to use it**:
+ * - Payloads containing `Date`, `Map`, `Set`, `RegExp` (use `seroval` instead)
+ * - Small / single-object payloads (overhead not justified)
+ *
+ * The factory is async because it dynamically imports the optional `@toon-format/toon` peer.
+ *
+ * `@toon-format/toon` must be installed separately:
+ * ```
+ * npm install @toon-format/toon
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const serializer = await createToonSerializer();
+ * const payload = serializer.serialize([
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ *   { id: 3, name: 'Carol' },
+ *   { id: 4, name: 'Dave' },
+ *   { id: 5, name: 'Eve' },
+ * ]);
+ * worker.postMessage({ payload }, payload.transferables);
+ * ```
+ *
+ * @see https://toonformat.dev
+ */
+async function createToonSerializer() {
+    const { encode, decode } = await loadToon();
+    return {
+        serialize(data) {
+            return {
+                data: encode(data),
+                transferables: [],
+                format: 'toon',
+            };
+        },
+        deserialize(payload) {
+            if (payload.format !== 'toon') {
+                throw new Error(`Expected format 'toon', got '${payload.format}'`);
+            }
+            return decode(payload.data);
+        },
+    };
+}
+/**
+ * Conservative threshold below which TOON's overhead outweighs its size benefit.
+ * Auto-serializer keeps shorter arrays on `structured-clone`.
+ *
+ * Exported for testing and for consumers building custom routing logic.
+ */
+const MIN_UNIFORM_ARRAY_LENGTH = 5;
+/**
+ * Detects whether a value is a depth-1 uniform array of plain objects with primitive values.
+ *
+ * Pure function — no side effects. Used by `createAutoSerializer()` to decide
+ * whether to route a payload through TOON.
+ *
+ * Conditions checked (all must pass):
+ * 1. Value is an array with `length >= MIN_UNIFORM_ARRAY_LENGTH`
+ * 2. Every item is a non-null, non-array plain object
+ * 3. Every item has the same set of keys as the first item
+ * 4. Every value across all items is a primitive (string, number, boolean, null)
+ *
+ * @example
+ * ```typescript
+ * isUniformObjectArray([{a:1},{a:2},{a:3},{a:4},{a:5}]); // true
+ * isUniformObjectArray([{a:1},{b:2}]);                    // false (heterogeneous keys)
+ * isUniformObjectArray([{a:[1,2]},{a:[3,4]}]);            // false (nested array value)
+ * isUniformObjectArray([{a:1}]);                          // false (length < 5)
+ * ```
+ */
+function isUniformObjectArray(value) {
+    if (!Array.isArray(value) || value.length < MIN_UNIFORM_ARRAY_LENGTH) {
+        return false;
+    }
+    const first = value[0];
+    if (first === null || typeof first !== 'object' || Array.isArray(first)) {
+        return false;
+    }
+    const expectedKeys = Object.keys(first)
+        .sort()
+        .join('\u0000');
+    if (expectedKeys === '') {
+        return false;
+    }
+    for (const item of value) {
+        if (item === null || typeof item !== 'object' || Array.isArray(item)) {
+            return false;
+        }
+        const record = item;
+        if (Object.keys(record).sort().join('\u0000') !== expectedKeys) {
+            return false;
+        }
+        for (const v of Object.values(record)) {
+            if (v === null)
+                continue;
+            const t = typeof v;
+            if (t !== 'string' && t !== 'number' && t !== 'boolean') {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 /**
  * Shallow check for complex types at depth-1 that structured-clone cannot preserve.
  * Depth-1 is intentional: fast and predictable. For deeply nested complex types,
@@ -107,9 +239,11 @@ function encodeToTransferable(str) {
  * The factory is async because it pre-loads `seroval` during initialization
  * so the returned serializer methods are fully synchronous (no await in hot path).
  *
- * Strategy selection per `serialize()` call:
- * - Contains `Date`, `Map`, `Set`, or `RegExp` at depth-1 → `seroval` (full fidelity)
- * - Otherwise → structured clone (native, zero overhead)
+ * Strategy selection per `serialize()` call (top-down, first match wins):
+ * 1. Contains `Date`, `Map`, `Set`, or `RegExp` at depth-1 → `seroval` (full fidelity)
+ * 2. Uniform array of plain objects (length ≥ 5, primitive values, identical key set)
+ *    → `toon` (30–60% size reduction)
+ * 3. Otherwise → structured clone (native, zero overhead)
  *
  * Large payloads (> `transferThreshold`, default 100 KiB) are encoded to
  * `ArrayBuffer` and added to `transferables` for zero-copy `postMessage` transfer.
@@ -130,6 +264,13 @@ async function createAutoSerializer(config) {
     catch {
         // seroval not installed — complex types will throw at serialize time with a clear message
     }
+    let toon = null;
+    try {
+        toon = await createToonSerializer();
+    }
+    catch {
+        // @toon-format/toon not installed — uniform arrays will fall back to structured-clone
+    }
     return {
         serialize(data) {
             let payload;
@@ -140,6 +281,9 @@ async function createAutoSerializer(config) {
                 }
                 payload = sv.serialize(data);
             }
+            else if (toon && isUniformObjectArray(data)) {
+                payload = toon.serialize(data);
+            }
             else {
                 payload = structuredCloneSerializer.serialize(data);
             }
@@ -154,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 };
             }
@@ -168,6 +313,13 @@ async function createAutoSerializer(config) {
                 }
                 return sv.deserialize(resolved);
             }
+            if (resolved.format === 'toon') {
+                if (!toon) {
+                    throw new Error('@toon-format/toon is required to deserialize this payload. ' +
+                        'Install it with: npm install @toon-format/toon');
+                }
+                return toon.deserialize(resolved);
+            }
             throw new Error(`Unknown serialization format: '${resolved.format}'`);
         },
     };
@@ -177,4 +329,4 @@ async function createAutoSerializer(config) {
  * Generated bundle index. Do not edit.
  */
 
-export { createAutoSerializer, createSerovalSerializer, structuredCloneSerializer };
+export { MIN_UNIFORM_ARRAY_LENGTH, createAutoSerializer, createSerovalSerializer, createToonSerializer, isUniformObjectArray, structuredCloneSerializer };

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.1.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": {
@@ -76,7 +76,8 @@
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0",
     "rxjs": "^7.0.0",
-    "seroval": "^1.0.0"
+    "seroval": "^1.0.0",
+    "@toon-format/toon": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "@angular/common": {
@@ -88,6 +89,9 @@
     "seroval": {
       "optional": true
     },
+    "@toon-format/toon": {
+      "optional": true
+    },
     "esbuild": {
       "optional": true
     },
@@ -98,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-serializer.d.ts

@@ -63,15 +63,85 @@ declare const structuredCloneSerializer: WorkerSerializer;
  */
 declare function createSerovalSerializer(): Promise<WorkerSerializer>;
 
+/**
+ * Creates a `WorkerSerializer` backed by `@toon-format/toon` (Token-Oriented Object Notation).
+ *
+ * TOON is a compact, schema-aware encoding of the JSON data model that declares object
+ * keys once and emits values as CSV-like rows. It typically reduces size by **30–60%**
+ * for uniform arrays of objects (e.g. `User[]`, `Product[]`, paginated lists), with
+ * negligible parsing overhead.
+ *
+ * **When to use it**:
+ * - Worker↔main `postMessage` payloads dominated by uniform arrays of objects
+ * - Cases where `structuredClone` cost is dominated by repeated key strings
+ *
+ * **When NOT to use it**:
+ * - Payloads containing `Date`, `Map`, `Set`, `RegExp` (use `seroval` instead)
+ * - Small / single-object payloads (overhead not justified)
+ *
+ * The factory is async because it dynamically imports the optional `@toon-format/toon` peer.
+ *
+ * `@toon-format/toon` must be installed separately:
+ * ```
+ * npm install @toon-format/toon
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const serializer = await createToonSerializer();
+ * const payload = serializer.serialize([
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ *   { id: 3, name: 'Carol' },
+ *   { id: 4, name: 'Dave' },
+ *   { id: 5, name: 'Eve' },
+ * ]);
+ * worker.postMessage({ payload }, payload.transferables);
+ * ```
+ *
+ * @see https://toonformat.dev
+ */
+declare function createToonSerializer(): Promise<WorkerSerializer>;
+/**
+ * Conservative threshold below which TOON's overhead outweighs its size benefit.
+ * Auto-serializer keeps shorter arrays on `structured-clone`.
+ *
+ * Exported for testing and for consumers building custom routing logic.
+ */
+declare const MIN_UNIFORM_ARRAY_LENGTH = 5;
+/**
+ * Detects whether a value is a depth-1 uniform array of plain objects with primitive values.
+ *
+ * Pure function — no side effects. Used by `createAutoSerializer()` to decide
+ * whether to route a payload through TOON.
+ *
+ * Conditions checked (all must pass):
+ * 1. Value is an array with `length >= MIN_UNIFORM_ARRAY_LENGTH`
+ * 2. Every item is a non-null, non-array plain object
+ * 3. Every item has the same set of keys as the first item
+ * 4. Every value across all items is a primitive (string, number, boolean, null)
+ *
+ * @example
+ * ```typescript
+ * isUniformObjectArray([{a:1},{a:2},{a:3},{a:4},{a:5}]); // true
+ * isUniformObjectArray([{a:1},{b:2}]);                    // false (heterogeneous keys)
+ * isUniformObjectArray([{a:[1,2]},{a:[3,4]}]);            // false (nested array value)
+ * isUniformObjectArray([{a:1}]);                          // false (length < 5)
+ * ```
+ */
+declare function isUniformObjectArray(value: unknown): boolean;
+
 /**
  * Creates an auto-detecting `WorkerSerializer` that picks the best strategy per payload.
  *
  * The factory is async because it pre-loads `seroval` during initialization
  * so the returned serializer methods are fully synchronous (no await in hot path).
  *
- * Strategy selection per `serialize()` call:
- * - Contains `Date`, `Map`, `Set`, or `RegExp` at depth-1 → `seroval` (full fidelity)
- * - Otherwise → structured clone (native, zero overhead)
+ * Strategy selection per `serialize()` call (top-down, first match wins):
+ * 1. Contains `Date`, `Map`, `Set`, or `RegExp` at depth-1 → `seroval` (full fidelity)
+ * 2. Uniform array of plain objects (length ≥ 5, primitive values, identical key set)
+ *    → `toon` (30–60% size reduction)
+ * 3. Otherwise → structured clone (native, zero overhead)
  *
  * Large payloads (> `transferThreshold`, default 100 KiB) are encoded to
  * `ArrayBuffer` and added to `transferables` for zero-copy `postMessage` transfer.
@@ -85,5 +155,5 @@ declare function createSerovalSerializer(): Promise<WorkerSerializer>;
  */
 declare function createAutoSerializer(config?: AutoSerializerConfig): Promise<WorkerSerializer>;
 
-export { createAutoSerializer, createSerovalSerializer, structuredCloneSerializer };
+export { MIN_UNIFORM_ARRAY_LENGTH, createAutoSerializer, createSerovalSerializer, createToonSerializer, isUniformObjectArray, structuredCloneSerializer };
 export type { AutoSerializerConfig, SerializedPayload, SerializerStrategy, WorkerSerializer };

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 };