@solidrt/cli 0.0.50 → 0.0.52

package/dist/server.js

@@ -0,0 +1,3936 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../node_modules/.bun/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
+var require_resolve_uri_umd = __commonJS(function(exports, module) {
+  (function(global, factory) {
+    typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.resolveURI = factory());
+  })(exports, function() {
+    const schemeRegex = /^[\w+.-]+:\/\//;
+    const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+    const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+    function isAbsoluteUrl(input) {
+      return schemeRegex.test(input);
+    }
+    function isSchemeRelativeUrl(input) {
+      return input.startsWith("//");
+    }
+    function isAbsolutePath(input) {
+      return input.startsWith("/");
+    }
+    function isFileUrl(input) {
+      return input.startsWith("file:");
+    }
+    function isRelative(input) {
+      return /^[.?#]/.test(input);
+    }
+    function parseAbsoluteUrl(input) {
+      const match = urlRegex.exec(input);
+      return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+    }
+    function parseFileUrl(input) {
+      const match = fileRegex.exec(input);
+      const path = match[2];
+      return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+    }
+    function makeUrl(scheme, user, host, port, path, query, hash) {
+      return {
+        scheme,
+        user,
+        host,
+        port,
+        path,
+        query,
+        hash,
+        type: 7
+      };
+    }
+    function parseUrl(input) {
+      if (isSchemeRelativeUrl(input)) {
+        const url2 = parseAbsoluteUrl("http:" + input);
+        url2.scheme = "";
+        url2.type = 6;
+        return url2;
+      }
+      if (isAbsolutePath(input)) {
+        const url2 = parseAbsoluteUrl("http://foo.com" + input);
+        url2.scheme = "";
+        url2.host = "";
+        url2.type = 5;
+        return url2;
+      }
+      if (isFileUrl(input))
+        return parseFileUrl(input);
+      if (isAbsoluteUrl(input))
+        return parseAbsoluteUrl(input);
+      const url = parseAbsoluteUrl("http://foo.com/" + input);
+      url.scheme = "";
+      url.host = "";
+      url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+      return url;
+    }
+    function stripPathFilename(path) {
+      if (path.endsWith("/.."))
+        return path;
+      const index = path.lastIndexOf("/");
+      return path.slice(0, index + 1);
+    }
+    function mergePaths(url, base) {
+      normalizePath(base, base.type);
+      if (url.path === "/") {
+        url.path = base.path;
+      } else {
+        url.path = stripPathFilename(base.path) + url.path;
+      }
+    }
+    function normalizePath(url, type) {
+      const rel = type <= 4;
+      const pieces = url.path.split("/");
+      let pointer = 1;
+      let positive = 0;
+      let addTrailingSlash = false;
+      for (let i = 1;i < pieces.length; i++) {
+        const piece = pieces[i];
+        if (!piece) {
+          addTrailingSlash = true;
+          continue;
+        }
+        addTrailingSlash = false;
+        if (piece === ".")
+          continue;
+        if (piece === "..") {
+          if (positive) {
+            addTrailingSlash = true;
+            positive--;
+            pointer--;
+          } else if (rel) {
+            pieces[pointer++] = piece;
+          }
+          continue;
+        }
+        pieces[pointer++] = piece;
+        positive++;
+      }
+      let path = "";
+      for (let i = 1;i < pointer; i++) {
+        path += "/" + pieces[i];
+      }
+      if (!path || addTrailingSlash && !path.endsWith("/..")) {
+        path += "/";
+      }
+      url.path = path;
+    }
+    function resolve(input, base) {
+      if (!input && !base)
+        return "";
+      const url = parseUrl(input);
+      let inputType = url.type;
+      if (base && inputType !== 7) {
+        const baseUrl = parseUrl(base);
+        const baseType = baseUrl.type;
+        switch (inputType) {
+          case 1:
+            url.hash = baseUrl.hash;
+          case 2:
+            url.query = baseUrl.query;
+          case 3:
+          case 4:
+            mergePaths(url, baseUrl);
+          case 5:
+            url.user = baseUrl.user;
+            url.host = baseUrl.host;
+            url.port = baseUrl.port;
+          case 6:
+            url.scheme = baseUrl.scheme;
+        }
+        if (baseType > inputType)
+          inputType = baseType;
+      }
+      normalizePath(url, inputType);
+      const queryHash = url.query + url.hash;
+      switch (inputType) {
+        case 2:
+        case 3:
+          return queryHash;
+        case 4: {
+          const path = url.path.slice(1);
+          if (!path)
+            return queryHash || ".";
+          if (isRelative(base || input) && !isRelative(path)) {
+            return "./" + path + queryHash;
+          }
+          return path + queryHash;
+        }
+        case 5:
+          return url.path + queryHash;
+        default:
+          return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+      }
+    }
+    return resolve;
+  });
+});
+
+// src/server/main.ts
+import { serve } from "flux:http";
+import { file as file7, realpath as realpath4 } from "flux:fs";
+import { on as onSignal } from "flux:process";
+import { join as join6, resolveWithin } from "flux:path";
+import { command as command2 } from "flux:subprocess";
+import { interfaces, probe } from "flux:net";
+
+// src/server/state.ts
+var state = {
+  config: undefined,
+  clients: new Map,
+  nextClientId: 0,
+  generation: Date.now(),
+  currentReload: null,
+  currentMaps: null,
+  serverUrl: "",
+  stats: false,
+  userInputMuted: false,
+  watchPaused: false,
+  captureStartMs: 0,
+  captureLastAt: 0,
+  captureChain: Promise.resolve()
+};
+
+// src/server/args.ts
+import { argv } from "flux:process";
+function fail(message) {
+  throw new Error(message);
+}
+function integer(name, raw, min, max) {
+  let value = Number(raw);
+  if (!/^\d+$/.test(raw) || value < min || value > max) {
+    fail(`Invalid --${name} value "${raw}": expected an integer between ${min} and ${max}`);
+  }
+  return value;
+}
+function parseArgs(raw = argv) {
+  let sep = raw.indexOf("--");
+  let own = sep === -1 ? raw : raw.slice(0, sep);
+  let args = {
+    entry: undefined,
+    project: false,
+    file: false,
+    lan: false,
+    proxyHttp: false,
+    tunnel: false,
+    stats: false,
+    minify: false,
+    port: undefined,
+    capture: undefined,
+    client: null,
+    dataRoot: undefined,
+    size: undefined,
+    appArgs: sep === -1 ? [] : raw.slice(sep + 1)
+  };
+  let value = (name, i) => {
+    let v = own[i];
+    if (v === undefined || v.startsWith("--"))
+      fail(`--${name} needs a value`);
+    return v;
+  };
+  for (let i = 0;i < own.length; i++) {
+    let arg = own[i];
+    if (!arg.startsWith("--")) {
+      if (args.entry !== undefined)
+        fail(`Unexpected argument: ${arg}`);
+      args.entry = arg;
+      continue;
+    }
+    let name = arg.slice(2);
+    switch (name) {
+      case "project":
+        args.project = true;
+        break;
+      case "file":
+        args.file = true;
+        break;
+      case "lan":
+        args.lan = true;
+        break;
+      case "proxy-http":
+        args.proxyHttp = true;
+        break;
+      case "tunnel":
+        args.tunnel = true;
+        break;
+      case "stats":
+        args.stats = true;
+        break;
+      case "minify":
+        args.minify = true;
+        break;
+      case "port":
+        args.port = integer(name, value(name, ++i), 1, 65535);
+        break;
+      case "capture":
+        args.capture = value(name, ++i);
+        break;
+      case "client":
+        args.client = integer(name, value(name, ++i), 0, Number.MAX_SAFE_INTEGER);
+        break;
+      case "data-root":
+        args.dataRoot = value(name, ++i);
+        break;
+      case "size":
+        args.size = value(name, ++i);
+        break;
+      default:
+        fail(`Unknown flag: ${arg}`);
+    }
+  }
+  return args;
+}
+
+// src/server/mode.ts
+import { file, realpath } from "flux:fs";
+import { join } from "flux:path";
+var DEFAULT_ENTRY = "src/index.tsx";
+var ENTRY_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"];
+async function resolveMode(args) {
+  let cwd = await realpath(".");
+  let hasPkg = await file(join(cwd, "package.json")).exists();
+  let source = args.entry;
+  if (source !== undefined && !ENTRY_EXTENSIONS.some((ext) => source.endsWith(ext))) {
+    fail(`Not an app entry: ${source} (expected .tsx, .jsx, .ts, .js or .srt.js)`);
+  }
+  if (source !== undefined && !await file(source).exists())
+    fail(`Entry not found: ${source}`);
+  if (args.file && args.project)
+    fail("--file and --project exclude each other");
+  if (source === undefined) {
+    if (args.file || args.project)
+      fail("--file and --project need an entry file");
+    if (!hasPkg)
+      fail(`No package.json in ${cwd}. Run from the project root, or pass a file to use on its own.`);
+    let declared = await declaredEntry(cwd);
+    let entry2 = join(cwd, declared ?? DEFAULT_ENTRY);
+    if (!await file(entry2).exists()) {
+      fail(`Entry not found: ${entry2}${declared ? "" : ' (set "solidrt": { "entry": ... } in package.json)'}`);
+    }
+    return { mode: "project", key: cwd, projectDir: cwd, entry: entry2 };
+  }
+  let entry = await realpath(source);
+  if (hasPkg && !args.file && !args.project) {
+    fail(`${cwd} is a project (it has a package.json) and ${source} is a file: pass --project to use the project with this entry, or --file to use the file on its own.`);
+  }
+  if (hasPkg && args.project)
+    return { mode: "project", key: cwd, projectDir: cwd, entry };
+  if (!hasPkg && args.project)
+    fail(`--project needs a package.json in ${cwd}`);
+  return { mode: "file", key: entry, projectDir: null, entry };
+}
+async function declaredEntry(dir) {
+  let pkg = await file(join(dir, "package.json")).json().catch(() => fail(`Unreadable package.json in ${dir}`));
+  let config = pkg?.solidrt;
+  if (config === undefined)
+    return;
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    fail('"solidrt" in package.json must be an object');
+  }
+  if ("entry" in config && typeof config.entry !== "string")
+    fail('"solidrt": "entry" must be a string');
+  return config.entry;
+}
+function sourceDirOf(mode) {
+  return dirname(mode.entry);
+}
+function dirname(path) {
+  let i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return i <= 0 ? i === 0 ? path.slice(0, 1) : "." : path.slice(0, i);
+}
+function absolute(path, base) {
+  return /^([A-Za-z]:)?[\\/]/.test(path) ? path : join(base, path);
+}
+
+// src/server/binaries.ts
+import { file as file2 } from "flux:fs";
+import { join as join2 } from "flux:path";
+import { arch, env, platform } from "flux:process";
+var TRIPLES = {
+  "linux-x64": "linux-x64-gnu",
+  "linux-arm64": "linux-arm64-gnu",
+  "darwin-arm64": "darwin-arm64",
+  "win32-x64": "win32-x64-msvc"
+};
+function platformDir() {
+  if (env.SRT_PLATFORM_DIR)
+    return env.SRT_PLATFORM_DIR;
+  let triple = TRIPLES[`${platform}-${arch}`];
+  return env.SRT_HOME && triple ? join2(env.SRT_HOME, "dist", triple) : null;
+}
+async function requireBinary(name) {
+  let dir = platformDir();
+  let path = dir ? join2(dir, name + (platform === "win32" ? ".exe" : "")) : null;
+  if (path && await file2(path).exists())
+    return path;
+  fail(`Could not find the ${name} binary${dir ? ` in ${dir}` : ""}. Run through srt, or set SRT_HOME to a SolidRT checkout built with make client.`);
+}
+function srtCommand() {
+  let cli = env.SRT_CLI ?? (env.SRT_HOME ? join2(env.SRT_HOME, "packages", "cli") : undefined);
+  if (!cli)
+    fail("Could not find srt: set SRT_CLI to the @solidrt/cli package root, or SRT_HOME to a SolidRT checkout.");
+  return [env.SRT_BUN ?? "bun", join2(cli, "bin", "srt")];
+}
+
+// src/server/cache.ts
+import { Database } from "flux:sqlite";
+import { dir } from "flux:fs";
+import { join as join3 } from "flux:path";
+var CACHE_FILE = "http-cache.db";
+var db = null;
+var enabled = false;
+async function initCache(opts) {
+  await dir(opts.dir).create();
+  let d = await Database.open(join3(opts.dir, CACHE_FILE), "rw+");
+  await d.exec(`CREATE TABLE IF NOT EXISTS entries (
+    key         TEXT PRIMARY KEY,
+    method      TEXT NOT NULL,
+    url         TEXT NOT NULL,
+    status      INTEGER NOT NULL,
+    headers     TEXT NOT NULL,
+    body        BLOB NOT NULL,
+    cached_at   INTEGER NOT NULL
+  )`);
+  db = d;
+  enabled = true;
+}
+function keyFor(method, url) {
+  return method + `
+` + url;
+}
+function cacheableMethod(method) {
+  return method === "GET" || method === "HEAD";
+}
+function hasNoStore(headerVal) {
+  if (!headerVal)
+    return false;
+  return /(^|,)\s*no-store(\s*,|$)/i.test(headerVal);
+}
+function hasNoCache(headerVal) {
+  if (!headerVal)
+    return false;
+  return /(^|,)\s*no-cache(\s*,|$)/i.test(headerVal);
+}
+function shouldConsider(method, reqHeaders) {
+  if (!enabled)
+    return { skip: true };
+  if (!cacheableMethod(method))
+    return { skip: true };
+  if (reqHeaders.has("authorization"))
+    return { skip: true };
+  if (hasNoStore(reqHeaders.get("cache-control")))
+    return { skip: true };
+  return { skip: false };
+}
+function isBypass(reqHeaders) {
+  if (reqHeaders.get("x-srt-cache")?.toLowerCase() === "bypass")
+    return true;
+  if (hasNoCache(reqHeaders.get("cache-control")))
+    return true;
+  return false;
+}
+async function get(method, url) {
+  if (!db || !enabled)
+    return null;
+  let row = await db.query("SELECT method, url, status, headers, body, cached_at FROM entries WHERE key = ?").get([keyFor(method, url)]);
+  if (!row)
+    return null;
+  return {
+    method: row.method,
+    url: row.url,
+    status: row.status,
+    headers: JSON.parse(row.headers),
+    body: row.body,
+    cachedAt: row.cached_at
+  };
+}
+async function put(method, url, status, headers, body) {
+  if (!db || !enabled)
+    return;
+  if (status < 200 || status >= 300)
+    return;
+  if (hasNoStore(headers["cache-control"] ?? null))
+    return;
+  await db.run(`INSERT OR REPLACE INTO entries
+     (key, method, url, status, headers, body, cached_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`, [keyFor(method, url), method, url, status, JSON.stringify(headers), body, Date.now()]);
+}
+
+// src/server/proxy.ts
+function headersToObject(h) {
+  let out = {};
+  h.forEach((v, k) => {
+    out[k] = v;
+  });
+  return out;
+}
+async function handleProxy(req) {
+  let target = req.headers.get("x-srt-proxy-url");
+  if (!target) {
+    return new Response("Missing X-SRT-Proxy-Url", { status: 400 });
+  }
+  let forwardHeaders = new Headers(req.headers);
+  forwardHeaders.delete("host");
+  forwardHeaders.delete("x-srt-proxy-url");
+  forwardHeaders.delete("x-srt-cache");
+  forwardHeaders.delete("content-length");
+  let cacheStatus = "skip";
+  let cacheable = !shouldConsider(req.method, req.headers).skip;
+  let bypass = cacheable && isBypass(req.headers);
+  if (cacheable && !bypass) {
+    let hit = await get(req.method, target);
+    if (hit) {
+      console.log(`[cli] proxy ${req.method} ${target} [cache hit]`);
+      let respHeaders = new Headers(hit.headers);
+      respHeaders.set("x-srt-cache", "hit");
+      return new Response(hit.body, { status: hit.status, headers: respHeaders });
+    }
+  }
+  let hasBody = req.method !== "GET" && req.method !== "HEAD";
+  if (cacheable) {
+    cacheStatus = bypass ? "bypass" : "miss";
+    console.log(`[cli] proxy ${req.method} ${target} [${cacheStatus}]`);
+  } else {
+    console.log(`[cli] proxy ${req.method} ${target}`);
+  }
+  try {
+    let upstream = await fetch(target, {
+      method: req.method,
+      headers: forwardHeaders,
+      body: hasBody ? await req.bytes() : undefined
+    });
+    let respHeaders = new Headers(upstream.headers);
+    respHeaders.delete("content-encoding");
+    respHeaders.delete("transfer-encoding");
+    let bodyBytes = await upstream.bytes();
+    if (cacheable) {
+      await put(req.method, target, upstream.status, headersToObject(respHeaders), bodyBytes);
+      respHeaders.set("x-srt-cache", cacheStatus);
+    }
+    return new Response(bodyBytes, {
+      status: upstream.status,
+      statusText: upstream.statusText,
+      headers: respHeaders
+    });
+  } catch (e) {
+    console.log(`[cli] proxy error ${target}: ${String(e)}`);
+    return new Response(`Proxy error: ${String(e)}`, { status: 502 });
+  }
+}
+
+// src/server/rebuild.ts
+import { command } from "flux:subprocess";
+import { dir as dir3, file as file3 } from "flux:fs";
+
+// src/server/watcher.ts
+import { dir as dir2 } from "flux:fs";
+var DEBOUNCE_MS = 100;
+var SOURCE_EXT = /\.(tsx?|jsx?)$/;
+var offs = [];
+var timer = null;
+var changed = new Set;
+var building = false;
+var dirty = false;
+function basename(path) {
+  return path.slice(Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1);
+}
+function isToolingPath(path, root) {
+  let rel = path.startsWith(root) ? path.slice(root.length) : path;
+  return rel.split(/[\\/]/).some((part) => part.startsWith(".") || part === "node_modules");
+}
+function armWatcher(inputs) {
+  stopWatcher();
+  let config = state.config;
+  let hit = (path) => onChange(path);
+  try {
+    if (inputs) {
+      let byDir = new Map;
+      for (let input of inputs) {
+        let parent = dirname(input);
+        let names = byDir.get(parent);
+        if (!names)
+          byDir.set(parent, names = new Set);
+        names.add(basename(input));
+      }
+      for (let [parent, names] of byDir) {
+        offs.push(dir2(parent).watch((e) => names.has(basename(e.path)) && hit(e.path)));
+      }
+    } else {
+      let root = config.sourceDir;
+      offs.push(dir2(root).watch((e) => SOURCE_EXT.test(e.path) && !isToolingPath(e.path, root) && hit(e.path), { recursive: true }));
+    }
+    if (config.projectDir) {
+      let assets = `${config.projectDir}/assets`;
+      dir2(assets).exists().then((exists) => {
+        if (exists && offs.length)
+          offs.push(dir2(assets).watch((e) => !isToolingPath(e.path, assets) && hit(e.path), { recursive: true }));
+      });
+    }
+  } catch (e) {
+    console.error(`[cli] Watch failed: ${e instanceof Error ? e.message : e}`);
+    stopWatcher();
+  }
+}
+function stopWatcher() {
+  for (let off of offs)
+    off();
+  offs = [];
+  if (timer !== null)
+    clearTimeout(timer);
+  timer = null;
+  changed.clear();
+}
+function onChange(path) {
+  if (state.watchPaused)
+    return;
+  changed.add(path);
+  if (building) {
+    dirty = true;
+    return;
+  }
+  if (timer !== null)
+    clearTimeout(timer);
+  timer = setTimeout(() => void rebuild(), DEBOUNCE_MS);
+}
+async function rebuild() {
+  timer = null;
+  building = true;
+  let root = state.config.projectDir ?? state.config.sourceDir;
+  let names = [...changed].map((p) => p.startsWith(root) ? p.slice(root.length + 1) : p);
+  changed.clear();
+  console.log(`[cli] Change detected: ${names.slice(0, 3).join(", ")}${names.length > 3 ? ` (+${names.length - 3})` : ""}`);
+  let error = await rebuildAndBroadcast();
+  if (error) {
+    console.error(error);
+    showBuildFailure();
+  }
+  building = false;
+  if (dirty) {
+    dirty = false;
+    onChange(names[0] ?? root);
+  }
+}
+
+// src/server/rebuild.ts
+function buildReload(code, manifest) {
+  let config = state.config;
+  return {
+    type: "reload",
+    proxyHttp: config.proxyHttp,
+    args: config.args,
+    ...manifest ? { manifest } : {},
+    code
+  };
+}
+var BSOD_TRIGGER = `throw new Error("SolidRT: build failed")`;
+function latchAndSend(text) {
+  state.currentReload = text;
+  for (let [ws, info] of state.clients) {
+    info.timeScale = 1;
+    ws.send(text);
+  }
+}
+function showBuildFailure() {
+  state.currentMaps = null;
+  latchAndSend(JSON.stringify(buildReload(BSOD_TRIGGER)));
+}
+async function rebuildAndBroadcast() {
+  let config = state.config;
+  let args = [...config.srt.slice(1), "bundle", "--json", "--dev", ...config.entryArgs];
+  if (config.minify)
+    args.push("--minify");
+  let result = await command(config.srt[0], args, { cwd: config.cwd }).output();
+  if (!result.success) {
+    let stderr = typeof result.stderr === "string" ? result.stderr : "";
+    armWatcher(null);
+    return `Rebuild failed:
+${stderr.trim()}`;
+  }
+  let bundle;
+  try {
+    bundle = JSON.parse(typeof result.stdout === "string" ? result.stdout : "");
+  } catch {
+    armWatcher(null);
+    return "Rebuild failed: unreadable bundler output";
+  }
+  armWatcher(bundle.inputs ?? null);
+  let maps = {};
+  if (bundle.map)
+    maps.main = bundle.map;
+  for (let isolate of bundle.isolates ?? []) {
+    let path = `${config.cacheDir}/isolates/${isolate.id}.js`;
+    await dir3(path.slice(0, path.lastIndexOf("/"))).create();
+    await file3(path).write(isolate.code);
+    if (isolate.map)
+      maps[isolate.id] = isolate.map;
+  }
+  state.currentMaps = Object.keys(maps).length ? maps : null;
+  latchAndSend(JSON.stringify(buildReload(bundle.code ?? "", bundle.manifest)));
+  return null;
+}
+
+// ../../node_modules/.bun/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = 44;
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0;i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+  let value = 0;
+  let shift = 0;
+  let integer2 = 0;
+  do {
+    const c = reader.next();
+    integer2 = charToInt[c];
+    value |= (integer2 & 31) << shift;
+    shift += 5;
+  } while (integer2 & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max)
+    return false;
+  return reader.peek() !== comma;
+}
+var bufLength = 1024 * 16;
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol)
+        sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted)
+      sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+
+// ../../node_modules/.bun/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+var import_resolve_uri = __toESM(require_resolve_uri_umd(), 1);
+function stripFilename(path) {
+  if (!path)
+    return "";
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => import_resolve_uri.default(prefix + (source || ""), from);
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length)
+    return mappings;
+  if (!owned)
+    mappings = mappings.slice();
+  for (let i = unsortedIndex;i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+    mappings[i] = sortSegments(mappings[i], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i = start;i < mappings.length; i++) {
+    if (!isSorted(mappings[i]))
+      return i;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1;j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned)
+    line = line.slice();
+  return line.sort(sortComparator2);
+}
+function sortComparator2(a, b) {
+  return a[COLUMN] - b[COLUMN];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1;i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1;i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state2, key) {
+  const { lastKey, lastNeedle, lastIndex } = state2;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state2.lastKey = key;
+  state2.lastNeedle = needle;
+  return state2.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo)
+      return map;
+    const parsed = parse(map);
+    const { version, file: file4, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file4;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+    const resolve = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = undefined;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = undefined;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = undefined;
+    this._bySourceMemos = undefined;
+  }
+};
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0)
+    throw new Error(LINE_GTR_ZERO);
+  if (column < 0)
+    throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length)
+    return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+  if (index === -1)
+    return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1)
+    return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND)
+    index++;
+  if (index === -1 || index === segments.length)
+    return -1;
+  return index;
+}
+
+// src/server/remap.ts
+var cached = new Map;
+function tracerFor(name, text) {
+  let entry = cached.get(name);
+  if (!entry || entry.text !== text) {
+    let tracer = null;
+    try {
+      tracer = new TraceMap(JSON.parse(text));
+    } catch {}
+    entry = { text, tracer };
+    cached.set(name, entry);
+  }
+  return entry.tracer;
+}
+var REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/g;
+function remapPositions(text, maps) {
+  if (!maps)
+    return text;
+  for (let [name, map] of Object.entries(maps)) {
+    if (!text.includes(name + ":"))
+      continue;
+    let t = tracerFor(name, map);
+    if (!t)
+      continue;
+    let pattern = new RegExp(`(^|[^\\w/.$-])${name.replace(REGEX_SPECIALS, "\\$&")}:(\\d+)(?::(\\d+))?\\b`, "g");
+    text = text.replace(pattern, (frame, prefix, line, column) => {
+      let pos = originalPositionFor(t, {
+        line: parseInt(line, 10),
+        column: column ? Math.max(parseInt(column, 10) - 1, 0) : 0
+      });
+      if (pos.source == null || pos.line == null)
+        return frame;
+      return `${prefix}${pos.source}:${pos.line}:${(pos.column ?? 0) + 1}`;
+    });
+  }
+  return text;
+}
+
+// src/server/control.ts
+import { file as file4, realpath as realpath2 } from "flux:fs";
+var LOG_CAP = 2000;
+var QUERY_TIMEOUT_MS = 5000;
+var MAX_WAIT_MS = 30000;
+var logs = [];
+var logSeq = 0;
+var logWaiters = [];
+var nextQueryId = 1;
+var pendingQueries = new Map;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function appendLog(client, level, text) {
+  logs.push({ seq: ++logSeq, at: Date.now(), client, level, text: remapPositions(text, state.currentMaps) });
+  if (logs.length > LOG_CAP)
+    logs.splice(0, logs.length - LOG_CAP);
+  let waiters = logWaiters;
+  logWaiters = [];
+  for (let wake of waiters)
+    wake();
+}
+function resolveQuery(msg) {
+  if (typeof msg.id !== "number")
+    return;
+  let resolve = pendingQueries.get(msg.id);
+  if (resolve) {
+    pendingQueries.delete(msg.id);
+    resolve(msg);
+  }
+}
+function clientList(withAddress = false) {
+  return [...state.clients.entries()].map(([ws, info]) => ({
+    id: info.id,
+    platform: info.platform,
+    version: info.version,
+    profile: info.profile,
+    capabilities: info.capabilities,
+    queries: info.queries,
+    stats: info.stats,
+    timeScale: info.timeScale,
+    clientDir: info.clientDir,
+    pid: info.pid,
+    execPath: info.execPath,
+    host: info.host,
+    os: info.os,
+    kernel: info.kernel,
+    videoDriver: info.videoDriver,
+    gpu: info.gpu,
+    ...withAddress ? { address: ws.remoteAddr ?? null } : {}
+  }));
+}
+function findClient(param) {
+  let entries = [...state.clients.entries()];
+  if (param === undefined) {
+    if (entries.length === 1)
+      return { ws: entries[0][0] };
+    if (entries.length === 0)
+      return { error: Response.json({ error: "No connected clients" }, { status: 503 }) };
+    return { error: Response.json({ error: "Multiple clients connected; pass a client id (list_clients has the ids)" }, { status: 400 }) };
+  }
+  let id = parseInt(param, 10);
+  let entry = entries.find(([, info]) => info.id === id);
+  if (!entry) {
+    let ids = entries.map(([, info]) => info.id);
+    return {
+      error: Response.json({
+        error: `Client ${param} is gone (connected ids: ${ids.length ? ids.join(", ") : "none"}). ` + "Ids reset when the dev server restarts; call list_clients for current ones."
+      }, { status: 404 })
+    };
+  }
+  return { ws: entry[0] };
+}
+function parseRect(query) {
+  let params = ["x", "y", "width", "height"].map((k) => query.get(k));
+  if (params.every((v) => v === undefined))
+    return;
+  let [x, y, width, height] = params.map((v) => parseInt(v ?? "", 10));
+  if (![x, y, width, height].every(Number.isFinite))
+    return Response.json({ error: "Crop rect requires all of x, y, width, height" }, { status: 400 });
+  return { x, y, width, height };
+}
+function parseFormat(query) {
+  let param = query.get("format");
+  if (param === undefined || param === "png")
+    return;
+  if (param === "raw")
+    return "raw";
+  return Response.json({ error: 'Format must be "png" or "raw"' }, { status: 400 });
+}
+function parseScale(query) {
+  let param = query.get("scale");
+  if (param === undefined)
+    return;
+  let scale = parseInt(param, 10);
+  if (!Number.isFinite(scale) || scale < 1 || scale > 8)
+    return Response.json({ error: "Scale must be an integer between 1 and 8" }, { status: 400 });
+  return scale === 1 ? undefined : scale;
+}
+async function queryClient(ws, kind, extra, timeoutMs = QUERY_TIMEOUT_MS) {
+  let id = nextQueryId++;
+  let reply = new Promise((resolve) => {
+    pendingQueries.set(id, resolve);
+  });
+  ws.send(JSON.stringify({ type: "query", kind, id, ...extra }));
+  let msg = await Promise.race([reply, sleep(timeoutMs)]);
+  pendingQueries.delete(id);
+  if (!msg)
+    return {
+      error: Response.json({ error: "Query timed out: the client is connected but did not answer (JS thread busy or app wedged?)" }, { status: 504 })
+    };
+  if (msg.error)
+    return { error: Response.json({ error: remapPositions(String(msg.error), state.currentMaps) }, { status: 502 }) };
+  return { data: msg.data };
+}
+async function handleQuery(query, kind, extra, timeoutMs = QUERY_TIMEOUT_MS) {
+  let target = findClient(query.get("client"));
+  if ("error" in target)
+    return target.error;
+  let result = await queryClient(target.ws, kind, extra, timeoutMs);
+  return "error" in result ? result.error : Response.json(result.data);
+}
+function collapseRepeats(entries) {
+  let out = [];
+  for (let e of entries) {
+    let last = out[out.length - 1];
+    if (last && last.client === e.client && last.level === e.level && last.text === e.text) {
+      last.repeats = (last.repeats ?? 1) + 1;
+      last.seq = e.seq;
+      last.at = e.at;
+    } else {
+      out.push({ ...e });
+    }
+  }
+  return out;
+}
+async function handleLogs(query) {
+  let since = parseInt(query.get("since") ?? "0", 10) || 0;
+  let wait = Math.min(parseInt(query.get("wait") ?? "0", 10) || 0, MAX_WAIT_MS);
+  let levels = query.get("level")?.split(",").map((l) => l.trim()).filter(Boolean);
+  let contains = query.get("contains")?.toLowerCase();
+  let client;
+  let clientParam = query.get("client");
+  if (clientParam !== undefined) {
+    client = parseInt(clientParam, 10);
+    if (!Number.isFinite(client))
+      return Response.json({ error: "Client must be a numeric id" }, { status: 400 });
+  }
+  let select = () => logs.filter((e) => e.seq > since && (client === undefined || e.client === client) && (!levels || levels.length === 0 || levels.includes(e.level)) && (!contains || e.text.toLowerCase().includes(contains)));
+  let entries = select();
+  let deadline = Date.now() + wait;
+  while (entries.length === 0 && Date.now() < deadline) {
+    await new Promise((resolve) => {
+      let timer2 = setTimeout(resolve, deadline - Date.now());
+      logWaiters.push(() => {
+        clearTimeout(timer2);
+        resolve();
+      });
+    });
+    entries = select();
+  }
+  let body = { entries: collapseRepeats(entries), latest: logSeq, generation: state.generation };
+  return Response.json(body);
+}
+function isUnder(path, root) {
+  return path.length > root.length && path.startsWith(root) && (path[root.length] === "/" || path[root.length] === "\\");
+}
+async function loadEntry(requested) {
+  if (!ENTRY_EXTENSIONS.some((ext) => requested.endsWith(ext))) {
+    return { error: `Not an app entry: ${requested} (expected .tsx, .jsx, .ts, .js or .srt.js)`, status: 400 };
+  }
+  let config = state.config;
+  let path = absolute(requested, config.projectDir ?? config.sourceDir);
+  if (!await file4(path).exists())
+    return { error: `Entry not found: ${path}`, status: 400 };
+  let entry = await realpath2(path);
+  if (config.projectDir && !isUnder(entry, config.projectDir)) {
+    return {
+      error: `Entry is outside the project: ${entry} is not under ${config.projectDir}. A project server only bundles sources inside its project; start srt for that file on its own.`,
+      status: 400
+    };
+  }
+  config.entry = entry;
+  config.entryArgs[0] = entry;
+  if (!config.projectDir) {
+    config.sourceDir = dirname(entry);
+    config.cwd = config.sourceDir;
+  }
+  console.log(`[cli] Loading ${entry}`);
+  let error = await rebuildAndBroadcast();
+  if (error)
+    return { error, status: 502 };
+  return { entry };
+}
+function setUserInputMuted(on) {
+  if (on !== state.userInputMuted) {
+    console.log(on ? "[cli] User input muted on every client" : "[cli] User input unmuted");
+  }
+  state.userInputMuted = on;
+  let text = JSON.stringify({ type: "mute", active: on });
+  for (let ws of state.clients.keys())
+    ws.send(text);
+}
+function setWatchActive(on) {
+  if (on === state.watchPaused) {
+    console.log(on ? "[cli] Reload on save resumed" : "[cli] Reload on save paused");
+  }
+  state.watchPaused = !on;
+}
+function setStats(on, ws) {
+  let text = JSON.stringify({ type: "stats", stats: on });
+  let targets = ws ? [ws] : [...state.clients.keys()];
+  if (!ws)
+    state.stats = on;
+  for (let target of targets) {
+    let info = state.clients.get(target);
+    if (info)
+      info.stats = on;
+    target.send(text);
+  }
+  return targets.length;
+}
+async function handleControl(req, path, query) {
+  switch (path) {
+    case "/__control__/clients":
+      let body = {
+        generation: state.generation,
+        key: state.config.key,
+        mode: state.config.mode,
+        entry: state.config.entry,
+        projectDir: state.config.projectDir,
+        userInputMuted: state.userInputMuted,
+        watchPaused: state.watchPaused,
+        clients: clientList()
+      };
+      return Response.json(body);
+    case "/__control__/logs":
+      return handleLogs(query);
+    case "/__control__/tree": {
+      let extra = {};
+      let root = parseInt(query.get("root") ?? "", 10);
+      if (Number.isFinite(root))
+        extra.root = root;
+      let depth = parseInt(query.get("depth") ?? "", 10);
+      if (Number.isFinite(depth))
+        extra.depth = depth;
+      let q = query.get("query");
+      if (q)
+        extra.query = q;
+      if (query.get("props") === "true")
+        extra.props = true;
+      return handleQuery(query, "tree", extra);
+    }
+    case "/__control__/stats": {
+      if (req.method === "POST") {
+        let active = query.get("active");
+        if (active !== "true" && active !== "false") {
+          return Response.json({ error: "Stats requires ?active=true or ?active=false" }, { status: 400 });
+        }
+        let on = active === "true";
+        let target = query.get("client");
+        let ws;
+        if (target !== undefined) {
+          let found2 = findClient(target);
+          if ("error" in found2)
+            return found2.error;
+          ws = found2.ws;
+        }
+        let body2 = { ok: true, active: on, clients: setStats(on, ws) };
+        return Response.json(body2);
+      }
+      let extra = {};
+      let windowMs = parseInt(query.get("window") ?? "", 10);
+      if (Number.isFinite(windowMs))
+        extra.windowMs = windowMs;
+      return handleQuery(query, "stats", extra);
+    }
+    case "/__control__/snapshot": {
+      let nodeId = parseInt(query.get("node") ?? "", 10);
+      if (!Number.isFinite(nodeId))
+        return Response.json({ error: "Snapshot requires ?node=<id>" }, { status: 400 });
+      let extra = { nodeId };
+      let rect = parseRect(query);
+      if (rect instanceof Response)
+        return rect;
+      if (rect)
+        extra.rect = rect;
+      let scale = parseScale(query);
+      if (scale instanceof Response)
+        return scale;
+      if (scale)
+        extra.scale = scale;
+      let format = parseFormat(query);
+      if (format instanceof Response)
+        return format;
+      if (format)
+        extra.format = format;
+      return handleQuery(query, "snapshot", extra);
+    }
+    case "/__control__/gpu": {
+      let label = query.get("label");
+      return handleQuery(query, "gpu", label === undefined ? undefined : { label });
+    }
+    case "/__control__/debug": {
+      if (req.method !== "POST")
+        return handleQuery(query, "debug_list");
+      let name = query.get("name");
+      if (!name)
+        return Response.json({ error: "Debug call requires ?name=<command>" }, { status: 400 });
+      let args = null;
+      try {
+        args = await req.json();
+      } catch {}
+      return handleQuery(query, "debug_call", { name, args });
+    }
+    case "/__control__/texture": {
+      let textureId = parseInt(query.get("id") ?? "", 10);
+      if (!Number.isFinite(textureId))
+        return Response.json({ error: "Texture requires ?id=<textureId>" }, { status: 400 });
+      let extra = { textureId };
+      let rect = parseRect(query);
+      if (rect instanceof Response)
+        return rect;
+      if (rect)
+        extra.rect = rect;
+      let scale = parseScale(query);
+      if (scale instanceof Response)
+        return scale;
+      if (scale)
+        extra.scale = scale;
+      let format = parseFormat(query);
+      if (format instanceof Response)
+        return format;
+      if (format)
+        extra.format = format;
+      return handleQuery(query, "texture", extra);
+    }
+    case "/__control__/clock": {
+      if (req.method !== "POST")
+        return Response.json({ error: "Clock requires POST" }, { status: 405 });
+      let extra = {};
+      let scaleParam = query.get("scale");
+      if (scaleParam !== undefined) {
+        let scale = parseFloat(scaleParam);
+        if (!Number.isFinite(scale) || scale < 0)
+          return Response.json({ error: "Clock scale must be a number >= 0" }, { status: 400 });
+        extra.scale = scale;
+      }
+      let stepParam = query.get("step");
+      if (stepParam !== undefined) {
+        let step = parseInt(stepParam, 10);
+        if (!Number.isFinite(step) || step < 1 || step > 1000)
+          return Response.json({ error: "Clock step must be an integer between 1 and 1000" }, { status: 400 });
+        extra.step = step;
+      }
+      if (!("scale" in extra) && !("step" in extra))
+        return Response.json({ error: "Clock requires ?scale=<x> or ?step=<n>" }, { status: 400 });
+      let target = findClient(query.get("client"));
+      if ("error" in target)
+        return target.error;
+      let result = await queryClient(target.ws, "clock", extra);
+      if ("error" in result)
+        return result.error;
+      let info = state.clients.get(target.ws);
+      if (info && typeof result.data?.scale === "number")
+        info.timeScale = result.data.scale;
+      return Response.json(result.data);
+    }
+    case "/__control__/input": {
+      if (req.method !== "POST")
+        return Response.json({ error: "Input requires POST" }, { status: 405 });
+      let body2 = null;
+      try {
+        body2 = await req.json();
+      } catch {}
+      let events = body2?.events;
+      if (!Array.isArray(events) || events.length === 0)
+        return Response.json({ error: "Input requires a body {events: [...]} with at least one event" }, { status: 400 });
+      if (events.length > 200)
+        return Response.json({ error: "Input sequences are capped at 200 events" }, { status: 400 });
+      let totalMs = 0;
+      for (let e of events) {
+        if (typeof e !== "object" || e === null)
+          return Response.json({ error: "Each event must be an object" }, { status: 400 });
+        for (let f of ["delayMs", "holdMs"]) {
+          let v = e[f];
+          if (v !== undefined) {
+            if (typeof v !== "number" || !Number.isInteger(v) || v < 0 || v > 5000)
+              return Response.json({ error: `Event ${f} must be an integer between 0 and 5000` }, { status: 400 });
+            totalMs += v;
+          }
+        }
+      }
+      if (totalMs > 30000)
+        return Response.json({ error: "Input sequence too long: delays and holds total over 30000 ms" }, { status: 400 });
+      return handleQuery(query, "input", { events }, QUERY_TIMEOUT_MS + totalMs);
+    }
+    case "/__control__/buffer": {
+      let bufferId = parseInt(query.get("id") ?? "", 10);
+      if (!Number.isFinite(bufferId))
+        return Response.json({ error: "Buffer requires ?id=<bufferId>" }, { status: 400 });
+      let extra = { bufferId };
+      let byteOffset = parseInt(query.get("offset") ?? "", 10);
+      if (Number.isFinite(byteOffset))
+        extra.byteOffset = byteOffset;
+      let length = parseInt(query.get("length") ?? "", 10);
+      if (Number.isFinite(length))
+        extra.length = length;
+      let as = query.get("as");
+      if (as !== undefined)
+        extra.as = as;
+      return handleQuery(query, "buffer", extra);
+    }
+    case "/__control__/reload": {
+      if (req.method !== "POST")
+        return Response.json({ error: "Reload requires POST" }, { status: 405 });
+      let error = await rebuildAndBroadcast();
+      if (error)
+        return Response.json({ error }, { status: 502 });
+      let body2 = { ok: true, clients: state.clients.size };
+      return Response.json(body2);
+    }
+    case "/__control__/load": {
+      if (req.method !== "POST")
+        return Response.json({ error: "Load requires POST" }, { status: 405 });
+      let requested = (await req.json().catch(() => null))?.entry;
+      if (typeof requested !== "string" || !requested) {
+        return Response.json({ error: "Load requires { entry: <source path> }" }, { status: 400 });
+      }
+      let result = await loadEntry(requested);
+      if ("error" in result)
+        return Response.json({ error: result.error }, { status: result.status });
+      let body2 = { ok: true, entry: result.entry, clients: state.clients.size };
+      return Response.json(body2);
+    }
+    case "/__control__/mute": {
+      if (req.method !== "POST")
+        return Response.json({ error: "Mute requires POST" }, { status: 405 });
+      let active = query.get("active");
+      if (active !== "true" && active !== "false") {
+        return Response.json({ error: "Mute requires ?active=true or ?active=false" }, { status: 400 });
+      }
+      let on = active === "true";
+      setUserInputMuted(on);
+      let body2 = { ok: true, active: on, clients: state.clients.size };
+      return Response.json(body2);
+    }
+    case "/__control__/watch": {
+      if (req.method !== "POST")
+        return Response.json({ error: "Watch requires POST" }, { status: 405 });
+      let active = query.get("active");
+      if (active !== "true" && active !== "false") {
+        return Response.json({ error: "Watch requires ?active=true or ?active=false" }, { status: 400 });
+      }
+      let on = active === "true";
+      setWatchActive(on);
+      let body2 = { ok: true, active: on };
+      return Response.json(body2);
+    }
+    default:
+      return Response.json({ error: "Unknown control endpoint" }, { status: 404 });
+  }
+}
+
+// ../../node_modules/.bun/qrcode-generator@2.0.4/node_modules/qrcode-generator/dist/qrcode.mjs
+var qrcode = function(typeNumber, errorCorrectionLevel) {
+  const PAD0 = 236;
+  const PAD1 = 17;
+  let _typeNumber = typeNumber;
+  const _errorCorrectionLevel = QRErrorCorrectionLevel[errorCorrectionLevel];
+  let _modules = null;
+  let _moduleCount = 0;
+  let _dataCache = null;
+  const _dataList = [];
+  const _this = {};
+  const makeImpl = function(test, maskPattern) {
+    _moduleCount = _typeNumber * 4 + 17;
+    _modules = function(moduleCount) {
+      const modules = new Array(moduleCount);
+      for (let row = 0;row < moduleCount; row += 1) {
+        modules[row] = new Array(moduleCount);
+        for (let col = 0;col < moduleCount; col += 1) {
+          modules[row][col] = null;
+        }
+      }
+      return modules;
+    }(_moduleCount);
+    setupPositionProbePattern(0, 0);
+    setupPositionProbePattern(_moduleCount - 7, 0);
+    setupPositionProbePattern(0, _moduleCount - 7);
+    setupPositionAdjustPattern();
+    setupTimingPattern();
+    setupTypeInfo(test, maskPattern);
+    if (_typeNumber >= 7) {
+      setupTypeNumber(test);
+    }
+    if (_dataCache == null) {
+      _dataCache = createData(_typeNumber, _errorCorrectionLevel, _dataList);
+    }
+    mapData(_dataCache, maskPattern);
+  };
+  const setupPositionProbePattern = function(row, col) {
+    for (let r = -1;r <= 7; r += 1) {
+      if (row + r <= -1 || _moduleCount <= row + r)
+        continue;
+      for (let c = -1;c <= 7; c += 1) {
+        if (col + c <= -1 || _moduleCount <= col + c)
+          continue;
+        if (0 <= r && r <= 6 && (c == 0 || c == 6) || 0 <= c && c <= 6 && (r == 0 || r == 6) || 2 <= r && r <= 4 && 2 <= c && c <= 4) {
+          _modules[row + r][col + c] = true;
+        } else {
+          _modules[row + r][col + c] = false;
+        }
+      }
+    }
+  };
+  const getBestMaskPattern = function() {
+    let minLostPoint = 0;
+    let pattern = 0;
+    for (let i = 0;i < 8; i += 1) {
+      makeImpl(true, i);
+      const lostPoint = QRUtil.getLostPoint(_this);
+      if (i == 0 || minLostPoint > lostPoint) {
+        minLostPoint = lostPoint;
+        pattern = i;
+      }
+    }
+    return pattern;
+  };
+  const setupTimingPattern = function() {
+    for (let r = 8;r < _moduleCount - 8; r += 1) {
+      if (_modules[r][6] != null) {
+        continue;
+      }
+      _modules[r][6] = r % 2 == 0;
+    }
+    for (let c = 8;c < _moduleCount - 8; c += 1) {
+      if (_modules[6][c] != null) {
+        continue;
+      }
+      _modules[6][c] = c % 2 == 0;
+    }
+  };
+  const setupPositionAdjustPattern = function() {
+    const pos = QRUtil.getPatternPosition(_typeNumber);
+    for (let i = 0;i < pos.length; i += 1) {
+      for (let j = 0;j < pos.length; j += 1) {
+        const row = pos[i];
+        const col = pos[j];
+        if (_modules[row][col] != null) {
+          continue;
+        }
+        for (let r = -2;r <= 2; r += 1) {
+          for (let c = -2;c <= 2; c += 1) {
+            if (r == -2 || r == 2 || c == -2 || c == 2 || r == 0 && c == 0) {
+              _modules[row + r][col + c] = true;
+            } else {
+              _modules[row + r][col + c] = false;
+            }
+          }
+        }
+      }
+    }
+  };
+  const setupTypeNumber = function(test) {
+    const bits = QRUtil.getBCHTypeNumber(_typeNumber);
+    for (let i = 0;i < 18; i += 1) {
+      const mod = !test && (bits >> i & 1) == 1;
+      _modules[Math.floor(i / 3)][i % 3 + _moduleCount - 8 - 3] = mod;
+    }
+    for (let i = 0;i < 18; i += 1) {
+      const mod = !test && (bits >> i & 1) == 1;
+      _modules[i % 3 + _moduleCount - 8 - 3][Math.floor(i / 3)] = mod;
+    }
+  };
+  const setupTypeInfo = function(test, maskPattern) {
+    const data = _errorCorrectionLevel << 3 | maskPattern;
+    const bits = QRUtil.getBCHTypeInfo(data);
+    for (let i = 0;i < 15; i += 1) {
+      const mod = !test && (bits >> i & 1) == 1;
+      if (i < 6) {
+        _modules[i][8] = mod;
+      } else if (i < 8) {
+        _modules[i + 1][8] = mod;
+      } else {
+        _modules[_moduleCount - 15 + i][8] = mod;
+      }
+    }
+    for (let i = 0;i < 15; i += 1) {
+      const mod = !test && (bits >> i & 1) == 1;
+      if (i < 8) {
+        _modules[8][_moduleCount - i - 1] = mod;
+      } else if (i < 9) {
+        _modules[8][15 - i - 1 + 1] = mod;
+      } else {
+        _modules[8][15 - i - 1] = mod;
+      }
+    }
+    _modules[_moduleCount - 8][8] = !test;
+  };
+  const mapData = function(data, maskPattern) {
+    let inc = -1;
+    let row = _moduleCount - 1;
+    let bitIndex = 7;
+    let byteIndex = 0;
+    const maskFunc = QRUtil.getMaskFunction(maskPattern);
+    for (let col = _moduleCount - 1;col > 0; col -= 2) {
+      if (col == 6)
+        col -= 1;
+      while (true) {
+        for (let c = 0;c < 2; c += 1) {
+          if (_modules[row][col - c] == null) {
+            let dark = false;
+            if (byteIndex < data.length) {
+              dark = (data[byteIndex] >>> bitIndex & 1) == 1;
+            }
+            const mask = maskFunc(row, col - c);
+            if (mask) {
+              dark = !dark;
+            }
+            _modules[row][col - c] = dark;
+            bitIndex -= 1;
+            if (bitIndex == -1) {
+              byteIndex += 1;
+              bitIndex = 7;
+            }
+          }
+        }
+        row += inc;
+        if (row < 0 || _moduleCount <= row) {
+          row -= inc;
+          inc = -inc;
+          break;
+        }
+      }
+    }
+  };
+  const createBytes = function(buffer, rsBlocks) {
+    let offset = 0;
+    let maxDcCount = 0;
+    let maxEcCount = 0;
+    const dcdata = new Array(rsBlocks.length);
+    const ecdata = new Array(rsBlocks.length);
+    for (let r = 0;r < rsBlocks.length; r += 1) {
+      const dcCount = rsBlocks[r].dataCount;
+      const ecCount = rsBlocks[r].totalCount - dcCount;
+      maxDcCount = Math.max(maxDcCount, dcCount);
+      maxEcCount = Math.max(maxEcCount, ecCount);
+      dcdata[r] = new Array(dcCount);
+      for (let i = 0;i < dcdata[r].length; i += 1) {
+        dcdata[r][i] = 255 & buffer.getBuffer()[i + offset];
+      }
+      offset += dcCount;
+      const rsPoly = QRUtil.getErrorCorrectPolynomial(ecCount);
+      const rawPoly = qrPolynomial(dcdata[r], rsPoly.getLength() - 1);
+      const modPoly = rawPoly.mod(rsPoly);
+      ecdata[r] = new Array(rsPoly.getLength() - 1);
+      for (let i = 0;i < ecdata[r].length; i += 1) {
+        const modIndex = i + modPoly.getLength() - ecdata[r].length;
+        ecdata[r][i] = modIndex >= 0 ? modPoly.getAt(modIndex) : 0;
+      }
+    }
+    let totalCodeCount = 0;
+    for (let i = 0;i < rsBlocks.length; i += 1) {
+      totalCodeCount += rsBlocks[i].totalCount;
+    }
+    const data = new Array(totalCodeCount);
+    let index = 0;
+    for (let i = 0;i < maxDcCount; i += 1) {
+      for (let r = 0;r < rsBlocks.length; r += 1) {
+        if (i < dcdata[r].length) {
+          data[index] = dcdata[r][i];
+          index += 1;
+        }
+      }
+    }
+    for (let i = 0;i < maxEcCount; i += 1) {
+      for (let r = 0;r < rsBlocks.length; r += 1) {
+        if (i < ecdata[r].length) {
+          data[index] = ecdata[r][i];
+          index += 1;
+        }
+      }
+    }
+    return data;
+  };
+  const createData = function(typeNumber2, errorCorrectionLevel2, dataList) {
+    const rsBlocks = QRRSBlock.getRSBlocks(typeNumber2, errorCorrectionLevel2);
+    const buffer = qrBitBuffer();
+    for (let i = 0;i < dataList.length; i += 1) {
+      const data = dataList[i];
+      buffer.put(data.getMode(), 4);
+      buffer.put(data.getLength(), QRUtil.getLengthInBits(data.getMode(), typeNumber2));
+      data.write(buffer);
+    }
+    let totalDataCount = 0;
+    for (let i = 0;i < rsBlocks.length; i += 1) {
+      totalDataCount += rsBlocks[i].dataCount;
+    }
+    if (buffer.getLengthInBits() > totalDataCount * 8) {
+      throw "code length overflow. (" + buffer.getLengthInBits() + ">" + totalDataCount * 8 + ")";
+    }
+    if (buffer.getLengthInBits() + 4 <= totalDataCount * 8) {
+      buffer.put(0, 4);
+    }
+    while (buffer.getLengthInBits() % 8 != 0) {
+      buffer.putBit(false);
+    }
+    while (true) {
+      if (buffer.getLengthInBits() >= totalDataCount * 8) {
+        break;
+      }
+      buffer.put(PAD0, 8);
+      if (buffer.getLengthInBits() >= totalDataCount * 8) {
+        break;
+      }
+      buffer.put(PAD1, 8);
+    }
+    return createBytes(buffer, rsBlocks);
+  };
+  _this.addData = function(data, mode) {
+    mode = mode || "Byte";
+    let newData = null;
+    switch (mode) {
+      case "Numeric":
+        newData = qrNumber(data);
+        break;
+      case "Alphanumeric":
+        newData = qrAlphaNum(data);
+        break;
+      case "Byte":
+        newData = qr8BitByte(data);
+        break;
+      case "Kanji":
+        newData = qrKanji(data);
+        break;
+      default:
+        throw "mode:" + mode;
+    }
+    _dataList.push(newData);
+    _dataCache = null;
+  };
+  _this.isDark = function(row, col) {
+    if (row < 0 || _moduleCount <= row || col < 0 || _moduleCount <= col) {
+      throw row + "," + col;
+    }
+    return _modules[row][col];
+  };
+  _this.getModuleCount = function() {
+    return _moduleCount;
+  };
+  _this.make = function() {
+    if (_typeNumber < 1) {
+      let typeNumber2 = 1;
+      for (;typeNumber2 < 40; typeNumber2++) {
+        const rsBlocks = QRRSBlock.getRSBlocks(typeNumber2, _errorCorrectionLevel);
+        const buffer = qrBitBuffer();
+        for (let i = 0;i < _dataList.length; i++) {
+          const data = _dataList[i];
+          buffer.put(data.getMode(), 4);
+          buffer.put(data.getLength(), QRUtil.getLengthInBits(data.getMode(), typeNumber2));
+          data.write(buffer);
+        }
+        let totalDataCount = 0;
+        for (let i = 0;i < rsBlocks.length; i++) {
+          totalDataCount += rsBlocks[i].dataCount;
+        }
+        if (buffer.getLengthInBits() <= totalDataCount * 8) {
+          break;
+        }
+      }
+      _typeNumber = typeNumber2;
+    }
+    makeImpl(false, getBestMaskPattern());
+  };
+  _this.createTableTag = function(cellSize, margin) {
+    cellSize = cellSize || 2;
+    margin = typeof margin == "undefined" ? cellSize * 4 : margin;
+    let qrHtml = "";
+    qrHtml += '<table style="';
+    qrHtml += " border-width: 0px; border-style: none;";
+    qrHtml += " border-collapse: collapse;";
+    qrHtml += " padding: 0px; margin: " + margin + "px;";
+    qrHtml += '">';
+    qrHtml += "<tbody>";
+    for (let r = 0;r < _this.getModuleCount(); r += 1) {
+      qrHtml += "<tr>";
+      for (let c = 0;c < _this.getModuleCount(); c += 1) {
+        qrHtml += '<td style="';
+        qrHtml += " border-width: 0px; border-style: none;";
+        qrHtml += " border-collapse: collapse;";
+        qrHtml += " padding: 0px; margin: 0px;";
+        qrHtml += " width: " + cellSize + "px;";
+        qrHtml += " height: " + cellSize + "px;";
+        qrHtml += " background-color: ";
+        qrHtml += _this.isDark(r, c) ? "#000000" : "#ffffff";
+        qrHtml += ";";
+        qrHtml += '"/>';
+      }
+      qrHtml += "</tr>";
+    }
+    qrHtml += "</tbody>";
+    qrHtml += "</table>";
+    return qrHtml;
+  };
+  _this.createSvgTag = function(cellSize, margin, alt, title) {
+    let opts = {};
+    if (typeof arguments[0] == "object") {
+      opts = arguments[0];
+      cellSize = opts.cellSize;
+      margin = opts.margin;
+      alt = opts.alt;
+      title = opts.title;
+    }
+    cellSize = cellSize || 2;
+    margin = typeof margin == "undefined" ? cellSize * 4 : margin;
+    alt = typeof alt === "string" ? { text: alt } : alt || {};
+    alt.text = alt.text || null;
+    alt.id = alt.text ? alt.id || "qrcode-description" : null;
+    title = typeof title === "string" ? { text: title } : title || {};
+    title.text = title.text || null;
+    title.id = title.text ? title.id || "qrcode-title" : null;
+    const size = _this.getModuleCount() * cellSize + margin * 2;
+    let c, mc, r, mr, qrSvg = "", rect;
+    rect = "l" + cellSize + ",0 0," + cellSize + " -" + cellSize + ",0 0,-" + cellSize + "z ";
+    qrSvg += '<svg version="1.1" xmlns="http://www.w3.org/2000/svg"';
+    qrSvg += !opts.scalable ? ' width="' + size + 'px" height="' + size + 'px"' : "";
+    qrSvg += ' viewBox="0 0 ' + size + " " + size + '" ';
+    qrSvg += ' preserveAspectRatio="xMinYMin meet"';
+    qrSvg += title.text || alt.text ? ' role="img" aria-labelledby="' + escapeXml([title.id, alt.id].join(" ").trim()) + '"' : "";
+    qrSvg += ">";
+    qrSvg += title.text ? '<title id="' + escapeXml(title.id) + '">' + escapeXml(title.text) + "</title>" : "";
+    qrSvg += alt.text ? '<description id="' + escapeXml(alt.id) + '">' + escapeXml(alt.text) + "</description>" : "";
+    qrSvg += '<rect width="100%" height="100%" fill="white" cx="0" cy="0"/>';
+    qrSvg += '<path d="';
+    for (r = 0;r < _this.getModuleCount(); r += 1) {
+      mr = r * cellSize + margin;
+      for (c = 0;c < _this.getModuleCount(); c += 1) {
+        if (_this.isDark(r, c)) {
+          mc = c * cellSize + margin;
+          qrSvg += "M" + mc + "," + mr + rect;
+        }
+      }
+    }
+    qrSvg += '" stroke="transparent" fill="black"/>';
+    qrSvg += "</svg>";
+    return qrSvg;
+  };
+  _this.createDataURL = function(cellSize, margin) {
+    cellSize = cellSize || 2;
+    margin = typeof margin == "undefined" ? cellSize * 4 : margin;
+    const size = _this.getModuleCount() * cellSize + margin * 2;
+    const min = margin;
+    const max = size - margin;
+    return createDataURL(size, size, function(x, y) {
+      if (min <= x && x < max && min <= y && y < max) {
+        const c = Math.floor((x - min) / cellSize);
+        const r = Math.floor((y - min) / cellSize);
+        return _this.isDark(r, c) ? 0 : 1;
+      } else {
+        return 1;
+      }
+    });
+  };
+  _this.createImgTag = function(cellSize, margin, alt) {
+    cellSize = cellSize || 2;
+    margin = typeof margin == "undefined" ? cellSize * 4 : margin;
+    const size = _this.getModuleCount() * cellSize + margin * 2;
+    let img = "";
+    img += "<img";
+    img += ' src="';
+    img += _this.createDataURL(cellSize, margin);
+    img += '"';
+    img += ' width="';
+    img += size;
+    img += '"';
+    img += ' height="';
+    img += size;
+    img += '"';
+    if (alt) {
+      img += ' alt="';
+      img += escapeXml(alt);
+      img += '"';
+    }
+    img += "/>";
+    return img;
+  };
+  const escapeXml = function(s) {
+    let escaped = "";
+    for (let i = 0;i < s.length; i += 1) {
+      const c = s.charAt(i);
+      switch (c) {
+        case "<":
+          escaped += "&lt;";
+          break;
+        case ">":
+          escaped += "&gt;";
+          break;
+        case "&":
+          escaped += "&amp;";
+          break;
+        case '"':
+          escaped += "&quot;";
+          break;
+        default:
+          escaped += c;
+          break;
+      }
+    }
+    return escaped;
+  };
+  const _createHalfASCII = function(margin) {
+    const cellSize = 1;
+    margin = typeof margin == "undefined" ? cellSize * 2 : margin;
+    const size = _this.getModuleCount() * cellSize + margin * 2;
+    const min = margin;
+    const max = size - margin;
+    let y, x, r1, r2, p;
+    const blocks = {
+      "██": "█",
+      "█ ": "▀",
+      " █": "▄",
+      "  ": " "
+    };
+    const blocksLastLineNoMargin = {
+      "██": "▀",
+      "█ ": "▀",
+      " █": " ",
+      "  ": " "
+    };
+    let ascii = "";
+    for (y = 0;y < size; y += 2) {
+      r1 = Math.floor((y - min) / cellSize);
+      r2 = Math.floor((y + 1 - min) / cellSize);
+      for (x = 0;x < size; x += 1) {
+        p = "█";
+        if (min <= x && x < max && min <= y && y < max && _this.isDark(r1, Math.floor((x - min) / cellSize))) {
+          p = " ";
+        }
+        if (min <= x && x < max && min <= y + 1 && y + 1 < max && _this.isDark(r2, Math.floor((x - min) / cellSize))) {
+          p += " ";
+        } else {
+          p += "█";
+        }
+        ascii += margin < 1 && y + 1 >= max ? blocksLastLineNoMargin[p] : blocks[p];
+      }
+      ascii += `
+`;
+    }
+    if (size % 2 && margin > 0) {
+      return ascii.substring(0, ascii.length - size - 1) + Array(size + 1).join("▀");
+    }
+    return ascii.substring(0, ascii.length - 1);
+  };
+  _this.createASCII = function(cellSize, margin) {
+    cellSize = cellSize || 1;
+    if (cellSize < 2) {
+      return _createHalfASCII(margin);
+    }
+    cellSize -= 1;
+    margin = typeof margin == "undefined" ? cellSize * 2 : margin;
+    const size = _this.getModuleCount() * cellSize + margin * 2;
+    const min = margin;
+    const max = size - margin;
+    let y, x, r, p;
+    const white = Array(cellSize + 1).join("██");
+    const black = Array(cellSize + 1).join("  ");
+    let ascii = "";
+    let line = "";
+    for (y = 0;y < size; y += 1) {
+      r = Math.floor((y - min) / cellSize);
+      line = "";
+      for (x = 0;x < size; x += 1) {
+        p = 1;
+        if (min <= x && x < max && min <= y && y < max && _this.isDark(r, Math.floor((x - min) / cellSize))) {
+          p = 0;
+        }
+        line += p ? white : black;
+      }
+      for (r = 0;r < cellSize; r += 1) {
+        ascii += line + `
+`;
+      }
+    }
+    return ascii.substring(0, ascii.length - 1);
+  };
+  _this.renderTo2dContext = function(context, cellSize) {
+    cellSize = cellSize || 2;
+    const length = _this.getModuleCount();
+    for (let row = 0;row < length; row++) {
+      for (let col = 0;col < length; col++) {
+        context.fillStyle = _this.isDark(row, col) ? "black" : "white";
+        context.fillRect(col * cellSize, row * cellSize, cellSize, cellSize);
+      }
+    }
+  };
+  return _this;
+};
+qrcode.stringToBytes = function(s) {
+  const bytes = [];
+  for (let i = 0;i < s.length; i += 1) {
+    const c = s.charCodeAt(i);
+    bytes.push(c & 255);
+  }
+  return bytes;
+};
+qrcode.createStringToBytes = function(unicodeData, numChars) {
+  const unicodeMap = function() {
+    const bin = base64DecodeInputStream(unicodeData);
+    const read = function() {
+      const b = bin.read();
+      if (b == -1)
+        throw "eof";
+      return b;
+    };
+    let count = 0;
+    const unicodeMap2 = {};
+    while (true) {
+      const b0 = bin.read();
+      if (b0 == -1)
+        break;
+      const b1 = read();
+      const b2 = read();
+      const b3 = read();
+      const k = String.fromCharCode(b0 << 8 | b1);
+      const v = b2 << 8 | b3;
+      unicodeMap2[k] = v;
+      count += 1;
+    }
+    if (count != numChars) {
+      throw count + " != " + numChars;
+    }
+    return unicodeMap2;
+  }();
+  const unknownChar = 63;
+  return function(s) {
+    const bytes = [];
+    for (let i = 0;i < s.length; i += 1) {
+      const c = s.charCodeAt(i);
+      if (c < 128) {
+        bytes.push(c);
+      } else {
+        const b = unicodeMap[s.charAt(i)];
+        if (typeof b == "number") {
+          if ((b & 255) == b) {
+            bytes.push(b);
+          } else {
+            bytes.push(b >>> 8);
+            bytes.push(b & 255);
+          }
+        } else {
+          bytes.push(unknownChar);
+        }
+      }
+    }
+    return bytes;
+  };
+};
+var QRMode = {
+  MODE_NUMBER: 1 << 0,
+  MODE_ALPHA_NUM: 1 << 1,
+  MODE_8BIT_BYTE: 1 << 2,
+  MODE_KANJI: 1 << 3
+};
+var QRErrorCorrectionLevel = {
+  L: 1,
+  M: 0,
+  Q: 3,
+  H: 2
+};
+var QRMaskPattern = {
+  PATTERN000: 0,
+  PATTERN001: 1,
+  PATTERN010: 2,
+  PATTERN011: 3,
+  PATTERN100: 4,
+  PATTERN101: 5,
+  PATTERN110: 6,
+  PATTERN111: 7
+};
+var QRUtil = function() {
+  const PATTERN_POSITION_TABLE = [
+    [],
+    [6, 18],
+    [6, 22],
+    [6, 26],
+    [6, 30],
+    [6, 34],
+    [6, 22, 38],
+    [6, 24, 42],
+    [6, 26, 46],
+    [6, 28, 50],
+    [6, 30, 54],
+    [6, 32, 58],
+    [6, 34, 62],
+    [6, 26, 46, 66],
+    [6, 26, 48, 70],
+    [6, 26, 50, 74],
+    [6, 30, 54, 78],
+    [6, 30, 56, 82],
+    [6, 30, 58, 86],
+    [6, 34, 62, 90],
+    [6, 28, 50, 72, 94],
+    [6, 26, 50, 74, 98],
+    [6, 30, 54, 78, 102],
+    [6, 28, 54, 80, 106],
+    [6, 32, 58, 84, 110],
+    [6, 30, 58, 86, 114],
+    [6, 34, 62, 90, 118],
+    [6, 26, 50, 74, 98, 122],
+    [6, 30, 54, 78, 102, 126],
+    [6, 26, 52, 78, 104, 130],
+    [6, 30, 56, 82, 108, 134],
+    [6, 34, 60, 86, 112, 138],
+    [6, 30, 58, 86, 114, 142],
+    [6, 34, 62, 90, 118, 146],
+    [6, 30, 54, 78, 102, 126, 150],
+    [6, 24, 50, 76, 102, 128, 154],
+    [6, 28, 54, 80, 106, 132, 158],
+    [6, 32, 58, 84, 110, 136, 162],
+    [6, 26, 54, 82, 110, 138, 166],
+    [6, 30, 58, 86, 114, 142, 170]
+  ];
+  const G15 = 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0;
+  const G18 = 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0;
+  const G15_MASK = 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1;
+  const _this = {};
+  const getBCHDigit = function(data) {
+    let digit = 0;
+    while (data != 0) {
+      digit += 1;
+      data >>>= 1;
+    }
+    return digit;
+  };
+  _this.getBCHTypeInfo = function(data) {
+    let d = data << 10;
+    while (getBCHDigit(d) - getBCHDigit(G15) >= 0) {
+      d ^= G15 << getBCHDigit(d) - getBCHDigit(G15);
+    }
+    return (data << 10 | d) ^ G15_MASK;
+  };
+  _this.getBCHTypeNumber = function(data) {
+    let d = data << 12;
+    while (getBCHDigit(d) - getBCHDigit(G18) >= 0) {
+      d ^= G18 << getBCHDigit(d) - getBCHDigit(G18);
+    }
+    return data << 12 | d;
+  };
+  _this.getPatternPosition = function(typeNumber) {
+    return PATTERN_POSITION_TABLE[typeNumber - 1];
+  };
+  _this.getMaskFunction = function(maskPattern) {
+    switch (maskPattern) {
+      case QRMaskPattern.PATTERN000:
+        return function(i, j) {
+          return (i + j) % 2 == 0;
+        };
+      case QRMaskPattern.PATTERN001:
+        return function(i, j) {
+          return i % 2 == 0;
+        };
+      case QRMaskPattern.PATTERN010:
+        return function(i, j) {
+          return j % 3 == 0;
+        };
+      case QRMaskPattern.PATTERN011:
+        return function(i, j) {
+          return (i + j) % 3 == 0;
+        };
+      case QRMaskPattern.PATTERN100:
+        return function(i, j) {
+          return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 == 0;
+        };
+      case QRMaskPattern.PATTERN101:
+        return function(i, j) {
+          return i * j % 2 + i * j % 3 == 0;
+        };
+      case QRMaskPattern.PATTERN110:
+        return function(i, j) {
+          return (i * j % 2 + i * j % 3) % 2 == 0;
+        };
+      case QRMaskPattern.PATTERN111:
+        return function(i, j) {
+          return (i * j % 3 + (i + j) % 2) % 2 == 0;
+        };
+      default:
+        throw "bad maskPattern:" + maskPattern;
+    }
+  };
+  _this.getErrorCorrectPolynomial = function(errorCorrectLength) {
+    let a = qrPolynomial([1], 0);
+    for (let i = 0;i < errorCorrectLength; i += 1) {
+      a = a.multiply(qrPolynomial([1, QRMath.gexp(i)], 0));
+    }
+    return a;
+  };
+  _this.getLengthInBits = function(mode, type) {
+    if (1 <= type && type < 10) {
+      switch (mode) {
+        case QRMode.MODE_NUMBER:
+          return 10;
+        case QRMode.MODE_ALPHA_NUM:
+          return 9;
+        case QRMode.MODE_8BIT_BYTE:
+          return 8;
+        case QRMode.MODE_KANJI:
+          return 8;
+        default:
+          throw "mode:" + mode;
+      }
+    } else if (type < 27) {
+      switch (mode) {
+        case QRMode.MODE_NUMBER:
+          return 12;
+        case QRMode.MODE_ALPHA_NUM:
+          return 11;
+        case QRMode.MODE_8BIT_BYTE:
+          return 16;
+        case QRMode.MODE_KANJI:
+          return 10;
+        default:
+          throw "mode:" + mode;
+      }
+    } else if (type < 41) {
+      switch (mode) {
+        case QRMode.MODE_NUMBER:
+          return 14;
+        case QRMode.MODE_ALPHA_NUM:
+          return 13;
+        case QRMode.MODE_8BIT_BYTE:
+          return 16;
+        case QRMode.MODE_KANJI:
+          return 12;
+        default:
+          throw "mode:" + mode;
+      }
+    } else {
+      throw "type:" + type;
+    }
+  };
+  _this.getLostPoint = function(qrcode2) {
+    const moduleCount = qrcode2.getModuleCount();
+    let lostPoint = 0;
+    for (let row = 0;row < moduleCount; row += 1) {
+      for (let col = 0;col < moduleCount; col += 1) {
+        let sameCount = 0;
+        const dark = qrcode2.isDark(row, col);
+        for (let r = -1;r <= 1; r += 1) {
+          if (row + r < 0 || moduleCount <= row + r) {
+            continue;
+          }
+          for (let c = -1;c <= 1; c += 1) {
+            if (col + c < 0 || moduleCount <= col + c) {
+              continue;
+            }
+            if (r == 0 && c == 0) {
+              continue;
+            }
+            if (dark == qrcode2.isDark(row + r, col + c)) {
+              sameCount += 1;
+            }
+          }
+        }
+        if (sameCount > 5) {
+          lostPoint += 3 + sameCount - 5;
+        }
+      }
+    }
+    for (let row = 0;row < moduleCount - 1; row += 1) {
+      for (let col = 0;col < moduleCount - 1; col += 1) {
+        let count = 0;
+        if (qrcode2.isDark(row, col))
+          count += 1;
+        if (qrcode2.isDark(row + 1, col))
+          count += 1;
+        if (qrcode2.isDark(row, col + 1))
+          count += 1;
+        if (qrcode2.isDark(row + 1, col + 1))
+          count += 1;
+        if (count == 0 || count == 4) {
+          lostPoint += 3;
+        }
+      }
+    }
+    for (let row = 0;row < moduleCount; row += 1) {
+      for (let col = 0;col < moduleCount - 6; col += 1) {
+        if (qrcode2.isDark(row, col) && !qrcode2.isDark(row, col + 1) && qrcode2.isDark(row, col + 2) && qrcode2.isDark(row, col + 3) && qrcode2.isDark(row, col + 4) && !qrcode2.isDark(row, col + 5) && qrcode2.isDark(row, col + 6)) {
+          lostPoint += 40;
+        }
+      }
+    }
+    for (let col = 0;col < moduleCount; col += 1) {
+      for (let row = 0;row < moduleCount - 6; row += 1) {
+        if (qrcode2.isDark(row, col) && !qrcode2.isDark(row + 1, col) && qrcode2.isDark(row + 2, col) && qrcode2.isDark(row + 3, col) && qrcode2.isDark(row + 4, col) && !qrcode2.isDark(row + 5, col) && qrcode2.isDark(row + 6, col)) {
+          lostPoint += 40;
+        }
+      }
+    }
+    let darkCount = 0;
+    for (let col = 0;col < moduleCount; col += 1) {
+      for (let row = 0;row < moduleCount; row += 1) {
+        if (qrcode2.isDark(row, col)) {
+          darkCount += 1;
+        }
+      }
+    }
+    const ratio = Math.abs(100 * darkCount / moduleCount / moduleCount - 50) / 5;
+    lostPoint += ratio * 10;
+    return lostPoint;
+  };
+  return _this;
+}();
+var QRMath = function() {
+  const EXP_TABLE = new Array(256);
+  const LOG_TABLE = new Array(256);
+  for (let i = 0;i < 8; i += 1) {
+    EXP_TABLE[i] = 1 << i;
+  }
+  for (let i = 8;i < 256; i += 1) {
+    EXP_TABLE[i] = EXP_TABLE[i - 4] ^ EXP_TABLE[i - 5] ^ EXP_TABLE[i - 6] ^ EXP_TABLE[i - 8];
+  }
+  for (let i = 0;i < 255; i += 1) {
+    LOG_TABLE[EXP_TABLE[i]] = i;
+  }
+  const _this = {};
+  _this.glog = function(n) {
+    if (n < 1) {
+      throw "glog(" + n + ")";
+    }
+    return LOG_TABLE[n];
+  };
+  _this.gexp = function(n) {
+    while (n < 0) {
+      n += 255;
+    }
+    while (n >= 256) {
+      n -= 255;
+    }
+    return EXP_TABLE[n];
+  };
+  return _this;
+}();
+var qrPolynomial = function(num, shift) {
+  if (typeof num.length == "undefined") {
+    throw num.length + "/" + shift;
+  }
+  const _num = function() {
+    let offset = 0;
+    while (offset < num.length && num[offset] == 0) {
+      offset += 1;
+    }
+    const _num2 = new Array(num.length - offset + shift);
+    for (let i = 0;i < num.length - offset; i += 1) {
+      _num2[i] = num[i + offset];
+    }
+    return _num2;
+  }();
+  const _this = {};
+  _this.getAt = function(index) {
+    return _num[index];
+  };
+  _this.getLength = function() {
+    return _num.length;
+  };
+  _this.multiply = function(e) {
+    const num2 = new Array(_this.getLength() + e.getLength() - 1);
+    for (let i = 0;i < _this.getLength(); i += 1) {
+      for (let j = 0;j < e.getLength(); j += 1) {
+        num2[i + j] ^= QRMath.gexp(QRMath.glog(_this.getAt(i)) + QRMath.glog(e.getAt(j)));
+      }
+    }
+    return qrPolynomial(num2, 0);
+  };
+  _this.mod = function(e) {
+    if (_this.getLength() - e.getLength() < 0) {
+      return _this;
+    }
+    const ratio = QRMath.glog(_this.getAt(0)) - QRMath.glog(e.getAt(0));
+    const num2 = new Array(_this.getLength());
+    for (let i = 0;i < _this.getLength(); i += 1) {
+      num2[i] = _this.getAt(i);
+    }
+    for (let i = 0;i < e.getLength(); i += 1) {
+      num2[i] ^= QRMath.gexp(QRMath.glog(e.getAt(i)) + ratio);
+    }
+    return qrPolynomial(num2, 0).mod(e);
+  };
+  return _this;
+};
+var QRRSBlock = function() {
+  const RS_BLOCK_TABLE = [
+    [1, 26, 19],
+    [1, 26, 16],
+    [1, 26, 13],
+    [1, 26, 9],
+    [1, 44, 34],
+    [1, 44, 28],
+    [1, 44, 22],
+    [1, 44, 16],
+    [1, 70, 55],
+    [1, 70, 44],
+    [2, 35, 17],
+    [2, 35, 13],
+    [1, 100, 80],
+    [2, 50, 32],
+    [2, 50, 24],
+    [4, 25, 9],
+    [1, 134, 108],
+    [2, 67, 43],
+    [2, 33, 15, 2, 34, 16],
+    [2, 33, 11, 2, 34, 12],
+    [2, 86, 68],
+    [4, 43, 27],
+    [4, 43, 19],
+    [4, 43, 15],
+    [2, 98, 78],
+    [4, 49, 31],
+    [2, 32, 14, 4, 33, 15],
+    [4, 39, 13, 1, 40, 14],
+    [2, 121, 97],
+    [2, 60, 38, 2, 61, 39],
+    [4, 40, 18, 2, 41, 19],
+    [4, 40, 14, 2, 41, 15],
+    [2, 146, 116],
+    [3, 58, 36, 2, 59, 37],
+    [4, 36, 16, 4, 37, 17],
+    [4, 36, 12, 4, 37, 13],
+    [2, 86, 68, 2, 87, 69],
+    [4, 69, 43, 1, 70, 44],
+    [6, 43, 19, 2, 44, 20],
+    [6, 43, 15, 2, 44, 16],
+    [4, 101, 81],
+    [1, 80, 50, 4, 81, 51],
+    [4, 50, 22, 4, 51, 23],
+    [3, 36, 12, 8, 37, 13],
+    [2, 116, 92, 2, 117, 93],
+    [6, 58, 36, 2, 59, 37],
+    [4, 46, 20, 6, 47, 21],
+    [7, 42, 14, 4, 43, 15],
+    [4, 133, 107],
+    [8, 59, 37, 1, 60, 38],
+    [8, 44, 20, 4, 45, 21],
+    [12, 33, 11, 4, 34, 12],
+    [3, 145, 115, 1, 146, 116],
+    [4, 64, 40, 5, 65, 41],
+    [11, 36, 16, 5, 37, 17],
+    [11, 36, 12, 5, 37, 13],
+    [5, 109, 87, 1, 110, 88],
+    [5, 65, 41, 5, 66, 42],
+    [5, 54, 24, 7, 55, 25],
+    [11, 36, 12, 7, 37, 13],
+    [5, 122, 98, 1, 123, 99],
+    [7, 73, 45, 3, 74, 46],
+    [15, 43, 19, 2, 44, 20],
+    [3, 45, 15, 13, 46, 16],
+    [1, 135, 107, 5, 136, 108],
+    [10, 74, 46, 1, 75, 47],
+    [1, 50, 22, 15, 51, 23],
+    [2, 42, 14, 17, 43, 15],
+    [5, 150, 120, 1, 151, 121],
+    [9, 69, 43, 4, 70, 44],
+    [17, 50, 22, 1, 51, 23],
+    [2, 42, 14, 19, 43, 15],
+    [3, 141, 113, 4, 142, 114],
+    [3, 70, 44, 11, 71, 45],
+    [17, 47, 21, 4, 48, 22],
+    [9, 39, 13, 16, 40, 14],
+    [3, 135, 107, 5, 136, 108],
+    [3, 67, 41, 13, 68, 42],
+    [15, 54, 24, 5, 55, 25],
+    [15, 43, 15, 10, 44, 16],
+    [4, 144, 116, 4, 145, 117],
+    [17, 68, 42],
+    [17, 50, 22, 6, 51, 23],
+    [19, 46, 16, 6, 47, 17],
+    [2, 139, 111, 7, 140, 112],
+    [17, 74, 46],
+    [7, 54, 24, 16, 55, 25],
+    [34, 37, 13],
+    [4, 151, 121, 5, 152, 122],
+    [4, 75, 47, 14, 76, 48],
+    [11, 54, 24, 14, 55, 25],
+    [16, 45, 15, 14, 46, 16],
+    [6, 147, 117, 4, 148, 118],
+    [6, 73, 45, 14, 74, 46],
+    [11, 54, 24, 16, 55, 25],
+    [30, 46, 16, 2, 47, 17],
+    [8, 132, 106, 4, 133, 107],
+    [8, 75, 47, 13, 76, 48],
+    [7, 54, 24, 22, 55, 25],
+    [22, 45, 15, 13, 46, 16],
+    [10, 142, 114, 2, 143, 115],
+    [19, 74, 46, 4, 75, 47],
+    [28, 50, 22, 6, 51, 23],
+    [33, 46, 16, 4, 47, 17],
+    [8, 152, 122, 4, 153, 123],
+    [22, 73, 45, 3, 74, 46],
+    [8, 53, 23, 26, 54, 24],
+    [12, 45, 15, 28, 46, 16],
+    [3, 147, 117, 10, 148, 118],
+    [3, 73, 45, 23, 74, 46],
+    [4, 54, 24, 31, 55, 25],
+    [11, 45, 15, 31, 46, 16],
+    [7, 146, 116, 7, 147, 117],
+    [21, 73, 45, 7, 74, 46],
+    [1, 53, 23, 37, 54, 24],
+    [19, 45, 15, 26, 46, 16],
+    [5, 145, 115, 10, 146, 116],
+    [19, 75, 47, 10, 76, 48],
+    [15, 54, 24, 25, 55, 25],
+    [23, 45, 15, 25, 46, 16],
+    [13, 145, 115, 3, 146, 116],
+    [2, 74, 46, 29, 75, 47],
+    [42, 54, 24, 1, 55, 25],
+    [23, 45, 15, 28, 46, 16],
+    [17, 145, 115],
+    [10, 74, 46, 23, 75, 47],
+    [10, 54, 24, 35, 55, 25],
+    [19, 45, 15, 35, 46, 16],
+    [17, 145, 115, 1, 146, 116],
+    [14, 74, 46, 21, 75, 47],
+    [29, 54, 24, 19, 55, 25],
+    [11, 45, 15, 46, 46, 16],
+    [13, 145, 115, 6, 146, 116],
+    [14, 74, 46, 23, 75, 47],
+    [44, 54, 24, 7, 55, 25],
+    [59, 46, 16, 1, 47, 17],
+    [12, 151, 121, 7, 152, 122],
+    [12, 75, 47, 26, 76, 48],
+    [39, 54, 24, 14, 55, 25],
+    [22, 45, 15, 41, 46, 16],
+    [6, 151, 121, 14, 152, 122],
+    [6, 75, 47, 34, 76, 48],
+    [46, 54, 24, 10, 55, 25],
+    [2, 45, 15, 64, 46, 16],
+    [17, 152, 122, 4, 153, 123],
+    [29, 74, 46, 14, 75, 47],
+    [49, 54, 24, 10, 55, 25],
+    [24, 45, 15, 46, 46, 16],
+    [4, 152, 122, 18, 153, 123],
+    [13, 74, 46, 32, 75, 47],
+    [48, 54, 24, 14, 55, 25],
+    [42, 45, 15, 32, 46, 16],
+    [20, 147, 117, 4, 148, 118],
+    [40, 75, 47, 7, 76, 48],
+    [43, 54, 24, 22, 55, 25],
+    [10, 45, 15, 67, 46, 16],
+    [19, 148, 118, 6, 149, 119],
+    [18, 75, 47, 31, 76, 48],
+    [34, 54, 24, 34, 55, 25],
+    [20, 45, 15, 61, 46, 16]
+  ];
+  const qrRSBlock = function(totalCount, dataCount) {
+    const _this2 = {};
+    _this2.totalCount = totalCount;
+    _this2.dataCount = dataCount;
+    return _this2;
+  };
+  const _this = {};
+  const getRsBlockTable = function(typeNumber, errorCorrectionLevel) {
+    switch (errorCorrectionLevel) {
+      case QRErrorCorrectionLevel.L:
+        return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];
+      case QRErrorCorrectionLevel.M:
+        return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];
+      case QRErrorCorrectionLevel.Q:
+        return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];
+      case QRErrorCorrectionLevel.H:
+        return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];
+      default:
+        return;
+    }
+  };
+  _this.getRSBlocks = function(typeNumber, errorCorrectionLevel) {
+    const rsBlock = getRsBlockTable(typeNumber, errorCorrectionLevel);
+    if (typeof rsBlock == "undefined") {
+      throw "bad rs block @ typeNumber:" + typeNumber + "/errorCorrectionLevel:" + errorCorrectionLevel;
+    }
+    const length = rsBlock.length / 3;
+    const list = [];
+    for (let i = 0;i < length; i += 1) {
+      const count = rsBlock[i * 3 + 0];
+      const totalCount = rsBlock[i * 3 + 1];
+      const dataCount = rsBlock[i * 3 + 2];
+      for (let j = 0;j < count; j += 1) {
+        list.push(qrRSBlock(totalCount, dataCount));
+      }
+    }
+    return list;
+  };
+  return _this;
+}();
+var qrBitBuffer = function() {
+  const _buffer = [];
+  let _length = 0;
+  const _this = {};
+  _this.getBuffer = function() {
+    return _buffer;
+  };
+  _this.getAt = function(index) {
+    const bufIndex = Math.floor(index / 8);
+    return (_buffer[bufIndex] >>> 7 - index % 8 & 1) == 1;
+  };
+  _this.put = function(num, length) {
+    for (let i = 0;i < length; i += 1) {
+      _this.putBit((num >>> length - i - 1 & 1) == 1);
+    }
+  };
+  _this.getLengthInBits = function() {
+    return _length;
+  };
+  _this.putBit = function(bit) {
+    const bufIndex = Math.floor(_length / 8);
+    if (_buffer.length <= bufIndex) {
+      _buffer.push(0);
+    }
+    if (bit) {
+      _buffer[bufIndex] |= 128 >>> _length % 8;
+    }
+    _length += 1;
+  };
+  return _this;
+};
+var qrNumber = function(data) {
+  const _mode = QRMode.MODE_NUMBER;
+  const _data = data;
+  const _this = {};
+  _this.getMode = function() {
+    return _mode;
+  };
+  _this.getLength = function(buffer) {
+    return _data.length;
+  };
+  _this.write = function(buffer) {
+    const data2 = _data;
+    let i = 0;
+    while (i + 2 < data2.length) {
+      buffer.put(strToNum(data2.substring(i, i + 3)), 10);
+      i += 3;
+    }
+    if (i < data2.length) {
+      if (data2.length - i == 1) {
+        buffer.put(strToNum(data2.substring(i, i + 1)), 4);
+      } else if (data2.length - i == 2) {
+        buffer.put(strToNum(data2.substring(i, i + 2)), 7);
+      }
+    }
+  };
+  const strToNum = function(s) {
+    let num = 0;
+    for (let i = 0;i < s.length; i += 1) {
+      num = num * 10 + chatToNum(s.charAt(i));
+    }
+    return num;
+  };
+  const chatToNum = function(c) {
+    if ("0" <= c && c <= "9") {
+      return c.charCodeAt(0) - 48;
+    }
+    throw "illegal char :" + c;
+  };
+  return _this;
+};
+var qrAlphaNum = function(data) {
+  const _mode = QRMode.MODE_ALPHA_NUM;
+  const _data = data;
+  const _this = {};
+  _this.getMode = function() {
+    return _mode;
+  };
+  _this.getLength = function(buffer) {
+    return _data.length;
+  };
+  _this.write = function(buffer) {
+    const s = _data;
+    let i = 0;
+    while (i + 1 < s.length) {
+      buffer.put(getCode(s.charAt(i)) * 45 + getCode(s.charAt(i + 1)), 11);
+      i += 2;
+    }
+    if (i < s.length) {
+      buffer.put(getCode(s.charAt(i)), 6);
+    }
+  };
+  const getCode = function(c) {
+    if ("0" <= c && c <= "9") {
+      return c.charCodeAt(0) - 48;
+    } else if ("A" <= c && c <= "Z") {
+      return c.charCodeAt(0) - 65 + 10;
+    } else {
+      switch (c) {
+        case " ":
+          return 36;
+        case "$":
+          return 37;
+        case "%":
+          return 38;
+        case "*":
+          return 39;
+        case "+":
+          return 40;
+        case "-":
+          return 41;
+        case ".":
+          return 42;
+        case "/":
+          return 43;
+        case ":":
+          return 44;
+        default:
+          throw "illegal char :" + c;
+      }
+    }
+  };
+  return _this;
+};
+var qr8BitByte = function(data) {
+  const _mode = QRMode.MODE_8BIT_BYTE;
+  const _data = data;
+  const _bytes = qrcode.stringToBytes(data);
+  const _this = {};
+  _this.getMode = function() {
+    return _mode;
+  };
+  _this.getLength = function(buffer) {
+    return _bytes.length;
+  };
+  _this.write = function(buffer) {
+    for (let i = 0;i < _bytes.length; i += 1) {
+      buffer.put(_bytes[i], 8);
+    }
+  };
+  return _this;
+};
+var qrKanji = function(data) {
+  const _mode = QRMode.MODE_KANJI;
+  const _data = data;
+  const stringToBytes = qrcode.stringToBytes;
+  (function(c, code) {
+    const test = stringToBytes(c);
+    if (test.length != 2 || (test[0] << 8 | test[1]) != code) {
+      throw "sjis not supported.";
+    }
+  })("友", 38726);
+  const _bytes = stringToBytes(data);
+  const _this = {};
+  _this.getMode = function() {
+    return _mode;
+  };
+  _this.getLength = function(buffer) {
+    return ~~(_bytes.length / 2);
+  };
+  _this.write = function(buffer) {
+    const data2 = _bytes;
+    let i = 0;
+    while (i + 1 < data2.length) {
+      let c = (255 & data2[i]) << 8 | 255 & data2[i + 1];
+      if (33088 <= c && c <= 40956) {
+        c -= 33088;
+      } else if (57408 <= c && c <= 60351) {
+        c -= 49472;
+      } else {
+        throw "illegal char at " + (i + 1) + "/" + c;
+      }
+      c = (c >>> 8 & 255) * 192 + (c & 255);
+      buffer.put(c, 13);
+      i += 2;
+    }
+    if (i < data2.length) {
+      throw "illegal char at " + (i + 1);
+    }
+  };
+  return _this;
+};
+var byteArrayOutputStream = function() {
+  const _bytes = [];
+  const _this = {};
+  _this.writeByte = function(b) {
+    _bytes.push(b & 255);
+  };
+  _this.writeShort = function(i) {
+    _this.writeByte(i);
+    _this.writeByte(i >>> 8);
+  };
+  _this.writeBytes = function(b, off, len) {
+    off = off || 0;
+    len = len || b.length;
+    for (let i = 0;i < len; i += 1) {
+      _this.writeByte(b[i + off]);
+    }
+  };
+  _this.writeString = function(s) {
+    for (let i = 0;i < s.length; i += 1) {
+      _this.writeByte(s.charCodeAt(i));
+    }
+  };
+  _this.toByteArray = function() {
+    return _bytes;
+  };
+  _this.toString = function() {
+    let s = "";
+    s += "[";
+    for (let i = 0;i < _bytes.length; i += 1) {
+      if (i > 0) {
+        s += ",";
+      }
+      s += _bytes[i];
+    }
+    s += "]";
+    return s;
+  };
+  return _this;
+};
+var base64EncodeOutputStream = function() {
+  let _buffer = 0;
+  let _buflen = 0;
+  let _length = 0;
+  let _base64 = "";
+  const _this = {};
+  const writeEncoded = function(b) {
+    _base64 += String.fromCharCode(encode2(b & 63));
+  };
+  const encode2 = function(n) {
+    if (n < 0) {
+      throw "n:" + n;
+    } else if (n < 26) {
+      return 65 + n;
+    } else if (n < 52) {
+      return 97 + (n - 26);
+    } else if (n < 62) {
+      return 48 + (n - 52);
+    } else if (n == 62) {
+      return 43;
+    } else if (n == 63) {
+      return 47;
+    } else {
+      throw "n:" + n;
+    }
+  };
+  _this.writeByte = function(n) {
+    _buffer = _buffer << 8 | n & 255;
+    _buflen += 8;
+    _length += 1;
+    while (_buflen >= 6) {
+      writeEncoded(_buffer >>> _buflen - 6);
+      _buflen -= 6;
+    }
+  };
+  _this.flush = function() {
+    if (_buflen > 0) {
+      writeEncoded(_buffer << 6 - _buflen);
+      _buffer = 0;
+      _buflen = 0;
+    }
+    if (_length % 3 != 0) {
+      const padlen = 3 - _length % 3;
+      for (let i = 0;i < padlen; i += 1) {
+        _base64 += "=";
+      }
+    }
+  };
+  _this.toString = function() {
+    return _base64;
+  };
+  return _this;
+};
+var base64DecodeInputStream = function(str) {
+  const _str = str;
+  let _pos = 0;
+  let _buffer = 0;
+  let _buflen = 0;
+  const _this = {};
+  _this.read = function() {
+    while (_buflen < 8) {
+      if (_pos >= _str.length) {
+        if (_buflen == 0) {
+          return -1;
+        }
+        throw "unexpected end of file./" + _buflen;
+      }
+      const c = _str.charAt(_pos);
+      _pos += 1;
+      if (c == "=") {
+        _buflen = 0;
+        return -1;
+      } else if (c.match(/^\s$/)) {
+        continue;
+      }
+      _buffer = _buffer << 6 | decode2(c.charCodeAt(0));
+      _buflen += 6;
+    }
+    const n = _buffer >>> _buflen - 8 & 255;
+    _buflen -= 8;
+    return n;
+  };
+  const decode2 = function(c) {
+    if (65 <= c && c <= 90) {
+      return c - 65;
+    } else if (97 <= c && c <= 122) {
+      return c - 97 + 26;
+    } else if (48 <= c && c <= 57) {
+      return c - 48 + 52;
+    } else if (c == 43) {
+      return 62;
+    } else if (c == 47) {
+      return 63;
+    } else {
+      throw "c:" + c;
+    }
+  };
+  return _this;
+};
+var gifImage = function(width, height) {
+  const _width = width;
+  const _height = height;
+  const _data = new Array(width * height);
+  const _this = {};
+  _this.setPixel = function(x, y, pixel) {
+    _data[y * _width + x] = pixel;
+  };
+  _this.write = function(out) {
+    out.writeString("GIF87a");
+    out.writeShort(_width);
+    out.writeShort(_height);
+    out.writeByte(128);
+    out.writeByte(0);
+    out.writeByte(0);
+    out.writeByte(0);
+    out.writeByte(0);
+    out.writeByte(0);
+    out.writeByte(255);
+    out.writeByte(255);
+    out.writeByte(255);
+    out.writeString(",");
+    out.writeShort(0);
+    out.writeShort(0);
+    out.writeShort(_width);
+    out.writeShort(_height);
+    out.writeByte(0);
+    const lzwMinCodeSize = 2;
+    const raster = getLZWRaster(lzwMinCodeSize);
+    out.writeByte(lzwMinCodeSize);
+    let offset = 0;
+    while (raster.length - offset > 255) {
+      out.writeByte(255);
+      out.writeBytes(raster, offset, 255);
+      offset += 255;
+    }
+    out.writeByte(raster.length - offset);
+    out.writeBytes(raster, offset, raster.length - offset);
+    out.writeByte(0);
+    out.writeString(";");
+  };
+  const bitOutputStream = function(out) {
+    const _out = out;
+    let _bitLength = 0;
+    let _bitBuffer = 0;
+    const _this2 = {};
+    _this2.write = function(data, length) {
+      if (data >>> length != 0) {
+        throw "length over";
+      }
+      while (_bitLength + length >= 8) {
+        _out.writeByte(255 & (data << _bitLength | _bitBuffer));
+        length -= 8 - _bitLength;
+        data >>>= 8 - _bitLength;
+        _bitBuffer = 0;
+        _bitLength = 0;
+      }
+      _bitBuffer = data << _bitLength | _bitBuffer;
+      _bitLength = _bitLength + length;
+    };
+    _this2.flush = function() {
+      if (_bitLength > 0) {
+        _out.writeByte(_bitBuffer);
+      }
+    };
+    return _this2;
+  };
+  const getLZWRaster = function(lzwMinCodeSize) {
+    const clearCode = 1 << lzwMinCodeSize;
+    const endCode = (1 << lzwMinCodeSize) + 1;
+    let bitLength = lzwMinCodeSize + 1;
+    const table = lzwTable();
+    for (let i = 0;i < clearCode; i += 1) {
+      table.add(String.fromCharCode(i));
+    }
+    table.add(String.fromCharCode(clearCode));
+    table.add(String.fromCharCode(endCode));
+    const byteOut = byteArrayOutputStream();
+    const bitOut = bitOutputStream(byteOut);
+    bitOut.write(clearCode, bitLength);
+    let dataIndex = 0;
+    let s = String.fromCharCode(_data[dataIndex]);
+    dataIndex += 1;
+    while (dataIndex < _data.length) {
+      const c = String.fromCharCode(_data[dataIndex]);
+      dataIndex += 1;
+      if (table.contains(s + c)) {
+        s = s + c;
+      } else {
+        bitOut.write(table.indexOf(s), bitLength);
+        if (table.size() < 4095) {
+          if (table.size() == 1 << bitLength) {
+            bitLength += 1;
+          }
+          table.add(s + c);
+        }
+        s = c;
+      }
+    }
+    bitOut.write(table.indexOf(s), bitLength);
+    bitOut.write(endCode, bitLength);
+    bitOut.flush();
+    return byteOut.toByteArray();
+  };
+  const lzwTable = function() {
+    const _map = {};
+    let _size = 0;
+    const _this2 = {};
+    _this2.add = function(key) {
+      if (_this2.contains(key)) {
+        throw "dup key:" + key;
+      }
+      _map[key] = _size;
+      _size += 1;
+    };
+    _this2.size = function() {
+      return _size;
+    };
+    _this2.indexOf = function(key) {
+      return _map[key];
+    };
+    _this2.contains = function(key) {
+      return typeof _map[key] != "undefined";
+    };
+    return _this2;
+  };
+  return _this;
+};
+var createDataURL = function(width, height, getPixel) {
+  const gif = gifImage(width, height);
+  for (let y = 0;y < height; y += 1) {
+    for (let x = 0;x < width; x += 1) {
+      gif.setPixel(x, y, getPixel(x, y));
+    }
+  }
+  const b = byteArrayOutputStream();
+  gif.write(b);
+  const base64 = base64EncodeOutputStream();
+  const bytes = b.toByteArray();
+  for (let i = 0;i < bytes.length; i += 1) {
+    base64.writeByte(bytes[i]);
+  }
+  base64.flush();
+  return "data:image/gif;base64," + base64;
+};
+var qrcode_default = qrcode;
+var stringToBytes = qrcode.stringToBytes;
+
+// src/server/qr.ts
+function printQr(text) {
+  let qr = qrcode_default(0, "L");
+  qr.addData(text);
+  qr.make();
+  let modCount = qr.getModuleCount();
+  const QR_INK = "\x1B[30;107m";
+  const QR_TILE_FG = "\x1B[97m";
+  const QR_RESET = "\x1B[0m";
+  const QUIET_ZONE = 2;
+  let qrWidth = modCount + 2 * QUIET_ZONE;
+  let dark = (y, x) => y >= 0 && y < modCount && x >= 0 && x < modCount && qr.isDark(y, x);
+  for (let y = -QUIET_ZONE;y < modCount + QUIET_ZONE - 1; y += 2) {
+    let row = "  " + QR_INK;
+    for (let x = -QUIET_ZONE;x < modCount + QUIET_ZONE; x++) {
+      let top = dark(y, x);
+      let bot = dark(y + 1, x);
+      row += top && bot ? "█" : top ? "▀" : bot ? "▄" : " ";
+    }
+    console.log(row + QR_RESET);
+  }
+  console.log("  " + QR_TILE_FG + "▀".repeat(qrWidth) + QR_RESET);
+}
+
+// src/server/tunnel.ts
+import { Endpoint } from "flux:p2p";
+import { file as file5 } from "flux:fs";
+import { join as join4 } from "flux:path";
+var TUNNEL_PROTOCOL = "solidrt-dev/0";
+var KEY_FILE = "tunnel.key";
+async function createTunnelEndpoint(port, keyDir) {
+  let keyPath = join4(keyDir, KEY_FILE);
+  let secretKey;
+  let keyFile = file5(keyPath);
+  if (await keyFile.exists()) {
+    let saved = (await keyFile.text()).trim();
+    if (saved.length === 64)
+      secretKey = saved;
+  }
+  let endpoint = await Endpoint.create({ local: true, protocols: [TUNNEL_PROTOCOL], ...port !== null ? { port } : {}, secretKey });
+  if (!secretKey)
+    await keyFile.write(endpoint.secretKey);
+  let ticket = await endpoint.ticket();
+  console.log("");
+  printQr(ticket);
+  console.log("");
+  console.log(`[cli] Tunnel ticket: ${ticket}`);
+  return endpoint;
+}
+
+// src/server/repl.ts
+import { isTTY, on as on2, write as write2 } from "flux:tty";
+import { dir as dir4 } from "flux:fs";
+
+// src/server/line-editor.ts
+import { on, setRawMode, write } from "flux:tty";
+var CLEAR_LINE = "\r\x1B[K";
+function commonPrefix(items) {
+  let prefix = items[0] ?? "";
+  for (let item of items) {
+    let i = 0;
+    while (i < prefix.length && i < item.length && prefix[i] === item[i])
+      i++;
+    prefix = prefix.slice(0, i);
+  }
+  return prefix;
+}
+function startLineEditor(opts) {
+  let buffer = "";
+  let cursor = 0;
+  let history = [];
+  let historyAt = -1;
+  let draft = "";
+  let busy = false;
+  let stopped = false;
+  let redraw = () => {
+    if (stopped || busy)
+      return;
+    let back = buffer.length - cursor;
+    write(CLEAR_LINE + opts.prompt + buffer + (back > 0 ? `\x1B[${back}D` : ""));
+  };
+  let submit = () => {
+    let line = buffer;
+    write(`\r
+`);
+    if (line.trim() && history[history.length - 1] !== line)
+      history.push(line);
+    historyAt = -1;
+    buffer = "";
+    cursor = 0;
+    busy = true;
+    Promise.resolve().then(() => opts.onLine(line)).catch((e) => console.error(`[cli] ${String(e)}`)).then(() => {
+      busy = false;
+      redraw();
+    });
+  };
+  let recall = (at) => {
+    if (historyAt === -1)
+      draft = buffer;
+    historyAt = at;
+    buffer = at === -1 ? draft : history[at];
+    cursor = buffer.length;
+  };
+  let complete = async () => {
+    if (!opts.complete)
+      return;
+    let head = buffer.slice(0, cursor);
+    let asked = buffer;
+    let { matches, replace } = await opts.complete(head);
+    if (buffer !== asked || cursor !== head.length)
+      return;
+    if (matches.length === 0)
+      return;
+    let insert = matches.length === 1 ? matches[0] : commonPrefix(matches);
+    if (insert.length > replace.length) {
+      buffer = head.slice(0, head.length - replace.length) + insert + buffer.slice(cursor);
+      cursor += insert.length - replace.length;
+    } else if (matches.length > 1) {
+      write(`\r
+` + matches.join("  ") + `\r
+`);
+    }
+    redraw();
+  };
+  let onKey = (key) => {
+    if (key.ctrl) {
+      switch (key.name) {
+        case "c":
+          opts.onQuit();
+          return;
+        case "d":
+          if (buffer.length === 0)
+            opts.onQuit();
+          else if (cursor < buffer.length)
+            buffer = buffer.slice(0, cursor) + buffer.slice(cursor + 1);
+          break;
+        case "a":
+          cursor = 0;
+          break;
+        case "e":
+          cursor = buffer.length;
+          break;
+        case "u":
+          buffer = buffer.slice(cursor);
+          cursor = 0;
+          break;
+        default:
+          return;
+      }
+      redraw();
+      return;
+    }
+    if (key.meta)
+      return;
+    switch (key.name) {
+      case "return":
+        submit();
+        return;
+      case "backspace":
+        if (cursor > 0) {
+          buffer = buffer.slice(0, cursor - 1) + buffer.slice(cursor);
+          cursor--;
+        }
+        break;
+      case "delete":
+        if (cursor < buffer.length)
+          buffer = buffer.slice(0, cursor) + buffer.slice(cursor + 1);
+        break;
+      case "left":
+        if (cursor > 0)
+          cursor--;
+        break;
+      case "right":
+        if (cursor < buffer.length)
+          cursor++;
+        break;
+      case "home":
+        cursor = 0;
+        break;
+      case "end":
+        cursor = buffer.length;
+        break;
+      case "up":
+        if (history.length && historyAt !== 0)
+          recall(historyAt === -1 ? history.length - 1 : historyAt - 1);
+        break;
+      case "down":
+        if (historyAt !== -1)
+          recall(historyAt === history.length - 1 ? -1 : historyAt + 1);
+        break;
+      case "tab":
+        complete();
+        return;
+      default:
+        if (key.char === undefined)
+          return;
+        buffer = buffer.slice(0, cursor) + key.char + buffer.slice(cursor);
+        cursor += key.char.length;
+    }
+    redraw();
+  };
+  setRawMode(true);
+  let offKey = on("key", onKey);
+  let offClose = on("close", opts.onQuit);
+  let original = { log: console.log, warn: console.warn, error: console.error, debug: console.debug };
+  let wrap = (print) => (...args) => {
+    if (!busy)
+      write(CLEAR_LINE);
+    print(...args);
+    redraw();
+  };
+  console.log = wrap(original.log);
+  console.warn = wrap(original.warn);
+  console.error = wrap(original.error);
+  console.debug = wrap(original.debug);
+  redraw();
+  return () => {
+    if (stopped)
+      return;
+    stopped = true;
+    Object.assign(console, original);
+    offKey();
+    offClose();
+    write(`\r
+`);
+    setRawMode(false);
+  };
+}
+
+// src/server/repl.ts
+var PROMPT = "srt> ";
+var HELP = "Commands: load <file>, reload [id...], stop [id...], list, stats [on|off], watch on|off, mute on|off, quit, help";
+var COMMANDS = ["load ", "reload", "stop", "list", "stats", "watch ", "mute ", "quit", "exit", "help"];
+function targets(args) {
+  let entries = [...state.clients.entries()];
+  if (!args)
+    return entries.map(([ws]) => ws);
+  let found2 = [];
+  for (let token of args.split(/\s+/)) {
+    let id = parseInt(token, 10);
+    let entry = entries.find(([, info]) => info.id === id);
+    if (!entry) {
+      console.log(`No client with id ${token}`);
+      continue;
+    }
+    found2.push(entry[0]);
+  }
+  return found2;
+}
+function describe(args, count) {
+  return args ? `client(s) ${args.split(/\s+/).join(", ")}` : `all ${count} client(s)`;
+}
+async function cmdReload(args) {
+  let error = await rebuildAndBroadcast();
+  if (error) {
+    console.error(error);
+    showBuildFailure();
+    return;
+  }
+  if (args) {
+    for (let ws of targets(args))
+      if (state.currentReload)
+        ws.send(state.currentReload);
+  }
+  console.log(`[cli] Sent reload to ${describe(args, state.clients.size)}`);
+}
+function cmdStop(args) {
+  let text = JSON.stringify({ type: "stop" });
+  let list = targets(args);
+  for (let ws of list)
+    ws.send(text);
+  if (list.length)
+    console.log(`[cli] Sent stop to ${describe(args, list.length)}`);
+}
+async function cmdLoad(file6) {
+  if (!file6) {
+    console.log("Usage: load <file>");
+    return;
+  }
+  let result = await loadEntry(file6);
+  if ("error" in result) {
+    console.error(result.error);
+    if (result.status === 502)
+      showBuildFailure();
+    return;
+  }
+  console.log(`[cli] Loaded ${result.entry}`);
+}
+function cmdList() {
+  let clients = clientList(true);
+  if (clients.length === 0) {
+    console.log("No connected clients");
+    return;
+  }
+  console.log(`${clients.length} connected client(s):`);
+  for (let c of clients) {
+    console.log(`  ${c.id}: ${c.address ?? "unknown"} [${c.platform}, ${c.version}]`);
+  }
+}
+function toggle(args, current, usage) {
+  if (args === "on")
+    return true;
+  if (args === "off")
+    return false;
+  if (!args)
+    return !current;
+  console.log(usage);
+  return;
+}
+function cmdStats(args) {
+  let on3 = toggle(args, state.stats, "Usage: stats [on|off]");
+  if (on3 === undefined)
+    return;
+  setStats(on3);
+  console.log(`[cli] Stats overlay ${on3 ? "on" : "off"}`);
+}
+function cmdWatch(args) {
+  let on3 = toggle(args, !state.watchPaused, "Usage: watch on|off");
+  if (on3 === undefined)
+    return;
+  setWatchActive(on3);
+}
+function cmdMute(args) {
+  let on3 = toggle(args, state.userInputMuted, "Usage: mute on|off");
+  if (on3 === undefined)
+    return;
+  setUserInputMuted(on3);
+}
+function split(line) {
+  let cmd = line.trim();
+  let i = cmd.indexOf(" ");
+  return i < 0 ? [cmd, ""] : [cmd.slice(0, i), cmd.slice(i + 1).trim()];
+}
+async function dispatch(line, quit) {
+  let [cmd, args] = split(line);
+  switch (cmd) {
+    case "":
+      return;
+    case "reload":
+      return cmdReload(args);
+    case "stop":
+      return cmdStop(args);
+    case "load":
+      return cmdLoad(args);
+    case "list":
+      return cmdList();
+    case "stats":
+      return cmdStats(args);
+    case "watch":
+      return cmdWatch(args);
+    case "mute":
+      return cmdMute(args);
+    case "quit":
+    case "exit":
+      return quit();
+    case "help":
+      console.log(HELP);
+      return;
+    default:
+      console.log(`Unknown command: ${cmd}`);
+  }
+}
+async function complete(line) {
+  if (!line.startsWith("load ")) {
+    return { matches: COMMANDS.filter((c) => c.startsWith(line)), replace: line };
+  }
+  let partial = line.slice(5);
+  let slash = partial.lastIndexOf("/");
+  let dirPart = slash < 0 ? "" : partial.slice(0, slash + 1);
+  let prefix = partial.slice(dirPart.length);
+  let base = state.config.projectDir ?? state.config.sourceDir;
+  let matches = [];
+  try {
+    for (let entry of await dir4(absolute(dirPart || ".", base)).entries()) {
+      if (!entry.name.startsWith(prefix))
+        continue;
+      if (entry.type === "directory")
+        matches.push(entry.name + "/");
+      else if (ENTRY_EXTENSIONS.some((ext) => entry.name.endsWith(ext)))
+        matches.push(entry.name);
+    }
+  } catch {}
+  return { matches, replace: prefix };
+}
+function startRepl(quit) {
+  if (!isTTY) {
+    console.log("[cli] No terminal on stdin, running without the repl");
+    return () => {};
+  }
+  try {
+    return startLineEditor({ prompt: PROMPT, onLine: (line) => dispatch(line, quit), onQuit: quit, complete });
+  } catch (e) {
+    console.log(`[cli] ${String(e)}; using plain line input`);
+    return startLineInput(quit);
+  }
+}
+function startLineInput(quit) {
+  let attached = true;
+  let prompt = () => {
+    if (attached)
+      write2(PROMPT);
+  };
+  let chain = Promise.resolve();
+  let offLine = on2("line", (line) => {
+    chain = chain.then(() => dispatch(line, quit)).then(prompt, (e) => {
+      console.error(`[cli] ${String(e)}`);
+      prompt();
+    });
+  });
+  let offClose = on2("close", quit);
+  prompt();
+  return () => {
+    attached = false;
+    offLine();
+    offClose();
+  };
+}
+
+// src/server/registry.ts
+import { dir as dir5, file as file6, realpath as realpath3 } from "flux:fs";
+import { join as join5 } from "flux:path";
+import { alive, homedir, pid } from "flux:process";
+var RECORD_FILE = "live.json";
+var PORT_FILE = "port";
+function devDir(...parts) {
+  let home = homedir();
+  if (!home)
+    fail("No home directory: the dev server keeps its state under ~/.solidrt");
+  return join5(home, ".solidrt", ...parts);
+}
+async function serverDirFor(key) {
+  let digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(key));
+  let hex = Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+  return devDir("servers", hex.slice(0, 16));
+}
+async function records() {
+  let root = devDir("servers");
+  let entries = await dir5(root).entries().catch(() => []);
+  let found2 = [];
+  for (let entry of entries) {
+    if (entry.type !== "directory")
+      continue;
+    let path = join5(root, entry.name, RECORD_FILE);
+    let record = await file6(path).json().catch(() => null);
+    if (typeof record?.pid === "number" && typeof record?.port === "number" && typeof record?.key === "string") {
+      found2.push({ path, record });
+    }
+  }
+  return found2;
+}
+async function pruneDeadRecords() {
+  for (let { path, record } of await records()) {
+    if (!alive(record.pid))
+      await file6(path).remove().catch(() => {});
+  }
+}
+async function serves(record) {
+  let control = new AbortController;
+  let timer2 = setTimeout(() => control.abort(), 1000);
+  try {
+    let resp = await fetch(`http://127.0.0.1:${record.port}/__control__/clients`, { signal: control.signal });
+    return resp.headers.get("x-solidrt-project") === record.key;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer2);
+  }
+}
+async function runningFor(key) {
+  for (let { path, record } of await records()) {
+    if (!alive(record.pid))
+      continue;
+    if (record.key === key || await realpath3(record.key).catch(() => null) === key) {
+      if (await serves(record))
+        return record;
+      await file6(path).remove().catch(() => {});
+    }
+  }
+  return;
+}
+async function rememberedPort(serverDir) {
+  let text = await file6(join5(serverDir, PORT_FILE)).text().catch(() => "");
+  let port = Number(text.trim());
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : null;
+}
+async function writeRecord(config, port, address) {
+  await dir5(config.serverDir).create();
+  let record = {
+    pid,
+    port,
+    address,
+    key: config.key,
+    mode: config.mode,
+    entry: config.entry,
+    projectDir: config.projectDir,
+    started: new Date().toISOString()
+  };
+  await file6(join5(config.serverDir, RECORD_FILE)).write(JSON.stringify(record));
+  await file6(join5(config.serverDir, PORT_FILE)).write(String(port));
+}
+async function removeRecord(serverDir) {
+  await file6(join5(serverDir, RECORD_FILE)).remove().catch(() => {});
+}
+
+// src/server/main.ts
+var args = parseArgs();
+var mode = await resolveMode(args);
+await pruneDeadRecords();
+var running = await runningFor(mode.key);
+if (running) {
+  fail(`A dev server already serves ${mode.key} on port ${running.port} (pid ${running.pid}). Stop it first, or attach a client with srt client.`);
+}
+var srt = srtCommand();
+var runner = args.client !== null ? await requireBinary("solidrt-go") : null;
+var serverDir = await serverDirFor(mode.key);
+var lanAddress = args.lan ? lanAddressOf(interfaces()) : undefined;
+function lanAddressOf(ifaces) {
+  let v4 = (list) => list.flatMap((i) => i.addrs).find((a) => a.family === "v4")?.ip;
+  let reachable = ifaces.filter((i) => i.up && !i.loopback);
+  return v4(reachable.filter((i) => i.default)) ?? v4(reachable);
+}
+var clientArgs = [];
+if (args.client !== null) {
+  clientArgs.push("--data-root", args.dataRoot ? absolute(args.dataRoot, await realpath4(".")) : devDir("clients"));
+  clientArgs.push("--client", String(args.client));
+  if (args.size)
+    clientArgs.push("--size", args.size);
+}
+var config = {
+  mode: mode.mode,
+  key: mode.key,
+  serverDir,
+  entry: mode.entry,
+  sourceDir: sourceDirOf(mode),
+  projectDir: mode.projectDir,
+  cwd: mode.projectDir ?? sourceDirOf(mode),
+  entryArgs: [mode.entry, mode.mode === "project" ? "--project" : "--file"],
+  srt,
+  port: args.port,
+  lan: args.lan,
+  address: lanAddress ?? "127.0.0.1",
+  proxyHttp: args.proxyHttp,
+  args: args.appArgs,
+  minify: args.minify,
+  cache: args.proxyHttp,
+  cacheDir: mode.projectDir ? join6(mode.projectDir, ".srt-data") : join6(serverDir, "data"),
+  capture: args.capture,
+  stats: args.stats,
+  tunnel: args.tunnel,
+  client: runner ? { cmd: runner, args: clientArgs } : null
+};
+state.config = config;
+state.stats = config.stats;
+if (config.cache) {
+  await initCache({ dir: config.cacheDir });
+  console.log("[cli] HTTP cache enabled");
+}
+if (config.capture) {
+  await file7(config.capture).write("");
+  state.captureStartMs = Date.now();
+}
+function splitQuery(url) {
+  let i = url.indexOf("?");
+  let path = i < 0 ? url : url.slice(0, i);
+  let query = new Map;
+  if (i >= 0) {
+    for (let pair of url.slice(i + 1).split("&")) {
+      if (!pair)
+        continue;
+      let j = pair.indexOf("=");
+      let k = j < 0 ? pair : pair.slice(0, j);
+      let v = j < 0 ? "" : pair.slice(j + 1);
+      query.set(decodeURIComponent(k), decodeURIComponent(v.replace(/\+/g, " ")));
+    }
+  }
+  return { path: decodeURIComponent(path), query };
+}
+async function handleFiles(req, path, root) {
+  let filePath = resolveWithin(root, "." + path);
+  if (!filePath) {
+    return new Response("Forbidden", { status: 403 });
+  }
+  console.log("[cli] get " + path);
+  let stat;
+  try {
+    stat = await file7(filePath).stat();
+  } catch {
+    console.log(`[cli] file not found ${path}`);
+    return new Response("Not found", { status: 404 });
+  }
+  if (stat.type === "directory") {
+    return new Response("Not found", { status: 404 });
+  }
+  let baseHeaders = { "Accept-Ranges": "bytes" };
+  let range = req.headers.get("range");
+  let match = range ? /^bytes=(\d*)-(\d*)$/.exec(range.trim()) : null;
+  if (match) {
+    let size = stat.size;
+    let start;
+    let end;
+    if (match[1] === "") {
+      let n = parseInt(match[2], 10);
+      start = isNaN(n) ? 0 : Math.max(0, size - n);
+      end = size - 1;
+    } else {
+      start = parseInt(match[1], 10);
+      end = match[2] === "" ? size - 1 : Math.min(parseInt(match[2], 10), size - 1);
+    }
+    if (start > end || start >= size) {
+      return new Response("Range not satisfiable", {
+        status: 416,
+        headers: { ...baseHeaders, "Content-Range": `bytes */${size}` }
+      });
+    }
+    return new Response(await file7(filePath).read(start, end - start + 1), {
+      status: 206,
+      headers: {
+        ...baseHeaders,
+        "Content-Range": `bytes ${start}-${end}/${size}`,
+        "Content-Length": String(end - start + 1)
+      }
+    });
+  }
+  return new Response(await file7(filePath).bytes(), { headers: baseHeaders });
+}
+async function handleRequest(req, server) {
+  if (server.upgrade(req))
+    return;
+  let { path, query } = splitQuery(req.url);
+  if (path === "/__proxy__") {
+    return handleProxy(req);
+  }
+  if (path.startsWith("/__control__/")) {
+    let resp = await handleControl(req, path, query);
+    resp.headers.set("x-solidrt-project", config.key);
+    resp.headers.set("x-solidrt-generation", String(state.generation));
+    return resp;
+  }
+  if (path === "/assets" || path.startsWith("/assets/")) {
+    if (!config.projectDir)
+      return new Response("Not found", { status: 404 });
+    return handleFiles(req, path, config.projectDir);
+  }
+  if (path.startsWith("/isolates/")) {
+    return handleFiles(req, path, config.cacheDir);
+  }
+  return handleFiles(req, path, config.sourceDir);
+}
+function text(value) {
+  return typeof value === "string" ? value : null;
+}
+function onOpen(ws) {
+  let id = state.nextClientId++;
+  state.clients.set(ws, {
+    platform: "unknown",
+    version: "unknown",
+    profile: "unknown",
+    id,
+    capabilities: [],
+    queries: [],
+    stats: state.stats,
+    timeScale: 1,
+    clientDir: null,
+    pid: null,
+    execPath: null,
+    host: null,
+    os: null,
+    kernel: null,
+    videoDriver: null,
+    gpu: null
+  });
+  console.log(`[cli] Client connected ${ws.remoteAddr ?? "unknown"}`);
+  ws.send(JSON.stringify({ type: "welcome", address: state.serverUrl, stats: state.stats, capture: !!config.capture, mute: state.userInputMuted }));
+  if (state.currentReload) {
+    ws.send(state.currentReload);
+  }
+}
+function onClose(ws) {
+  let info = state.clients.get(ws);
+  state.clients.delete(ws);
+  console.log(`[cli] Client disconnected: ${info?.platform ?? "unknown"}`);
+  if (config.client && localClientExited && state.clients.size === 0)
+    shutdown();
+}
+function onMessage(ws, msg) {
+  try {
+    let data = JSON.parse(typeof msg === "string" ? msg : new TextDecoder().decode(msg));
+    if (data.type === "info") {
+      let existing = state.clients.get(ws);
+      state.clients.set(ws, {
+        platform: data.platform ?? "unknown",
+        version: data.version ?? "unknown",
+        profile: data.profile ?? "unknown",
+        id: existing?.id ?? state.nextClientId++,
+        capabilities: Array.isArray(data.capabilities) ? data.capabilities.map(String) : [],
+        queries: Array.isArray(data.queries) ? data.queries.map(String) : [],
+        stats: existing?.stats ?? state.stats,
+        timeScale: existing?.timeScale ?? 1,
+        clientDir: text(data.clientDir),
+        pid: typeof data.pid === "number" ? data.pid : null,
+        execPath: text(data.execPath),
+        host: text(data.host),
+        os: text(data.os),
+        kernel: text(data.kernel),
+        videoDriver: text(data.videoDriver),
+        gpu: data.gpu && typeof data.gpu === "object" ? { vendor: text(data.gpu.vendor) ?? "", renderer: text(data.gpu.renderer) ?? "", version: text(data.gpu.version) ?? "" } : null
+      });
+      console.log(`[cli] Client info ${ws.remoteAddr ?? "unknown"} ${data.platform} (${data.version})`);
+    } else if (data.type === "log") {
+      let device = state.clients.get(ws)?.id ?? -1;
+      appendLog(device, String(data.level ?? "log"), String(data.text ?? ""));
+    } else if (data.type === "result") {
+      resolveQuery(data);
+    } else if (data.type === "capture" && config.capture) {
+      let device = state.clients.get(ws)?.id ?? -1;
+      let at = Date.now() - state.captureStartMs;
+      let after = at - state.captureLastAt;
+      state.captureLastAt = at;
+      let line = JSON.stringify({ after, type: data.kind, key: data.key, device }) + `
+`;
+      state.captureChain = state.captureChain.then(() => file7(config.capture).append(line));
+    }
+  } catch {}
+}
+var DEFAULT_PORT = 34884;
+var PORT_TRIES = 100;
+var host = config.lan ? "0.0.0.0" : "127.0.0.1";
+var remembered = config.port ?? await rememberedPort(config.serverDir);
+var tunnel = config.tunnel ? await createTunnelEndpoint(remembered, config.serverDir) : null;
+function bind(port) {
+  return serve({
+    host,
+    port,
+    p2p: tunnel ? { endpoint: tunnel, protocol: TUNNEL_PROTOCOL } : undefined,
+    fetch: handleRequest,
+    websocket: { open: onOpen, close: onClose, message: onMessage }
+  });
+}
+async function bindFirstFree() {
+  if (config.port !== undefined)
+    return bind(config.port);
+  let candidates = remembered !== null ? [remembered] : [];
+  for (let p = DEFAULT_PORT;p < DEFAULT_PORT + PORT_TRIES; p++)
+    candidates.push(p);
+  let last = null;
+  for (let port of candidates) {
+    if (await probe("127.0.0.1", port, { timeoutMs: 200 }) !== "closed")
+      continue;
+    try {
+      return bind(port);
+    } catch (e) {
+      last = e;
+    }
+  }
+  throw last ?? new Error(`No free port between ${DEFAULT_PORT} and ${DEFAULT_PORT + PORT_TRIES - 1}`);
+}
+var server = await bindFirstFree();
+var address = config.lan ? config.address : "127.0.0.1";
+state.serverUrl = `${address}:${server.port}`;
+await writeRecord(config, server.port, address);
+if (config.lan && !config.tunnel) {
+  console.log("");
+  printQr(state.serverUrl);
+  console.log("");
+}
+console.log(`[cli] Dev server on http://${state.serverUrl} serving ${config.mode} ${config.key}`);
+var keepalive = setInterval(() => {
+  for (let ws of state.clients.keys()) {
+    ws.ping();
+  }
+}, 5000);
+var shuttingDown = false;
+var stopRepl = () => {};
+var localClient = null;
+var localClientExited = false;
+var signalOffs = ["SIGINT", "SIGTERM"].map((signal) => onSignal(signal, () => {
+  shutdown();
+}));
+async function shutdown() {
+  if (shuttingDown)
+    return;
+  shuttingDown = true;
+  clearInterval(keepalive);
+  for (let off of signalOffs)
+    off();
+  stopRepl();
+  stopWatcher();
+  await removeRecord(config.serverDir);
+  if (localClient)
+    localClient.kill();
+  server.close();
+  if (tunnel)
+    await tunnel.close();
+}
+async function pump(stream, print) {
+  let decoder = new TextDecoder;
+  let rest = "";
+  for await (let chunk of stream) {
+    rest += decoder.decode(chunk, { stream: true });
+    let lines = rest.split(`
+`);
+    rest = lines.pop() ?? "";
+    for (let line of lines)
+      print(line);
+  }
+  if (rest)
+    print(rest);
+}
+console.log("[cli] Bundling (development)");
+var buildError = await rebuildAndBroadcast();
+if (buildError) {
+  console.error(buildError);
+  showBuildFailure();
+}
+console.log("[cli] Reload on save is on (pause it with the MCP pause_watch tool)");
+stopRepl = startRepl(shutdown);
+if (!config.entry.endsWith(".srt.js")) {
+  let check = command2(config.srt[0], [...config.srt.slice(1), "check", config.entry], { cwd: config.cwd }).spawn();
+  pump(check.stdout, (line) => console.log(line));
+  pump(check.stderr, (line) => console.error(line));
+}
+if (config.client) {
+  let child = command2(config.client.cmd, [...config.client.args, "--dev-server", `127.0.0.1:${server.port}`]).spawn();
+  localClient = child;
+  pump(child.stdout, (line) => console.log(line));
+  pump(child.stderr, (line) => console.error(line));
+  child.status().then(() => {
+    localClient = null;
+    localClientExited = true;
+    if (shuttingDown)
+      return;
+    if (state.clients.size === 0) {
+      shutdown();
+    } else {
+      console.log(`[cli] Local client exited, ${state.clients.size} remote client(s) still connected`);
+    }
+  });
+}