@chaos-maker/core 0.3.0 → 0.4.0

package/dist/types/ChaosMaker.d.ts

@@ -1,20 +1,38 @@
 import { ChaosConfig } from './config';
 import { ChaosEvent, ChaosEventType, ChaosEventListener } from './events';
+/**
+ * Global context ChaosMaker patches against. Must expose at minimum `fetch`
+ * (network chaos), and optionally `XMLHttpRequest` / `WebSocket`. In a
+ * browser page this is `window`; in a service worker / dedicated worker
+ * this is `self`. `globalThis` resolves to the correct value in both.
+ */
+export type ChaosTarget = typeof globalThis;
+export interface ChaosMakerOptions {
+    /**
+     * Explicit global to install chaos on. Defaults to `globalThis`, which
+     * resolves correctly in both window and service-worker contexts. Pass
+     * `window` or `self` explicitly only for cross-context testing.
+     */
+    target?: ChaosTarget;
+}
 export declare class ChaosMaker {
     private config;
     private emitter;
     private random;
     private seed;
     private running;
+    private target;
     private originalFetch?;
     private originalXhrSend?;
     private originalXhrOpen?;
     private domObserver?;
     private originalWebSocket?;
     private webSocketHandle?;
+    private originalEventSource?;
+    private eventSourceHandle?;
     /** Shared counters keyed by config rule object reference. Shared across fetch + XHR + WS. */
     private requestCounters;
-    constructor(config: ChaosConfig);
+    constructor(config: ChaosConfig, options?: ChaosMakerOptions);
     /** Get the seed used by this instance. Log this on failure to reproduce exact chaos decisions. */
     getSeed(): number;
     on(type: ChaosEventType | '*', listener: ChaosEventListener): void;

package/dist/types/builder.d.ts

@@ -1,4 +1,4 @@
-import { ChaosConfig, CorruptionStrategy, RequestCountingOptions, WebSocketDirection, WebSocketCorruptionStrategy } from './config';
+import { ChaosConfig, CorruptionStrategy, GraphQLOperationMatcher, RequestCountingOptions, SSECorruptionStrategy, WebSocketDirection, WebSocketCorruptionStrategy } from './config';
 export declare class ChaosConfigBuilder {
     private config;
     constructor(initialConfig?: ChaosConfig);
@@ -33,6 +33,18 @@ export declare class ChaosConfigBuilder {
     }, counting?: RequestCountingOptions): this;
     dropMessagesOnNth(urlPattern: string, direction: WebSocketDirection, n: number): this;
     delayMessagesOnNth(urlPattern: string, direction: WebSocketDirection, delayMs: number, n: number): this;
+    /** Fail every GraphQL request matching `operationName`.
+     *  Defaults `urlPattern` to `'*'`; pass an explicit pattern as the 4th
+     *  argument to scope to a specific endpoint. */
+    failGraphQLOperation(operationName: GraphQLOperationMatcher, statusCode: number, probability: number, urlPattern?: string): this;
+    /** Add `delayMs` of latency to every GraphQL request matching `operationName`. */
+    delayGraphQLOperation(operationName: GraphQLOperationMatcher, delayMs: number, probability: number, urlPattern?: string): this;
+    dropSSE(urlPattern: string, probability: number, eventType?: string, counting?: RequestCountingOptions): this;
+    delaySSE(urlPattern: string, delayMs: number, probability: number, eventType?: string, counting?: RequestCountingOptions): this;
+    corruptSSE(urlPattern: string, strategy: SSECorruptionStrategy, probability: number, eventType?: string, counting?: RequestCountingOptions): this;
+    closeSSE(urlPattern: string, probability: number, opts?: {
+        afterMs?: number;
+    }, counting?: RequestCountingOptions): this;
     /** Set the PRNG seed for reproducible chaos. */
     withSeed(seed: number): this;
     build(): ChaosConfig;

package/dist/types/config.d.ts

@@ -11,37 +11,49 @@ export interface RequestCountingOptions {
     everyNth?: number;
     afterN?: number;
 }
-export interface NetworkFailureConfig extends RequestCountingOptions {
+/** Match a GraphQL operation by name. Applied AFTER `urlPattern` + `methods`
+ *  as an additive filter — never a replacement. Matches against:
+ *  - JSON `operationName` field on POST request bodies, OR
+ *  - the operation name parsed from the `query` field (e.g. `query GetUser { … }`),
+ *  - `?operationName=` query parameter for persisted-query GET requests, OR
+ *  - operation name parsed from `?query=` in GET requests carrying GraphQL text.
+ *
+ *  When the rule has `graphqlOperation` set but the request body cannot be
+ *  parsed (multipart upload, ReadableStream, binary), the rule is skipped and
+ *  a diagnostic event is emitted with `applied: false, reason: 'graphql-body-unparseable'`.
+ *  XHR requests with non-string bodies are treated the same way.
+ *
+ *  - `string` matches the operation name exactly.
+ *  - `RegExp` matches when `.test(operationName)` returns true.
+ */
+export type GraphQLOperationMatcher = string | RegExp;
+/** Common matcher fields shared by every network chaos rule type. */
+export interface NetworkRuleMatchers {
     urlPattern: string;
     methods?: string[];
+    graphqlOperation?: GraphQLOperationMatcher;
+}
+export interface NetworkFailureConfig extends RequestCountingOptions, NetworkRuleMatchers {
     statusCode: number;
     probability: number;
     body?: string;
     statusText?: string;
     headers?: Record<string, string>;
 }
-export interface NetworkLatencyConfig extends RequestCountingOptions {
-    urlPattern: string;
-    methods?: string[];
+export interface NetworkLatencyConfig extends RequestCountingOptions, NetworkRuleMatchers {
     delayMs: number;
     probability: number;
 }
-export interface NetworkAbortConfig extends RequestCountingOptions {
-    urlPattern: string;
-    methods?: string[];
+export interface NetworkAbortConfig extends RequestCountingOptions, NetworkRuleMatchers {
     probability: number;
     timeout?: number;
 }
 export type CorruptionStrategy = 'truncate' | 'malformed-json' | 'empty' | 'wrong-type';
-export interface NetworkCorruptionConfig extends RequestCountingOptions {
-    urlPattern: string;
-    methods?: string[];
+export interface NetworkCorruptionConfig extends RequestCountingOptions, NetworkRuleMatchers {
     probability: number;
     strategy: CorruptionStrategy;
 }
-export interface NetworkCorsConfig extends RequestCountingOptions {
-    urlPattern: string;
-    methods?: string[];
+export interface NetworkCorsConfig extends RequestCountingOptions, NetworkRuleMatchers {
     probability: number;
 }
 export interface NetworkConfig {
@@ -113,10 +125,53 @@ export interface WebSocketConfig {
     corruptions?: WebSocketCorruptConfig[];
     closes?: WebSocketCloseConfig[];
 }
+/** Strategies for corrupting Server-Sent Event payloads.
+ *  All four strategies operate on `event.data` (always a string per the SSE
+ *  spec). Mirrors the fetch / WebSocket corruption shape so the same
+ *  vocabulary applies across protocols.
+ */
+export type SSECorruptionStrategy = 'truncate' | 'malformed-json' | 'empty' | 'wrong-type';
+/** Filter SSE chaos to a specific event type.
+ *  - `'message'` (default in the spec) targets unnamed events fired via
+ *    `onmessage` / `addEventListener('message', …)`.
+ *  - Any other string targets named events dispatched with `event:` lines.
+ *  - `'*'` matches every event regardless of name.
+ */
+export type SSEEventTypeMatcher = string | '*';
+export interface SSEDropConfig extends RequestCountingOptions {
+    urlPattern: string;
+    eventType?: SSEEventTypeMatcher;
+    probability: number;
+}
+export interface SSEDelayConfig extends RequestCountingOptions {
+    urlPattern: string;
+    eventType?: SSEEventTypeMatcher;
+    delayMs: number;
+    probability: number;
+}
+export interface SSECorruptConfig extends RequestCountingOptions {
+    urlPattern: string;
+    eventType?: SSEEventTypeMatcher;
+    strategy: SSECorruptionStrategy;
+    probability: number;
+}
+export interface SSECloseConfig extends RequestCountingOptions {
+    urlPattern: string;
+    /** Delay after `open` before dispatching `error` + closing, in ms. Default 0. */
+    afterMs?: number;
+    probability: number;
+}
+export interface SSEConfig {
+    drops?: SSEDropConfig[];
+    delays?: SSEDelayConfig[];
+    corruptions?: SSECorruptConfig[];
+    closes?: SSECloseConfig[];
+}
 export interface ChaosConfig {
     network?: NetworkConfig;
     ui?: UiConfig;
     websocket?: WebSocketConfig;
+    sse?: SSEConfig;
     /**
      * Seed for Chaos Maker's PRNG.
      *

package/dist/types/events.d.ts

@@ -1,4 +1,4 @@
-export type ChaosEventType = 'network:failure' | 'network:latency' | 'network:abort' | 'network:corruption' | 'network:cors' | 'ui:assault' | 'websocket:drop' | 'websocket:delay' | 'websocket:corrupt' | 'websocket:close';
+export type ChaosEventType = 'network:failure' | 'network:latency' | 'network:abort' | 'network:corruption' | 'network:cors' | 'ui:assault' | 'websocket:drop' | 'websocket:delay' | 'websocket:corrupt' | 'websocket:close' | 'sse:drop' | 'sse:delay' | 'sse:corrupt' | 'sse:close';
 export interface ChaosEvent {
     type: ChaosEventType;
     timestamp: number;
@@ -20,6 +20,12 @@ export interface ChaosEvent {
         closeCode?: number;
         /** WebSocket close reason (for `websocket:close` events). */
         closeReason?: string;
+        /** SSE event type (for `sse:*` events). `'message'` is the spec default. */
+        eventType?: string;
+        /** GraphQL operation name (for `network:*` events when the request was
+         *  detected as a GraphQL operation). Pivot on this to slice events by
+         *  operation in dashboards / assertions. */
+        operationName?: string;
         /** Reason string for diagnostic `applied: false` events. */
         reason?: string;
     };

package/dist/types/graphql.d.ts

@@ -0,0 +1,54 @@
+import type { GraphQLOperationMatcher } from './config';
+/** Result of attempting to extract a GraphQL operation from a request. */
+export type GraphQLExtractResult = {
+    kind: 'not-graphql';
+} | {
+    kind: 'extracted';
+    operationName: string | null;
+} | {
+    kind: 'unparseable';
+};
+/**
+ * Pull the operation name out of a GraphQL `query` string without bringing in
+ * a full GraphQL parser. Matches the first `query|mutation|subscription`
+ * keyword followed by an identifier — the spec form for named operations.
+ * Anonymous operations (`query { … }`) return `null`.
+ */
+export declare function parseOperationFromQueryString(query: string): string | null;
+/**
+ * Identify a request as GraphQL and extract its operation name.
+ *
+ * - `kind: 'extracted'` — request is GraphQL; `operationName` may be `null`
+ *   for anonymous operations.
+ * - `kind: 'not-graphql'` — not a GraphQL request (no body, wrong shape).
+ * - `kind: 'unparseable'` — looks like it could be GraphQL but the body is in
+ *   a form we can't read (multipart upload, ReadableStream, binary). Callers
+ *   that have a `graphqlOperation` matcher must skip the rule and emit a
+ *   diagnostic event so the user can debug why their rule isn't firing.
+ */
+export declare function extractGraphQLOperation(method: string, url: string, bodyText: string | null, bodyUnparseable: boolean): GraphQLExtractResult;
+/** Decide whether a rule's `graphqlOperation` matcher accepts the extracted name.
+ *
+ *  Defensive `lastIndex` reset: validation rejects `/g` and `/y` flags up-front,
+ *  but matchers can also be constructed dynamically (in-page, after deserialization),
+ *  so reset here too — `RegExp.test()` mutates `lastIndex` for stateful flags
+ *  and would flap match outcomes across consecutive calls with the same instance.
+ */
+export declare function operationNameMatches(matcher: GraphQLOperationMatcher, operationName: string | null): boolean;
+/** Outcome of evaluating a rule's `graphqlOperation` matcher against a request. */
+export type GraphQLRuleOutcome = {
+    kind: 'skip-no-constraint';
+    operationName: string | null;
+} | {
+    kind: 'match';
+    operationName: string | null;
+} | {
+    kind: 'no-match';
+} | {
+    kind: 'unparseable';
+};
+/**
+ * Evaluate a rule's `graphqlOperation` matcher against the cached extraction.
+ * `extract` is computed once per request and reused across all rules.
+ */
+export declare function evaluateGraphQLRule(matcher: GraphQLOperationMatcher | undefined, extract: GraphQLExtractResult): GraphQLRuleOutcome;

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 import { ChaosMaker } from './ChaosMaker';
-import { ChaosConfig, CorruptionStrategy, NetworkFailureConfig, NetworkLatencyConfig, NetworkAbortConfig, NetworkCorruptionConfig, NetworkCorsConfig, NetworkConfig, UiAssaultConfig, UiConfig, WebSocketConfig, WebSocketDropConfig, WebSocketDelayConfig, WebSocketCorruptConfig, WebSocketCloseConfig, WebSocketDirection, WebSocketCorruptionStrategy } from './config';
+import { ChaosConfig, CorruptionStrategy, GraphQLOperationMatcher, NetworkFailureConfig, NetworkLatencyConfig, NetworkAbortConfig, NetworkCorruptionConfig, NetworkCorsConfig, NetworkConfig, NetworkRuleMatchers, UiAssaultConfig, UiConfig, WebSocketConfig, WebSocketDropConfig, WebSocketDelayConfig, WebSocketCorruptConfig, WebSocketCloseConfig, WebSocketDirection, WebSocketCorruptionStrategy, SSEConfig, SSEDropConfig, SSEDelayConfig, SSECorruptConfig, SSECloseConfig, SSECorruptionStrategy, SSEEventTypeMatcher } from './config';
 import { ChaosConfigError } from './errors';
 import { validateConfig } from './validation';
 import { ChaosEvent, ChaosEventType, ChaosEventListener, ChaosEventEmitter } from './events';
@@ -7,4 +7,8 @@ import { ChaosConfigBuilder } from './builder';
 import { presets } from './presets';
 import { createPrng, generateSeed } from './prng';
 export { ChaosMaker, ChaosConfigError, validateConfig, ChaosEventEmitter, ChaosConfigBuilder, presets, createPrng, generateSeed };
-export type { ChaosConfig, CorruptionStrategy, NetworkFailureConfig, NetworkLatencyConfig, NetworkAbortConfig, NetworkCorruptionConfig, NetworkCorsConfig, NetworkConfig, UiAssaultConfig, UiConfig, WebSocketConfig, WebSocketDropConfig, WebSocketDelayConfig, WebSocketCorruptConfig, WebSocketCloseConfig, WebSocketDirection, WebSocketCorruptionStrategy, ChaosEvent, ChaosEventType, ChaosEventListener };
+export { SW_BRIDGE_SOURCE } from './sw-bridge-source';
+export { extractGraphQLOperation, parseOperationFromQueryString, operationNameMatches } from './graphql';
+export { serializeForTransport, deserializeForTransport } from './transport';
+export type { GraphQLExtractResult, GraphQLRuleOutcome } from './graphql';
+export type { ChaosConfig, CorruptionStrategy, GraphQLOperationMatcher, NetworkFailureConfig, NetworkLatencyConfig, NetworkAbortConfig, NetworkCorruptionConfig, NetworkCorsConfig, NetworkConfig, NetworkRuleMatchers, UiAssaultConfig, UiConfig, WebSocketConfig, WebSocketDropConfig, WebSocketDelayConfig, WebSocketCorruptConfig, WebSocketCloseConfig, WebSocketDirection, WebSocketCorruptionStrategy, SSEConfig, SSEDropConfig, SSEDelayConfig, SSECorruptConfig, SSECloseConfig, SSECorruptionStrategy, SSEEventTypeMatcher, ChaosEvent, ChaosEventType, ChaosEventListener };

package/dist/types/interceptors/eventSource.d.ts

@@ -0,0 +1,41 @@
+/**
+ * EventSource (Server-Sent Events) chaos interceptor.
+ *
+ * Mirrors the WebSocket interceptor's wrapper-constructor strategy: replace
+ * `globalThis.EventSource` with a chaos wrapper that owns a hidden real
+ * `EventSource` instance, intercepts inbound `MessageEvent`s on the capture
+ * phase via `stopImmediatePropagation`, and re-dispatches mutated payloads.
+ *
+ * Design notes:
+ * - SSE is inbound-only (the spec defines no client → server channel beyond
+ *   the initial GET), so direction/payloadType fields are absent vs. WS.
+ * - `event.data` is always a string per the spec — corruption strategies
+ *   reuse the four text strategies from network/WS chaos.
+ * - Counting (onNth/everyNth/afterN) is per-rule, per-event, identical to WS.
+ * - Per-rule ordering on a matched event: drop → corrupt → delay. A dropped
+ *   event short-circuits the rest.
+ * - Close chaos dispatches an `error` event then calls `.close()` on the
+ *   underlying EventSource. Delivery of `error` mirrors what browsers do
+ *   when the upstream connection drops; the app's reconnection logic (if any)
+ *   re-runs the original `new EventSource(url)` path, so a fresh wrapper is
+ *   created and chaos continues.
+ * - On `uninstall()`, every pending delay timer is cleared and an
+ *   `sse:drop` is emitted for it with `reason: 'stop-during-delay'`. Pending
+ *   close timers cancel silently (they had not fired anything yet).
+ */
+import { SSEConfig } from '../config';
+import { ChaosEventEmitter } from '../events';
+export interface EventSourceLikeStatic {
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSED: 2;
+    new (url: string | URL, init?: EventSourceInit): EventSource;
+    prototype: EventSource;
+}
+export interface EventSourcePatchHandle {
+    /** Wrapped EventSource constructor suitable for `globalThis.EventSource = …`. */
+    readonly Wrapped: typeof EventSource;
+    /** Cancel pending timers and disarm wrapped instances. Call on ChaosMaker.stop(). */
+    uninstall(): void;
+}
+export declare function patchEventSource(OriginalEventSource: EventSourceLikeStatic, config: SSEConfig, emitter: ChaosEventEmitter, random: () => number, counters: Map<object, number>): EventSourcePatchHandle;

package/dist/types/interceptors/networkFetch.d.ts

@@ -1,3 +1,3 @@
 import { NetworkConfig } from '../config';
 import { ChaosEventEmitter } from '../events';
-export declare function patchFetch(originalFetch: typeof window.fetch, config: NetworkConfig, random: () => number, emitter?: ChaosEventEmitter, counters?: Map<object, number>): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare function patchFetch(originalFetch: typeof globalThis.fetch, config: NetworkConfig, random: () => number, emitter?: ChaosEventEmitter, counters?: Map<object, number>): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

package/dist/types/interceptors/websocket.d.ts

@@ -2,7 +2,7 @@
  * WebSocket chaos interceptor.
  *
  * Design decisions (see V2_PHASE3_WEBSOCKET_PLAN.md §4, §9):
- * - Patch `window.WebSocket` with a wrapper constructor. Real socket is returned
+ * - Patch `globalThis.WebSocket` with a wrapper constructor. Real socket is returned
  *   so `instanceof WebSocket` continues to work. `.send` is overridden on the
  *   instance; inbound messages are intercepted via a listener installed *before*
  *   user code runs.
@@ -22,7 +22,7 @@
 import { WebSocketConfig } from '../config';
 import { ChaosEventEmitter } from '../events';
 export interface WebSocketPatchHandle {
-    /** Wrapped WebSocket constructor suitable for `window.WebSocket = …`. */
+    /** Wrapped WebSocket constructor suitable for `globalThis.WebSocket = …`. */
     readonly Wrapped: typeof WebSocket;
     /** Clear all pending delay timers and emit drop events for them. Call on ChaosMaker.stop(). */
     uninstall(): void;

package/dist/types/sw-bridge-source.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Browser-side bridge installed into the page by each adapter (Playwright /
+ * Cypress / WDIO / Puppeteer) to talk to the Service-Worker chaos engine.
+ *
+ * This is a string because it is injected via `addInitScript`, `eval` or a
+ * `<script>` tag — *not* imported as a module. Adapters are Node-side, but
+ * this source executes in the AUT window.
+ *
+ * Exposes `window.__chaosMakerSWBridge`:
+ *  - `apply(cfg, timeoutMs)` — post config over MessageChannel, wait for ack.
+ *  - `stop(timeoutMs)` — stop chaos in the SW.
+ *  - `getLocalLog()` / `clearLocalLog()` — page-side buffered event log.
+ *  - `getRemoteLog(timeoutMs)` — fetch SW's in-memory log.
+ *
+ * The bridge auto-wires a `controllerchange` listener so SW updates inherit
+ * the most recent config. Install is idempotent.
+ */
+export declare const SW_BRIDGE_SOURCE = "\n(function installChaosMakerSWBridge() {\n  if (typeof window === 'undefined') return;\n  if (window.__chaosMakerSWBridgeInstalled) return;\n  window.__chaosMakerSWBridgeInstalled = true;\n\n  var log = [];\n  var lastConfig = null;\n\n  function addSwListeners() {\n    if (!('serviceWorker' in navigator)) return;\n    navigator.serviceWorker.addEventListener('message', function (evt) {\n      var data = evt && evt.data;\n      if (data && data.__chaosMakerSWEvent && data.event) {\n        log.push(data.event);\n      }\n    });\n    navigator.serviceWorker.addEventListener('controllerchange', function () {\n      if (lastConfig) {\n        postConfig(lastConfig, 5000).catch(function (err) {\n          try { console.warn('[chaos-maker] re-apply after controllerchange failed', err); } catch (_) {}\n        });\n      }\n    });\n  }\n\n  function waitForController(timeoutMs) {\n    return new Promise(function (resolve, reject) {\n      if (!('serviceWorker' in navigator)) {\n        reject(new Error('[chaos-maker] service worker API not available on this page'));\n        return;\n      }\n      var start = Date.now();\n      (function poll() {\n        if (navigator.serviceWorker.controller) {\n          resolve(navigator.serviceWorker.controller);\n          return;\n        }\n        if (Date.now() - start >= timeoutMs) {\n          reject(new Error('[chaos-maker] no SW controller after ' + timeoutMs + 'ms \u2014 did you register the SW?'));\n          return;\n        }\n        setTimeout(poll, 50);\n      })();\n    });\n  }\n\n  function postViaPort(controller, message, timeoutMs) {\n    return new Promise(function (resolve, reject) {\n      var channel = new MessageChannel();\n      var settled = false;\n      var timer = setTimeout(function () {\n        if (settled) return;\n        settled = true;\n        try { channel.port1.close(); } catch (_) {}\n        reject(new Error('[chaos-maker] SW ack timeout after ' + timeoutMs + 'ms'));\n      }, timeoutMs);\n      channel.port1.onmessage = function (evt) {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        resolve(evt && evt.data);\n      };\n      controller.postMessage(message, [channel.port2]);\n    });\n  }\n\n  function postConfig(cfg, timeoutMs) {\n    return waitForController(timeoutMs).then(function (ctrl) {\n      return postViaPort(ctrl, { __chaosMakerConfig: cfg }, timeoutMs);\n    });\n  }\n\n  window.__chaosMakerSWBridge = {\n    apply: function (cfg, timeoutMs) {\n      // Stash cfg BEFORE awaiting ack \u2014 intentional. If the first ack times\n      // out (e.g. SW still installing), the controllerchange listener above\n      // will retry with this config once the new SW claims the page. Caller\n      // still sees the rejection from this attempt and can re-throw.\n      lastConfig = cfg;\n      return postConfig(cfg, timeoutMs).then(function (ack) {\n        return { seed: ack && typeof ack.seed === 'number' ? ack.seed : null };\n      });\n    },\n    stop: function (timeoutMs) {\n      lastConfig = null;\n      if (!('serviceWorker' in navigator) || !navigator.serviceWorker.controller) {\n        return Promise.resolve({ running: false });\n      }\n      return postViaPort(navigator.serviceWorker.controller, { __chaosMakerStop: true }, timeoutMs);\n    },\n    getLocalLog: function () { return log.slice(); },\n    clearLocalLog: function () { log.length = 0; },\n    getRemoteLog: function (timeoutMs) {\n      if (!('serviceWorker' in navigator) || !navigator.serviceWorker.controller) {\n        return Promise.resolve([]);\n      }\n      return postViaPort(navigator.serviceWorker.controller, { __chaosMakerGetLog: true }, timeoutMs)\n        .then(function (reply) {\n          return (reply && Array.isArray(reply.log)) ? reply.log : [];\n        });\n    },\n  };\n\n  addSwListeners();\n})();\n";

package/dist/types/sw.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Service Worker chaos entry point.
+ *
+ * Loaded into the user's service-worker script (classic `importScripts(…)` or
+ * module-worker `import { installChaosSW }`), this module patches
+ * `self.fetch` + `self.WebSocket` using the same interceptor engine that
+ * powers page-context chaos. Config is delivered from the page via
+ * `postMessage` and acked through a `MessageChannel` transferred by the
+ * adapter helper. Every chaos event is broadcast to controlled clients so
+ * tests can read a unified log on the page side.
+ *
+ * Deliberately excluded from this bundle: Zod validation, UI DOM assailant,
+ * the public `ChaosMaker` class, and the builder — all page-side concerns.
+ * The page-side adapter helpers validate config before postMessage, so the
+ * SW bundle stays small enough to ship to production service workers.
+ */
+import type { ChaosConfig } from './config';
+import type { ChaosEvent } from './events';
+/** Message sent by page → SW to configure chaos. */
+export interface ChaosSWConfigMessage {
+    __chaosMakerConfig: ChaosConfig;
+}
+/** Message sent by page → SW to stop chaos and restore fetch/WebSocket. */
+export interface ChaosSWStopMessage {
+    __chaosMakerStop: true;
+}
+/** Message sent by page → SW to read the accumulated event log. */
+export interface ChaosSWGetLogMessage {
+    __chaosMakerGetLog: true;
+}
+/** Message sent by page → SW to clear the accumulated event log. */
+export interface ChaosSWClearLogMessage {
+    __chaosMakerClearLog: true;
+}
+/** Ack sent SW → port (or broadcast) after a config / stop message lands. */
+export interface ChaosSWAck {
+    __chaosMakerAck: true;
+    seed?: number;
+    running: boolean;
+}
+/** Log payload sent SW → port (or broadcast) in response to getLog. */
+export interface ChaosSWLogReply {
+    __chaosMakerLog: true;
+    log: ChaosEvent[];
+}
+/** Event broadcast SW → all controlled clients for every chaos decision. */
+export interface ChaosSWEventMessage {
+    __chaosMakerSWEvent: true;
+    event: ChaosEvent;
+}
+export interface InstallChaosSWOptions {
+    /**
+     * How the SW receives its chaos config.
+     *
+     * - `'message'` (default) — wait for a `postMessage({ __chaosMakerConfig: … })`
+     *   from the page. Typically paired with a `MessageChannel` for ack.
+     * - `'self-global'` — read `self.__CHAOS_CONFIG__` synchronously. Useful when
+     *   the SW script is served with the config baked in (e.g. query-string).
+     */
+    source?: 'message' | 'self-global';
+    /** Max entries buffered in the SW-side log. Defaults to 2000. */
+    maxLogEntries?: number;
+}
+export interface SWChaosHandle {
+    /** True while a config is installed and `self.fetch` is patched. */
+    isRunning(): boolean;
+    /** Seed used by the active PRNG, or null if no config is installed. */
+    getSeed(): number | null;
+    /** Snapshot of chaos events emitted inside the SW since install. */
+    getLog(): ChaosEvent[];
+    /** Clear the in-SW log buffer. Does not clear already-delivered page-side events. */
+    clearLog(): void;
+    /** Stop chaos + remove the message listener. Restores `self.fetch`. */
+    uninstall(): void;
+}
+/**
+ * Install Service-Worker chaos. Listens for config via `postMessage`,
+ * patches `self.fetch` (and `self.WebSocket` when configured), and
+ * broadcasts every chaos event to all controlled clients so the test
+ * runner's page-side helper can build a unified event log.
+ *
+ * Idempotent: calling more than once returns the existing handle.
+ *
+ * @example Classic SW (typical user integration — one line)
+ * ```js
+ * // user's sw.js
+ * importScripts('/vendor/chaos-maker-sw.js');
+ * ```
+ *
+ * @example Module SW (`type: 'module'`)
+ * ```js
+ * import { installChaosSW } from '@chaos-maker/core/sw';
+ * installChaosSW();
+ * ```
+ */
+export declare function installChaosSW(opts?: InstallChaosSWOptions): SWChaosHandle;
+export type { ChaosConfig, ChaosEvent };

package/dist/types/transport.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Transport-safe (de)serialization for `ChaosConfig` values that may carry
+ * `RegExp` instances.
+ *
+ * Why: every adapter passes config across the Node ↔ browser boundary via a
+ * channel that JSON-encodes its argument (Playwright `addInitScript`,
+ * Puppeteer `evaluateOnNewDocument`, WDIO `JSON.stringify(...)` into a script
+ * tag). `JSON.stringify` collapses `RegExp` to `{}`, which silently breaks
+ * matchers like `graphqlOperation: /^Get/`.
+ *
+ * `serializeForTransport` walks the config and replaces every `RegExp` with a
+ * plain marker object that survives JSON. `deserializeForTransport` reverses
+ * the substitution. Both are pure and structurally recursive — they don't
+ * touch other values.
+ */
+/** Replace every `RegExp` instance in `value` with a JSON-safe marker object.
+ *  Pass through everything else (primitives, arrays, plain objects). */
+export declare function serializeForTransport<T>(value: T): T;
+/** Reconstruct any `RegExp` markers in `value` produced by `serializeForTransport`.
+ *  Idempotent: passing a fully-deserialized value through a second time is a no-op. */
+export declare function deserializeForTransport<T>(value: T): T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaos-maker/core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "A lightweight, framework-agnostic toolkit for injecting chaos into web applications to test frontend resilience",
   "keywords": [
@@ -17,12 +17,12 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jvjithin/chaos-maker.git",
+    "url": "https://github.com/chaos-maker-dev/chaos-maker.git",
     "directory": "packages/core"
   },
-  "homepage": "https://github.com/jvjithin/chaos-maker",
+  "homepage": "https://github.com/chaos-maker-dev/chaos-maker",
   "bugs": {
-    "url": "https://github.com/jvjithin/chaos-maker/issues"
+    "url": "https://github.com/chaos-maker-dev/chaos-maker/issues"
   },
   "engines": {
     "node": ">=18"
@@ -40,6 +40,11 @@
         "types": "./dist/types/index.d.ts",
         "default": "./dist/chaos-maker.cjs"
       }
+    },
+    "./sw": {
+      "types": "./dist/types/sw.d.ts",
+      "import": "./dist/sw.mjs",
+      "default": "./dist/sw.js"
     }
   },
   "files": [
@@ -57,7 +62,7 @@
   },
   "scripts": {
     "dev": "vite build --watch",
-    "build": "vite build && tsc -p tsconfig.build.json",
+    "build": "vite build && vite build -c vite.config.sw.ts && tsc -p tsconfig.build.json",
     "test": "vitest run",
     "test:watch": "vitest"
   }