@buoy-gg/network 7.0.73 → 7.0.75

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

@@ -137,6 +137,16 @@ declare class OverrideRulesStore {
     upsertRule(draft: OverrideRuleDraft & {
         id?: string;
     }): OverrideRule | null;
+    /**
+     * Swap the whole list and the master switch in one write.
+     *
+     * For a tool that installs a rule SET and must later put the old one back
+     * exactly: bug links load a case's recorded answers this way, and undo it
+     * the same way. Order is kept, since first match wins. Device only: a
+     * mirror refuses (returns null), because the dashboard has no forwarder for
+     * a whole list.
+     */
+    replaceAllRules(rules: readonly unknown[], enabled: boolean): OverrideRule[] | null;
     updateRule(id: string, patch: Partial<OverrideRuleDraft>): void;
     setRuleEnabled(id: string, enabled: boolean): void;
     removeRule(id: string): void;
@@ -160,9 +170,19 @@ declare class OverrideRulesStore {
      *
      * 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.
+     * nothing capturing. On the web `loadNow` has usually done it already.
      */
     ensureLoaded(): Promise<void>;
+    /**
+     * Web only: read the saved rules from localStorage right now.
+     *
+     * A page makes its first requests (the session check, the first queries)
+     * before an async read could finish, so a mocked sign-in was lost on every
+     * reload. localStorage is synchronous, so this puts the rules, and the
+     * interceptor that applies them, in place before the first request.
+     */
+    loadNow(): void;
+    private hydrate;
     /**
      * 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.

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

@@ -28,7 +28,7 @@ export declare function shouldApply(rule: OverrideRule): boolean;
  * 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[], headers?: Record<string, string>): OverrideRule | null;
+export declare function findMatchingRule(url: string, method: string, rules: readonly OverrideRule[], headers?: Record<string, string>, body?: string): OverrideRule | null;
 /**
  * First ENABLED matching rule wins outright — no merging across rules.
  *
@@ -41,6 +41,6 @@ export declare function findMatchingRule(url: string, method: string, rules: rea
  * @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[], headers?: Record<string, string>): OverrideOutcome | null;
+export declare function resolveOverride(url: string, method: string, rules: readonly OverrideRule[], headers?: Record<string, string>, body?: string): OverrideOutcome | null;
 export { toOutcome };
 //# sourceMappingURL=resolveOverride.d.ts.map

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

@@ -81,6 +81,14 @@ export interface OverrideRule {
      * carried the token and never on the app's own token request.
      */
     requireHeader?: string;
+    /**
+     * Only requests whose body CONTAINS this text. Absent means any body.
+     *
+     * For calls that share one URL, like GraphQL's `POST /graphql`: replaying a
+     * bug case needs the GetCart answer to reach GetCart, not whichever query
+     * asked first. A body that isn't text (FormData, a Blob) never matches.
+     */
+    bodyIncludes?: string;
     kind: OverrideRuleKind;
     /** `respond` only. Clamped to [STATUS_MIN, STATUS_MAX]. Defaults to 200. */
     status?: number;

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

@@ -1,5 +1,5 @@
 import type { OverrideRulesState } from "../overrides/overrideRulesStore";
-import type { OverrideRuleKind } from "../overrides/types";
+import { type OverrideRuleKind } from "../overrides/types";
 import type { NetworkEvent } from "../types";
 import { type EditViolation } from "@buoy-gg/shared-ui";
 /**
@@ -208,6 +208,29 @@ export declare const networkSyncAdapter: {
         clearOverrideRules: () => {
             ok: boolean;
         };
+        /**
+         * Replace every rule and the master switch at once, in order.
+         *
+         * For a tool that installs a whole rule set and must put the old one back
+         * exactly: bug links' sandbox (recorded answers, then block the rest) and
+         * its undo. Rules use the stored shape (`listOverrideRules` returns it).
+         */
+        replaceOverrideRules: (params?: unknown) => Promise<{
+            ok: boolean;
+            error: string;
+        } | {
+            active: false;
+            inactiveReason: string;
+            ok: boolean;
+            count: number;
+            enabled: boolean;
+            error?: undefined;
+        } | {
+            ok: boolean;
+            count: number;
+            enabled: boolean;
+            error?: undefined;
+        }>;
         /**
          * Read the rules back — hit counts included, which the snapshot coalesces.
          *
@@ -243,6 +266,10 @@ export declare const networkSyncAdapter: {
             eventCount: number;
         };
         debugOverrides: (params?: unknown) => {
+            tested: {
+                url: string;
+                method: string;
+            };
             interceptorInstalled: boolean;
             listenerCount: number;
             engine: {
@@ -253,6 +280,7 @@ export declare const networkSyncAdapter: {
             };
             store: {
                 enabled: boolean;
+                autoPaused: boolean;
                 ruleCount: number;
                 rulesVisibleToEngine: number;
             };