@avasapp/agent-bridge 0.2.0 → 0.4.0

package/dist/network/index.cjs

@@ -22,21 +22,108 @@ var network_exports = {};
 __export(network_exports, {
   installNetwork: () => installNetwork,
   mock: () => mock,
+  mockApi: () => mockApi,
   mockRequests: () => mockRequests,
-  networkTools: () => networkTools
+  networkTools: () => networkTools,
+  strictNetwork: () => strictNetwork
 });
 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*)$/;
+function compileRoute(baseUrl, route) {
+  const parsed = ROUTE.exec(route.trim());
+  if (!parsed)
+    throw new Error(`Bad route "${route}": use "METHOD /path" or "/path"`);
+  const [, method, path] = parsed;
+  const names = [];
+  const pattern = path.split(/(:[A-Za-z_][A-Za-z0-9_]*|\*)/).map((part) => {
+    if (part === "*") {
+      names.push("*");
+      return "([^?#]*)";
+    }
+    if (part.startsWith(":")) {
+      names.push(part.slice(1));
+      return "([^/?#]+)";
+    }
+    return escape(part);
+  }).join("");
+  const base = baseUrl ? escape(baseUrl.replace(/\/+$/, "")) : "(?:[a-z][a-z0-9+.-]*://[^/?#]*)?";
+  return {
+    method: method?.toUpperCase(),
+    regex: new RegExp(`^${base}${pattern}(?:[?#].*)?$`, "i"),
+    names
+  };
+}
+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 decode = (s) => {
+      try {
+        return decodeURIComponent(s.replace(/\+/g, " "));
+      } catch {
+        return s;
+      }
+    };
+    out[decode(key)] = decode(value);
+  }
+  return out;
+}
+function apiRoutes(baseUrl, routes, options = {}) {
+  const { id, ...mockOptions } = options;
+  return Object.entries(routes).map(([route, response]) => {
+    const { method, regex, names } = compileRoute(baseUrl, route);
+    const match = { url: regex, method };
+    const handler = typeof response === "function" ? (request) => {
+      const values = regex.exec(request.url)?.slice(1) ?? [];
+      const params = Object.fromEntries(
+        names.map((name, i) => [name, decodeURIComponent(values[i] ?? "")])
+      );
+      return response({ ...request, params, query: queryOf(request.url) });
+    } : response;
+    return {
+      match,
+      response: handler,
+      options: { ...mockOptions, ...id && { id: `${id} ${route}` } }
+    };
+  });
+}
+
 // 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;
@@ -62,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,
@@ -74,9 +161,12 @@ function networkState() {
     insideFetch: 0,
     devHost: null,
     skip: [],
-    uninstall: []
+    uninstall: [],
+    strictApp: [],
+    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] ?? "";
@@ -100,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);
@@ -143,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);
@@ -153,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)
@@ -165,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);
 }
@@ -196,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;
@@ -207,6 +382,41 @@ function responseParts(response) {
     };
   return { status, text: r.body ?? "", headers: { ...r.headers } };
 }
+function strictRule(options = {}) {
+  const allow = options.allow ?? [];
+  if (!Array.isArray(allow))
+    throw new Error("allow must be a list of URL substrings or regexes");
+  return {
+    allow: allow.map((rule) => urlTest(rule)),
+    allowShown: allow.map(
+      (rule) => typeof rule === "string" ? rule : String(rule instanceof RegExp ? rule : new RegExp(rule.regex, rule.flags))
+    ),
+    status: options.status ?? 501,
+    offline: options.offline === true
+  };
+}
+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) {
+  const rules = strictRules(state);
+  if (!rules.length || rules.some((r) => r.allow.some((test) => test(url))))
+    return null;
+  const key = `${method} ${url}`;
+  const seen = state.blocked.get(key);
+  if (seen) seen.count += 1;
+  else state.blocked.set(key, { method, url, count: 1 });
+  const error = `agent-bridge strict network: no mock for ${key}`;
+  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();
@@ -273,7 +483,7 @@ function patchFetch(state) {
     const entry = startEntry(state, {
       method,
       url,
-      requestBody: formatBody(requestBody)
+      requestBody
     });
     const real = () => {
       let promise;
@@ -286,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) => {
@@ -302,8 +509,20 @@ function patchFetch(state) {
         }
       );
     };
+    const passOn = () => {
+      const blocked = blockedResponse(state, method, url);
+      if (!blocked) return real();
+      entry.blocked = true;
+      if (isOffline(blocked)) {
+        finishEntry(entry, { error: `${OFFLINE_MESSAGE} (strict network)` });
+        return Promise.reject(new TypeError(OFFLINE_MESSAGE));
+      }
+      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);
-    if (!candidates.length) return real();
+    if (!candidates.length) return passOn();
     const request = async () => {
       let body = requestBody;
       if (body === void 0 && init?.body === void 0 && req.clone) {
@@ -322,8 +541,9 @@ function patchFetch(state) {
       throw error;
     });
     return answered.then(async (hit) => {
-      if (!hit) return real();
+      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" });
@@ -333,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);
     });
   };
