@angular-helpers/worker-http 0.7.0 → 21.0.0

package/README.md

@@ -16,13 +16,15 @@ On top of that, workers provide a natural isolation boundary for security-sensit
 
 ## Package map
 
-| Entry point                                 | Description                                                      | Status       |
-| ------------------------------------------- | ---------------------------------------------------------------- | ------------ |
-| `@angular-helpers/worker-http/transport`    | Typed RPC bridge, round-robin pool, cancellation                 | ✅ Available |
-| `@angular-helpers/worker-http/serializer`   | Pluggable serialization (structured clone, seroval, auto-detect) | ✅ Available |
-| `@angular-helpers/worker-http/interceptors` | Pure-function interceptor pipeline for workers                   | ✅ Available |
-| `@angular-helpers/worker-http/crypto`       | WebCrypto primitives (HMAC, AES-GCM, SHA hashing)                | ✅ Available |
-| `@angular-helpers/worker-http/backend`      | Angular `HttpBackend` replacement — `provideWorkerHttpClient()`  | ✅ Available |
+| Entry point                                     | Description                                                      | Status       |
+| ----------------------------------------------- | ---------------------------------------------------------------- | ------------ |
+| `@angular-helpers/worker-http/transport`        | Typed RPC bridge, round-robin pool, cancellation                 | ✅ Available |
+| `@angular-helpers/worker-http/serializer`       | Pluggable serialization (structured clone, seroval, auto-detect) | ✅ Available |
+| `@angular-helpers/worker-http/interceptors`     | Pure-function interceptor pipeline for workers                   | ✅ Available |
+| `@angular-helpers/worker-http/crypto`           | WebCrypto primitives (HMAC, AES-GCM, SHA hashing)                | ✅ Available |
+| `@angular-helpers/worker-http/backend`          | Angular `HttpBackend` replacement — `provideWorkerHttpClient()`  | ✅ Available |
+| `@angular-helpers/worker-http/esbuild-plugin`   | esbuild plugin for auto-bundling interceptors into workers       | ✅ Available |
+| `@angular-helpers/worker-http/streams-polyfill` | Safari streams ponyfill for transferable stream support          | ✅ Available |
 
 ---
 
