@buoy-gg/network 7.0.40 → 7.0.42

package/lib/module/network/overrides/applyToXhr.js

@@ -1,446 +1,2 @@
-"use strict";
-
-/**
- * Perform an override outcome against an XMLHttpRequest — React Native's OR a
- * standards (browser/webview) one.
- *
- * WHY THIS IS POSSIBLE ON RN: React Native's XMLHttpRequest
- * (`react-native/Libraries/Network/XMLHttpRequest.js`) is pure JavaScript.
- * `readyState`, `status`, `responseHeaders` and `responseURL` are plain
- * writable fields, and `setResponseHeaders()` / `setReadyState()` are real
- * methods — `setReadyState(DONE)` dispatches the correct terminal event off
- * internal flags (`_aborted` → abort, `_hasError` + `_timedOut` → timeout,
- * `_hasError` → error, otherwise load; always loadend). So a response can be
- * synthesized end to end without touching native code.
- *
- * WHY XHR IS THE ONLY PLACE WE HOOK ON RN:
- * `react-native/Libraries/Network/fetch.js` is `require('whatwg-fetch')` —
- * RN's `fetch` IS the polyfill over XMLHttpRequest. Overriding here therefore
- * covers `fetch`, `axios` and raw XHR through one code path, and the fake
- * response flows back up through the polyfill so the tool records it without
- * any extra plumbing.
- *
- * Verified field-for-field on React Native 0.81.4 and 0.85.3.
- *
- * WHY THERE IS A SECOND PATH: on a STANDARDS XMLHttpRequest (a webview port —
- * Tauri/Capacitor — or react-native-web) none of the RN internals exist, and
- * `status` / `readyState` / `response` are readonly ACCESSORS on
- * `XMLHttpRequest.prototype`, so plain assignment silently no-ops (or throws
- * in strict mode). This file used to feature-detect that and give up —
- * "degraded, but never broken" — which was right for react-native-web as a
- * by-product of an RN app, and wrong the moment the web ports made the
- * browser XHR a first-class target: the row got FLAGGED as overridden (the
- * rule matched) while the real request went out. The fix is
- * `runStandardOverride` below: `Object.defineProperty` INSTANCE own-properties
- * shadow the prototype accessors (legal on any object), and the lifecycle
- * events are dispatched by hand through the XHR's own EventTarget — which
- * fires `addEventListener` listeners AND the `onload`/`onloadend`/
- * `onreadystatechange` handler attributes, exactly what axios's XHR adapter
- * listens on.
- *
- * Several non-obvious behaviours are handled below; each one is a real bug if
- * you skip it, and each is commented at the line that fixes it.
- */
-
-const HEADERS_RECEIVED = 2;
-const LOADING = 3;
-const DONE = 4;
-
-/**
- * The private surface of RN's XMLHttpRequest that we drive.
- *
- * Typed explicitly rather than reached for with `any` so that if a future React
- * Native renames one of these, the compiler points at every use — and so the
- * blast radius of "we depend on RN internals" is one interface.
- */
-
-const internalsOf = xhr => xhr;
-let warnedUnsupported = false;
-
-/**
- * Can this XMLHttpRequest be driven through React Native's internals?
- *
- * The RN technique rests on those internals, so it is feature-detected rather
- * than assumed. A request that fails this check is NOT automatically a lost
- * cause — `canSynthesizeStandard` covers the standards XHR next.
- */
-export function canSynthesize(xhr) {
-  const internals = internalsOf(xhr);
-  return typeof internals.setReadyState === "function" && typeof internals.setResponseHeaders === "function";
-}
-
-/**
- * Can this XMLHttpRequest be driven as a STANDARDS one?
- *
- * `dispatchEvent` is the load-bearing requirement: the whole standard path
- * works by defining instance own-properties and then dispatching the
- * lifecycle events through the XHR's own EventTarget. `removeEventListener`
- * rules out half-mocks that could take the branch and then leak listeners.
- */
-export function canSynthesizeStandard(xhr) {
-  return typeof xhr.addEventListener === "function" && typeof xhr.removeEventListener === "function" && typeof xhr.dispatchEvent === "function";
-}
-function warnUnsupported() {
-  if (warnedUnsupported) return;
-  warnedUnsupported = true;
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.warn("[Buoy] Network overrides need an XMLHttpRequest they can drive (React " + "Native's, or a standards EventTarget one) and this environment " + "provides neither — requests will run normally.");
-  }
-}
-
-/** Synthesize a successful response. */
-function respond(xhr, url, outcome) {
-  const internals = internalsOf(xhr);
-
-  // `_reset()` does `delete this.responseURL`, so `'responseURL' in xhr` is
-  // FALSE on a fresh request — and whatwg-fetch reads exactly that to populate
-  // `Response.url` (fetch.js:558). Without this line every overridden fetch
-  // response would silently carry `url: ""`.
-  internals.responseURL = url;
-  internals.status = outcome.status;
-  // RN has no `statusText` field at all (real requests report `undefined`), so
-  // this is a new own property. Harmless, and it makes the tool's list read
-  // correctly instead of showing a bare number.
-  internals.statusText = outcome.statusText;
-  internals.setResponseHeaders?.(outcome.headers);
-  // HEADERS_RECEIVED also stamps the interceptor's existing `_ttfb`, so an
-  // overridden request reports its injected latency like a real one.
-  internals.setReadyState?.(HEADERS_RECEIVED);
-  if (internals._aborted) return;
-
-  // whatwg-fetch sets `responseType = 'blob'` before every send
-  // (fetch.js:599-606), which would make RN's `response` getter demand a native
-  // Blob descriptor from BlobManager. But the polyfill reads the response
-  // exactly once — `'response' in xhr ? xhr.response : xhr.responseText`
-  // (fetch.js:559) — and never re-reads `responseType`. Handing back text is
-  // therefore both sufficient and strictly simpler: no Blob, no FileReader, no
-  // native round trip, and `.json()` becomes a synchronous JSON.parse.
-  //
-  // Assign the FIELD, not the property: the `responseType` setter throws once
-  // `_sent` is true (XMLHttpRequest.js:215), and we set `_sent` above.
-  internals._responseType = "text";
-  internals._response = outcome.body;
-  internals._cachedResponse = undefined; // force the getter to recompute
-  internals.setReadyState?.(LOADING);
-  if (internals._aborted) return;
-  internals.setReadyState?.(DONE); // dispatches 'load' then 'loadend'
-}
-
-/** Synthesize a transport failure — offline or timeout. */
-function fail(xhr, outcome) {
-  const internals = internalsOf(xhr);
-  const timedOut = outcome.failKind === "timeout";
-
-  // These two flags are the entire difference between the 'error' and
-  // 'timeout' events — see `setReadyState` in XMLHttpRequest.js. whatwg-fetch
-  // turns them into `TypeError: Network request failed` and
-  // `TypeError: Network request timed out` respectively, which is exactly what
-  // the app would see from a real dead connection.
-  internals._hasError = true;
-  internals._timedOut = timedOut;
-  internals._responseType = "text";
-  internals._response = timedOut ? "Request timed out (Buoy override)" : "Network request failed (Buoy override)";
-  internals._cachedResponse = undefined;
-  internals.setReadyState?.(DONE);
-}
-
-// ============================================================================
-// STANDARDS XMLHttpRequest path (webview ports / react-native-web)
-// ============================================================================
-
-/**
- * Shadow a prototype accessor with an instance own-property.
- *
- * This is the entire trick: `xhr.status = 500` silently no-ops (or throws in
- * strict mode) against the readonly getter on `XMLHttpRequest.prototype`, but
- * an own DATA property on the instance is legal and takes precedence in every
- * lookup. `configurable: true` so `readyState` can be redefined per
- * transition. Works identically against RN's plain class fields, so nothing
- * here is browser-only — the RN path just has a richer mechanism available.
- */
-function defineOwn(xhr, name, value) {
-  Object.defineProperty(xhr, name, {
-    value,
-    configurable: true,
-    enumerable: true,
-    writable: false
-  });
-}
-
-/**
- * Build a lifecycle event to dispatch by hand.
- *
- * `ProgressEvent` where the spec uses one (load/loadend/error/timeout/abort)
- * and the constructor exists; plain `Event` otherwise (Node test runs have no
- * ProgressEvent); a `{ type }` literal as the last resort for event-target
- * shims. Dispatching through the XHR's own EventTarget is what makes the
- * `onload`/`onloadend`/`onreadystatechange` handler ATTRIBUTES fire too —
- * they're listeners in the same list, which is exactly what axios's adapter
- * registers.
- */
-function makeEvent(type) {
-  if (type !== "readystatechange" && typeof ProgressEvent === "function") {
-    try {
-      return new ProgressEvent(type);
-    } catch {
-      // fall through
-    }
-  }
-  if (typeof Event === "function") {
-    try {
-      return new Event(type);
-    } catch {
-      // fall through
-    }
-  }
-  return {
-    type
-  };
-}
-function fireEvent(xhr, type) {
-  xhr.dispatchEvent(makeEvent(type));
-}
-
-/** Move the shadowed `readyState` and announce it — the interceptor's own
- * listener stamps TTFB off the HEADERS_RECEIVED notification, same as a real
- * response. */
-function setStandardReadyState(xhr, state) {
-  defineOwn(xhr, "readyState", state);
-  fireEvent(xhr, "readystatechange");
-}
-
-/**
- * `xhr.response` in the caller's requested shape.
- *
- * A standards XHR types `response` off `responseType`; axios sets it when the
- * caller asked for one (default '' → text). JSON is parsed (spec: null on
- * parse failure), arraybuffer/blob are best-effort encodings of the rule's
- * text body, everything else falls back to the string.
- */
-function standardResponseFor(xhr, outcome) {
-  let responseType = "";
-  try {
-    responseType = xhr.responseType;
-  } catch {
-    // Some shims throw on access before send — treat as default text.
-  }
-  switch (responseType) {
-    case "":
-    case "text":
-      return outcome.body;
-    case "json":
-      try {
-        return JSON.parse(outcome.body);
-      } catch {
-        return null;
-      }
-    case "arraybuffer":
-      if (typeof TextEncoder === "function") {
-        return new TextEncoder().encode(outcome.body).buffer;
-      }
-      return outcome.body;
-    case "blob":
-      if (typeof Blob === "function") {
-        const contentType = Object.entries(outcome.headers).find(([name]) => name.toLowerCase() === "content-type")?.[1] ?? "";
-        return new Blob([outcome.body], {
-          type: contentType
-        });
-      }
-      return outcome.body;
-    default:
-      return outcome.body;
-  }
-}
-
-/** Synthesize a successful response on a standards XHR. */
-function respondStandard(xhr, url, outcome, isAborted) {
-  const headers = outcome.headers;
-  // Spec shape: lowercase names, `name: value\r\n` per pair — axios splits on
-  // newlines and trims, raw XHR users get what a real response reads like.
-  const allHeaders = Object.entries(headers).map(([name, value]) => `${name.toLowerCase()}: ${value}\r\n`).join("");
-  defineOwn(xhr, "getAllResponseHeaders", () => allHeaders);
-  defineOwn(xhr, "getResponseHeader", name => {
-    const wanted = String(name).toLowerCase();
-    for (const [key, value] of Object.entries(headers)) {
-      if (key.toLowerCase() === wanted) return value;
-    }
-    return null;
-  });
-  defineOwn(xhr, "responseURL", url);
-  defineOwn(xhr, "status", outcome.status);
-  defineOwn(xhr, "statusText", outcome.statusText);
-  defineOwn(xhr, "response", standardResponseFor(xhr, outcome));
-  // Own property, so it answers with the body even under a non-text
-  // `responseType` (where the real accessor would throw). axios reads it
-  // whenever `responseType` is '' or 'text'.
-  defineOwn(xhr, "responseText", outcome.body);
-  setStandardReadyState(xhr, HEADERS_RECEIVED);
-  if (isAborted()) return;
-  setStandardReadyState(xhr, LOADING);
-  if (isAborted()) return;
-  setStandardReadyState(xhr, DONE);
-  fireEvent(xhr, "load");
-  fireEvent(xhr, "loadend");
-}
-
-/** Synthesize a transport failure on a standards XHR — offline or timeout. */
-function failStandard(xhr, outcome) {
-  // `status` stays 0 (the prototype getter's answer for a request whose real
-  // send never ran) — exactly what a genuine network error reports. The
-  // 'error'/'timeout' event is the entire signal; axios turns them into
-  // ERR_NETWORK / ECONNABORTED the same way whatwg-fetch turns RN's flags
-  // into TypeErrors.
-  setStandardReadyState(xhr, DONE);
-  fireEvent(xhr, outcome.failKind === "timeout" ? "timeout" : "error");
-  fireEvent(xhr, "loadend");
-}
-
-/**
- * Apply an outcome to a standards XMLHttpRequest that has NOT been sent.
- *
- * The real `send()` is never invoked for respond/fail — the request must not
- * touch the network. That leaves `abort()` with nothing to do natively (per
- * spec, abort on a request whose send flag is unset dispatches NOTHING), so
- * an instance shadow gives it the in-flight behaviour the app expects:
- * cancel the pending outcome and dispatch abort + loadend. The shadow deletes
- * itself the moment it can't matter anymore — after settling, and before a
- * `delay` pass-through hands the request to the real network, where the
- * prototype `abort()` must be reachable again.
- */
-function runStandardOverride(xhr, url, outcome, passThrough) {
-  let timer = null;
-  let aborted = false;
-  let settled = false;
-  const restoreAbort = () => {
-    try {
-      delete xhr.abort;
-    } catch {
-      // Non-configurable shadow can't happen (we define it configurable), but
-      // never let cleanup throw into app code.
-    }
-  };
-  Object.defineProperty(xhr, "abort", {
-    configurable: true,
-    writable: true,
-    value: () => {
-      if (settled || aborted) return;
-      aborted = true;
-      settled = true;
-      if (timer !== null) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      restoreAbort();
-      // The in-flight abort sequence: DONE, then 'abort', then 'loadend' —
-      // whatwg's request-error steps, which is also what RN's setReadyState
-      // dispatches off `_aborted`.
-      setStandardReadyState(xhr, DONE);
-      fireEvent(xhr, "abort");
-      fireEvent(xhr, "loadend");
-    }
-  });
-  const fire = () => {
-    timer = null;
-    if (aborted) return;
-    if (outcome.kind === "delay") {
-      // The real request is about to be genuinely in flight — put the
-      // prototype `abort()` back FIRST so cancelling reaches the network.
-      restoreAbort();
-      passThrough();
-      return;
-    }
-    if (outcome.kind === "fail") {
-      failStandard(xhr, outcome);
-    } else {
-      respondStandard(xhr, url, outcome, () => aborted);
-    }
-    settled = true;
-    restoreAbort();
-  };
-
-  // ALWAYS asynchronous, even at 0ms — same contract as the RN path: callers
-  // legitimately attach handlers after `send()` returns (axios does).
-  timer = setTimeout(fire, outcome.delayMs);
-  return true;
-}
-
-// ============================================================================
-// Entry point
-// ============================================================================
-
-/**
- * Apply an outcome to a request that has NOT been sent yet.
- *
- * Returns `false` when this environment can't be driven by hand, in which case
- * the caller must send the request normally.
- *
- * @param passThrough Sends the real request. Only used by `kind: "delay"`.
- */
-export function runOverride(xhr, url, outcome, passThrough) {
-  if (!canSynthesize(xhr)) {
-    // Not React Native's XMLHttpRequest — a standards one (webview port,
-    // react-native-web) is driven through instance property shadowing
-    // instead. Order matters: RN's XHR also extends an EventTarget shim, so
-    // the RN check must win first.
-    if (canSynthesizeStandard(xhr)) {
-      return runStandardOverride(xhr, url, outcome, passThrough);
-    }
-    warnUnsupported();
-    return false;
-  }
-  const internals = internalsOf(xhr);
-
-  // Claim the request as sent, for all three kinds.
-  //
-  // We skip RN's own `send()`, which is what normally sets this — and `abort()`
-  // branches on it: with `_sent` false it treats the request as never started,
-  // silently `_reset()`s, and dispatches NOTHING. The app's fetch promise would
-  // then never settle (a hang), and for a synthesized response our own timer
-  // would afterwards fire 'load' on a reset object, resolving a fetch the app
-  // had already aborted. Claiming it means abort() dispatches DONE + 'abort'
-  // and whatwg-fetch rejects with AbortError, as it should.
-  internals._sent = true;
-
-  // There is no native request to cancel until a delayed send is dispatched.
-  internals._requestId = null;
-  let timer = null;
-  const onAbort = () => {
-    xhr.removeEventListener("abort", onAbort);
-    if (timer !== null) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  };
-  xhr.addEventListener("abort", onAbort);
-  const fire = () => {
-    timer = null;
-    xhr.removeEventListener("abort", onAbort);
-    // The real guard. `_aborted` is set unconditionally by `abort()` and
-    // survives its `_reset()`, so this is true whether or not the 'abort' event
-    // was ever dispatched.
-    if (internals._aborted) return;
-    if (outcome.kind === "delay") {
-      // Hand the state machine back before RN's `send()` sees it: it throws
-      // 'Request has already been sent' on a truthy `_sent`.
-      internals._sent = false;
-      passThrough();
-      return;
-    }
-    if (outcome.kind === "fail") {
-      fail(xhr, outcome);
-      return;
-    }
-    respond(xhr, url, outcome);
-  };
-
-  // ALWAYS asynchronous, even at 0ms. Callers legitimately attach handlers
-  // after `send()` returns (axios does), and a synchronous response would fire
-  // 'load' before they exist.
-  timer = setTimeout(fire, outcome.delayMs);
-  return true;
-}
-
-/** Complete an already scheduled native outcome without adding another timer. */
-export function completeNativeOverride(xhr, url, outcome) {
-  if (outcome.kind === "fail") fail(xhr, outcome);else if (outcome.kind === "respond") respond(xhr, url, outcome);
-}
+"use strict";import{realClearTimeout as k,realNow as _,realSetTimeout as U}from"../utils/realNow";const m=2;const P=3;const v=4;const R=e=>e;let D=false;export function canSynthesize(e){const n=R(e);return typeof n.setReadyState==="function"&&typeof n.setResponseHeaders==="function"}export function canSynthesizeStandard(e){return typeof e.addEventListener==="function"&&typeof e.removeEventListener==="function"&&typeof e.dispatchEvent==="function"}function A(){if(D)return;D=true;if(typeof __DEV__!=="undefined"&&__DEV__){console.warn("[Buoy] Network overrides need an XMLHttpRequest they can drive (React Native's, or a standards EventTarget one) and this environment provides neither \u2014 requests will run normally.")}}function H(e,n,t){const r=R(e);r.responseURL=n;r.status=t.status;r.statusText=t.statusText;r.setResponseHeaders?.(t.headers);r.setReadyState?.(m);if(r._aborted)return;r._responseType="text";r._response=t.body;r._cachedResponse=void 0;r.setReadyState?.(P);if(r._aborted)return;r.setReadyState?.(v)}function N(e,n){const t=R(e);const r=n.failKind==="timeout";t._hasError=true;t._timedOut=r;t._responseType="text";t._response=r?"Request timed out (Buoy override)":"Network request failed (Buoy override)";t._cachedResponse=void 0;t.setReadyState?.(v)}function f(e,n,t){Object.defineProperty(e,n,{value:t,configurable:true,enumerable:true,writable:false})}function K(e){if(e!=="readystatechange"&&typeof ProgressEvent==="function"){try{return new ProgressEvent(e)}catch{}}if(typeof Event==="function"){try{return new Event(e)}catch{}}return{type:e}}function c(e,n){e.dispatchEvent(K(n))}function E(e,n){f(e,"readyState",n);c(e,"readystatechange")}function I(e,n){let t="";try{t=e.responseType}catch{}switch(t){case"":case"text":return n.body;case"json":try{return JSON.parse(n.body)}catch{return null}case"arraybuffer":if(typeof TextEncoder==="function"){return new TextEncoder().encode(n.body).buffer}return n.body;case"blob":if(typeof Blob==="function"){const r=Object.entries(n.headers).find(([s])=>s.toLowerCase()==="content-type")?.[1]??"";return new Blob([n.body],{type:r})}return n.body;default:return n.body}}function V(e,n,t,r){const s=t.headers;const i=Object.entries(s).map(([a,o])=>`${a.toLowerCase()}: ${o}\r
+`).join("");f(e,"getAllResponseHeaders",()=>i);f(e,"getResponseHeader",a=>{const o=String(a).toLowerCase();for(const[p,b]of Object.entries(s)){if(p.toLowerCase()===o)return b}return null});f(e,"responseURL",n);f(e,"status",t.status);f(e,"statusText",t.statusText);f(e,"response",I(e,t));f(e,"responseText",t.body);E(e,m);if(r())return;E(e,P);if(r())return;E(e,v);if(r())return;c(e,"load");c(e,"loadend")}function S(e,n){E(e,v);c(e,n.failKind==="timeout"?"timeout":"error");c(e,"loadend")}const y=new WeakMap;export function hasPendingStandardRequest(e){return y.has(e)}function z(e,n,t,r){const s=_();const i={};let a;let o;let p=false;let b=false;let g=false;let u=e.timeout;const M=e.abort;const q=e.open;const C=["abort","open","timeout","readyState","status","statusText","response","responseText","responseURL","getAllResponseHeaders","getResponseHeader"];const B=new Map(C.map(d=>[d,Object.getOwnPropertyDescriptor(e,d)]));let O=Object.getPrototypeOf(e);let w;while(O&&!w){w=Object.getOwnPropertyDescriptor(O,"timeout");O=Object.getPrototypeOf(O)}const l=()=>{p=true;if(y.get(e)===i)y.delete(e);clearTimeout(a);k(o);e.removeEventListener("loadend",l)};const L=()=>{l();for(const[d,j]of B){if(j)Object.defineProperty(e,d,j);else delete e[d]}e.timeout=u};const T=()=>{k(o);if(g){w?.set?.call(e,u>0?Math.max(1,u-(_()-s)):0)}else if(u>0){o=U(()=>{if(p)return;clearTimeout(a);S(e,{...t,kind:"fail",failKind:"timeout"});l()},Math.max(0,u-(_()-s)))}};Object.defineProperty(e,"timeout",{configurable:true,get:()=>u,set:d=>{u=Math.max(0,Number(d)||0);T()}});Object.defineProperty(e,"open",{configurable:true,value:(...d)=>{L();return Reflect.apply(q,e,d)}});Object.defineProperty(e,"abort",{configurable:true,value:()=>{if(g||p){L();M.call(e);return}b=true;clearTimeout(a);E(e,v);c(e,"abort");c(e,"loadend");l();if(!y.has(e))f(e,"readyState",0)}});y.set(e,i);e.addEventListener("loadend",l);T();a=setTimeout(()=>{if(p||b)return;if(t.kind==="delay"){g=true;T();try{r()}catch{S(e,{...t,kind:"fail",failKind:"network"});l()}return}if(t.kind==="fail")S(e,t);else V(e,n,t,()=>b||y.get(e)!==i);l()},t.delayMs);return true}export function runOverride(e,n,t,r){if(!canSynthesize(e)){if(canSynthesizeStandard(e)){return z(e,n,t,r)}A();return false}const s=R(e);s._sent=true;s._requestId=null;let i=null;const a=()=>{e.removeEventListener("abort",a);if(i!==null){clearTimeout(i);i=null}};e.addEventListener("abort",a);const o=()=>{i=null;e.removeEventListener("abort",a);if(s._aborted)return;if(t.kind==="delay"){s._sent=false;r();return}if(t.kind==="fail"){N(e,t);return}H(e,n,t)};i=setTimeout(o,t.delayMs);return true}export function completeNativeOverride(e,n,t){if(t.kind==="fail")N(e,t);else if(t.kind==="respond")H(e,n,t)}

