@avasapp/agent-bridge 0.4.2 → 0.6.0

package/dist/adapters/device.cjs

@@ -0,0 +1,1110 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/device.ts
+var device_exports = {};
+__export(device_exports, {
+  deviceTools: () => deviceTools
+});
+module.exports = __toCommonJS(device_exports);
+
+// src/adapters/device/types.ts
+var KEY = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/device");
+function deviceState() {
+  const g = globalThis;
+  return g[KEY] ?? (g[KEY] = {});
+}
+function loadReactNative() {
+  return require("react-native");
+}
+
+// src/adapters/device/app-state.ts
+var STATES = ["active", "background", "inactive"];
+function emitState(rn, state) {
+  const st = deviceState();
+  st.emitting = true;
+  try {
+    rn.DeviceEventEmitter.emit("appStateDidChange", { app_state: state });
+    if (rn.Platform?.OS === "android") rn.DeviceEventEmitter.emit("appStateFocusChange", state === "active");
+  } finally {
+    st.emitting = false;
+  }
+}
+function appStateArea(rn) {
+  const restore = () => {
+    const st = deviceState();
+    const faked = st.appState;
+    if (!faked) return { restored: false };
+    const { AppState } = rn();
+    delete st.appState;
+    delete AppState.currentState;
+    AppState.currentState = faked.real;
+    if (faked.real !== faked.fake) emitState(rn(), faked.real);
+    return { restored: true, state: faked.real };
+  };
+  return {
+    pending: () => {
+      const faked = deviceState().appState;
+      return faked ? { state: faked.fake, real: faked.real } : null;
+    },
+    restore,
+    tools: {
+      "device.appState": {
+        description: 'Move the app to "active", "background" or "inactive": every AppState change listener fires and AppState.currentState reports it until device.restore. Real native changes still reach listeners meanwhile. Returns { state, previous }.',
+        maxArgs: 1,
+        run: (state) => {
+          if (typeof state !== "string" || !STATES.includes(state))
+            throw new Error(`Pass one of: ${STATES.join(", ")}`);
+          const native = rn();
+          const { AppState } = native;
+          const st = deviceState();
+          const previous = st.appState?.fake ?? AppState.currentState;
+          if (!st.appState) {
+            const faked = { fake: state, real: AppState.currentState };
+            st.appState = faked;
+            Object.defineProperty(AppState, "currentState", {
+              configurable: true,
+              enumerable: true,
+              get: () => deviceState().appState?.fake ?? faked.real,
+              set: (value) => {
+                if (!deviceState().emitting && deviceState().appState) deviceState().appState.real = value;
+              }
+            });
+          } else st.appState.fake = state;
+          emitState(native, state);
+          return { state, previous };
+        }
+      }
+    }
+  };
+}
+
+// src/adapters/device/clock.ts
+function clockArea() {
+  const restore = () => {
+    const st = deviceState();
+    if (!st.RealDate) return { restored: false };
+    globalThis.Date = st.RealDate;
+    st.RealDate.prototype.constructor = st.RealDate;
+    delete st.RealDate;
+    delete st.offsetMs;
+    return { restored: true };
+  };
+  const install2 = () => {
+    const st = deviceState();
+    const Real = st.RealDate ?? (st.RealDate = globalThis.Date);
+    const now2 = () => Real.now() + (deviceState().offsetMs ?? 0);
+    const proxy = new Proxy(Real, {
+      construct: (target, args, newTarget) => Reflect.construct(target, args.length ? args : [now2()], newTarget),
+      apply: () => new Real(now2()).toString(),
+      get: (target, key) => key === "now" ? now2 : Reflect.get(target, key)
+    });
+    Real.prototype.constructor = proxy;
+    globalThis.Date = proxy;
+  };
+  return {
+    pending: () => {
+      const { RealDate, offsetMs } = deviceState();
+      return RealDate ? { offsetMs, now: (/* @__PURE__ */ new Date()).toISOString() } : null;
+    },
+    restore,
+    tools: {
+      "device.setTime": {
+        description: 'Fake the clock: ["2026-12-25T09:00:00Z"] or [{ offsetMs: 86400000 }] shifts Date.now() and new Date() app-wide until device.restore. Timers, performance.now and values read earlier are not shifted, and react-query only rechecks staleness on its next trigger (follow with device.appState "active"). Returns { offsetMs, now }.',
+        maxArgs: 1,
+        run: (to) => {
+          const st = deviceState();
+          const real = (st.RealDate ?? Date).now();
+          let offsetMs;
+          if (typeof to === "string") {
+            const at = (st.RealDate ?? Date).parse(to);
+            if (Number.isNaN(at)) throw new Error('Pass an ISO date, e.g. "2026-12-25T09:00:00Z"');
+            offsetMs = at - real;
+          } else if (to && typeof to === "object" && Number.isFinite(to.offsetMs))
+            offsetMs = to.offsetMs;
+          else throw new Error("Pass an ISO date or { offsetMs }");
+          st.offsetMs = offsetMs;
+          if (!st.RealDate || globalThis.Date === st.RealDate) install2();
+          return { offsetMs, now: (/* @__PURE__ */ new Date()).toISOString() };
+        }
+      }
+    }
+  };
+}
+
+// src/runtime/screen/settle.ts
+var STATE = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/commits");
+var UPDATE_LANES = (1 << 22) - 1;
+var hook = () => globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+var now = () => performance.now();
+function install() {
+  const h = hook();
+  if (!h) return null;
+  const current = h.onCommitFiberRoot;
+  const existing = current?.[STATE];
+  if (existing) return existing;
+  const state = { commits: 0, listeners: /* @__PURE__ */ new Set() };
+  const wrapped = function(...args) {
+    state.commits += 1;
+    for (const listener of state.listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+    return current?.apply(this, args);
+  };
+  Object.defineProperty(wrapped, STATE, { value: state });
+  h.onCommitFiberRoot = wrapped;
+  return state;
+}
+function busy() {
+  const h = hook();
+  if (!h?.renderers || !h.getFiberRoots) return false;
+  for (const id of h.renderers.keys()) {
+    for (const root of h.getFiberRoots(id)) {
+      const pending = root.pendingLanes;
+      if (typeof pending !== "number") continue;
+      if (pending & ~(root.suspendedLanes ?? 0) & UPDATE_LANES) return true;
+    }
+  }
+  return false;
+}
+var frame = () => new Promise((resolve) => {
+  const raf = globalThis.requestAnimationFrame;
+  if (raf) raf(() => resolve());
+  else setTimeout(resolve, 16);
+});
+async function settle(options = {}) {
+  const maxMs = options.maxMs ?? 500;
+  const t0 = now();
+  const state = install();
+  const start = state?.commits ?? 0;
+  const result = () => ({
+    commits: (state?.commits ?? 0) - start,
+    ms: Math.round((now() - t0) * 100) / 100
+  });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  if (!state) return result();
+  let seen = state.commits;
+  if (seen === start && !busy()) return result();
+  while (now() - t0 < maxMs) {
+    await frame();
+    if (state.commits === seen && !busy()) break;
+    seen = state.commits;
+  }
+  return result();
+}
+
+// src/adapters/expo-router-route.ts
+var ROOT = "__root";
+var NOT_FOUND = "+not-found";
+var SETTLE_MS = 1e3;
+var decode = (value) => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+var isGroup = (segment) => segment.startsWith("(") && segment.endsWith(")");
+var focused = (state) => state.routes[state.index ?? 0];
+function routeFromState(state) {
+  let route = state && focused(state);
+  if (!route) return { pathname: "/", href: "/", params: {}, segments: [], name: "" };
+  if (route.name !== ROOT) {
+    const path = route.path ?? (route.name === NOT_FOUND ? "/" : `/${route.name}`);
+    return { pathname: path, href: path, params: {}, segments: [route.name], name: route.name };
+  }
+  const segments = [];
+  const raw = {};
+  let name = "";
+  let next = route.state;
+  while (next && (route = focused(next))) {
+    Object.assign(raw, route.params);
+    name = route.name;
+    segments.push(...route.name.replace(/^\//, "").split("/"));
+    next = route.state;
+  }
+  let pending = route?.params;
+  while (pending && typeof pending.screen === "string") {
+    segments.push(...pending.screen.replace(/^\//, "").split("/"));
+    name = pending.screen;
+    pending = pending.params && typeof pending.params === "object" ? pending.params : void 0;
+  }
+  if (segments.at(-1) === "index") segments.pop();
+  delete raw.screen;
+  delete raw.params;
+  const params = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string") params[key] = decode(value);
+    else if (Array.isArray(value)) params[key] = value.map((v) => decode(String(v)));
+    else if (value != null) params[key] = String(value);
+  }
+  const inPath = /* @__PURE__ */ new Set();
+  const fill = (key) => {
+    inPath.add(key);
+    const value = params[key];
+    return value === void 0 ? [] : Array.isArray(value) ? value : [value];
+  };
+  const pathname = "/" + segments.filter((s) => !isGroup(s)).flatMap((s) => {
+    if (s === NOT_FOUND) return fill("not-found");
+    if (s.startsWith("[...") && s.endsWith("]")) return fill(s.slice(4, -1).replace(/\?$/, ""));
+    if (s.startsWith("[") && s.endsWith("]")) return fill(s.slice(1, -1));
+    return [s];
+  }).join("/");
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params))
+    if (!inPath.has(key)) for (const v of [value].flat()) search.append(key, v);
+  const query = search.toString();
+  return { pathname, href: query ? `${pathname}?${query}` : pathname, params, segments, name };
+}
+function settle2(navigation, go) {
+  return new Promise((resolve, reject) => {
+    let off;
+    const done = () => {
+      off?.();
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(done, navigation.addListener ? SETTLE_MS : 0);
+    off = navigation.addListener?.("__unsafe_action__", done);
+    try {
+      go();
+    } catch (error) {
+      off?.();
+      clearTimeout(timer);
+      reject(error);
+    }
+  });
+}
+
+// src/adapters/device/link.ts
+var expoLinking = () => globalThis.expo?.modules?.ExpoLinking;
+function linkArea(rn, navigation) {
+  const restore = () => {
+    const st = deviceState();
+    const had = st.origGetInitialURL !== void 0;
+    if (had) rn().Linking.getInitialURL = st.origGetInitialURL;
+    const url = st.initialUrl;
+    delete st.origGetInitialURL;
+    delete st.initialUrl;
+    return { restored: had, ...url && { url } };
+  };
+  return {
+    pending: () => {
+      const { initialUrl } = deviceState();
+      return initialUrl ? { initialUrl } : null;
+    },
+    restore,
+    tools: {
+      "device.openUrl": {
+        description: 'Deliver an incoming deep link, e.g. ["myapp://orders/5"], to every Linking "url" listener and, when the native expo-linking module exists, its useLinkingURL() hook without leaving the app, and make Linking.getInitialURL() return it until device.restore. getLinkingURL() still reads the native value. A cold start already read its URL, so this tests links that arrive while the app runs. Returns { url, listeners } and, with the navigation container, the route the app ended on.',
+        maxArgs: 1,
+        run: async (url) => {
+          if (typeof url !== "string" || !url) throw new Error('Pass the URL, e.g. "myapp://orders/5"');
+          const { Linking, DeviceEventEmitter } = rn();
+          const st = deviceState();
+          if (st.origGetInitialURL === void 0) {
+            st.origGetInitialURL = Linking.getInitialURL;
+            Linking.getInitialURL = () => Promise.resolve(deviceState().initialUrl ?? null);
+          }
+          st.initialUrl = url;
+          const native = expoLinking();
+          const emit = () => {
+            DeviceEventEmitter.emit("url", { url });
+            if (typeof native?.emit === "function") native.emit("onURLReceived", { url });
+          };
+          const listeners2 = DeviceEventEmitter.listenerCount?.("url");
+          if (!navigation || navigation.isReady && !navigation.isReady()) {
+            emit();
+            return { url, listeners: listeners2 };
+          }
+          await settle2(navigation, emit);
+          await settle();
+          const route = routeFromState(navigation.getRootState());
+          return { url, listeners: listeners2, route };
+        }
+      }
+    }
+  };
+}
+
+// src/adapters/device/notification.ts
+var count = 0;
+function emitter(rn) {
+  const native = globalThis.expo?.modules?.ExpoNotificationsEmitter;
+  return typeof native?.emit === "function" ? { target: native, via: "ExpoNotificationsEmitter" } : { target: rn.DeviceEventEmitter, via: "DeviceEventEmitter" };
+}
+function notificationArea(rn, Notifications) {
+  return {
+    pending: () => null,
+    restore: () => ({}),
+    tools: {
+      "device.notification": {
+        description: "Deliver a push notification to expo-notifications listeners: [{ title?, body?, data? }, { tapped? }]. By default addNotificationReceivedListener fires (app open); { tapped: true } fires addNotificationResponseReceivedListener with the default action, as if the user tapped it. Returns { id, event, via, listeners }: which emitter it used and how many listeners it reached (0 means nothing heard it).",
+        maxArgs: 2,
+        run: (content, options = {}) => {
+          if (!content || typeof content !== "object" || Array.isArray(content))
+            throw new Error("Pass { title, body, data }");
+          const { tapped } = options ?? {};
+          const { title = null, body = null, data = {}, ...rest } = content;
+          const id = `agent-bridge-${++count}`;
+          const notification = {
+            date: Date.now() / 1e3,
+            request: {
+              identifier: id,
+              content: { title, body, subtitle: null, sound: null, badge: null, data, ...rest },
+              trigger: { type: "push" }
+            }
+          };
+          const { target, via } = emitter(rn());
+          const send = (event, payload) => {
+            target.emit(event, payload);
+            return target.listenerCount?.(event);
+          };
+          if (tapped) {
+            const listeners3 = send("onDidReceiveNotificationResponse", {
+              notification,
+              actionIdentifier: Notifications.DEFAULT_ACTION_IDENTIFIER ?? "expo.modules.notifications.actions.DEFAULT"
+            });
+            return { id, event: "response", via, listeners: listeners3 };
+          }
+          const listeners2 = send("onDidReceiveNotification", notification);
+          return { id, event: "received", via, listeners: listeners2 };
+        }
+      }
+    }
+  };
+}
+
+// src/shared/mock-signal.ts
+var KEY2 = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/mock-signal");
+var listeners = () => {
+  const g = globalThis;
+  return g[KEY2] ?? (g[KEY2] = /* @__PURE__ */ new Set());
+};
+var signalRequestStarted = (requestId) => {
+  for (const l of [...listeners()]) l.started?.(requestId);
+};
+var signalMockAnswered = (mockId, requestId) => {
+  for (const l of [...listeners()]) l.answered?.(mockId, requestId);
+};
+
+// src/network/api.ts
+function queryOf(url) {
+  const search = /\?([^#]*)/.exec(url)?.[1];
+  const out = {};
+  if (!search) return out;
+  for (const pair of search.split("&")) {
+    if (!pair) continue;
+    const [key, value = ""] = pair.split("=");
+    const decode2 = (s) => {
+      try {
+        return decodeURIComponent(s.replace(/\+/g, " "));
+      } catch {
+        return s;
+      }
+    };
+    out[decode2(key)] = decode2(value);
+  }
+  return out;
+}
+
+// src/network/body.ts
+var MAX_BODY = 2048;
+var MAX_FULL_BODY = 1e6;
+var FULL_BUDGET = 4e6;
+function compactBody(text) {
+  if (text === void 0 || text === "") return void 0;
+  try {
+    return JSON.stringify(JSON.parse(text));
+  } catch {
+    return text;
+  }
+}
+function truncateBody(text) {
+  return text.length > MAX_BODY ? `${text.slice(0, MAX_BODY)}\u2026 (+${text.length - MAX_BODY} chars)` : text;
+}
+function bodyText(body) {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") return body;
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams)
+    return body.toString();
+  if (typeof FormData !== "undefined" && body instanceof FormData)
+    return "[FormData]";
+  if (typeof Blob !== "undefined" && body instanceof Blob)
+    return `[Blob ${body.size} bytes]`;
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body))
+    return `[binary ${body.byteLength} bytes]`;
+  return String(body);
+}
+function isTextual(contentType) {
+  if (!contentType) return true;
+  if (/event-stream/i.test(contentType)) return false;
+  return /json|text|xml|javascript|x-www-form-urlencoded/i.test(contentType);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/network/headers.ts
+var lower = (headers) => Object.fromEntries(Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v]));
+function keepHeaders(headers) {
+  return headers && Object.keys(headers).length ? lower(headers) : void 0;
+}
+function parseHeaderBlock(block) {
+  const out = {};
+  for (const line of (block ?? "").split(/\r?\n/)) {
+    const at = line.indexOf(":");
+    if (at <= 0) continue;
+    const name = line.slice(0, at).trim().toLowerCase();
+    const value = line.slice(at + 1).trim();
+    out[name] = name in out ? `${out[name]}, ${value}` : value;
+  }
+  return out;
+}
+
+// src/network/match.ts
+function operationName(probe) {
+  const json = probe.json();
+  if (json && typeof json === "object" && !Array.isArray(json)) {
+    const name = json.operationName;
+    if (typeof name === "string") return name;
+  }
+  return queryOf(probe.url).operationName;
+}
+
+// src/network/state.ts
+var LOG_SIZE = 100;
+var KEY3 = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/network");
+function networkState() {
+  const g = globalThis;
+  g[KEY3] ?? (g[KEY3] = {
+    installed: false,
+    log: [],
+    nextLogId: 1,
+    logSize: LOG_SIZE,
+    mocks: [],
+    nextSeq: 1,
+    insideFetch: 0,
+    devHost: null,
+    skip: [],
+    uninstall: [],
+    strictApp: [],
+    strictAgent: null,
+    blocked: /* @__PURE__ */ new Map()
+  });
+  return g[KEY3];
+}
+var URL_PARTS = /^(?:[a-z][a-z0-9+.-]*:)?(?:\/\/([^/?#]*))?([^?#]*)/i;
+var hostOf = (url) => URL_PARTS.exec(url)?.[1] ?? "";
+var pathOf = (url) => URL_PARTS.exec(url)?.[2] ?? "";
+var DEV_PATH = /^\/(symbolicate|logs|status|hot|message|inspector|expo-dev-plugins|_expo)(\/.*)?$|\.(bundle|map)$/;
+function isSkipped(state, url) {
+  const host = hostOf(url);
+  if (state.devHost && host === state.devHost) return true;
+  if (DEV_PATH.test(pathOf(url))) return true;
+  return state.skip.some(
+    (rule) => typeof rule === "string" ? url.includes(rule) : rule.test(url)
+  );
+}
+function deriveDevHost() {
+  try {
+    const rn = require("react-native");
+    const module2 = rn.TurboModuleRegistry?.get?.("SourceCode") ?? rn.NativeModules?.SourceCode;
+    const scriptURL = module2?.getConstants?.().scriptURL ?? module2?.scriptURL;
+    return typeof scriptURL === "string" && /^https?:/i.test(scriptURL) ? hostOf(scriptURL) || null : null;
+  } catch {
+    return null;
+  }
+}
+var FULL = /* @__PURE__ */ new WeakMap();
+var fullOf = (entry) => {
+  let full = FULL.get(entry);
+  if (!full) FULL.set(entry, full = {});
+  return full;
+};
+function enforceBudget() {
+  const { log } = networkState();
+  const size = (f) => (f?.requestBody?.length ?? 0) + (f?.responseBody?.length ?? 0);
+  let total = log.reduce((sum, e) => sum + size(FULL.get(e)), 0);
+  for (const entry of log) {
+    if (total <= FULL_BUDGET) return;
+    const full = FULL.get(entry);
+    if (!full || !size(full)) continue;
+    total -= size(full);
+    delete full.requestBody;
+    if (full.responseBody !== void 0) {
+      delete full.responseBody;
+      full.response = "evicted";
+    }
+  }
+}
+function keepRequestBody(entry, text) {
+  const body = compactBody(text);
+  if (body === void 0) return;
+  entry.requestBody = truncateBody(body);
+  if (text.length <= MAX_FULL_BODY) {
+    fullOf(entry).requestBody = text;
+    enforceBudget();
+  }
+}
+function setResponseBody(entry, text, contentType) {
+  const full = fullOf(entry);
+  if (contentType !== void 0) full.contentType = contentType;
+  if (text === void 0) {
+    full.response = "none";
+    return;
+  }
+  const body = compactBody(text);
+  if (body !== void 0) entry.responseBody = truncateBody(body);
+  if (text.length > MAX_FULL_BODY) {
+    full.response = "cut";
+    return;
+  }
+  full.responseBody = text;
+  full.response = "kept";
+  enforceBudget();
+}
+function markResponse(entry, response) {
+  fullOf(entry).response = response;
+}
+function startEntry(state, fields) {
+  const entry = {
+    id: state.nextLogId++,
+    method: fields.method,
+    url: fields.url,
+    startedAt: Date.now(),
+    ms: 0,
+    pending: true
+  };
+  keepRequestBody(entry, fields.requestBody);
+  const requestHeaders = keepHeaders(fields.requestHeaders);
+  if (requestHeaders) fullOf(entry).requestHeaders = requestHeaders;
+  state.log.push(entry);
+  signalRequestStarted(entry.id);
+  if (state.log.length > state.logSize)
+    state.log.splice(0, state.log.length - state.logSize);
+  return entry;
+}
+function finishEntry(entry, fields) {
+  entry.ms = Date.now() - entry.startedAt;
+  delete entry.pending;
+  const { responseBody, contentType, responseHeaders, ...rest } = fields;
+  const kept = keepHeaders(responseHeaders);
+  if (kept) fullOf(entry).responseHeaders = kept;
+  for (const [key, value] of Object.entries(rest))
+    if (value !== void 0) entry[key] = value;
+  if (responseBody !== void 0) setResponseBody(entry, responseBody, contentType);
+}
+function setRequestBody(entry, text) {
+  if (entry.requestBody === void 0) keepRequestBody(entry, text);
+}
+function removeMocks(state, which) {
+  const before = state.mocks.length;
+  state.mocks = state.mocks.filter((m) => !which(m));
+  return before - state.mocks.length;
+}
+var mockOrder = (a, b) => Number(b.source === "agent") - Number(a.source === "agent") || b.priority - a.priority || b.seq - a.seq;
+function setDeviceOffline(offline) {
+  networkState().deviceOffline = offline;
+}
+function matchingMocks(state, method, url, body) {
+  if (state.deviceOffline) return [];
+  const found = state.mocks.filter((m) => m.test(method, url));
+  const probe = body && found.some((m) => m.needsBody) ? mockRequest(method, url, {}, body.text) : null;
+  return found.filter((m) => !m.needsBody || !probe || m.testBody(probe)).sort(mockOrder);
+}
+async function answer(state, candidates, request, bodyKnown = true) {
+  for (const mock of candidates) {
+    if (mock.needsBody && !bodyKnown && !mock.testBody(await request())) continue;
+    if (!state.mocks.includes(mock)) continue;
+    const response = typeof mock.response === "function" ? await mock.response(await request()) : mock.response;
+    if (!response || !state.mocks.includes(mock)) continue;
+    mock.hits += 1;
+    if (mock.times !== void 0 && mock.hits >= mock.times)
+      removeMocks(state, (m) => m === mock);
+    return { mock, response };
+  }
+  return null;
+}
+function mockRequest(method, url, headers, body) {
+  let parsed;
+  return {
+    method,
+    url,
+    headers,
+    body,
+    json: () => {
+      if (!parsed) {
+        try {
+          parsed = { value: body === void 0 ? void 0 : JSON.parse(body) };
+        } catch {
+          parsed = { value: void 0 };
+        }
+      }
+      return parsed.value;
+    }
+  };
+}
+var contentTypeOf = (headers) => Object.entries(headers).find(([k]) => k.toLowerCase() === "content-type")?.[1];
+function responseParts(response) {
+  const r = response;
+  const status = r.status ?? 200;
+  if (r.json !== void 0)
+    return {
+      status,
+      text: JSON.stringify(r.json),
+      headers: { "content-type": "application/json", ...r.headers }
+    };
+  return { status, text: r.body ?? "", headers: { ...r.headers } };
+}
+function strictRules(state) {
+  if (state.strictAgent === false) return [];
+  return state.strictAgent ? [state.strictAgent, ...state.strictApp] : state.strictApp;
+}
+var BLOCKED_HEADER = "x-agent-bridge";
+function blockedResponse(state, method, url, body) {
+  if (state.deviceOffline) return { offline: true };
+  const rules = strictRules(state);
+  if (!rules.length || rules.some((r) => r.allow.some((test) => test(url))))
+    return null;
+  const operation = operationName(mockRequest(method, url, {}, body));
+  const key = operation ? `${method} ${url} (${operation})` : `${method} ${url}`;
+  const probe = mockRequest(method, url, {}, body);
+  const near = state.mocks.filter((m) => m.needsBody && m.test(method, url) && !m.testBody(probe)).map((m) => m.id);
+  const seen = state.blocked.get(key);
+  if (seen) seen.count += 1;
+  else state.blocked.set(key, { method, url, count: 1, ...operation && { operation } });
+  const error = `agent-bridge strict network: no mock for ${key}${near.length ? ` (${near.join(", ")} matched the URL but not the body)` : ""}`;
+  console.error(`${error}. Mock it, or allow it in strict mode.`);
+  if (rules[0].offline) return { offline: true };
+  return {
+    status: rules[0].status,
+    json: { error },
+    headers: { [BLOCKED_HEADER]: "blocked" }
+  };
+}
+var isOffline = (response) => response.offline === true;
+var OFFLINE_MESSAGE = "Network request failed";
+var sleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+
+// src/network/fetch.ts
+function headersRecord(headers) {
+  const out = {};
+  if (!headers) return out;
+  const h = headers;
+  if (Array.isArray(headers)) {
+    for (const [key, value] of headers) out[String(key).toLowerCase()] = String(value);
+  } else if (typeof h.forEach === "function") {
+    h.forEach((value, key) => {
+      out[key.toLowerCase()] = value;
+    });
+  } else {
+    for (const [key, value] of Object.entries(headers))
+      out[key.toLowerCase()] = String(value);
+  }
+  return out;
+}
+var nullBody = (status) => [101, 204, 205, 304].includes(status);
+function mockedResponse(response) {
+  const { status, text, headers } = responseParts(response);
+  const body = nullBody(status) ? null : text;
+  if (typeof Response !== "undefined")
+    return new Response(body, { status, headers });
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: "",
+    url: "",
+    headers: { get: (name) => headers[name.toLowerCase()] ?? null },
+    text: async () => text,
+    json: async () => JSON.parse(text),
+    clone() {
+      return mockedResponse(response);
+    }
+  };
+}
+function abortError() {
+  const error = new Error("Aborted");
+  error.name = "AbortError";
+  return error;
+}
+function patchFetch(state) {
+  const g = globalThis;
+  const original = g.fetch;
+  if (typeof original !== "function") return null;
+  const callOriginal = (input, init) => {
+    state.insideFetch += 1;
+    try {
+      return original.call(globalThis, input, init);
+    } finally {
+      state.insideFetch -= 1;
+    }
+  };
+  const wrapped = function fetch(input, init) {
+    const req = typeof input === "object" && input ? input : {};
+    const url = typeof input === "string" ? input : req.url ?? String(input);
+    if (isSkipped(state, url)) return callOriginal(input, init);
+    const method = String(init?.method ?? req.method ?? "GET").toUpperCase();
+    let requestBody = bodyText(init?.body);
+    const entry = startEntry(state, {
+      method,
+      url,
+      requestBody,
+      requestHeaders: headersRecord(init?.headers ?? req.headers)
+    });
+    const real = () => {
+      let promise;
+      try {
+        promise = callOriginal(input, init);
+      } catch (error) {
+        finishEntry(entry, { error: errorMessage(error) });
+        throw error;
+      }
+      return promise.then(
+        (res) => {
+          finishEntry(entry, { status: res.status, responseHeaders: headersRecord(res.headers) });
+          const type = res.headers?.get?.("content-type") ?? void 0;
+          if (isTextual(type) && typeof res.clone === "function") {
+            markResponse(entry, "pending");
+            res.clone().text().then((text) => setResponseBody(entry, text, type)).catch(() => markResponse(entry, "none"));
+          } else markResponse(entry, "none");
+          return res;
+        },
+        (error) => {
+          finishEntry(entry, { error: errorMessage(error) });
+          throw error;
+        }
+      );
+    };
+    const passOn = () => {
+      const blocked = blockedResponse(state, method, url, requestBody);
+      if (!blocked) return real();
+      if (!state.deviceOffline) entry.blocked = true;
+      if (isOffline(blocked)) {
+        finishEntry(entry, { error: `${OFFLINE_MESSAGE} (${state.deviceOffline ? "device offline" : "strict network"})` });
+        return Promise.reject(new TypeError(OFFLINE_MESSAGE));
+      }
+      const { status, text, headers } = responseParts(blocked);
+      finishEntry(entry, { status, responseBody: text, contentType: contentTypeOf(headers), responseHeaders: headers });
+      return Promise.resolve(mockedResponse(blocked));
+    };
+    const bodyKnown = init?.body !== void 0 || !req.clone || method === "GET" || method === "HEAD" || !isTextual(headersRecord(init?.headers ?? req.headers)["content-type"]);
+    const candidates = matchingMocks(state, method, url, bodyKnown ? { text: requestBody } : void 0);
+    if (!candidates.length) return passOn();
+    let built;
+    const request = () => built ?? (built = (async () => {
+      let body = requestBody;
+      if (body === void 0 && !bodyKnown) {
+        body = await Promise.resolve().then(() => req.clone().text()).catch(() => void 0);
+        setRequestBody(entry, body);
+        requestBody = body;
+      }
+      return mockRequest(
+        method,
+        url,
+        headersRecord(init?.headers ?? req.headers),
+        body || void 0
+      );
+    })());
+    const answered = answer(state, candidates, request, bodyKnown).catch((error) => {
+      entry.mocked = true;
+      finishEntry(entry, { error: errorMessage(error) });
+      throw error;
+    });
+    return answered.then(async (hit) => {
+      if (!hit) return passOn();
+      entry.mocked = true;
+      if (hit.mock.source === "agent") signalMockAnswered(hit.mock.id, entry.id);
+      await sleep(hit.mock.delayMs);
+      if (init?.signal?.aborted) {
+        finishEntry(entry, { error: "aborted" });
+        throw abortError();
+      }
+      if (isOffline(hit.response)) {
+        finishEntry(entry, { error: `${OFFLINE_MESSAGE} (mocked offline)` });
+        throw new TypeError(OFFLINE_MESSAGE);
+      }
+      const { status, text, headers } = responseParts(hit.response);
+      finishEntry(entry, { status, responseBody: text, contentType: contentTypeOf(headers), responseHeaders: headers });
+      return mockedResponse(hit.response);
+    });
+  };
+  g.fetch = wrapped;
+  return () => {
+    if (g.fetch === wrapped) g.fetch = original;
+  };
+}
+
+// src/network/xhr.ts
+var META = /* @__PURE__ */ Symbol("agent-bridge.xhr");
+var isRN = (xhr) => typeof xhr.__didReceiveResponse === "function" && typeof xhr.__didCompleteResponse === "function";
+function responseTextOf(xhr) {
+  try {
+    if (xhr.responseType === "" || xhr.responseType === "text") return xhr.responseText;
+    if (xhr.responseType === "json") return JSON.stringify(xhr.response);
+  } catch {
+  }
+  return void 0;
+}
+function track(xhr, entry) {
+  let error;
+  xhr.addEventListener("error", () => error = OFFLINE_MESSAGE);
+  xhr.addEventListener("timeout", () => error = "timed out");
+  xhr.addEventListener("abort", () => error = "aborted");
+  xhr.addEventListener("loadend", () => {
+    const text = error ? void 0 : responseTextOf(xhr);
+    finishEntry(entry, {
+      status: error ? void 0 : xhr.status,
+      error,
+      responseBody: text,
+      contentType: xhr.getResponseHeader?.("content-type") ?? void 0,
+      responseHeaders: error ? void 0 : parseHeaderBlock(xhr.getAllResponseHeaders?.())
+    });
+    if (!error && text === void 0) markResponse(entry, "none");
+  });
+}
+var fakeRequestId = 0;
+function fire(xhr, type) {
+  const Ctor = (type === "readystatechange" ? void 0 : globalThis.ProgressEvent) ?? globalThis.Event;
+  xhr.dispatchEvent(new Ctor(type));
+}
+function respond(xhr, mocked, url) {
+  const offline = isOffline(mocked);
+  const { status, text, headers } = responseParts(mocked);
+  if (isRN(xhr)) {
+    const id = -++fakeRequestId;
+    xhr.__didCreateRequest(id);
+    if (offline) return xhr.__didCompleteResponse(id, OFFLINE_MESSAGE, false);
+    xhr.__didReceiveResponse(id, status, headers, url);
+    if (xhr.responseType === "arraybuffer" && typeof btoa === "function") {
+      xhr.__didReceiveData(id, btoa(unescape(encodeURIComponent(text))));
+    } else if (xhr.responseType !== "blob") {
+      xhr.__didReceiveData(id, text);
+    }
+    return xhr.__didCompleteResponse(id, "", false);
+  }
+  const define = (values) => {
+    for (const [key, value] of Object.entries(values))
+      Object.defineProperty(xhr, key, { value, configurable: true });
+  };
+  const lower2 = Object.fromEntries(
+    Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v])
+  );
+  let response = text;
+  if (xhr.responseType === "json") {
+    try {
+      response = JSON.parse(text);
+    } catch {
+      response = null;
+    }
+  }
+  define({
+    readyState: 4,
+    status: offline ? 0 : status,
+    statusText: "",
+    responseURL: url,
+    responseText: offline ? "" : text,
+    response: offline ? "" : response,
+    getAllResponseHeaders: () => offline ? "" : Object.entries(lower2).map(([k, v]) => `${k}: ${v}\r
+`).join(""),
+    getResponseHeader: (name) => lower2[name.toLowerCase()] ?? null
+  });
+  fire(xhr, "readystatechange");
+  fire(xhr, offline ? "error" : "load");
+  fire(xhr, "loadend");
+}
+function patchXhr(state) {
+  const XHR = globalThis.XMLHttpRequest;
+  if (typeof XHR !== "function") return null;
+  const proto = XHR.prototype;
+  const { open, send, setRequestHeader, abort } = proto;
+  proto.open = function(method, url, ...rest) {
+    this[META] = {
+      method: String(method).toUpperCase(),
+      url: String(url),
+      // Opened by the patched fetch's own original: fetch logs it already.
+      internal: state.insideFetch > 0,
+      headers: {}
+    };
+    return open.call(this, method, url, ...rest);
+  };
+  proto.setRequestHeader = function(name, value) {
+    const meta = this[META];
+    if (meta) meta.headers[name.toLowerCase()] = value;
+    return setRequestHeader.call(this, name, value);
+  };
+  proto.abort = function() {
+    const meta = this[META];
+    if (meta) meta.aborted = true;
+    return abort.call(this);
+  };
+  proto.send = function(body) {
+    const meta = this[META];
+    if (!meta || meta.internal || isSkipped(state, meta.url))
+      return send.call(this, body);
+    meta.aborted = false;
+    const { method, url } = meta;
+    const text = bodyText(body);
+    const entry = startEntry(state, {
+      method,
+      url,
+      requestBody: text,
+      requestHeaders: meta.headers
+    });
+    const passOn = () => {
+      if (meta.aborted) {
+        finishEntry(entry, { error: "aborted" });
+        return;
+      }
+      const blocked = blockedResponse(state, method, url, text);
+      if (!blocked) {
+        track(this, entry);
+        return send.call(this, body);
+      }
+      const { status, text: out, headers } = responseParts(blocked);
+      if (!state.deviceOffline) entry.blocked = true;
+      finishEntry(
+        entry,
+        isOffline(blocked) ? { error: `${OFFLINE_MESSAGE} (${state.deviceOffline ? "device offline" : "strict network"})` } : { status, responseBody: out, contentType: contentTypeOf(headers), responseHeaders: headers }
+      );
+      void Promise.resolve().then(() => {
+        if (!meta.aborted) respond(this, blocked, url);
+      });
+    };
+    const candidates = matchingMocks(state, method, url, { text });
+    if (!candidates.length) return passOn();
+    const request = async () => mockRequest(method, url, meta.headers, text);
+    answer(state, candidates, request).then(
+      async (hit) => {
+        if (!hit) return passOn();
+        entry.mocked = true;
+        if (hit.mock.source === "agent") signalMockAnswered(hit.mock.id, entry.id);
+        await sleep(hit.mock.delayMs);
+        if (meta.aborted) {
+          finishEntry(entry, { error: "aborted" });
+          return;
+        }
+        const offline = isOffline(hit.response);
+        const { status, text: out, headers } = responseParts(hit.response);
+        finishEntry(
+          entry,
+          offline ? { error: `${OFFLINE_MESSAGE} (mocked offline)` } : { status, responseBody: out, contentType: contentTypeOf(headers), responseHeaders: headers }
+        );
+        respond(this, hit.response, url);
+      },
+      (error) => {
+        entry.mocked = true;
+        finishEntry(entry, { error: errorMessage(error) });
+        respond(this, { offline: true }, url);
+      }
+    );
+  };
+  return () => {
+    Object.assign(proto, { open, send, setRequestHeader, abort });
+  };
+}
+
+// src/network/index.ts
+function installNetwork() {
+  const state = networkState();
+  if (state.installed) return;
+  state.installed = true;
+  state.devHost = deriveDevHost();
+  for (const undo of [patchXhr(state), patchFetch(state)])
+    if (undo) state.uninstall.push(undo);
+}
+
+// src/adapters/device/offline.ts
+var NETINFO_EVENT = "netInfo.networkStatusDidChange";
+var NONE = { type: "none", isConnected: false, isInternetReachable: false, details: null };
+function offlineArea(rn, NetInfo) {
+  const restore = () => {
+    const st = deviceState();
+    if (!st.offline) return { restored: false };
+    st.offline = false;
+    setDeviceOffline(false);
+    const faked = st.netInfo;
+    if (faked && st.origRefresh) {
+      faked.refresh = st.origRefresh;
+      Promise.resolve(faked.refresh()).catch(() => {
+      });
+    }
+    delete st.netInfo;
+    delete st.origRefresh;
+    return { restored: true };
+  };
+  return {
+    pending: () => deviceState().offline ? { offline: true, netInfo: Boolean(NetInfo) } : null,
+    restore,
+    tools: {
+      "device.offline": {
+        description: "device.offline true makes every fetch and XHR fail like no network (mocks included; Metro stays reachable) and, when NetInfo was passed in, tells its listeners, NetInfo.fetch and useNetInfo the device is offline. false goes back. device.restore also does. Returns { offline }.",
+        maxArgs: 1,
+        run: (offline) => {
+          if (typeof offline !== "boolean") throw new Error("Pass true or false");
+          if (!offline) {
+            restore();
+            return { offline: false };
+          }
+          const st = deviceState();
+          st.offline = true;
+          installNetwork();
+          setDeviceOffline(true);
+          if (NetInfo) {
+            if (!st.origRefresh && typeof NetInfo.refresh === "function") {
+              st.netInfo = NetInfo;
+              st.origRefresh = NetInfo.refresh;
+              NetInfo.refresh = () => Promise.resolve(NONE);
+            }
+            rn().DeviceEventEmitter.emit(NETINFO_EVENT, NONE);
+          }
+          return { offline: true };
+        }
+      }
+    }
+  };
+}
+
+// src/adapters/device.ts
+function deviceTools(options = {}) {
+  const rn = () => options.reactNative ?? loadReactNative();
+  const areas = [
+    linkArea(rn, options.navigation),
+    appStateArea(rn),
+    offlineArea(rn, options.NetInfo)
+  ];
+  if (options.Notifications) areas.push(notificationArea(rn, options.Notifications));
+  if (options.time) areas.push(clockArea());
+  const tools = Object.assign({}, ...areas.map((a) => a.tools));
+  tools["device.restore"] = {
+    description: "Undo every device event: deep link, app state, offline and clock.",
+    pending: () => {
+      const pending = Object.assign({}, ...areas.map((a) => a.pending()));
+      return Object.keys(pending).length ? pending : false;
+    },
+    run: () => {
+      const results = areas.map((a) => a.restore());
+      return { ...Object.assign({}, ...results), restored: results.some((r) => Boolean(r.restored)) };
+    }
+  };
+  return tools;
+}