@buoy-gg/network 7.0.12 → 7.0.14

package/lib/typescript/network/overrides/overrideRulesStore.d.ts

@@ -0,0 +1,205 @@
+/**
+ * The override rule list — persisted, and the source of truth for the engine.
+ *
+ * Shape and persistence follow `networkSavedStore` / `ignoredPatternsStore`:
+ * lazy hydrate on first use, a `dirty` flag so a slow read can't clobber a
+ * mutation the user just made, and commit = set + emit + persist.
+ *
+ * Two things here are specific to overrides and worth reading:
+ *
+ *  - `getRules()` is on the HOT PATH. It is called inside the app's own
+ *    `XMLHttpRequest.send()`, for every request, so it does no work: the master
+ *    switch collapses to returning a frozen empty array.
+ *
+ *  - `syncKeepAlive()` keeps the interceptor installed while any rule is
+ *    active. Without it a rule would stop firing the moment the Network tool
+ *    closed, because the swizzle is reference-counted off capture subscribers.
+ */
+import { type OverrideRule } from "./types";
+export interface OverrideRulesState {
+    /** Master switch. Off disables every rule without losing any of them. */
+    enabled: boolean;
+    rules: OverrideRule[];
+    /**
+     * Set when the launch-safety guard turned overrides off by itself.
+     *
+     * Cleared the moment the developer turns them back on or touches a rule. The
+     * UI uses it to explain the state rather than leave it looking like a bug.
+     */
+    autoPaused: boolean;
+}
+/**
+ * A rule as authored. `id`/`createdAt` and the runtime counters (`hits`,
+ * `seen`) are the store's business, never the caller's.
+ */
+export type OverrideRuleDraft = Omit<OverrideRule, "id" | "hits" | "seen" | "createdAt">;
+/**
+ * Handlers the desktop dashboard installs to forward mutations to the device.
+ *
+ * Rules only DO anything on the device — a rule is applied inside the app's own
+ * `fetch`/`XMLHttpRequest`, which the dashboard doesn't have. So in remote mode
+ * this store becomes a MIRROR: it renders the device's rules and forwards every
+ * edit, writing nothing to this machine's storage. Same seam
+ * `networkSavedStore` uses for pins.
+ */
+export interface OverrideRulesRemote {
+    setEnabled: (enabled: boolean) => void;
+    upsertRule: (draft: OverrideRuleDraft & {
+        id?: string;
+    }) => void;
+    setRuleEnabled: (id: string, enabled: boolean) => void;
+    removeRule: (id: string) => void;
+    clearRules: () => void;
+    /**
+     * Fetch the body the snapshot withheld (see `OverrideRule.bodyOmitted`).
+     * Optional so an older dashboard still mirrors rules — it just shows an empty
+     * body for the large ones.
+     */
+    getRuleBody?: (id: string) => Promise<string | null>;
+}
+type Listener = () => void;
+declare class OverrideRulesStore {
+    private rules;
+    private enabled;
+    private readonly listeners;
+    private loaded;
+    private loadPromise;
+    /** Set once a mutation happens so a slow initial load can't clobber it. */
+    private dirty;
+    private idCounter;
+    private state;
+    /** Consecutive launches that began with rules armed and nobody touching them. */
+    private launchStreak;
+    private autoPaused;
+    /** Held while any rule is active — see `syncKeepAlive`. */
+    private keepAlive;
+    private hitEmitTimer;
+    /** Set on the desktop dashboard — see `disableEngine`. */
+    private engineDisabled;
+    /** Set on the desktop dashboard — see `OverrideRulesRemote`. */
+    private remote;
+    private remoteEchoUntil;
+    /**
+     * Turn this store into a mirror of a connected device's rules. Edits are
+     * applied locally for immediate feedback AND forwarded to the device, which
+     * is the source of truth; nothing is persisted to this machine.
+     */
+    enableRemoteMode(remote: OverrideRulesRemote): void;
+    disableRemoteMode(): void;
+    /**
+     * Feed the device's rules in (mirror mode only). `force` bypasses the echo
+     * guard — used when tearing the mirror down, where there is no later snapshot
+     * to converge on.
+     */
+    replaceRules(state: OverrideRulesState, force?: boolean): void;
+    /** Mark a local optimistic write so the next in-flight mirror is ignored. */
+    private markLocalEdit;
+    /**
+     * Never intercept traffic in this runtime.
+     *
+     * The desktop dashboard renders the real tool (`NetworkToolView`), so this
+     * module is imported there too — but the dashboard is a VIEWER. Its job is to
+     * drive rules on the connected device, never to swizzle its own `fetch` and
+     * override its own requests. The same seam `networkEventStore.disableCapture()`
+     * uses, for the same reason.
+     */
+    disableEngine(): void;
+    getState(): OverrideRulesState;
+    /**
+     * The hot path — called inside `send()` for every request the app makes.
+     * Returns a frozen empty array when the master switch is off so the caller
+     * needs no second check.
+     */
+    getRules(): readonly OverrideRule[];
+    /**
+     * The rule's real body, fetching it from the device when this surface only
+     * has the stripped copy (see `OverrideRule.bodyOmitted`).
+     *
+     * On the device itself every body is already here, so this resolves
+     * immediately and the editor never notices the difference.
+     */
+    fetchRuleBody(id: string): Promise<string | null>;
+    /** Rules that would actually fire — drives the "overrides active" banner. */
+    activeCount(): number;
+    subscribe(listener: Listener): () => void;
+    setEnabled(enabled: boolean): void;
+    addRule(draft: OverrideRuleDraft): OverrideRule | null;
+    /**
+     * Create or replace a rule in one call.
+     *
+     * THE ONLY WRITE PATH THE UI SHOULD USE. `addRule`/`updateRule` are the
+     * primitives underneath and deliberately do NOT forward to the device — if
+     * the UI called them directly, an edit made on the dashboard would apply to
+     * the mirror and never reach the phone, which looks exactly like it worked.
+     *
+     * Returns the rule, or null when the list is full.
+     */
+    upsertRule(draft: OverrideRuleDraft & {
+        id?: string;
+    }): OverrideRule | null;
+    updateRule(id: string, patch: Partial<OverrideRuleDraft>): void;
+    setRuleEnabled(id: string, enabled: boolean): void;
+    removeRule(id: string): void;
+    clearRules(): void;
+    /**
+     * One rule matched one request.
+     *
+     * Replaces the rule object rather than mutating it so memoized rows actually
+     * re-render, and coalesces the notification — this runs at request rate.
+     */
+    /**
+     * One rule matched one request, applied or not.
+     *
+     * Deliberately silent — this fires on requests an alternating rule lets
+     * through, where nothing visible changed. `recordHit` owns the notification.
+     */
+    recordMatch(ruleId: string): void;
+    recordHit(ruleId: string): void;
+    /**
+     * Hydrate from storage. Safe to call repeatedly; only the first call reads.
+     *
+     * Called at package import (see `preset.tsx`) rather than on first subscribe,
+     * because a rule has to fire from app boot — with the Network tool closed and
+     * nothing capturing.
+     */
+    ensureLoaded(): Promise<void>;
+    /**
+     * Count this launch, and pause overrides if they've been armed and untouched
+     * for too many in a row. See MAX_UNTOUCHED_LAUNCHES for why.
+     */
+    private applyLaunchGuard;
+    /**
+     * Keep the interceptor installed for as long as a rule could fire.
+     *
+     * The swizzle is reference-counted off `networkListener`'s listener count
+     * (the event store adds one while capturing). Holding a no-op listener reuses
+     * that existing lifecycle instead of inventing a second one.
+     */
+    private syncKeepAlive;
+    private scheduleHitEmit;
+    private commit;
+    /** Rebuild the derived view once per mutation so renders get stable refs. */
+    private rebuild;
+    /**
+     * The developer is actively working with the rules, so the launch guard has
+     * nothing to protect them from — reset it and clear any auto-pause notice.
+     */
+    private markTouched;
+    /**
+     * The developer reached the override UI, which is proof the app still runs.
+     *
+     * The launch guard exists to escape a WEDGE — a body the app can't render,
+     * where the controls are unreachable because nothing draws. If this call
+     * happens, that isn't the situation, so the streak has nothing to protect
+     * against. Without it the guard nags anyone who legitimately keeps a rule
+     * armed for days, which is a real workflow ("force /checkout to 500 every
+     * morning") and not the failure mode it was built for.
+     */
+    noteHealthyLaunch(): void;
+    private persist;
+    private emit;
+}
+/** Singleton — one rule list per JS runtime. */
+export declare const overrideRulesStore: OverrideRulesStore;
+export {};
+//# sourceMappingURL=overrideRulesStore.d.ts.map