package/lib/module/network/overrides/engine.js

@@ -1,85 +1 @@
-"use strict";
-
-import { hasAccountAccess } from "@buoy-gg/shared-ui";
-/**
- * The seam between the interceptor and the rule store.
- *
- * It exists to keep the import graph acyclic: `networkListener` needs rules,
- * and the rule store needs the listener (to keep the swizzle installed while a
- * rule is active). Rather than have them import each other, the store REGISTERS
- * itself here and the listener asks here. Both sides import only this leaf.
- *
- * It's also the single place the production gate lives — see `overrideForRequest`.
- */
-
-import { findMatchingRule, shouldApply, toOutcome } from "./resolveOverride";
-let hooks = null;
-export function setOverrideHooks(next) {
-  hooks = next;
-}
-
-/**
- * Whether a rule stored right now could ever be applied to a request.
- *
- * `overrideForRequest` refuses in a release build, but every WRITE path
- * (`upsertOverrideRule`, `setOverrideRuleEnabled`, `setOverridesEnabled`) still
- * succeeds and still persists, so a remote caller was told `{ok: true}` for a
- * rule that would never fire. That is fine for a human looking at the Network
- * tool — they can see nothing is happening — and actively harmful for a remote
- * driver relaying "done" to a QA tester, who then files a bug against data that
- * was never actually faked.
- *
- * So the same gate is readable here and stamped onto those receipts. One
- * predicate, one truth, at the same single entry point.
- */
-export function overridesCanApply() {
-  // `__DEV__` is undefined outside React Native (unit tests, the desktop
-  // bundle); only an explicit `false` — a real release build — disables it.
-  return hasAccountAccess() && !(typeof __DEV__ !== "undefined" && !__DEV__);
-}
-
-/** Why overrides are inert, for a caller that has to explain it to a person. */
-export const OVERRIDES_INACTIVE_REASON = "Response overrides never apply in a release build — the rule is saved but will not affect any request.";
-
-/**
- * Diagnostics for the sync adapter's `debugOverrides` action.
- *
- * Reads the engine's own view of the world — crucially `hooks`, which is
- * MODULE state here: if the interceptor and the rule store ever ended up with
- * separate copies of this file, this is the only place that shows it.
- */
-export function inspectEngine(url, method) {
-  return {
-    hooksInstalled: hooks !== null,
-    devFlag: typeof __DEV__ === "undefined" ? "undefined" : __DEV__,
-    ruleCount: hooks ? hooks.getRules().length : 0,
-    // Non-recording probe — a diagnostic must not burn a rule's `times` budget
-    // or nudge an alternating rule's phase.
-    matches: hooks ? findMatchingRule(url, method, hooks.getRules()) !== null : false
-  };
-}
-
-/**
- * Resolve an override for one outgoing request, recording the hit.
- *
- * NEVER ACTIVE IN A PRODUCTION BUILD. A shipped app that synthesizes 500s or
- * silently swallows requests is a catastrophe of a different order than a
- * broken dev tool, so the gate is here — at the single entry point — rather
- * than trusted to every call site.
- */
-export function overrideForRequest(url, method) {
-  if (!hooks) return null;
-  if (!overridesCanApply()) return null;
-  const rules = hooks.getRules();
-  if (rules.length === 0) return null;
-  const rule = findMatchingRule(url, method, rules);
-  if (!rule) return null;
-
-  // Phase is read BEFORE the match is recorded, so a fresh alternating rule
-  // (`seen === 0`) lets this first request through and takes the next one.
-  const applies = shouldApply(rule);
-  hooks.recordMatch(rule.id);
-  if (!applies) return null;
-  hooks.recordHit(rule.id);
-  return toOutcome(rule);
-}
+"use strict";import{hasAccountAccess as i}from"@buoy-gg/shared-ui";import{findMatchingRule as u,shouldApply as c,toOutcome as d}from"./resolveOverride";let e=null;export function setOverrideHooks(n){e=n}export function overridesCanApply(){return i()&&!(typeof __DEV__!=="undefined"&&!__DEV__)}export const OVERRIDES_INACTIVE_REASON="Response overrides never apply in a release build \u2014 the rule is saved but will not affect any request.";export function inspectEngine(n,r){return{hooksInstalled:e!==null,devFlag:typeof __DEV__==="undefined"?"undefined":__DEV__,ruleCount:e?e.getRules().length:0,matches:e?u(n,r,e.getRules())!==null:false}}export function overrideForRequest(n,r,o){if(!e)return null;if(!overridesCanApply())return null;const l=e.getRules();if(l.length===0)return null;const t=u(n,r,l,o);if(!t)return null;const s=c(t);e.recordMatch(t.id);if(!s)return null;e.recordHit(t.id);return d(t)}

