@chaos-maker/core 0.3.0 → 0.5.0

package/dist/sw.mjs

@@ -0,0 +1,1074 @@
+var ce = Object.defineProperty;
+var ie = (n, e, t) => e in n ? ce(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var O = (n, e, t) => ie(n, typeof e != "symbol" ? e + "" : e, t);
+class de {
+  constructor(e = 2e3) {
+    O(this, "listeners", /* @__PURE__ */ new Map());
+    O(this, "log", []);
+    O(this, "logger");
+    O(this, "ruleIds");
+    this.maxLogEntries = e;
+  }
+  on(e, t) {
+    this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(t);
+  }
+  off(e, t) {
+    var o;
+    (o = this.listeners.get(e)) == null || o.delete(t);
+  }
+  emit(e) {
+    this.log.push(e), this.log.length > this.maxLogEntries && this.log.shift(), this.notify(this.listeners.get(e.type), e), this.notify(this.listeners.get("*"), e);
+  }
+  /** Attach a Debug Mode logger. When unset, `debug()` is a fast-path no-op. */
+  setLogger(e) {
+    this.logger = e;
+  }
+  /** Attach the rule-id map so debug events auto-resolve `ruleType` /
+   *  `ruleId` from a rule object reference. */
+  setRuleIds(e) {
+    this.ruleIds = e;
+  }
+  /**
+   * Emit a Debug Mode event. Fast-path no-op when no logger is attached —
+   * single undefined-check before any allocation. When `rule` is supplied
+   * and present in the rule-id map, `detail.ruleType` and `detail.ruleId`
+   * are filled in automatically.
+   */
+  debug(e, t, o) {
+    var f;
+    if (!this.logger) return;
+    const s = o ? (f = this.ruleIds) == null ? void 0 : f.get(o) : void 0, p = s ? { ...t, ruleType: s.ruleType, ruleId: s.ruleId } : t, l = this.logger.log(e, p);
+    l && this.emit(l);
+  }
+  getLog() {
+    return [...this.log];
+  }
+  clearLog() {
+    this.log = [];
+  }
+  notify(e, t) {
+    if (e)
+      for (const o of e)
+        try {
+          o(t);
+        } catch {
+        }
+  }
+}
+function pe(n) {
+  let e = n | 0;
+  return () => {
+    e = e + 1831565813 | 0;
+    let t = Math.imul(e ^ e >>> 15, 1 | e);
+    return t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t, ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function fe() {
+  return Math.random() * 4294967296 >>> 0;
+}
+function re(n) {
+  const e = n ?? fe();
+  return {
+    random: pe(e),
+    seed: e
+  };
+}
+const z = "default";
+class se {
+  constructor() {
+    O(this, "groups", /* @__PURE__ */ new Map());
+    /**
+     * Tracks groups that have already emitted a `rule-group:gated` event since
+     * the last toggle. Cleared on every `setEnabled()` so the next toggle cycle
+     * gets a fresh diagnostic event without flooding.
+     */
+    O(this, "gatedEmitted", /* @__PURE__ */ new Set());
+  }
+  /**
+   * Look up an existing group or create a new one.
+   *
+   * - Implicit (auto-create from `isActive`): `explicit: false`, defaults
+   *   `enabled: true`.
+   * - Explicit (`ChaosConfig.groups` / `createGroup()`): `explicit: true`.
+   *   When called with both `explicit: true` and `enabled` set, the existing
+   *   group's `enabled` is overwritten; the explicit form is the source of truth.
+   */
+  ensure(e, t) {
+    const o = this.groups.get(e);
+    if (o)
+      return t != null && t.explicit && (o.explicit = !0), (t == null ? void 0 : t.enabled) !== void 0 && (o.enabled = t.enabled), o;
+    const s = {
+      name: e,
+      enabled: (t == null ? void 0 : t.enabled) ?? !0,
+      explicit: (t == null ? void 0 : t.explicit) ?? !1
+    };
+    return this.groups.set(e, s), s;
+  }
+  setEnabled(e, t) {
+    this.ensure(e).enabled = t, this.gatedEmitted.clear();
+  }
+  /**
+   * Auto-creates unknown groups on first check (implicit). Rationale:
+   * silently returning `true` for unknown names lets typos like
+   * `group: 'paymets'` mask chaos as if no group existed; auto-registering
+   * surfaces the typo via `list()` / `getSnapshot()` and keeps default-on
+   * backward compat.
+   */
+  isActive(e) {
+    return this.ensure(e ?? z).enabled;
+  }
+  /** True when this group should emit a `rule-group:gated` event right now (first block since last toggle). */
+  shouldEmitGated(e) {
+    return this.gatedEmitted.has(e) ? !1 : (this.gatedEmitted.add(e), !0);
+  }
+  has(e) {
+    return this.groups.has(e);
+  }
+  /**
+   * Remove a group from the registry.
+   * - `'default'` cannot be removed (returns `false`).
+   * - By default, throws when any rule in `referencedBy` still uses the group.
+   * - Pass `{ force: true }` to remove anyway. Subsequent `isActive(name)`
+   *   calls auto-recreate the group (default-on).
+   */
+  remove(e, t, o) {
+    if (e === z) return !1;
+    if (!(o != null && o.force) && t.has(e))
+      throw new Error(
+        `[chaos-maker] Cannot remove group '${e}': still referenced by one or more rules. Pass { force: true } to override.`
+      );
+    const s = this.groups.delete(e);
+    return s && this.gatedEmitted.delete(e), s;
+  }
+  list() {
+    return [...this.groups.values()].map(
+      (e) => ({ ...e })
+    );
+  }
+  getSnapshot() {
+    const e = {};
+    for (const t of this.groups.values()) e[t.name] = t.enabled;
+    return e;
+  }
+}
+function $(n, e) {
+  return e() < n;
+}
+function q(n, e) {
+  const t = (e.get(n) ?? 0) + 1;
+  return e.set(n, t), t;
+}
+function P(n, e) {
+  return n.onNth !== void 0 ? e === n.onNth : n.everyNth !== void 0 ? e % n.everyNth === 0 : n.afterN !== void 0 ? e > n.afterN : !0;
+}
+function Z(n, e) {
+  return e === "*" ? !0 : n.includes(e);
+}
+function ge(n, e) {
+  switch (e) {
+    case "truncate":
+      return n.slice(0, Math.max(0, Math.floor(n.length / 2)));
+    case "malformed-json":
+      return `${n}"}`;
+    case "empty":
+      return "";
+    case "wrong-type":
+      return "<html><body>Unexpected HTML</body></html>";
+  }
+}
+function G(n, e, t, o) {
+  if (!e || e.isActive(n.group)) return !0;
+  const s = n.group ?? z;
+  return e.shouldEmitGated(s) && t && t.emit({
+    type: "rule-group:gated",
+    timestamp: Date.now(),
+    applied: !1,
+    detail: { ...o, groupName: s }
+  }), t == null || t.debug("rule-skip-group", { ...o, groupName: s }, n), !1;
+}
+function he(n, e) {
+  var o, s, p, l, f, u, a, E, x, M, L, A, S, d;
+  const t = (c) => {
+    if (c)
+      for (const i of c) e(i);
+  };
+  t((o = n.network) == null ? void 0 : o.failures), t((s = n.network) == null ? void 0 : s.latencies), t((p = n.network) == null ? void 0 : p.aborts), t((l = n.network) == null ? void 0 : l.corruptions), t((f = n.network) == null ? void 0 : f.cors), t((u = n.ui) == null ? void 0 : u.assaults), t((a = n.websocket) == null ? void 0 : a.drops), t((E = n.websocket) == null ? void 0 : E.delays), t((x = n.websocket) == null ? void 0 : x.corruptions), t((M = n.websocket) == null ? void 0 : M.closes), t((L = n.sse) == null ? void 0 : L.drops), t((A = n.sse) == null ? void 0 : A.delays), t((S = n.sse) == null ? void 0 : S.corruptions), t((d = n.sse) == null ? void 0 : d.closes);
+}
+function ae(n) {
+  const e = n.replace(/#[^\r\n]*/g, " "), t = /\b(?:query|mutation|subscription)\s+([A-Za-z_][A-Za-z0-9_]*)/.exec(e);
+  return (t == null ? void 0 : t[1]) ?? null;
+}
+function be(n) {
+  try {
+    return JSON.parse(n);
+  } catch {
+    return;
+  }
+}
+function ue(n) {
+  if (!n || typeof n != "object") return { isGraphQL: !1, operationName: null };
+  if (Array.isArray(n))
+    return n.length === 0 ? { isGraphQL: !1, operationName: null } : ue(n[0]);
+  const e = n, t = typeof e.query == "string", o = typeof e.operationName == "string";
+  return !t && !o ? { isGraphQL: !1, operationName: null } : o && e.operationName.length > 0 ? { isGraphQL: !0, operationName: e.operationName } : t ? { isGraphQL: !0, operationName: ae(e.query) } : { isGraphQL: !0, operationName: null };
+}
+function ye(n) {
+  let e;
+  try {
+    e = new URL(n, "http://_chaos-maker.invalid");
+  } catch {
+    return { kind: "not-graphql" };
+  }
+  const t = e.searchParams.get("operationName"), o = e.searchParams.get("query");
+  return t && t.length > 0 ? { kind: "extracted", operationName: t } : o && o.length > 0 ? { kind: "extracted", operationName: ae(o) } : { kind: "not-graphql" };
+}
+function ke(n, e, t, o) {
+  const s = n.toUpperCase();
+  if (s === "POST") {
+    if (t !== null) {
+      const p = be(t);
+      if (p === void 0) return { kind: "not-graphql" };
+      const { isGraphQL: l, operationName: f } = ue(p);
+      return l ? { kind: "extracted", operationName: f } : { kind: "not-graphql" };
+    }
+    return o ? { kind: "unparseable" } : { kind: "not-graphql" };
+  }
+  return s === "GET" ? ye(e) : { kind: "not-graphql" };
+}
+function we(n, e) {
+  return e === null ? !1 : typeof n == "string" ? n === e : ((n.global || n.sticky) && (n.lastIndex = 0), n.test(e));
+}
+function Me(n, e) {
+  return n ? e.kind === "not-graphql" ? { kind: "no-match" } : e.kind === "unparseable" ? { kind: "unparseable" } : we(n, e.operationName) ? { kind: "match", operationName: e.operationName } : { kind: "no-match" } : e.kind === "extracted" ? { kind: "skip-no-constraint", operationName: e.operationName } : { kind: "skip-no-constraint", operationName: null };
+}
+function J(n) {
+  return typeof Request < "u" && n instanceof Request;
+}
+function ve(n) {
+  return J(n) ? n.url : n.toString();
+}
+function Ce(n, e) {
+  return e != null && e.method ? e.method.toUpperCase() : J(n) ? n.method.toUpperCase() : "GET";
+}
+function Ee(n, e) {
+  if (e != null && e.signal)
+    return e.signal;
+  if (J(n))
+    return n.signal;
+}
+function Se() {
+  if (typeof DOMException < "u")
+    return new DOMException("The user aborted a request.", "AbortError");
+  const n = new Error("The user aborted a request.");
+  return n.name = "AbortError", n;
+}
+function Te(n, e) {
+  if (!e)
+    return n;
+  const t = new AbortController(), o = (f) => {
+    l(), t.signal.aborted || t.abort(f.reason);
+  }, s = () => o(n), p = () => o(e), l = () => {
+    n.removeEventListener("abort", s), e.removeEventListener("abort", p);
+  };
+  return n.aborted ? (o(n), t.signal) : e.aborted ? (o(e), t.signal) : (n.addEventListener("abort", s, { once: !0 }), e.addEventListener("abort", p, { once: !0 }), t.signal);
+}
+function Le(n, e) {
+  return e ? {
+    ...n ?? {},
+    signal: e
+  } : n;
+}
+async function xe(n, e) {
+  const t = e == null ? void 0 : e.body;
+  if (t != null) {
+    if (typeof t == "string") return { text: t, unparseable: !1 };
+    if (typeof URLSearchParams < "u" && t instanceof URLSearchParams)
+      return { text: t.toString(), unparseable: !1 };
+    if (typeof Blob < "u" && t instanceof Blob) {
+      if (!(t.type === "" || /json|text|graphql/i.test(t.type))) return { text: null, unparseable: !0 };
+      try {
+        return { text: await t.text(), unparseable: !1 };
+      } catch {
+        return { text: null, unparseable: !0 };
+      }
+    }
+    return { text: null, unparseable: !0 };
+  }
+  if (J(n)) {
+    if (n.body === null) return { text: null, unparseable: !1 };
+    try {
+      return { text: await n.clone().text(), unparseable: !1 };
+    } catch {
+      return { text: null, unparseable: !0 };
+    }
+  }
+  return { text: null, unparseable: !1 };
+}
+function U(n, e, t, o, s) {
+  n == null || n.emit({
+    type: e,
+    timestamp: Date.now(),
+    applied: !1,
+    detail: { url: t, method: o, ...s, reason: "graphql-body-unparseable" }
+  });
+}
+function B(n, e, t, o) {
+  if (!Z(e, n.urlPattern)) return { proceed: !1, outcome: null };
+  if (n.methods && !n.methods.includes(t)) return { proceed: !1, outcome: null };
+  const s = Me(n.graphqlOperation, o);
+  return s.kind === "no-match" ? { proceed: !1, outcome: s } : { proceed: !0, outcome: s };
+}
+function W(n) {
+  return n ? n.kind === "match" || n.kind === "skip-no-constraint" ? n.operationName ? { operationName: n.operationName } : {} : {} : {};
+}
+function V(n, e, t, o, s, p) {
+  n == null || n.emit({
+    type: "network:abort",
+    timestamp: Date.now(),
+    applied: s,
+    detail: { url: t, method: o, timeoutMs: e.timeout, ...W(p) }
+  });
+}
+function Q(n, e, t, o, s, p) {
+  n == null || n.emit({
+    type: "network:corruption",
+    timestamp: Date.now(),
+    applied: s,
+    detail: { url: t, method: o, strategy: e.strategy, ...W(p) }
+  });
+}
+function Ae(n) {
+  return n.graphqlOperation !== void 0;
+}
+function Ne(n, e, t, o, s = /* @__PURE__ */ new Map(), p) {
+  return async (l, f) => {
+    var k, w, C, T, R;
+    const u = ve(l), a = Ce(l, f), E = Ee(l, f), x = (() => {
+      const r = [e.failures, e.latencies, e.aborts, e.corruptions, e.cors];
+      for (const b of r)
+        if (b != null && b.some(Ae)) return !0;
+      return !1;
+    })();
+    let M = { kind: "not-graphql" };
+    if (x) {
+      const r = await xe(l, f);
+      M = ke(a, u, r.text, r.unparseable);
+    }
+    if (e.cors)
+      for (const r of e.cors) {
+        o == null || o.debug("rule-evaluating", { url: u, method: a }, r);
+        const b = B(r, u, a, M);
+        if (!b.proceed) {
+          o == null || o.debug("rule-skip-match", { url: u, method: a }, r);
+          continue;
+        }
+        o == null || o.debug("rule-matched", { url: u, method: a }, r);
+        const N = q(r, s);
+        if (!P(r, N)) {
+          o == null || o.debug("rule-skip-counting", { url: u, method: a }, r);
+          continue;
+        }
+        if (!G(r, p, o, { url: u, method: a })) continue;
+        const v = $(r.probability, t);
+        if (((k = b.outcome) == null ? void 0 : k.kind) === "unparseable") {
+          v && U(o, "network:cors", u, a, {});
+          continue;
+        }
+        if (o == null || o.emit({
+          type: "network:cors",
+          timestamp: Date.now(),
+          applied: v,
+          detail: { url: u, method: a, ...W(b.outcome) }
+        }), !v) {
+          o == null || o.debug("rule-skip-probability", { url: u, method: a }, r);
+          continue;
+        }
+        o == null || o.debug("rule-applied", { url: u, method: a }, r);
+        const _ = new TypeError("Failed to fetch");
+        throw _.stack = "", _;
+      }
+    let L = null, A = null, S, d, c = !1;
+    const i = (r) => {
+      !L || c || (c = !0, d && (clearTimeout(d), d = void 0), V(o, L, u, a, r, A));
+    };
+    if (e.aborts)
+      for (const r of e.aborts) {
+        o == null || o.debug("rule-evaluating", { url: u, method: a, timeoutMs: r.timeout }, r);
+        const b = B(r, u, a, M);
+        if (!b.proceed) {
+          o == null || o.debug("rule-skip-match", { url: u, method: a, timeoutMs: r.timeout }, r);
+          continue;
+        }
+        o == null || o.debug("rule-matched", { url: u, method: a, timeoutMs: r.timeout }, r);
+        const N = q(r, s);
+        if (!P(r, N)) {
+          o == null || o.debug("rule-skip-counting", { url: u, method: a, timeoutMs: r.timeout }, r);
+          continue;
+        }
+        if (!G(r, p, o, { url: u, method: a, timeoutMs: r.timeout })) continue;
+        const v = $(r.probability, t);
+        if (((w = b.outcome) == null ? void 0 : w.kind) === "unparseable") {
+          v && U(o, "network:abort", u, a, { timeoutMs: r.timeout });
+          continue;
+        }
+        if (!v) {
+          o == null || o.debug("rule-skip-probability", { url: u, method: a, timeoutMs: r.timeout }, r), V(o, r, u, a, !1, b.outcome);
+          continue;
+        }
+        o == null || o.debug("rule-applied", { url: u, method: a, timeoutMs: r.timeout }, r), console.warn(`CHAOS: Aborting ${a} ${u} after ${r.timeout || 0}ms`), L = r, A = b.outcome;
+        const _ = new AbortController();
+        S = Te(_.signal, E);
+        const H = () => {
+          c || (i(!0), _.abort(Se()));
+        };
+        r.timeout ? d = setTimeout(H, r.timeout) : H();
+        break;
+      }
+    if (L)
+      try {
+        const r = await n(l, Le(f, S));
+        return i(!1), r;
+      } catch (r) {
+        throw i(!1), r;
+      }
+    if (e.failures)
+      for (const r of e.failures) {
+        o == null || o.debug("rule-evaluating", { url: u, method: a, statusCode: r.statusCode }, r);
+        const b = B(r, u, a, M);
+        if (!b.proceed) {
+          o == null || o.debug("rule-skip-match", { url: u, method: a, statusCode: r.statusCode }, r);
+          continue;
+        }
+        o == null || o.debug("rule-matched", { url: u, method: a, statusCode: r.statusCode }, r);
+        const N = q(r, s);
+        if (!P(r, N)) {
+          o == null || o.debug("rule-skip-counting", { url: u, method: a, statusCode: r.statusCode }, r);
+          continue;
+        }
+        if (!G(r, p, o, { url: u, method: a, statusCode: r.statusCode })) continue;
+        const v = $(r.probability, t);
+        if (((C = b.outcome) == null ? void 0 : C.kind) === "unparseable") {
+          v && U(o, "network:failure", u, a, { statusCode: r.statusCode });
+          continue;
+        }
+        if (o == null || o.emit({
+          type: "network:failure",
+          timestamp: Date.now(),
+          applied: v,
+          detail: { url: u, method: a, statusCode: r.statusCode, ...W(b.outcome) }
+        }), !v) {
+          o == null || o.debug("rule-skip-probability", { url: u, method: a, statusCode: r.statusCode }, r);
+          continue;
+        }
+        o == null || o.debug("rule-applied", { url: u, method: a, statusCode: r.statusCode }, r), console.warn(`CHAOS: Forcing ${r.statusCode} for ${a} ${u}`);
+        const _ = r.body ?? JSON.stringify({ error: "Chaos Maker Attack!" }), H = r.headers ?? {};
+        return new Response(_, {
+          status: r.statusCode,
+          statusText: r.statusText ?? "Service Unavailable (Chaos)",
+          headers: H
+        });
+      }
+    if (e.latencies)
+      for (const r of e.latencies) {
+        o == null || o.debug("rule-evaluating", { url: u, method: a, delayMs: r.delayMs }, r);
+        const b = B(r, u, a, M);
+        if (!b.proceed) {
+          o == null || o.debug("rule-skip-match", { url: u, method: a, delayMs: r.delayMs }, r);
+          continue;
+        }
+        o == null || o.debug("rule-matched", { url: u, method: a, delayMs: r.delayMs }, r);
+        const N = q(r, s);
+        if (!P(r, N)) {
+          o == null || o.debug("rule-skip-counting", { url: u, method: a, delayMs: r.delayMs }, r);
+          continue;
+        }
+        if (!G(r, p, o, { url: u, method: a, delayMs: r.delayMs })) continue;
+        const v = $(r.probability, t);
+        if (((T = b.outcome) == null ? void 0 : T.kind) === "unparseable") {
+          v && U(o, "network:latency", u, a, { delayMs: r.delayMs });
+          continue;
+        }
+        if (o == null || o.emit({
+          type: "network:latency",
+          timestamp: Date.now(),
+          applied: v,
+          detail: { url: u, method: a, delayMs: r.delayMs, ...W(b.outcome) }
+        }), !v) {
+          o == null || o.debug("rule-skip-probability", { url: u, method: a, delayMs: r.delayMs }, r);
+          continue;
+        }
+        o == null || o.debug("rule-applied", { url: u, method: a, delayMs: r.delayMs }, r), console.warn(`CHAOS: Adding ${r.delayMs}ms latency to ${a} ${u}`), await new Promise((_) => setTimeout(_, r.delayMs));
+      }
+    let g = null, h = null;
+    if (e.corruptions)
+      for (const r of e.corruptions) {
+        o == null || o.debug("rule-evaluating", { url: u, method: a, strategy: r.strategy }, r);
+        const b = B(r, u, a, M);
+        if (!b.proceed) {
+          o == null || o.debug("rule-skip-match", { url: u, method: a, strategy: r.strategy }, r);
+          continue;
+        }
+        o == null || o.debug("rule-matched", { url: u, method: a, strategy: r.strategy }, r);
+        const N = q(r, s);
+        if (!P(r, N)) {
+          o == null || o.debug("rule-skip-counting", { url: u, method: a, strategy: r.strategy }, r);
+          continue;
+        }
+        if (!G(r, p, o, { url: u, method: a, strategy: r.strategy })) continue;
+        const v = $(r.probability, t);
+        if (((R = b.outcome) == null ? void 0 : R.kind) === "unparseable") {
+          v && U(o, "network:corruption", u, a, { strategy: r.strategy });
+          continue;
+        }
+        if (!v) {
+          o == null || o.debug("rule-skip-probability", { url: u, method: a, strategy: r.strategy }, r), Q(o, r, u, a, !1, b.outcome);
+          continue;
+        }
+        o == null || o.debug("rule-applied", { url: u, method: a, strategy: r.strategy }, r), g = r, h = b.outcome;
+        break;
+      }
+    let y;
+    try {
+      y = await n(l, f);
+    } catch (r) {
+      throw g && Q(o, g, u, a, !1, h), r;
+    }
+    if (!g)
+      return y;
+    try {
+      console.warn(`CHAOS: Corrupting response for ${a} ${u} with strategy: ${g.strategy}`);
+      const r = await y.text(), b = ge(r, g.strategy);
+      return Q(o, g, u, a, !0, h), new Response(b, {
+        status: y.status,
+        statusText: y.statusText,
+        headers: y.headers
+      });
+    } catch (r) {
+      throw Q(o, g, u, a, !1, h), r;
+    }
+  };
+}
+const X = /* @__PURE__ */ Symbol.for("chaos-maker.websocket.intercepted");
+function _e(n, e) {
+  return n === "both" ? !0 : n === e;
+}
+function m(n) {
+  return typeof n == "string" ? "text" : "binary";
+}
+function ee(n, e) {
+  switch (e) {
+    case "truncate":
+      return n.slice(0, Math.max(0, Math.floor(n.length / 2)));
+    case "malformed-json":
+      return `${n}"}`;
+    case "empty":
+      return "";
+    case "wrong-type":
+      return "<html><body>Unexpected HTML</body></html>";
+  }
+}
+function ne(n, e) {
+  if (e === "malformed-json" || e === "wrong-type") return null;
+  if (e === "empty")
+    return typeof Blob < "u" && n instanceof Blob ? new Blob([]) : n instanceof ArrayBuffer ? new ArrayBuffer(0) : new Uint8Array(0);
+  if (typeof Blob < "u" && n instanceof Blob)
+    return n.slice(0, Math.max(0, Math.floor(n.size / 2)));
+  if (n instanceof ArrayBuffer)
+    return n.slice(0, Math.max(0, Math.floor(n.byteLength / 2)));
+  const t = n, o = Math.max(0, Math.floor(t.byteLength / 2));
+  return new Uint8Array(t.buffer.slice(t.byteOffset, t.byteOffset + o));
+}
+function I(n, e, t, o, s, p, l) {
+  if (!n) return null;
+  for (const f of n) {
+    if (l == null || l.debug("rule-evaluating", { url: e, direction: t }, f), !Z(e, f.urlPattern)) {
+      l == null || l.debug("rule-skip-match", { url: e, direction: t }, f);
+      continue;
+    }
+    if (!_e(f.direction, t)) {
+      l == null || l.debug("rule-skip-match", { url: e, direction: t }, f);
+      continue;
+    }
+    l == null || l.debug("rule-matched", { url: e, direction: t }, f);
+    const u = q(f, s);
+    if (!P(f, u)) {
+      l == null || l.debug("rule-skip-counting", { url: e, direction: t }, f);
+      continue;
+    }
+    if (G(f, p, l, { url: e, direction: t })) {
+      if (!$(f.probability, o)) {
+        l == null || l.debug("rule-skip-probability", { url: e, direction: t }, f);
+        continue;
+      }
+      return l == null || l.debug("rule-applied", { url: e, direction: t }, f), f;
+    }
+  }
+  return null;
+}
+function j(n, e, t, o, s) {
+  n.emit({
+    type: "websocket:drop",
+    timestamp: Date.now(),
+    applied: !0,
+    detail: { url: e, direction: t, payloadType: o, ...s ? { reason: s } : {} }
+  });
+}
+function oe(n, e, t, o, s) {
+  n.emit({
+    type: "websocket:delay",
+    timestamp: Date.now(),
+    applied: !0,
+    detail: { url: e, direction: t, payloadType: o, delayMs: s }
+  });
+}
+function D(n, e, t, o, s, p, l) {
+  n.emit({
+    type: "websocket:corrupt",
+    timestamp: Date.now(),
+    applied: p,
+    detail: { url: e, direction: t, payloadType: o, strategy: s, ...l ? { reason: l } : {} }
+  });
+}
+function Re(n, e, t, o) {
+  n.emit({
+    type: "websocket:close",
+    timestamp: Date.now(),
+    applied: !0,
+    detail: { url: e, closeCode: t, closeReason: o }
+  });
+}
+function Oe(n, e, t, o, s, p) {
+  const l = /* @__PURE__ */ new Map();
+  let f = !0;
+  const u = (d, c) => {
+    let i = l.get(d);
+    i || (i = /* @__PURE__ */ new Set(), l.set(d, i)), i.add(c);
+  }, a = (d, c) => {
+    var i;
+    (i = l.get(d)) == null || i.delete(c);
+  }, E = (d, c) => {
+    const i = l.get(d);
+    if (i) {
+      for (const g of i)
+        clearTimeout(g.handle), g.kind === "delay" && j(t, g.url, g.direction, g.payloadType, c);
+      l.delete(d);
+    }
+  }, x = (d, c, i) => {
+    const g = new MessageEvent("message", {
+      data: i,
+      origin: c.origin,
+      lastEventId: c.lastEventId,
+      source: c.source,
+      ports: Array.from(c.ports ?? [])
+    });
+    g[X] = !0, d.dispatchEvent(g);
+  }, M = (d, c, i, g) => {
+    if (!f) return { handled: !1, data: i };
+    const h = "outbound", y = m(i);
+    if (I(e.drops, c, h, o, s, p, t))
+      return j(t, c, h, y), { handled: !0, data: i };
+    let k = i;
+    const w = I(e.corruptions, c, h, o, s, p, t);
+    if (w)
+      if (y === "text")
+        k = ee(k, w.strategy), D(t, c, h, y, w.strategy, !0);
+      else {
+        const T = ne(k, w.strategy);
+        T === null ? D(t, c, h, y, w.strategy, !1, "incompatible-payload-type") : (k = T, D(t, c, h, y, w.strategy, !0));
+      }
+    const C = I(e.delays, c, h, o, s, p, t);
+    if (C) {
+      oe(t, c, h, y, C.delayMs);
+      const T = {
+        kind: "delay",
+        handle: setTimeout(() => {
+          a(d, T);
+          try {
+            g(k);
+          } catch {
+          }
+        }, C.delayMs),
+        url: c,
+        direction: h,
+        payloadType: y
+      };
+      return u(d, T), { handled: !0, data: k };
+    }
+    return { handled: !1, data: k };
+  }, L = (d, c) => {
+    d.addEventListener("message", (i) => {
+      const g = i;
+      if (g[X] || !f) return;
+      const h = "inbound", y = m(g.data);
+      if (I(e.drops, c, h, o, s, p, t)) {
+        g.stopImmediatePropagation(), j(t, c, h, y);
+        return;
+      }
+      let k = g.data, w = !1;
+      const C = I(e.corruptions, c, h, o, s, p, t);
+      if (C)
+        if (y === "text")
+          k = ee(k, C.strategy), w = !0, D(t, c, h, y, C.strategy, !0);
+        else {
+          const R = ne(k, C.strategy);
+          R === null ? D(t, c, h, y, C.strategy, !1, "incompatible-payload-type") : (k = R, w = !0, D(t, c, h, y, C.strategy, !0));
+        }
+      const T = I(e.delays, c, h, o, s, p, t);
+      if (T) {
+        g.stopImmediatePropagation(), oe(t, c, h, y, T.delayMs);
+        const R = {
+          kind: "delay",
+          handle: setTimeout(() => {
+            a(d, R), x(d, g, k);
+          }, T.delayMs),
+          url: c,
+          direction: h,
+          payloadType: y
+        };
+        u(d, R);
+        return;
+      }
+      w && (g.stopImmediatePropagation(), x(d, g, k));
+    });
+  }, A = (d, c) => {
+    if (e.closes)
+      for (const i of e.closes) {
+        if (t.debug("rule-evaluating", { url: c }, i), !Z(c, i.urlPattern)) {
+          t.debug("rule-skip-match", { url: c }, i);
+          continue;
+        }
+        t.debug("rule-matched", { url: c }, i);
+        const g = q(i, s);
+        if (!P(i, g)) {
+          t.debug("rule-skip-counting", { url: c }, i);
+          continue;
+        }
+        if (!G(i, p, t, { url: c })) continue;
+        if (!$(i.probability, o)) {
+          t.debug("rule-skip-probability", { url: c }, i);
+          continue;
+        }
+        t.debug("rule-applied", { url: c }, i);
+        const h = i.code ?? 1e3, y = i.reason ?? "Chaos Maker close", k = i.afterMs ?? 0, w = () => {
+          if (f) {
+            E(d, "close-interrupt"), Re(t, c, h, y);
+            try {
+              d.close(h, y);
+            } catch {
+              try {
+                d.close();
+              } catch {
+              }
+            }
+          }
+        };
+        if (k <= 0)
+          d.readyState === d.OPEN ? w() : d.addEventListener("open", w, { once: !0 });
+        else {
+          const C = () => {
+            const T = {
+              kind: "close",
+              handle: setTimeout(w, k)
+            };
+            u(d, T);
+          };
+          d.readyState === d.OPEN ? C() : d.addEventListener("open", C, { once: !0 });
+        }
+        return;
+      }
+  };
+  function S(d, c) {
+    const i = new n(d, c), g = typeof d == "string" ? d : d.toString(), h = i.send.bind(i);
+    return i.send = function(k) {
+      const w = M(i, g, k, h);
+      w.handled || h(w.data);
+    }, L(i, g), A(i, g), i;
+  }
+  Object.defineProperty(S, "prototype", {
+    value: n.prototype,
+    writable: !1
+  });
+  for (const d of ["CONNECTING", "OPEN", "CLOSING", "CLOSED"])
+    S[d] = n[d];
+  return {
+    Wrapped: S,
+    uninstall() {
+      f = !1;
+      for (const [, d] of l)
+        for (const c of d)
+          clearTimeout(c.handle), c.kind === "delay" && j(t, c.url, c.direction, c.payloadType, "stop-during-delay");
+      l.clear();
+    }
+  };
+}
+function $e(n) {
+  return n === void 0 ? { enabled: !1 } : typeof n == "boolean" ? { enabled: n } : { enabled: n.enabled };
+}
+const qe = [
+  { pick: (n) => {
+    var e;
+    return (e = n.network) == null ? void 0 : e.failures;
+  }, ruleType: "failure" },
+  { pick: (n) => {
+    var e;
+    return (e = n.network) == null ? void 0 : e.latencies;
+  }, ruleType: "latency" },
+  { pick: (n) => {
+    var e;
+    return (e = n.network) == null ? void 0 : e.aborts;
+  }, ruleType: "abort" },
+  { pick: (n) => {
+    var e;
+    return (e = n.network) == null ? void 0 : e.corruptions;
+  }, ruleType: "corruption" },
+  { pick: (n) => {
+    var e;
+    return (e = n.network) == null ? void 0 : e.cors;
+  }, ruleType: "cors" },
+  { pick: (n) => {
+    var e;
+    return (e = n.ui) == null ? void 0 : e.assaults;
+  }, ruleType: "ui-assault" },
+  { pick: (n) => {
+    var e;
+    return (e = n.websocket) == null ? void 0 : e.drops;
+  }, ruleType: "ws-drop" },
+  { pick: (n) => {
+    var e;
+    return (e = n.websocket) == null ? void 0 : e.delays;
+  }, ruleType: "ws-delay" },
+  { pick: (n) => {
+    var e;
+    return (e = n.websocket) == null ? void 0 : e.corruptions;
+  }, ruleType: "ws-corrupt" },
+  { pick: (n) => {
+    var e;
+    return (e = n.websocket) == null ? void 0 : e.closes;
+  }, ruleType: "ws-close" },
+  { pick: (n) => {
+    var e;
+    return (e = n.sse) == null ? void 0 : e.drops;
+  }, ruleType: "sse-drop" },
+  { pick: (n) => {
+    var e;
+    return (e = n.sse) == null ? void 0 : e.delays;
+  }, ruleType: "sse-delay" },
+  { pick: (n) => {
+    var e;
+    return (e = n.sse) == null ? void 0 : e.corruptions;
+  }, ruleType: "sse-corrupt" },
+  { pick: (n) => {
+    var e;
+    return (e = n.sse) == null ? void 0 : e.closes;
+  }, ruleType: "sse-close" }
+];
+function Pe(n) {
+  const e = /* @__PURE__ */ new WeakMap();
+  for (const { pick: t, ruleType: o } of qe) {
+    const s = t(n);
+    s && s.forEach((p, l) => {
+      e.set(p, { ruleType: o, ruleId: `${o}#${l}` });
+    });
+  }
+  return e;
+}
+function Ge(n, e) {
+  const t = [];
+  return e.ruleId && t.push(`rule=${e.ruleId}`), e.phase && t.push(e.phase), e.method && t.push(e.method), e.url && t.push(e.url), e.statusCode !== void 0 && t.push(`-> ${e.statusCode}`), e.delayMs !== void 0 && t.push(`+${e.delayMs}ms`), e.direction && t.push(e.direction), e.eventType && t.push(`event=${e.eventType}`), e.selector && t.push(`selector=${e.selector}`), e.action && t.push(`action=${e.action}`), e.strategy && t.push(`strategy=${e.strategy}`), e.groupName && t.push(`group=${e.groupName}`), e.reason && t.push(`reason=${e.reason}`), t.length === 0 ? n : `${n}: ${t.join(" ")}`;
+}
+class Ie {
+  constructor(e, t = "page") {
+    this.opts = e, this.target = t;
+  }
+  isEnabled() {
+    return this.opts.enabled;
+  }
+  /**
+   * Build a `type: 'debug'` event with `detail.stage = stage`, mirror a
+   * `[Chaos] ...` (page) or `[Chaos SW] ...` (Service Worker) line to
+   * `console.debug`, and return the event for the emitter to fan out. The
+   * formatted string is never stored on the event payload.
+   *
+   * Returns `null` when the logger was constructed with `enabled: false`.
+   * Internal callers (the emitter fast-path) never reach this branch because
+   * `ChaosMaker` does not attach a logger when debug is off, but the guard
+   * keeps the public `Logger` API consistent with the `DebugOptions.enabled`
+   * contract for external consumers who instantiate it directly.
+   */
+  log(e, t) {
+    if (!this.opts.enabled) return null;
+    const o = { ...t, stage: e }, s = {
+      type: "debug",
+      timestamp: Date.now(),
+      applied: !1,
+      detail: o
+    };
+    if (typeof console < "u" && typeof console.debug == "function") {
+      const p = this.target === "sw" ? "[Chaos SW]" : "[Chaos]";
+      try {
+        console.debug(`${p} ${Ge(e, o)}`);
+      } catch {
+      }
+    }
+    return s;
+  }
+}
+const Y = /* @__PURE__ */ Symbol.for("chaos-maker.sw.installed");
+function De() {
+  return typeof self < "u" ? self : typeof globalThis < "u" ? globalThis : null;
+}
+function le(n, e) {
+  const t = n.clients;
+  !t || typeof t.matchAll != "function" || t.matchAll({ includeUncontrolled: !0 }).then((o) => {
+    for (const s of o)
+      try {
+        s.postMessage(e);
+      } catch {
+      }
+  }).catch(() => {
+  });
+}
+function te(n, e) {
+  n.running && K(n);
+  const t = re(e.seed);
+  n.seed = t.seed, n.random = t.random, n.requestCounters = /* @__PURE__ */ new Map(), n.groups = new se();
+  for (const s of e.groups ?? [])
+    n.groups.ensure(s.name, { enabled: s.enabled ?? !0, explicit: !0 });
+  he(e, (s) => {
+    s.group && n.groups.ensure(s.group);
+  }), n.groups.ensure(z, { enabled: !0 });
+  const o = $e(e.debug);
+  if (o.enabled ? (n.emitter.setRuleIds(Pe(e)), n.emitter.setLogger(new Ie(o, "sw"))) : (n.emitter.setRuleIds(void 0), n.emitter.setLogger(void 0)), n.emitter.debug("lifecycle", { phase: "sw:config-applied" }), e.network) {
+    const s = n.target;
+    typeof s.fetch == "function" && (n.originalFetch = s.fetch, s.fetch = Ne(
+      n.originalFetch.bind(s),
+      e.network,
+      n.random,
+      n.emitter,
+      n.requestCounters,
+      n.groups
+    ));
+  }
+  return e.websocket && typeof n.target.WebSocket < "u" && (n.originalWebSocket = n.target.WebSocket, n.webSocketHandle = Oe(
+    n.originalWebSocket,
+    e.websocket,
+    n.emitter,
+    n.random,
+    n.requestCounters,
+    n.groups
+  ), n.target.WebSocket = n.webSocketHandle.Wrapped), n.running = !0, n.seed;
+}
+function K(n) {
+  !n.running && !n.originalFetch && !n.originalWebSocket || (n.originalFetch && (n.target.fetch = n.originalFetch, n.originalFetch = void 0), n.originalWebSocket && (n.target.WebSocket = n.originalWebSocket, n.originalWebSocket = void 0), n.webSocketHandle && (n.webSocketHandle.uninstall(), n.webSocketHandle = void 0), n.emitter.debug("lifecycle", { phase: "sw:config-stopped" }), n.emitter.setLogger(void 0), n.emitter.setRuleIds(void 0), n.running = !1);
+}
+function F(n, e, t) {
+  var s;
+  const o = (s = e.ports) == null ? void 0 : s[0];
+  if (o && typeof o.postMessage == "function")
+    try {
+      o.postMessage(t);
+      return;
+    } catch {
+    }
+  le(n, t);
+}
+function Fe(n = {}) {
+  const e = De(), t = {
+    isRunning: () => !1,
+    getSeed: () => null,
+    getLog: () => [],
+    clearLog: () => {
+    },
+    uninstall: () => {
+    }
+  };
+  if (!e || typeof e.fetch != "function" || typeof e.addEventListener != "function")
+    return t;
+  const o = e[Y];
+  if (o) return o;
+  const s = new de(n.maxLogEntries ?? 2e3), p = re(0), l = {
+    target: e,
+    emitter: s,
+    running: !1,
+    seed: null,
+    random: p.random,
+    requestCounters: /* @__PURE__ */ new Map(),
+    groups: new se()
+  };
+  s.on("*", (a) => {
+    le(e, { __chaosMakerSWEvent: !0, event: a });
+  });
+  const f = (a) => {
+    const E = a, x = E.data;
+    if (!x || typeof x != "object") return;
+    const M = x;
+    if (M.__chaosMakerConfig) {
+      const L = te(l, M.__chaosMakerConfig);
+      F(e, E, {
+        __chaosMakerAck: !0,
+        seed: L,
+        running: l.running
+      });
+      return;
+    }
+    if (M.__chaosMakerStop) {
+      K(l), F(e, E, {
+        __chaosMakerAck: !0,
+        running: !1
+      });
+      return;
+    }
+    if (M.__chaosMakerToggleGroup) {
+      const { name: L, enabled: A } = M.__chaosMakerToggleGroup, S = L.trim();
+      if (!S) {
+        F(e, E, {
+          __chaosMakerAck: !0,
+          running: l.running
+        });
+        return;
+      }
+      l.groups.setEnabled(S, A), l.emitter.emit({
+        type: A ? "rule-group:enabled" : "rule-group:disabled",
+        timestamp: Date.now(),
+        applied: !0,
+        detail: { groupName: S }
+      }), l.emitter.debug("lifecycle", { phase: "sw:group-toggled", groupName: S, enabled: A }), F(e, E, {
+        __chaosMakerAck: !0,
+        running: l.running
+      });
+      return;
+    }
+    if (M.__chaosMakerGetLog) {
+      F(e, E, {
+        __chaosMakerLog: !0,
+        log: s.getLog()
+      });
+      return;
+    }
+    if (M.__chaosMakerClearLog) {
+      s.clearLog(), F(e, E, {
+        __chaosMakerAck: !0,
+        running: l.running
+      });
+      return;
+    }
+  };
+  if (e.addEventListener("message", f), (n.source ?? "message") === "self-global") {
+    const a = e.__CHAOS_CONFIG__;
+    a && typeof a == "object" && te(l, a);
+  }
+  const u = {
+    isRunning: () => l.running,
+    getSeed: () => l.seed,
+    getLog: () => s.getLog(),
+    clearLog: () => s.clearLog(),
+    uninstall: () => {
+      e.removeEventListener("message", f), K(l), delete e[Y];
+    }
+  };
+  return e[Y] = u, u;
+}
+typeof self < "u" && typeof importScripts == "function" && Fe({ source: "message" });
+export {
+  Fe as installChaosSW
+};