package/lib/typescript/network/overrides/overrideRulesStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overrideRulesStore.d.ts","sourceRoot":"","sources":["../../../../src/network/overrides/overrideRulesStore.ts"],"names":[],"mappings":"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"}

package/lib/typescript/network/overrides/presets.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Turning a captured request into a rule draft.
+ *
+ * Chrome's flow assumes a keyboard, a file tree and a second monitor. On a
+ * phone the equivalent has to start from the request you're already looking at,
+ * which is what this file is for — the editor never opens on a blank field.
+ *
+ * There used to be a list of one-tap presets here (Force 500, Empty list,
+ * Offline…) rendered as chips. They're gone: the editor's outcome grid says the
+ * same things in the same words, so keeping both meant two lists to maintain
+ * and two places to look for the same choice.
+ */
+import type { NetworkEvent } from "../types";
+import type { OverrideRuleDraft } from "./overrideRulesStore";
+/**
+ * Turn a captured URL into a pattern that will match the request AGAIN.
+ *
+ * The query string is dropped and replaced with `*`, which is not a
+ * simplification — it's the difference between a rule that works and one that
+ * silently never fires. Plenty of clients cache-bust
+ * (`?timestamp=1785783081234`), carry a request id, or page; pinning the exact
+ * URL means the next call to the same endpoint doesn't match. Found exactly
+ * that way: an "Offline" preset on a Pokémon request sat at 0 hits because the
+ * app appends a timestamp to every call.
+ *
+ * The path stays exact, so this still means "this endpoint" and not "this
+ * host" — and the editor shows the pattern, so narrowing it back down is one
+ * edit away.
+ */
+export declare function patternForUrl(url: string): string;
+/**
+ * Prefill the rule editor from a captured request.
+ *
+ * Seeds the REAL response as the body so the common edit — change two fields of
+ * a payload you just saw — starts from something true rather than from nothing.
+ */
+export declare function draftFromEvent(event: NetworkEvent): OverrideRuleDraft;
+//# sourceMappingURL=presets.d.ts.map