package/lib/module/network/overrides/matchRule.js

@@ -1,75 +1 @@
-"use strict";
-
-/**
- * Glob matching for override rules — a faithful port of Chrome DevTools'.
- *
- * Ported from `NetworkPersistenceManager.ts:1051` + `StringUtilities.ts:9` in
- * the devtools-frontend source. Ported rather than reinvented on purpose: `*`
- * globs are the syntax developers already have in their fingers from Chrome's
- * "Override headers" `applyTo` field, and a pattern that behaves differently
- * here than it does in the browser would be a quiet trap.
- */
-
-/**
- * Chrome's escape set, character for character.
- *
- * `*` is deliberately ABSENT — it survives escaping so it can become `.*`
- * below. Everything else that means something to a regex is neutered.
- */
-const SPECIAL_CHARACTERS = "[]{}()\\.^$+|-,?";
-
-/**
- * Escape a glob into regex source: neutralize regex metacharacters, then
- * promote `*` to `.*`.
- *
- * `split`/`join` rather than `replaceAll` — same result, no reliance on how
- * complete a given Hermes build's ES2021 surface is.
- */
-export function escapeRegex(pattern) {
-  let result = "";
-  for (let i = 0; i < pattern.length; i++) {
-    const char = pattern.charAt(i);
-    if (SPECIAL_CHARACTERS.indexOf(char) !== -1) {
-      result += "\\";
-    }
-    result += char;
-  }
-  return result.split("*").join(".*");
-}
-
-/**
- * Compiled patterns, cached by source.
- *
- * `resolveOverride` runs on EVERY request the app makes, against every rule.
- * Recompiling a RegExp per request per rule is pure waste in the one place
- * this feature is allowed to cost nothing.
- */
-const compiled = new Map();
-export function compilePattern(pattern) {
-  const cached = compiled.get(pattern);
-  if (cached) return cached;
-  // Anchored, like Chrome's `^${...}$` — a pattern describes the whole URL, so
-  // `pokeapi.co` matches nothing and `*pokeapi.co*` matches everything on that
-  // host. Predictable beats clever; the rule editor writes full URLs for you.
-  const regex = new RegExp(`^${escapeRegex(pattern)}$`);
-  // Unbounded growth isn't possible in practice (patterns come from a capped
-  // rule list), but a user editing a pattern character by character churns
-  // entries, so keep the cache from becoming a leak.
-  if (compiled.size > 200) compiled.clear();
-  compiled.set(pattern, regex);
-  return regex;
-}
-
-/** Does this rule apply to this request? Ignores `enabled` — callers check it. */
-export function ruleMatches(rule, url, method) {
-  if (rule.methods && rule.methods.length > 0) {
-    if (!rule.methods.includes(method.toUpperCase())) return false;
-  }
-  try {
-    return compilePattern(rule.urlPattern).test(url);
-  } catch {
-    // A pattern that can't compile matches nothing rather than throwing inside
-    // the app's `send()`. The rule editor validates; this is the backstop.
-    return false;
-  }
-}
+"use strict";const o="[]{}()\\.^$+|-,?";export function escapeRegex(e){let r="";for(let n=0;n<e.length;n++){const t=e.charAt(n);if(o.indexOf(t)!==-1){r+="\\"}r+=t}return r.split("*").join(".*")}const s=new Map;export function compilePattern(e){const r=s.get(e);if(r)return r;const n=e.startsWith("/")?`[a-zA-Z][a-zA-Z0-9+.-]*://[^/]*${escapeRegex(e)}`:escapeRegex(e);const t=new RegExp(`^${n}$`);if(s.size>200)s.clear();s.set(e,t);return t}function c(e,r){if(!e)return false;const n=r.toLowerCase();for(const t of Object.keys(e)){if(t.toLowerCase()===n&&e[t]!==void 0&&e[t]!=="")return true}return false}export function ruleMatches(e,r,n,t){if(e.methods&&e.methods.length>0){if(!e.methods.includes(n.toUpperCase()))return false}if(e.requireHeader&&!c(t,e.requireHeader))return false;try{return compilePattern(e.urlPattern).test(r)}catch{return false}}

package/lib/module/network/overrides/overriddenRows.js

@@ -0,0 +1 @@
+"use strict";import{ruleMatches as s}from"./matchRule";export function overriddenEvents(o,d){if(d.length===0)return[];const n=new Set(d.map(t=>t.id));const i=new Set;for(const t of d){let r;for(const e of o){if(e.override&&n.has(e.override.ruleId)){i.add(e.id);continue}if(!s(t,e.url,String(e.method||"GET"),e.requestHeaders))continue;if(e.timestamp>=t.createdAt)i.add(e.id);else if(!r||e.timestamp>r.timestamp)r=e}if(r)i.add(r.id)}return o.filter(t=>i.has(t.id))}