@ethisyscore/extension-runtime 1.6.0

package/dist/mock-host/cli.js

@@ -0,0 +1,770 @@
+import { promises } from 'fs';
+import * as path from 'path';
+import { KNOWN_PRIMITIVES } from '@ethisyscore/protocol';
+
+// src/mock-host/cli.ts
+
+// src/host/worker/offscreen.ts
+var transferredCanvases = /* @__PURE__ */ new WeakSet();
+function createOffscreenCanvasTransfer(options) {
+  const { canvas, surfaceId, postMessage } = options;
+  const proto = HTMLCanvasElement.prototype;
+  if (typeof proto.transferControlToOffscreen !== "function") {
+    throw new Error(
+      "[offscreen-canvas] OffscreenCanvas is not supported in this environment. Contract B canvas surfaces require a browser with HTMLCanvasElement.transferControlToOffscreen."
+    );
+  }
+  if (transferredCanvases.has(canvas)) {
+    throw new Error(
+      `[offscreen-canvas] canvas already transferred (surfaceId='${surfaceId}'). Create a fresh <canvas> for each surface instead of re-transferring.`
+    );
+  }
+  const offscreen = canvas.transferControlToOffscreen();
+  transferredCanvases.add(canvas);
+  const envelope = {
+    type: "ethisys:offscreen:transfer",
+    surfaceId,
+    width: canvas.width,
+    height: canvas.height,
+    offscreen
+  };
+  postMessage(envelope, [offscreen]);
+  return { offscreen };
+}
+
+// src/host/worker/transport.ts
+var WORKER_TRANSPORT_PROTOCOL = "ethisys.worker.remotedom.v1";
+var DEFAULT_MAX_CONCURRENT_MCP_REQUESTS = 8;
+var WorkerRemoteDomTransport = class {
+  worker;
+  hostPort;
+  workerPort;
+  mcpClient;
+  capabilityTokenProvider;
+  coalesceMs;
+  maxConcurrentMcpRequests;
+  abortController;
+  inFlightMcpRequests = 0;
+  remoteDomConsumer;
+  disposed = false;
+  connected = false;
+  constructor(options) {
+    const WorkerCtor = options.workerCtor ?? globalThis.Worker;
+    if (!WorkerCtor) {
+      throw new Error("WorkerRemoteDomTransport: no Worker constructor available");
+    }
+    this.mcpClient = options.mcpClient;
+    this.capabilityTokenProvider = options.capabilityToken;
+    this.coalesceMs = options.coalesceMs ?? 16;
+    this.maxConcurrentMcpRequests = Math.max(
+      1,
+      options.maxConcurrentMcpRequests ?? DEFAULT_MAX_CONCURRENT_MCP_REQUESTS
+    );
+    this.abortController = new AbortController();
+    this.worker = new WorkerCtor(options.bootstrapUrl, { type: "module" });
+    const channel = new MessageChannel();
+    this.hostPort = channel.port1;
+    this.workerPort = channel.port2;
+    this.hostPort.onmessage = (ev) => this.handlePortMessage(ev.data);
+    this.hostPort.start();
+    this.worker.onerror = (ev) => {
+    };
+  }
+  /**
+   * Post the handshake to the worker. Idempotent — only the FIRST call
+   * transfers the {@link MessagePort} and posts the handshake payload;
+   * subsequent calls are silent no-ops. Splitting this off from the
+   * constructor lets the host mount fetch the per-plugin
+   * `worker-bundle.import-map.json` (and resolve the bundle's module URL)
+   * before the bootstrap script consumes them.
+   *
+   * Wire shape: {@link WorkerHandshakePayload}. The capability token NEVER
+   * appears in the payload — it's bound on the host side via the
+   * {@link WorkerRemoteDomTransportOptions.capabilityToken} provider.
+   *
+   * The `moduleUrl` and `importMap` are forwarded to the worker so the
+   * bootstrap script (served from the host-pinned
+   * `/extensions/runtime/worker-bootstrap.js`) can:
+   *   1. Compose the frozen, same-origin-validated `IMPORT_MAP` from the
+   *      handshake payload (rejecting any cross-origin entries).
+   *   2. `safeImport(moduleUrl)` the plugin's entry module.
+   *
+   * Same-origin enforcement is the bootstrap's job — this transport is
+   * structurally agnostic to the host origin and only forwards what it's
+   * handed.
+   */
+  connect(moduleUrl, importMap) {
+    if (this.connected) {
+      return;
+    }
+    this.connected = true;
+    const handshake = Object.freeze({
+      type: "ethisys:worker:handshake",
+      protocol: WORKER_TRANSPORT_PROTOCOL,
+      moduleUrl,
+      importMap: Object.freeze({ ...importMap })
+    });
+    this.worker.postMessage(handshake, [this.workerPort]);
+  }
+  /**
+   * Bind a consumer for Remote DOM mutation payloads emitted by the worker.
+   * The Remote DOM receiver wiring is owned by the caller (typically a host
+   * React component); this method exposes the raw stream so the receiver
+   * can integrate cleanly without a circular package import.
+   */
+  onRemoteDom(consumer) {
+    this.remoteDomConsumer = consumer;
+  }
+  /**
+   * Transfer control of a host-owned `<canvas>` to the worker so plugin code
+   * can render via `OffscreenCanvas`. The host retains the `<canvas>` for
+   * layout / accessibility purposes only — every pixel is produced inside the
+   * worker, so the main thread is never blocked per frame.
+   *
+   * The transfer rides the established MessagePort (not the worker global
+   * `postMessage`) so it is multiplexed with the rest of the host ↔ worker
+   * traffic on the same channel. The `OffscreenCanvas` handle is the sole
+   * `Transferable` in the envelope; no capability token, MCP context, or
+   * other host-only data crosses the boundary.
+   *
+   * Throws if the environment lacks `transferControlToOffscreen()` or if the
+   * canvas has already been transferred — see {@link createOffscreenCanvasTransfer}
+   * for the exact diagnostics.
+   */
+  transferCanvas(canvas, options) {
+    return createOffscreenCanvasTransfer({
+      canvas,
+      surfaceId: options.surfaceId,
+      postMessage: (message, transfer) => {
+        this.hostPort.postMessage(message, transfer);
+      }
+    });
+  }
+  /**
+   * Forward a host-sourced input event to the worker over the port. The
+   * payload shape is opaque to the transport — pointer / wheel / keyboard
+   * envelopes share the same wire type. Callers are expected to wrap
+   * high-frequency (pointer-move, wheel, scroll) events in
+   * {@link createCoalescer} or {@link createInputEventCoalescer} BEFORE
+   * calling this method so the port never sees the un-coalesced flood.
+   *
+   * Keyboard / pointer-down / pointer-up events are discrete and should be
+   * delivered without coalescing — pass them straight through.
+   */
+  postInputEvent(payload) {
+    this.hostPort.postMessage({
+      type: "ethisys:input:event",
+      payload
+    });
+  }
+  /**
+   * Build a trailing-edge coalescer keyed to {@link WorkerRemoteDomTransportOptions.coalesceMs}.
+   *
+   * Use it to wrap pointer-move / scroll / resize callbacks **before**
+   * they cross the port. The last payload in any coalescing window is the
+   * one that wins.
+   */
+  createCoalescer(consumer) {
+    let pending;
+    let timer;
+    const flush = () => {
+      timer = void 0;
+      const value = pending;
+      pending = void 0;
+      if (value !== void 0) {
+        consumer(value);
+      }
+    };
+    return (payload) => {
+      pending = payload;
+      if (timer === void 0) {
+        timer = setTimeout(flush, this.coalesceMs);
+      }
+    };
+  }
+  /**
+   * Tear down the worker and port. Idempotent.
+   *
+   * Order matters: we abort BEFORE closing the port so any in-flight
+   * `mcpClient.fetch` that observes the signal short-circuits and the
+   * subsequent attempt to post a reply lands in the disposed-guard branch
+   * (which silently drops the post) instead of throwing on a closed port.
+   */
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    try {
+      this.abortController.abort();
+    } catch {
+    }
+    try {
+      this.hostPort.close();
+    } catch {
+    }
+    try {
+      this.worker.terminate();
+    } catch {
+    }
+  }
+  /**
+   * Best-effort wrapper around `hostPort.postMessage` that tolerates posts
+   * arriving after {@link dispose}. The browser throws on a closed port and
+   * the async handlers below can race dispose, so any post initiated by an
+   * awaited continuation must be guarded.
+   */
+  safePostMessage(message) {
+    if (this.disposed) {
+      return;
+    }
+    try {
+      this.hostPort.postMessage(message);
+    } catch {
+    }
+  }
+  // ─── Port message handling ──────────────────────────────────────────────
+  handlePortMessage(message) {
+    if (this.disposed) {
+      return;
+    }
+    switch (message.type) {
+      case "ethisys:mcp:invokeTool":
+        this.dispatchMcp(message, "ethisys:mcp:invokeTool:result", (m) => this.handleInvokeTool(m));
+        return;
+      case "ethisys:mcp:getResource":
+        this.dispatchMcp(message, "ethisys:mcp:getResource:result", (m) => this.handleGetResource(m));
+        return;
+      case "ethisys:remotedom":
+        this.remoteDomConsumer?.(message.payload);
+        return;
+      default:
+        return;
+    }
+  }
+  /**
+   * Gate inbound MCP requests through the bounded concurrency window,
+   * reject with a deterministic error reply when the cap is exceeded, and
+   * decrement the counter unconditionally when the underlying handler
+   * settles (regardless of resolution/rejection shape).
+   */
+  dispatchMcp(message, resultType, handler) {
+    if (this.inFlightMcpRequests >= this.maxConcurrentMcpRequests) {
+      this.safePostMessage({
+        id: message.id,
+        type: resultType,
+        ok: false,
+        error: `MCP back-pressure: in-flight cap of ${this.maxConcurrentMcpRequests} reached.`
+      });
+      return;
+    }
+    this.inFlightMcpRequests++;
+    handler(message).finally(() => {
+      this.inFlightMcpRequests = Math.max(0, this.inFlightMcpRequests - 1);
+    });
+  }
+  async handleInvokeTool(message) {
+    let token;
+    try {
+      token = await this.capabilityTokenProvider();
+    } catch (err) {
+      this.replyError(message.id, "ethisys:mcp:invokeTool:result", err);
+      return;
+    }
+    if (this.disposed) {
+      return;
+    }
+    try {
+      const result = await this.mcpClient.fetch({
+        kind: "invokeTool",
+        name: message.name,
+        args: message.args,
+        capabilityToken: token,
+        signal: this.abortController.signal
+      });
+      this.safePostMessage({
+        id: message.id,
+        type: "ethisys:mcp:invokeTool:result",
+        ok: result.ok,
+        data: result.data,
+        error: result.error
+      });
+    } catch (err) {
+      this.replyError(message.id, "ethisys:mcp:invokeTool:result", err);
+    }
+  }
+  async handleGetResource(message) {
+    let token;
+    try {
+      token = await this.capabilityTokenProvider();
+    } catch (err) {
+      this.replyError(message.id, "ethisys:mcp:getResource:result", err);
+      return;
+    }
+    if (this.disposed) {
+      return;
+    }
+    try {
+      const result = await this.mcpClient.fetch({
+        kind: "getResource",
+        uri: message.uri,
+        capabilityToken: token,
+        signal: this.abortController.signal
+      });
+      this.safePostMessage({
+        id: message.id,
+        type: "ethisys:mcp:getResource:result",
+        ok: result.ok,
+        data: result.data,
+        error: result.error
+      });
+    } catch (err) {
+      this.replyError(message.id, "ethisys:mcp:getResource:result", err);
+    }
+  }
+  replyError(id, type, err) {
+    const message = err instanceof Error ? err.message : "MCP request failed";
+    this.safePostMessage({ id, type, ok: false, error: message });
+  }
+};
+
+// src/host/worker/component-registry.ts
+var CONTRACT_B_PRIMITIVES = [
+  "Button",
+  "DataTable",
+  "Form",
+  "EntityPicker",
+  "CommandBar",
+  "Drawer",
+  "Modal",
+  "CanvasSurface",
+  "WebGLSurface"
+];
+new Set(CONTRACT_B_PRIMITIVES);
+
+// src/mock-host/cli.ts
+async function loadResources(dir) {
+  const absDir = path.resolve(dir);
+  const files = await walkJson(absDir);
+  const out = {};
+  const errors = [];
+  for (const file of files) {
+    try {
+      const raw = await promises.readFile(file, "utf8");
+      const parsed = JSON.parse(raw);
+      const { uri, tree } = normaliseEntry(parsed, file, absDir);
+      if (out[uri] !== void 0) {
+        errors.push(`Duplicate resource URI '${uri}' (from ${file})`);
+        continue;
+      }
+      out[uri] = tree;
+    } catch (e) {
+      errors.push(`${file}: ${e.message}`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      `Failed to load ${errors.length} mock-host resource(s):
+  - ${errors.join("\n  - ")}`
+    );
+  }
+  return out;
+}
+function normaliseEntry(parsed, absFile, absDir) {
+  if (parsed === null || typeof parsed !== "object") {
+    throw new Error("Resource JSON must be an object");
+  }
+  const obj = parsed;
+  if (typeof obj.uri === "string" && obj.tree !== void 0) {
+    return { uri: obj.uri, tree: obj.tree };
+  }
+  const rel = path.relative(absDir, absFile).replace(/\\/g, "/");
+  const uri = rel.replace(/\.json$/i, "");
+  return { uri, tree: parsed };
+}
+async function walkJson(root) {
+  const out = [];
+  async function recurse(dir) {
+    let entries;
+    try {
+      entries = await promises.readdir(dir, { withFileTypes: true });
+    } catch (e) {
+      const err = e;
+      if (err.code === "ENOENT") {
+        throw new Error(`Resources directory not found: ${root}`);
+      }
+      throw e;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await recurse(full);
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".json")) {
+        out.push(full);
+      }
+    }
+  }
+  await recurse(root);
+  out.sort();
+  return out;
+}
+function renderIndexHtml(resourceUris) {
+  const defaultUri = resourceUris[0] ?? "";
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>mock-host (${resourceUris.length} resources)</title>
+    <style>
+      body { font-family: system-ui, sans-serif; margin: 1rem; }
+      header { border-bottom: 1px solid #ccc; padding-bottom: 0.5rem; margin-bottom: 1rem; }
+      select { padding: 0.25rem 0.5rem; }
+      [data-mock-primitive] { padding: 0.5rem; margin: 0.25rem 0; border: 1px dashed #aaa; }
+      [data-mock-primitive]::before { content: attr(data-mock-primitive); font-size: 0.75rem; color: #666; display: block; }
+    </style>
+  </head>
+  <body>
+    <header>
+      <strong>mock-host</strong>
+      &nbsp;|&nbsp;
+      <label>Resource: <select id="resource-picker">
+        ${resourceUris.map((u) => `<option value="${escapeHtml(u)}">${escapeHtml(u)}</option>`).join("")}
+      </select></label>
+    </header>
+    <main id="root"></main>
+    <script type="module" src="/@mock-host/entry.tsx"></script>
+    <script>
+      window.__MOCK_HOST_DEFAULT_URI__ = ${safeJsonForScript(defaultUri)};
+      window.__MOCK_HOST_RESOURCE_URIS__ = ${safeJsonForScript(resourceUris)};
+    </script>
+  </body>
+</html>`;
+}
+function escapeHtml(s) {
+  return s.replace(/[&<>"']/g, (c) => ({
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  })[c]);
+}
+function safeJsonForScript(v) {
+  return JSON.stringify(v).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+}
+function renderEntryModule(resources) {
+  const json = JSON.stringify(resources);
+  const primitives = JSON.stringify([...KNOWN_PRIMITIVES]);
+  return `
+import { createRoot } from "react-dom/client";
+import { createElement, useState } from "react";
+import { DeclarativeMockHost } from "@ethisyscore/extension-runtime/mock-host";
+
+const PRIMITIVES = ${primitives};
+
+const registry = Object.fromEntries(PRIMITIVES.map(name => [
+    name,
+    ({ children }) => createElement("div", { "data-mock-primitive": name }, children),
+]));
+
+const resources = ${json};
+const uris = Object.keys(resources);
+
+function App() {
+    const [uri, setUri] = useState(window.__MOCK_HOST_DEFAULT_URI__ || uris[0] || "");
+    // Wire the header picker to React state so authors can switch trees live.
+    const picker = document.getElementById("resource-picker");
+    if (picker && !picker.__wired) {
+        picker.__wired = true;
+        picker.value = uri;
+        picker.addEventListener("change", e => setUri(e.target.value));
+    }
+    return createElement(DeclarativeMockHost, {
+        resources,
+        registry,
+        defaultResourceUri: uri,
+    });
+}
+
+createRoot(document.getElementById("root")).render(createElement(App));
+`;
+}
+var RENDER_MODES = /* @__PURE__ */ new Set([
+  "host-rendered",
+  "remote-runtime"
+]);
+function parseArgs(args) {
+  let renderMode = "host-rendered";
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--render-mode") {
+      const next = args[i + 1];
+      if (next === void 0) {
+        throw new Error("Usage: mock-host [--render-mode <host-rendered|remote-runtime>] <path>");
+      }
+      if (!RENDER_MODES.has(next)) {
+        throw new Error(
+          `Invalid --render-mode '${next}'. Allowed: ${[...RENDER_MODES].join(", ")}.`
+        );
+      }
+      renderMode = next;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--render-mode=")) {
+      const value = arg.slice("--render-mode=".length);
+      if (!RENDER_MODES.has(value)) {
+        throw new Error(
+          `Invalid --render-mode '${value}'. Allowed: ${[...RENDER_MODES].join(", ")}.`
+        );
+      }
+      renderMode = value;
+      continue;
+    }
+    positional.push(arg);
+  }
+  if (positional.length === 0) {
+    throw new Error("Usage: mock-host [--render-mode <host-rendered|remote-runtime>] <path>");
+  }
+  return { renderMode, path: positional[0] };
+}
+function renderWorkerBundleIndexHtml(bundlePath) {
+  const safePath = escapeHtml(bundlePath);
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>mock-host (remote-runtime: ${safePath})</title>
+    <style>
+      body { font-family: system-ui, sans-serif; margin: 1rem; }
+      header { border-bottom: 1px solid #ccc; padding-bottom: 0.5rem; margin-bottom: 1rem; }
+      [data-mock-primitive] { padding: 0.5rem; margin: 0.25rem 0; border: 1px dashed #aaa; }
+      [data-mock-primitive]::before { content: attr(data-mock-primitive); font-size: 0.75rem; color: #666; display: block; }
+    </style>
+  </head>
+  <body>
+    <header><strong>mock-host</strong> &nbsp;|&nbsp; <em>remote-runtime: ${safePath}</em></header>
+    <main id="root"></main>
+    <script type="module" src="/@mock-host/worker-bundle-entry.tsx"></script>
+  </body>
+</html>`;
+}
+function renderWorkerBundleEntryModule(bundleUrl) {
+  const safePrimitives = JSON.stringify([...CONTRACT_B_PRIMITIVES]);
+  const safeUrl = JSON.stringify(bundleUrl);
+  return `
+import { createRoot } from "react-dom/client";
+import { createElement } from "react";
+import {
+    WorkerRemoteDomTransport,
+    SemanticComponentRegistry,
+} from "@ethisyscore/extension-runtime/host";
+
+const PRIMITIVES = ${safePrimitives};
+const bundleUrl = ${safeUrl};
+
+// Build the test-injectable component map \u2014 every Contract B primitive
+// renders to a labelled placeholder so plugin authors can see what their
+// worker is emitting before plugging in gogo-ui.
+const componentMap = Object.fromEntries(PRIMITIVES.map(name => [
+    name,
+    ({ children }) => createElement("div", { "data-mock-primitive": name }, children),
+]));
+const registry = SemanticComponentRegistry.fromMap(componentMap);
+
+// Mock-host MCP client: no platform, so every tool/resource call resolves
+// to a friendly placeholder. Authors who need real MCP traffic should run
+// against the full platform host.
+const mcpClient = {
+    fetch: async (req) => ({
+        ok: true,
+        data: { mockHost: true, kind: req.kind, name: req.name ?? req.uri },
+    }),
+};
+
+// The capability token never crosses the worker boundary \u2014 supply a marker
+// here so the host-side fetcher can still attach an Authorization header.
+const transport = new WorkerRemoteDomTransport({
+    bootstrapUrl: bundleUrl,
+    capabilityToken: async () => "mock-host-capability-token",
+    mcpClient,
+});
+
+const root = createRoot(document.getElementById("root"));
+transport.onRemoteDom(() => {
+    // The full Remote DOM receiver belongs to a separate concern (E3.S2's
+    // WorkerSurfaceMount). For mock-host purposes the registry is the
+    // observable surface \u2014 log the receiver payload for now.
+    root.render(createElement("div", { "data-mock-host-primitives": PRIMITIVES.join(",") }));
+});
+
+// Expose the transport + registry on window so authors can poke at them from
+// devtools (e.g., to terminate the worker between iteration cycles).
+window.__MOCK_HOST_TRANSPORT__ = transport;
+window.__MOCK_HOST_REGISTRY__ = registry;
+`;
+}
+var defaultMockMcpClient = {
+  fetch: async (req) => {
+    const echo = req.kind === "invokeTool" ? { tool: req.name, args: req.args } : { resource: req.uri };
+    return { ok: true, data: { mockHost: true, ...echo } };
+  }
+};
+function bootContractBHost(options) {
+  return new WorkerRemoteDomTransport({
+    bootstrapUrl: options.bundleUrl,
+    capabilityToken: options.capabilityToken ?? (async () => "mock-host-capability-token"),
+    mcpClient: options.mcpClient ?? defaultMockMcpClient,
+    workerCtor: options.workerCtor
+  });
+}
+async function runContractBHost(bundlePathOrUrl) {
+  let viteMod;
+  try {
+    viteMod = await import('vite');
+  } catch {
+    throw new Error(
+      "vite is required to run `mock-host`. Install with: npm install --save-dev vite"
+    );
+  }
+  const isUrl = /^https?:\/\//i.test(bundlePathOrUrl);
+  const absBundle = isUrl ? bundlePathOrUrl : path.resolve(bundlePathOrUrl);
+  if (!isUrl) {
+    try {
+      await promises.access(absBundle);
+    } catch {
+      throw new Error(`mock-host: worker bundle not found at ${absBundle}`);
+    }
+  }
+  const bundleServePath = "/@mock-host/worker-bundle.js";
+  const indexHtml = renderWorkerBundleIndexHtml(isUrl ? bundlePathOrUrl : bundleServePath);
+  const entryModule = renderWorkerBundleEntryModule(isUrl ? bundlePathOrUrl : bundleServePath);
+  const server = await viteMod.createServer({
+    root: process.cwd(),
+    configFile: false,
+    server: { port: 0, host: "127.0.0.1" },
+    plugins: [
+      {
+        name: "mock-host-virtual-worker",
+        resolveId(id) {
+          if (id === "/@mock-host/worker-bundle-entry.tsx") {
+            return "\0mock-host:worker-bundle-entry";
+          }
+          return null;
+        },
+        load(id) {
+          if (id === "\0mock-host:worker-bundle-entry") {
+            return entryModule;
+          }
+          return null;
+        },
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        configureServer(devServer) {
+          devServer.middlewares.use(async (req, res, next) => {
+            if (req.url === "/" || req.url === "/index.html") {
+              res.setHeader("Content-Type", "text/html");
+              res.end(indexHtml);
+              return;
+            }
+            if (!isUrl && req.url === bundleServePath) {
+              try {
+                const bytes = await promises.readFile(absBundle);
+                res.setHeader("Content-Type", "text/javascript; charset=utf-8");
+                res.end(bytes);
+              } catch (e) {
+                res.statusCode = 500;
+                res.end(`mock-host: failed to read worker bundle: ${e.message}`);
+              }
+              return;
+            }
+            next();
+          });
+        }
+        /* eslint-enable @typescript-eslint/no-explicit-any */
+      }
+    ]
+  });
+  await server.listen();
+  const addr = server.httpServer?.address();
+  let port = 5173;
+  if (addr && typeof addr === "object") {
+    port = addr.port;
+  }
+  const url = `http://127.0.0.1:${port}/`;
+  process.stdout.write(`mock-host listening on ${url} (remote-runtime: ${absBundle})
+`);
+  return { url, close: () => server.close() };
+}
+async function run(args) {
+  const parsed = parseArgs(args);
+  if (parsed.renderMode === "remote-runtime") {
+    return runContractBHost(parsed.path);
+  }
+  const dir = parsed.path;
+  const resources = await loadResources(dir);
+  const uris = Object.keys(resources).sort();
+  if (uris.length === 0) {
+    process.stderr.write(`mock-host: no resources found in ${dir} (HMR will pick up new files)
+`);
+  }
+  let viteMod;
+  try {
+    viteMod = await import('vite');
+  } catch {
+    throw new Error(
+      "vite is required to run `mock-host`. Install with: npm install --save-dev vite"
+    );
+  }
+  const indexHtml = renderIndexHtml(uris);
+  const entryModule = renderEntryModule(resources);
+  const absDir = path.resolve(dir);
+  const server = await viteMod.createServer({
+    root: process.cwd(),
+    configFile: false,
+    server: { port: 0, host: "127.0.0.1" },
+    plugins: [
+      {
+        name: "mock-host-virtual",
+        resolveId(id) {
+          if (id === "/@mock-host/entry.tsx") {
+            return "\0mock-host:entry";
+          }
+          return null;
+        },
+        load(id) {
+          if (id === "\0mock-host:entry") {
+            return entryModule;
+          }
+          return null;
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        configureServer(devServer) {
+          devServer.watcher.add(absDir);
+          devServer.middlewares.use((req, res, next) => {
+            if (req.url === "/" || req.url === "/index.html") {
+              res.setHeader("Content-Type", "text/html");
+              res.end(indexHtml);
+              return;
+            }
+            next();
+          });
+        }
+      }
+    ]
+  });
+  await server.listen();
+  const addr = server.httpServer?.address();
+  let port = 5173;
+  if (addr && typeof addr === "object") {
+    port = addr.port;
+  }
+  const url = `http://127.0.0.1:${port}/`;
+  process.stdout.write(`mock-host listening on ${url} (resources: ${uris.length})
+`);
+  return { url, close: () => server.close() };
+}
+
+export { bootContractBHost, loadResources, normaliseEntry, parseArgs, renderEntryModule, renderIndexHtml, renderWorkerBundleEntryModule, renderWorkerBundleIndexHtml, run };
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map