package/lib/typescript/network/overrides/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../../../src/network/overrides/presets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGjD;AAaD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,iBAAiB,CAYrE"}

package/lib/typescript/network/overrides/resolveOverride.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Decide whether a request is overridden — the whole decision, in one pure
+ * function.
+ *
+ * Pure on purpose: this is the piece worth unit-testing, and it runs inside the
+ * app's own `XMLHttpRequest.send()`, so it must be cheap, total, and incapable
+ * of throwing. Everything that could surprise (defaults, clamping, content-type
+ * inference) is resolved HERE, so `applyToXhr` never makes a decision — it just
+ * performs the outcome.
+ */
+import { type OverrideOutcome, type OverrideRule } from "./types";
+/** Normalize a matched rule into the exact instructions the interceptor needs. */
+declare function toOutcome(rule: OverrideRule): OverrideOutcome;
+/** A rule that has burned through its `times` budget no longer applies. */
+export declare function isSpent(rule: OverrideRule): boolean;
+/**
+ * Is this rule in a phase where it should actually fire?
+ *
+ * Only `alternate` can answer no. It reads the CURRENT `seen` count, before
+ * this match is recorded, so an untouched rule (`seen === 0`) lets the first
+ * request through and overrides the second.
+ */
+export declare function shouldApply(rule: OverrideRule): boolean;
+/**
+ * The first enabled rule whose pattern covers this request, phase ignored.
+ *
+ * Separate from `resolveOverride` because an alternating rule has to advance
+ * its phase on the requests it deliberately skips — the caller needs the rule
+ * back even when the answer is "not this time".
+ */
+export declare function findMatchingRule(url: string, method: string, rules: readonly OverrideRule[]): OverrideRule | null;
+/**
+ * First ENABLED matching rule wins outright — no merging across rules.
+ *
+ * Chrome cascades header overrides from the most general path segment to the
+ * most specific, but that only exists because its rules are directory-nested
+ * files. A flat list with a cascade would be a rule whose effect you cannot see
+ * by reading it, which is exactly the wrong trade on a phone screen.
+ *
+ * @param url    Full request URL, query string included.
+ * @param method HTTP method as the caller sent it (case-insensitive).
+ * @param rules  Ordered rule list; earlier entries win.
+ */
+export declare function resolveOverride(url: string, method: string, rules: readonly OverrideRule[]): OverrideOutcome | null;
+export { toOutcome };
+//# sourceMappingURL=resolveOverride.d.ts.map

