leglas 0.9.0 → 1.1.0

package/dist/index.js

@@ -1247,13 +1247,21 @@ var KNOWN_AGENTS = {
     name: "Cursor",
     binary: "cursor-agent",
     efforts: [],
+    // `--trust` on every invocation. Without it, print mode stops at a
+    // "Workspace Trust Required" prompt nothing can answer and exits 1 with
+    // no events, in any directory Cursor has not been trusted for by hand:
+    // measured against cursor-agent 2026.09.02, one second, zero output. The
+    // project is the one the user pointed Leglas at, which is the trust the
+    // flag grants. It is the only permission the run needs: with it alone,
+    // the edit and the shell command in the same run both executed.
     args: (prompt, _effort = null, _images = []) => [
       "-p",
       prompt,
       "--output-format",
-      "stream-json"
+      "stream-json",
+      "--trust"
     ],
-    terminalArgs: (prompt, _effort = null, _images = []) => ["-p", prompt],
+    terminalArgs: (prompt, _effort = null, _images = []) => ["-p", prompt, "--trust"],
     // `--resume [chatId]` is documented alongside `--continue` in the CLI
     // parameter reference, and every stream-json event carries the
     // `session_id` to feed it. Cursor exposes no persistent transport the way
@@ -1264,11 +1272,16 @@ var KNOWN_AGENTS = {
     // Images are accepted and ignored, like its other argument builders:
     // `cursor-agent` documents no flag for them, and the capture paths reach
     // it as text in the prompt either way.
-    resumeArgs: (sessionId, prompt, _effort = null, _images = []) => ["-p", "--resume", sessionId, prompt, "--output-format", "stream-json"],
+    resumeArgs: (sessionId, prompt, _effort = null, _images = []) => ["-p", "--resume", sessionId, prompt, "--output-format", "stream-json", "--trust"],
     sessionFrom: (event) => typeof event.session_id === "string" && event.session_id !== "" ? event.session_id : null,
+    // Read against cursor-agent 2026.09.02: every event carries the id, a
+    // resume in this argument order answers under the same id and remembers
+    // the earlier turn.
+    activityVerified: true,
     authArgs: ["status"],
-    // UNVERIFIED: cursor-agent was not available on the build machine. The
-    // reading is deliberately loose, and anything ambiguous stays unknown.
+    // The signed-in form was read from the CLI: "✓ Logged in as <email>",
+    // exit 0. The signed-out form has not been, so that side of the reading
+    // stays loose, and anything ambiguous stays unknown.
     authVerdict: (result) => {
       if (/logged in|signed in/i.test(result.stdout))
         return "ok";
@@ -1358,9 +1371,9 @@ function agentSearchPath(env = process.env, platform = process.platform) {
 function agentEnvironment(env = process.env) {
   return { ...env, PATH: agentSearchPath(env) };
 }
-async function pathLookup(binary) {
-  const entries = agentSearchPath().split(delimiter).filter((entry) => entry !== "");
-  const extensions = process.platform === "win32" ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((entry) => entry !== "") : [""];
+async function pathLookup(binary, env = process.env, platform = process.platform) {
+  const entries = agentSearchPath(env, platform).split(delimiter).filter((entry) => entry !== "");
+  const extensions = platform === "win32" ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((entry) => entry !== "") : [""];
   for (const entry of entries) {
     for (const extension of extensions) {
       try {
@@ -1372,10 +1385,10 @@ async function pathLookup(binary) {
   }
   return false;
 }
-async function detectAgents(lookup = pathLookup, probe2 = execProbe) {
+async function detectAgents(lookup2 = pathLookup, probe2 = execProbe) {
   const entries = Object.entries(KNOWN_AGENTS);
   return Promise.all(entries.map(async ([id, adapter]) => {
-    const available = await lookup(adapter.binary).catch(() => false);
+    const available = await lookup2(adapter.binary).catch(() => false);
     if (!available) {
       return {
         id,
@@ -1472,15 +1485,15 @@ function cursorActivity(event, cwd) {
   const wrapper = record(event.tool_call);
   if (wrapper === null)
     return null;
-  const key = Object.keys(wrapper)[0];
+  const key = Object.keys(wrapper).find((name) => name.endsWith("ToolCall"));
   if (key === void 0)
     return null;
   const call = record(wrapper[key]);
   const args = record(call?.args);
   const tool = key.replace(/ToolCall$/, "");
-  if (tool === "write") {
+  if (tool === "edit" || tool === "write") {
     const path2 = shownPath(args?.path, cwd);
-    return path2 === null ? "using write" : `editing ${path2}`;
+    return path2 === null ? "editing a file" : `editing ${path2}`;
   }
   if (tool === "read") {
     const path2 = shownPath(args?.path, cwd);
@@ -1804,6 +1817,13 @@ async function dropLocalPreviews(cwd, titles) {
 // ../server/dist/proxy.js
 import http, {} from "http";
 import net from "net";
+var SHARE_COOKIE = "leglas-share";
+function withoutShareCookie(cookie) {
+  if (cookie === void 0)
+    return void 0;
+  const kept = (Array.isArray(cookie) ? cookie.join("; ") : cookie).split(";").map((entry) => entry.trim()).filter((entry) => entry !== "" && !entry.startsWith(`${SHARE_COOKIE}=`));
+  return kept.length === 0 ? void 0 : kept.join("; ");
+}
 function createProxyHandler(options) {
   const target = new URL(options.target);
   const host = target.hostname;
@@ -1811,19 +1831,25 @@ function createProxyHandler(options) {
   const port = Number(target.port || (target.protocol === "https:" ? 443 : 80));
   const authority = target.port ? `${host}:${target.port}` : host;
   function upstreamHeaders(req) {
-    return { ...req.headers, host: authority };
+    const headers = { ...req.headers, host: authority };
+    const cookie = withoutShareCookie(headers.cookie);
+    if (cookie === void 0)
+      delete headers.cookie;
+    else
+      headers.cookie = cookie;
+    return headers;
   }
-  function rewriteLocation(location, publicOrigin) {
+  function rewriteLocation(location, publicOrigin2) {
     if (location === void 0)
       return void 0;
     for (const origin of [`${target.protocol}//${authority}`, `${target.protocol}//localhost:${port}`]) {
       if (location.startsWith(origin))
-        return publicOrigin + location.slice(origin.length);
+        return publicOrigin2 + location.slice(origin.length);
     }
     return location;
   }
   return {
-    request(req, res, publicOrigin) {
+    request(req, res, publicOrigin2) {
       options.onActivity?.();
       options.onOpen?.();
       let open = true;
@@ -1838,7 +1864,7 @@ function createProxyHandler(options) {
       res.once("close", close);
       const upstream = http.request({ host: dialHost, port, method: req.method, path: req.url, headers: upstreamHeaders(req) }, (upstreamRes) => {
         const headers = { ...upstreamRes.headers };
-        const location = rewriteLocation(typeof headers.location === "string" ? headers.location : void 0, publicOrigin);
+        const location = rewriteLocation(typeof headers.location === "string" ? headers.location : void 0, publicOrigin2);
         if (location !== void 0)
           headers.location = location;
         res.writeHead(upstreamRes.statusCode ?? 502, headers);
@@ -3027,13 +3053,13 @@ async function attachRequest(cwd, requestId, input, deps) {
   const references = [];
   requestedWidths.set(captured, Math.min(MAX_WIDTH, Math.max(MIN_WIDTH, Math.round(input.width))));
   const controller = new AbortController();
-  let expired = false;
+  let expired2 = false;
   let finishDeadline;
   const deadline = new Promise((resolve5) => {
     finishDeadline = resolve5;
   });
   const timer = setTimeout(() => {
-    expired = true;
+    expired2 = true;
     controller.abort();
     finishDeadline();
   }, deadlineMs);
@@ -3046,7 +3072,7 @@ async function attachRequest(cwd, requestId, input, deps) {
   const work = (async () => {
     try {
       const browser = await deps.pool.acquire();
-      if (expired)
+      if (expired2)
         return;
       if (browser === null) {
         captured.skipped = deps.pool.reason() ?? NO_BROWSER;
@@ -3060,7 +3086,7 @@ async function attachRequest(cwd, requestId, input, deps) {
         signal: controller.signal
       };
       const direction = await capture(browser, directionInput);
-      if (expired)
+      if (expired2)
         return;
       await mkdir3(destination, { recursive: true });
       await writeFile3(join5(destination, "frame.png"), direction.frame.png);
@@ -3078,7 +3104,7 @@ async function attachRequest(cwd, requestId, input, deps) {
       for (let index = 0; index < direction.crops.length; index += 1) {
         const crop = direction.crops[index];
         const note = input.notes[index];
-        if (crop === null || crop === void 0 || note === void 0 || expired)
+        if (crop === null || crop === void 0 || note === void 0 || expired2)
           continue;
         const name = `note-${index + 1}.png`;
         await writeFile3(join5(destination, name), crop.shot.png);
@@ -3092,7 +3118,7 @@ async function attachRequest(cwd, requestId, input, deps) {
           viewport: direction.frame.width
         });
       }
-      if (input.compare !== null && !expired) {
+      if (input.compare !== null && !expired2) {
         const compareInput = {
           url: previewUrl(input.origin, input.compare),
           width: input.width,
@@ -3100,7 +3126,7 @@ async function attachRequest(cwd, requestId, input, deps) {
           signal: controller.signal
         };
         const comparison = await capture(browser, compareInput);
-        if (expired)
+        if (expired2)
           return;
         await writeFile3(join5(destination, "compare.png"), comparison.frame.png);
         captured.attachments.push({
@@ -3113,14 +3139,14 @@ async function attachRequest(cwd, requestId, input, deps) {
         });
       }
     } catch (error) {
-      if (!expired) {
+      if (!expired2) {
         captured.skipped = error instanceof Error ? error.message : `The page did not load: ${String(error)}`;
       }
     }
   })();
   await Promise.race([work, deadline]);
   clearTimeout(timer);
-  if (expired)
+  if (expired2)
     captured.skipped = "The design could not be captured in time.";
   captured.attachments.push(...references);
   return captured;
@@ -5407,10 +5433,14 @@ function createCoalescer(emit, options = {}) {
     }
   };
 }
-function createLiveHub(_options = {}) {
+function createLiveHub(options = {}) {
   const listeners = /* @__PURE__ */ new Set();
+  let viewers = 0;
   const drop = (listener) => {
-    listeners.delete(listener);
+    if (!listeners.delete(listener) || !listener.viewer)
+      return;
+    viewers = Math.max(0, viewers - 1);
+    options.onViewers?.(viewers);
   };
   const write2 = (listener, opcode, payload) => {
     if (listener.socket.destroyed || !listener.socket.writable) {
@@ -5495,7 +5525,7 @@ function createLiveHub(_options = {}) {
         }
       }
     },
-    upgrade: (req, socket, head) => {
+    upgrade: (req, socket, head, upgradeOptions = {}) => {
       const path = (req.url ?? "/").split("?")[0] ?? "/";
       if (req.method !== "GET" || path !== LIVE_PATH)
         return false;
@@ -5517,8 +5547,16 @@ Sec-WebSocket-Accept: ${accept}\r
         socket.destroy();
         return false;
       }
-      const listener = { socket, buffered: Buffer.alloc(0) };
+      const listener = {
+        socket,
+        buffered: Buffer.alloc(0),
+        viewer: upgradeOptions.viewer === true
+      };
       listeners.add(listener);
+      if (listener.viewer) {
+        viewers += 1;
+        options.onViewers?.(viewers);
+      }
       socket.on("data", (chunk) => read(listener, chunk));
       socket.once("error", () => drop(listener));
       socket.once("end", () => drop(listener));
@@ -5536,10 +5574,1330 @@ Sec-WebSocket-Accept: ${accept}\r
     },
     get listening() {
       return listeners.size;
+    },
+    get viewers() {
+      return viewers;
+    }
+  };
+}
+
+// ../server/dist/share.js
+import { randomBytes as randomBytes4, randomUUID, timingSafeEqual } from "crypto";
+import http3 from "http";
+import { posix } from "path";
+
+// ../server/dist/tunnel.js
+import { spawn as spawnChild } from "child_process";
+import { Resolver, lookup } from "dns/promises";
+import http2 from "http";
+import https from "https";
+var URL_DEADLINE_MS = 3e4;
+var PROBE_DEADLINE_MS = 3e4;
+var PROBE_INTERVAL_MS = 1500;
+var SLOW_PROBE_INTERVAL_MS = 4e3;
+var SLOW_PROBE_CAP_MS = 3e4;
+var STOP_GRACE_MS = 3e3;
+var STOP_LIMIT_MS = STOP_GRACE_MS + 2e3;
+var PROBE_TIMEOUT_MS2 = 3e3;
+async function askLink(resolver, url, entryPath) {
+  let target;
+  try {
+    target = new URL(url);
+  } catch {
+    return false;
+  }
+  let address;
+  try {
+    [address] = await resolver.resolve4(target.hostname);
+  } catch {
+    try {
+      address = (await lookup(target.hostname, { family: 4 })).address;
+    } catch {
+      return false;
+    }
+  }
+  if (address === void 0)
+    return false;
+  const secure = target.protocol === "https:";
+  return new Promise((resolve5) => {
+    const request = (secure ? https : http2).request({
+      host: address,
+      port: Number(target.port || (secure ? 443 : 80)),
+      path: entryPath,
+      method: "GET",
+      headers: { host: target.host },
+      ...secure ? { servername: target.hostname } : {},
+      timeout: PROBE_TIMEOUT_MS2
+    }, (response) => {
+      response.resume();
+      const status = response.statusCode ?? 0;
+      resolve5(status >= 200 && status < 400);
+    });
+    request.once("timeout", () => request.destroy());
+    request.once("error", () => resolve5(false));
+    request.end();
+  });
+}
+async function detectTunnels(env = process.env) {
+  const providers = ["cloudflared", "ngrok"];
+  const found = await Promise.all(providers.map((provider) => pathLookup(provider, env).catch(() => false)));
+  return providers.filter((_provider, index) => found[index] === true);
+}
+function duration(ms) {
+  return ms % 1e3 === 0 ? `${ms / 1e3}s` : `${ms}ms`;
+}
+function withOutput(sentence, output) {
+  if (output === "")
+    return sentence;
+  const stem = sentence.endsWith(".") ? sentence.slice(0, -1) : sentence;
+  return `${stem} (${output.slice(0, 160)}).`;
+}
+function startTunnel(options, deps = {}) {
+  const spawn4 = deps.spawn ?? spawnChild;
+  const now = deps.now ?? Date.now;
+  const urlDeadlineMs = deps.urlDeadlineMs ?? URL_DEADLINE_MS;
+  const probeDeadlineMs = deps.probeDeadlineMs ?? PROBE_DEADLINE_MS;
+  const resolver = deps.probe === void 0 ? new Resolver() : null;
+  const probe2 = deps.probe ?? ((url2) => askLink(resolver, url2, options.entryPath));
+  const timers = /* @__PURE__ */ new Set();
+  const later = (callback, ms) => {
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      callback();
+    }, ms);
+    timer.unref?.();
+    timers.add(timer);
+    return timer;
+  };
+  const clearTimers = () => {
+    for (const timer of timers)
+      clearTimeout(timer);
+    timers.clear();
+  };
+  let lastState = "";
+  let state = { status: "starting", provider: options.provider };
+  let terminal = false;
+  let stopping = false;
+  let exited = false;
+  let stopPromise = null;
+  let settleStop = null;
+  let url = null;
+  let urlAt = 0;
+  let urlTimer = null;
+  let lastLine = "";
+  const partial = { stdout: "", stderr: "" };
+  const report = (next) => {
+    const serialized = JSON.stringify(next);
+    if (serialized === lastState)
+      return;
+    lastState = serialized;
+    state = next;
+    options.onState(next);
+  };
+  const fail = (reason) => {
+    if (terminal)
+      return;
+    terminal = true;
+    clearTimers();
+    report({
+      status: "failed",
+      provider: options.provider,
+      reason,
+      ...url === null ? {} : { url }
+    });
+  };
+  report(state);
+  const args = options.provider === "cloudflared" ? [
+    "tunnel",
+    "--url",
+    `http://127.0.0.1:${options.port}`,
+    "--no-autoupdate"
+  ] : ["http", String(options.port), "--log", "stdout", "--log-format", "json"];
+  let child;
+  try {
+    child = spawn4(options.provider, args, {
+      env: agentEnvironment(),
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch {
+    fail(`${options.provider} exited before the tunnel came up.`);
+    return { settle: () => {
+    }, stop: async () => {
+    } };
+  }
+  const beginProbe = (found) => {
+    if (url !== null || terminal || stopping)
+      return;
+    url = found;
+    urlAt = now();
+    if (urlTimer !== null) {
+      clearTimeout(urlTimer);
+      timers.delete(urlTimer);
+      urlTimer = null;
+    }
+    report({ status: "starting", provider: options.provider, url });
+    later(() => {
+      if (terminal || stopping || url === null)
+        return;
+      report({ status: "starting", provider: options.provider, url, slow: true });
+    }, probeDeadlineMs);
+    let slowWait = SLOW_PROBE_INTERVAL_MS;
+    const again = () => {
+      if (terminal || stopping || url === null)
+        return;
+      if (now() - urlAt < probeDeadlineMs) {
+        later(poll, PROBE_INTERVAL_MS);
+        return;
+      }
+      later(poll, slowWait);
+      slowWait = Math.min(SLOW_PROBE_CAP_MS, slowWait * 2);
+    };
+    const poll = () => {
+      if (terminal || stopping || url === null)
+        return;
+      void probe2(url).then((reachable) => {
+        if (terminal || stopping || url === null)
+          return;
+        if (reachable) {
+          terminal = true;
+          clearTimers();
+          report({ status: "ready", provider: options.provider, url });
+          return;
+        }
+        again();
+      }, again);
+    };
+    poll();
+  };
+  const inspect = (stream, line) => {
+    const trimmed = line.trim();
+    if (trimmed !== "")
+      lastLine = trimmed;
+    if (url !== null || trimmed === "")
+      return;
+    if (options.provider === "cloudflared") {
+      const found = /https:\/\/(?!api\.)[a-z0-9-]+\.trycloudflare\.com/.exec(trimmed)?.[0];
+      if (found !== void 0)
+        beginProbe(found);
+      return;
+    }
+    if (stream !== "stdout")
+      return;
+    try {
+      const event = JSON.parse(trimmed);
+      const candidate = typeof event.url === "string" && event.url.startsWith("https://") ? event.url : null;
+      if (candidate !== null)
+        beginProbe(candidate);
+    } catch {
+    }
+  };
+  const read = (stream, chunk) => {
+    const combined = partial[stream] + (Buffer.isBuffer(chunk) ? chunk.toString() : chunk);
+    const lines2 = combined.split(/\r?\n/);
+    partial[stream] = lines2.pop() ?? "";
+    for (const line of lines2)
+      inspect(stream, line);
+    if (partial[stream] !== "")
+      inspect(stream, partial[stream]);
+  };
+  child.stdout?.on("data", (chunk) => read("stdout", chunk));
+  child.stderr?.on("data", (chunk) => read("stderr", chunk));
+  const onExit = () => {
+    if (exited)
+      return;
+    exited = true;
+    clearTimers();
+    settleStop?.();
+    settleStop = null;
+    if (stopping)
+      return;
+    if (state.status === "ready") {
+      terminal = true;
+      report({
+        status: "failed",
+        provider: options.provider,
+        url: state.url,
+        reason: "The tunnel process exited."
+      });
+      return;
+    }
+    fail(withOutput(`${options.provider} exited before the tunnel came up.`, lastLine));
+  };
+  child.once("error", onExit);
+  child.once("exit", onExit);
+  urlTimer = later(() => fail(withOutput(`${options.provider} did not report a URL within ${duration(urlDeadlineMs)}.`, lastLine)), urlDeadlineMs);
+  return {
+    settle() {
+      if (terminal || stopping || url === null)
+        return;
+      terminal = true;
+      clearTimers();
+      report({ status: "ready", provider: options.provider, url });
+    },
+    stop() {
+      if (stopPromise !== null)
+        return stopPromise;
+      stopping = true;
+      clearTimers();
+      if (exited)
+        return Promise.resolve();
+      stopPromise = new Promise((resolve5) => {
+        let settled = false;
+        const done = () => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimers();
+          settleStop = null;
+          resolve5();
+        };
+        settleStop = done;
+        try {
+          child.kill("SIGTERM");
+        } catch {
+          done();
+          return;
+        }
+        later(() => {
+          if (exited)
+            return done();
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, STOP_GRACE_MS);
+        later(done, STOP_LIMIT_MS);
+      });
+      return stopPromise;
     }
   };
 }
 
+// ../server/dist/share.js
+var MAX_REFUSED = 40;
+function routeAllowed(routes, url) {
+  const [rawPath = "/"] = url.split("?", 2);
+  const path = canonical(rawPath);
+  return routes.some((route) => {
+    const prefix = route.endsWith("/") && route !== "/";
+    return prefix ? path.startsWith(route) || `${path}/` === route : path === route || path === `${route}/`;
+  });
+}
+var OWN_PREFIX = "/leglas";
+var ENTRY_PREFIX = `${OWN_PREFIX}/s/`;
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var MAX_GRANTS = 16;
+var MAX_TOMBSTONES = 32;
+var VIEWER_CONCURRENCY = 12;
+var VIEWER_QUEUE = 128;
+var VIEWER_DEADLINE_MS = 3e4;
+var DEV_CONTROL_ROUTES = [
+  /** read, Vite 8.2.2: opens `?file=` in the machine's editor. Rsbuild 2.2.3 too. */
+  "/__open-in-editor",
+  /** read, react-dev-utils 12.0.1: the same, older name. */
+  "/__open-stack-frame-in-editor",
+  /** read, react-dev-utils 12.0.1: serves a module's source through the overlay. */
+  "/__get-internal-source",
+  /** read, vite-plugin-inspect 12.0.2: the module graph and every transformed source. */
+  "/__inspect",
+  /** read, vite-plugin-vue-devtools 8.2.1: its whole interface and RPC surface. */
+  "/__devtools__",
+  /** read, browser-sync 3.0.4: its client surface and server metadata. */
+  "/__browser_sync__",
+  /**
+   * read, webpack-dev-server 6.0.0, which mounts its own surface here: the
+   * file listing, `/webpack-dev-server/invalidate`, which forces a rebuild,
+   * and `/webpack-dev-server/open-editor`, which calls the same launch-editor
+   * package Vite does. The subtree match below takes all three.
+   */
+  "/webpack-dev-server",
+  /** reported: Rails Web Console, an interactive server-side REPL. */
+  "/__web_console",
+  /** reported: the Better Errors gem, likewise. */
+  "/__better_errors",
+  /** reported: Laravel Ignition, whose solutions endpoint runs code. */
+  "/_ignition",
+  /** reported: Symfony's profiler, which serves traces, config and source. */
+  "/_profiler",
+  /** reported: Symfony's web debug toolbar. */
+  "/_wdt",
+  /** reported: Django Debug Toolbar, which serves settings, SQL and templates. */
+  "/__debug__",
+  /** reported: Go's pprof, where some GETs start expensive profiling. */
+  "/debug/pprof",
+  /** reported: Spring Boot Actuator, which can serve env, beans and heap dumps. */
+  "/actuator",
+  /** reported: Gatsby's development GraphQL surface, schema and content. */
+  "/___graphql"
+];
+var DEV_CONTROL_PREFIXES = [
+  /** read, Next 16.3.1. Its app assets sit at `/_next/` and stay allowed. */
+  "/__nextjs_",
+  /**
+   * read, Nuxt DevTools 4.0.0-alpha.16. Nuxt's own bundle is at `/_nuxt/`,
+   * one underscore and a different prefix, so the app is untouched.
+   */
+  "/__nuxt_devtools__",
+  /**
+   * read, Parcel 2.16.4: `__parcel_launch_editor` reads a `file` parameter
+   * and calls the same launch-editor code Vite does. Beside it sit
+   * `__parcel_source_map`, `__parcel_source_root` and `__parcel_code_frame`,
+   * which serve source, and the HMR and health routes, which a viewer has no
+   * use for: their live-reload socket is already refused.
+   */
+  "/__parcel_"
+];
+var DEV_CONTROL_QUERY_KEYS = ["__debugger__"];
+function canonical(path) {
+  let form = path;
+  try {
+    form = decodeURIComponent(path);
+  } catch {
+  }
+  return posix.normalize(form.replaceAll("\\", "/").replace(/\/{2,}/g, "/"));
+}
+function spellings(path) {
+  const seen = /* @__PURE__ */ new Set();
+  const add = (value) => {
+    seen.add(value);
+    seen.add(value.toLowerCase());
+  };
+  add(path);
+  const forms = [path];
+  try {
+    forms.push(decodeURIComponent(path));
+  } catch {
+  }
+  for (const value of forms) {
+    add(value);
+    for (const slashed of [value, value.replaceAll("\\", "/")]) {
+      const collapsed = slashed.replace(/\/{2,}/g, "/");
+      add(collapsed);
+      add(posix.normalize(collapsed));
+    }
+  }
+  return [...seen];
+}
+function isDevControlRequest(url) {
+  const [rawPath = "/", query] = url.split("?", 2);
+  for (const path of spellings(rawPath)) {
+    if (DEV_CONTROL_PREFIXES.some((prefix) => path.startsWith(prefix)))
+      return true;
+    if (DEV_CONTROL_ROUTES.some((route) => path === route || path.startsWith(`${route}/`))) {
+      return true;
+    }
+  }
+  if (query === void 0)
+    return false;
+  const keys = new URLSearchParams(query);
+  return DEV_CONTROL_QUERY_KEYS.some((key) => keys.has(key) || keys.has(key.toUpperCase()));
+}
+function isHiddenPath(path) {
+  return spellings(path).some((form) => {
+    const segments = form.split("/");
+    const modules = segments.indexOf("node_modules");
+    return segments.some((segment, at) => {
+      if (!segment.startsWith(".") || segment === "." || segment === "..")
+        return false;
+      const last = at === segments.length - 1;
+      return last || !(modules >= 0 && at > modules);
+    });
+  });
+}
+var FILES_PREFIX_PATH = "/leglas/files/";
+var DETECT_TTL_MS = 1e4;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function stringRecord(value) {
+  return isRecord3(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function layoutFrom(value) {
+  if (!isRecord3(value))
+    return null;
+  if (!stringArray(value.order) || !stringRecord(value.renames) || !stringArray(value.collapsedFamilies) || value.compare !== null && typeof value.compare !== "string" || value.viewport !== null && (typeof value.viewport !== "number" || !Number.isFinite(value.viewport))) {
+    return null;
+  }
+  return {
+    order: [...value.order],
+    renames: { ...value.renames },
+    collapsedFamilies: [...value.collapsedFamilies],
+    compare: value.compare,
+    viewport: value.viewport
+  };
+}
+function manifestFrom(value, previews) {
+  if (!isRecord3(value)) {
+    return { ok: false, error: "Share details must be a JSON object." };
+  }
+  const scope2 = value.scope;
+  const layout = layoutFrom(value.layout);
+  if (scope2 !== "direction" && scope2 !== "compare" && scope2 !== "rail" || !stringArray(value.titles) || layout === null) {
+    return { ok: false, error: "Share details need a scope, directions and a complete layout." };
+  }
+  const titles = [...value.titles];
+  if (titles.length === 0) {
+    return { ok: false, error: "Choose at least one direction to share." };
+  }
+  const byTitle = new Map(previews.map((preview) => [preview.title, preview]));
+  const unknown = [...new Set(titles.filter((title) => !byTitle.has(title)))];
+  if (unknown.length > 0) {
+    return {
+      ok: false,
+      error: `Directions are not available to share: ${unknown.join(", ")}.`
+    };
+  }
+  const branches = [
+    ...new Set(titles.filter((title) => byTitle.get(title)?.branch !== void 0))
+  ];
+  if (branches.length > 0) {
+    return {
+      ok: false,
+      error: `Branch directions can't be shared yet: ${branches.join(", ")}.`
+    };
+  }
+  if (scope2 === "direction" && titles.length > 1) {
+    return { ok: false, error: "A direction share can contain only one direction." };
+  }
+  if (scope2 === "compare" && (titles.length !== 2 || new Set(titles).size !== 2 || layout.compare === null || !titles.includes(layout.compare))) {
+    return {
+      ok: false,
+      error: "A comparison share needs exactly two directions and one of them on the right."
+    };
+  }
+  if (scope2 !== "compare" && layout.compare !== null) {
+    return { ok: false, error: "Only a comparison share can name a right pane." };
+  }
+  const reach = value.reach === "listed" ? "listed" : "open";
+  if (value.reach !== void 0 && value.reach !== "open" && value.reach !== "listed") {
+    return { ok: false, error: "Reach is either open or listed." };
+  }
+  if (value.routes !== void 0 && !stringArray(value.routes)) {
+    return { ok: false, error: "The route list must be an array of paths." };
+  }
+  const routes = [...new Set((value.routes ?? []).map((route) => route.split("?", 1)[0] ?? ""))].filter((route) => route !== "").slice(0, 400);
+  if (routes.some((route) => !route.startsWith("/"))) {
+    return { ok: false, error: "Every route must be a path beginning with a slash." };
+  }
+  const own = titles.flatMap((title) => {
+    const url = byTitle.get(title)?.url;
+    return url === void 0 ? [] : [url.split("?", 1)[0] ?? ""];
+  });
+  return {
+    ok: true,
+    manifest: { scope: scope2, titles, layout, reach, routes: [.../* @__PURE__ */ new Set([...routes, ...own])] }
+  };
+}
+function matchOne(candidate, grants) {
+  const received = Buffer.from(candidate, "utf8");
+  let found = null;
+  for (const grant of grants) {
+    const expected = Buffer.from(grant.token, "utf8");
+    if (expected.length !== received.length)
+      continue;
+    if (timingSafeEqual(expected, received))
+      found = grant;
+  }
+  return found;
+}
+function grantFor(share, candidate) {
+  return matchOne(candidate, share.grants.values());
+}
+function endedGrantFor(share, candidate) {
+  return matchOne(candidate, share.tombstones);
+}
+function expired(grant, now, nowMono) {
+  return now >= grant.expiresAt || nowMono >= grant.expiresAtMono;
+}
+function cookieToken(req) {
+  const raw = req.headers.cookie;
+  const cookies = (Array.isArray(raw) ? raw.join(";") : raw ?? "").split(";");
+  for (const cookie of cookies) {
+    const separator = cookie.indexOf("=");
+    if (separator === -1)
+      continue;
+    if (cookie.slice(0, separator).trim() !== SHARE_COOKIE)
+      continue;
+    return cookie.slice(separator + 1).trim();
+  }
+  return null;
+}
+function forwardedProto(req) {
+  const forwarded = req.headers["x-forwarded-proto"];
+  const first = Array.isArray(forwarded) ? forwarded[0] : forwarded;
+  return first?.split(",", 1)[0]?.trim() || "http";
+}
+function publicOrigin(req) {
+  return `${forwardedProto(req)}://${req.headers.host ?? "127.0.0.1"}`;
+}
+function throughTunnel(req) {
+  return req.headers["x-forwarded-for"] !== void 0 || req.headers["cf-connecting-ip"] !== void 0 || req.headers["x-forwarded-proto"] !== void 0;
+}
+function cloneLayout(layout) {
+  return {
+    ...layout,
+    order: [...layout.order],
+    renames: { ...layout.renames },
+    collapsedFamilies: [...layout.collapsedFamilies]
+  };
+}
+function sendJson(res, status, body) {
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(JSON.stringify(body));
+}
+var REFUSALS = {
+  inactive: {
+    status: 403,
+    sentence: "This link isn't active.",
+    title: "This Leglas link isn't active"
+  },
+  expiry: {
+    status: 410,
+    sentence: "This link expired. The person sharing it can send a new one.",
+    title: "This Leglas link expired"
+  },
+  revoke: {
+    status: 410,
+    sentence: "This link was turned off.",
+    title: "This Leglas link was turned off"
+  }
+};
+function refuse(req, res, cause = "inactive") {
+  const refusal = REFUSALS[cause];
+  const accept = req.headers.accept;
+  const html = (Array.isArray(accept) ? accept.join(",") : accept ?? "").includes("text/html");
+  if (!html) {
+    return sendJson(res, refusal.status, { ok: false, error: refusal.sentence });
+  }
+  res.writeHead(refusal.status, {
+    "content-type": "text/html; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(`<!doctype html>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${refusal.title}</title>
+<body style="margin:0;background:#1C1C20;color:#f5f4f1;font:16px/1.5 ui-sans-serif,system-ui;display:grid;min-height:100vh;place-items:center">
+<main style="max-width:34rem;padding:2rem"><h1 style="font-size:1.25rem">${refusal.title}</h1>
+<p>${refusal.sentence}</p></main>
+</body>`);
+}
+function bind(server) {
+  return new Promise((resolve5, reject) => {
+    const onError = (error) => {
+      server.removeListener("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      const address = server.address();
+      resolve5(typeof address === "object" && address !== null ? address.port : 0);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(0, "127.0.0.1");
+  });
+}
+function closeListener(share) {
+  return new Promise((resolve5) => {
+    if (share.expiryTimer !== null) {
+      clearTimeout(share.expiryTimer);
+      share.expiryTimer = null;
+    }
+    for (const socket of share.sockets)
+      socket.destroy();
+    share.sockets.clear();
+    share.server.closeAllConnections();
+    share.server.close(() => resolve5());
+  });
+}
+function createShareManager(options) {
+  const detect = options.detectTunnels ?? detectTunnels;
+  const runTunnel = options.startTunnel ?? startTunnel;
+  const now = options.now ?? Date.now;
+  const nowMono = options.nowMono ?? process.hrtime.bigint;
+  const deadlineMs = options.viewerDeadlineMs ?? VIEWER_DEADLINE_MS;
+  let detected = null;
+  let active = null;
+  let creating = false;
+  let stops = 0;
+  let closed = false;
+  let stopPromise = null;
+  let detectedAt = 0;
+  const tunnels = () => {
+    if (detected === null || Date.now() - detectedAt > DETECT_TTL_MS) {
+      detectedAt = Date.now();
+      detected = detect().catch(() => []);
+    }
+    return detected;
+  };
+  const status = () => {
+    const share = active;
+    if (share === null)
+      return null;
+    const tunnelUrl = "url" in share.tunnel ? share.tunnel.url : void 0;
+    const origin = tunnelUrl === void 0 ? null : tunnelUrl.replace(/\/$/, "");
+    return {
+      id: share.id,
+      scope: share.scope,
+      titles: [...share.titles],
+      layout: cloneLayout(share.layout),
+      sharePort: share.port,
+      grants: [...share.grants.values()].toSorted((a, b) => a.createdAt - b.createdAt).map((grant) => {
+        const entryPath = `${ENTRY_PREFIX}${grant.token}`;
+        return {
+          id: grant.id,
+          name: grant.name,
+          url: origin === null ? null : `${origin}${entryPath}`,
+          localUrl: `http://127.0.0.1:${share.port}${entryPath}`,
+          viewers: grant.viewers,
+          createdAt: grant.createdAt,
+          expiresAt: grant.expiresAt
+        };
+      }),
+      reach: share.reach,
+      routes: [...share.routes],
+      refused: [...share.refused],
+      tunnel: { ...share.tunnel },
+      startedAt: share.startedAt
+    };
+  };
+  const endGrant = (share, grant, why) => {
+    if (!share.grants.delete(grant.id))
+      return;
+    grant.endedAt = now();
+    grant.endedBy = why;
+    grant.viewers = 0;
+    share.tombstones.push(grant);
+    while (share.tombstones.length > MAX_TOMBSTONES)
+      share.tombstones.shift();
+    for (const socket of share.grantSockets.get(grant.id) ?? [])
+      socket.destroy();
+    share.grantSockets.delete(grant.id);
+    for (const held of share.grantRequests.get(grant.id) ?? []) {
+      held.res.destroy();
+      held.req.destroy();
+    }
+    share.grantRequests.delete(grant.id);
+    for (const held of [...share.waiting.get(grant.id) ?? []]) {
+      if (held.drop())
+        refuse(held.req, held.res, why);
+    }
+    share.waiting.delete(grant.id);
+    const turn = share.rota.indexOf(grant.id);
+    if (turn >= 0)
+      share.rota.splice(turn, 1);
+  };
+  const sweepExpiry = () => {
+    const share = active;
+    if (share === null)
+      return;
+    if (share.expiryTimer !== null) {
+      clearTimeout(share.expiryTimer);
+      share.expiryTimer = null;
+    }
+    const at = now();
+    const mono = nowMono();
+    let ended = false;
+    for (const grant of [...share.grants.values()]) {
+      if (!expired(grant, at, mono))
+        continue;
+      endGrant(share, grant, "expiry");
+      ended = true;
+    }
+    const next = [...share.grants.values()].reduce((soonest, grant) => soonest === null ? grant.expiresAt : Math.min(soonest, grant.expiresAt), null);
+    if (next !== null) {
+      share.expiryTimer = setTimeout(sweepExpiry, Math.max(1, next - at));
+      share.expiryTimer.unref?.();
+    }
+    if (ended)
+      options.live.nudge("share");
+  };
+  const mintGrant = (share, name) => {
+    let token = randomBytes4(24).toString("base64url");
+    const taken = new Set([...share.grants.values(), ...share.tombstones].map((g) => g.token));
+    while (taken.has(token))
+      token = randomBytes4(24).toString("base64url");
+    const at = now();
+    const grant = {
+      id: randomUUID(),
+      name,
+      token,
+      createdAt: at,
+      expiresAt: at + DEFAULT_TTL_MS,
+      expiresAtMono: nowMono() + BigInt(DEFAULT_TTL_MS) * 1000000n,
+      endedAt: null,
+      endedBy: null,
+      viewers: 0
+    };
+    share.grants.set(grant.id, grant);
+    return grant;
+  };
+  const resolve5 = (share, candidate) => {
+    const grant = grantFor(share, candidate);
+    if (grant !== null) {
+      if (!expired(grant, now(), nowMono()))
+        return { grant };
+      endGrant(share, grant, "expiry");
+      options.live.nudge("share");
+      return { refusal: "expiry" };
+    }
+    const ended = endedGrantFor(share, candidate);
+    if (ended !== null)
+      return { refusal: ended.endedBy === "revoke" ? "revoke" : "expiry" };
+    return { refusal: "inactive" };
+  };
+  const pump = (share) => {
+    while (share.running < VIEWER_CONCURRENCY && share.rota.length > 0) {
+      const grantId = share.rota[0];
+      if (grantId === void 0)
+        return;
+      const next = share.waiting.get(grantId)?.[0];
+      if (next === void 0) {
+        share.rota.shift();
+        share.waiting.delete(grantId);
+        continue;
+      }
+      next.drop();
+      const turn = share.rota.indexOf(grantId);
+      if (turn >= 0) {
+        share.rota.splice(turn, 1);
+        share.rota.push(grantId);
+      }
+      if (Date.now() >= next.spentAt) {
+        next.shed();
+        continue;
+      }
+      if (!share.grants.has(grantId)) {
+        refuse(next.req, next.res, "revoke");
+        continue;
+      }
+      next.start();
+    }
+  };
+  const admit = (share, grant, req, res, run4) => {
+    const queue = share.waiting.get(grant.id) ?? [];
+    if (queue.length >= VIEWER_QUEUE) {
+      return sendJson(res, 503, { ok: false, error: "Too much at once. Try again." });
+    }
+    let queued = true;
+    let running = false;
+    let over = false;
+    const spentAt = Date.now() + deadlineMs;
+    const shed = () => {
+      if (over)
+        return;
+      over = true;
+      sendJson(res, 503, { ok: false, error: "The dev server is busy. Try again." });
+    };
+    const deadline = setTimeout(() => {
+      if (over)
+        return;
+      const waited = held.drop();
+      if (running) {
+        over = true;
+        res.destroy();
+        release();
+        return;
+      }
+      if (waited)
+        shed();
+    }, deadlineMs);
+    deadline.unref?.();
+    const release = () => {
+      if (!running)
+        return;
+      running = false;
+      over = true;
+      clearTimeout(deadline);
+      share.running = Math.max(0, share.running - 1);
+      pump(share);
+    };
+    const start = () => {
+      running = true;
+      share.running += 1;
+      const writeHead = res.writeHead.bind(res);
+      res.writeHead = ((...args) => {
+        release();
+        return writeHead(...args);
+      });
+      res.once("finish", release);
+      res.once("close", release);
+      run4();
+    };
+    const held = {
+      req,
+      res,
+      grantId: grant.id,
+      spentAt,
+      start,
+      shed,
+      drop: () => {
+        if (!queued)
+          return false;
+        queued = false;
+        const rest = share.waiting.get(grant.id);
+        const at = rest?.indexOf(held) ?? -1;
+        if (rest !== void 0 && at >= 0)
+          rest.splice(at, 1);
+        if (rest !== void 0 && rest.length === 0) {
+          share.waiting.delete(grant.id);
+          const turn = share.rota.indexOf(grant.id);
+          if (turn >= 0)
+            share.rota.splice(turn, 1);
+        }
+        return true;
+      }
+    };
+    queue.push(held);
+    share.waiting.set(grant.id, queue);
+    if (!share.rota.includes(grant.id))
+      share.rota.push(grant.id);
+    pump(share);
+    if (!queued)
+      return;
+    res.once("close", () => {
+      held.drop();
+      if (running)
+        return;
+      over = true;
+      clearTimeout(deadline);
+    });
+  };
+  const request = (req, res) => {
+    const share = active;
+    if (share === null)
+      return refuse(req, res);
+    const path = (req.url ?? "/").split("?")[0] ?? "/";
+    if (path.startsWith(ENTRY_PREFIX)) {
+      const candidate = path.slice(ENTRY_PREFIX.length);
+      if (req.method !== "GET" && req.method !== "HEAD" || candidate.includes("/")) {
+        return refuse(req, res);
+      }
+      const found2 = resolve5(share, candidate);
+      if ("refusal" in found2)
+        return refuse(req, res, found2.refusal);
+      const secure = forwardedProto(req) === "https" ? "; Secure" : "";
+      res.writeHead(302, {
+        location: "/leglas/",
+        "set-cookie": `${SHARE_COOKIE}=${found2.grant.token}; Path=/; HttpOnly; SameSite=Lax${secure}`,
+        "cache-control": "no-store"
+      });
+      res.end();
+      return;
+    }
+    const cookie = cookieToken(req);
+    if (cookie === null)
+      return refuse(req, res);
+    const found = resolve5(share, cookie);
+    if ("refusal" in found)
+      return refuse(req, res, found.refusal);
+    const grant = found.grant;
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      return sendJson(res, 403, {
+        ok: false,
+        error: "Viewers can look, not change what runs."
+      });
+    }
+    if (isDevControlRequest(req.url ?? "/")) {
+      return sendJson(res, 403, { ok: false, error: "Not available to viewers." });
+    }
+    if (isHiddenPath(path)) {
+      return sendJson(res, 403, { ok: false, error: "Not available to viewers." });
+    }
+    if (req.headers["sec-fetch-dest"] === "serviceworker") {
+      return sendJson(res, 403, { ok: false, error: "Not available to viewers." });
+    }
+    const url = req.url ?? "/";
+    const interfaceOwn = spellings(path).every((form) => form === OWN_PREFIX || form.startsWith(`${OWN_PREFIX}/`));
+    if (share.reach === "listed" && !interfaceOwn && !routeAllowed(share.routes, url)) {
+      const asked = canonical(url.split("?", 1)[0] ?? "/");
+      if (!share.refused.includes(asked)) {
+        share.refused.push(asked);
+        while (share.refused.length > MAX_REFUSED)
+          share.refused.shift();
+        options.live.nudge("share");
+      }
+      return sendJson(res, 403, { ok: false, error: "Not shared." });
+    }
+    const run4 = () => {
+      const held = { req, res };
+      const inFlight = share.grantRequests.get(grant.id) ?? /* @__PURE__ */ new Set();
+      inFlight.add(held);
+      share.grantRequests.set(grant.id, inFlight);
+      let released = false;
+      const release = () => {
+        if (released)
+          return;
+        released = true;
+        share.grantRequests.get(grant.id)?.delete(held);
+      };
+      res.once("finish", release);
+      res.once("close", release);
+      options.request(req, res, { publicOrigin: publicOrigin(req), grantId: grant.id });
+    };
+    if (interfaceOwn)
+      return run4();
+    admit(share, grant, req, res, run4);
+  };
+  const upgrade = (req, socket, head) => {
+    const share = active;
+    const cookie = cookieToken(req);
+    if (share === null || cookie === null) {
+      socket.destroy();
+      return;
+    }
+    const found = resolve5(share, cookie);
+    if ("refusal" in found) {
+      socket.destroy();
+      return;
+    }
+    const grant = found.grant;
+    const path = (req.url ?? "/").split("?")[0] ?? "/";
+    if (path !== LIVE_PATH) {
+      socket.destroy();
+      return;
+    }
+    if (throughTunnel(req))
+      share.runningTunnel?.settle();
+    if (!options.upgrade(req, socket, head))
+      return;
+    const held = share.grantSockets.get(grant.id) ?? /* @__PURE__ */ new Set();
+    held.add(socket);
+    share.grantSockets.set(grant.id, held);
+    grant.viewers += 1;
+    options.live.nudge("share");
+    let gone = false;
+    const letGo = () => {
+      if (gone)
+        return;
+      gone = true;
+      share.grantSockets.get(grant.id)?.delete(socket);
+      grant.viewers = Math.max(0, grant.viewers - 1);
+      options.live.nudge("share");
+    };
+    socket.once("close", letGo);
+    socket.once("end", letGo);
+    socket.once("error", letGo);
+  };
+  const create = async (input) => {
+    if (closed)
+      return { ok: false, status: 409, error: "Leglas is shutting down." };
+    if (active !== null || creating) {
+      return { ok: false, status: 409, error: "Stop the current share first." };
+    }
+    creating = true;
+    const stopsAtStart = stops;
+    try {
+      const previews = await options.previews();
+      const parsed = manifestFrom(input, previews);
+      if (!parsed.ok)
+        return { ok: false, status: 400, error: parsed.error };
+      const providers = await tunnels();
+      const requested = isRecord3(input) ? input.tunnel : void 0;
+      if (requested !== void 0 && requested !== "none" && requested !== "cloudflared" && requested !== "ngrok") {
+        return { ok: false, status: 400, error: "That tunnel provider is not supported." };
+      }
+      if (requested !== void 0 && requested !== "none" && !providers.includes(requested)) {
+        return {
+          ok: false,
+          status: 400,
+          error: `${requested} is not available on this machine.`
+        };
+      }
+      const provider = requested ?? providers[0] ?? "none";
+      if (closed)
+        return { ok: false, status: 409, error: "Leglas is shutting down." };
+      const server = http3.createServer(request);
+      const sockets = /* @__PURE__ */ new Set();
+      server.on("connection", (socket) => {
+        sockets.add(socket);
+        socket.once("close", () => sockets.delete(socket));
+      });
+      server.on("upgrade", upgrade);
+      let port;
+      try {
+        port = await bind(server);
+      } catch (error) {
+        return {
+          ok: false,
+          status: 500,
+          error: `Leglas could not open a listener for the share (${error instanceof Error ? error.message : String(error)}).`
+        };
+      }
+      if (closed) {
+        await new Promise((resolve6) => server.close(() => resolve6()));
+        return { ok: false, status: 409, error: "Leglas is shutting down." };
+      }
+      if (stops !== stopsAtStart) {
+        await new Promise((resolve6) => server.close(() => resolve6()));
+        return { ok: false, status: 409, error: "Sharing was stopped while it was starting." };
+      }
+      const share = {
+        ...parsed.manifest,
+        id: randomUUID(),
+        grants: /* @__PURE__ */ new Map(),
+        tombstones: [],
+        port,
+        startedAt: now(),
+        tunnel: provider === "none" ? { status: "none" } : { status: "starting", provider },
+        runningTunnel: null,
+        tunnelGeneration: 0,
+        server,
+        sockets,
+        grantSockets: /* @__PURE__ */ new Map(),
+        grantRequests: /* @__PURE__ */ new Map(),
+        launch: null,
+        expiryTimer: null,
+        refused: [],
+        running: 0,
+        waiting: /* @__PURE__ */ new Map(),
+        rota: []
+      };
+      active = share;
+      mintGrant(share, "");
+      sweepExpiry();
+      options.live.nudge("share");
+      if (provider !== "none") {
+        share.launch = setImmediate(() => {
+          share.launch = null;
+          if (active !== share)
+            return;
+          share.runningTunnel = runTunnel({
+            provider,
+            port,
+            // Whichever link exists when the tunnel starts: the probe only
+            // needs a path the listener answers, and a share always has one.
+            entryPath: `${ENTRY_PREFIX}${[...share.grants.values()][0]?.token ?? ""}`,
+            onState: (next) => {
+              if (active !== share || JSON.stringify(share.tunnel) === JSON.stringify(next))
+                return;
+              share.tunnel = next;
+              options.live.nudge("share");
+            }
+          });
+        });
+        share.launch.unref?.();
+      }
+      return { ok: true, share: status() };
+    } finally {
+      creating = false;
+    }
+  };
+  const createGrant = (input) => {
+    const share = active;
+    if (share === null)
+      return { ok: false, status: 404, error: "Nothing is being shared." };
+    const name = isRecord3(input) && typeof input.name === "string" ? input.name.trim() : "";
+    if (name.length > 60) {
+      return { ok: false, status: 400, error: "That name is too long for a link." };
+    }
+    sweepExpiry();
+    if (share.grants.size >= MAX_GRANTS) {
+      return {
+        ok: false,
+        status: 409,
+        error: `A share can hold ${MAX_GRANTS} links. Revoke one to make another.`
+      };
+    }
+    mintGrant(share, name);
+    sweepExpiry();
+    options.live.nudge("share");
+    return { ok: true, share: status() };
+  };
+  const revokeGrant = (input) => {
+    const share = active;
+    if (share === null)
+      return { ok: false, status: 404, error: "Nothing is being shared." };
+    const id = isRecord3(input) && typeof input.id === "string" ? input.id : "";
+    const grant = share.grants.get(id);
+    if (grant === void 0)
+      return { ok: false, status: 404, error: "No such link." };
+    endGrant(share, grant, "revoke");
+    sweepExpiry();
+    options.live.nudge("share");
+    return { ok: true, share: status() };
+  };
+  const extendGrant = (input) => {
+    const share = active;
+    if (share === null)
+      return { ok: false, status: 404, error: "Nothing is being shared." };
+    const id = isRecord3(input) && typeof input.id === "string" ? input.id : "";
+    sweepExpiry();
+    const grant = share.grants.get(id);
+    if (grant === void 0) {
+      return { ok: false, status: 404, error: "That link has ended. Make a new one." };
+    }
+    const at = now();
+    grant.expiresAt = at + DEFAULT_TTL_MS;
+    grant.expiresAtMono = nowMono() + BigInt(DEFAULT_TTL_MS) * 1000000n;
+    sweepExpiry();
+    options.live.nudge("share");
+    return { ok: true, share: status() };
+  };
+  const rotate = async () => {
+    const share = active;
+    if (share === null)
+      return { ok: false, status: 404, error: "Nothing is being shared." };
+    for (const grant of [...share.grants.values()])
+      endGrant(share, grant, "revoke");
+    const provider = "provider" in share.tunnel ? share.tunnel.provider : null;
+    await share.runningTunnel?.stop().catch(() => {
+    });
+    share.runningTunnel = null;
+    if (active !== share)
+      return { ok: false, status: 404, error: "Nothing is being shared." };
+    mintGrant(share, "");
+    sweepExpiry();
+    if (provider !== null) {
+      share.tunnelGeneration += 1;
+      const generation = share.tunnelGeneration;
+      share.tunnel = { status: "starting", provider };
+      share.runningTunnel = runTunnel({
+        provider,
+        port: share.port,
+        entryPath: `${ENTRY_PREFIX}${[...share.grants.values()][0]?.token ?? ""}`,
+        onState: (next) => {
+          if (active !== share || share.tunnelGeneration !== generation)
+            return;
+          if (JSON.stringify(share.tunnel) === JSON.stringify(next))
+            return;
+          share.tunnel = next;
+          options.live.nudge("share");
+        }
+      });
+    }
+    options.live.nudge("share");
+    return { ok: true, share: status() };
+  };
+  const allowRoute = (input) => {
+    const share = active;
+    if (share === null)
+      return { ok: false, status: 404, error: "Nothing is being shared." };
+    const given = isRecord3(input) && typeof input.path === "string" ? input.path.trim() : "";
+    if (!given.startsWith("/")) {
+      return { ok: false, status: 400, error: "A route is a path beginning with a slash." };
+    }
+    const subtree = isRecord3(input) && input.subtree === true;
+    if (subtree && given.replace(/\/+$/, "") === "") {
+      return { ok: false, status: 400, error: "The root is a page, not a folder." };
+    }
+    const asked = subtree ? `${given.replace(/\/+$/, "")}/` : given === "/" ? given : given.replace(/\/+$/, "");
+    if (share.routes.length >= 400) {
+      return { ok: false, status: 409, error: "That share is holding as many routes as it can." };
+    }
+    if (!share.routes.includes(asked))
+      share.routes.push(asked);
+    share.refused = share.refused.filter((path) => !routeAllowed([asked], path));
+    options.live.nudge("share");
+    return { ok: true, share: status() };
+  };
+  const update = async (input) => {
+    const share = active;
+    if (share === null) {
+      return { ok: false, status: 404, error: "Nothing is being shared." };
+    }
+    const parsed = manifestFrom(input, await options.previews());
+    if (!parsed.ok)
+      return { ok: false, status: 400, error: parsed.error };
+    if (active !== share) {
+      return { ok: false, status: 404, error: "Nothing is being shared." };
+    }
+    share.scope = parsed.manifest.scope;
+    share.titles = parsed.manifest.titles;
+    share.layout = parsed.manifest.layout;
+    options.live.nudge("share");
+    options.live.nudge("config");
+    return { ok: true, share: status() };
+  };
+  const viewerConfig = async (grantId) => {
+    const share = active;
+    if (share === null || !share.grants.has(grantId))
+      return null;
+    const titles = new Set(share.titles);
+    const previews = (await options.previews()).filter((preview) => titles.has(preview.title));
+    if (active !== share)
+      return null;
+    return {
+      ...options.viewerConfig,
+      // The project id is the config's absolute path, which keys the sharer's
+      // saved layout and names their machine's directories, and the dev
+      // server's address names their network. A viewer keeps no layout and
+      // never dials the dev server, so the share's own id does the job and
+      // the address is left blank.
+      project: `share:${share.id}`,
+      devServer: "",
+      previews: options.previewsForConfig(previews),
+      errors: [],
+      warnings: [],
+      viewer: { scope: share.scope, layout: cloneLayout(share.layout) }
+    };
+  };
+  const fileSlugAllowed = async (slug, grantId) => {
+    const share = active;
+    if (share === null || !share.grants.has(grantId))
+      return false;
+    const titles = new Set(share.titles);
+    const previews = await options.previews();
+    return previews.some((preview) => {
+      if (!titles.has(preview.title) || preview.file === void 0)
+        return false;
+      const rest = preview.url.startsWith(FILES_PREFIX_PATH) ? preview.url.slice(FILES_PREFIX_PATH.length) : "";
+      const slash = rest.indexOf("/");
+      return (slash === -1 ? rest : rest.slice(0, slash)) === slug;
+    });
+  };
+  const stop = () => {
+    stops += 1;
+    if (stopPromise !== null)
+      return stopPromise;
+    const share = active;
+    if (share === null)
+      return Promise.resolve();
+    if (share.launch !== null) {
+      clearImmediate(share.launch);
+      share.launch = null;
+    }
+    stopPromise = (async () => {
+      await share.runningTunnel?.stop().catch(() => {
+      });
+      await closeListener(share);
+      if (active === share)
+        active = null;
+      options.live.nudge("share");
+    })().finally(() => {
+      stopPromise = null;
+    });
+    return stopPromise;
+  };
+  const close = async () => {
+    closed = true;
+    await stop();
+  };
+  return {
+    tunnels,
+    status,
+    fileSlugAllowed,
+    allowRoute,
+    create,
+    createGrant,
+    revokeGrant,
+    extendGrant,
+    rotate,
+    update,
+    viewerConfig,
+    stop,
+    close
+  };
+}
+
 // ../server/dist/renames.js
 import { mkdir as mkdir6, readFile as readFile10, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname6, join as join10 } from "path";
@@ -5576,7 +6934,7 @@ function resolveTitle(input, titles, renames) {
 import { createReadStream, existsSync as existsSync3, statSync, unwatchFile, watch as watchFs, watchFile } from "fs";
 import { createHash as createHash2 } from "crypto";
 import { mkdir as mkdir8, readdir as readdir3, writeFile as writeFile8 } from "fs/promises";
-import http2 from "http";
+import http4 from "http";
 import net3 from "net";
 import { basename as basename3, dirname as dirname8, extname as extname3, join as join12, normalize, relative as relative3 } from "path";
 
@@ -5645,7 +7003,7 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 var FILES_PREFIX = `${LEGLAS_PREFIX}/files`;
-function sendJson(res, status, body) {
+function sendJson2(res, status, body) {
   const payload = JSON.stringify(body);
   res.writeHead(status, {
     "content-type": "application/json; charset=utf-8",
@@ -5982,7 +7340,8 @@ function watchHealth(target, live) {
     close: () => {
       closed = true;
       clearInterval(timer);
-    }
+    },
+    reachable: () => previous
   };
 }
 function snapshotConfig(cwd) {
@@ -6039,7 +7398,7 @@ function listen(server, port) {
     server.listen(port, "127.0.0.1");
   });
 }
-async function bind(server, requested) {
+async function bind2(server, requested) {
   if (requested === 0)
     return listen(server, 0);
   for (let attempt = 0; attempt < PORT_ATTEMPTS; attempt += 1) {
@@ -6055,6 +7414,8 @@ async function bind(server, requested) {
 async function startServer(options) {
   const { config, configErrors = [], configWarnings = [], shellDir = null, project = "", cwd = process.cwd(), leglasCommand = "npx -y leglas", fileMounts = /* @__PURE__ */ new Map(), detect = () => detectAgents() } = options;
   const browserPool = options.pool ?? createBrowserPool();
+  let shares = null;
+  let liveHealth = null;
   const live = options.live ?? createLiveHub();
   const branches = createBranchRegistry({
     cwd,
@@ -6129,12 +7490,136 @@ async function startServer(options) {
   const livePreviews = async () => (await livePreviewDefinitions()).map(readyPreview).filter((preview) => preview !== null);
   void probeAgents().catch(() => {
   });
-  const server = http2.createServer((req, res) => {
+  const readShareBody = (req, res, run4) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => {
+      const parsed = jsonBody(body);
+      if (parsed === null)
+        return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
+      void Promise.resolve(run4(parsed)).then((result) => {
+        if (result === void 0) {
+          return sendJson2(res, 500, { ok: false, error: "Sharing is not available." });
+        }
+        return result.ok ? sendJson2(res, 200, result) : sendJson2(res, result.status, { ok: false, error: result.error });
+      });
+    });
+  };
+  const handleRequest = (req, res, context) => {
     const url = req.url ?? "/";
     const path = url.split("?")[0] ?? "/";
     const query = new URLSearchParams(url.includes("?") ? url.slice(url.indexOf("?") + 1) : "");
-    if (req.method === "POST" && path.startsWith(`${LEGLAS_PREFIX}/api/`) && !isTrustedMutation(req)) {
-      return sendJson(res, 403, { ok: false, error: "Cross-origin API mutations are refused." });
+    if (!context.remote && req.method === "POST" && path.startsWith(`${LEGLAS_PREFIX}/api/`) && !isTrustedMutation(req)) {
+      return sendJson2(res, 403, { ok: false, error: "Cross-origin API mutations are refused." });
+    }
+    if (context.remote && path === `${LEGLAS_PREFIX}/api/config`) {
+      return void shares?.viewerConfig(context.grantId ?? "").then((payload) => {
+        if (payload === null) {
+          return sendJson2(res, 403, { ok: false, error: "This link isn't active." });
+        }
+        sendConditionalJson(req, res, payload);
+      });
+    }
+    if (context.remote && path === `${LEGLAS_PREFIX}/api/health`) {
+      const known = liveHealth?.reachable() ?? null;
+      return void (known === null ? probe(target) : Promise.resolve(known)).then((reachable) => sendConditionalJson(req, res, { reachable }));
+    }
+    if (context.remote && path.startsWith(`${LEGLAS_PREFIX}/api/`)) {
+      return sendJson2(res, 403, { error: "Not available to viewers." });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/update` && req.method === "GET" || req.method === "POST" && ["check", "skip", "install"].some((action) => path === `${LEGLAS_PREFIX}/api/update/${action}`)) {
+      const updates = options.updates;
+      if (updates === void 0) {
+        return sendJson2(res, 404, { ok: false, error: "Updates are not available here." });
+      }
+      if (req.method === "GET")
+        return sendJson2(res, 200, updates.status());
+      if (path.endsWith("/check")) {
+        return void updates.check({ force: true }).then((status) => sendJson2(res, 200, status));
+      }
+      if (path.endsWith("/install")) {
+        return void updates.update().then((status) => sendJson2(res, 200, status), (error) => sendJson2(res, 409, {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }));
+      }
+      if (!hasJsonBody(req))
+        return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", () => {
+        const parsed = jsonBody(body);
+        if (parsed === null)
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
+        if (typeof parsed.version !== "string" || parsed.version.trim() === "") {
+          return sendJson2(res, 400, { ok: false, error: "Body needs a version." });
+        }
+        void updates.skip(parsed.version).then((status) => sendJson2(res, 200, status), (error) => sendJson2(res, 400, {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }));
+      });
+    }
+    if (!context.remote && path === `${LEGLAS_PREFIX}/api/share` && req.method === "GET") {
+      return void shares?.tunnels().then((tunnels) => sendJson2(res, 200, { share: shares?.status() ?? null, tunnels }));
+    }
+    if (!context.remote && path === `${LEGLAS_PREFIX}/api/share` && req.method === "POST") {
+      if (!hasJsonBody(req)) {
+        return sendJson2(res, 400, { ok: false, error: "Share details must be JSON." });
+      }
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", async () => {
+        const parsed = jsonBody(body);
+        if (parsed === null) {
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        const result = await shares?.create(parsed).catch((error) => ({
+          ok: false,
+          status: 500,
+          error: `Leglas could not start the share (${error instanceof Error ? error.message : String(error)}).`
+        }));
+        if (result === void 0) {
+          return sendJson2(res, 500, { ok: false, error: "Sharing is not available." });
+        }
+        return result.ok ? sendJson2(res, 200, result) : sendJson2(res, result.status, { ok: false, error: result.error });
+      });
+    }
+    if (!context.remote && path === `${LEGLAS_PREFIX}/api/share/update` && req.method === "POST") {
+      if (!hasJsonBody(req)) {
+        return sendJson2(res, 400, { ok: false, error: "Share details must be JSON." });
+      }
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", async () => {
+        const parsed = jsonBody(body);
+        if (parsed === null) {
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        const result = await shares?.update(parsed);
+        if (result === void 0) {
+          return sendJson2(res, 500, { ok: false, error: "Sharing is not available." });
+        }
+        return result.ok ? sendJson2(res, 200, result) : sendJson2(res, result.status, { ok: false, error: result.error });
+      });
+    }
+    if (!context.remote && path === `${LEGLAS_PREFIX}/api/share/grants` && req.method === "POST") {
+      return void readShareBody(req, res, (body) => shares?.createGrant(body));
+    }
+    if (!context.remote && path === `${LEGLAS_PREFIX}/api/share/grants/revoke` && req.method === "POST") {
+      return void readShareBody(req, res, (body) => shares?.revokeGrant(body));
+    }
+    if (!context.remote && path === `${LEGLAS_PREFIX}/api/share/grants/extend` && req.method === "POST") {
+      return void readShareBody(req, res, (body) => shares?.extendGrant(body));
+    }
+    if (!context.remote && path === `${LEGLAS_PREFIX}/api/share/allow` && req.method === "POST") {
+      return void readShareBody(req, res, (body) => shares?.allowRoute(body));
+    }
+    if (!context.remote && path === `${LEGLAS_PREFIX}/api/share/rotate` && req.method === "POST") {
+      return void readShareBody(req, res, () => shares?.rotate());
+    }
+    if (!context.remote && path === `${LEGLAS_PREFIX}/api/share/stop` && req.method === "POST") {
+      return void (shares?.stop() ?? Promise.resolve()).then(() => sendJson2(res, 200, { ok: true }));
     }
     if (path === `${LEGLAS_PREFIX}/api/config`) {
       const boot = config?.previews ?? [];
@@ -6180,23 +7665,23 @@ async function startServer(options) {
       return void req.on("end", async () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (typeof parsed.title !== "string" || parsed.title.trim() === "") {
-          return sendJson(res, 400, { ok: false, error: "Body needs a direction title." });
+          return sendJson2(res, 400, { ok: false, error: "Body needs a direction title." });
         }
         const preview = (await livePreviewDefinitions()).find((entry) => entry.title === parsed.title);
         if (preview === void 0) {
-          return sendJson(res, 404, { ok: false, error: "No such direction." });
+          return sendJson2(res, 404, { ok: false, error: "No such direction." });
         }
         if (preview.branch === void 0) {
-          return sendJson(res, 400, {
+          return sendJson2(res, 400, {
             ok: false,
             error: `"${preview.title}" is not a branch preview.`
           });
         }
         if (config?.devCommand === void 0) {
-          return sendJson(res, 400, {
+          return sendJson2(res, 400, {
             ok: false,
             error: `"${preview.title}" cannot start because the config sets no devCommand.`
           });
@@ -6204,9 +7689,9 @@ async function startServer(options) {
         void branches.start(preview.title);
         const state = branches.state(preview.title);
         if (state === void 0) {
-          return sendJson(res, 404, { ok: false, error: "No such branch preview." });
+          return sendJson2(res, 404, { ok: false, error: "No such branch preview." });
         }
-        return sendJson(res, 200, { ok: true, state: publicBranchState(state) });
+        return sendJson2(res, 200, { ok: true, state: publicBranchState(state) });
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/previews/delete` && req.method === "POST") {
@@ -6215,11 +7700,11 @@ async function startServer(options) {
       return void req.on("end", async () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         const titles = parsed.titles;
         if (!Array.isArray(titles) || titles.length === 0 || titles.some((title) => typeof title !== "string" || title.trim() === "")) {
-          return sendJson(res, 400, {
+          return sendJson2(res, 400, {
             ok: false,
             error: "Body needs a non-empty array of direction titles."
           });
@@ -6228,20 +7713,20 @@ async function startServer(options) {
         try {
           const local = await readLocalPreviews(cwd);
           if (local.errors.length > 0) {
-            return sendJson(res, 409, { ok: false, error: local.errors.join(" ") });
+            return sendJson2(res, 409, { ok: false, error: local.errors.join(" ") });
           }
           const localTitles = new Set(local.previews.map((preview) => preview.title));
           const unknown = unique.filter((title) => !localTitles.has(title));
           if (unknown.length > 0) {
-            return sendJson(res, 400, {
+            return sendJson2(res, 400, {
               ok: false,
               error: "Only machine-local directions can be deleted from the registry."
             });
           }
           const deleted = await dropLocalPreviews(cwd, unique);
-          return sendJson(res, 200, { ok: true, deleted });
+          return sendJson2(res, 200, { ok: true, deleted });
         } catch {
-          return sendJson(res, 500, {
+          return sendJson2(res, 500, {
             ok: false,
             error: "The directions could not be deleted from Leglas."
           });
@@ -6251,7 +7736,7 @@ async function startServer(options) {
     if (path === `${LEGLAS_PREFIX}/api/references` && req.method === "POST") {
       const declaredLength = req.headers["content-length"];
       if (typeof declaredLength === "string" && Number(declaredLength) > REFERENCE_MAX_BYTES) {
-        return sendJson(res, 413, { ok: false, error: "That image is over 10MB." });
+        return sendJson2(res, 413, { ok: false, error: "That image is over 10MB." });
       }
       const chunks = [];
       let bytes = 0;
@@ -6265,7 +7750,7 @@ async function startServer(options) {
           refused = true;
           req.pause();
           res.once("finish", () => req.socket.destroy());
-          sendJson(res, 413, { ok: false, error: "That image is over 10MB." });
+          sendJson2(res, 413, { ok: false, error: "That image is over 10MB." });
           return;
         }
         chunks.push(buffer);
@@ -6274,12 +7759,12 @@ async function startServer(options) {
         if (refused)
           return;
         if (bytes === 0) {
-          return sendJson(res, 400, { ok: false, error: "The upload was empty." });
+          return sendJson2(res, 400, { ok: false, error: "The upload was empty." });
         }
         const body = Buffer.concat(chunks, bytes);
         const image = sniffImage(body);
         if (image === null) {
-          return sendJson(res, 415, {
+          return sendJson2(res, 415, {
             ok: false,
             error: "Only PNG, JPEG, WebP and GIF images can be attached."
           });
@@ -6291,7 +7776,7 @@ async function startServer(options) {
           await writeFile8(join12(cwd, file), body);
           void pruneReferences(cwd).catch(() => {
           });
-          return sendJson(res, 200, {
+          return sendJson2(res, 200, {
             ok: true,
             reference: {
               id,
@@ -6303,7 +7788,7 @@ async function startServer(options) {
             }
           });
         } catch {
-          return sendJson(res, 500, {
+          return sendJson2(res, 500, {
             ok: false,
             error: "The image could not be attached."
           });
@@ -6316,24 +7801,24 @@ async function startServer(options) {
       return void req.on("end", async () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (parsed.mode !== void 0 && parsed.mode !== "variant" && parsed.mode !== "replace") {
-          return sendJson(res, 400, {
+          return sendJson2(res, 400, {
             ok: false,
             error: 'mode must be "variant" or "replace".'
           });
         }
         const mode = parsed.mode === "replace" ? "replace" : "variant";
         if (parsed.references !== void 0 && (!Array.isArray(parsed.references) || parsed.references.some((reference) => typeof reference !== "string" || !/^[A-Za-z0-9_-]{1,32}$/.test(reference)))) {
-          return sendJson(res, 400, { ok: false, error: "references must be uploaded image ids." });
+          return sendJson2(res, 400, { ok: false, error: "references must be uploaded image ids." });
         }
         const references = parsed.references ?? [];
         if (references.length > 0) {
           const present = new Set((await readdir3(join12(cwd, REFERENCES_DIR)).catch(() => [])).map((name) => name.slice(0, name.indexOf(".") === -1 ? name.length : name.indexOf("."))));
           const gone = references.filter((id2) => !present.has(id2));
           if (gone.length > 0) {
-            return sendJson(res, 410, {
+            return sendJson2(res, 410, {
               ok: false,
               error: gone.length === 1 ? "An attached image is gone: it was pasted over an hour ago and never sent. Attach it again." : "Some attached images are gone: they were pasted over an hour ago and never sent. Attach them again."
             });
@@ -6343,11 +7828,11 @@ async function startServer(options) {
         const previews = await livePreviews();
         const preview = previews.find((entry) => entry.title === parsed.title);
         if (!preview) {
-          return sendJson(res, 400, { ok: false, error: "Unknown preview, or empty request." });
+          return sendJson2(res, 400, { ok: false, error: "Unknown preview, or empty request." });
         }
         const notes = annotationsFor(await readAnnotations(cwd).catch(() => []), preview.title);
         if (!parsed.intent?.trim() && notes.length === 0) {
-          return sendJson(res, 400, { ok: false, error: "Unknown preview, or empty request." });
+          return sendJson2(res, 400, { ok: false, error: "Unknown preview, or empty request." });
         }
         const intent = (parsed.intent ?? "").trim();
         const live2 = (await readRequests(cwd).catch(() => [])).filter((entry) => entry.status === "queued" || entry.status === "picked-up");
@@ -6361,7 +7846,7 @@ async function startServer(options) {
         // one forks the direction and the other rewrites it. Only a
         // genuine repeat is refused.
         (entry.mode ?? "replace") === mode && sameNotes(entry) && sameContext(entry))) {
-          return sendJson(res, 409, {
+          return sendJson2(res, 409, {
             ok: false,
             duplicate: true,
             error: `That exact change to ${preview.title} is already waiting.`
@@ -6395,13 +7880,13 @@ async function startServer(options) {
             ...composed
           }, id);
           runner?.nudge();
-          return sendJson(res, 200, {
+          return sendJson2(res, 200, {
             ok: true,
             ...composed,
             attachments: captured.attachments
           });
         } catch {
-          return sendJson(res, 200, {
+          return sendJson2(res, 200, {
             ok: true,
             ...composed,
             attachments: captured.attachments,
@@ -6412,29 +7897,29 @@ async function startServer(options) {
     }
     if (path === `${LEGLAS_PREFIX}/api/capture` && req.method === "POST") {
       if (!hasJsonBody(req)) {
-        return sendJson(res, 400, { ok: false, error: "Capture must be JSON." });
+        return sendJson2(res, 400, { ok: false, error: "Capture must be JSON." });
       }
       let body = "";
       req.on("data", (chunk) => body += chunk);
       return void req.on("end", async () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (typeof parsed.title !== "string" || parsed.title === "") {
-          return sendJson(res, 400, { ok: false, error: "Capture needs a direction title." });
+          return sendJson2(res, 400, { ok: false, error: "Capture needs a direction title." });
         }
         if (parsed.note !== void 0 && typeof parsed.note !== "string") {
-          return sendJson(res, 400, { ok: false, error: "The note id must be a string." });
+          return sendJson2(res, 400, { ok: false, error: "The note id must be a string." });
         }
         const preview = (await livePreviews()).find((entry) => entry.title === parsed.title);
         if (preview === void 0) {
-          return sendJson(res, 404, { ok: false, error: "No such direction." });
+          return sendJson2(res, 404, { ok: false, error: "No such direction." });
         }
         const width = typeof parsed.width === "number" && Number.isFinite(parsed.width) ? Math.min(MAX_WIDTH, Math.max(MIN_WIDTH, Math.round(parsed.width))) : 1440;
         const browser = await browserPool.acquire();
         if (browser === null) {
-          return sendJson(res, 503, {
+          return sendJson2(res, 503, {
             ok: false,
             error: browserPool.reason() ?? NO_BROWSER
           });
@@ -6471,7 +7956,7 @@ async function startServer(options) {
           });
           const result = await Promise.race([work, timeout]);
           if (result === timeoutMarker) {
-            return sendJson(res, 504, { ok: false, error: "The page did not load in time." });
+            return sendJson2(res, 504, { ok: false, error: "The page did not load in time." });
           }
           clearTimeout(timer);
           const crop = annotations.length > 0 ? result.crops[0] : null;
@@ -6481,7 +7966,7 @@ async function startServer(options) {
           const relativeFile = `${CAPTURES_DIR}/show/${name}`;
           await mkdir8(join12(cwd, CAPTURES_DIR, "show"), { recursive: true });
           await writeFile8(join12(cwd, relativeFile), shot.png);
-          return sendJson(res, 200, {
+          return sendJson2(res, 200, {
             ok: true,
             file: relativeFile,
             width: shot.width,
@@ -6493,7 +7978,7 @@ async function startServer(options) {
           });
         } catch (error) {
           clearTimeout(timer);
-          return sendJson(res, 502, {
+          return sendJson2(res, 502, {
             ok: false,
             error: error instanceof Error ? error.message : String(error)
           });
@@ -6504,14 +7989,14 @@ async function startServer(options) {
       return void readAgentChoice(cwd).then((choice) => {
         if (choice.agent !== null)
           runner?.prepare(choice.agent);
-        sendJson(res, 200, { ok: true });
-      }, () => sendJson(res, 200, { ok: true }));
+        sendJson2(res, 200, { ok: true });
+      }, () => sendJson2(res, 200, { ok: true }));
     }
     if (path === `${LEGLAS_PREFIX}/api/agents` && req.method === "GET") {
       return void Promise.all([
         currentAgents(query.get("refresh") === "1"),
         readAgentChoice(cwd)
-      ]).then(([agents, choice]) => sendJson(res, 200, {
+      ]).then(([agents, choice]) => sendJson2(res, 200, {
         agents,
         choice: choice.agent,
         customRun: choice.run,
@@ -6520,48 +8005,48 @@ async function startServer(options) {
     }
     if (path === `${LEGLAS_PREFIX}/api/agent` && req.method === "POST") {
       if (!isLoopbackAddress(req.socket.remoteAddress)) {
-        return sendJson(res, 403, {
+        return sendJson2(res, 403, {
           ok: false,
           error: "The agent choice can only be made from the machine running Leglas."
         });
       }
       if (!hasJsonBody(req)) {
-        return sendJson(res, 400, { ok: false, error: "Agent choice must be JSON." });
+        return sendJson2(res, 400, { ok: false, error: "Agent choice must be JSON." });
       }
       let body = "";
       req.on("data", (chunk) => body += chunk);
       return void req.on("end", () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (!isKnownAgent(parsed.agent) && parsed.agent !== "custom") {
-          return sendJson(res, 400, { ok: false, error: "Body needs a known agent." });
+          return sendJson2(res, 400, { ok: false, error: "Body needs a known agent." });
         }
         if (parsed.run !== void 0 && typeof parsed.run !== "string") {
-          return sendJson(res, 400, { ok: false, error: "The custom run command must be a string." });
+          return sendJson2(res, 400, { ok: false, error: "The custom run command must be a string." });
         }
         const effort = parsed.effort === null || isAgentEffort(parsed.effort) ? parsed.effort : void 0;
         if (parsed.effort !== void 0 && effort === void 0) {
-          return sendJson(res, 400, { ok: false, error: "Effort must be a supported level or null." });
+          return sendJson2(res, 400, { ok: false, error: "Effort must be a supported level or null." });
         }
         if (parsed.agent === "custom") {
           if (effort !== void 0) {
-            return sendJson(res, 400, {
+            return sendJson2(res, 400, {
               ok: false,
               error: "Custom agents manage effort in their own command."
             });
           }
           if (typeof parsed.run !== "string") {
-            return sendJson(res, 400, { ok: false, error: "A custom agent needs a run command." });
+            return sendJson2(res, 400, { ok: false, error: "A custom agent needs a run command." });
           }
           const template = parseTemplate(parsed.run);
           if (!template.ok)
-            return sendJson(res, 400, { ok: false, error: template.error });
-          return void saveAgentChoice(cwd, { agent: "custom", run: parsed.run }).then(() => sendJson(res, 200, { ok: true }), () => sendJson(res, 500, { ok: false, error: "Agent choice could not be saved." }));
+            return sendJson2(res, 400, { ok: false, error: template.error });
+          return void saveAgentChoice(cwd, { agent: "custom", run: parsed.run }).then(() => sendJson2(res, 200, { ok: true }), () => sendJson2(res, 500, { ok: false, error: "Agent choice could not be saved." }));
         }
         if (effort !== void 0 && effort !== null && !KNOWN_AGENTS[parsed.agent].efforts.includes(effort)) {
-          return sendJson(res, 400, {
+          return sendJson2(res, 400, {
             ok: false,
             error: `${KNOWN_AGENTS[parsed.agent].name} does not expose an effort override.`
           });
@@ -6571,8 +8056,8 @@ async function startServer(options) {
           ...effort === void 0 ? {} : { effort }
         }).then(() => {
           runner?.prepare(parsed.agent);
-          sendJson(res, 200, { ok: true });
-        }, () => sendJson(res, 500, { ok: false, error: "Agent choice could not be saved." }));
+          sendJson2(res, 200, { ok: true });
+        }, () => sendJson2(res, 500, { ok: false, error: "Agent choice could not be saved." }));
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/watch` && req.method === "POST") {
@@ -6581,13 +8066,13 @@ async function startServer(options) {
       return void req.on("end", () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (typeof parsed.watching !== "boolean") {
-          return sendJson(res, 400, { ok: false, error: "Body needs a watching boolean." });
+          return sendJson2(res, 400, { ok: false, error: "Body needs a watching boolean." });
         }
         lastSeen = parsed.watching ? Date.now() : null;
-        sendJson(res, 200, { ok: true });
+        sendJson2(res, 200, { ok: true });
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/requests` && req.method === "GET") {
@@ -6636,47 +8121,47 @@ async function startServer(options) {
     }
     if (path === `${LEGLAS_PREFIX}/api/requests/cancel` && req.method === "POST") {
       if (!hasJsonBody(req)) {
-        return sendJson(res, 200, { ok: true, cancelled: runner?.cancel() ?? false });
+        return sendJson2(res, 200, { ok: true, cancelled: runner?.cancel() ?? false });
       }
       let body = "";
       req.on("data", (chunk) => body += chunk);
       return void req.on("end", () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (parsed.id !== void 0 && typeof parsed.id !== "string") {
-          return sendJson(res, 400, { ok: false, error: "The request id must be a string." });
+          return sendJson2(res, 400, { ok: false, error: "The request id must be a string." });
         }
-        return sendJson(res, 200, { ok: true, cancelled: runner?.cancel(parsed.id) ?? false });
+        return sendJson2(res, 200, { ok: true, cancelled: runner?.cancel(parsed.id) ?? false });
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/requests/retry` && req.method === "POST") {
       if (!hasJsonBody(req)) {
-        return sendJson(res, 400, { ok: false, error: "Retry must be JSON." });
+        return sendJson2(res, 400, { ok: false, error: "Retry must be JSON." });
       }
       let body = "";
       req.on("data", (chunk) => body += chunk);
       return void req.on("end", async () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (typeof parsed.id !== "string") {
-          return sendJson(res, 400, { ok: false, error: "Body needs a request id." });
+          return sendJson2(res, 400, { ok: false, error: "Body needs a request id." });
         }
         const request = (await readRequests(cwd)).find((entry) => entry.id === parsed.id);
         if (request === void 0) {
-          return sendJson(res, 404, { ok: false, error: "No such request." });
+          return sendJson2(res, 404, { ok: false, error: "No such request." });
         }
         if (!isEnded(request, runner?.snapshot().failedIds ?? [])) {
-          return sendJson(res, 400, { ok: false, error: "Only an ended request can be run again." });
+          return sendJson2(res, 400, { ok: false, error: "Only an ended request can be run again." });
         }
         try {
           const retryId = newRequestId();
           const attachments = await rehomeCaptures(cwd, request.id, retryId, request.attachments ?? []).catch(() => []);
           if (!await removeRequest(cwd, request.id)) {
-            return sendJson(res, 404, { ok: false, error: "No such request." });
+            return sendJson2(res, 404, { ok: false, error: "No such request." });
           }
           await appendRequest(cwd, {
             title: request.title,
@@ -6697,9 +8182,9 @@ async function startServer(options) {
             ...request.references === void 0 ? {} : { references: request.references }
           }, retryId);
           runner?.nudge();
-          return sendJson(res, 200, { ok: true });
+          return sendJson2(res, 200, { ok: true });
         } catch {
-          return sendJson(res, 500, { ok: false, error: "The request could not be retried." });
+          return sendJson2(res, 500, { ok: false, error: "The request could not be retried." });
         }
       });
     }
@@ -6708,21 +8193,21 @@ async function startServer(options) {
     }
     if (path === `${LEGLAS_PREFIX}/api/annotations` && req.method === "POST") {
       if (!hasJsonBody(req)) {
-        return sendJson(res, 400, { ok: false, error: "A note must be JSON." });
+        return sendJson2(res, 400, { ok: false, error: "A note must be JSON." });
       }
       let body = "";
       req.on("data", (chunk) => body += chunk);
       return void req.on("end", async () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (typeof parsed.title !== "string" || parsed.title.trim() === "") {
-          return sendJson(res, 400, { ok: false, error: "A note needs a direction." });
+          return sendJson2(res, 400, { ok: false, error: "A note needs a direction." });
         }
         const anchor = anchorFrom(parsed.anchor);
         if (anchor === null) {
-          return sendJson(res, 400, { ok: false, error: "A note needs something to point at." });
+          return sendJson2(res, 400, { ok: false, error: "A note needs something to point at." });
         }
         try {
           const annotation = await addAnnotation(cwd, {
@@ -6730,87 +8215,87 @@ async function startServer(options) {
             note: typeof parsed.note === "string" ? parsed.note.trim() : "",
             title: parsed.title
           });
-          return sendJson(res, 200, { ok: true, annotation });
+          return sendJson2(res, 200, { ok: true, annotation });
         } catch {
-          return sendJson(res, 500, { ok: false, error: "The note could not be kept." });
+          return sendJson2(res, 500, { ok: false, error: "The note could not be kept." });
         }
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/annotations/update` && req.method === "POST") {
       if (!hasJsonBody(req)) {
-        return sendJson(res, 400, { ok: false, error: "A note must be JSON." });
+        return sendJson2(res, 400, { ok: false, error: "A note must be JSON." });
       }
       let body = "";
       req.on("data", (chunk) => body += chunk);
       return void req.on("end", async () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (typeof parsed.id !== "string" || parsed.id === "") {
-          return sendJson(res, 400, { ok: false, error: "Body needs the note to reword." });
+          return sendJson2(res, 400, { ok: false, error: "Body needs the note to reword." });
         }
         if (typeof parsed.note !== "string") {
-          return sendJson(res, 400, { ok: false, error: "A reworded note needs its words." });
+          return sendJson2(res, 400, { ok: false, error: "A reworded note needs its words." });
         }
         try {
           const annotation = await updateAnnotation(cwd, parsed.id, parsed.note);
           if (annotation === null) {
-            return sendJson(res, 404, { ok: false, error: "That note has gone." });
+            return sendJson2(res, 404, { ok: false, error: "That note has gone." });
           }
-          return sendJson(res, 200, { ok: true, annotation });
+          return sendJson2(res, 200, { ok: true, annotation });
         } catch {
-          return sendJson(res, 500, { ok: false, error: "The note could not be reworded." });
+          return sendJson2(res, 500, { ok: false, error: "The note could not be reworded." });
         }
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/annotations/delete` && req.method === "POST") {
       if (!hasJsonBody(req)) {
-        return sendJson(res, 400, { ok: false, error: "Delete must be JSON." });
+        return sendJson2(res, 400, { ok: false, error: "Delete must be JSON." });
       }
       let body = "";
       req.on("data", (chunk) => body += chunk);
       return void req.on("end", async () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         const ids = Array.isArray(parsed.ids) ? parsed.ids.filter((entry) => typeof entry === "string") : [];
         if (ids.length === 0) {
-          return sendJson(res, 400, { ok: false, error: "Body needs the notes to forget." });
+          return sendJson2(res, 400, { ok: false, error: "Body needs the notes to forget." });
         }
         try {
-          return sendJson(res, 200, { ok: true, deleted: await removeAnnotations(cwd, ids) });
+          return sendJson2(res, 200, { ok: true, deleted: await removeAnnotations(cwd, ids) });
         } catch {
-          return sendJson(res, 500, { ok: false, error: "The notes could not be forgotten." });
+          return sendJson2(res, 500, { ok: false, error: "The notes could not be forgotten." });
         }
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/requests/dismiss` && req.method === "POST") {
       if (!hasJsonBody(req)) {
-        return sendJson(res, 400, { ok: false, error: "Dismiss must be JSON." });
+        return sendJson2(res, 400, { ok: false, error: "Dismiss must be JSON." });
       }
       let body = "";
       req.on("data", (chunk) => body += chunk);
       return void req.on("end", async () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (typeof parsed.id !== "string") {
-          return sendJson(res, 400, { ok: false, error: "Body needs a request id." });
+          return sendJson2(res, 400, { ok: false, error: "Body needs a request id." });
         }
         const target2 = (await readRequests(cwd)).find((entry) => entry.id === parsed.id);
         if (target2 === void 0 || !isEnded(target2, runner?.snapshot().failedIds ?? [])) {
-          return sendJson(res, 400, { ok: false, error: "Only an ended request can be dismissed." });
+          return sendJson2(res, 400, { ok: false, error: "Only an ended request can be dismissed." });
         }
         try {
           if (!await removeRequest(cwd, parsed.id)) {
-            return sendJson(res, 404, { ok: false, error: "No such request." });
+            return sendJson2(res, 404, { ok: false, error: "No such request." });
           }
-          return sendJson(res, 200, { ok: true });
+          return sendJson2(res, 200, { ok: true });
         } catch {
-          return sendJson(res, 500, { ok: false, error: "The request could not be dismissed." });
+          return sendJson2(res, 500, { ok: false, error: "The request could not be dismissed." });
         }
       });
     }
@@ -6820,13 +8305,13 @@ async function startServer(options) {
       return void req.on("end", () => {
         const parsed = jsonBody(body);
         if (parsed === null) {
-          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+          return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
         }
         if (parsed.renames === null || typeof parsed.renames !== "object") {
-          return sendJson(res, 400, { ok: false, error: "Body needs a renames object." });
+          return sendJson2(res, 400, { ok: false, error: "Body needs a renames object." });
         }
         const renames = Object.fromEntries(Object.entries(parsed.renames).filter((entry) => typeof entry[1] === "string" && entry[1] !== ""));
-        void writeRenames(cwd, renames).then(() => sendJson(res, 200, { ok: true }), () => sendJson(res, 200, { ok: false }));
+        void writeRenames(cwd, renames).then(() => sendJson2(res, 200, { ok: true }), () => sendJson2(res, 200, { ok: false }));
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/health`) {
@@ -6843,42 +8328,87 @@ async function startServer(options) {
         relative6 = "";
       }
       const dir = fileMounts.get(slug);
-      if (dir !== void 0 && relative6 !== "" && serveFrom(res, dir, relative6))
-        return;
-      res.writeHead(404, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" });
-      return res.end("Leglas: no such preview file.");
+      const serveMount = () => {
+        if (dir !== void 0 && relative6 !== "" && serveFrom(res, dir, relative6))
+          return;
+        res.writeHead(404, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" });
+        res.end("Leglas: no such preview file.");
+      };
+      if (!context.remote)
+        return serveMount();
+      if (relative6.split("/").some((segment) => segment.startsWith("."))) {
+        return sendJson2(res, 403, { ok: false, error: "Not available to viewers." });
+      }
+      return void (shares?.fileSlugAllowed(slug, context.grantId ?? "") ?? Promise.resolve(false)).then((allowed) => {
+        if (!allowed)
+          return sendJson2(res, 403, { ok: false, error: "Not available to viewers." });
+        serveMount();
+      });
     }
     if (path.startsWith(`${LEGLAS_PREFIX}/api/`)) {
-      return sendJson(res, 404, { error: "No such Leglas API path." });
+      return sendJson2(res, 404, { error: "No such Leglas API path." });
     }
     if (path === LEGLAS_PREFIX || path.startsWith(`${LEGLAS_PREFIX}/`)) {
       if (shellDir !== null && serveShellFile(res, shellDir, path))
         return;
       if (shellDir !== null) {
         res.writeHead(404, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" });
-        return res.end("Leglas: no such path.");
+        res.end("Leglas: no such path.");
+        return;
       }
       res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
-      return res.end(PLACEHOLDER);
+      res.end(PLACEHOLDER);
+      return;
     }
-    return proxy.request(req, res, `http://localhost:${port}`);
-  });
+    return proxy.request(req, res, context.publicOrigin);
+  };
+  let port = 0;
+  const server = http4.createServer((req, res) => handleRequest(req, res, {
+    remote: false,
+    publicOrigin: `http://localhost:${port}`
+  }));
   const sockets = /* @__PURE__ */ new Set();
   server.on("connection", (socket) => {
     sockets.add(socket);
     socket.once("close", () => sockets.delete(socket));
   });
-  server.on("upgrade", (req, socket, head) => {
-    if (live.upgrade(req, socket, head))
-      return;
+  const handleUpgrade = (req, socket, head, context) => {
+    const liveUpgrade = context.remote ? live.upgrade(req, socket, head, { viewer: true }) : live.upgrade(req, socket, head);
+    if (liveUpgrade)
+      return true;
     const path = (req.url ?? "/").split("?")[0] ?? "/";
-    if (path.startsWith(`${LEGLAS_PREFIX}/`))
-      return socket.destroy();
+    if (path.startsWith(`${LEGLAS_PREFIX}/`)) {
+      socket.destroy();
+      return false;
+    }
     proxy.upgrade(req, socket, head);
+    return false;
+  };
+  server.on("upgrade", (req, socket, head) => {
+    handleUpgrade(req, socket, head, { remote: false });
+  });
+  shares = createShareManager({
+    live,
+    previews: livePreviewDefinitions,
+    previewsForConfig,
+    viewerConfig: {
+      project,
+      devServer: target,
+      scanPreviews: config?.scanPreviews ?? true
+    },
+    request: (req, res, context) => handleRequest(req, res, {
+      remote: true,
+      publicOrigin: context.publicOrigin,
+      grantId: context.grantId
+    }),
+    upgrade: (req, socket, head) => handleUpgrade(req, socket, head, { remote: true }),
+    ...options.detectTunnels === void 0 ? {} : { detectTunnels: options.detectTunnels },
+    ...options.startTunnel === void 0 ? {} : { startTunnel: options.startTunnel }
   });
-  const port = await bind(server, options.port ?? DEFAULT_PORT);
+  port = await bind2(server, options.port ?? DEFAULT_PORT);
+  options.updates?.setPort(port);
   const liveFiles = watchLiveFiles(cwd, bootConfigPath, live);
-  const liveHealth = watchHealth(target, live);
+  liveHealth = watchHealth(target, live);
   await pruneCaptures(cwd, (await readRequests(cwd).catch(() => [])).map((request) => request.id)).catch(() => {
   });
   await writeServerInfo(cwd, {
@@ -6895,6 +8425,8 @@ async function startServer(options) {
     ...options.codexAppServer === void 0 ? {} : { codexAppServer: options.codexAppServer },
     ...options.claudeAgentSession === void 0 ? {} : { claudeAgentSession: options.claudeAgentSession }
   });
+  options.updates?.onBusy(() => runner?.snapshot().running ?? false);
+  options.updates?.onChange(() => live.nudge("update"));
   let closePromise = null;
   return {
     port,
@@ -6902,26 +8434,41 @@ async function startServer(options) {
     close: () => {
       if (closePromise !== null)
         return closePromise;
-      liveFiles.close();
-      liveHealth.close();
-      closePromise = Promise.all([
-        branches.stop(),
-        runner.stop(),
-        browserPool.close(),
-        live.close()
-      ]).then(() => new Promise((done) => {
-        for (const socket of sockets)
-          socket.destroy();
-        sockets.clear();
-        server.closeAllConnections();
-        server.close(() => done());
-      })).then(() => removeServerInfo(cwd, { port, pid: process.pid }).catch(() => {
-      }));
+      closePromise = (async () => {
+        liveFiles.close();
+        liveHealth?.close();
+        await options.updates?.close();
+        await Promise.all([
+          shares?.close() ?? Promise.resolve(),
+          branches.stop(),
+          runner.stop(),
+          browserPool.close(),
+          live.close()
+        ]);
+        await new Promise((done) => {
+          for (const socket of sockets)
+            socket.destroy();
+          sockets.clear();
+          server.closeAllConnections();
+          server.close(() => done());
+        });
+        await removeServerInfo(cwd, { port, pid: process.pid }).catch(() => {
+        });
+      })();
       return closePromise;
     }
   };
 }
 
+// ../server/dist/update.js
+import { spawn as spawnChild2 } from "child_process";
+import { existsSync as existsSync4, readFileSync, realpathSync } from "fs";
+import { lstat as lstat3, mkdir as mkdir9, mkdtemp, rename as rename3, rm as rm5, writeFile as writeFile9 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname9, join as join13, posix as posix2, win32 } from "path";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var INSTALL_DEADLINE_MS = 5 * 60 * 1e3;
+
 // src/keep.ts
 function surfaceOf(url) {
   if (!url.startsWith("/") || !url.includes("?")) return null;
@@ -6977,8 +8524,8 @@ function planKeep(options) {
 }
 
 // src/run-init.ts
-import { readFile as readFile12, writeFile as writeFile9 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
+import { join as join14 } from "path";
 async function readIfPresent(path) {
   try {
     return await readFile12(path, "utf8");
@@ -6989,18 +8536,18 @@ async function readIfPresent(path) {
 async function runInit(options, deps) {
   const existingConfig = findConfigFile(options.cwd);
   const plan = planInit({
-    agents: await readIfPresent(join13(options.cwd, "AGENTS.md")),
+    agents: await readIfPresent(join14(options.cwd, "AGENTS.md")),
     config: existingConfig === null ? null : "present",
-    gitignore: await readIfPresent(join13(options.cwd, ".gitignore")),
+    gitignore: await readIfPresent(join14(options.cwd, ".gitignore")),
     force: options.force
   });
   const touched = [];
   for (const write2 of plan.writes) {
-    await writeFile9(join13(options.cwd, write2.path), write2.contents, "utf8");
+    await writeFile10(join14(options.cwd, write2.path), write2.contents, "utf8");
     touched.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile9(join13(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile10(join14(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     touched.push(".gitignore");
   }
   if (options.json) {
@@ -7019,9 +8566,9 @@ async function runInit(options, deps) {
 }
 
 // src/run-keep.ts
-import { existsSync as existsSync4 } from "fs";
-import { copyFile as copyFile2, mkdir as mkdir9, readFile as readFile13, rm as rm5, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname9, join as join14 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { copyFile as copyFile2, mkdir as mkdir10, readFile as readFile13, rm as rm6, writeFile as writeFile11 } from "fs/promises";
+import { dirname as dirname10, join as join15 } from "path";
 
 // src/resolve-title.ts
 function resolveOrExplain(input, titles, renames) {
@@ -7057,15 +8604,15 @@ async function writeLogEntry(options) {
     annotations: await readAnnotations(options.cwd),
     date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
   });
-  const dir = join14(options.cwd, options.logDir);
-  await mkdir9(dir, { recursive: true });
-  const file = join14(dir, `${entry.slug}.md`);
-  await writeFile10(file, entry.markdown, "utf8");
+  const dir = join15(options.cwd, options.logDir);
+  await mkdir10(dir, { recursive: true });
+  const file = join15(dir, `${entry.slug}.md`);
+  await writeFile11(file, entry.markdown, "utf8");
   if (entry.pictures.length > 0) {
-    const pictureDir = join14(dir, entry.slug);
-    await mkdir9(pictureDir, { recursive: true });
+    const pictureDir = join15(dir, entry.slug);
+    await mkdir10(pictureDir, { recursive: true });
     for (const picture of entry.pictures) {
-      await copyFile2(join14(options.cwd, picture.from), join14(pictureDir, picture.to)).catch(() => {
+      await copyFile2(join15(options.cwd, picture.from), join15(pictureDir, picture.to)).catch(() => {
       });
     }
   }
@@ -7088,17 +8635,17 @@ async function runKeep(options, deps) {
   if (!resolved.ok) return fail(resolved.error);
   const plan = planKeep({ title: resolved.title, previews, to: options.to });
   if (!plan.ok) return fail(plan.error);
-  const from = join14(options.cwd, plan.move.from);
-  const to = join14(options.cwd, plan.move.to);
-  if (!existsSync4(from)) {
+  const from = join15(options.cwd, plan.move.from);
+  const to = join15(options.cwd, plan.move.to);
+  if (!existsSync5(from)) {
     return fail(`${plan.move.from} does not exist. Nothing to keep.`);
   }
-  if (existsSync4(to)) {
+  if (existsSync5(to)) {
     return fail(`${plan.move.to} already exists. Choose another destination or move it aside.`);
   }
   const source = await readFile13(from, "utf8");
-  await mkdir9(dirname9(to), { recursive: true });
-  await writeFile10(to, renameExport(source, plan.exportName), "utf8");
+  await mkdir10(dirname10(to), { recursive: true });
+  await writeFile11(to, renameExport(source, plan.exportName), "utf8");
   const surface = plan.removeDir.slice(plan.removeDir.lastIndexOf("/") + 1);
   let logged = null;
   let logError = null;
@@ -7113,7 +8660,7 @@ async function runKeep(options, deps) {
   } catch (error) {
     logError = error instanceof Error ? error.message : String(error);
   }
-  await rm5(join14(options.cwd, plan.removeDir), { recursive: true, force: true });
+  await rm6(join15(options.cwd, plan.removeDir), { recursive: true, force: true });
   const dropped = await dropLocalPreviews(options.cwd, plan.dropTitles);
   if (options.json) {
     deps.log(
@@ -7151,9 +8698,9 @@ async function runKeep(options, deps) {
 }
 
 // src/run-new.ts
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir10, readFile as readFile14, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname10, join as join15 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir11, readFile as readFile14, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname11, join as join16 } from "path";
 async function readIfPresent2(path) {
   try {
     return await readFile14(path, "utf8");
@@ -7164,7 +8711,7 @@ async function readIfPresent2(path) {
 async function runNew(options, deps) {
   let from;
   if (options.from !== void 0) {
-    const contents = await readIfPresent2(join15(options.cwd, options.from));
+    const contents = await readIfPresent2(join16(options.cwd, options.from));
     if (contents === null) {
       const message2 = `${options.from} does not exist, so there is nothing to use as the baseline.`;
       if (options.json) deps.log(JSON.stringify({ ok: false, error: message2 }));
@@ -7175,8 +8722,8 @@ async function runNew(options, deps) {
   }
   const plan = planNew({
     surface: options.surface,
-    packageJson: await readIfPresent2(join15(options.cwd, "package.json")),
-    gitignore: await readIfPresent2(join15(options.cwd, ".gitignore")),
+    packageJson: await readIfPresent2(join16(options.cwd, "package.json")),
+    gitignore: await readIfPresent2(join16(options.cwd, ".gitignore")),
     from
   });
   const fail = (error) => {
@@ -7199,19 +8746,19 @@ async function runNew(options, deps) {
     deps.log(plan.instructions);
     return { exitCode: 0, written: [] };
   }
-  const existing = plan.writes.filter((write2) => existsSync5(join15(options.cwd, write2.path)));
+  const existing = plan.writes.filter((write2) => existsSync6(join16(options.cwd, write2.path)));
   if (existing.length > 0) {
     return fail(`${existing[0]?.path} already exists. Delete it first, or pick another surface name.`);
   }
   const written = [];
   for (const write2 of plan.writes) {
-    const target = join15(options.cwd, write2.path);
-    await mkdir10(dirname10(target), { recursive: true });
-    await writeFile11(target, write2.contents, "utf8");
+    const target = join16(options.cwd, write2.path);
+    await mkdir11(dirname11(target), { recursive: true });
+    await writeFile12(target, write2.contents, "utf8");
     written.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile11(join15(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile12(join16(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     written.push(".gitignore");
   }
   if (options.json) {
@@ -7232,13 +8779,13 @@ async function runNew(options, deps) {
 }
 
 // src/run-previews.ts
-import { readFile as readFile15, writeFile as writeFile12 } from "fs/promises";
-import { join as join16 } from "path";
+import { readFile as readFile15, writeFile as writeFile13 } from "fs/promises";
+import { join as join17 } from "path";
 function envelope(deps, ok, body) {
   deps.log(JSON.stringify({ ok, ...body }));
 }
 async function ensureIgnored(cwd) {
-  const path = join16(cwd, ".gitignore");
+  const path = join17(cwd, ".gitignore");
   let current = null;
   try {
     current = await readFile15(path, "utf8");
@@ -7246,7 +8793,7 @@ async function ensureIgnored(cwd) {
     current = null;
   }
   const next = ignoreEntry(current);
-  if (next !== null) await writeFile12(path, next, "utf8");
+  if (next !== null) await writeFile13(path, next, "utf8");
 }
 async function runAdd(options, deps) {
   const loaded = await loadConfig(options.cwd);
@@ -7576,12 +9123,12 @@ async function runShow(options, deps) {
 
 // src/run-watch.ts
 import { spawn as spawn3 } from "child_process";
-import { mkdir as mkdir11, readFile as readFile16, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname11, join as join17 } from "path";
+import { mkdir as mkdir12, readFile as readFile16, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname12, join as join18 } from "path";
 var POLL_MS2 = 2e3;
 var HEARTBEAT_TIMEOUT_MS = 1e3;
 async function saveTemplate(cwd, run4) {
-  const path = join17(cwd, WATCH_PATH);
+  const path = join18(cwd, WATCH_PATH);
   let config = {};
   try {
     const parsed = JSON.parse(await readFile16(path, "utf8"));
@@ -7591,8 +9138,8 @@ async function saveTemplate(cwd, run4) {
   } catch {
   }
   config.run = run4;
-  await mkdir11(dirname11(path), { recursive: true });
-  await writeFile13(path, `${JSON.stringify(config, null, 2)}
+  await mkdir12(dirname12(path), { recursive: true });
+  await writeFile14(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 function spawnAgent(command, args, cwd) {
@@ -7731,12 +9278,12 @@ async function runWatch(options, deps) {
 
 // src/run-classify.ts
 import { stat as stat4 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 async function runClassify(options, deps) {
   const declared = await Promise.all(
     options.changes.map(async (change) => ({
       ...change,
-      exists: await stat4(join18(options.cwd, change.path)).then(
+      exists: await stat4(join19(options.cwd, change.path)).then(
         () => true,
         () => false
       )
@@ -7762,10 +9309,10 @@ async function runClassify(options, deps) {
 }
 
 // src/run.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { realpath as realpath4 } from "fs/promises";
 import { createRequire } from "module";
-import { basename as basename6, dirname as dirname12, join as join19, relative as relative5, resolve as resolve4 } from "path";
+import { basename as basename6, dirname as dirname13, join as join20, relative as relative5, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 
 // src/dev-server-owner.ts
@@ -7851,11 +9398,11 @@ function devServerOwnerWarning(origin, projectRoot, owners) {
 
 // src/run.ts
 function findShellDir() {
-  const bundled = join19(dirname12(fileURLToPath(import.meta.url)), "shell");
-  if (existsSync6(join19(bundled, "index.html"))) return bundled;
+  const bundled = join20(dirname13(fileURLToPath(import.meta.url)), "shell");
+  if (existsSync7(join20(bundled, "index.html"))) return bundled;
   try {
     const require2 = createRequire(import.meta.url);
-    return dirname12(require2.resolve("@leglas/shell/dist/index.html"));
+    return dirname13(require2.resolve("@leglas/shell/dist/index.html"));
   } catch {
     return null;
   }
@@ -7866,10 +9413,14 @@ function shellWord(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
 function embeddedLeglasCommand() {
-  const entry = join19(dirname12(fileURLToPath(import.meta.url)), "bin.js");
-  if (!existsSync6(entry)) return "npx -y leglas";
+  const entry = join20(dirname13(fileURLToPath(import.meta.url)), "bin.js");
+  if (!existsSync7(entry)) return "npx -y leglas";
   return [process.execPath, entry].map(shellWord).join(" ");
 }
+function skipStartupCheck(env) {
+  const off = (value) => value === void 0 || value === "" || value === "0" || value === "false";
+  return env.CI !== void 0 && env.CI !== "" && env.CI !== "false" || !off(env.LEGLAS_NO_UPDATE_CHECK);
+}
 async function run3(options, deps) {
   const loaded = await loadConfig(options.cwd);
   const local = await readLocalPreviews(options.cwd);
@@ -7898,8 +9449,8 @@ async function run3(options, deps) {
   const fileMounts = /* @__PURE__ */ new Map();
   for (const preview of merged?.previews ?? []) {
     if (preview.file !== void 0) {
-      const absolute = join19(options.cwd, preview.file);
-      if (!existsSync6(absolute)) {
+      const absolute = join20(options.cwd, preview.file);
+      if (!existsSync7(absolute)) {
         previewErrors.push(
           `"${preview.title}" names file ${preview.file}, which does not exist. The preview is skipped.`
         );
@@ -7909,7 +9460,7 @@ async function run3(options, deps) {
       for (let suffix = 2; fileMounts.has(slug); suffix += 1) {
         slug = `${worktreeSlug(preview.title) || "file"}-${suffix}`;
       }
-      fileMounts.set(slug, dirname12(absolute));
+      fileMounts.set(slug, dirname13(absolute));
       previews.push({
         ...preview,
         url: `${FILES_PREFIX}/${slug}/${encodeURIComponent(basename6(absolute))}`
@@ -7920,8 +9471,8 @@ async function run3(options, deps) {
   }
   const config = merged === null ? null : { ...merged, previews };
   const configWarnings = [];
-  const projectRoot = await realpath4(loaded.path === null ? options.cwd : dirname12(loaded.path)).catch(
-    () => resolve4(loaded.path === null ? options.cwd : dirname12(loaded.path))
+  const projectRoot = await realpath4(loaded.path === null ? options.cwd : dirname13(loaded.path)).catch(
+    () => resolve4(loaded.path === null ? options.cwd : dirname13(loaded.path))
   );
   const ownerWarning = needsApp && app === null ? inspectLocalDevServer(devServer).then((owners) => devServerOwnerWarning(devServer, projectRoot, owners)).catch(() => null) : Promise.resolve(null);
   const serverPromise = startServer({
@@ -7935,6 +9486,7 @@ async function run3(options, deps) {
     project: loaded.path ?? options.cwd,
     cwd: options.cwd,
     leglasCommand: embeddedLeglasCommand(),
+    ...deps.updates === void 0 ? {} : { updates: deps.updates },
     ...options.port === void 0 ? {} : { port: options.port }
   });
   const [server, warning] = await Promise.all([serverPromise, ownerWarning]);
@@ -7984,12 +9536,26 @@ async function run3(options, deps) {
     }
   }
   if (options.open) await deps.open(url);
+  let stopped = false;
+  let updateTimer = null;
+  if (!options.json && deps.updates !== void 0 && !skipStartupCheck(process.env)) {
+    void deps.updates.check().then(() => {
+      if (stopped) return;
+      const line = deps.updates?.notice();
+      if (line !== null && line !== void 0) deps.log(line);
+    });
+    const updates = deps.updates;
+    updateTimer = setInterval(() => void updates.check(), 60 * 6e4);
+    updateTimer.unref?.();
+  }
   return {
     exitCode: 0,
     url,
     devServer,
     previewCount,
     stop: async () => {
+      stopped = true;
+      if (updateTimer !== null) clearInterval(updateTimer);
       await app?.stop().catch(() => {
       });
       await server.close();