npm - @openthink/ui-leaf - Versions diffs - 0.4.0 → 0.5.0 - Mend

@openthink/ui-leaf 0.4.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/README.md +11 -11
package/package.json +14 -17
package/packages/cli/dist/cli.js +957 -0
package/packages/cli/dist/cli.js.map +1 -0
package/{dist → packages/cli/dist}/index.d.ts +62 -40
package/packages/cli/dist/index.js +698 -0
package/packages/cli/dist/index.js.map +1 -0
package/packages/cli/dist/server-Bp6cms3O.d.ts +7 -0
package/{dist → packages/cli/dist}/view.d.ts +1 -1
package/packages/cli/package.json +22 -0
package/dist/cli.js +0 -725
package/dist/cli.js.map +0 -1
package/dist/dev-server-DapOoULX.d.ts +0 -5
package/dist/index.js +0 -556
package/dist/index.js.map +0 -1
/package/{dist → packages/cli/dist}/cli.d.ts +0 -0
/package/{dist → packages/cli/dist}/view.js +0 -0
/package/{dist → packages/cli/dist}/view.js.map +0 -0

package/packages/cli/dist/index.js ADDED Viewed

@@ -0,0 +1,698 @@
+// src/index.ts
+import { resolve as resolve2 } from "path";
+// src/server.ts
+import { randomBytes, timingSafeEqual as nodeTimingSafeEqual } from "crypto";
+import open, { apps } from "open";
+// src/compile.ts
+import { createRequire } from "module";
+import { tmpdir } from "os";
+import { join, resolve, sep } from "path";
+import { mkdtemp, rm, stat, writeFile } from "fs/promises";
+// src/internal/html.ts
+function escapeForScriptTag(json) {
+  return json.replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+// src/compile.ts
+var requireFromHere = createRequire(import.meta.url);
+var reactAliasPlugin = {
+  name: "ui-leaf-react-alias",
+  setup(build) {
+    build.onResolve({ filter: /^react($|\/|-dom($|\/))/ }, (args) => {
+      try {
+        return { path: requireFromHere.resolve(args.path) };
+      } catch {
+        return {
+          path: args.path,
+          errors: [{ text: `ui-leaf: failed to resolve ${args.path}` }]
+        };
+      }
+    });
+  }
+};
+var SHARED_BRIDGE = `
+async function mutate(name: string, args?: unknown): Promise<unknown> {
+  const res = await fetch("/mutate", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(token ? { Authorization: "Bearer " + token } : {}),
+    },
+    body: JSON.stringify({ name, args }),
+  });
+  const text = await res.text().catch(() => "");
+  if (!res.ok) {
+    let detail = text;
+    try {
+      const parsed: unknown = text ? JSON.parse(text) : null;
+      if (parsed !== null && typeof parsed === "object" && "error" in parsed && typeof (parsed as { error: unknown }).error === "string") {
+        detail = (parsed as { error: string }).error;
+      }
+    } catch { /* keep raw text */ }
+    throw new Error("ui-leaf: mutation '" + name + "' failed (" + res.status + "): " + detail);
+  }
+  return text ? JSON.parse(text) : undefined;
+}
+async function heartbeat(): Promise<void> {
+  try {
+    await fetch("/heartbeat", {
+      method: "POST",
+      headers: token ? { Authorization: "Bearer " + token } : {},
+    });
+  } catch { /* server may have shut down; ignore */ }
+}
+setInterval(heartbeat, 5000);
+heartbeat();`;
+async function runBunBuild(entryPath) {
+  let buildOutput;
+  try {
+    buildOutput = await Bun.build({
+      entrypoints: [entryPath],
+      target: "browser",
+      format: "esm",
+      minify: false,
+      sourcemap: "none",
+      plugins: [reactAliasPlugin]
+    });
+  } catch (err) {
+    if (err instanceof AggregateError) {
+      const errors = err.errors.map((e) => ({
+        file: e.position?.file ?? "<unknown>",
+        line: e.position?.line ?? 0,
+        column: e.position?.column ?? 0,
+        message: e.message
+      }));
+      return { errors };
+    }
+    throw err;
+  }
+  const output = buildOutput.outputs[0];
+  if (!output) {
+    return {
+      errors: [{ file: "<unknown>", line: 0, column: 0, message: "ui-leaf: Bun.build produced no output" }]
+    };
+  }
+  return { js: await output.text() };
+}
+function assembleHtml(opts) {
+  const { js, title, csp, data, token, dataLoader } = opts;
+  const safeJs = js.replace(/<\/script>/gi, "<\\/script>");
+  const titleEscaped = title.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const cspMeta = csp ? `    <meta http-equiv="Content-Security-Policy" content="${csp.replace(/&/g, "&amp;").replace(/"/g, "&quot;")}" />
+` : "";
+  const safeToken = token ? escapeForScriptTag(JSON.stringify(token)) : null;
+  const tokenField = safeToken ? `, token: ${safeToken}` : "";
+  const bootstrapValue = dataLoader ? `{ token: ${safeToken ?? '""'} }` : `{ data: JSON.parse(${escapeForScriptTag(JSON.stringify(JSON.stringify(data ?? null)))})${tokenField} }`;
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>${titleEscaped}</title>
+${cspMeta}    <!-- ui-leaf bootstrap -->
+    <script>window.__UI_LEAF__ = ${bootstrapValue};</script>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module">${safeJs}</script>
+  </body>
+</html>`;
+}
+async function compileView(opts) {
+  const {
+    entry,
+    viewsRoot,
+    data,
+    title = "ui-leaf",
+    csp,
+    // allowedHosts has no compile-time effect; accepted for API symmetry.
+    allowedHosts: _allowedHosts,
+    token,
+    dataLoader = false
+  } = opts;
+  const viewsRootAbs = resolve(viewsRoot);
+  const hasExt = /\.[a-z]+$/i.test(entry);
+  const viewAbs = resolve(viewsRootAbs, hasExt ? entry : `${entry}.tsx`);
+  if (!viewAbs.startsWith(viewsRootAbs + sep)) {
+    return {
+      html: "",
+      errors: [
+        {
+          file: "<unknown>",
+          line: 0,
+          column: 0,
+          message: `ui-leaf: view '${entry}' resolves outside viewsRoot`
+        }
+      ]
+    };
+  }
+  try {
+    await stat(viewAbs);
+  } catch {
+    return {
+      html: "",
+      errors: [
+        {
+          file: viewAbs,
+          line: 0,
+          column: 0,
+          message: `ui-leaf: view '${entry}' not found at ${viewAbs}`
+        }
+      ]
+    };
+  }
+  const tempDir = await mkdtemp(join(tmpdir(), "ui-leaf-compile-"));
+  try {
+    const entryPath = join(tempDir, "entry.tsx");
+    const entryContent = dataLoader ? `import { createRoot } from "react-dom/client";
+import View from ${JSON.stringify(viewAbs)};
+const ctx = (globalThis as { __UI_LEAF__?: { token?: string } }).__UI_LEAF__ ?? {};
+const token = ctx.token;
+${SHARED_BRIDGE}
+async function bootstrap(): Promise<void> {
+  const res = await fetch("/api/data", {
+    headers: token ? { Authorization: "Bearer " + token } : {},
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error("ui-leaf: /api/data fetch failed (" + res.status + "): " + text);
+  }
+  const data = await res.json();
+  const el = document.getElementById("root");
+  if (!el) throw new Error("ui-leaf: #root element missing");
+  createRoot(el).render(<View data={data} mutate={mutate} />);
+}
+bootstrap();
+` : `import { createRoot } from "react-dom/client";
+import View from ${JSON.stringify(viewAbs)};
+const ctx = (globalThis as { __UI_LEAF__?: { data?: unknown; token?: string } }).__UI_LEAF__ ?? {};
+const data = ctx.data;
+const token = ctx.token;
+${SHARED_BRIDGE}
+const el = document.getElementById("root");
+if (!el) throw new Error("ui-leaf: #root element missing");
+createRoot(el).render(<View data={data} mutate={mutate} />);
+`;
+    await writeFile(entryPath, entryContent);
+    const buildResult = await runBunBuild(entryPath);
+    if ("errors" in buildResult) return { html: "", errors: buildResult.errors };
+    return {
+      html: assembleHtml({ js: buildResult.js, title, csp, data, token, dataLoader }),
+      errors: []
+    };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+async function compileSource(opts) {
+  const { source, data, title = "ui-leaf", csp, token } = opts;
+  const tempDir = await mkdtemp(join(tmpdir(), "ui-leaf-src-"));
+  try {
+    const viewPath = join(tempDir, "view.tsx");
+    const entryPath = join(tempDir, "entry.tsx");
+    await writeFile(viewPath, source);
+    const entryContent = `import { createRoot } from "react-dom/client";
+import View from ${JSON.stringify(viewPath)};
+const ctx = (globalThis as { __UI_LEAF__?: { data?: unknown; token?: string } }).__UI_LEAF__ ?? {};
+const data = ctx.data;
+const token = ctx.token;
+${SHARED_BRIDGE}
+const el = document.getElementById("root");
+if (!el) throw new Error("ui-leaf: #root element missing");
+createRoot(el).render(<View data={data} mutate={mutate} />);
+`;
+    await writeFile(entryPath, entryContent);
+    const buildResult = await runBunBuild(entryPath);
+    if ("errors" in buildResult) return { html: "", errors: buildResult.errors };
+    return {
+      html: assembleHtml({ js: buildResult.js, title, csp, data, token, dataLoader: false }),
+      errors: []
+    };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+// src/server.ts
+var ORIGINAL_STDOUT_WRITE = process.stdout.write.bind(process.stdout);
+var stdoutRedirectCount = 0;
+function redirectStdoutToStderr() {
+  stdoutRedirectCount++;
+  if (stdoutRedirectCount === 1) {
+    process.stdout.write = ((chunk, enc, cb) => process.stderr.write(chunk, enc, cb));
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    stdoutRedirectCount--;
+    if (stdoutRedirectCount === 0) {
+      process.stdout.write = ORIGINAL_STDOUT_WRITE;
+    }
+  };
+}
+async function openInAppMode(url) {
+  const candidates = [apps.chrome, apps.edge, apps.brave];
+  for (const app of candidates) {
+    try {
+      await open(url, { app: { name: app, arguments: [`--app=${url}`] } });
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var STRICT_CSP = [
+  "default-src 'self'",
+  "connect-src 'self'",
+  "img-src 'self' data: https:",
+  "font-src 'self' https: data:",
+  "style-src 'self' 'unsafe-inline'",
+  "script-src 'self' 'unsafe-inline'"
+].join("; ");
+function resolveCsp(opt) {
+  if (!opt || opt === "off") return null;
+  if (opt === "strict") return STRICT_CSP;
+  return opt;
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return nodeTimingSafeEqual(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+}
+var DEFAULT_LOOPBACK_HOSTNAMES = ["127.0.0.1", "localhost", "::1"];
+function parseHostHeader(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  if (trimmed.startsWith("[")) {
+    const close = trimmed.indexOf("]");
+    if (close === -1) return null;
+    return trimmed.slice(1, close).toLowerCase();
+  }
+  const colon = trimmed.indexOf(":");
+  return (colon === -1 ? trimmed : trimmed.slice(0, colon)).toLowerCase();
+}
+function isAllowedHost(value, allowed) {
+  const host = value === void 0 ? null : parseHostHeader(value);
+  return host !== null && allowed.has(host);
+}
+function isAllowedOrigin(value, allowed) {
+  if (value === void 0 || value === "" || value === "null") return true;
+  try {
+    let hostname = new URL(value).hostname.toLowerCase();
+    if (hostname.startsWith("[") && hostname.endsWith("]")) {
+      hostname = hostname.slice(1, -1);
+    }
+    return allowed.has(hostname);
+  } catch {
+    return false;
+  }
+}
+async function startDevServer(opts) {
+  const {
+    view,
+    data,
+    dataLoader,
+    viewsRoot,
+    mutations = {},
+    title = "ui-leaf",
+    port,
+    openBrowser = true,
+    shell = "tab",
+    heartbeatTimeoutMs = 75e3,
+    startupGraceMs = 3e4,
+    csp,
+    allowedHosts,
+    silent = false,
+    _opener
+  } = opts;
+  const cspHeader = resolveCsp(csp);
+  const allowedHostSet = new Set(DEFAULT_LOOPBACK_HOSTNAMES);
+  for (const h of allowedHosts ?? []) allowedHostSet.add(h.toLowerCase());
+  const allowedHostList = [...allowedHostSet].join(", ");
+  const restoreStdout = silent ? redirectStdoutToStderr() : null;
+  try {
+    let fireEvent2 = function(event) {
+      for (const fn of listeners.get(event)) fn();
+    };
+    var fireEvent = fireEvent2;
+    if (view.includes("/") || view.includes("\\")) {
+      throw new Error(
+        `ui-leaf: view '${view}' must be a bare identifier with no path separators`
+      );
+    }
+    if (data !== void 0 && dataLoader) {
+      throw new Error("ui-leaf: pass data or dataLoader, not both");
+    }
+    const token = randomBytes(32).toString("hex");
+    let loadedData;
+    if (dataLoader) {
+      loadedData = await dataLoader();
+    }
+    const result = await compileView({
+      entry: view,
+      viewsRoot,
+      data: dataLoader ? null : data,
+      title,
+      csp: cspHeader ?? void 0,
+      token,
+      dataLoader: !!dataLoader
+    });
+    if (result.errors.length > 0) {
+      const msg = result.errors.map((e) => e.message).join("; ");
+      throw new Error(`ui-leaf: view compilation failed: ${msg}`);
+    }
+    const viewState = { html: result.html, data: dataLoader ? loadedData : data };
+    const listeners = /* @__PURE__ */ new Map([
+      ["data-updated", /* @__PURE__ */ new Set()],
+      ["view-swapped", /* @__PURE__ */ new Set()]
+    ]);
+    let lastHeartbeatAt = Date.now();
+    let closeRequested = false;
+    let resolveClosed = () => {
+    };
+    const closed = new Promise((r) => {
+      resolveClosed = r;
+    });
+    const bunPort = port === void 0 ? 5810 : port;
+    let actualPort = bunPort;
+    const server = (() => {
+      const handler = (req) => {
+        const host = req.headers.get("host") ?? void 0;
+        const origin = req.headers.get("origin") ?? void 0;
+        const hostOk = isAllowedHost(host, allowedHostSet);
+        const originOk = isAllowedOrigin(origin, allowedHostSet);
+        if (!hostOk || !originOk) {
+          const offender = !hostOk ? `Host "${host ?? "(absent)"}"` : `Origin "${origin}"`;
+          return new Response(
+            `ui-leaf: refusing request with ${offender} \u2014 only the following hostnames are accepted to prevent DNS rebinding: ${allowedHostList}. Open the server at http://localhost:${actualPort}/ or http://127.0.0.1:${actualPort}/, or pass { allowedHosts: ["my-alias"] } to mount() to permit a custom alias.
+`,
+            { status: 403, headers: { "Content-Type": "text/plain; charset=utf-8" } }
+          );
+        }
+        const headers = {};
+        if (cspHeader) {
+          headers["Content-Security-Policy"] = cspHeader;
+        }
+        const url2 = new URL(req.url);
+        const path = url2.pathname;
+        const method = req.method;
+        if (method === "GET" && path === "/") {
+          return new Response(viewState.html, {
+            status: 200,
+            headers: { ...headers, "Content-Type": "text/html; charset=utf-8" }
+          });
+        }
+        if (method === "POST" && path === "/heartbeat") {
+          if (!checkAuth(req, token)) {
+            return new Response(JSON.stringify({ error: "unauthorized" }), {
+              status: 401,
+              headers: { ...headers, "Content-Type": "application/json" }
+            });
+          }
+          lastHeartbeatAt = Date.now();
+          return new Response("", { status: 204, headers });
+        }
+        if (method === "POST" && path === "/mutate") {
+          if (!checkAuth(req, token)) {
+            return new Response(JSON.stringify({ error: "unauthorized" }), {
+              status: 401,
+              headers: { ...headers, "Content-Type": "application/json" }
+            });
+          }
+          return handleMutate(req, mutations, headers);
+        }
+        if (method === "GET" && path === "/api/data") {
+          if (!dataLoader) {
+            return new Response(JSON.stringify({ error: "not found" }), {
+              status: 404,
+              headers: { ...headers, "Content-Type": "application/json" }
+            });
+          }
+          if (!checkAuth(req, token)) {
+            return new Response(JSON.stringify({ error: "unauthorized" }), {
+              status: 401,
+              headers: { ...headers, "Content-Type": "application/json" }
+            });
+          }
+          return new Response(JSON.stringify(viewState.data !== void 0 ? viewState.data : null), {
+            status: 200,
+            headers: { ...headers, "Content-Type": "application/json" }
+          });
+        }
+        return new Response(JSON.stringify({ error: "not found" }), {
+          status: 404,
+          headers: { ...headers, "Content-Type": "application/json" }
+        });
+      };
+      if (bunPort === 0) {
+        return Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: handler });
+      }
+      const MAX_PORT_ATTEMPTS = 10;
+      for (let i = 0; i < MAX_PORT_ATTEMPTS; i++) {
+        try {
+          return Bun.serve({ hostname: "127.0.0.1", port: bunPort + i, fetch: handler });
+        } catch (err) {
+          const isAddrinuse = err instanceof Error && err.message.includes("EADDRINUSE");
+          if (!isAddrinuse || i === MAX_PORT_ATTEMPTS - 1) {
+            if (isAddrinuse) {
+              throw new Error(
+                `ui-leaf: ports ${bunPort}\u2013${bunPort + MAX_PORT_ATTEMPTS - 1} are all in use. Pass { port: 0 } to mount() for an OS-assigned port.`
+              );
+            }
+            throw err;
+          }
+        }
+      }
+      throw new Error("unreachable");
+    })();
+    actualPort = server.port ?? bunPort;
+    const url = `http://127.0.0.1:${actualPort}`;
+    const startedAt = Date.now();
+    let heartbeatWatcher;
+    const cleanup = async () => {
+      if (closeRequested) return;
+      closeRequested = true;
+      if (heartbeatWatcher) clearInterval(heartbeatWatcher);
+      await server.stop(true);
+      if (restoreStdout) restoreStdout();
+      resolveClosed();
+    };
+    heartbeatWatcher = setInterval(() => {
+      const now = Date.now();
+      if (now - startedAt < startupGraceMs) return;
+      if (now - lastHeartbeatAt > heartbeatTimeoutMs) {
+        void cleanup();
+      }
+    }, 1e3);
+    const doOpen = _opener ? () => _opener(url) : async () => {
+      if (shell === "app") {
+        const launched = await openInAppMode(url);
+        if (!launched) {
+          process.stderr.write(
+            `ui-leaf: shell:"app" requested but no Chromium browser found; falling back to default browser tab.
+`
+          );
+          await open(url);
+        }
+      } else {
+        await open(url);
+      }
+    };
+    if (openBrowser) {
+      await doOpen();
+    }
+    return {
+      url,
+      port: actualPort,
+      closed,
+      close: cleanup,
+      on(event, listener) {
+        listeners.get(event)?.add(listener);
+      },
+      off(event, listener) {
+        listeners.get(event)?.delete(listener);
+      },
+      update(newData) {
+        viewState.data = newData;
+        fireEvent2("data-updated");
+      },
+      async swapView(source) {
+        const r = await compileSource({
+          source,
+          data: viewState.data,
+          title,
+          csp: cspHeader ?? void 0,
+          token
+        });
+        if (r.errors.length > 0) return r.errors;
+        viewState.html = r.html;
+        fireEvent2("view-swapped");
+        return [];
+      },
+      async patch(newData, source) {
+        const r = await compileSource({
+          source,
+          data: newData,
+          title,
+          csp: cspHeader ?? void 0,
+          token
+        });
+        if (r.errors.length > 0) return r.errors;
+        viewState.data = newData;
+        viewState.html = r.html;
+        fireEvent2("data-updated");
+        fireEvent2("view-swapped");
+        return [];
+      },
+      async reopen() {
+        await doOpen();
+      }
+    };
+  } catch (err) {
+    restoreStdout?.();
+    throw err;
+  }
+}
+function checkAuth(req, token) {
+  const header = req.headers.get("authorization") ?? "";
+  const match = /^Bearer (.+)$/.exec(header);
+  if (!match) return false;
+  return timingSafeEqual(match[1], token);
+}
+async function handleMutate(req, mutations, headers) {
+  const contentLength = req.headers.get("content-length");
+  if (contentLength && Number.parseInt(contentLength, 10) > 1024 * 1024) {
+    return new Response(JSON.stringify({ error: "request body exceeds 1 MiB limit" }), {
+      status: 400,
+      headers: { ...headers, "Content-Type": "application/json" }
+    });
+  }
+  let body;
+  try {
+    const text = await req.text();
+    if (text.length > 1024 * 1024) {
+      return new Response(JSON.stringify({ error: "request body exceeds 1 MiB limit" }), {
+        status: 400,
+        headers: { ...headers, "Content-Type": "application/json" }
+      });
+    }
+    body = text ? JSON.parse(text) : void 0;
+  } catch (err) {
+    return new Response(
+      JSON.stringify({ error: err instanceof Error ? err.message : "bad request" }),
+      { status: 400, headers: { ...headers, "Content-Type": "application/json" } }
+    );
+  }
+  const name = body?.name;
+  if (typeof name !== "string" || name.length === 0) {
+    return new Response(JSON.stringify({ error: "missing mutation name" }), {
+      status: 400,
+      headers: { ...headers, "Content-Type": "application/json" }
+    });
+  }
+  if (!Object.hasOwn(mutations, name)) {
+    return new Response(
+      JSON.stringify({
+        error: `ui-leaf: no mutation handler registered for '${name}'. Add it to the mutations: { } map passed to mount().`
+      }),
+      { status: 404, headers: { ...headers, "Content-Type": "application/json" } }
+    );
+  }
+  const handler = mutations[name];
+  try {
+    const result = await handler(body.args);
+    return new Response(JSON.stringify(result ?? null), {
+      status: 200,
+      headers: { ...headers, "Content-Type": "application/json" }
+    });
+  } catch (err) {
+    return new Response(
+      JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
+      { status: 500, headers: { ...headers, "Content-Type": "application/json" } }
+    );
+  }
+}
+// src/index.ts
+async function mount(opts) {
+  const viewsRoot = opts.viewsRoot ?? resolve2(process.cwd(), "views");
+  const server = await startDevServer({
+    view: opts.view,
+    data: opts.data,
+    dataLoader: opts.dataLoader,
+    viewsRoot,
+    mutations: opts.mutations,
+    title: opts.title,
+    port: opts.port,
+    openBrowser: opts.openBrowser,
+    shell: opts.shell,
+    heartbeatTimeoutMs: opts.heartbeatTimeoutMs,
+    startupGraceMs: opts.startupGraceMs,
+    csp: opts.csp,
+    allowedHosts: opts.allowedHosts,
+    silent: opts.silent
+  });
+  const onSignal = (signal) => {
+    void (async () => {
+      await server.close();
+      process.kill(process.pid, signal);
+    })();
+  };
+  const sigint = () => onSignal("SIGINT");
+  const sigterm = () => onSignal("SIGTERM");
+  process.once("SIGINT", sigint);
+  process.once("SIGTERM", sigterm);
+  if (opts.signal) {
+    if (opts.signal.aborted) {
+      process.off("SIGINT", sigint);
+      process.off("SIGTERM", sigterm);
+      await server.close();
+      return {
+        url: server.url,
+        port: server.port,
+        closed: Promise.resolve(),
+        close: server.close,
+        update: server.update.bind(server),
+        swapView: (source) => server.swapView(source),
+        patch: (data, source) => server.patch(data, source),
+        reopen: server.reopen.bind(server),
+        on: server.on.bind(server),
+        off: server.off.bind(server)
+      };
+    }
+    opts.signal.addEventListener(
+      "abort",
+      () => void server.close(),
+      { once: true }
+    );
+  }
+  const closed = server.closed.finally(() => {
+    process.off("SIGINT", sigint);
+    process.off("SIGTERM", sigterm);
+  });
+  return {
+    url: server.url,
+    port: server.port,
+    closed,
+    close: server.close,
+    update: server.update.bind(server),
+    swapView: (source) => server.swapView(source),
+    patch: (data, source) => server.patch(data, source),
+    reopen: server.reopen.bind(server),
+    on: server.on.bind(server),
+    off: server.off.bind(server)
+  };
+}
+export {
+  mount
+};
+//# sourceMappingURL=index.js.map