package/lib/typescript/network/overrides/resolveOverride.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveOverride.d.ts","sourceRoot":"","sources":["../../../../src/network/overrides/resolveOverride.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,SAAS,CAAC;AA4CjB,kFAAkF;AAClF,iBAAS,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,eAAe,CA6BtD;AAED,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAGvD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,YAAY,EAAE,GAC7B,YAAY,GAAG,IAAI,CAcrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,YAAY,EAAE,GAC7B,eAAe,GAAG,IAAI,CAIxB;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/lib/typescript/network/overrides/types.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Network response overrides — the rule model.
+ *
+ * This is Buoy's answer to Chrome DevTools' "Local Overrides", reshaped for
+ * mobile. Two deliberate differences from Chrome are worth knowing, because
+ * they explain the whole shape of this file:
+ *
+ * 1. Chrome's rules ARE a directory tree — a body override is a file at
+ *    `<host>/<path>`, header overrides live in per-directory `.headers` files,
+ *    and its general→specific header cascade exists only to hang off that
+ *    nesting. We have no filesystem, so rules are a flat ordered list and the
+ *    FIRST enabled match wins outright. That's what Charles/Proxyman/MSW do,
+ *    and it's what a developer can reason about on a phone screen.
+ *
+ * 2. Chrome CANNOT change a status code. `NetworkManager.ts` computes
+ *    `responseCode = isBodyOverridden ? 200 : (responseStatusCode || 200)`, so
+ *    overriding a body forces 200, and there is no latency or failure
+ *    simulation at all. Chrome's feature is "serve different bytes". Forcing a
+ *    500, a timeout or a 3s stall is the entire mobile use case, so `status`,
+ *    `delayMs` and `kind: "fail"` below are the point of the exercise.
+ */
+/**
+ * What a rule does when it matches.
+ *
+ * - `respond` — synthesize a response. The request never leaves the device.
+ * - `fail`    — synthesize a transport failure (offline / timeout). Also never
+ *               leaves the device.
+ * - `delay`   — let the real request run, just late. Pure latency injection.
+ */
+export type OverrideRuleKind = "respond" | "fail" | "delay";
+/**
+ * Which transport failure to fake.
+ *
+ * `network` surfaces the way a real offline request does — `fetch` rejects with
+ * `TypeError: Network request failed`. This is also how you simulate "status 0":
+ * you can't, via `respond`, because whatwg-fetch's `Response` constructor throws
+ * a RangeError outside 200–599 (see STATUS_MIN/STATUS_MAX).
+ */
+export type OverrideFailKind = "network" | "timeout";
+/**
+ * Status codes a synthesized response may use.
+ *
+ * NOT an arbitrary product decision: React Native's `fetch` is the whatwg-fetch
+ * polyfill, whose `Response` constructor throws
+ * `RangeError: The status provided is outside the range [200, 599]`. A rule set
+ * to 0 would therefore crash the app's own fetch call rather than override it.
+ * Use `kind: "fail"` for connection-level failures.
+ */
+export declare const STATUS_MIN = 200;
+export declare const STATUS_MAX = 599;
+/** Bounds the persisted list so a runaway UI can't fill storage. */
+export declare const MAX_RULES = 50;
+/** Free tier gets one active rule; Pro is unlimited (up to MAX_RULES). */
+export declare const FREE_TIER_RULE_LIMIT = 1;
+export interface OverrideRule {
+    id: string;
+    enabled: boolean;
+    /** Display label. Falls back to `urlPattern` when absent. */
+    name?: string;
+    /**
+     * Glob matched against the FULL request URL, query string included.
+     *
+     * `*` is the only wildcard and the match is anchored, exactly like Chrome's
+     * `applyTo` patterns — see `escapeRegex` in `matchRule.ts`, ported from
+     * `NetworkPersistenceManager.ts:1051` so a pattern behaves the same way here
+     * as it does in the browser.
+     */
+    urlPattern: string;
+    /** Uppercase methods. Absent or empty means "any method". */
+    methods?: string[];
+    kind: OverrideRuleKind;
+    /** `respond` only. Clamped to [STATUS_MIN, STATUS_MAX]. Defaults to 200. */
+    status?: number;
+    /**
+     * `respond` only. React Native's XMLHttpRequest has no `statusText` field at
+     * all (real requests report `undefined`), so this is purely cosmetic — it
+     * makes the tool's own list read correctly.
+     */
+    statusText?: string;
+    /** `respond` only. A `content-type` is inferred from the body when omitted. */
+    headers?: Record<string, string>;
+    /** `respond` only. Raw text; JSON is just JSON-shaped text. */
+    body?: string;
+    /** `fail` only. Defaults to `network`. */
+    failKind?: OverrideFailKind;
+    /** Latency before the outcome, in ms. Applies to all three kinds. */
+    delayMs?: number;
+    /**
+     * Auto-disable after N matches; `null`/absent means "forever".
+     *
+     * A throwaway rule ("make the next save fail") should retire itself. A rule
+     * that silently breaks the app tomorrow is this feature's main footgun.
+     */
+    times?: number | null;
+    /**
+     * Apply to every OTHER matching request instead of every one.
+     *
+     * For the failure that isn't total: a flaky endpoint, a retry that should
+     * succeed on the second attempt, a token refresh that only fires after one
+     * 401. Those paths are where retry logic is usually wrong, and a rule that's
+     * either always-on or always-off can't reach them.
+     *
+     * The first matching request passes THROUGH, the second is overridden, and it
+     * alternates forever — so the sequence is off, on, off, on.
+     */
+    alternate?: boolean;
+    /** Times this rule was APPLIED. Runtime-only counter; not persisted. */
+    hits: number;
+    /**
+     * Times this rule MATCHED, whether or not it applied. Runtime-only.
+     *
+     * Distinct from `hits` because `alternate` needs to advance its phase on the
+     * requests it deliberately lets through — counting only applications would
+     * leave it stuck in the off phase forever.
+     */
+    seen: number;
+    createdAt: number;
+    /**
+     * WIRE-ONLY: this rule's `body` was too big to ride the sync snapshot and was
+     * left out of it. Never persisted, never set on the device's own copy.
+     *
+     * A rule seeded from a real request holds that request's whole response —
+     * half a megabyte is normal — and the snapshot goes out several times a second
+     * while traffic flows. Streaming those bodies forever is the freeze that
+     * `stripLargeBodies` already exists to prevent for events.
+     *
+     * Remote surfaces fetch the real body with `getOverrideRuleBody` when the user
+     * actually opens the rule. The flag also protects the body on save: a
+     * dashboard editing a rule it never received the body for sends this back, and
+     * the device keeps what it has rather than wiping it.
+     */
+    bodyOmitted?: boolean;
+}
+/**
+ * Stamped onto the `NetworkEvent` a rule affected, so the list can badge the
+ * row and the detail view can offer "edit / disable the rule that did this".
+ */
+export interface NetworkOverrideMark {
+    ruleId: string;
+    ruleName?: string;
+    kind: OverrideRuleKind;
+    delayMs?: number;
+}
+/**
+ * A matched rule, normalized into exactly what the interceptor needs — defaults
+ * resolved, status clamped, content-type inferred. Keeping normalization in the
+ * resolver means `applyToXhr` never has to make a decision.
+ */
+export type OverrideOutcome = {
+    kind: "respond";
+    rule: OverrideRule;
+    delayMs: number;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+} | {
+    kind: "fail";
+    rule: OverrideRule;
+    delayMs: number;
+    failKind: OverrideFailKind;
+} | {
+    kind: "delay";
+    rule: OverrideRule;
+    delayMs: number;
+};
+/** The marker recorded for an outcome. */
+export declare function markForOutcome(outcome: OverrideOutcome): NetworkOverrideMark;
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/network/overrides/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/network/overrides/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AAE5D;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,SAAS,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,MAAM,CAAC;AAC9B,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B,oEAAoE;AACpE,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,OAAO,CAAC;IACjB,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;OAOG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,gBAAgB,CAAC;IACvB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,+DAA+D;IAC/D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,GACD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D,0CAA0C;AAC1C,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,mBAAmB,CAO5E"}