@@ -43,6 +45,43 @@ Angular HttpClient                   createWorkerPipeline([
 
 ---
 
+## Installation
+
+### Quick setup with ng-add
+
+The easiest way to get started is using the Angular CLI schematic:
+
+```bash
+ng add @angular-helpers/worker-http
+```
+
+This will:
+
+1. Install the package
+2. Create a worker file at `src/app/workers/http-api.worker.ts`
+3. Update `tsconfig.json` with webworker lib
+4. Add `provideWorkerHttpClient()` to your `app.config.ts`
+
+**Options:**
+
+```bash
+# Custom worker path
+ng add @angular-helpers/worker-http --workerPath=src/workers/api.worker.ts
+
+# Configure esbuild plugin (for custom build setups)
+ng add @angular-helpers/worker-http --installEsbuildPlugin=true
+```
+
+### Manual installation
+
+```bash
+npm install @angular-helpers/worker-http
+```
+
+Then follow the setup in the `/backend` section below.
+
+---
+
 ## Entry points
 
 ### `/transport` — Typed RPC bridge
@@ -510,6 +549,61 @@ interface WorkerHttpTelemetryEventBase {
 
 ---
 
+### `/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.
+
+```typescript
+// esbuild.config.ts
+import { workerHttpPlugin } from '@angular-helpers/worker-http/esbuild-plugin';
+
+export default {
+  plugins: [
+    workerHttpPlugin({
+      // Explicit interceptors (relative to project root)
+      interceptors: ['./src/interceptors/auth.ts', './src/interceptors/logging.ts'],
+
+      // Or auto-discover all files matching interceptor naming pattern
+      autoDiscover: true,
+    }),
+  ],
+};
+```
+
+**Options:**
+
+| Option         | Type       | Default | Description                                            |
+| -------------- | ---------- | ------- | ------------------------------------------------------ |
+| `interceptors` | `string[]` | `[]`    | Explicit list of interceptor paths to bundle           |
+| `autoDiscover` | `boolean`  | `false` | Scan `src/` for files matching `*interceptor*` pattern |
+
+Discovered interceptors are merged with explicit ones. Test files (`.spec.ts`, `.test.ts`) are automatically excluded.
+
+---
+
+### `/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.
+
+```typescript
+// Enable in your app config (main thread)
+import { withWorkerStreamsPolyfill } from '@angular-helpers/worker-http/backend';
+
+provideWorkerHttpClient(
+  withWorkerConfigs([...]),
+  withWorkerStreamsPolyfill(), // Enable Safari 16-17 compatibility
+);
+```
+
+**When to use:**
+
+- Your app uses `responseType: 'stream'` and targets Safari 16-17
+- You see `DataCloneError` when transferring streams to/from workers
+
+**Bundle impact:** Zero for modern browsers. The polyfill is lazy-loaded only on affected Safari versions when streams are actually used.
+
+---
+
 ## SSR + hydration
 
 Worker HTTP integrates transparently with Angular SSR. The two problems SSR

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

@@ -62,6 +62,15 @@ const WORKER_HTTP_INTERCEPTORS_TOKEN = new InjectionToken('WorkerHttpInterceptor
  * affects the HTTP request).
  */
 const WORKER_HTTP_TELEMETRY_TOKEN = new InjectionToken('WorkerHttpTelemetry', { factory: () => [] });
+/**
+ * Enable Safari streams polyfill for transferable ReadableStream/TransformStream
+ * support in workers. Provided via `withWorkerStreamsPolyfill()`.
+ * Defaults to `false` (native streams only).
+ *
+ * When enabled, the transport dynamically imports `@angular-helpers/worker-http/streams-polyfill`
+ * on Safari 16-17 to enable stream transfer via postMessage.
+ */
+const WORKER_HTTP_STREAMS_POLYFILL_TOKEN = new InjectionToken('WorkerHttpStreamsPolyfill', { factory: () => false });
 
 /**
  * Converts an Angular `HttpRequest` into a structured-clone-safe POJO
@@ -156,6 +165,7 @@ class WorkerHttpBackend extends HttpBackend {
     interceptorSpecs = inject(WORKER_HTTP_INTERCEPTORS_TOKEN);
     fetchBackend = inject(FetchBackend, { optional: true });
     telemetry = inject(WORKER_HTTP_TELEMETRY_TOKEN);
+    streamsPolyfill = inject(WORKER_HTTP_STREAMS_POLYFILL_TOKEN);
     transports = new Map();
     handle(req) {
         if (typeof Worker === 'undefined') {
@@ -208,6 +218,7 @@ class WorkerHttpBackend extends HttpBackend {
             workerFactory: () => new Worker(config.workerUrl, { type: 'module' }),
             maxInstances: config.maxInstances ?? 1,
             initMessage: specs.length > 0 ? { type: 'init-interceptors', specs } : undefined,
+            streamsPolyfill: this.streamsPolyfill,
         });
         this.transports.set(config.id, transport);
         return transport;
@@ -558,9 +569,38 @@ function withTelemetry(telemetry) {
         providers: [{ provide: WORKER_HTTP_TELEMETRY_TOKEN, useValue: telemetry, multi: true }],
     };
 }
+/**
+ * Enables the Safari streams polyfill for transferable ReadableStream/TransformStream
+ * support in Web Workers.
+ *
+ * Safari 16-17 lacks native transferable streams. When this feature is enabled,
+ * the transport layer dynamically loads a ponyfill that enables stream transfer
+ * via postMessage on affected browsers.
+ *
+ * **When to use:**
+ * - Your application uses `responseType: 'stream'` and targets Safari 16-17
+ * - You see "DataCloneError" when transferring streams to/from workers
+ *
+ * **Bundle impact:** The polyfill is lazy-loaded only on Safari 16-17 when
+ * streams are actually used. Non-Safari browsers and modern Safari pay 0 bytes.
+ *
+ * @example
+ * ```typescript
+ * provideWorkerHttpClient(
+ *   withWorkerConfigs([...]),
+ *   withWorkerStreamsPolyfill(), // Enable for Safari compatibility
+ * )
+ * ```
+ */
+function withWorkerStreamsPolyfill() {
+    return {
+        kind: 'StreamsPolyfill',
+        providers: [{ provide: WORKER_HTTP_STREAMS_POLYFILL_TOKEN, useValue: true }],
+    };
+}
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { WORKER_HTTP_INTERCEPTORS_TOKEN, WORKER_HTTP_SERIALIZER_TOKEN, WORKER_TARGET, WorkerHttpBackend, WorkerHttpClient, matchWorkerRoute, provideWorkerHttpClient, toHttpResponse, toSerializableRequest, withTelemetry, withWorkerConfigs, withWorkerFallback, withWorkerInterceptors, withWorkerRoutes, withWorkerSerialization };
+export { WORKER_HTTP_INTERCEPTORS_TOKEN, WORKER_HTTP_SERIALIZER_TOKEN, WORKER_HTTP_STREAMS_POLYFILL_TOKEN, WORKER_TARGET, WorkerHttpBackend, WorkerHttpClient, matchWorkerRoute, provideWorkerHttpClient, toHttpResponse, toSerializableRequest, withTelemetry, withWorkerConfigs, withWorkerFallback, withWorkerInterceptors, withWorkerRoutes, withWorkerSerialization, withWorkerStreamsPolyfill };

package/fesm2022/angular-helpers-worker-http-esbuild-plugin.mjs

@@ -0,0 +1,170 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/**
+ * esbuild plugin for worker-http that bundles interceptors into worker files.
+ *
+ * This plugin:
+ * 1. Intercepts worker file builds
+ * 2. Discovers interceptor files if autoDiscover is true
+ * 3. Injects interceptor imports into the worker bootstrap
+ * 4. Ensures interceptors are available in the worker's interceptor pipeline
+ *
+ * @param options - Plugin configuration
+ * @returns esbuild Plugin
+ *
+ * @example
+ * ```typescript
+ * import { workerHttpPlugin } from '@angular-helpers/worker-http/esbuild-plugin';
+ *
+ * const config = {
+ *   plugins: [
+ *     workerHttpPlugin({
+ *       autoDiscover: true,
+ *     })
+ *   ]
+ * };
+ * ```
+ */
+function workerHttpPlugin(options = {}) {
+    const { interceptors = [], autoDiscover = false } = options;
+    return {
+        name: 'worker-http',
+        setup(build) {
+            const filter = /\.worker\.(ts|js|mjs)$/;
+            const discoveredInterceptors = [];
+            // Auto-discover interceptors from src directory
+            if (autoDiscover) {
+                const rootDir = build.initialOptions.absWorkingDir ?? process.cwd();
+                discoveredInterceptors.push(...discoverInterceptors(rootDir));
+            }
+            const allInterceptors = [...new Set([...interceptors, ...discoveredInterceptors])];
+            // Intercept worker file loads to inject interceptor imports
+            build.onLoad({ filter }, async (args) => {
+                let contents = await fs.promises.readFile(args.path, 'utf-8');
+                if (allInterceptors.length > 0) {
+                    const importStatements = generateInterceptorImports(allInterceptors, args.path);
+                    contents = injectImports(contents, importStatements);
+                }
+                return {
+                    contents,
+                    loader: 'ts',
+                };
+            });
+        },
+    };
+}
+/**
+ * Discovers interceptor files by scanning src directories.
+ * Looks for files matching interceptor naming patterns
+ * in TypeScript or JavaScript files.
+ */
+function discoverInterceptors(rootDir) {
+    const interceptors = [];
+    const srcDir = path.join(rootDir, 'src');
+    if (!fs.existsSync(srcDir)) {
+        return interceptors;
+    }
+    scanDirectory(srcDir, interceptors, rootDir);
+    return interceptors;
+}
+/**
+ * Recursively scans a directory for interceptor files.
+ */
+function scanDirectory(dir, interceptors, rootDir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // Skip node_modules and dist
+            if (entry.name === 'node_modules' || entry.name === 'dist') {
+                continue;
+            }
+            scanDirectory(fullPath, interceptors, rootDir);
+        }
+        else if (entry.isFile()) {
+            const isInterceptorFile = /interceptor/i.test(entry.name) &&
+                (entry.name.endsWith('.ts') || entry.name.endsWith('.js') || entry.name.endsWith('.mjs')) &&
+                !entry.name.endsWith('.spec.ts') &&
+                !entry.name.endsWith('.test.ts') &&
+                !entry.name.endsWith('.d.ts');
+            if (isInterceptorFile) {
+                // Get relative path from project root
+                const relativePath = path.relative(rootDir, fullPath);
+                interceptors.push('./' + relativePath.replace(/\\/g, '/'));
+            }
+        }
+    }
+}
+/**
+ * Generates import statements for discovered interceptors.
+ * Converts relative paths to valid import specifiers.
+ */
+function generateInterceptorImports(interceptorPaths, workerFilePath) {
+    return interceptorPaths.map((interceptorPath, index) => {
+        // Create a valid identifier from the path
+        const identifier = `interceptor_${index}_${interceptorPath.replace(/[^a-zA-Z0-9]/g, '_')}`;
+        return `import ${identifier} from '${interceptorPath}';`;
+    });
+}
+/**
+ * Injects import statements at the top of the worker file.
+ * Preserves any existing imports.
+ */
+function injectImports(contents, importStatements) {
+    if (importStatements.length === 0) {
+        return contents;
+    }
+    const imports = importStatements.join('\n');
+    const marker = '// Auto-injected by worker-http esbuild plugin';
+    // Check if already injected
+    if (contents.includes(marker)) {
+        return contents;
+    }
+    const injection = `${marker}\n${imports}\n`;
+    // Find the first non-comment, non-whitespace line to insert before
+    const lines = contents.split('\n');
+    let insertIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Skip shebang, comments, and empty lines
+        if (line.startsWith('#!') ||
+            line.startsWith('//') ||
+            line.startsWith('/*') ||
+            line.startsWith('*') ||
+            line === '') {
+            insertIndex = i + 1;
+            continue;
+        }
+        break;
+    }
+    lines.splice(insertIndex, 0, injection);
+    return lines.join('\n');
+}
+
+/**
+ * esbuild plugin for @angular-helpers/worker-http
+ *
+ * Automatically bundles worker interceptors and injects them into the worker bootstrap.
+ *
+ * @example
+ * ```typescript
+ * // angular.json custom webpack config
+ * import { workerHttpPlugin } from '@angular-helpers/worker-http/esbuild-plugin';
+ *
+ * export default {
+ *   plugins: [
+ *     workerHttpPlugin({
+ *       interceptors: ['./src/interceptors/auth.ts'],
+ *       autoDiscover: true
+ *     })
+ *   ]
+ * };
+ * ```
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { workerHttpPlugin };

package/fesm2022/angular-helpers-worker-http-streams-polyfill.mjs

@@ -0,0 +1,125 @@
+/**
+ * Detects if the current browser needs the streams ponyfill.
+ *
+ * Safari 16-17 fails to transfer `ReadableStream`/`TransformStream`
+ * to/from Web Workers via `structuredClone` because they lack
+ * the transferable streams implementation.
+ *
+ * @param userAgent - Optional user agent string for testing (defaults to feature detection)
+ * @returns `true` if ponyfill is needed, `false` if native works
+ */
+function needsPolyfill(userAgent) {
+    // If userAgent provided (testing mode), use UA-based detection
+    if (userAgent !== undefined) {
+        return isLegacySafari(userAgent);
+    }
+    // Quick check: if we're not in a browser context, assume no polyfill needed
+    if (typeof ReadableStream === 'undefined') {
+        return false;
+    }
+    try {
+        const rs = new ReadableStream({
+            start(controller) {
+                controller.close();
+            },
+        });
+        // Safari < 18 lacks the transferable streams spec extension
+        // The presence of 'getReader' alone isn't enough — we need to verify
+        // that the stream can be transferred via postMessage
+        const channel = new MessageChannel();
+        let transferable = true;
+        // Try to transfer — this throws on Safari 16-17
+        try {
+            channel.port1.postMessage(rs, [rs]);
+        }
+        catch {
+            transferable = false;
+        }
+        channel.port1.close();
+        channel.port2.close();
+        return !transferable;
+    }
+    catch {
+        // Any error means we should try polyfill
+        return true;
+    }
+}
+/**
+ * User-agent based detection for Safari.
+ * Used as a fast-path before the more expensive transfer test.
+ *
+ * @param userAgent - Optional user agent string (defaults to navigator.userAgent)
+ */
+function isSafari(userAgent) {
+    const ua = userAgent ?? (typeof navigator !== 'undefined' ? navigator.userAgent : '');
+    return /Safari/.test(ua) && !/Chrome/.test(ua) && !/Chromium/.test(ua);
+}
+/**
+ * Check if Safari version is known to need polyfill (< 18).
+ *
+ * @param userAgent - Optional user agent string (defaults to navigator.userAgent)
+ */
+function isLegacySafari(userAgent) {
+    if (!isSafari(userAgent)) {
+        return false;
+    }
+    const ua = userAgent ?? (typeof navigator !== 'undefined' ? navigator.userAgent : '');
+    const match = /Version\/(\d+)/.exec(ua);
+    if (!match) {
+        return false;
+    }
+    const version = Number.parseInt(match[1], 10);
+    return version < 18;
+}
+
+/**
+ * Ponyfill for Web Streams API that supports transfer to/from workers.
+ *
+ * Uses `web-streams-polyfill` internally but only loads it when needed.
+ * This keeps bundle size small for non-Safari browsers.
+ *
+ * @see {@link needsPolyfill} for detection
+ */
+let cachedPonyfill = null;
+/**
+ * Lazily loads the web-streams-polyfill ponyfill.
+ *
+ * @returns Ponyfilled streams or native if not needed
+ */
+async function ponyfillStreams() {
+    if (cachedPonyfill) {
+        return cachedPonyfill;
+    }
+    // Dynamic import to avoid bundling polyfill for non-Safari users
+    const { ReadableStream, TransformStream, WritableStream } = await import('web-streams-polyfill');
+    cachedPonyfill = {
+        ReadableStream,
+        TransformStream,
+        WritableStream,
+    };
+    return cachedPonyfill;
+}
+
+/**
+ * Safari Transferable Streams Ponyfill
+ *
+ * Provides `ReadableStream` and `TransformStream` implementations that support
+ * `structuredClone` transfer to/from Web Workers on Safari 16-17.
+ *
+ * This is a **ponyfill** (not a polyfill) — it does not modify global scope.
+ * Native implementations are re-exported when available.
+ *
+ * Usage:
+ * ```typescript
+ * import '@angular-helpers/worker-http/streams-polyfill';
+ * ```
+ * Or let the transport auto-inject when `safariPolyfill: true` is configured.
+ *
+ * @see {@link detect} for feature detection
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { needsPolyfill, ponyfillStreams };

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

@@ -134,6 +134,8 @@ function createWorkerTransport(config) {
     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() {
         if (config.workerFactory) {
             return config.workerFactory();
@@ -167,6 +169,12 @@ function createWorkerTransport(config) {
         }
         const requestId = crypto.randomUUID();
         return new Observable((subscriber) => {
+            // 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();
             let settled = false;
             let timeoutHandle;
@@ -233,6 +241,26 @@ function createWorkerTransport(config) {
             };
         });
     }
+    /**
+     * 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;
+        }
+        try {
+            const { needsPolyfill, ponyfillStreams } = await import('@angular-helpers/worker-http/streams-polyfill');
+            if (needsPolyfill()) {
+                await ponyfillStreams();
+            }
+            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) {

package/package.json

@@ -1,7 +1,53 @@
 {
   "name": "@angular-helpers/worker-http",
-  "version": "0.7.0",
+  "version": "21.0.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": {
+    ".": {
+      "types": "./types/angular-helpers-worker-http.d.ts",
+      "esm": "./esm/src/index.js",
+      "default": "./fesm2022/angular-helpers-worker-http.mjs"
+    },
+    "./backend": {
+      "types": "./types/angular-helpers-worker-http-backend.d.ts",
+      "esm": "./esm/backend/src/index.js",
+      "default": "./fesm2022/angular-helpers-worker-http-backend.mjs"
+    },
+    "./transport": {
+      "types": "./types/angular-helpers-worker-http-transport.d.ts",
+      "esm": "./esm/transport/src/index.js",
+      "default": "./fesm2022/angular-helpers-worker-http-transport.mjs"
+    },
+    "./interceptors": {
+      "types": "./types/angular-helpers-worker-http-interceptors.d.ts",
+      "esm": "./esm/interceptors/src/index.js",
+      "default": "./fesm2022/angular-helpers-worker-http-interceptors.mjs"
+    },
+    "./crypto": {
+      "types": "./types/angular-helpers-worker-http-crypto.d.ts",
+      "esm": "./esm/crypto/src/index.js",
+      "default": "./fesm2022/angular-helpers-worker-http-crypto.mjs"
+    },
+    "./serializer": {
+      "types": "./types/angular-helpers-worker-http-serializer.d.ts",
+      "esm": "./esm/serializer/src/index.js",
+      "default": "./fesm2022/angular-helpers-worker-http-serializer.mjs"
+    },
+    "./esbuild-plugin": {
+      "types": "./types/angular-helpers-worker-http-esbuild-plugin.d.ts",
+      "esm": "./esm/esbuild-plugin/src/index.js",
+      "default": "./fesm2022/angular-helpers-worker-http-esbuild-plugin.mjs"
+    },
+    "./streams-polyfill": {
+      "types": "./types/angular-helpers-worker-http-streams-polyfill.d.ts",
+      "esm": "./esm/streams-polyfill/src/index.js",
+      "default": "./fesm2022/angular-helpers-worker-http-streams-polyfill.mjs"
+    },
+    "./package.json": {
+      "default": "./package.json"
+    }
+  },
   "keywords": [
     "angular",
     "web-worker",
@@ -41,39 +87,16 @@
     },
     "seroval": {
       "optional": true
-    }
-  },
-  "module": "fesm2022/angular-helpers-worker-http.mjs",
-  "typings": "types/angular-helpers-worker-http.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./types/angular-helpers-worker-http.d.ts",
-      "default": "./fesm2022/angular-helpers-worker-http.mjs"
-    },
-    "./backend": {
-      "types": "./types/angular-helpers-worker-http-backend.d.ts",
-      "default": "./fesm2022/angular-helpers-worker-http-backend.mjs"
-    },
-    "./crypto": {
-      "types": "./types/angular-helpers-worker-http-crypto.d.ts",
-      "default": "./fesm2022/angular-helpers-worker-http-crypto.mjs"
-    },
-    "./interceptors": {
-      "types": "./types/angular-helpers-worker-http-interceptors.d.ts",
-      "default": "./fesm2022/angular-helpers-worker-http-interceptors.mjs"
     },
-    "./serializer": {
-      "types": "./types/angular-helpers-worker-http-serializer.d.ts",
-      "default": "./fesm2022/angular-helpers-worker-http-serializer.mjs"
+    "esbuild": {
+      "optional": true
     },
-    "./transport": {
-      "types": "./types/angular-helpers-worker-http-transport.d.ts",
-      "default": "./fesm2022/angular-helpers-worker-http-transport.mjs"
+    "web-streams-polyfill": {
+      "optional": true
     }
   },
+  "module": "fesm2022/angular-helpers-worker-http.mjs",
+  "typings": "types/angular-helpers-worker-http.d.ts",
   "sideEffects": false,
   "dependencies": {
     "tslib": "^2.3.0"

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

@@ -9,7 +9,7 @@ import { Observable } from 'rxjs';
  * Discriminated union for worker HTTP feature kinds.
  * Mirrors Angular's HttpFeatureKind pattern.
  */
