@chaos-maker/core 0.1.0 → 0.2.0

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

@@ -1,3 +1,3 @@
 import { UiConfig } from '../config';
 import { ChaosEventEmitter } from '../events';
-export declare function attachDomAssailant(config: UiConfig, emitter?: ChaosEventEmitter): MutationObserver;
+export declare function attachDomAssailant(config: UiConfig, emitter?: ChaosEventEmitter, random?: () => number): MutationObserver;

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, emitter?: ChaosEventEmitter): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare function patchFetch(originalFetch: typeof window.fetch, config: NetworkConfig, emitter?: ChaosEventEmitter, random?: () => number, counters?: Map<object, number>): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

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

@@ -1,4 +1,4 @@
 import { NetworkConfig } from '../config';
 import { ChaosEventEmitter } from '../events';
-export declare function patchXHR(originalXhrSend: (body?: Document | XMLHttpRequestBodyInit) => void, config: NetworkConfig, emitter?: ChaosEventEmitter): (this: XMLHttpRequest, body?: Document | XMLHttpRequestBodyInit) => void;
+export declare function patchXHR(originalXhrSend: (body?: Document | XMLHttpRequestBodyInit) => void, config: NetworkConfig, emitter?: ChaosEventEmitter, random?: () => number, counters?: Map<object, number>): (this: XMLHttpRequest, body?: Document | XMLHttpRequestBodyInit) => void;
 export declare function patchXHROpen(originalXhrOpen: (method: string, url: string | URL) => void): (this: XMLHttpRequest, method: string, url: string | URL) => void;

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

@@ -0,0 +1,30 @@
+/**
+ * WebSocket chaos interceptor.
+ *
+ * Design decisions (see V2_PHASE3_WEBSOCKET_PLAN.md §4, §9):
+ * - Patch `window.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.
+ * - Ordering of primitives on a matched message: drop → corrupt → delay.
+ *   A dropped message short-circuits the remaining primitives.
+ * - Counting for drop/delay/corrupt is per-rule, per-message. Counting for
+ *   close is per-rule, per-connection.
+ * - On `stop()`, the interceptor flips a `running` flag and cancels every
+ *   pending timer. Any already-wrapped socket is disarmed in place so its
+ *   patched `.send` and inbound listener become no-ops; pending delay timers
+ *   emit `websocket:drop` with `detail.reason: 'stop-during-delay'`; pending
+ *   close timers silently cancel (they never fired a close event).
+ * - Close chaos clears pending-delay timers for the socket before closing.
+ * - Binary corruption runs `truncate` / `empty` natively; `malformed-json` and
+ *   `wrong-type` emit `applied: false` with `reason: 'incompatible-payload-type'`.
+ */
+import { WebSocketConfig } from '../config';
+import { ChaosEventEmitter } from '../events';
+export interface WebSocketPatchHandle {
+    /** Wrapped WebSocket constructor suitable for `window.WebSocket = …`. */
+    readonly Wrapped: typeof WebSocket;
+    /** Clear all pending delay timers and emit drop events for them. Call on ChaosMaker.stop(). */
+    uninstall(): void;
+}
+export declare function patchWebSocket(OriginalWebSocket: typeof WebSocket, config: WebSocketConfig, emitter: ChaosEventEmitter, random: () => number, counters: Map<object, number>): WebSocketPatchHandle;

package/dist/types/prng.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generate a random seed using Math.random().
+ * Returns a 32-bit integer.
+ */
+export declare function generateSeed(): number;
+/**
+ * Create a seedable random number generator.
+ * If no seed is provided, one is auto-generated.
+ *
+ * @returns An object with the `random` function and the `seed` used.
+ */
+export declare function createPrng(seed?: number): {
+    random: () => number;
+    seed: number;
+};

package/dist/types/utils.d.ts

@@ -1,4 +1,16 @@
-import type { CorruptionStrategy } from './config';
-export declare function shouldApplyChaos(probability: number): boolean;
+import type { CorruptionStrategy, RequestCountingOptions } from './config';
+export declare function shouldApplyChaos(probability: number, random?: () => number): boolean;
+/**
+ * Increment the per-rule request counter and return the new count.
+ * Keyed by the rule object reference so the same counter is shared across
+ * fetch and XHR interceptors for a given config entry.
+ */
+export declare function incrementCounter(rule: object, counters: Map<object, number>): number;
+/**
+ * Given a rule with optional counting fields and the current (already-incremented)
+ * request count for that rule, return whether the chaos should fire this request.
+ * Returns `true` when no counting field is set (counting is always opt-in).
+ */
+export declare function checkCountingCondition(rule: RequestCountingOptions, count: number): boolean;
 export declare function matchUrl(url: string, pattern: string): boolean;
 export declare function corruptText(text: string, strategy: CorruptionStrategy): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaos-maker/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "A lightweight, framework-agnostic toolkit for injecting chaos into web applications to test frontend resilience",
   "keywords": [
@@ -52,12 +52,13 @@
     "@vitejs/plugin-basic-ssl": "^1.1.0",
     "jsdom": "^27.0.1",
     "typescript": "^5.4.5",
-    "vite": "^5.3.1",
-    "vitest": "^1.6.0"
+    "vite": "^6.4.2",
+    "vitest": "^3.2.4"
   },
   "scripts": {
     "dev": "vite build --watch",
     "build": "vite build && tsc -p tsconfig.build.json",
-    "test": "vitest"
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
 }