@angular-helpers/worker-http 0.2.0 → 0.4.0

package/README.md

@@ -16,13 +16,13 @@ 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()`  | 🔧 In progress |
+| 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 |
 
 ---
 
@@ -313,13 +313,9 @@ const hash = await hasher.hash('SHA-256', data); // → hex string
 
 ---
 
-### `/backend` — Angular `HttpBackend` replacement (in progress)
+### `/backend` — Angular `HttpBackend` replacement
 
-> 🔧 **This entry point is currently in development.**
-
-The goal is a drop-in replacement for Angular's `HttpBackend` that transparently routes requests to the appropriate worker.
-
-**Planned API:**
+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.
 
 ```typescript
 // app.config.ts
@@ -328,34 +324,86 @@ import {
   withWorkerConfigs,
   withWorkerRoutes,
   withWorkerFallback,
+  withWorkerSerialization,
+  withWorkerInterceptors,
 } from '@angular-helpers/worker-http/backend';
+import { createSerovalSerializer } from '@angular-helpers/worker-http/serializer';
+import { workerLogging, workerRetry, workerCache } from '@angular-helpers/worker-http/interceptors';
 
-bootstrapApplication(AppComponent, {
+export const appConfig: ApplicationConfig = {
   providers: [
     provideWorkerHttpClient(
       withWorkerConfigs([
+        {
+          id: 'api',
+          workerUrl: new URL('./workers/api.worker', import.meta.url),
+          maxInstances: 2, // round-robin pool
+        },
         {
           id: 'secure',
           workerUrl: new URL('./workers/secure.worker', import.meta.url),
-          maxInstances: 2,
         },
       ]),
-      withWorkerRoutes([{ pattern: /\/api\/secure\//, worker: 'secure', priority: 10 }]),
-      withWorkerFallback('main-thread'), // SSR-safe fallback
+      withWorkerRoutes([
+        { pattern: /\/api\/secure\//, worker: 'secure', priority: 10 },
+        { pattern: /\/api\//, worker: 'api', priority: 5 },
+      ]),
+      withWorkerFallback('main-thread'), // SSR-safe
+      withWorkerSerialization(createSerovalSerializer()), // optional: complex bodies
+      withWorkerInterceptors([
+        workerLogging(),
+        workerRetry({ maxRetries: 3 }),
+        workerCache({ ttl: 60000 }),
+      ]),
     ),
   ],
-});
+};
 
-// data.service.ts — identical to normal HttpClient usage
+// data.service.ts — WorkerHttpClient is a drop-in for HttpClient
 export class DataService {
-  private http = inject(HttpClient);
+  private http = inject(WorkerHttpClient);
+
+  getUsers() {
+    return this.http.get<User[]>('/api/users'); // auto-routed to 'api' worker
+  }
 
-  getReports() {
-    return this.http.get<Report[]>('/api/secure/reports');
+  getSecureData() {
+    // per-request override via { worker } option or WORKER_TARGET context token
+    return this.http.get('/api/secure/payments', { worker: 'secure' });
   }
 }
+
+// workers/api.worker.ts — runs on a separate OS thread
+import { createConfigurableWorkerPipeline } from '@angular-helpers/worker-http/interceptors';
+
+// The pipeline is built at runtime from the specs configured via
+// `withWorkerInterceptors([...])` in `app.config.ts`. Custom interceptors
+// not covered by the built-in catalogue can be wired in here:
+//
+//   import { registerInterceptor } from '@angular-helpers/worker-http/interceptors';
+//   registerInterceptor('auth-token', (config) => async (req, next) => { ... });
+//
+// then referenced from the main thread with `workerCustom('auth-token', config)`.
+createConfigurableWorkerPipeline();
 ```
 
+If you prefer to keep the pipeline composition inside the worker file, use
+`createWorkerPipeline([interceptors])` instead — it stays available for full
+manual control.
+
+**Features:**
+
+- `provideWorkerHttpClient(...features)` — replaces `provideHttpClient()`; do not use both
+- `withWorkerConfigs(configs)` — register named workers with optional pool size
+- `withWorkerRoutes(routes)` — URL-pattern routing with priority ordering
+- `withWorkerFallback(strategy)` — `'main-thread'` (SSR-safe) or `'error'`
+- `withWorkerSerialization(serializer)` — plug in `createSerovalSerializer()` for complex request bodies (`Date`, `Map`, `Set`)
+- `withWorkerInterceptors(specs | specsByWorker)` — configure the worker-side pipeline from Angular DI; pairs with `createConfigurableWorkerPipeline()` in the worker file
+- `WORKER_TARGET` — `HttpContextToken<string | null>` for per-request worker routing via `HttpContext`
+- `WorkerHttpClient` — `HttpClient` wrapper with optional `{ worker: string }` routing field
+- `WorkerHttpBackend` — the `HttpBackend` implementation (injectable for advanced use)
+- `matchWorkerRoute(url, routes)` — pure utility to test routing rules
+
 ---
 
 ## Design principles
@@ -392,6 +440,48 @@ 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:
+
+| Mode            | What it measures                                           |
+| --------------- | ---------------------------------------------------------- |
+| `main-thread`   | Baseline — the same simulated work runs on the main thread |
+| `worker-pool-1` | Single worker — measures pure transport overhead           |
+| `worker-pool-4` | Four workers — measures the benefit of parallel dispatch   |
+
+Each scenario simulates identical "server" work (synchronous CPU burn + async delay + payload
+generation), so the only variable being compared is **where** the work runs.
+
+**Workloads**:
+
+- 100 small sequential requests — pure transport overhead
+- 1 large response (10MB) — serialization / structured clone cost
+- 50 parallel requests — pool benefit
+- 20 parallel requests + 500ms main-thread CPU burn — real-world jank case
+
+**Metrics collected**:
+
+- **Long Tasks** (`PerformanceObserver` / `longtask`) — count and total duration (Chromium-only)
+- **Dropped frames** (`requestAnimationFrame` deltas > 25 ms) — visible jank proxy, works in every browser
+- **Wall-clock total** for the scenario
+- **Success / failure** counts
+
+To run locally:
+
+```bash
+npm run build:workers
+npm start
+# open https://localhost:4200/demo/worker-http-benchmark
+```
+
+Numbers vary by hardware, browser, and current system load — always run a scenario several times
+and watch the trend, not a single value.
+
+---
+
 ## Related documentation
 
 - [Architecture & Feasibility Study](../../docs/sdd-angular-http-web-workers.md)

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

@@ -1,3 +1,431 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, makeEnvironmentProviders } from '@angular/core';
+import { HttpContextToken, HttpHeaders, HttpResponse, HttpBackend, FetchBackend, HttpErrorResponse, HttpClient, HttpContext, provideHttpClient, withFetch } from '@angular/common/http';
+import { throwError } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import { createWorkerTransport } from '@angular-helpers/worker-http/transport';
+
+/**
+ * Per-request HttpContextToken that carries the target worker ID.
+ *
+ * `null` → use URL-pattern auto-routing (or main-thread fallback if no route matches).
+ *
+ * @example
+ * ```typescript
+ * // With WorkerHttpClient (recommended)
+ * this.http.get('/api/data', { worker: 'secure' });
+ *
+ * // With standard HttpClient (power user)
+ * this.http.get('/api/data', {
+ *   context: new HttpContext().set(WORKER_TARGET, 'secure'),
+ * });
+ * ```
+ */
+const WORKER_TARGET = new HttpContextToken(() => null);
+/**
+ * Registered worker definitions provided via `withWorkerConfigs()`.
+ */
+const WORKER_HTTP_CONFIGS_TOKEN = new InjectionToken('WorkerHttpConfigs', {
+    factory: () => [],
+});
+/**
+ * URL-pattern routing rules provided via `withWorkerRoutes()`.
+ */
+const WORKER_HTTP_ROUTES_TOKEN = new InjectionToken('WorkerHttpRoutes', {
+    factory: () => [],
+});
+/**
+ * Fallback strategy provided via `withWorkerFallback()`.
+ * Defaults to `'main-thread'` (safe for SSR / unsupported environments).
+ */
+const WORKER_HTTP_FALLBACK_TOKEN = new InjectionToken('WorkerHttpFallback', { factory: () => 'main-thread' });
+/**
+ * Optional serializer for crossing the worker boundary.
+ * Provided via `withWorkerSerialization()`. Defaults to `null` (structured clone).
+ *
+ * When set, `WorkerHttpBackend` serializes the request body before `postMessage`
+ * using this serializer. The worker-side `createWorkerPipeline()` receives the
+ * serialized form — add a worker interceptor to deserialize it if needed.
+ */
+const WORKER_HTTP_SERIALIZER_TOKEN = new InjectionToken('WorkerHttpSerializer', { factory: () => null });
+/**
+ * Per-worker interceptor specs provided via `withWorkerInterceptors()`.
+ * Defaults to an empty map (no interceptors).
+ */
+const WORKER_HTTP_INTERCEPTORS_TOKEN = new InjectionToken('WorkerHttpInterceptors', { factory: () => ({}) });
+
+/**
+ * Converts an Angular `HttpRequest` into a structured-clone-safe POJO
+ * that can be sent to a web worker via `postMessage`.
+ *
+ * Notes:
+ * - `urlWithParams` is used so query params embedded via `HttpParams` are included.
+ * - The `context` field is intentionally left empty: `HttpContext` uses class references
+ *   as keys which cannot cross the worker boundary.
+ */
+function toSerializableRequest(req) {
+    const headers = {};
+    for (const name of req.headers.keys()) {
+        headers[name.toLowerCase()] = req.headers.getAll(name) ?? [];
+    }
+    const params = {};
+    for (const name of req.params.keys()) {
+        params[name] = req.params.getAll(name) ?? [];
+    }
+    return {
+        method: req.method,
+        url: req.urlWithParams,
+        headers,
+        params,
+        body: req.body,
+        responseType: req.responseType,
+        withCredentials: req.withCredentials,
+        context: {},
+    };
+}
+/**
+ * Converts a worker `SerializableResponse` back into an Angular `HttpResponse`.
+ */
+function toHttpResponse(res, req) {
+    let headers = new HttpHeaders();
+    for (const [key, values] of Object.entries(res.headers)) {
+        for (const value of values) {
+            headers = headers.append(key, value);
+        }
+    }
+    return new HttpResponse({
+        body: res.body,
+        headers,
+        status: res.status,
+        statusText: res.statusText,
+        url: res.url || req.urlWithParams,
+    });
+}
+/**
+ * Matches a URL against a sorted list of `WorkerRoute` rules.
+ * Rules with higher `priority` are evaluated first.
+ * Returns the matched worker ID or `null` if no rule matches.
+ */
+function matchWorkerRoute(url, routes) {
+    const sorted = [...routes].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    for (const route of sorted) {
+        const pattern = typeof route.pattern === 'string' ? new RegExp(route.pattern) : route.pattern;
+        if (pattern.test(url)) {
+            return route.worker;
+        }
+    }
+    return null;
+}
+
+/**
+ * Angular `HttpBackend` replacement that routes HTTP requests to web workers.
+ *
+ * Registered via `provideWorkerHttpClient()`. Not meant to be used directly.
+ *
+ * Flow per request:
+ * 1. Check SSR: if `Worker` is undefined → fallback strategy
+ * 2. Resolve target worker ID from `WORKER_TARGET` context or URL-pattern routing
+ * 3. Serialize `HttpRequest` → `SerializableRequest` (structured-clone safe)
+ * 4. Dispatch to the worker's `WorkerTransport`
+ * 5. Deserialize `SerializableResponse` → `HttpResponse`
+ */
+class WorkerHttpBackend extends HttpBackend {
+    configs = inject(WORKER_HTTP_CONFIGS_TOKEN);
+    routes = inject(WORKER_HTTP_ROUTES_TOKEN);
+    fallback = inject(WORKER_HTTP_FALLBACK_TOKEN);
+    serializer = inject(WORKER_HTTP_SERIALIZER_TOKEN);
+    interceptorSpecs = inject(WORKER_HTTP_INTERCEPTORS_TOKEN);
+    fetchBackend = inject(FetchBackend, { optional: true });
+    transports = new Map();
+    handle(req) {
+        if (typeof Worker === 'undefined') {
+            return this.handleFallback(req, 'Web Workers are not available in this environment (SSR)');
+        }
+        const workerId = req.context.get(WORKER_TARGET) ?? matchWorkerRoute(req.url, this.routes);
+        if (!workerId) {
+            return this.handleFallback(req, `No worker route matched for URL: ${req.url}`);
+        }
+        const config = this.configs.find((c) => c.id === workerId);
+        if (!config) {
+            return throwError(() => new Error(`[WorkerHttpBackend] Unknown worker id: "${workerId}". ` +
+                `Register it via withWorkerConfigs([{ id: "${workerId}", workerUrl: ... }]).`));
+        }
+        const transport = this.getOrCreateTransport(config);
+        const serializable = toSerializableRequest(req);
+        const body = this.serializer !== null && serializable.body !== null && serializable.body !== undefined
+            ? this.serializer.serialize(serializable.body).data
+            : serializable.body;
+        const payload = body !== serializable.body ? { ...serializable, body } : serializable;
+        return transport.execute(payload).pipe(map((res) => toHttpResponse(res, req)), catchError((err) => throwError(() => new HttpErrorResponse({
+            error: err,
+            status: 0,
+            statusText: 'Worker Error',
+            url: req.urlWithParams,
+        }))));
+    }
+    ngOnDestroy() {
+        for (const transport of this.transports.values()) {
+            transport.terminate();
+        }
+        this.transports.clear();
+    }
+    getOrCreateTransport(config) {
+        const existing = this.transports.get(config.id);
+        if (existing)
+            return existing;
+        const specs = this.resolveSpecsFor(config.id);
+        const transport = createWorkerTransport({
+            workerFactory: () => new Worker(config.workerUrl, { type: 'module' }),
+            maxInstances: config.maxInstances ?? 1,
+            initMessage: specs.length > 0 ? { type: 'init-interceptors', specs } : undefined,
+        });
+        this.transports.set(config.id, transport);
+        return transport;
+    }
+    resolveSpecsFor(workerId) {
+        const wildcard = this.interceptorSpecs['*'] ?? [];
+        const specific = this.interceptorSpecs[workerId] ?? [];
+        if (wildcard.length === 0)
+            return specific;
+        if (specific.length === 0)
+            return wildcard;
+        return [...wildcard, ...specific];
+    }
+    handleFallback(req, reason) {
+        if (this.fallback === 'error' || !this.fetchBackend) {
+            return throwError(() => new Error(`[WorkerHttpBackend] ${reason}`));
+        }
+        return this.fetchBackend.handle(req);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WorkerHttpBackend, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WorkerHttpBackend });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WorkerHttpBackend, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Convenience wrapper over `HttpClient` that adds an optional `{ worker }` field
+ * to every method. Under the hood it sets `WORKER_TARGET` on the `HttpContext` —
+ * the caller never has to touch the context manually.
+ *
+ * Usage is identical to `HttpClient` — just inject `WorkerHttpClient` instead.
+ *
+ * @example
+ * ```typescript
+ * @Injectable({ providedIn: 'root' })
+ * export class DataService {
+ *   private readonly http = inject(WorkerHttpClient);
+ *
+ *   getUsers(): Observable<User[]> {
+ *     return this.http.get<User[]>('/api/users'); // auto-routed by URL pattern
+ *   }
+ *
+ *   getSensitiveReport(): Observable<Report> {
+ *     return this.http.get<Report>('/api/secure/reports', { worker: 'secure' });
+ *   }
+ * }
+ * ```
+ */
+class WorkerHttpClient {
+    http = inject(HttpClient);
+    get(url, options) {
+        return this.http.get(url, this.withWorker(options));
+    }
+    post(url, body, options) {
+        return this.http.post(url, body, this.withWorker(options));
+    }
+    put(url, body, options) {
+        return this.http.put(url, body, this.withWorker(options));
+    }
+    patch(url, body, options) {
+        return this.http.patch(url, body, this.withWorker(options));
+    }
+    delete(url, options) {
+        return this.http.delete(url, this.withWorker(options));
+    }
+    head(url, options) {
+        return this.http.head(url, this.withWorker(options));
+    }
+    withWorker(options) {
+        const { worker = null, context, ...rest } = options ?? {};
+        return {
+            ...rest,
+            context: (context ?? new HttpContext()).set(WORKER_TARGET, worker),
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WorkerHttpClient, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WorkerHttpClient });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WorkerHttpClient, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Sets up the worker HTTP infrastructure and replaces Angular's `HttpBackend`
+ * with `WorkerHttpBackend`.
+ *
+ * Drop-in companion to `provideHttpClient()`. Can be used INSTEAD of it —
+ * `HttpClient` and the full interceptor chain are included automatically.
+ *
+ * @example
+ * ```typescript
+ * // app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideWorkerHttpClient(
+ *       withWorkerConfigs([
+ *         { id: 'public', workerUrl: new URL('./workers/public.worker', import.meta.url) },
+ *       ]),
+ *       withWorkerRoutes([
+ *         { pattern: /\/api\//, worker: 'public', priority: 1 },
+ *       ]),
+ *       withWorkerFallback('main-thread'),
+ *     ),
+ *   ],
+ * };
+ * ```
+ */
+function provideWorkerHttpClient(...features) {
+    const featureProviders = features.flatMap((f) => f.providers);
+    return makeEnvironmentProviders([
+        provideHttpClient(withFetch()),
+        FetchBackend,
+        { provide: HttpBackend, useClass: WorkerHttpBackend },
+        WorkerHttpClient,
+        ...featureProviders,
+    ]);
+}
+/**
+ * Registers worker definitions (id + workerUrl + optional pool size).
+ *
+ * At least one config is required for any request to reach a worker.
+ *
+ * @example
+ * ```typescript
+ * withWorkerConfigs([
+ *   { id: 'public', workerUrl: new URL('./workers/public.worker', import.meta.url) },
+ *   { id: 'secure', workerUrl: new URL('./workers/secure.worker', import.meta.url), maxInstances: 2 },
+ * ])
+ * ```
+ */
+function withWorkerConfigs(configs) {
+    return {
+        kind: 'WorkerConfigs',
+        providers: [{ provide: WORKER_HTTP_CONFIGS_TOKEN, useValue: configs }],
+    };
+}
+/**
+ * Declares URL-pattern → worker routing rules evaluated in priority order.
+ *
+ * When a request URL matches a pattern, the associated worker handles it.
+ * Explicit `WORKER_TARGET` context always takes precedence over routes.
+ *
+ * @example
+ * ```typescript
+ * withWorkerRoutes([
+ *   { pattern: /\/api\/secure\//, worker: 'secure', priority: 10 },
+ *   { pattern: /\/api\//, worker: 'public', priority: 1 },
+ * ])
+ * ```
+ */
+function withWorkerRoutes(routes) {
+    return {
+        kind: 'WorkerRoutes',
+        providers: [{ provide: WORKER_HTTP_ROUTES_TOKEN, useValue: routes }],
+    };
+}
+/**
+ * Sets the fallback strategy when workers are unavailable (SSR, old browsers,
+ * or when no route matches).
+ *
+ * - `'main-thread'` (default) — silently delegates to `FetchBackend`
+ * - `'error'` — throws, forcing explicit handling in the application
+ *
+ * @example
+ * ```typescript
+ * withWorkerFallback('main-thread') // SSR-safe
+ * ```
+ */
+function withWorkerFallback(strategy) {
+    return {
+        kind: 'WorkerFallback',
+        providers: [{ provide: WORKER_HTTP_FALLBACK_TOKEN, useValue: strategy }],
+    };
+}
+/**
+ * Configures a custom serializer for crossing the worker boundary.
+ *
+ * By default `WorkerHttpBackend` relies on the browser's structured clone algorithm
+ * (safe for plain objects, arrays, primitives, `Date`, `ArrayBuffer`).
+ * Use `withWorkerSerialization` when your request bodies contain types that
+ * structured clone cannot handle (e.g. class instances, circular references, `Map`, `Set`).
+ *
+ * **Worker-side note:** The serialized form is what the worker receives as `req.body`.
+ * If you use `createSerovalSerializer` or similar, add a worker-side interceptor
+ * to deserialize the body before calling `fetch()`.
+ *
+ * @example
+ * ```typescript
+ * import { createSerovalSerializer } from '@angular-helpers/worker-http/serializer';
+ *
+ * provideWorkerHttpClient(
+ *   withWorkerConfigs([...]),
+ *   withWorkerSerialization(createSerovalSerializer()),
+ * )
+ * ```
+ */
+function withWorkerSerialization(serializer) {
+    return {
+        kind: 'WorkerSerialization',
+        providers: [{ provide: WORKER_HTTP_SERIALIZER_TOKEN, useValue: serializer }],
+    };
+}
+/**
+ * Configures the worker-side interceptor pipeline from Angular DI.
+ *
+ * Specs are forwarded to each worker via an `init-interceptors` handshake
+ * message posted before any HTTP request. Workers must call
+ * `createConfigurableWorkerPipeline()` to receive and act on the handshake.
+ *
+ * Two shapes are accepted:
+ *  - `WorkerInterceptorSpec[]` — applied to every registered worker
+ *  - `Record<workerId, WorkerInterceptorSpec[]>` — per-worker, with the
+ *    special `'*'` key applied to all workers in addition to the
+ *    worker-specific specs
+ *
+ * @example
+ * ```typescript
+ * provideWorkerHttpClient(
+ *   withWorkerConfigs([{ id: 'api', workerUrl: ... }]),
+ *   withWorkerInterceptors([
+ *     workerLogging(),
+ *     workerRetry({ maxRetries: 3 }),
+ *     workerCache({ ttl: 30_000 }),
+ *   ]),
+ * );
+ * ```
+ *
+ * @example Per-worker specs
+ * ```typescript
+ * withWorkerInterceptors({
+ *   '*': [workerLogging()],
+ *   'secure': [workerHmacSigning({ keyMaterial })],
+ * });
+ * ```
+ */
+function withWorkerInterceptors(specs) {
+    const map = Array.isArray(specs)
+        ? { '*': [...specs] }
+        : specs;
+    return {
+        kind: 'WorkerInterceptors',
+        providers: [{ provide: WORKER_HTTP_INTERCEPTORS_TOKEN, useValue: map }],
+    };
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
+
+export { WORKER_HTTP_INTERCEPTORS_TOKEN, WORKER_HTTP_SERIALIZER_TOKEN, WORKER_TARGET, WorkerHttpBackend, WorkerHttpClient, matchWorkerRoute, provideWorkerHttpClient, toHttpResponse, toSerializableRequest, withWorkerConfigs, withWorkerFallback, withWorkerInterceptors, withWorkerRoutes, withWorkerSerialization };