-type WorkerHttpFeatureKind = 'WorkerConfigs' | 'WorkerRoutes' | 'WorkerFallback' | 'WorkerSerialization' | 'WorkerInterceptors' | 'Telemetry';
+type WorkerHttpFeatureKind = 'WorkerConfigs' | 'WorkerRoutes' | 'WorkerFallback' | 'WorkerSerialization' | 'WorkerInterceptors' | 'Telemetry' | 'StreamsPolyfill';
 /**
  * Feature object — mirrors Angular's HttpFeature<K> shape.
  */
@@ -182,6 +182,15 @@ declare const WORKER_HTTP_SERIALIZER_TOKEN: InjectionToken<WorkerSerializer>;
  * Defaults to an empty map (no interceptors).
  */
 declare const WORKER_HTTP_INTERCEPTORS_TOKEN: InjectionToken<Readonly<Record<string, readonly WorkerInterceptorSpec[]>>>;
+/**
+ * Enable Safari streams polyfill for transferable ReadableStream/TransformStream
+ * support in workers. Provided via `withWorkerStreamsPolyfill()`.
+ * Defaults to `false` (native streams only).
+ *
+ * When enabled, the transport dynamically imports `@angular-helpers/worker-http/streams-polyfill`
+ * on Safari 16-17 to enable stream transfer via postMessage.
+ */
+declare const WORKER_HTTP_STREAMS_POLYFILL_TOKEN: InjectionToken<boolean>;
 
 /**
  * Sets up the worker HTTP infrastructure and replaces Angular's `HttpBackend`
@@ -345,6 +354,30 @@ declare function withWorkerInterceptors(specs: readonly WorkerInterceptorSpec[]
  * ```
  */
 declare function withTelemetry(telemetry: WorkerHttpTelemetry): WorkerHttpFeature<'Telemetry'>;