@@ -361,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;
@@ -373,9 +596,9 @@ function fire(xhr, type) {
   const Ctor = (type === "readystatechange" ? void 0 : globalThis.ProgressEvent) ?? globalThis.Event;
   xhr.dispatchEvent(new Ctor(type));
 }
-function respond(xhr, hit, url) {
-  const offline = isOffline(hit.response);
-  const { status, text, headers } = responseParts(hit.response);
+function respond(xhr, mocked, url) {
+  const offline = isOffline(mocked);
+  const { status, text, headers } = responseParts(mocked);
   if (isRN(xhr)) {
     const id = -++fakeRequestId;
     xhr.__didCreateRequest(id);
@@ -452,38 +675,49 @@ function patchXhr(state) {
     const entry = startEntry(state, {
       method,
       url,
-      requestBody: formatBody(text)
+      requestBody: text
     });
+    const passOn = () => {
+      const blocked = blockedResponse(state, method, url);
+      if (!blocked) {
+        track(this, entry);
+        return send.call(this, body);
+      }
+      const { status, text: out, headers } = responseParts(blocked);
+      entry.blocked = true;
+      finishEntry(
+        entry,
+        isOffline(blocked) ? { error: `${OFFLINE_MESSAGE} (strict network)` } : { status, responseBody: out, contentType: contentTypeOf(headers) }
+      );
+      void Promise.resolve().then(() => {
+        if (!meta.aborted) respond(this, blocked, url);
+      });
+    };
     const candidates = matchingMocks(state, method, url);
-    if (!candidates.length) {
-      track(this, entry);
-      return send.call(this, body);
-    }
+    if (!candidates.length) return passOn();
     const request = async () => mockRequest(method, url, meta.headers, text);
     answer(state, candidates, request).then(
       async (hit) => {
-        if (!hit) {
-          track(this, entry);
-          return send.call(this, body);
-        }
+        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, url);
+        respond(this, hit.response, url);
       },
       (error) => {
         entry.mocked = true;
         finishEntry(entry, { error: errorMessage(error) });
-        respond(this, { mock: candidates[0], response: { offline: true } }, url);
+        respond(this, { offline: true }, url);
       }
     );
   };
@@ -513,56 +747,190 @@ function mockRequests(routes) {
     for (const m of added) m.remove();
   };
 }
-var describeMock = (m) => ({
+function mockApi(baseUrl, routes, options) {
+  return mockRequests(apiRoutes(baseUrl, routes, options));
+}
+function strictNetwork(options = {}) {
+  installNetwork();
+  const state = networkState();
+  const rule = strictRule(options);
+  state.strictApp.push(rule);
+  return () => {
+    state.strictApp = state.strictApp.filter((r) => r !== rule);
+  };
+}
+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 }.",
+      run: (...args) => {
+        if (args.length) {
+          const value = args[0];
+          if (value === null || value === void 0) state.strictAgent = null;
+          else if (value === false) state.strictAgent = false;
+          else if (value === true) state.strictAgent = strictRule();
+          else if (typeof value === "object") state.strictAgent = strictRule(value);
+          else throw new Error("Pass true, false, null or { allow?, status?, offline? }");
+        }
+        const rules = strictRules(state);
+        return {
+          strict: rules.length > 0,
+          source: state.strictAgent !== null ? "agent" : rules.length ? "app" : null,
+          allow: rules.flatMap((r) => r.allowShown),
+          blocked: [...state.blocked.values()].slice(-20).reverse()
+        };
+      }
     },
     "net.clear": {
-      description: "Empty the request log. Returns how many entries it held.",
-      run: () => state.log.splice(0).length
+      description: "Empty the request log and the strict-mode blocked list. Returns how many log entries it held.",
+      run: () => {
+        state.blocked.clear();
+        return state.log.splice(0).length;
+      }
     },
     "net.restore": {
-      description: "Undo the agent's network changes: remove agent mocks, keep the app's. Returns how many were removed.",
-      run: () => removeMocks(state, isAgent)
+      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;
+        const count = removeMocks(state, isAgent);
+        signalMocksRemoved();
+        return count;
+      }
     }
   };
 }