package/lib/typescript/network/sync/networkSyncAdapter.d.ts

@@ -1,3 +1,5 @@
+import type { OverrideRulesState } from "../overrides/overrideRulesStore";
+import type { OverrideRuleKind } from "../overrides/types";
 import type { NetworkEvent } from "../types";
 /**
  * Request/response bodies larger than this (using the cached size proxy already
@@ -31,6 +33,12 @@ export declare const networkSyncAdapter: {
     version: number;
     getSnapshot: () => {
         events: NetworkEvent[];
+        /**
+         * Response-override rules live on the DEVICE — that's the only place they
+         * can run, since a rule is applied inside the app's own XMLHttpRequest.
+         * Remote surfaces mirror this and forward their edits back as actions.
+         */
+        overrides: OverrideRulesState;
         saved: {
             event: NetworkEvent;
             key: string;
@@ -85,6 +93,71 @@ export declare const networkSyncAdapter: {
         clearPinnedRequests: () => {
             ok: boolean;
         };
+        /** Master switch — turns every rule off without losing any of them. */
+        setOverridesEnabled: (params: unknown) => {
+            ok: boolean;
+            enabled: boolean;
+        };
+        /** Create a rule, or replace one by id. */
+        upsertOverrideRule: (params: unknown) => {
+            ok: boolean;
+            error: string;
+            rule?: undefined;
+        } | {
+            ok: boolean;
+            rule: {
+                id: string;
+                urlPattern: string;
+                enabled: boolean;
+                kind: OverrideRuleKind;
+                status: number | undefined;
+                bodySize: number;
+            };
+            error?: undefined;
+        };
+        setOverrideRuleEnabled: (params: unknown) => {
+            ok: boolean;
+            error: string;
+        } | {
+            ok: boolean;
+            error?: undefined;
+        };
+        deleteOverrideRule: (params: unknown) => {
+            ok: boolean;
+            error: string;
+        } | {
+            ok: boolean;
+            error?: undefined;
+        };
+        clearOverrideRules: () => {
+            ok: boolean;
+        };
+        /** Read the rules back — hit counts included, which the snapshot coalesces. */
+        listOverrideRules: () => OverrideRulesState;
+        /**
+         * The full body of one rule, for the surfaces the snapshot withheld it from
+         * (see `stripLargeRuleBodies`). Fetched when the user opens the rule, which
+         * is the only moment it's needed.
+         */
+        getOverrideRuleBody: (params: unknown) => {
+            body: string | null;
+        } | null;
+        /** Why isn't my rule firing? Reports the engine's own view of the world. */
+        debugOverrides: (params: unknown) => {
+            interceptorInstalled: boolean;
+            listenerCount: number;
+            engine: {
+                hooksInstalled: boolean;
+                devFlag: string | boolean;
+                ruleCount: number;
+                matches: boolean;
+            };
+            store: {
+                enabled: boolean;
+                ruleCount: number;
+                rulesVisibleToEngine: number;
+            };
+        };
     };
 };
 //# sourceMappingURL=networkSyncAdapter.d.ts.map