+/**
+ * Enables the Safari streams polyfill for transferable ReadableStream/TransformStream
+ * support in Web Workers.
+ *
+ * Safari 16-17 lacks native transferable streams. When this feature is enabled,
+ * the transport layer dynamically loads a ponyfill that enables stream transfer
+ * via postMessage on affected browsers.
+ *
+ * **When to use:**
+ * - Your application uses `responseType: 'stream'` and targets Safari 16-17
+ * - You see "DataCloneError" when transferring streams to/from workers
+ *
+ * **Bundle impact:** The polyfill is lazy-loaded only on Safari 16-17 when
+ * streams are actually used. Non-Safari browsers and modern Safari pay 0 bytes.
+ *
+ * @example
+ * ```typescript
+ * provideWorkerHttpClient(
+ *   withWorkerConfigs([...]),
+ *   withWorkerStreamsPolyfill(), // Enable for Safari compatibility
+ * )
+ * ```
+ */
+declare function withWorkerStreamsPolyfill(): WorkerHttpFeature<'StreamsPolyfill'>;
 
 /**
  * Angular `HttpBackend` replacement that routes HTTP requests to web workers.
@@ -366,6 +399,7 @@ declare class WorkerHttpBackend extends HttpBackend implements OnDestroy {
     private readonly interceptorSpecs;
     private readonly fetchBackend;
     private readonly telemetry;
+    private readonly streamsPolyfill;
     private readonly transports;
     handle(req: HttpRequest<unknown>): Observable<HttpEvent<unknown>>;
     ngOnDestroy(): void;
@@ -460,5 +494,5 @@ declare function matchWorkerRoute(url: string, routes: Array<{
     priority?: number;
 }>): string | null;
 
-export { WORKER_HTTP_INTERCEPTORS_TOKEN, WORKER_HTTP_SERIALIZER_TOKEN, WORKER_TARGET, WorkerHttpBackend, WorkerHttpClient, matchWorkerRoute, provideWorkerHttpClient, toHttpResponse, toSerializableRequest, withTelemetry, withWorkerConfigs, withWorkerFallback, withWorkerInterceptors, withWorkerRoutes, withWorkerSerialization };
+export { WORKER_HTTP_INTERCEPTORS_TOKEN, WORKER_HTTP_SERIALIZER_TOKEN, WORKER_HTTP_STREAMS_POLYFILL_TOKEN, WORKER_TARGET, WorkerHttpBackend, WorkerHttpClient, matchWorkerRoute, provideWorkerHttpClient, toHttpResponse, toSerializableRequest, withTelemetry, withWorkerConfigs, withWorkerFallback, withWorkerInterceptors, withWorkerRoutes, withWorkerSerialization, withWorkerStreamsPolyfill };
 export type { SerializableRequest, SerializableResponse, WorkerConfig, WorkerFallbackStrategy, WorkerHttpErrorEvent, WorkerHttpFeature, WorkerHttpFeatureKind, WorkerHttpRequestEvent, WorkerHttpResponseEvent, WorkerHttpTelemetry, WorkerHttpTelemetryEventBase, WorkerHttpTransportKind, WorkerInterceptorSpecsMap, WorkerRequestOptions, WorkerRoute };

package/types/angular-helpers-worker-http-esbuild-plugin.d.ts

@@ -0,0 +1,46 @@
+import { Plugin } from 'esbuild';
+
+interface WorkerHttpPluginOptions {
+    /**
+     * Explicit list of interceptor file paths to bundle into the worker.
+     * Paths are relative to project root.
+     * @example ['./src/interceptors/auth.ts', './src/interceptors/logging.ts']
+     */
+    interceptors?: string[];
+    /**
+     * Auto-discover interceptors by scanning src folders for files
+     * matching the interceptor naming pattern.
+     * Discovered interceptors are merged with explicit interceptors list.
+     * @default false
+     */
+    autoDiscover?: boolean;
+}
+/**
+ * esbuild plugin for worker-http that bundles interceptors into worker files.
+ *
+ * This plugin:
+ * 1. Intercepts worker file builds
+ * 2. Discovers interceptor files if autoDiscover is true
+ * 3. Injects interceptor imports into the worker bootstrap
+ * 4. Ensures interceptors are available in the worker's interceptor pipeline
+ *
+ * @param options - Plugin configuration
+ * @returns esbuild Plugin
+ *
+ * @example
+ * ```typescript
+ * import { workerHttpPlugin } from '@angular-helpers/worker-http/esbuild-plugin';
+ *
+ * const config = {
+ *   plugins: [
+ *     workerHttpPlugin({
+ *       autoDiscover: true,
+ *     })
+ *   ]
+ * };
+ * ```
+ */
+declare function workerHttpPlugin(options?: WorkerHttpPluginOptions): Plugin;
+
+export { workerHttpPlugin };
+export type { WorkerHttpPluginOptions };

