@angular-helpers/worker-http 21.1.0 → 21.2.0

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';
 
@@ -146,12 +149,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 +291,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 +335,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 +400,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 +445,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 +544,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 +622,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 +659,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 +687,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 +746,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 +762,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 +787,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 +828,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-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);
             }
@@ -168,6 +312,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 +328,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/worker-http",
-  "version": "21.1.0",
+  "version": "21.2.0",
   "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
     },

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