@avasapp/agent-bridge 0.3.0 → 0.4.1

package/dist/network/index.cjs

@@ -29,6 +29,22 @@ __export(network_exports, {
 });
 module.exports = __toCommonJS(network_exports);
 
+// src/shared/mock-signal.ts
+var KEY = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/mock-signal");
+var listeners = () => {
+  const g = globalThis;
+  return g[KEY] ?? (g[KEY] = /* @__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);
+};
+var signalMocksRemoved = (ids) => {
+  for (const l of [...listeners()]) l.removed?.(ids);
+};
+
 // src/network/api.ts
 var escape = (s) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
 var ROUTE = /^(?:([A-Za-z]+)\s+)?(\/\S*)$/;
@@ -96,14 +112,18 @@ function apiRoutes(baseUrl, routes, options = {}) {
 
 // src/network/body.ts
 var MAX_BODY = 2048;
-function formatBody(text) {
+var MAX_FULL_BODY = 1e6;
+var FULL_BUDGET = 4e6;
+function compactBody(text) {
   if (text === void 0 || text === "") return void 0;
-  let out = text;
   try {
-    out = JSON.stringify(JSON.parse(text));
+    return JSON.stringify(JSON.parse(text));
   } catch {
+    return text;
   }
-  return out.length > MAX_BODY ? `${out.slice(0, MAX_BODY)}\u2026 (+${out.length - MAX_BODY} chars)` : out;
+}
+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;
@@ -129,10 +149,10 @@ function errorMessage(error) {
 
 // src/network/state.ts
 var LOG_SIZE = 100;
-var KEY = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/network");
+var KEY2 = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/network");
 function networkState() {
   const g = globalThis;
-  g[KEY] ?? (g[KEY] = {
+  g[KEY2] ?? (g[KEY2] = {
     installed: false,
     log: [],
     nextLogId: 1,
@@ -146,7 +166,7 @@ function networkState() {
     strictAgent: null,
     blocked: /* @__PURE__ */ new Map()
   });