package/types/angular-helpers-worker-http-streams-polyfill.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Detects if the current browser needs the streams ponyfill.
+ *
+ * Safari 16-17 fails to transfer `ReadableStream`/`TransformStream`
+ * to/from Web Workers via `structuredClone` because they lack
+ * the transferable streams implementation.
+ *
+ * @param userAgent - Optional user agent string for testing (defaults to feature detection)
+ * @returns `true` if ponyfill is needed, `false` if native works
+ */
+declare function needsPolyfill(userAgent?: string): boolean;
+
+/**
+ * Ponyfill for Web Streams API that supports transfer to/from workers.
+ *
+ * Uses `web-streams-polyfill` internally but only loads it when needed.
+ * This keeps bundle size small for non-Safari browsers.
+ *
+ * @see {@link needsPolyfill} for detection
+ */
+interface StreamPonyfillExports {
+    ReadableStream: typeof ReadableStream;
+    TransformStream: typeof TransformStream;
+    WritableStream: typeof WritableStream;
+}
+/**
+ * Lazily loads the web-streams-polyfill ponyfill.
+ *
+ * @returns Ponyfilled streams or native if not needed
+ */
+declare function ponyfillStreams(): Promise<StreamPonyfillExports>;
+
+export { needsPolyfill, ponyfillStreams };
+export type { StreamPonyfillExports };

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

@@ -68,6 +68,14 @@ interface WorkerTransportConfig {
         type: string;
         [key: string]: unknown;
     };
+    /**
+     * Enable Safari streams polyfill for transferable ReadableStream/TransformStream
+     * support. When `true`, the transport lazy-loads the ponyfill on Safari 16-17
+     * to enable stream transfer via postMessage.
+     *
+     * @default false
+     */
+    streamsPolyfill?: boolean;
 }
 /**
  * Message sent from main thread to worker.