package/lib/typescript/network/sync/networkSyncAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"networkSyncAdapter.d.ts","sourceRoot":"","sources":["../../../../src/network/sync/networkSyncAdapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,QAAY,CAAC;AA+BpD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;0BAYP,MAAM,IAAI;;;QAc9B;;;;;WAKG;+BACoB,OAAO;;;;QAU9B,8CAA8C;4BAC1B,OAAO;;;;;;;;;QAY3B,gDAAgD;2BAC7B,OAAO;;;;;;;;;QAU1B,sDAAsD;oCAC1B,OAAO;;;;;;;;;;CAkBtC,CAAC"}
+{"version":3,"file":"networkSyncAdapter.d.ts","sourceRoot":"","sources":["../../../../src/network/sync/networkSyncAdapter.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAEV,kBAAkB,EACnB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,QAAY,CAAC;AA8JpD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB;;;;QAI3B;;;;WAIG;;;;;;;;;;;;;0BAUiB,MAAM,IAAI;;;QAkB9B;;;;;WAKG;+BACoB,OAAO;;;;QAU9B,8CAA8C;4BAC1B,OAAO;;;;;;;;;QAY3B,gDAAgD;2BAC7B,OAAO;;;;;;;;;QAU1B,sDAAsD;oCAC1B,OAAO;;;;;;;;;QAsBnC,uEAAuE;sCACzC,OAAO;;;;QAKrC,2CAA2C;qCACd,OAAO;;;;;;;;;;;;;;;;yCAmCH,OAAO;;;;;;;qCAOX,OAAO;;;;;;;;;;QAYpC,+EAA+E;;QAG/E;;;;WAIG;sCAC2B,OAAO;;;QAYrC,4EAA4E;iCACnD,OAAO;;;;;;;;;;;;;;;;CAiBnC,CAAC"}

package/lib/typescript/network/types/index.d.ts

@@ -1,6 +1,8 @@
 /**
  * Network monitoring types for React Native dev tools
  */
+import type { NetworkOverrideMark } from "../overrides/types";
+export type { NetworkOverrideMark, OverrideRule, OverrideRuleKind, OverrideFailKind, } from "../overrides/types";
 /**
  * The parts of a request's lifetime we can actually observe from JavaScript.
  *
@@ -93,6 +95,14 @@ export interface NetworkEvent {
      * // Display: "GetPokemon › Sandshrew"
      */
     graphqlVariables?: Record<string, unknown>;
+    /**
+     * Set when a response-override rule affected this request.
+     *
+     * OPTIONAL ON PURPOSE, like `timings` — absent on requests captured before
+     * overrides existed, and on devices running an older Buoy than the dashboard.
+     * Consumers must treat its absence as "not overridden", never as "unknown".
+     */
+    override?: NetworkOverrideMark;
 }
 /**
  * Aggregated counts derived from the currently loaded set of network events.

package/lib/typescript/network/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/network/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;OAOG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EACF,KAAK,GACL,MAAM,GACN,KAAK,GACL,QAAQ,GACR,OAAO,GACP,MAAM,GACN,SAAS,GACT,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,KAAK,GAAG,SAAS,GAAG,UAAU,CAAC;IACnE;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,KAAK,CAAC;IACjD,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,oFAAoF;AACpF,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAE7E;;;;GAIG;AACH,YAAY,EACV,cAAc,EACd,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;IAC5D,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/network/types/index.ts"],"names":[],"mappings":"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"}

package/lib/typescript/network/utils/networkEventStore.d.ts

@@ -31,6 +31,13 @@ export type NetworkEventCallback = (event: NetworkEvent) => void;
 export type NetworkEventsArrayCallback = (events: NetworkEvent[]) => void;
 declare class NetworkEventStore extends BaseEventStore<NetworkEvent> {
     private pendingRequests;
+    /**
+     * Recently seen `METHOD:url` keys → when, and which event id we kept.
+     *
+     * The timestamp powers the dual-interception dedup below. The id is what lets
+     * a DROPPED duplicate still contribute something the kept event doesn't know
+     * — see `applyOverrideMark`.
+     */
     private recentRequests;
     private rawListenerUnsubscribe;
     constructor();