-  return g[KEY];
+  return g[KEY2];
 }
 var URL_PARTS = /^(?:[a-z][a-z0-9+.-]*:)?(?:\/\/([^/?#]*))?([^?#]*)/i;
 var hostOf = (url) => URL_PARTS.exec(url)?.[1] ?? "";
@@ -170,29 +190,96 @@ function deriveDevHost() {
     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++,
-    ...fields,
+    method: fields.method,
+    url: fields.url,
+    startedAt: Date.now(),
     ms: 0,
-    pending: true,
-    started: Date.now()
+    pending: true
   };
-  if (entry.requestBody === void 0) delete entry.requestBody;
+  keepRequestBody(entry, fields.requestBody);
   state.log.push(entry);
+  signalRequestStarted(entry.id);
   if (state.log.length > LOG_SIZE)
     state.log.splice(0, state.log.length - LOG_SIZE);
   return entry;
 }
 function finishEntry(entry, fields) {
-  entry.ms = Date.now() - entry.started;
+  entry.ms = Date.now() - entry.startedAt;
   delete entry.pending;
-  for (const [key, value] of Object.entries(fields))
+  const { responseBody, contentType, ...rest } = fields;
+  for (const [key, value] of Object.entries(rest))
     if (value !== void 0) entry[key] = value;
+  if (responseBody !== void 0) setResponseBody(entry, responseBody, contentType);
+}
+function publicEntry(entry, full = false) {
+  const out = entry.pending ? { ...entry, ms: Date.now() - entry.startedAt } : { ...entry };
+  if (full) {
+    const { requestBody, responseBody } = FULL.get(entry) ?? {};
+    if (requestBody !== void 0) out.requestBody = requestBody;
+    if (responseBody !== void 0) out.responseBody = responseBody;
+    const cut = entry.responseBody !== void 0 && responseBody === void 0;
+    const cutRequest = entry.requestBody !== void 0 && requestBody === void 0;
+    if (cut || cutRequest) out.truncated = true;
+  }
+  return out;
 }
-function publicEntry(entry) {
-  const { started, ...rest } = entry;
-  return rest.pending && started !== void 0 ? { ...rest, ms: Date.now() - started } : rest;
+function fullResponse(entry) {
+  const full = FULL.get(entry);
+  return { state: full?.response ?? "none", body: full?.responseBody, contentType: full?.contentType };
 }
 function urlTest(url) {
   if (typeof url === "string") return (u) => u.includes(url);
@@ -213,6 +300,8 @@ function compileMatch(match) {
 function addMock(state, source, match, response, options = {}) {
   if (!response || typeof response !== "object" && typeof response !== "function")
     throw new Error("A mock needs a response: { status?, json?, body?, headers? }, { offline: true } or a handler");
+  if (options.priority !== void 0 && !Number.isFinite(options.priority))
+    throw new Error("priority must be a finite number");
   const seq = state.nextSeq++;
   const id = options.id ?? `${source}-${seq}`;
   removeMocks(state, (m) => m.id === id);
@@ -223,6 +312,7 @@ function addMock(state, source, match, response, options = {}) {
     response,
     times: options.times,
     delayMs: options.delayMs ?? 0,
+    priority: options.priority ?? 0,
     hits: 0,
     seq,
     test: compileMatch(match)
@@ -235,7 +325,21 @@ function removeMocks(state, which) {
   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.seq - a.seq;
+var mockOrder = (a, b) => Number(b.source === "agent") - Number(a.source === "agent") || b.priority - a.priority || b.seq - a.seq;
+var substringMatch = (match) => {
+  const spec = typeof match === "string" ? { url: match } : match;
+  return typeof spec.url === "string" ? { url: spec.url, method: spec.method?.toUpperCase() } : null;
+};
+function shadowedMocks(state, added) {
+  const next = substringMatch(added.match);
+  if (!next || typeof added.response === "function") return [];
+  return state.mocks.filter((old) => {
+    if (old === added || old.source !== "agent" || mockOrder(added, old) >= 0)
+      return false;
+    const prev = substringMatch(old.match);
+    return !!prev && prev.url.includes(next.url) && (!next.method || next.method === prev.method);
+  });
+}
 function matchingMocks(state, method, url) {
   return state.mocks.filter((m) => m.test(method, url)).sort(mockOrder);
 }
@@ -266,6 +370,7 @@ function mockRequest(method, url, headers, body) {
     }
   };
 }
+var contentTypeOf = (headers) => Object.entries(headers).find(([k]) => k.toLowerCase() === "content-type")?.[1];
 function responseParts(response) {
   const r = response;
   const status = r.status ?? 200;
@@ -378,7 +483,7 @@ function patchFetch(state) {
     const entry = startEntry(state, {
       method,
       url,
-      requestBody: formatBody(requestBody)
+      requestBody
     });
     const real = () => {
       let promise;
@@ -391,14 +496,11 @@ function patchFetch(state) {
       return promise.then(
         (res) => {
           finishEntry(entry, { status: res.status });
-          const type = res.headers?.get?.("content-type");
+          const type = res.headers?.get?.("content-type") ?? void 0;
           if (isTextual(type) && typeof res.clone === "function") {
-            res.clone().text().then((text) => {
-              const body = formatBody(text);
-              if (body !== void 0) entry.responseBody = body;
-            }).catch(() => {
-            });
-          }
+            markResponse(entry, "pending");
+            res.clone().text().then((text) => setResponseBody(entry, text, type)).catch(() => markResponse(entry, "none"));
+          } else markResponse(entry, "none");
           return res;
         },
         (error) => {
@@ -415,8 +517,8 @@ function patchFetch(state) {
         finishEntry(entry, { error: `${OFFLINE_MESSAGE} (strict network)` });
         return Promise.reject(new TypeError(OFFLINE_MESSAGE));
       }
-      const { status, text } = responseParts(blocked);
-      finishEntry(entry, { status, responseBody: formatBody(text) });
+      const { status, text, headers } = responseParts(blocked);
+      finishEntry(entry, { status, responseBody: text, contentType: contentTypeOf(headers) });
       return Promise.resolve(mockedResponse(blocked));
     };
     const candidates = matchingMocks(state, method, url);
@@ -441,6 +543,7 @@ function patchFetch(state) {
     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" });
@@ -450,8 +553,8 @@ function patchFetch(state) {
         finishEntry(entry, { error: `${OFFLINE_MESSAGE} (mocked offline)` });
         throw new TypeError(OFFLINE_MESSAGE);
       }
-      const { status, text } = responseParts(hit.response);
-      finishEntry(entry, { status, responseBody: formatBody(text) });
+      const { status, text, headers } = responseParts(hit.response);
+      finishEntry(entry, { status, responseBody: text, contentType: contentTypeOf(headers) });
       return mockedResponse(hit.response);
     });
   };
@@ -478,11 +581,14 @@ function track(xhr, entry) {
   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: error ? void 0 : formatBody(responseTextOf(xhr))
+      responseBody: text,
+      contentType: xhr.getResponseHeader?.("content-type") ?? void 0
     });
+    if (!error && text === void 0) markResponse(entry, "none");
   });
 }
 var fakeRequestId = 0;
@@ -569,7 +675,7 @@ function patchXhr(state) {
     const entry = startEntry(state, {
       method,
       url,
-      requestBody: formatBody(text)
+      requestBody: text
     });
     const passOn = () => {
       const blocked = blockedResponse(state, method, url);
@@ -577,11 +683,11 @@ function patchXhr(state) {
         track(this, entry);
         return send.call(this, body);
       }
-      const { status, text: out } = responseParts(blocked);
+      const { status, text: out, headers } = responseParts(blocked);
       entry.blocked = true;
       finishEntry(
         entry,
-        isOffline(blocked) ? { error: `${OFFLINE_MESSAGE} (strict network)` } : { status, responseBody: formatBody(out) }
+        isOffline(blocked) ? { error: `${OFFLINE_MESSAGE} (strict network)` } : { status, responseBody: out, contentType: contentTypeOf(headers) }
       );
       void Promise.resolve().then(() => {
         if (!meta.aborted) respond(this, blocked, url);
@@ -594,16 +700,17 @@ function patchXhr(state) {
       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 } = responseParts(hit.response);
+        const { status, text: out, headers } = responseParts(hit.response);
         finishEntry(
           entry,
-          offline ? { error: `${OFFLINE_MESSAGE} (mocked offline)` } : { status, responseBody: formatBody(out) }
+          offline ? { error: `${OFFLINE_MESSAGE} (mocked offline)` } : { status, responseBody: out, contentType: contentTypeOf(headers) }
         );
         respond(this, hit.response, url);
       },
@@ -652,48 +759,141 @@ function strictNetwork(options = {}) {
     state.strictApp = state.strictApp.filter((r) => r !== rule);
   };
 }
-var describeMock = (m) => ({
+var escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var isPlain = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function deepMerge(base, patch) {
+  if (!isPlain(base) || !isPlain(patch)) return patch;
+  const out = { ...base };
+  for (const [key, value] of Object.entries(patch)) out[key] = deepMerge(base[key], value);
+  return out;
+}
+var describeMatch = (match) => {
+  if (match instanceof RegExp) return String(match);
+  if (typeof match === "object" && match.url instanceof RegExp)
+    return { ...match, url: String(match.url) };
+  return match;
+};
+function describeResponse(response, full) {
+  if (typeof response === "function") return { response: "[handler]" };
+  if (full || "offline" in response) return { response };
+  const out = { ...response };
+  let truncated = false;
+  if (response.json !== void 0) {
+    const text = JSON.stringify(response.json) ?? "";
+    const cut = truncateBody(text);
+    if (cut !== text) {
+      out.json = cut;
+      truncated = true;
+    }
+  }
+  if (typeof response.body === "string") {
+    const cut = truncateBody(response.body);
+    if (cut !== response.body) {
+      out.body = cut;
+      truncated = true;
+    }
+  }
+  return truncated ? { response: out, truncated } : { response };
+}
+var describeMock = (m, full) => ({
   id: m.id,
   source: m.source,
-  match: m.match instanceof RegExp ? String(m.match) : m.match,
-  response: typeof m.response === "function" ? "[handler]" : m.response,
+  match: describeMatch(m.match),
+  ...describeResponse(m.response, full),
   times: m.times,
   hits: m.hits,
-  delayMs: m.delayMs || void 0
+  delayMs: m.delayMs || void 0,
+  priority: m.priority || void 0
 });
 function networkTools(options = {}) {
   installNetwork();
   const state = networkState();
   if (options.skip) state.skip = options.skip;
   const isAgent = (m) => m.source === "agent";
+  const logged = (id) => {
+    const entry = state.log.find((e) => e.id === id);
+    if (!entry) throw new Error(`No logged request with id ${id}; it may have left the log`);
+    return entry;
+  };
+  const addAgentMock = (match, response, { times, delayMs, priority }) => {
+    const added = addMock(state, "agent", match, response, { times, delayMs, priority });
+    const shadows = shadowedMocks(state, added).map((m) => m.id);
+    return shadows.length ? { id: added.id, shadows } : { id: added.id };
+  };
   return {
     "net.log": {
-      description: "Recent requests, newest first: method, url, status, ms, bodies (~2 KB), error, mocked. Filter by url substring or method; clear: true empties the log after reading.",
+      description: 'Recent requests, newest first: method, url, startedAt (epoch ms), status, ms, bodies (~2 KB, cut with "\u2026 (+N chars)"), error, mocked. Filter by url substring, method, since (epoch ms: startedAt >= since) or sinceId (id > sinceId); full: true returns whole bodies (truncated: true when one is too large or gone); clear: true empties the log after reading. net.entry gets one request whole.',
       run: (filter = {}) => {
         const method = filter.method?.toUpperCase();
+        if (filter.since !== void 0 && !(filter.since >= 1e11))
+          throw new Error("since is an epoch time in ms (e.g. Date.now()); use sinceId for log ids");
         const entries = state.log.filter(
-          (e) => (!filter.url || e.url.includes(filter.url)) && (!method || e.method === method)
-        ).reverse().slice(0, filter.limit ?? 20).map(publicEntry);
+          (e) => (!filter.url || e.url.includes(filter.url)) && (!method || e.method === method) && (filter.since === void 0 || e.startedAt >= filter.since) && (filter.sinceId === void 0 || e.id > filter.sinceId)
+        ).reverse().slice(0, filter.limit ?? 20).map((e) => publicEntry(e, filter.full));
         if (filter.clear) state.log.length = 0;
         return entries;
       }
     },
+    "net.entry": {
+      description: "One logged request by id, with its request and response bodies whole (not cut at ~2 KB). Ids come from net.log.",
+      run: (id) => publicEntry(logged(id), true)
+    },
     "net.mock": {
-      description: 'Answer matching requests with a canned response until unmocked. match: "/path" or { url: string | { regex }, method? }. response: { status?, json?, body?, headers? } or { offline: true }. options: { times?, delayMs? }.',
+      description: 'Answer matching requests with a canned response until unmocked. match: "/path" or { url: string | { regex }, method? }. response: { status?, json?, body?, headers? } or { offline: true }. options: { times?, delayMs?, priority? }. The newest mock is tried first, so a later broad mock shadows an earlier specific one; give the specific one a higher priority (default 0, ties newest first; negative makes a fallback); agent mocks still come before the app mocks. The result lists `shadows` when the new mock will be tried before an agent mock it also matches.',
       run: (match, response, mockOptions = {}) => {
         if (typeof response !== "object" || response === null)
           throw new Error("response must be an object, e.g. { status: 500 }");
-        const { times, delayMs } = mockOptions;
-        return { id: addMock(state, "agent", match, response, { times, delayMs }).id };
+        return addAgentMock(match, response, mockOptions);
+      }
+    },
+    "net.mockFromLog": {
+      description: "Mock the same method and URL as a logged request (id from net.log) with its status and whole response body, optionally changed by patch: JSON objects merge deeply, other values replace. [id, patch?, options?] options as net.mock. Returns { id, match, response }.",
+      run: (id, patch, mockOptions = {}) => {
+        const entry = logged(id);
+        if (entry.status === void 0)
+          throw new Error(`Request ${id} has no response to copy (${entry.error ?? "still pending"})`);
+        const { state: kept, body, contentType } = fullResponse(entry);
+        if (kept !== "kept" || body === void 0)
+          throw new Error(
+            `Request ${id}'s response body can't be copied: ${{
+              pending: "it is still being read, try again",
+              none: "it was not captured (binary or unreadable)",
+              cut: "it is too large",
+              evicted: "it was dropped to save memory",
+              kept: "it is missing"
+            }[kept]}`
+          );
+        const response = { status: entry.status };
+        if (patch !== void 0) {
+          let json;
+          try {
+            json = JSON.parse(body);
+          } catch {
+            throw new Error(`Request ${id}'s response is not JSON, so it can't take a patch`);
+          }
+          response.json = deepMerge(json, patch);
+        } else {
+          response.body = body;
+          if (contentType) response.headers = { "content-type": contentType };
+        }
+        const match = { url: { regex: `^${escapeRegex(entry.url)}$` }, method: entry.method };
+        return { ...addAgentMock(match, response, mockOptions), match: { url: entry.url, method: entry.method }, response };
       }
     },
     "net.mocks": {
-      description: "Active mocks, agent and app, in the order they are tried.",
-      run: () => [...state.mocks].sort(mockOrder).map(describeMock)
+      description: 'Active mocks, agent and app, in the order they are tried. Response json and body over ~2 KB are cut like net.log (json shown as its cut JSON text, "\u2026 (+N chars)"), with truncated: true; { full: true } returns them whole.',
+      run: (options2 = {}) => [...state.mocks].sort(mockOrder).map((m) => describeMock(m, options2.full))
     },
     "net.unmock": {
-      description: "Remove one agent mock by id, or every agent mock when no id. Returns how many.",
-      run: (id) => removeMocks(state, (m) => isAgent(m) && (id === void 0 || m.id === id))
+      description: "Remove one agent mock by id, or every agent mock when no id. Returns how many. With the query adapter, queries that fetched while the mock answered are reset, so its fake data can't outlive it.",
+      run: (id) => {
+        const removed = state.mocks.filter(
+          (m) => isAgent(m) && (id === void 0 || m.id === id)
+        );
+        const count = removeMocks(state, (m) => removed.includes(m));
+        signalMocksRemoved(id === void 0 ? void 0 : [id]);
+        return count;
+      }
     },
     "net.strict": {
       description: "Strict mode: requests no mock answers fail with a 501 (or like offline) instead of reaching a server. [true | false | { allow?: [substring | { regex }], status?, offline? }] sets it for the agent, [null] follows the app again; no args reads it. Returns { strict, source, allow, blocked }.",
@@ -723,10 +923,13 @@ function networkTools(options = {}) {
       }
     },
     "net.restore": {
-      description: "Undo the agent's network changes: remove agent mocks and its net.strict setting, keep the app's. Returns how many mocks were removed.",
+      pending: () => state.strictAgent !== null || state.mocks.some(isAgent),
+      description: "Undo the agent's network changes: remove agent mocks and its net.strict setting, keep the app's. Returns how many mocks were removed. With the query adapter, queries that fetched while an agent mock answered are reset (query.restore reports how many).",
       run: () => {
         state.strictAgent = null;
-        return removeMocks(state, isAgent);
+        const count = removeMocks(state, isAgent);
+        signalMocksRemoved();
+        return count;
       }
     }
   };

package/dist/network/index.d.cts

@@ -1,4 +1,4 @@
-import { T as Tools } from '../types-6kKQsLC1.cjs';
+import { T as Tools } from '../types-BmpykP1P.cjs';
 
 /** Which requests a mock answers. A bare string is a URL substring. */
 type MockMatch = string | {
@@ -38,6 +38,8 @@ type MockOptions = {
     times?: number;
     /** Wait before answering. */
     delayMs?: number;
+    /** Higher is tried first among mocks from the same source (agent mocks still come before the app's). Default 0; ties go to the newest. Negative makes a fallback. */
+    priority?: number;
     /** Registering again with the same id replaces the mock (handy with Fast Refresh). */
     id?: string;
 };
@@ -50,11 +52,15 @@ type LogEntry = {
     id: number;
     method: string;
     url: string;
+    /** When the request started, epoch ms (the app's clock). */
+    startedAt: number;
     status?: number;
     ms: number;
     pending?: boolean;
     requestBody?: string;
     responseBody?: string;
+    /** From net.entry: a body shown is only a preview because the whole one was too large or is gone. */
+    truncated?: boolean;
     error?: string;
     mocked?: boolean;
     /** Failed by strict mode: no mock answered it. */
@@ -94,7 +100,8 @@ type MockApiOptions = Omit<MockOptions, 'id'> & {
 declare function installNetwork(): void;
 /**
  * Answers matching requests from the app's own code, e.g. a fake backend.
- * Agent mocks (from `net.mock`) take precedence; `net.restore` keeps these.
+ * Agent mocks (from `net.mock`) are tried first, whatever their priority;
+ * `net.restore` keeps these.
  */
 declare function mock(match: MockMatch, response: MockResponse | MockHandler, options?: MockOptions): {
     id: string;

package/dist/noop/index.cjs

@@ -22,6 +22,7 @@ var noop_exports = {};
 __export(noop_exports, {
   cdpTransport: () => cdpTransport,
   createGate: () => createGate,
+  onRestore: () => onRestore,
   settle: () => settle,
   startAgentBridge: () => startAgentBridge,
   useAgentBridge: () => useAgentBridge
@@ -35,6 +36,8 @@ var useAgentBridge = () => {
 };
 var cdpTransport = inert;
 var settle = () => Promise.resolve({ commits: 0, ms: 0 });
+var onRestore = () => {
+};
 var createGate = (name) => ({
   name,
   closed: false,

package/dist/noop/react-native-webview.cjs

@@ -0,0 +1,38 @@
+"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/noop/react-native-webview.ts
+var react_native_webview_exports = {};
+__export(react_native_webview_exports, {
+  useWebViewTools: () => useWebViewTools,
+  webviewTools: () => webviewTools
+});
+module.exports = __toCommonJS(react_native_webview_exports);
+var wrap = (onMessage) => onMessage;
+function useWebViewTools(_ref, options) {
+  const props = {};
+  const { injectedJavaScriptBeforeContentLoaded, onLoadStart, onLoadEnd, onNavigationStateChange } = options;
+  if (injectedJavaScriptBeforeContentLoaded !== void 0)
+    props.injectedJavaScriptBeforeContentLoaded = injectedJavaScriptBeforeContentLoaded;
+  if (onLoadStart) props.onLoadStart = onLoadStart;
+  if (onLoadEnd) props.onLoadEnd = onLoadEnd;
+  if (onNavigationStateChange) props.onNavigationStateChange = onNavigationStateChange;
+  return { props, wrap };
+}
+var webviewTools = () => ({});

package/dist/realtime/index.cjs

@@ -221,7 +221,7 @@ function createRealtimeTap(options = {}) {
       }
     },
     [`${ns}.emit`]: {
-      description: "Deliver a fake message to every listener on a channel: [channel, message]. Runs the app's own handlers. Returns { id, delivered }.",
+      description: "Deliver a fake message to every listener on a channel: [channel, message]. Runs the app's own handlers. Returns { id, delivered }." + (options.emitUsage ? ` ${options.emitUsage}` : ""),
       run: (channel, ...values) => {
         const entries = channels.get(channel);
         if (!entries?.size)
@@ -257,6 +257,7 @@ function createRealtimeTap(options = {}) {
       run: (channel) => setMute(channel, null)
     },
     [`${ns}.restore`]: {
+      pending: () => mutes.size > 0 || faked !== null,
       description: "Undo the agent: unmute every channel and go back to the real connection state.",
       run: () => {
         const unmuted = [...mutes.keys()];

package/dist/realtime/index.d.cts

@@ -1,4 +1,4 @@
-import { T as Tools } from '../types-6kKQsLC1.cjs';
+import { T as Tools } from '../types-BmpykP1P.cjs';
 
 /** How a message shows up in `realtime.log`. */
 type MessageSummary = {
@@ -34,6 +34,8 @@ type RealtimeTapOptions<M> = {
         channel: string;
         id: string;
     }) => M;
+    /** What to pass to `realtime.emit` for this library, appended to its description. */
+    emitUsage?: string;
     /** Extra fields for `realtime.channels`, e.g. the library's channel state. */
     channelInfo?: (channel: string) => Record<string, unknown>;
     /** Adds `realtime.connection`, to fake connection states. */