@avasapp/agent-bridge 0.1.0 → 0.3.0

package/dist/client/index.cjs

@@ -34,7 +34,8 @@ __export(client_exports, {
   connect: () => connect,
   connectSession: () => connectSession,
   listDevices: () => listDevices,
-  listSessions: () => listSessions
+  listSessions: () => listSessions,
+  runFlow: () => runFlow
 });
 module.exports = __toCommonJS(client_exports);
 
@@ -213,6 +214,8 @@ async function connectExpo(metro, device, discoveryMs = 600) {
 
 // src/client/cdp.ts
 var import_ws2 = __toESM(require("ws"), 1);
+var CannotEvaluate = class extends Error {
+};
 var targetLabel = (t) => `${t.title}${t.deviceName ? ` [${t.deviceName}]` : ""}`;
 async function connectCdp(metro, device) {
   const target = pickOne(await listCdpTargets(metro), device, targetLabel);
@@ -259,6 +262,7 @@ async function connectCdp(metro, device) {
       expression,
       returnByValue: true
     });
+    if (message.error?.code === -32601) throw new CannotEvaluate();
     const details = message.result?.exceptionDetails;
     if (details) {
       const text = details.exception?.description ?? details.text ?? "evaluation failed";
@@ -273,10 +277,10 @@ async function connectCdp(metro, device) {
     info = JSON.parse(
       String(await evaluate(`${CDP_GLOBAL}.info()`))
     );
-  } catch {
+  } catch (error) {
     ws.close();
     throw new Error(
-      `agent-bridge isn't running in ${targetLabel(target)}. Is useAgentBridge mounted in a dev build?`
+      error instanceof CannotEvaluate ? `The debugger for ${targetLabel(target)} can't run code (no Runtime.evaluate, as in Expo Go on Android). Use --transport expo, or a dev build.` : `agent-bridge isn't running in ${targetLabel(target)}. Is useAgentBridge mounted in a dev build?`
     );
   }
   return {
@@ -327,6 +331,106 @@ async function openConnection(options = {}) {
   }
 }
 
+// src/client/log-lines.ts
+function logLine(entry) {
+  const where = entry.during ? ` during ${entry.during}` : entry.after ? ` after ${entry.after}` : "";
+  const first = entry.message.split("\n")[0] ?? "";
+  const text = first.length > 300 ? `${first.slice(0, 300)}...` : first;
+  return `! ${entry.level}${where}: ${text}`;
+}
+
+// src/client/flow.ts
+function flowScenarios(flow) {
+  const declared = [
+    ...flow.scenario === void 0 ? [] : [flow.scenario],
+    ...flow.scenarios ?? []
+  ];
+  return declared.map((s) => {
+    if (typeof s === "string") return { name: s };
+    if (s && typeof s === "object" && typeof s.name === "string") return s;
+    throw new Error(
+      `A flow's scenario is a name or { name, options }, not ${JSON.stringify(s)}`
+    );
+  });
+}
+function mergeScenarios(declared, extra) {
+  const names = new Set(extra.map((s) => s.name));
+  return [...declared.filter((s) => !names.has(s.name)), ...extra];
+}
+var failedLogs = (error) => error instanceof AgentBridgeCallError ? error.logs : [];
+async function runFlow(bridge, flow, options = {}) {
+  const print = options.print ?? console.log;
+  const needs = mergeScenarios(flowScenarios(flow), options.scenarios ?? []);
+  let n = 0;
+  let total = 0;
+  let errors = 0;
+  const t0 = performance.now();
+  const report = (logs) => {
+    errors += logs.length;
+    for (const e of logs) print(`   ${logLine(e)}`);
+  };
+  const timed = async (tool, ...args) => {
+    try {
+      const result = await bridge.timed(tool, ...args);
+      report(result.logs);
+      return result;
+    } catch (error) {
+      report(failedLogs(error));
+      throw error;
+    }
+  };
+  const call = async (tool, ...args) => (await timed(tool, ...args)).value;
+  const step = async (label, tool, ...args) => {
+    const { value, ms, logs } = await bridge.timed(tool, ...args).catch((error) => {
+      report(failedLogs(error));
+      throw error;
+    });
+    total += ms;
+    print(
+      `${String(++n).padStart(2, "0")} ${label.padEnd(30)} ${ms.toFixed(1).padStart(7)} ms`
+    );
+    report(logs);
+    return value;
+  };
+  const restoreErrors = [];
+  const applied = {};
+  if (needs.length && !bridge.tools().some((t) => t.name === "scenario.apply"))
+    throw new Error(
+      `The flow needs scenario "${needs[0].name}", but the app defines none: pass \`scenarios\` to useAgentBridge.`
+    );
+  try {
+    for (const { name, options: options2 } of needs) {
+      const args = options2 === void 0 ? [name] : [name, options2];
+      applied[name] = await step(`scenario ${name}`, "scenario.apply", ...args);
+    }
+    await flow.default({
+      bridge: { ...bridge, timed, call },
+      call,
+      step,
+      scenarios: applied
+    });
+  } finally {
+    if (needs.length) {
+      try {
+        const result = await step("restore", "bridge.restore");
+        for (const [name, value] of Object.entries(result ?? {})) {
+          const error = value?.error;
+          if (error !== void 0) restoreErrors.push(`${name}: ${String(error)}`);
+        }
+      } catch (error) {
+        restoreErrors.push(
+          `bridge.restore: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      for (const e of restoreErrors) print(`   ! restore failed: ${e}`);
+    }
+  }
+  print(
+    `${n} steps, ${total.toFixed(1)} ms in calls, ${(performance.now() - t0).toFixed(0)} ms wall (${bridge.transport})${errors ? `, ${errors} error${errors === 1 ? "" : "s"}` : ""}`
+  );
+  return { steps: n, errors, restoreErrors };
+}
+
 // src/client/session/client.ts
 var import_node_net = require("net");
 var import_node_readline = require("readline");
@@ -564,5 +668,6 @@ async function listDevices(options = {}) {
   connect,
   connectSession,
   listDevices,
-  listSessions
+  listSessions,
+  runFlow
 });

package/dist/client/index.d.ts

@@ -25,6 +25,49 @@ type DeviceInfo = {
 
 type TransportName = 'expo' | 'cdp';
 
+/** A scenario a flow needs: a name, or a name with options. */
+type FlowScenario = string | {
+    name: string;
+    options?: unknown;
+};
+type FlowApi = {
+    bridge: AgentBridge;
+    call: AgentBridge['call'];
+    step: (label: string, tool: string, ...args: unknown[]) => Promise<unknown>;
+    /** What each declared scenario's apply returned, by name. */
+    scenarios: Record<string, unknown>;
+};
+/** A flow file: `export default async ({ step, call }) => {}`, plus what it needs. */
+type FlowModule = {
+    default: (api: FlowApi) => Promise<void>;
+    /** Applied before the flow and undone after it, even when it fails. */
+    scenario?: FlowScenario;
+    scenarios?: FlowScenario[];
+};
+type FlowResult = {
+    steps: number;
+    /** Errors the app logged during the flow. */
+    errors: number;
+    /** Restorers that failed in the closing bridge.restore, with why. */
+    restoreErrors: string[];
+};
+type RunFlowOptions = {
+    /** Where step lines go. Default: console.log. */
+    print?: (line: string) => void;
+    /** More scenarios to apply, e.g. from `--scenario`; one of the same name replaces the flow's. */
+    scenarios?: Array<{
+        name: string;
+        options?: unknown;
+    }>;
+};
+/**
+ * Runs a flow module you imported: applies its scenarios, runs it, and when
+ * there were any, undoes everything with bridge.restore afterwards, even
+ * when it fails. Throws what the flow threw; otherwise returns how it went.
+ * It runs only the code you hand it, in this process.
+ */
+declare function runFlow(bridge: AgentBridge, flow: FlowModule, options?: RunFlowOptions): Promise<FlowResult>;
+
 /** What a running session writes next to its socket. Readable only by the user. */
 type SessionState = {
     name: string;
@@ -109,4 +152,4 @@ type ListedDevice = {
 /** Apps with the bridge on Expo's socket, plus every React Native page Metro knows. */
 declare function listDevices(options?: Pick<ConnectOptions, 'metro'>): Promise<ListedDevice[]>;
 
-export { type AgentBridge, AgentBridgeCallError, type ConnectOptions, type DeviceInfo, type ListedDevice, type LogEntry, type SessionConnectOptions, type SessionState, type Timed, type ToolInfo, type TransportName, connect, connectSession, listDevices, listSessions };
+export { type AgentBridge, AgentBridgeCallError, type ConnectOptions, type DeviceInfo, type FlowApi, type FlowModule, type FlowResult, type FlowScenario, type ListedDevice, type LogEntry, type RunFlowOptions, type SessionConnectOptions, type SessionState, type Timed, type ToolInfo, type TransportName, connect, connectSession, listDevices, listSessions, runFlow };

package/dist/client/index.js

@@ -3,12 +3,14 @@ import {
   connect,
   connectSession,
   listDevices,
-  listSessions
-} from "../chunk-UEWFQWCY.js";
+  listSessions,
+  runFlow
+} from "../chunk-S2FYN2R5.js";
 export {
   AgentBridgeCallError,
   connect,
   connectSession,
   listDevices,
-  listSessions
+  listSessions,
+  runFlow
 };

package/dist/expo/index.d.cts

@@ -1,4 +1,4 @@
-import { a as Transport } from '../types-C6DUUHnB.cjs';
+import { a as Transport } from '../types-6kKQsLC1.cjs';
 
 /**
  * Plain JSON over Expo's dev-tools plugin socket: no string evaluation, emoji

package/dist/network/index.cjs

@@ -22,11 +22,78 @@ 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/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) {
@@ -74,7 +141,10 @@ function networkState() {
     insideFetch: 0,
     devHost: null,
     skip: [],
-    uninstall: []
+    uninstall: [],
+    strictApp: [],
+    strictAgent: null,
+    blocked: /* @__PURE__ */ new Map()
   });
   return g[KEY];
 }
@@ -207,6 +277,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();
@@ -302,8 +407,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 } = responseParts(blocked);
+      finishEntry(entry, { status, responseBody: formatBody(text) });
+      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,7 +439,7 @@ function patchFetch(state) {
       throw error;
     });
     return answered.then(async (hit) => {
-      if (!hit) return real();
+      if (!hit) return passOn();
       entry.mocked = true;
       await sleep(hit.mock.delayMs);
       if (init?.signal?.aborted) {
@@ -373,9 +490,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);
@@ -454,18 +571,28 @@ function patchXhr(state) {
       url,
       requestBody: formatBody(text)
     });
+    const passOn = () => {
+      const blocked = blockedResponse(state, method, url);
+      if (!blocked) {
+        track(this, entry);
+        return send.call(this, body);
+      }
+      const { status, text: out } = responseParts(blocked);
+      entry.blocked = true;
+      finishEntry(
+        entry,
+        isOffline(blocked) ? { error: `${OFFLINE_MESSAGE} (strict network)` } : { status, responseBody: formatBody(out) }
+      );
+      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;
         await sleep(hit.mock.delayMs);
         if (meta.aborted) {
@@ -478,12 +605,12 @@ function patchXhr(state) {
           entry,
           offline ? { error: `${OFFLINE_MESSAGE} (mocked offline)` } : { status, responseBody: formatBody(out) }
         );
-        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,6 +640,18 @@ function mockRequests(routes) {
     for (const m of added) m.remove();
   };
 }
+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 describeMock = (m) => ({
   id: m.id,
   source: m.source,
@@ -556,13 +695,39 @@ function networkTools(options = {}) {
       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))
     },
+    "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)
+      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.",
+      run: () => {
+        state.strictAgent = null;
+        return removeMocks(state, isAgent);
+      }
     }
   };
 }

package/dist/network/index.d.cts

@@ -1,4 +1,4 @@
-import { T as Tools } from '../types-C6DUUHnB.cjs';
+import { T as Tools } from '../types-6kKQsLC1.cjs';
 
 /** Which requests a mock answers. A bare string is a URL substring. */
 type MockMatch = string | {
@@ -57,6 +57,33 @@ type LogEntry = {
     responseBody?: string;
     error?: string;
     mocked?: boolean;
+    /** Failed by strict mode: no mock answered it. */
+    blocked?: boolean;
+};
+type StrictOptions = {
+    /** URLs strict mode lets through to the network: substrings or RegExps. */
+    allow?: Array<string | RegExp>;
+    /** Status of the error response. Default 501. */
+    status?: number;
+    /** Fail like a network failure instead of answering with a status. */
+    offline?: boolean;
+};
+
+/** What a `mockApi` handler sees: the request, plus its path params and query. */
+type ApiRequest = MockRequest & {
+    /** `:name` segments of the route, and `*` as "*". */
+    params: Record<string, string>;
+    query: Record<string, string>;
+};
+type ApiHandler = (request: ApiRequest) => MockResponse | undefined | Promise<MockResponse | undefined>;
+/** "METHOD /path" (or "/path" for any method) → a response or a handler. */
+type ApiRoutes = Record<string, MockResponse | ApiHandler>;
+type MockApiOptions = Omit<MockOptions, 'id'> & {
+    /**
+     * Registering again with the same id replaces these routes (handy with
+     * Fast Refresh). Each route's mock id is `<id> <METHOD /path>`.
+     */
+    id?: string;
 };
 
 /**
@@ -75,6 +102,22 @@ declare function mock(match: MockMatch, response: MockResponse | MockHandler, op
 };
 /** Registers several app mocks. Returns a function that removes them. */
 declare function mockRequests(routes: MockRoute[]): () => void;
+/**
+ * Answers many endpoints under one base URL, e.g. a scenario's fixtures:
+ * `mockApi(API, { 'GET /me': { json: user }, 'GET /plants/:id': ({ params }) => ... })`.
+ * `:name` matches a path segment and `*` the rest; the query string is ignored.
+ * Pass '' as the base URL to match the path on any host. Returns a function
+ * that removes the routes.
+ */
+declare function mockApi(baseUrl: string, routes: ApiRoutes, options?: MockApiOptions): () => void;
+/**
+ * Strict mode: a fetch or XMLHttpRequest that no mock answers fails with an
+ * error response (501 by default, or like offline with `offline: true`) and
+ * a console error naming it, instead of
+ * reaching a server. Only JS requests: native networking (images, native
+ * SDKs, WebSockets) isn't covered. Returns a function that turns it off.
+ */
+declare function strictNetwork(options?: StrictOptions): () => void;
 type NetworkToolsOptions = {
     /** Extra URLs never to log or mock: substrings or RegExps. */
     skip?: Array<string | RegExp>;
@@ -82,4 +125,4 @@ type NetworkToolsOptions = {
 /** Read the request log and mock responses: `net.*`. */
 declare function networkTools(options?: NetworkToolsOptions): Tools;
 
-export { type LogEntry, type MockHandler, type MockMatch, type MockOptions, type MockRequest, type MockResponse, type MockRoute, type NetworkToolsOptions, installNetwork, mock, mockRequests, networkTools };
+export { type ApiHandler, type ApiRequest, type ApiRoutes, type LogEntry, type MockApiOptions, type MockHandler, type MockMatch, type MockOptions, type MockRequest, type MockResponse, type MockRoute, type NetworkToolsOptions, type StrictOptions, installNetwork, mock, mockApi, mockRequests, networkTools, strictNetwork };

package/dist/noop/ably.cjs

@@ -0,0 +1,26 @@
+"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/ably.ts
+var ably_exports = {};
+__export(ably_exports, {
+  ablyTools: () => ablyTools
+});
+module.exports = __toCommonJS(ably_exports);
+var ablyTools = () => ({});

package/dist/noop/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var noop_exports = {};
 __export(noop_exports, {
   cdpTransport: () => cdpTransport,
+  createGate: () => createGate,
   settle: () => settle,
   startAgentBridge: () => startAgentBridge,
   useAgentBridge: () => useAgentBridge
@@ -34,3 +35,11 @@ var useAgentBridge = () => {
 };
 var cdpTransport = inert;
 var settle = () => Promise.resolve({ commits: 0, ms: 0 });
+var createGate = (name) => ({
+  name,
+  closed: false,
+  close: () => () => {
+  },
+  subscribe: () => () => {
+  }
+});

package/dist/noop/network.cjs

@@ -22,8 +22,10 @@ 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);
 var installNetwork = () => {
@@ -32,3 +34,7 @@ var mock = () => ({ id: "", remove: () => false });
 var mockRequests = () => () => {
 };
 var networkTools = () => ({});
+var mockApi = () => () => {
+};
+var strictNetwork = () => () => {
+};