@@ -50,6 +57,13 @@ declare class NetworkEventStore extends BaseEventStore<NetworkEvent> {
      * Process a network listener event
      */
     processNetworkEvent(event: NetworkingEvent): void;
+    /**
+     * Stamp an override mark onto an already-recorded event.
+     *
+     * Only ever moves a mark from a dropped duplicate onto the event that was
+     * kept, so it never overwrites one that is already there.
+     */
+    private applyOverrideMark;
     private extractHost;
     private extractPath;
     private getDataSize;

package/lib/typescript/network/utils/networkEventStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"networkEventStore.d.ts","sourceRoot":"","sources":["../../../../src/network/utils/networkEventStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAQzD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,IAAI,CAAC;AAE1E,cAAM,iBAAkB,SAAQ,cAAc,CAAC,YAAY,CAAC;IAC1D,OAAO,CAAC,eAAe,CAAwC;IAC/D,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,sBAAsB,CAA6B;;IAS3D;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;IAgBhC;;OAEG;IACH,SAAS,CAAC,aAAa,IAAI,IAAI;IAc/B;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAgHjD,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,WAAW;IAUnB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIlD;;OAEG;IACH,WAAW,IAAI,IAAI;IAMnB;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,oBAAoB,EAAE,cAAc,UAAO,GAAG,MAAM,IAAI;IAkB1E,QAAQ;;;;;;;;;IAuCR,YAAY,CAAC,MAAM,EAAE;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;QACzC,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,GAAG,YAAY,EAAE;CAyCnB;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}
+{"version":3,"file":"networkEventStore.d.ts","sourceRoot":"","sources":["../../../../src/network/utils/networkEventStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAQzD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,IAAI,CAAC;AAE1E,cAAM,iBAAkB,SAAQ,cAAc,CAAC,YAAY,CAAC;IAC1D,OAAO,CAAC,eAAe,CAAwC;IAC/D;;;;;;OAMG;IACH,OAAO,CAAC,cAAc,CAAsD;IAC5E,OAAO,CAAC,sBAAsB,CAA6B;;IAS3D;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;IAgBhC;;OAEG;IACH,SAAS,CAAC,aAAa,IAAI,IAAI;IAc/B;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAgIjD;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,WAAW;IAUnB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIlD;;OAEG;IACH,WAAW,IAAI,IAAI;IAMnB;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,oBAAoB,EAAE,cAAc,UAAO,GAAG,MAAM,IAAI;IAkB1E,QAAQ;;;;;;;;;IAuCR,YAAY,CAAC,MAAM,EAAE;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;QACzC,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,GAAG,YAAY,EAAE;CAyCnB;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}