@mirrowel/opencode-openshare 0.0.0-stage → 0.1.0

package/dist/tui.js

@@ -0,0 +1,4762 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { basename, dirname, join, relative } from "path";
+import { fileURLToPath } from "url";
+function moduleDir() {
+  return dirname(fileURLToPath(import.meta.pathname ?? import.meta.url));
+}
+function packageRoot(start) {
+  let current = start;
+  for (let guard = 0;guard < 16; guard++) {
+    if (existsSync(join(current, "package.json")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return start;
+}
+function configPaths(pluginDir, env = process.env) {
+  const paths = [join(pluginDir, CONFIG_NAME)];
+  const root = packageRoot(pluginDir);
+  if (root !== pluginDir)
+    paths.push(join(root, CONFIG_NAME));
+  let current = pluginDir;
+  for (let i = 0;i < 5; i++) {
+    paths.push(join(current, LOCAL_NAME));
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  paths.push(join(globalConfigDir(env), CONFIG_NAME));
+  return paths;
+}
+function configHomePath(env = process.env) {
+  return join(globalConfigDir(env), CONFIG_NAME);
+}
+function writeCandidates(pluginDir, env = process.env) {
+  const candidates = [{ path: configHomePath(env), label: "global settings (~/.config/opencode)", always: true }];
+  const labels = [
+    [join(pluginDir, CONFIG_NAME), "plugin folder (adjacent template)"],
+    [join(packageRoot(pluginDir), CONFIG_NAME), "package root"]
+  ];
+  let current = pluginDir;
+  for (let i = 0;i < 5; i++) {
+    labels.push([join(current, LOCAL_NAME), `local override (${relative(process.cwd(), join(current, LOCAL_NAME)) || join(current, LOCAL_NAME)})`]);
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  for (const [path, label] of labels) {
+    if (path === candidates[0].path)
+      continue;
+    if (existsSync(path))
+      candidates.push({ path, label });
+  }
+  return candidates;
+}
+function configSourceMap(pluginDir, env = process.env) {
+  const emptyMeansUnset = new Set(["workerUrl", "createToken", "urlFile", "spoolDir"]);
+  const known = new Set([...Object.keys(DEFAULTS), "shareMode", "servers"]);
+  const sources = {};
+  const envKeys = {
+    workerUrl: env.OPENSHARE_WORKER_URL,
+    createToken: env.OPENSHARE_CREATE_TOKEN,
+    debounceMs: env.OPENSHARE_DEBOUNCE_MS,
+    completedDelayMs: env.OPENSHARE_COMPLETED_DELAY_MS,
+    modelLabel: env.OPENSHARE_MODEL_LABEL,
+    ttlDays: env.OPENSHARE_TTL_DAYS,
+    authLogin: env.OPENSHARE_AUTH_LOGIN,
+    authPassword: env.OPENSHARE_AUTH_PASSWORD,
+    urlFile: env.OPENSHARE_URL_FILE,
+    spoolDir: env.OPENSHARE_SPOOL_DIR,
+    announceStderr: env.OPENSHARE_ANNOUNCE_STDERR,
+    shareMode: env.OPENSHARE_SHARE_MODE
+  };
+  for (const [key, value] of Object.entries(envKeys)) {
+    if (value !== undefined && value !== "")
+      sources[key] = "environment";
+  }
+  for (const path of configPaths(pluginDir, env)) {
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync(path, "utf8"));
+      if (!raw || typeof raw !== "object")
+        continue;
+    } catch {
+      continue;
+    }
+    const label = basename(path) === LOCAL_NAME ? `openshare.local.json (${dirname(path).split(/[\\/]/).pop()})` : `${basename(path)} (${dirname(path).split(/[\\/]/).pop()})`;
+    for (const [key, value] of Object.entries(raw)) {
+      if (key === "servers") {
+        if (sources.servers === undefined && normalizeServers(value))
+          sources.servers = label;
+        continue;
+      }
+      if (sources[key] !== undefined || !known.has(key))
+        continue;
+      if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
+        continue;
+      if (typeof value === "string" && value === "" && emptyMeansUnset.has(key))
+        continue;
+      sources[key] = label;
+    }
+  }
+  return sources;
+}
+function num(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function str(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function normalizeServers(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return;
+  const out = {};
+  for (const [url, value] of Object.entries(raw)) {
+    if (!url.startsWith("http") || !value || typeof value !== "object")
+      continue;
+    const e = value;
+    const entry = {};
+    if (typeof e.token === "string" && e.token)
+      entry.token = e.token;
+    if (typeof e.code === "string" && e.code)
+      entry.code = e.code;
+    if (typeof e.label === "string" && e.label)
+      entry.label = e.label;
+    if (typeof e.adminToken === "string" && e.adminToken)
+      entry.adminToken = e.adminToken;
+    if (e.active === true)
+      entry.active = true;
+    out[url] = entry;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+function mergeServerGroups(base, add) {
+  const merged = { ...base ?? {} };
+  for (const [url, entry] of Object.entries(add))
+    merged[url] = { ...merged[url] ?? {}, ...entry };
+  return merged;
+}
+function resolveServer(cfg) {
+  const servers = {};
+  if (cfg.workerUrl)
+    servers[cfg.workerUrl] = { token: cfg.createToken || "", adminToken: cfg.createToken || "", active: true };
+  if (cfg.servers)
+    for (const [url2, entry] of Object.entries(cfg.servers))
+      servers[url2] = entry;
+  const urls = Object.keys(servers);
+  if (!urls.length)
+    return;
+  const url = urls.find((u) => servers[u].active) ?? urls[0];
+  return { url, token: servers[url].token ?? "", entry: servers[url] };
+}
+function saveServerEntry(url, patch, target) {
+  const path = target ?? configHomePath();
+  if (!path || !url.startsWith("http"))
+    return;
+  try {
+    let previous = {};
+    try {
+      previous = JSON.parse(readFileSync(path, "utf8"));
+      if (!previous || typeof previous !== "object")
+        previous = {};
+    } catch {}
+    const servers = normalizeServers(previous.servers) ?? {};
+    servers[url] = { ...servers[url], ...patch };
+    previous.servers = servers;
+    writeFileSync(path, JSON.stringify(previous, null, 2) + `
+`);
+    return path;
+  } catch {
+    return;
+  }
+}
+function deleteServerEntry(url, target) {
+  const path = target ?? configHomePath();
+  if (!path)
+    return;
+  try {
+    let previous = {};
+    try {
+      previous = JSON.parse(readFileSync(path, "utf8"));
+      if (!previous || typeof previous !== "object")
+        previous = {};
+    } catch {}
+    const servers = normalizeServers(previous.servers) ?? {};
+    delete servers[url];
+    previous.servers = servers;
+    writeFileSync(path, JSON.stringify(previous, null, 2) + `
+`);
+    return path;
+  } catch {
+    return;
+  }
+}
+function loadConfig(pluginDir, options) {
+  const cfg = { ...DEFAULTS };
+  const emptyMeansUnset = new Set(["workerUrl", "createToken", "urlFile", "spoolDir"]);
+  const known = new Set([...Object.keys(DEFAULTS), "shareMode"]);
+  for (const path of [...configPaths(pluginDir)].reverse()) {
+    try {
+      const raw = JSON.parse(readFileSync(path, "utf8"));
+      if (!raw || typeof raw !== "object")
+        continue;
+      for (const [key, value] of Object.entries(raw)) {
+        if (key === "servers") {
+          const servers = normalizeServers(value);
+          if (servers)
+            cfg.servers = mergeServerGroups(cfg.servers, servers);
+          continue;
+        }
+        if (!known.has(key))
+          continue;
+        if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
+          continue;
+        if (typeof value === "string" && value === "" && emptyMeansUnset.has(key))
+          continue;
+        cfg[key] = value;
+      }
+    } catch {}
+  }
+  if (options && typeof options === "object") {
+    const serversOpt = normalizeServers(options.servers);
+    if (serversOpt)
+      cfg.servers = mergeServerGroups(cfg.servers, serversOpt);
+    for (const key of Object.keys(DEFAULTS)) {
+      const value = options[key];
+      if (value === undefined || value === null)
+        continue;
+      if (typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
+        cfg[key] = value;
+      }
+    }
+    const mode = str(options.shareMode);
+    if (mode === "all" || mode === "manual")
+      cfg.shareMode = mode;
+  }
+  const env = process.env;
+  if (env.OPENSHARE_WORKER_URL)
+    cfg.workerUrl = env.OPENSHARE_WORKER_URL;
+  if (env.OPENSHARE_CREATE_TOKEN)
+    cfg.createToken = env.OPENSHARE_CREATE_TOKEN;
+  if (env.OPENSHARE_DEBOUNCE_MS)
+    cfg.debounceMs = num(env.OPENSHARE_DEBOUNCE_MS, cfg.debounceMs);
+  if (env.OPENSHARE_COMPLETED_DELAY_MS !== undefined)
+    cfg.completedDelayMs = num(env.OPENSHARE_COMPLETED_DELAY_MS, cfg.completedDelayMs);
+  if (env.OPENSHARE_MODEL_LABEL !== undefined)
+    cfg.modelLabel = env.OPENSHARE_MODEL_LABEL;
+  if (env.OPENSHARE_TTL_DAYS)
+    cfg.ttlDays = num(env.OPENSHARE_TTL_DAYS, cfg.ttlDays);
+  if (env.OPENSHARE_AUTH_LOGIN !== undefined)
+    cfg.authLogin = env.OPENSHARE_AUTH_LOGIN;
+  if (env.OPENSHARE_AUTH_PASSWORD !== undefined)
+    cfg.authPassword = env.OPENSHARE_AUTH_PASSWORD;
+  if (env.OPENSHARE_URL_FILE !== undefined)
+    cfg.urlFile = env.OPENSHARE_URL_FILE;
+  if (env.OPENSHARE_SPOOL_DIR)
+    cfg.spoolDir = env.OPENSHARE_SPOOL_DIR;
+  if (env.OPENSHARE_ANNOUNCE_STDERR !== undefined)
+    cfg.announceStderr = !/^(0|false|no|off)$/i.test(env.OPENSHARE_ANNOUNCE_STDERR.trim());
+  if (env.OPENSHARE_SHARE_MODE === "all" || env.OPENSHARE_SHARE_MODE === "manual")
+    cfg.shareMode = env.OPENSHARE_SHARE_MODE;
+  if (cfg.urlFile.trim().toLowerCase() === URL_FILE_NONE)
+    cfg.urlFile = URL_FILE_NONE;
+  return cfg;
+}
+function globalConfigDir(env) {
+  if (env["OPENCODE_CONFIG_DIR"])
+    return env["OPENCODE_CONFIG_DIR"];
+  if (env["XDG_CONFIG_HOME"])
+    return join(env["XDG_CONFIG_HOME"], "opencode");
+  const home = process.env.USERPROFILE ?? process.env.HOME ?? "";
+  return join(home, ".config", "opencode");
+}
+var METADATA_KEY = "openshare", URL_FILE_NONE = "none", DEFAULTS, CONFIG_NAME = "openshare.config.json", LOCAL_NAME = "openshare.local.json";
+var init_config = __esm(() => {
+  DEFAULTS = {
+    workerUrl: "",
+    createToken: "",
+    debounceMs: 1e4,
+    completedDelayMs: 5000,
+    modelLabel: "$Provider/$Model",
+    ttlDays: 90,
+    openTasksInNewTab: true,
+    authLogin: "",
+    authPassword: "",
+    spoolDir: "",
+    urlFile: "",
+    announceStderr: true
+  };
+});
+
+// src/sidebar.tsx
+import { effect as _$effect } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { appendFileSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+function dbg(v, depth = 0) {
+  const t = typeof v;
+  if (v === null)
+    return "null";
+  if (t === "string")
+    return `str(${v.length}):${JSON.stringify(v.slice(0, 60))}`;
+  if (t === "number" || t === "boolean" || t === "bigint")
+    return `${t}:${String(v)}`;
+  if (t === "undefined")
+    return "undef";
+  if (t === "function")
+    return `fn:${v.name || "anon"}`;
+  if (Array.isArray(v))
+    return `arr[${v.length}]:[${v.slice(0, 6).map((x) => dbg(x, depth + 1)).join(",")}]`;
+  if (depth >= 3)
+    return "obj:\u2026";
+  try {
+    const keys = Object.keys(v);
+    return `obj{${keys.slice(0, 8).join(",")}}` + (depth < 2 ? `{${keys.slice(0, 8).map((k) => `${k}=${dbg(v[k], depth + 1)}`).join(",")}}` : "");
+  } catch {
+    return "obj:?}";
+  }
+}
+function dbgEl(el, depth = 0) {
+  if (el === null || el === undefined || typeof el === "string" || typeof el === "number" || typeof el === "boolean")
+    return dbg(el);
+  if (Array.isArray(el))
+    return `[${el.map((x) => dbgEl(x, depth)).join(",")}]`;
+  if (typeof el === "function")
+    return "fn-node";
+  if (depth >= 4)
+    return "\u2026";
+  try {
+    const rec = el;
+    const t = dbg(rec.t ?? rec.type, 2);
+    const kids = rec.children;
+    const props = Object.keys(rec).filter((k) => !["t", "type", "children"].includes(k));
+    return `<${t} ${props.join(" ")}>${kids === undefined ? "" : dbgEl(kids, depth + 1)}</${t}>`;
+  } catch (e) {
+    return `el?-${dbg(e)}`;
+  }
+}
+function dbgLog(line) {
+  try {
+    appendFileSync(DBG_FILE, `${new Date().toISOString()} ${line}
+`);
+  } catch {}
+}
+function goneVerdict(sid, server, shareId) {
+  const key = `${sid}|${server}`;
+  const cached = goneCache.get(key);
+  if (cached && Date.now() - cached.at < GONE_TTL_MS)
+    return cached;
+  verifyShare(server, shareId).then((status) => {
+    goneCache.set(key, {
+      status,
+      at: Date.now()
+    });
+  });
+  return cached;
+}
+function createSidebarSlot(api, opts) {
+  dbgLog(`createSidebarSlot called; api.state=${!!api.state} api.theme=${!!api.theme} api.version=${dbg(api.app?.version)}`);
+  return {
+    slots: {
+      sidebar_title: (ctx, props) => {
+        const seq = ++renderSeq;
+        try {
+          dbgLog(`render#${seq} ctx=${dbg(ctx)} props=${dbg(props)}`);
+          const sid = typeof props?.session_id === "string" ? props.session_id : "";
+          const title = String(props?.title ?? "") || "Session";
+          const session = sid ? api.state.session.get(sid) : undefined;
+          const binding = bindingOf(session);
+          const allBindings = bindingsOf(session);
+          const liveCount = allBindings.filter((b) => b.url && b.enabled !== false).length;
+          const status = session?.time?.archived ? undefined : binding?.url ? binding.enabled === false ? "attached" : "live" : undefined;
+          const checked = allBindings.filter((b) => b.url && b.enabled !== false && b.id && b.server);
+          const verdicts = checked.map((b) => goneVerdict(sid, b.server, b.id));
+          const anyGone = verdicts.some((v) => v?.status === "gone");
+          const multi = liveCount > 1 ? `\xB7${liveCount} ` : "";
+          const theme = ctx?.theme?.current ?? api.theme.current;
+          dbgLog(`render#${seq} sid=${dbg(sid)} title=${dbg(title)} session=${session ? "found" : "MISSING"} binding=${binding ? `id=${dbg(binding.id)} enabled=${dbg(binding.enabled)}` : "none"} status=${dbg(status)} theme=${dbg(theme)}`);
+          const copyLink = () => {
+            if (anyGone) {
+              opts?.onShareCommand?.();
+              return;
+            }
+            const url = binding?.url;
+            if (!url)
+              return;
+            let copied = false;
+            try {
+              const clip = navigator.clipboard;
+              if (typeof clip?.writeText === "function") {
+                clip.writeText(url).then(() => {}, () => {});
+                copied = true;
+              }
+            } catch {}
+            try {
+              process.stdout.write(`\x1B]52;c;${Buffer.from(url, "utf8").toString("base64")}\x07`);
+              copied = true;
+            } catch {}
+            try {
+              api.ui.toast({
+                variant: copied ? "success" : "info",
+                title: "OpenShare",
+                message: copied ? `Share link copied: ${url}` : `Share link: ${url}`,
+                duration: 6000
+              });
+            } catch {}
+          };
+          const el = (() => {
+            var _el$ = _$createElement("box"), _el$2 = _$createElement("text");
+            _$insertNode(_el$, _el$2);
+            _$setProp(_el$, "flexDirection", "column");
+            _$setProp(_el$, "paddingRight", 1);
+            _$insert(_el$2, title);
+            _$insert(_el$, status ? (() => {
+              var _el$3 = _$createElement("box"), _el$4 = _$createElement("text");
+              _$insertNode(_el$3, _el$4);
+              _$setProp(_el$3, "onMouseDown", copyLink);
+              _$insert(_el$4, anyGone ? `\u2298 re:share \u2014 gone (removed/expired) \u2014 click to fix` : status === "live" ? `\u25C9 re:share ${multi}\u2014 click to copy link` : "\u25C9 re:share (dormant)");
+              _$effect((_$p) => _$setProp(_el$4, "fg", anyGone ? theme.error : binding?.enabled === false ? theme.warning : theme.success, _$p));
+              return _el$3;
+            })() : null, null);
+            _$effect((_$p) => _$setProp(_el$2, "fg", theme.text, _$p));
+            return _el$;
+          })();
+          dbgLog(`render#${seq} RETURNS ${dbgEl(el)}`);
+          return el;
+        } catch (error) {
+          dbgLog(`render#${seq} THREW ${error?.stack ?? dbg(error)} \u2014 rethrowing`);
+          throw error;
+        }
+      }
+    }
+  };
+}
+var DBG_FILE, renderSeq = 0, GONE_TTL_MS = 60000, goneCache;
+var init_sidebar = __esm(() => {
+  init_share_flow();
+  DBG_FILE = join2(tmpdir(), "openshare-tui-debug.log");
+  goneCache = new Map;
+});
+
+// src/share-flow.ts
+var exports_share_flow = {};
+__export(exports_share_flow, {
+  workerDeleteShare: () => workerDeleteShare,
+  waitForBinding: () => waitForBinding,
+  verifyShare: () => verifyShare,
+  setShareFlag: () => setShareFlag,
+  serverEntries: () => serverEntries,
+  saveServerEntry: () => saveServerEntry,
+  saveConfig: () => saveConfig,
+  runUnshareFlow: () => runUnshareFlow,
+  runShareFlow: () => runShareFlow,
+  rotateAtServer: () => rotateAtServer,
+  resolveRoot: () => resolveRoot,
+  readBindings: () => readBindings,
+  readBinding: () => readBinding,
+  probeWorker: () => probeWorker,
+  probeAuthMode: () => probeAuthMode,
+  pluginConfigPaths: () => pluginConfigPaths,
+  patchSessionBinding: () => patchSessionBinding,
+  normServerUrl: () => normServerUrl,
+  isConfigured: () => isConfigured,
+  hostOf: () => hostOf,
+  enrollAtServer: () => enrollAtServer,
+  disconnectAtServer: () => disconnectAtServer,
+  deleteServerEntry: () => deleteServerEntry,
+  currentConfig: () => currentConfig,
+  confirmShare: () => confirmShare,
+  clearShareFlag: () => clearShareFlag,
+  clearGoneBindingEntries: () => clearGoneBindingEntries,
+  bindingsOf: () => bindingsOf,
+  bindingOf: () => bindingOf,
+  adminTokenFor: () => adminTokenFor,
+  adminClient: () => adminClient,
+  activeServer: () => activeServer,
+  CONSENT_KV_KEY: () => CONSENT_KV_KEY
+});
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+function pluginConfigPaths(baseDir = moduleDir()) {
+  return configPaths(baseDir);
+}
+function currentConfig(baseDir = moduleDir()) {
+  return loadConfig(baseDir);
+}
+function saveConfig(cfg, target, baseDir = moduleDir()) {
+  const path = target ?? configHomePath();
+  if (!path)
+    return;
+  try {
+    const previous = existsSync2(path) ? (() => {
+      try {
+        return JSON.parse(readFileSync2(path, "utf8"));
+      } catch {
+        return {};
+      }
+    })() : {};
+    const next = { ...previous };
+    for (const key of [
+      "workerUrl",
+      "createToken",
+      "servers",
+      "debounceMs",
+      "completedDelayMs",
+      "modelLabel",
+      "ttlDays",
+      "openTasksInNewTab",
+      "authLogin",
+      "authPassword",
+      "spoolDir",
+      "urlFile",
+      "shareMode",
+      "announceStderr"
+    ]) {
+      next[key] = cfg[key];
+    }
+    writeFileSync2(path, JSON.stringify(next, null, 2) + `
+`);
+    return { path };
+  } catch {
+    return;
+  }
+}
+function isConfigured(cfg) {
+  return Boolean(resolveServer(cfg)?.url);
+}
+function activeServer(cfg = currentConfig()) {
+  return resolveServer(cfg);
+}
+function serverEntries(cfg = currentConfig()) {
+  const merged = {};
+  if (cfg.workerUrl)
+    merged[cfg.workerUrl] = { token: cfg.createToken || "", active: true };
+  if (cfg.servers)
+    for (const [url, entry] of Object.entries(cfg.servers))
+      merged[url] = { ...merged[url], ...entry };
+  const urls = Object.keys(merged);
+  const activeUrl = urls.find((u) => merged[u].active) ?? urls[0];
+  return urls.map((url) => ({ url, entry: merged[url], active: url === activeUrl }));
+}
+function bindingsOf(info) {
+  const raw = info?.metadata?.[METADATA_KEY];
+  if (!raw || typeof raw !== "object")
+    return [];
+  const record = raw;
+  const opts = record.opts ?? undefined;
+  const enabled = record.enabled === true ? true : undefined;
+  const out = [];
+  if (record.servers && typeof record.servers === "object") {
+    for (const [server, entry] of Object.entries(record.servers)) {
+      if (!entry || typeof entry !== "object")
+        continue;
+      const e = entry;
+      if (typeof e.id !== "string" || typeof e.secret !== "string" || !e.id)
+        continue;
+      const collided = typeof e.collided === "string" ? e.collided : undefined;
+      out.push({
+        id: e.id,
+        secret: e.secret,
+        rev: typeof e.rev === "number" ? e.rev : 0,
+        url: typeof e.url === "string" ? e.url : "",
+        enabled,
+        opts,
+        server,
+        collided
+      });
+    }
+    return out;
+  }
+  if (typeof record.id === "string" && typeof record.secret === "string" && record.id) {
+    const collided = typeof record.collided === "string" ? record.collided : undefined;
+    out.push({
+      id: record.id,
+      secret: record.secret,
+      rev: typeof record.rev === "number" ? record.rev : 0,
+      url: typeof record.url === "string" ? record.url : "",
+      enabled,
+      opts,
+      server: "",
+      collided
+    });
+  }
+  return out;
+}
+async function readBindings(client, sid) {
+  return bindingsOf(await getSession(client, sid));
+}
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+async function patchSessionBinding(client, sid, mutator) {
+  const info = await getSession(client, sid);
+  if (!info)
+    return false;
+  const metadata = { ...info.metadata ?? {} };
+  const raw = info.metadata?.[METADATA_KEY];
+  const binding = raw && typeof raw === "object" ? { ...raw } : { v: 2, servers: {} };
+  const servers = binding.servers && typeof binding.servers === "object" ? { ...binding.servers } : {};
+  mutator(servers, binding);
+  binding.servers = servers;
+  metadata[METADATA_KEY] = binding;
+  return patchMetadata(client, sid, metadata);
+}
+function bindingOf(info) {
+  const all = bindingsOf(info);
+  if (!all.length)
+    return;
+  const active = activeServer()?.url;
+  return all.find((b) => b.server === active) ?? all[0];
+}
+async function getSession(client, sid) {
+  if (!client?.session?.get)
+    return;
+  try {
+    const res = await client.session.get({ path: { id: sid } });
+    const info = res?.data ?? res;
+    return info && typeof info === "object" ? info : undefined;
+  } catch {
+    return;
+  }
+}
+async function patchMetadata(client, sid, metadata) {
+  if (!client?.session?.update) {
+    dbgLog(`patchMetadata(${sid}): no client.session.update`);
+    return false;
+  }
+  try {
+    const res = await client.session.update({ path: { id: sid }, body: { metadata } });
+    if (res && typeof res === "object" && "error" in res && res.error) {
+      const err = res.error;
+      dbgLog(`patchMetadata(${sid}) ERROR: ${err?.name}: ${err?.data?.message ?? ""} ref=${err?.data?.ref ?? ""}`);
+      return false;
+    }
+    dbgLog(`patchMetadata(${sid}): ok res=${dbg(res)}`);
+    return true;
+  } catch (e) {
+    dbgLog(`patchMetadata(${sid}) THREW: ${e?.stack ?? e}`);
+    return false;
+  }
+}
+async function resolveRoot(client, sid) {
+  let current = sid;
+  for (let hops = 0;hops < 10; hops++) {
+    const info = await getSession(client, current);
+    const parent = info?.parentID;
+    if (typeof parent !== "string" || !parent || parent === current)
+      return current;
+    current = parent;
+  }
+  return current;
+}
+async function readBinding(client, sid) {
+  return bindingOf(await getSession(client, sid));
+}
+async function setShareFlag(client, sid, opts) {
+  const info = await getSession(client, sid);
+  if (!info)
+    return false;
+  const metadata = { ...info.metadata ?? {} };
+  const existing = info.metadata?.[METADATA_KEY];
+  const value = existing && typeof existing === "object" ? { ...existing } : { v: 2, servers: {} };
+  value.enabled = true;
+  if (opts && Object.keys(opts).length)
+    value.opts = opts;
+  metadata[METADATA_KEY] = value;
+  return patchMetadata(client, sid, metadata);
+}
+async function clearShareFlag(client, sid) {
+  const info = await getSession(client, sid);
+  if (!info)
+    return false;
+  const metadata = { ...info.metadata ?? {} };
+  delete metadata[METADATA_KEY];
+  return patchMetadata(client, sid, metadata);
+}
+async function workerDeleteShare(workerUrl, id, secret) {
+  try {
+    const res = await fetch(`${workerUrl.replace(/\/$/, "")}/api/share/${id}`, {
+      method: "DELETE",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ secret }),
+      signal: AbortSignal.timeout(8000)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function probeWorker(workerUrl) {
+  if (!workerUrl)
+    return { ok: false, detail: "workerUrl is empty" };
+  try {
+    const res = await fetch(`${workerUrl.replace(/\/$/, "")}/health`, { signal: AbortSignal.timeout(6000) });
+    if (!res.ok)
+      return { ok: false, detail: `HTTP ${res.status}` };
+    const body = await res.json().catch(() => ({}));
+    return { ok: true, detail: body.service ? `service: ${body.service}` : "reachable" };
+  } catch (error) {
+    return { ok: false, detail: error.message };
+  }
+}
+async function verifyShare(workerUrl, shareId) {
+  const base = normServerUrl(workerUrl);
+  if (!base || !shareId)
+    return "unknown";
+  try {
+    const res = await fetch(`${base}/api/share/${shareId}/data`, { signal: AbortSignal.timeout(4000) });
+    if (res.status === 404) {
+      const body = await res.json().catch(() => ({}));
+      return body.status === "gone" || Object.keys(body).length === 0 ? "gone" : "unknown";
+    }
+    return "live";
+  } catch {
+    return "unknown";
+  }
+}
+async function clearGoneBindingEntries(host, root, servers) {
+  if (!servers.length)
+    return false;
+  return patchSessionBinding(host.client, root, (map) => {
+    for (const server of servers)
+      delete map[server];
+  });
+}
+function normServerUrl(url) {
+  return url.trim().replace(/\/+$/, "");
+}
+async function probeAuthMode(workerUrl) {
+  const base = normServerUrl(workerUrl);
+  if (!base)
+    return { ok: false, detail: "no URL" };
+  try {
+    const res = await fetch(`${base}/health`, { signal: AbortSignal.timeout(6000) });
+    if (!res.ok)
+      return { ok: false, detail: `HTTP ${res.status}` };
+    const body = await res.json().catch(() => ({}));
+    const mode = body.auth?.mode === "public" ? "public" : body.auth?.mode === "private" ? "private" : undefined;
+    return { ok: true, mode, detail: mode ? `auth: ${mode}` : "reachable (pre-auth server?)" };
+  } catch (error) {
+    return { ok: false, detail: error.message };
+  }
+}
+async function enrollAtServer(workerUrl, code) {
+  const base = normServerUrl(workerUrl);
+  try {
+    const res = await fetch(`${base}/api/enroll`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ code: code || undefined }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    const body = await res.json().catch(() => ({}));
+    if (res.ok && body.ok && typeof body.token === "string") {
+      return { ok: true, token: body.token, userId: body.userId, label: body.label };
+    }
+    return { ok: false, error: body.error ?? `HTTP ${res.status}` };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+async function rotateAtServer(workerUrl, token) {
+  const base = normServerUrl(workerUrl);
+  try {
+    const res = await fetch(`${base}/api/token/rotate`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(1e4)
+    });
+    const body = await res.json().catch(() => ({}));
+    if (res.ok && body.ok && typeof body.token === "string")
+      return { ok: true, token: body.token };
+    return { ok: false, error: body.error ?? `HTTP ${res.status}` };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+async function disconnectAtServer(workerUrl, token) {
+  const base = normServerUrl(workerUrl);
+  try {
+    const res = await fetch(`${base}/api/token`, {
+      method: "DELETE",
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(1e4)
+    });
+    const body = await res.json().catch(() => ({}));
+    return { ok: res.ok && body.ok !== false, error: body.error };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+function adminClient(workerUrl, token) {
+  const base = normServerUrl(workerUrl);
+  const call = async (method, path, body) => {
+    try {
+      const res = await fetch(`${base}${path}`, {
+        method,
+        headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: AbortSignal.timeout(12000)
+      });
+      const parsed = await res.json().catch(() => ({}));
+      if (!res.ok)
+        return { ok: false, status: res.status, error: parsed?.error ?? `HTTP ${res.status}` };
+      return { ok: parsed?.ok !== false, status: res.status, data: parsed, error: parsed?.error };
+    } catch (error) {
+      return { ok: false, status: 0, error: error.message };
+    }
+  };
+  return {
+    users: () => call("GET", "/api/admin/users"),
+    createUser: (label) => call("POST", "/api/admin/users", { label }),
+    freeze: (userId) => call("POST", `/api/admin/users/${userId}/freeze`),
+    unfreeze: (userId) => call("POST", `/api/admin/users/${userId}/unfreeze`),
+    deleteUser: (userId, mode) => call("DELETE", `/api/admin/users/${userId}`, { mode }),
+    tokens: () => call("GET", "/api/admin/tokens"),
+    mintToken: (userId, label, limits) => call("POST", "/api/admin/tokens", { userId, label, limits }),
+    revokeToken: (tokenId) => call("DELETE", `/api/admin/tokens/${tokenId}`),
+    codes: () => call("GET", "/api/admin/codes"),
+    createCode: (label, activations) => call("POST", "/api/admin/codes", { label, activations }),
+    disableCode: (codeId) => call("DELETE", `/api/admin/codes/${codeId}`),
+    shares: () => call("GET", "/api/admin/shares"),
+    deleteShare: (shareId) => call("DELETE", `/api/share/${shareId}`),
+    reassign: (shareId, userId) => call("POST", `/api/admin/shares/${shareId}/reassign`, { userId }),
+    purge: () => call("POST", "/api/admin/purge"),
+    health: () => call("GET", "/health")
+  };
+}
+function adminTokenFor(url, cfg = currentConfig()) {
+  const base = normServerUrl(url);
+  const entry = serverEntries(cfg).find((s) => s.url === base);
+  return entry?.entry.adminToken ?? (cfg.workerUrl && normServerUrl(cfg.workerUrl) === base ? cfg.createToken : "") ?? "";
+}
+async function waitForBinding(client, sid, timeoutMs = 25000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const binding = await readBinding(client, sid);
+    if (binding?.url)
+      return binding;
+    await sleep(600);
+  }
+  return;
+}
+async function runShareFlow(host, sessionID) {
+  if (!sessionID)
+    return { ok: false, message: "No active session to share." };
+  const cfg = currentConfig();
+  if (!isConfigured(cfg)) {
+    return { ok: false, message: "No share server connected \u2014 run /openshare to connect one.", unconfigured: true };
+  }
+  const root = await resolveRoot(host.client, sessionID);
+  const existing = await readBinding(host.client, root);
+  if (existing?.url && existing.enabled !== false) {
+    await host.clipboard.write(existing.url);
+    return { ok: true, message: `Share URL copied to clipboard: ${existing.url}`, url: existing.url };
+  }
+  if (!host.kv.get(CONSENT_KV_KEY, false)) {
+    return { ok: false, message: "consent required" };
+  }
+  return confirmShare(host, root);
+}
+async function confirmShare(host, rootSessionID) {
+  dbgLog(`confirmShare: setShareFlag(${rootSessionID})`);
+  const set = await setShareFlag(host.client, rootSessionID);
+  dbgLog(`confirmShare: setShareFlag -> ${set}`);
+  if (!set)
+    return { ok: false, message: "Could not write the share flag into session metadata." };
+  const binding = await waitForBinding(host.client, rootSessionID);
+  dbgLog(`confirmShare: waitForBinding -> ${binding?.url ? binding.url : "timeout"}`);
+  if (!binding?.url) {
+    return {
+      ok: false,
+      message: "Share did not come up (timeout waiting for the URL). Is the worker reachable? Check the server plugin log for [openshare] lines."
+    };
+  }
+  await host.clipboard.write(binding.url);
+  return { ok: true, message: `Share URL copied to clipboard: ${binding.url}`, url: binding.url };
+}
+async function runUnshareFlow(host, sessionID) {
+  if (!sessionID)
+    return { ok: false, message: "No active session." };
+  const root = await resolveRoot(host.client, sessionID);
+  const info = await getSession(host.client, root);
+  const all = bindingsOf(info);
+  if (!all.length)
+    return { ok: false, message: "This session is not shared." };
+  await clearShareFlag(host.client, root);
+  let deleted = 0;
+  for (const b of all) {
+    const bindingOrigin = b.url ? b.url.slice(0, b.url.indexOf("/s/")) : "";
+    const deleteBase = bindingOrigin || b.server;
+    if (deleteBase && b.id && b.secret) {
+      if (await workerDeleteShare(deleteBase, b.id, b.secret))
+        deleted++;
+    }
+  }
+  return {
+    ok: true,
+    message: deleted === all.length ? `Sharing stopped; ${deleted} share page${deleted === 1 ? "" : "s"} deleted.` : `Sharing stopped (${deleted}/${all.length} pages deleted; the rest will follow via the sweeper).`
+  };
+}
+var CONSENT_KV_KEY = "openshare_consent", sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var init_share_flow = __esm(() => {
+  init_config();
+  init_sidebar();
+});
+
+// src/tui.tsx
+import { effect as _$effect3 } from "@opentui/solid";
+import { createTextNode as _$createTextNode2 } from "@opentui/solid";
+import { insertNode as _$insertNode3 } from "@opentui/solid";
+import { insert as _$insert3 } from "@opentui/solid";
+import { setProp as _$setProp3 } from "@opentui/solid";
+import { createElement as _$createElement3 } from "@opentui/solid";
+
+// src/commands.ts
+init_share_flow();
+
+// src/settings.ts
+init_config();
+init_share_flow();
+
+// src/ui-prefs.ts
+var UI_WIDTH_KV = "openshare.ui-width";
+var UI_HEIGHT_PERCENT_KV = "openshare.ui-height-percent";
+var HEIGHT_PERCENT_MIN = 25;
+var HEIGHT_PERCENT_MAX = 100;
+var DIALOG_WIDTH_COLUMNS = { medium: 60, large: 88, xlarge: 116 };
+function clampHeightPercent(value) {
+  return Math.max(HEIGHT_PERCENT_MIN, Math.min(HEIGHT_PERCENT_MAX, Math.round(value)));
+}
+function nextDialogWidth(width) {
+  return width === "medium" ? "large" : width === "large" ? "xlarge" : "medium";
+}
+function kvWidthOf(kv) {
+  const value = kv.get(UI_WIDTH_KV, "large");
+  return value === "medium" || value === "large" || value === "xlarge" ? value : "large";
+}
+function kvHeightPercentOf(kv) {
+  const value = kv.get(UI_HEIGHT_PERCENT_KV, 50);
+  return typeof value === "number" && Number.isFinite(value) ? clampHeightPercent(value) : 50;
+}
+
+// src/settings.ts
+function withSource(display, source) {
+  return source ? `${display} [${source}]` : display;
+}
+function summarizeSources(sources) {
+  const labels = [...new Set(Object.values(sources))];
+  return labels.length ? labels.slice(0, 2).join(" + ") + (labels.length > 2 ? "\u2026" : "") : "all defaults";
+}
+function sourcesMessage(sources) {
+  const lines = Object.entries(sources).map(([key, source]) => `${key}: ${source}`);
+  return lines.length ? lines.join(`
+`) : "All values are defaults \u2014 no config file or env var sets anything yet.";
+}
+function showSelect(ui, props) {
+  return ui.showMenu({ title: props.title, options: props.options, current: props.current, hint: props.placeholder });
+}
+function showPrompt(ui, props) {
+  return ui.showPrompt(props);
+}
+function showConfirm(ui, props) {
+  return ui.showConfirm(props);
+}
+function showInfo(ui, props) {
+  return ui.showAlert(props);
+}
+function mask(value) {
+  if (!value)
+    return "(not set)";
+  if (value.length <= 6)
+    return "****";
+  return `${value.slice(0, 3)}${"*".repeat(Math.min(10, value.length - 5))}${value.slice(-2)}`;
+}
+var LABELS = {
+  workerUrl: {
+    label: "Worker URL",
+    help: "Your openshare-worker deployment (https://\u2026). Empty disables the plugin.",
+    kind: "text",
+    section: "Connection",
+    info: `The base URL of your share server \u2014 the Cloudflare Worker or the portable Bun server. Every share page is created, synced and deleted through it.
+
+Legacy single-server key: the servers group below is the canonical multi-server form; this pair still works and synthesizes into it.`,
+    def: "(empty \u2014 plugin disabled)"
+  },
+  createToken: {
+    label: "Create token",
+    help: "The worker's CREATE_TOKEN. Required to create shares.",
+    kind: "password",
+    section: "Connection",
+    info: `The server's root CREATE_TOKEN \u2014 full admin rights (create, edit, delete ANY share, manage users). Kept for legacy setups and hoster machines.
+
+Regular users should NOT hold the root token: connect via an access code instead (Connect to a server) and the plugin enrolls its own limited user token. The value is masked here but stored as-is in the config file.`,
+    def: "(empty)"
+  },
+  shareMode: {
+    label: "Share mode",
+    help: '"all" shares every session; "manual" needs /share. Default: TUI presence.',
+    kind: "text",
+    options: ["auto", "all", "manual"],
+    section: "Sharing",
+    info: `all: every NEW session shares automatically (CI posture). Sessions that existed before the plugin started are never auto-shared \u2014 share those explicitly. manual: sessions stay private until you run /share.
+
+Default (empty): TUI presence decides \u2014 installing the TUI part means manual, server-only means all.`,
+    def: "auto (TUI presence)"
+  },
+  debounceMs: {
+    label: "Sync interval (ms)",
+    help: "Max time between syncs while streaming; anything batched rides the next one. Turn-end batches flush immediately. Default 10000; clamped into the server policy window.",
+    kind: "number",
+    section: "Sharing",
+    info: `A rate limit anchored at the previous flush, not a restart-on-every-event debounce: an update arriving AFTER the interval flushes instantly; anything earlier rides the next tick. Turn-end batches (idle) always flush immediately regardless of this value.
+
+The server clamps it into its allowed window (DEBOUNCE_MIN_MS..DEBOUNCE_MAX_MS, default 1000..60000).`,
+    def: "10000"
+  },
+  completedDelayMs: {
+    label: "Completed delay (ms)",
+    help: "Idle this long before the share says completed (default 5000, 0 = immediate). Busy cancels; opencode exit flushes. Clamped by the server.",
+    kind: "number",
+    section: "Sharing",
+    info: `opencode's idle signal is authoritative turn end (busy is held through tool runs and permission waits). This delay only smooths the gap before an automation's NEXT prompt \u2014 if a new turn starts inside the window the timer cancels and the share stays live.
+
+A graceful opencode exit flushes the pending flip, so CI runs land their final status.`,
+    def: "5000"
+  },
+  modelLabel: {
+    label: "Model label template",
+    help: "$Provider/$Model placeholders; literal text as-is; empty hides the model.",
+    kind: "text",
+    section: "Sharing",
+    info: 'How the model name appears on the share page. "$Provider/$Model" renders e.g. "closedrouter/zai/glm-5.3". Any literal text is used as-is; empty string hides the model line entirely.',
+    def: '"$Provider/$Model"'
+  },
+  ttlDays: {
+    label: "TTL (days)",
+    help: "Share lifetime; the worker caps it at its MAX_TTL_DAYS.",
+    kind: "number",
+    section: "Sharing",
+    info: `How long pages live before the server's sweeper deletes them. Capped server-side: the deployment's MAX_TTL_DAYS and the token's maxTtlDays limit both apply.
+
+A per-session override lives in the This-session section; it is sent at create/attach time.`,
+    def: "worker cap (90 on the reference deployment)"
+  },
+  openTasksInNewTab: {
+    label: "Open tasks in new tab",
+    help: "Viewer: task rows open subagent pages in a new tab.",
+    kind: "text",
+    options: ["true", "false"],
+    section: "Sharing",
+    info: "Viewer behavior only: clicking a task (subagent) row opens its sub-page in a new browser tab instead of navigating. true/false.",
+    def: "true"
+  },
+  authLogin: {
+    label: "Read auth: login",
+    help: "Optional read gate for share pages. Empty removes protection on the next attach.",
+    kind: "text",
+    section: "Read auth",
+    info: `Optional username for a login gate on NEW shares. Viewers must enter login+password (PBKDF2-hashed server-side, 7-day cookie, lockout after failures).
+
+Write access is a separate lock \u2014 a login never lets anyone edit. Removing both values removes the gate on the next attach.`,
+    def: "(empty \u2014 no gate)"
+  },
+  authPassword: {
+    label: "Read auth: password",
+    help: "Optional read gate for share pages.",
+    kind: "password",
+    section: "Read auth",
+    info: "The password half of the optional read gate. Stored in plain text in the config file \u2014 prefer per-session auth for anything sensitive. Only the hash ever reaches the server.",
+    def: "(empty)"
+  },
+  spoolDir: {
+    label: "Spool directory",
+    help: "Temporary unacked-frame buffer (default: XDG data home).",
+    kind: "text",
+    section: "Advanced",
+    info: "Where un-acked sync frames buffer on disk (one file per session per server). They replay automatically on reconnect. The binding in session metadata is the source of truth \u2014 the spool is an optimization, safe to clear while idle.",
+    def: "XDG data home"
+  },
+  urlFile: {
+    label: "URL file",
+    help: 'File each share URL is appended to (all-mode). Empty = default openshare.urls.txt in the session directory; "none" = no URL file.',
+    kind: "text",
+    section: "Advanced",
+    info: `All-mode CI surface: every created share URL is APPENDED to this file and announced on stderr. Empty uses openshare.urls.txt in the session's working directory; "none" disables the file; a path writes there.
+
+Manual mode (TUI) never writes it \u2014 the link lives in the TUI.`,
+    def: "openshare.urls.txt (session dir)"
+  },
+  announceStderr: {
+    label: "Announce on stderr",
+    help: '"true"/"false": the [openshare] live: and url file: log lines. false silences them; the share itself is unaffected.',
+    kind: "text",
+    options: ["true", "false"],
+    section: "Advanced",
+    info: "Whether the informational [openshare] lines reach stderr in all-mode (CI logs). Error-class lines (worker down, refused, timeouts) ALWAYS reach stderr regardless. In manual mode stderr is errors-only by design.",
+    def: "true"
+  }
+};
+function helpForKey(key, cfg, sources) {
+  const meta = LABELS[key];
+  if (!meta)
+    return;
+  const lines = [meta.info ?? meta.help];
+  lines.push("");
+  lines.push(`Current: ${displayValue(key, cfg)}`);
+  if (sources[key])
+    lines.push(`Source: ${sources[key]} (overrides anything written below it)`);
+  if (meta.def)
+    lines.push(`Default: ${meta.def}`);
+  return lines.join(`
+`);
+}
+function displayValue(key, cfg) {
+  if (key === "createToken" || key === "authPassword")
+    return mask(String(cfg[key] ?? ""));
+  if (key === "openTasksInNewTab")
+    return String(cfg.openTasksInNewTab !== false);
+  if (key === "announceStderr")
+    return String(cfg.announceStderr !== false);
+  const value = cfg[key];
+  return value === undefined || value === "" ? "(not set)" : String(value);
+}
+async function editKey(host, cfg, key) {
+  const meta = LABELS[key];
+  if (!meta)
+    return;
+  if (meta.options) {
+    const current = String(cfg[key] ?? "");
+    const picked = await showSelect(host.ui, {
+      title: meta.label,
+      options: meta.options.map((option) => ({
+        title: option,
+        value: option,
+        description: option === current ? "\u25CF current" : ""
+      })),
+      current
+    });
+    if (picked === undefined)
+      return;
+    const next2 = { ...cfg };
+    if (key === "shareMode")
+      next2[key] = picked === "auto" ? undefined : picked;
+    else if (key === "openTasksInNewTab" || key === "announceStderr")
+      next2[key] = picked === "true";
+    else
+      next2[key] = picked;
+    return next2;
+  }
+  const raw = await showPrompt(host.ui, {
+    title: `${meta.label} \u2014 ${displayValue(key, cfg)}`,
+    placeholder: meta.kind === "number" ? "number" : meta.kind === "password" ? "paste token" : "value",
+    value: meta.kind === "password" ? "" : String(cfg[key] ?? "")
+  });
+  if (raw === undefined)
+    return;
+  const next = { ...cfg };
+  if (meta.kind === "number") {
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      host.ui.toast({ variant: "error", title: "OpenShare", message: `${meta.label}: "${raw}" is not a positive number.` });
+      return;
+    }
+    next[key] = Math.floor(parsed);
+  } else if (key === "urlFile") {
+    next[key] = raw.trim().toLowerCase() === "none" ? "none" : raw;
+  } else {
+    next[key] = raw;
+  }
+  return next;
+}
+async function connectServerFlow(host) {
+  const raw = await showPrompt(host.ui, { title: "Share server URL", placeholder: "https://your-openshare-host" });
+  if (raw === undefined || raw === "")
+    return { ok: false, message: "Cancelled." };
+  const url = normServerUrl(raw);
+  if (!/^https?:\/\//.test(url))
+    return { ok: false, message: "URL must start with http:// or https://" };
+  host.ui.toast({ variant: "info", title: "OpenShare", message: `Probing ${url}\u2026` });
+  const probe = await probeAuthMode(url);
+  if (!probe.ok)
+    return { ok: false, message: `${url}: ${probe.detail}` };
+  let code = "";
+  if (probe.mode === "private") {
+    const typed = await showPrompt(host.ui, { title: `${url} needs an access code`, placeholder: "osc_\u2026 (from the hoster)" });
+    if (typed === undefined)
+      return { ok: false, message: "Cancelled \u2014 private servers need a code." };
+    code = typed.trim();
+  }
+  const res = await enrollAtServer(url, code);
+  if (!res.ok)
+    return { ok: false, message: `Enrollment refused: ${res.error}` };
+  for (const other of serverEntries()) {
+    if (other.url !== url)
+      saveServerEntry(other.url, { active: undefined });
+  }
+  saveServerEntry(url, { token: res.token, label: res.label, code: code || undefined, active: true });
+  return { ok: true, message: `Connected to ${url} as "${res.label}" \u2014 sharing goes there now.`, url };
+}
+async function serverMenu(host, url) {
+  while (true) {
+    const entries = serverEntries();
+    const mine = entries.find((s) => s.url === url);
+    if (!mine)
+      return;
+    const holdsRoot = !!mine.entry.token && mine.entry.token === (mine.entry.adminToken ?? adminTokenFor(url));
+    const cred = holdsRoot ? `ROOT token ${mask(mine.entry.token)} \u2014 admin, no user identity` : mine.entry.token ? `token ${mask(mine.entry.token)}` : mine.entry.code ? "no token (code saved, enrolls on demand)" : "no token (public server, enrolls on demand)";
+    const options = [
+      { title: url, value: "info", description: `${mine.entry.label ?? "(no label)"} \xB7 ${cred}${mine.active ? " \xB7 ACTIVE" : ""}`, disabled: true }
+    ];
+    if (!mine.active)
+      options.push({ title: "Set active", value: "active", description: "new sessions share here" });
+    if (holdsRoot) {
+      options.push({
+        title: "Get a user token",
+        value: "adopt",
+        description: "admin-mint YOUR user token; root stays saved",
+        help: `You hold the server's ROOT token \u2014 full admin, but root is not a user identity: rotate/disconnect act on user tokens, and a root-holder "user" doesn't exist.
+
+This creates your own user on ${url} (label prompt, prefilled), mints its token, and saves it as this server's user token. The root token stays in adminToken for the admin panel. You become admin AND user.`
+      });
+    }
+    if (!mine.entry.token || holdsRoot)
+      options.push({ title: "Enroll now", value: "enroll", description: holdsRoot ? "join as a user via code/public enrollment" : "get a user token immediately" });
+    if (mine.entry.token && !holdsRoot)
+      options.push({ title: "Rotate token", value: "rotate", description: "new token, old one revoked" });
+    if (mine.entry.token && !holdsRoot)
+      options.push({ title: "Disconnect", value: "disconnect", description: "revoke the token server-side and forget it", danger: true });
+    options.push({
+      title: "Admin panel",
+      value: "admin",
+      description: "root-token console: users, codes, tokens, shares",
+      help: `Opens the admin console for THIS server: manage users (freeze/unfreeze/mint/delete), revoke tokens, create access codes, list/reassign/delete shares, purge.
+
+Needs the server's root CREATE_TOKEN (saved admin token used first; prompted otherwise, and then saved). User tokens cannot administer.`
+    });
+    options.push({ title: "Test this server", value: "test", description: "probe /health" });
+    options.push({ title: "Remove from config", value: "remove", description: "drop the saved membership (server-side state untouched)", danger: true });
+    options.push({ title: "Back", value: "__back" });
+    const choice = await showSelect(host.ui, { title: "Share server", options });
+    if (choice === undefined || choice === "__back")
+      return;
+    if (choice === "active") {
+      for (const other of entries) {
+        if (other.url !== url)
+          saveServerEntry(other.url, { active: undefined });
+      }
+      saveServerEntry(url, { active: true });
+      host.ui.toast({ variant: "success", title: "OpenShare", message: `${url} is now the active server.` });
+      return;
+    }
+    if (choice === "adopt") {
+      const rootToken = mine.entry.adminToken ?? adminTokenFor(url);
+      if (!rootToken) {
+        await showInfo(host.ui, { title: "No admin token", message: "The root token is needed to mint your user token. Open the Admin panel once (it saves the token), then retry." });
+        continue;
+      }
+      const prefill = `admin-${hostOf(url).replace(/[^a-z0-9-]/gi, "") || "user"}`;
+      const label = (await showPrompt(host.ui, { title: "Your user label on this server", placeholder: "shown in the admin user list", value: prefill }))?.trim();
+      if (!label)
+        continue;
+      const client = adminClient(url, rootToken);
+      const made = await client.createUser(label);
+      if (!made.ok || !made.data?.userId) {
+        await showInfo(host.ui, { title: "User creation failed", message: `${url}: ${made.error ?? "unknown error"}` });
+        continue;
+      }
+      const minted = await client.mintToken(made.data.userId, label);
+      if (!minted.ok || !minted.data?.token) {
+        await showInfo(host.ui, { title: "Token mint failed", message: `${url}: ${minted.error ?? "unknown error"} (user was created \u2014 retry mint from the admin panel)` });
+        continue;
+      }
+      saveServerEntry(url, { token: minted.data.token, label, adminToken: rootToken });
+      host.ui.toast({ variant: "success", title: "OpenShare", message: `User token for "${label}" saved \u2014 rotate and disconnect now work; root stays for the admin panel.` });
+      continue;
+    }
+    if (choice === "enroll") {
+      const probe = await probeAuthMode(url);
+      if (!probe.ok) {
+        await showInfo(host.ui, { title: "Unreachable", message: `${url}: ${probe.detail}` });
+        continue;
+      }
+      let code = mine.entry.code ?? "";
+      if (probe.mode === "private" && !code) {
+        const typed = await showPrompt(host.ui, { title: `${url} needs an access code`, placeholder: "osc_\u2026 (from the hoster)" });
+        if (typed === undefined)
+          continue;
+        code = typed.trim();
+        if (code)
+          saveServerEntry(url, { code });
+      }
+      const res = await enrollAtServer(url, code);
+      if (res.ok) {
+        saveServerEntry(url, { token: res.token, label: res.label });
+        host.ui.toast({ variant: "success", title: "OpenShare", message: `Enrolled as "${res.label}".` });
+      } else {
+        await showInfo(host.ui, { title: "Enrollment refused", message: res.error ?? "unknown error" });
+      }
+      continue;
+    }
+    if (choice === "rotate") {
+      const res = await rotateAtServer(url, mine.entry.token ?? "");
+      if (res.ok && res.token) {
+        saveServerEntry(url, { token: res.token });
+        host.ui.toast({ variant: "success", title: "OpenShare", message: "Token rotated; the old one is revoked." });
+      } else {
+        await showInfo(host.ui, { title: "Rotation failed", message: `${res.error ?? "unknown"} \u2014 if the token was revoked server-side, use Enroll now instead.` });
+      }
+      continue;
+    }
+    if (choice === "disconnect") {
+      const sure = await showConfirm(host.ui, { title: "Disconnect", message: `Revoke the token at ${url} and forget it?
+Your shares stay (read-only for you until TTL).`, confirmLabel: "Disconnect", danger: true });
+      if (!sure)
+        continue;
+      const res = await disconnectAtServer(url, mine.entry.token ?? "");
+      saveServerEntry(url, { token: undefined });
+      host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.ok ? "Disconnected." : `Server-side revoke failed (${res.error ?? "error"}) \u2014 token forgotten locally.` });
+      continue;
+    }
+    if (choice === "test") {
+      const result = await probeWorker(url);
+      await showInfo(host.ui, { title: result.ok ? "Server reachable" : "Server unreachable", message: `${url} \u2014 ${result.detail}` });
+      continue;
+    }
+    if (choice === "admin") {
+      await adminConsole(host, url);
+      continue;
+    }
+    if (choice === "remove") {
+      const sure = await showConfirm(host.ui, { title: "Remove server", message: `Remove the saved membership for
+${url}?`, confirmLabel: "Remove", danger: true });
+      if (!sure)
+        continue;
+      deleteServerEntry(url);
+      host.ui.toast({ variant: "success", title: "OpenShare", message: "Membership removed." });
+      return;
+    }
+  }
+}
+async function adminConsole(host, pinnedUrl) {
+  let url = pinnedUrl;
+  if (!url) {
+    const entries = serverEntries();
+    const pickOptions = entries.map((s) => ({
+      title: s.url,
+      value: s.url,
+      description: `${s.entry.label ? s.entry.label + " \xB7 " : ""}${s.entry.adminToken ? "admin token saved" : "no admin token saved"}`
+    }));
+    pickOptions.push({ title: "Enter a server URL\u2026", value: "__prompt" });
+    const picked = await showSelect(host.ui, { title: "Admin console \u2014 server", options: pickOptions });
+    if (picked === undefined)
+      return;
+    url = picked;
+    if (picked === "__prompt") {
+      const raw = await showPrompt(host.ui, { title: "Server URL", placeholder: "https://your-openshare-host" });
+      if (raw === undefined || raw === "")
+        return;
+      url = normServerUrl(raw);
+    }
+  }
+  let adminToken = adminTokenFor(url);
+  let prompted = false;
+  let client = adminClient(url, adminToken);
+  while (true) {
+    const probe = adminToken ? await client.users() : { ok: false, error: "no admin token" };
+    if (probe.ok)
+      break;
+    const raw = await showPrompt(host.ui, {
+      title: `Admin (root) token for ${url}`,
+      placeholder: "the worker's CREATE_TOKEN",
+      value: ""
+    });
+    if (raw === undefined)
+      return;
+    adminToken = raw.trim();
+    prompted = true;
+    client = adminClient(url, adminToken);
+    const retry = await client.users();
+    if (!retry.ok) {
+      await showInfo(host.ui, { title: "Not an admin token", message: `${url}: ${retry.error ?? "rejected"} \u2014 the root CREATE_TOKEN is required (user tokens cannot administer).` });
+      return;
+    }
+    break;
+  }
+  if (prompted && adminToken) {
+    const saved = saveServerEntry(url, { adminToken });
+    if (saved)
+      host.ui.toast({ variant: "info", title: "OpenShare", message: `Admin token saved for ${url} (servers entry).` });
+  }
+  while (true) {
+    const users = [];
+    const tokens = [];
+    const codes = [];
+    const shares = [];
+    await withBusy(host, `Loading ${hostOf(url)}\u2026`, async () => {
+      const [usersR, tokensR, codesR, sharesR] = await Promise.all([client.users(), client.tokens(), client.codes(), client.shares()]);
+      users.push(...usersR.data?.users ?? []);
+      tokens.push(...tokensR.data?.tokens ?? []);
+      codes.push(...codesR.data?.codes ?? []);
+      shares.push(...sharesR.data?.shares ?? []);
+    });
+    const choice = await showSelect(host.ui, {
+      title: `Admin \u2014 ${url}`,
+      options: [
+        { title: "Server info", value: "info", description: "health, policy, auth mode, your standing", help: `Full server state: service version, socket policy (formatted, not a JSON blob), what joining requires, and what THIS plugin instance holds (user token / root / none) \u2014 with follow-up actions.` },
+        { title: `Users (${users.length})`, value: "users", description: `${users.filter((u) => u.frozen).length} frozen` },
+        { title: `Tokens (${tokens.length})`, value: "tokens", description: `${tokens.filter((t) => !t.revoked).length} active` },
+        { title: `Access codes (${codes.length})`, value: "codes", description: "invite codes with activation budgets" },
+        { title: `Shares (${shares.length})`, value: "shares", description: "every share on this server" },
+        { title: "Mint my user token", value: "adopt", description: "admin-mint YOUR user token and save it", help: `Creates your own user on ${url} and saves its token as this server's user credential \u2014 so rotate/disconnect and share ownership work for you. The root token stays untouched in adminToken.` },
+        { title: "Purge ALL shares", value: "purge", description: "delete every share \u2014 maintenance", danger: true },
+        { title: "Back", value: "__back" }
+      ]
+    });
+    if (choice === undefined || choice === "__back")
+      return;
+    if (choice === "info") {
+      await serverInfoScreen(host, url, client);
+      continue;
+    }
+    if (choice === "users") {
+      await adminUsersMenu(host, client, url, users);
+      continue;
+    }
+    if (choice === "tokens") {
+      await adminTokensMenu(host, client, tokens);
+      continue;
+    }
+    if (choice === "codes") {
+      await adminCodesMenu(host, client, codes);
+      continue;
+    }
+    if (choice === "shares") {
+      await adminSharesMenu(host, client, url, shares, users);
+      continue;
+    }
+    if (choice === "adopt") {
+      await adoptUserToken(host, url, adminToken);
+      continue;
+    }
+    if (choice === "purge") {
+      const sure = await showConfirm(host.ui, {
+        title: "Purge every share",
+        message: `Delete ALL ${shares.length} shares on
+${url}?
+Viewers get a final "gone" frame. Users, tokens and codes are untouched.`,
+        confirmLabel: "Purge",
+        danger: true
+      });
+      if (!sure)
+        continue;
+      const res = await client.purge();
+      host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.ok ? `Removed ${res.data?.removed ?? "?"} shares.` : `Purge failed: ${res.error}` });
+      continue;
+    }
+  }
+}
+async function withBusy(host, title, work) {
+  const doneBusy = host.ui.showBusy?.(title);
+  try {
+    await (typeof work === "function" ? work() : work);
+  } catch {}
+  doneBusy?.();
+}
+async function serverInfoScreen(host, url, client) {
+  const h = await client.health();
+  if (!h.ok) {
+    await showInfo(host.ui, { title: "Unreachable", message: `${url}: ${h.error ?? "unreachable"}` });
+    return;
+  }
+  const policy = h.data?.policy ?? {};
+  const policyLines = Object.entries(policy).map(([key, value]) => {
+    if (typeof value === "number" && /ms$/i.test(key))
+      return `${key}: ${value >= 60000 ? `${Math.round(value / 60000)}m` : `${Math.round(value / 1000)}s`} (${value}ms)`;
+    return `${key}: ${String(value)}`;
+  });
+  const mode = h.data?.auth?.mode;
+  const entry = serverEntries().find((s) => s.url === url)?.entry;
+  const standing = entry?.token ? entry.token === (entry.adminToken ?? adminTokenFor(url)) ? `root token only \u2014 admin, NO user identity (see "Get a user token")` : `user token ${mask(entry.token)}${entry.adminToken ? " + root adminToken" : ""}` : entry?.code ? "access code saved \u2014 enrolls on demand" : "no credential held \u2014 public enrollment on demand";
+  const message = [
+    `${url}`,
+    `service: ${h.data?.service ?? "?"}`,
+    "",
+    "Auth:",
+    mode === "private" ? "private \u2014 joining needs an access code (osc_\u2026) issued by the hoster" : mode === "public" ? "public \u2014 anyone with the URL may enroll and share" : `unknown (${String(mode)})`,
+    "You hold: " + standing,
+    "",
+    "Policy (server-owned; clients get clamped into it):",
+    ...policyLines
+  ].join(`
+`);
+  await showInfo(host.ui, { title: "Server info", message });
+  const followUp = await showSelect(host.ui, {
+    title: "Server info \u2014 actions",
+    options: [
+      { title: "Create access code", value: "code", description: "invite: N activations, each issues a user token", help: `Mints an osc_ access code on ${url}. Each activation creates a new user + token; the budget limits how many. Shown once \u2014 copy it right away.` },
+      { title: "Back", value: "__back" }
+    ]
+  });
+  if (followUp === "code") {
+    const raw = await showPrompt(host.ui, { title: "Activations budget", placeholder: "how many users this code may create", value: "1" });
+    if (raw === undefined)
+      return;
+    const activations = Math.max(1, Math.floor(Number(raw) || 1));
+    const res = await client.createCode(`info-${new Date().toISOString().slice(0, 10)}`, activations);
+    if (res.ok && res.data?.code) {
+      await host.clipboard.write(res.data.code).catch(() => false);
+      await showInfo(host.ui, { title: "Access code created", message: `${res.data.code}
+
+${activations} activation(s). Copied to the clipboard \u2014 shown once.` });
+    } else {
+      await showInfo(host.ui, { title: "Creation failed", message: res.error ?? "unknown error" });
+    }
+  }
+}
+async function adoptUserToken(host, url, rootToken) {
+  const prefill = `admin-${hostOf(url).replace(/[^a-z0-9-]/gi, "") || "user"}`;
+  const label = (await showPrompt(host.ui, { title: "Your user label on this server", placeholder: "shown in the admin user list", value: prefill }))?.trim();
+  if (!label)
+    return;
+  const client = adminClient(url, rootToken);
+  const made = await client.createUser(label);
+  if (!made.ok || !made.data?.userId) {
+    await showInfo(host.ui, { title: "User creation failed", message: `${url}: ${made.error ?? "unknown error"}` });
+    return;
+  }
+  const minted = await client.mintToken(made.data.userId, label);
+  if (!minted.ok || !minted.data?.token) {
+    await showInfo(host.ui, { title: "Token mint failed", message: `${url}: ${minted.error ?? "unknown error"} (user was created \u2014 retry mint from the admin panel)` });
+    return;
+  }
+  saveServerEntry(url, { token: minted.data.token, label, adminToken: rootToken });
+  host.ui.toast({ variant: "success", title: "OpenShare", message: `User token for "${label}" saved \u2014 root stays for the admin panel.` });
+}
+async function adminUsersMenu(host, client, url, users) {
+  const options = users.map((u) => ({
+    title: u.label,
+    value: u.id,
+    description: `${u.shares} shares \xB7 ${u.tokensActive}/${u.tokens} tokens${u.frozen ? " \xB7 FROZEN" : ""}`
+  }));
+  options.push({ title: "Create user", value: "__create", description: "empty user record; mint a token next" });
+  options.push({ title: "Back", value: "__back" });
+  if (users.length === 0)
+    options.splice(0, 0, { title: "No users yet", value: "__empty", description: "create one below, or share an access code", disabled: true });
+  while (true) {
+    const picked = await showSelect(host.ui, { title: `Users \u2014 ${url}`, options });
+    if (picked === undefined || picked === "__back")
+      return;
+    if (picked === "__create") {
+      const label = await showPrompt(host.ui, { title: "New user label", placeholder: "name (optional)" });
+      if (label === undefined)
+        continue;
+      const res = await client.createUser(label.trim());
+      host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.ok ? `User created: ${res.data?.label}` : `Failed: ${res.error}` });
+      continue;
+    }
+    const user = users.find((u) => u.id === picked);
+    if (!user)
+      return;
+    const action = await showSelect(host.ui, {
+      title: `${user.label}${user.frozen ? " (FROZEN)" : ""}`,
+      options: [
+        { title: user.frozen ? "Unfreeze" : "Freeze", value: "freeze", description: user.frozen ? "restore edit rights on their shares" : "sever ALL edit paths on their shares (view unaffected)" },
+        { title: "Mint token", value: "mint", description: "issue a new osk_ token (shown once)" },
+        { title: "Delete user", value: "delete", description: "default freezes; delete mode also removes shares + tokens", danger: true },
+        { title: "Back", value: "__back" }
+      ]
+    });
+    if (action === undefined || action === "__back")
+      continue;
+    if (action === "freeze") {
+      const res = user.frozen ? await client.unfreeze(user.id) : await client.freeze(user.id);
+      host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.ok ? user.frozen ? "Unfrozen." : `Frozen (${res.data?.shares ?? "?"} shares locked).` : `Failed: ${res.error}` });
+      continue;
+    }
+    if (action === "mint") {
+      const res = await client.mintToken(user.id);
+      if (res.ok && res.data?.token) {
+        await host.clipboard.write(res.data.token);
+        await showInfo(host.ui, { title: "Token minted", message: `For ${user.label}:
+${res.data.token}
+
+(copied to clipboard \u2014 shown once)` });
+      } else {
+        await showInfo(host.ui, { title: "Mint failed", message: res.error ?? "unknown error" });
+      }
+      continue;
+    }
+    if (action === "delete") {
+      const mode = await showSelect(host.ui, {
+        title: `Delete ${user.label}?`,
+        options: [
+          { title: "Freeze instead (default)", value: "freeze", description: "reversible \u2014 shares stay, edits blocked" },
+          { title: "Delete everything", value: "delete", description: "remove their shares + tokens + user", danger: true },
+          { title: "Cancel", value: "__cancel" }
+        ]
+      });
+      if (mode === undefined || mode === "__cancel")
+        continue;
+      const res = await client.deleteUser(user.id, mode === "delete" ? "delete" : "freeze");
+      host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.ok ? mode === "delete" ? `Deleted (${res.data?.shares ?? "?"} shares removed).` : "Frozen." : `Failed: ${res.error}` });
+      continue;
+    }
+  }
+}
+async function adminTokensMenu(host, client, tokens) {
+  while (true) {
+    const fresh = (await client.tokens()).data?.tokens ?? [];
+    const options = fresh.filter((t) => !t.revoked).map((t) => ({
+      title: `${t.label || "(unlabeled)"} ${t.id}`,
+      value: t.id,
+      description: `last used ${t.lastUsedAt ? new Date(t.lastUsedAt).toISOString().slice(0, 16).replace("T", " ") : "never"}`
+    }));
+    if (options.length === 0)
+      options.push({ title: "No active tokens", value: "__empty", description: "mint one from a user in Users", disabled: true });
+    options.push({ title: "Back", value: "__back" });
+    const picked = await showSelect(host.ui, { title: `Active tokens (${options.length - 1}) \u2014 revoke`, options });
+    if (picked === undefined || picked === "__back")
+      return;
+    const sure = await showConfirm(host.ui, { title: "Revoke token", message: `Revoke ${picked}?
+The holder can no longer write (existing shares keep their secrets unless the user is frozen).`, confirmLabel: "Revoke", danger: true });
+    if (!sure)
+      continue;
+    const res = await client.revokeToken(picked);
+    host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.ok ? "Token revoked." : `Failed: ${res.error}` });
+  }
+}
+async function adminCodesMenu(host, client, codes) {
+  while (true) {
+    const fresh = (await client.codes()).data?.codes ?? [];
+    const options = fresh.map((c) => ({
+      title: `${c.label}${c.disabled ? " (disabled)" : ""}`,
+      value: c.id,
+      description: c.activationsLeft === -1 ? "unlimited activations" : `${c.activationsLeft} left \xB7 ${c.used} used`
+    }));
+    if (fresh.length === 0)
+      options.push({ title: "No access codes yet", value: "__empty", description: "create one below to invite users", disabled: true });
+    options.push({ title: "Create code", value: "__create", description: "invite: label + activation budget" });
+    options.push({ title: "Back", value: "__back" });
+    const picked = await showSelect(host.ui, { title: "Access codes", options });
+    if (picked === undefined || picked === "__back")
+      return;
+    if (picked === "__create") {
+      const label = await showPrompt(host.ui, { title: "Code label", placeholder: "e.g. friends, team" });
+      if (label === undefined)
+        continue;
+      const raw = await showPrompt(host.ui, { title: "Activations", placeholder: "1 (personal invite) \xB7 number \xB7 -1 = unlimited" });
+      if (raw === undefined)
+        continue;
+      const n = Number(raw.trim() === "" ? "1" : raw.trim());
+      const activations = Number.isFinite(n) && n >= 1 ? Math.floor(n) : -1;
+      const res2 = await client.createCode(label.trim() || "invite", activations);
+      if (res2.ok && res2.data?.code) {
+        await host.clipboard.write(res2.data.code);
+        await showInfo(host.ui, { title: "Code created", message: `${label.trim() || "invite"}: ${res2.data.code}
+(${activations === -1 ? "unlimited" : activations} activation${activations === 1 ? "" : "s"})
+
+(copied to clipboard \u2014 shown once)` });
+      } else {
+        await showInfo(host.ui, { title: "Create failed", message: res2.error ?? "unknown error" });
+      }
+      continue;
+    }
+    const code = fresh.find((c) => c.id === picked);
+    if (!code || code.disabled)
+      continue;
+    const sure = await showConfirm(host.ui, { title: "Disable code", message: `Disable "${code.label}"?
+Holders can no longer enroll with it (existing tokens unaffected).`, confirmLabel: "Disable" });
+    if (!sure)
+      continue;
+    const res = await client.disableCode(picked);
+    host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.ok ? "Code disabled." : `Failed: ${res.error}` });
+  }
+}
+async function adminSharesMenu(host, client, url, shares, users) {
+  const labelOf = (id) => users.find((u) => u.id === id)?.label ?? id ?? "(ownerless)";
+  while (true) {
+    const fresh = (await client.shares()).data?.shares ?? [];
+    const options = fresh.map((s) => ({
+      title: `${s.id.slice(0, 10)}\u2026`,
+      value: s.id,
+      description: `${labelOf(s.ownerId)} \xB7 ${new Date(s.createdAt).toISOString().slice(0, 16).replace("T", " ")}`
+    }));
+    if (fresh.length === 0)
+      options.push({ title: "No shares on this server", value: "__empty", description: "nothing is being shared right now", disabled: true });
+    options.push({ title: "Back", value: "__back" });
+    const picked = await showSelect(host.ui, { title: `Shares \u2014 ${url}`, options });
+    if (picked === undefined || picked === "__back" || picked === "__empty")
+      return;
+    const share = fresh.find((s) => s.id === picked);
+    if (!share)
+      continue;
+    const action = await showSelect(host.ui, {
+      title: `Share ${picked.slice(0, 12)}\u2026`,
+      options: [
+        { title: "Reassign owner", value: "reassign", description: `currently ${labelOf(share.ownerId)} \u2014 the rescue path` },
+        { title: "Delete share", value: "delete", description: "viewers get a final gone frame", danger: true },
+        { title: "Back", value: "__back" }
+      ]
+    });
+    if (action === undefined || action === "__back")
+      continue;
+    if (action === "reassign") {
+      const usersNow = (await client.users()).data?.users ?? [];
+      const target = await showSelect(host.ui, {
+        title: "Reassign to user",
+        options: [...usersNow.map((u) => ({ title: u.label, value: u.id, description: u.frozen ? "FROZEN \u2014 unfreeze after" : `${u.shares} shares` })), { title: "Cancel", value: "__cancel" }]
+      });
+      if (target === undefined || target === "__cancel")
+        continue;
+      const res = await client.reassign(picked, target);
+      host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.ok ? "Reassigned (freeze cleared on this share)." : `Failed: ${res.error}` });
+      continue;
+    }
+    if (action === "delete") {
+      const sure = await showConfirm(host.ui, { title: "Delete share", message: `Delete ${picked} permanently?`, confirmLabel: "Delete", danger: true });
+      if (!sure)
+        continue;
+      const res = await client.deleteShare(picked);
+      host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.ok ? "Share deleted." : `Failed: ${res.error}` });
+      continue;
+    }
+  }
+}
+async function settingsDialog(host, startAtSession) {
+  let cfg = currentConfig();
+  let dirty = false;
+  const candidates = writeCandidates(moduleDir());
+  let writeTarget = candidates[0];
+  const sources = configSourceMap(moduleDir());
+  const GROUP_LABEL = {
+    session: "This session",
+    servers: "Servers",
+    sharing: "Sharing",
+    readauth: "Read auth",
+    interface: "Interface",
+    advanced: "Advanced",
+    configfiles: "Config files"
+  };
+  const dirtyKeys = new Set;
+  const keyRows = (section) => Object.entries(LABELS).filter(([, meta]) => meta.section === section).map(([key, meta]) => ({ title: meta.label, value: `key:${key}`, description: withSource(displayValue(key, cfg), sources[key]), help: helpForKey(key, cfg, sources), edited: dirtyKeys.has(key) }));
+  const serverRows = () => {
+    const servers = serverEntries(cfg);
+    const rows = keyRows("Connection");
+    rows.push({ title: "\u2014 saved servers \u2014", value: "__divider_servers", divider: true });
+    for (const s of servers) {
+      const cred = s.entry.token ? "token saved" : s.entry.code ? "code saved" : "enrolls on demand";
+      rows.push({
+        title: s.url,
+        value: `server:${s.url}`,
+        description: `${s.entry.label ? s.entry.label + " \xB7 " : ""}${cred}${s.active ? " \xB7 ACTIVE" : ""}`,
+        help: [
+          `## Server`,
+          `Server: ${s.url}`,
+          `Label: ${s.entry.label ?? "(none)"}`,
+          `Credential: ${s.entry.token ? `user token ${mask(s.entry.token)}` : s.entry.code ? "access code saved \u2014 enrolls on demand" : "none \u2014 public server, enrolls on demand"}`,
+          `Receives new sessions: ${s.active ? "YES (active)" : "no"}`,
+          "",
+          "## Notes",
+          "Every ACTIVE server receives new sessions (fan-out); one active server is the normal setup. Tokens persist in the settings home; enroll once, then it just works. The per-server submenu (enter) adds the admin panel for this server."
+        ].join(`
+`)
+      });
+    }
+    rows.push({
+      title: "Connect to a server",
+      value: "server:add",
+      description: "URL (+ access code) \u2014 enrolls and saves the token",
+      help: "Onboarding flow: paste the server URL; public servers enroll immediately, private ones ask for an access code (osc_\u2026 from the hoster). The server issues a user token that persists in the settings home \u2014 the root CREATE_TOKEN is never needed for sharing."
+    });
+    rows.push({
+      title: "Test connection",
+      value: "action:test",
+      description: "Probe the active server's /health",
+      help: "Fetches /health on the active server and reports the service, auth mode, and socket policy. A quick way to verify URL and reachability before sharing."
+    });
+    return rows;
+  };
+  const interfaceRows = () => {
+    const uiWidth = kvWidthOf(host.kv);
+    const uiHeight = kvHeightPercentOf(host.kv);
+    return [
+      {
+        title: "Menu size\u2026",
+        value: "ui:size",
+        description: `${uiWidth} (${DIALOG_WIDTH_COLUMNS[uiWidth]} cols) \xB7 ${uiHeight}% height`,
+        help: `## Width
+medium = 60, large = 88, xlarge = 116 columns \u2014 opencode exposes fixed widths only. In the picker, w cycles the width and the dialog resizes live.
+
+## Height
+A percent of terminal rows (25-100), capped at 75% of the terminal minus chrome (the host's backdrop offset). Presets: compact 35, normal 50, tall 70, max 100. The picker's live preview shows the true capped height.
+
+Current: ${uiWidth} (${DIALOG_WIDTH_COLUMNS[uiWidth]} columns) at ${uiHeight}%
+Stored per host (opencode's own preference store), not in the config file.`
+      }
+    ];
+  };
+  const configRows = () => [
+    {
+      title: "Write target",
+      value: "action:target",
+      description: writeTarget.label,
+      disabled: candidates.length <= 1,
+      help: `Which file "Save & exit" writes. The global settings home is always available; other files in the read chain only when they already exist (the TUI never creates deploy-time override files).
+
+Writing: ${writeTarget.path}`
+    },
+    {
+      title: "Where values come from",
+      value: "action:sources",
+      description: summarizeSources(sources),
+      help: `Config merges per key, highest priority wins: OPENSHARE_* env > plugin options > adjacent openshare.config.json > openshare.local.json (repo walk-up) > settings home > defaults. An empty string means unset for url/token keys.
+
+${sourcesMessage(sources)}`
+    }
+  ];
+  const sessionRows = async () => {
+    if (!startAtSession)
+      return [];
+    const binding = await readBinding(host.client, await resolveRoot(host.client, startAtSession));
+    const rows = [
+      {
+        title: binding?.url ? "Copy share link" : "Share this session",
+        value: "session:share",
+        description: binding?.url ? "copy the share URL to the clipboard" : "Set the share flag; the server plugin creates the page",
+        help: binding?.url ? `Copies the share URL to the clipboard.
+
+URL: ${binding.url}
+Share id: ${binding.id ?? "?"}` : "Publishes this session (and its subagent sessions) to the active server. The full history lands in the page \u2014 sharing mid-session is first-class, nothing is missed."
+      }
+    ];
+    if (binding?.url) {
+      rows.push({
+        title: "Stop sharing",
+        value: "session:unshare",
+        description: "delete the page(s), or leave a snapshot",
+        danger: true,
+        help: `Choose per run: DELETE every page server-side (links stop working \u2014 final "gone" state), or LEAVE AS-IS (stop updating; pages stay readable until their TTL \u2014 a frozen snapshot).
+
+URLs:
+${[binding.url].join(`
+`)}
+
+Sharing again later always creates fresh page(s) with new URLs.`
+      });
+    }
+    rows.push({
+      title: "Session TTL override (days)",
+      value: "session:ttl",
+      description: binding?.opts?.ttlDays !== undefined ? String(binding.opts.ttlDays) : "(worker default)",
+      help: `Per-session share lifetime. Overrides the config ttlDays for THIS session's pages; still capped by the server's MAX_TTL_DAYS and the token's maxTtlDays. Applied at the next create/attach.
+
+Current: ${binding?.opts?.ttlDays !== undefined ? `${binding.opts.ttlDays} days` : "(none \u2014 config default)"}`
+    });
+    rows.push({
+      title: "Session read auth",
+      value: "session:auth",
+      description: binding?.opts?.authLogin ? `${binding.opts.authLogin} / ****` : "(config default)",
+      help: `Login gate for THIS session's page only \u2014 viewers must log in (7-day cookie, lockout). Overrides the config read auth. Applied at the next create/attach; removing the login removes the gate.
+
+Current: ${binding?.opts?.authLogin ? `${binding.opts.authLogin} / (password set)` : "(none \u2014 config default applies)"}`
+    });
+    return rows;
+  };
+  const rowsFor = async (id) => {
+    switch (id) {
+      case "session":
+        return await sessionRows();
+      case "servers":
+        return serverRows();
+      case "sharing":
+        return keyRows("Sharing");
+      case "readauth":
+        return keyRows("Read auth");
+      case "interface":
+        return interfaceRows();
+      case "advanced":
+        return keyRows("Advanced");
+      case "configfiles":
+        return configRows();
+    }
+  };
+  const dispatch = async (choice) => {
+    if (choice === "action:target") {
+      const picked = await showSelect(host.ui, {
+        title: "Write target",
+        placeholder: "Files that already exist; the global home is always available",
+        options: candidates.map((candidate) => ({ title: candidate.label, value: candidate.path, description: candidate.path })),
+        current: writeTarget.path
+      });
+      if (picked)
+        writeTarget = candidates.find((candidate) => candidate.path === picked) ?? writeTarget;
+      return;
+    }
+    if (choice === "action:sources") {
+      await showInfo(host.ui, { title: "Where values come from", message: sourcesMessage(sources) });
+      return;
+    }
+    if (choice === "ui:size") {
+      if (host.ui.showSizePicker) {
+        const result = await host.ui.showSizePicker({ width: kvWidthOf(host.kv), heightPercent: kvHeightPercentOf(host.kv) });
+        if (result) {
+          host.kv.set(UI_WIDTH_KV, result.width);
+          host.kv.set(UI_HEIGHT_PERCENT_KV, clampHeightPercent(result.heightPercent));
+          host.ui.toast({ variant: "info", title: "OpenShare", message: `Menu size: ${result.width} \xB7 ${result.heightPercent}% of terminal.` });
+        }
+      } else {
+        const rawHeight = await showPrompt(host.ui, { title: "Menu height percent", placeholder: "25-100", value: String(kvHeightPercentOf(host.kv)) });
+        if (rawHeight !== undefined) {
+          const parsed = Number(rawHeight);
+          if (!Number.isFinite(parsed)) {
+            host.ui.toast({ variant: "error", title: "OpenShare", message: "Height must be a number from 25 to 100." });
+            return;
+          }
+          host.kv.set(UI_HEIGHT_PERCENT_KV, clampHeightPercent(parsed));
+          host.kv.set(UI_WIDTH_KV, nextDialogWidth(kvWidthOf(host.kv)));
+          host.ui.toast({ variant: "info", title: "OpenShare", message: `Menu size: ${kvWidthOf(host.kv)} \xB7 ${kvHeightPercentOf(host.kv)}%` });
+        }
+      }
+      return;
+    }
+    if (choice === "action:test") {
+      const serverUrl = serverEntries(cfg).find((s) => s.active)?.url ?? cfg.workerUrl;
+      host.ui.toast({ variant: "info", title: "OpenShare", message: "Testing server connection..." });
+      const result = await probeWorker(serverUrl);
+      await showInfo(host.ui, {
+        title: result.ok ? "Server reachable" : "Server unreachable",
+        message: `${serverUrl || "(no server set)"} \u2014 ${result.detail}${result.ok && !serverEntries(cfg).some((s) => s.entry.token) ? `
+Note: no token held \u2014 the plugin enrolls on first contact (public) or needs a code (private).` : ""}`
+      });
+      return;
+    }
+    if (choice === "server:add") {
+      const res = await connectServerFlow(host);
+      host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.message, duration: 1e4 });
+      if (res.ok)
+        cfg = currentConfig();
+      return;
+    }
+    if (choice.startsWith("server:")) {
+      await serverMenu(host, choice.slice(7));
+      cfg = currentConfig();
+      return;
+    }
+    if (choice.startsWith("key:")) {
+      const key = choice.slice(4);
+      const next = await editKey(host, cfg, key);
+      if (next) {
+        cfg = next;
+        dirty = true;
+        dirtyKeys.add(key);
+      }
+      return;
+    }
+    if (choice.startsWith("session:") && startAtSession) {
+      const root = await resolveRoot(host.client, startAtSession);
+      const current = await readBinding(host.client, root);
+      if (choice === "session:share") {
+        if (!isConfigured(cfg)) {
+          await showInfo(host.ui, { title: "Not configured", message: "Connect a server (Servers group) first, then share." });
+          return;
+        }
+        const result = await confirmShare(host, root);
+        host.ui.toast({ variant: result.ok ? "success" : "error", title: "OpenShare", message: result.message, duration: result.ok ? 8000 : 15000 });
+        return;
+      }
+      if (choice === "session:unshare") {
+        const how = await showSelect(host.ui, {
+          title: "Stop sharing",
+          options: [
+            { title: "Delete every page", value: "delete", description: "all links stop working", danger: true, help: "Deletes every bound server's page and clears the share flag. Viewers see a final gone state." },
+            { title: "Leave as-is (snapshot)", value: "leave", description: "stop updating; pages stay until their TTL", help: "Stops mirroring without deleting anything \u2014 pages stay readable as frozen snapshots until their TTL expires." },
+            { title: "Cancel", value: "__cancel" }
+          ]
+        });
+        if (how === undefined || how === "__cancel")
+          return;
+        if (how === "leave") {
+          const all = await readBindings(host.client, root);
+          const okPatch = await patchSessionBinding(host.client, root, (servers) => {
+            for (const b of all) {
+              if (!b.server)
+                continue;
+              delete servers[b.server];
+              servers[b.server] = { optedOut: true };
+            }
+          });
+          host.ui.toast({ variant: okPatch ? "success" : "error", title: "OpenShare", message: okPatch ? "Left as-is \u2014 snapshots until their TTLs." : "Could not update the binding." });
+          return;
+        }
+        const result = await runUnshareFlow(host, startAtSession);
+        host.ui.toast({ variant: result.ok ? "success" : "error", title: "OpenShare", message: result.message });
+        return;
+      }
+      if (choice === "session:ttl") {
+        const raw = await showPrompt(host.ui, { title: "Session TTL (days)", placeholder: "days", value: current?.opts?.ttlDays !== undefined ? String(current.opts.ttlDays) : "" });
+        if (raw === undefined)
+          return;
+        const opts = { ...current?.opts ?? {} };
+        if (raw === "")
+          delete opts.ttlDays;
+        else {
+          const days = Number(raw);
+          if (!Number.isFinite(days) || days <= 0) {
+            host.ui.toast({ variant: "error", title: "OpenShare", message: "TTL must be a positive number of days." });
+            return;
+          }
+          opts.ttlDays = Math.floor(days);
+        }
+        await setShareFlag(host.client, root, opts);
+        host.ui.toast({ variant: "success", title: "OpenShare", message: opts.ttlDays !== undefined ? `Session TTL: ${opts.ttlDays}d (applies at the next attach/create)` : "Session TTL override cleared" });
+        return;
+      }
+      if (choice === "session:auth") {
+        const login = await showPrompt(host.ui, { title: "Session read auth: login", placeholder: "empty = use config default", value: current?.opts?.authLogin ?? "" });
+        if (login === undefined)
+          return;
+        const password = await showPrompt(host.ui, { title: "Session read auth: password", placeholder: "empty = no password" });
+        if (password === undefined)
+          return;
+        const opts = { ...current?.opts ?? {} };
+        if (login === "") {
+          delete opts.authLogin;
+          delete opts.authPassword;
+        } else {
+          opts.authLogin = login;
+          if (password !== "")
+            opts.authPassword = password;
+          else
+            delete opts.authPassword;
+        }
+        await setShareFlag(host.client, root, opts);
+        host.ui.toast({ variant: "success", title: "OpenShare", message: "Session read auth saved (applies at the next attach/create)." });
+        return;
+      }
+    }
+  };
+  const groupMenu = async (id) => {
+    while (true) {
+      const rows = await rowsFor(id);
+      if (!rows.length)
+        return;
+      const options = [...rows, { title: "Back", value: "__back" }];
+      const choice = await showSelect(host.ui, { title: `OpenShare \u2014 ${GROUP_LABEL[id]}`, options });
+      if (choice === undefined || choice === "__back")
+        return;
+      await dispatch(choice);
+    }
+  };
+  const seconds = (ms, fallback) => `${Math.round((ms ?? fallback) / 100) / 10}s`;
+  while (true) {
+    const servers = serverEntries(cfg);
+    const active = servers.find((s) => s.active);
+    const uiWidth = kvWidthOf(host.kv);
+    const groups = [];
+    if (startAtSession) {
+      const binding = await readBinding(host.client, await resolveRoot(host.client, startAtSession));
+      const shared = binding?.url ? binding.enabled === false ? "attached (dormant)" : "live" : "not shared";
+      groups.push({
+        id: "session",
+        summary: shared,
+        help: `Per-session state and overrides for the session this dialog was opened on.
+
+Status: ${shared}${binding?.url ? `
+URL: ${binding.url}` : ""}
+
+Inside: share/stop sharing (delete or leave a snapshot), session TTL override, session read auth.`
+      });
+    }
+    groups.push({
+      id: "servers",
+      summary: servers.length ? `${servers.length} saved${active ? ` \xB7 active: ${hostOf(active.url)}` : " \xB7 none active"}${cfg.workerUrl ? " \xB7 legacy pair set" : ""}` : cfg.workerUrl ? `${hostOf(cfg.workerUrl)} \xB7 legacy pair` : "no server yet",
+      help: `Server connection, memberships, and admin \u2014 one place (owner: "we already do connection in servers, why was it separate").
+
+Inside: the legacy workerUrl + createToken pair, saved servers (enroll, rotate, disconnect, admin panel, test, remove), Connect to a server, Test connection.
+
+Every ACTIVE server receives new sessions (fan-out).`
+    });
+    groups.push({
+      id: "sharing",
+      summary: `sync ${seconds(cfg.debounceMs, 1e4)} \xB7 completed ${seconds(cfg.completedDelayMs, 5000)} \xB7 TTL ${cfg.ttlDays ?? "server cap"}`,
+      help: `What and how sessions stream: share mode (all/manual), sync cadence, the completed-delay, the model label on pages, share TTL, and the viewer's task-tab behavior.
+
+Cadence values are clamped by the server's policy window.`
+    });
+    groups.push({
+      id: "readauth",
+      summary: cfg.authLogin ? `${cfg.authLogin} / ****` : "none set",
+      help: `Optional login gate for NEW share pages: viewers must enter login+password (PBKDF2 server-side, 7-day cookie, lockout after failures). Per-session overrides live in This session.
+
+Write access is a separate lock \u2014 a login never lets anyone edit.`
+    });
+    groups.push({
+      id: "interface",
+      summary: `${uiWidth} (${DIALOG_WIDTH_COLUMNS[uiWidth]} cols) \xB7 ${kvHeightPercentOf(host.kv)}% height`,
+      help: `OpenShare menu sizing: width (opencode's fixed dialog widths: 60/88/116 columns) and height (a percent of terminal rows, presets compact/normal/tall/max).
+
+Stored in the host's preference store \u2014 per machine, not the config file.`
+    });
+    groups.push({
+      id: "advanced",
+      summary: "spool dir \xB7 url file \xB7 stderr",
+      help: `Rarely-touched plumbing: the un-acked frame spool directory, the all-mode URL file (append log for CI), and the stderr announce lines.`
+    });
+    groups.push({
+      id: "configfiles",
+      summary: `write: ${writeTarget.label}`,
+      help: `Which file Save & exit writes (global settings home by default; other existing files selectable) and the per-key source map of the current read chain (env > options > adjacent > local > home > defaults).`
+    });
+    const options = groups.map((group) => ({
+      title: GROUP_LABEL[group.id],
+      value: `group:${group.id}`,
+      description: group.summary,
+      help: group.help
+    }));
+    options.push({ title: dirty ? "Save & exit" : "Exit", value: "action:exit", description: dirty ? `Write ${writeTarget.path}` : "No changes" });
+    const choice = await showSelect(host.ui, { title: "OpenShare settings", options });
+    if (choice === undefined || choice === "action:exit") {
+      if (dirty) {
+        const saved = saveConfig(cfg, writeTarget.path);
+        if (saved)
+          host.ui.toast({ variant: "success", title: "OpenShare", message: `Saved ${saved.path}` });
+        else
+          host.ui.toast({ variant: "error", title: "OpenShare", message: `Could not write ${writeTarget.path}.` });
+      }
+      host.ui.dialog.clear();
+      return;
+    }
+    if (choice.startsWith("group:")) {
+      const id = choice.slice(6);
+      if (GROUP_LABEL[id])
+        await groupMenu(id);
+    }
+  }
+}
+async function onboardingDialog(host) {
+  const ok = await showConfirm(host.ui, {
+    title: "Welcome to Open(code)Share",
+    message: `Sharing needs a share server.
+Connect now (URL + access code if the hoster gave you one), or open the full settings?`,
+    confirmLabel: "Connect to a server"
+  });
+  if (ok) {
+    const res = await connectServerFlow(host);
+    host.ui.dialog.clear();
+    host.ui.toast({ variant: res.ok ? "success" : "error", title: "OpenShare", message: res.message, duration: 1e4 });
+    if (!res.ok)
+      await settingsDialog(host);
+  } else {
+    await settingsDialog(host);
+  }
+}
+
+// src/commands.ts
+init_sidebar();
+var PALETTE_CATEGORY = "OpenShare";
+function finish(host, result) {
+  try {
+    host.ui.dialog.clear();
+  } catch {}
+  host.ui.toast({
+    variant: result.ok ? "success" : result.unconfigured ? "warning" : "error",
+    title: "OpenShare",
+    message: result.message,
+    duration: result.ok ? 8000 : 15000
+  });
+}
+async function showShareManager(host, sessionID) {
+  const sid = sessionID();
+  if (!sid)
+    return;
+  const root = await resolveRoot(host.client, sid);
+  let all = await readBindings(host.client, root);
+  const collided = all.find((b) => b.collided);
+  if (collided)
+    return showCollisionDialog(host, root, collided.server, collided.id, collided.collided ?? "");
+  const live = all.filter((b) => b.url && b.enabled !== false && b.id);
+  if (live.length) {
+    const verdicts = await Promise.all(live.map((b) => verifyShare(b.server, b.id)));
+    const gone = live.filter((b, i) => verdicts[i] === "gone");
+    if (gone.length) {
+      await clearGoneBindingEntries(host, root, gone.map((b) => b.server));
+      all = all.filter((b) => !gone.some((g) => g.server === b.server));
+      const list = gone.map((b) => `\u2022 ${hostOf(b.url || b.server)} \u2014 ${b.url}`).join(`
+`);
+      const choice2 = await host.ui.showMenu({
+        title: "Share is gone",
+        hint: "The page was removed, expired, or purged on the server \u2014 sharing disabled for it.",
+        options: [
+          { title: "Share again", value: "again", description: "create a fresh page with the full history", help: `The stale binding was already cleared. Sharing again creates a brand-new page on the ACTIVE server with this session's full history backfilled.
+
+Gone:
+${list}` },
+          { title: "Close", value: "close", description: "leave the session unshared", help: `The stale binding entries were cleared automatically; the session is not shared anymore. Run /share any time to share it fresh.
+
+Gone:
+${list}` }
+        ]
+      });
+      if (choice2 === "again") {
+        finish(host, await runShareFlow(host, sid));
+        return;
+      }
+      if (all.length === 0)
+        return;
+    }
+  }
+  if (all.length === 0)
+    return;
+  const otherServers = serverEntries().filter((s) => !all.some((b) => b.server === s.url));
+  if (all.length === 1 && otherServers.length === 0) {
+    const b = all[0];
+    host.ui.showMenu({
+      title: "Session is shared",
+      hint: b.url,
+      options: [
+        {
+          title: "Copy share link",
+          value: "copy",
+          description: "copy the share URL to the clipboard",
+          help: `Copies the share URL to the clipboard (navigator + OSC52 fallback).
+
+URL: ${b.url}
+Server: ${b.server}
+Share id: ${b.id}
+
+Anyone with the link can read the page (plus the login, if read auth is set).`
+        },
+        {
+          title: "Stop sharing",
+          value: "stop",
+          description: "Delete the share page \u2014 the link stops working for everyone",
+          help: `Deletes the page on ${hostOf(b.url || b.server)} server-side and clears this session's share flag. Viewers with the link see a final "gone" state. This cannot be undone \u2014 sharing again creates a NEW page with a new URL.`
+        },
+        { title: "Cancel", value: "cancel" }
+      ]
+    }).then(async (choice2) => {
+      if (choice2 === "copy") {
+        const ok = await host.clipboard.write(b.url);
+        finish(host, ok ? { ok: true, message: `Share URL copied to clipboard: ${b.url}`, url: b.url } : { ok: false, message: `Could not write the clipboard \u2014 link: ${b.url}`, url: b.url });
+        return;
+      }
+      if (choice2 === "stop") {
+        const how = await host.ui.showMenu({
+          title: "Stop sharing",
+          hint: b.url,
+          options: [
+            {
+              title: "Delete the page",
+              value: "delete",
+              description: "the link stops working for everyone",
+              danger: true,
+              help: `Deletes the page on ${hostOf(b.url || b.server)} and clears this session's share flag. Viewers with the link see a final "gone" state. Sharing again later creates a fresh page with a new URL.`
+            },
+            {
+              title: "Leave as-is (snapshot)",
+              value: "leave",
+              description: "stop updating; the page stays until its TTL",
+              help: `Stops mirroring WITHOUT deleting anything \u2014 viewers keep reading the snapshot until the share's TTL expires. Useful for handing someone a frozen copy while you keep working.`
+            },
+            { title: "Cancel", value: "cancel" }
+          ]
+        });
+        if (!how || how === "cancel")
+          return;
+        if (how === "leave") {
+          await patchSessionBinding(host.client, root, (servers) => {
+            delete servers[b.server];
+            servers[b.server] = { optedOut: true };
+          });
+          finish(host, { ok: true, message: `${hostOf(b.url || b.server)} left as-is \u2014 a snapshot until its TTL.` });
+          return;
+        }
+        const yes = await host.ui.showConfirm({
+          title: "Delete the share page",
+          message: `Delete the page on ${hostOf(b.url || b.server)}?
+The link stops working for everyone.`,
+          confirmLabel: "Delete",
+          danger: true
+        });
+        if (!yes) {
+          host.ui.dialog.clear();
+          return;
+        }
+        finish(host, await runUnshareFlow(host, sessionID()));
+      }
+    });
+    return;
+  }
+  const options = all.map((b) => ({
+    title: `Copy link \u2014 ${hostOf(b.url || b.server)}`,
+    value: `copy:${b.server}`,
+    description: b.url,
+    help: `Copies this server's share URL to the clipboard.
+
+URL: ${b.url}
+Server: ${b.server}
+Share id: ${b.id}
+
+Each server carries an independent page of the same session.`
+  }));
+  options.push({
+    title: "Manage per server\u2026",
+    value: "manage",
+    description: `${all.length} servers \u2014 stop one, leave a snapshot`,
+    help: `Per-server actions: copy the link, stop sharing there (page deleted), or leave it as a read-only snapshot (updates stop, the page lives out its TTL). Other servers are unaffected.
+
+Bound servers:
+${all.map((b) => `\u2022 ${b.server} \u2014 ${b.url}`).join(`
+`)}`
+  });
+  if (otherServers.length) {
+    options.push({
+      title: "Share to another server\u2026",
+      value: "more",
+      description: otherServers.map((s) => hostOf(s.url)).join(", "),
+      help: `Adds one of your other configured servers as a destination for THIS session: it becomes the active server and the full history is mirrored there within seconds.
+
+Available:
+${otherServers.map((s) => `\u2022 ${s.url}`).join(`
+`)}`
+    });
+  }
+  options.push({
+    title: "Stop sharing (all)",
+    value: "stop-all",
+    description: "delete every server's page, or leave snapshots",
+    danger: true,
+    help: `Deletes the page on all ${all.length} servers (or leaves them as read-only snapshots \u2014 your choice on the next screen) and clears the share flag. Sharing again creates fresh pages.`
+  });
+  options.push({ title: "Cancel", value: "cancel" });
+  const choice = await host.ui.showMenu({ title: `Session is shared \xB7 ${all.length} servers`, options });
+  if (!choice || choice === "cancel")
+    return;
+  if (choice.startsWith("copy:")) {
+    const b = all.find((x) => `copy:${x.server}` === choice);
+    if (b) {
+      const ok = await host.clipboard.write(b.url);
+      finish(host, ok ? { ok: true, message: `Share URL copied: ${b.url}`, url: b.url } : { ok: false, message: `Clipboard failed \u2014 ${b.url}`, url: b.url });
+    }
+    return;
+  }
+  if (choice === "stop-all") {
+    const how = await host.ui.showMenu({
+      title: `Stop sharing \xB7 ${all.length} servers`,
+      options: [
+        { title: "Delete every page", value: "delete", description: "all links stop working", danger: true, help: `Deletes the page on every bound server (${all.map((b) => hostOf(b.url || b.server)).join(", ")}) and clears the share flag.` },
+        { title: "Leave all as-is (snapshots)", value: "leave", description: "stop updating; pages stay until their TTLs", help: `Stops mirroring everywhere without deleting anything \u2014 every page stays readable as a frozen snapshot until its TTL expires.` },
+        { title: "Cancel", value: "cancel" }
+      ]
+    });
+    if (!how || how === "cancel")
+      return;
+    if (how === "leave") {
+      await patchSessionBinding(host.client, root, (servers) => {
+        for (const b of all) {
+          delete servers[b.server];
+          servers[b.server] = { optedOut: true };
+        }
+      });
+      finish(host, { ok: true, message: `${all.length} server(s) left as-is \u2014 snapshots until their TTLs.` });
+      return;
+    }
+    const yes = await host.ui.showConfirm({
+      title: "Stop sharing",
+      message: `Delete the share pages on all ${all.length} servers? The links stop working for everyone.`,
+      confirmLabel: "Stop all",
+      danger: true
+    });
+    if (!yes)
+      return;
+    finish(host, await runUnshareFlow(host, sessionID()));
+    return;
+  }
+  if (choice === "more") {
+    const pick = await host.ui.showMenu({
+      title: "Share to another server",
+      options: [...otherServers.map((s) => ({ title: hostOf(s.url), value: s.url, description: s.entry.label })), { title: "Cancel", value: "__cancel" }]
+    });
+    if (!pick || pick === "__cancel")
+      return;
+    const { saveServerEntry: saveServerEntry2 } = await Promise.resolve().then(() => (init_share_flow(), exports_share_flow));
+    for (const s of serverEntries())
+      if (s.url !== pick)
+        saveServerEntry2(s.url, { active: undefined });
+    saveServerEntry2(pick, { active: true });
+    finish(host, { ok: true, message: `${hostOf(pick)} activated \u2014 this session mirrors there within seconds (new sessions share to it too).` });
+    return;
+  }
+  if (choice === "manage") {
+    const pick = await host.ui.showMenu({
+      title: "Manage server",
+      options: [...all.map((b2) => ({ title: hostOf(b2.url || b2.server), value: b2.server, description: b2.url })), { title: "Cancel", value: "__cancel" }]
+    });
+    if (!pick || pick === "__cancel")
+      return;
+    const b = all.find((x) => x.server === pick);
+    if (!b)
+      return;
+    const action = await host.ui.showMenu({
+      title: `${hostOf(b.url || b.server)}`,
+      hint: b.url,
+      options: [
+        {
+          title: "Copy link",
+          value: "copy",
+          description: "copy the share URL",
+          help: `Copies this server's share URL to the clipboard.
+
+URL: ${b.url}
+Share id: ${b.id}`
+        },
+        {
+          title: "Stop sharing here",
+          value: "stop",
+          description: "delete THIS server's page; other servers unaffected",
+          help: `Deletes the page on ${hostOf(b.url || b.server)} and retires this server for the session (the engine stops mirroring here). Other servers keep streaming. Sharing here again later creates a new page.`
+        },
+        {
+          title: "Leave as-is (snapshot)",
+          value: "leave",
+          description: "stop updating it; the page stays until its TTL",
+          help: `Stops mirroring to ${hostOf(b.url || b.server)} WITHOUT deleting anything \u2014 viewers keep reading the snapshot until the share's TTL expires. Useful for handing someone a frozen copy while you keep working.`
+        },
+        { title: "Cancel", value: "cancel" }
+      ]
+    });
+    if (!action || action === "cancel")
+      return;
+    if (action === "copy") {
+      const ok = await host.clipboard.write(b.url);
+      finish(host, ok ? { ok: true, message: `Share URL copied: ${b.url}`, url: b.url } : { ok: false, message: `Clipboard failed \u2014 ${b.url}`, url: b.url });
+      return;
+    }
+    if (action === "stop") {
+      const deleted = await workerDeleteShare(b.server || b.url.slice(0, b.url.indexOf("/s/")), b.id, b.secret);
+      await patchSessionBinding(host.client, root, (servers) => {
+        delete servers[b.server];
+        servers[b.server] = { optedOut: true };
+      });
+      finish(host, { ok: true, message: deleted ? `Stopped sharing on ${hostOf(b.url || b.server)} \u2014 page deleted.` : `Stopped sharing on ${hostOf(b.url || b.server)} (page deletion follows via the sweeper).` });
+      return;
+    }
+    if (action === "leave") {
+      await patchSessionBinding(host.client, root, (servers) => {
+        delete servers[b.server];
+        servers[b.server] = { optedOut: true };
+      });
+      finish(host, { ok: true, message: `${hostOf(b.url || b.server)} left as-is \u2014 a snapshot until its TTL.` });
+      return;
+    }
+  }
+}
+async function showCollisionDialog(host, root, server, shareId, error) {
+  const debugInfo = JSON.stringify({ server, shareId, error, sessionID: root, plugin: "openshare", time: new Date().toISOString() }, null, 2);
+  const choice = await host.ui.showMenu({
+    title: `Share conflict \u2014 ${hostOf(server)}`,
+    hint: `saved credentials for ${shareId.slice(0, 12)}\u2026 were rejected (${error})`,
+    options: [
+      {
+        title: "Copy debug info",
+        value: "debug",
+        description: "server, share id, error \u2014 for the hoster or an issue report",
+        help: `Copies a JSON blob with the server, share id, exact error, and session id \u2014 attach it when reporting to the hoster or filing an issue.
+
+${debugInfo}`
+      },
+      {
+        title: "Share on a new share",
+        value: "new",
+        description: "abandon the old binding; create a fresh share with full history",
+        help: `Drops the rejected binding and lets the engine create a brand-new share on ${hostOf(server)} with the session's full history. The old page (whoever owns it now) is left untouched.`
+      },
+      {
+        title: "Don't share here",
+        value: "no",
+        description: "leave the old page; this server stops receiving this session",
+        help: `Opts this session out on ${hostOf(server)}: the engine stops trying to attach. The rejected page stays as-is. Re-share here anytime via "Share to another server".`
+      },
+      { title: "Cancel", value: "cancel" }
+    ]
+  });
+  if (!choice || choice === "cancel")
+    return;
+  if (choice === "debug") {
+    const ok = await host.clipboard.write(debugInfo);
+    finish(host, ok ? { ok: true, message: "Debug info copied to clipboard." } : { ok: false, message: `Clipboard failed:
+${debugInfo}` });
+    return;
+  }
+  if (choice === "new") {
+    await patchSessionBinding(host.client, root, (servers) => {
+      delete servers[server];
+    });
+    finish(host, { ok: true, message: `Re-sharing on ${hostOf(server)} \u2014 a new share appears within seconds.` });
+    return;
+  }
+  if (choice === "no") {
+    await patchSessionBinding(host.client, root, (servers) => {
+      delete servers[server];
+      servers[server] = { optedOut: true };
+    });
+    finish(host, { ok: true, message: `${hostOf(server)} opted out for this session.` });
+  }
+}
+function buildShareCommand(host, sessionID) {
+  return {
+    name: "session.share",
+    title: "Share session (re:share)",
+    desc: "Share this session via openshare; on a shared session: copy the link or stop sharing",
+    slashName: "share",
+    slashAliases: ["reshare"],
+    category: PALETTE_CATEGORY,
+    group: PALETTE_CATEGORY,
+    run: async () => {
+      dbgLog(`/share run: entered (sid=${sessionID() ?? "none"})`);
+      host.ui.dialog.clear();
+      const cfg = currentConfig();
+      if (!isConfigured(cfg)) {
+        onboardingDialog(host);
+        return;
+      }
+      const sid = sessionID();
+      if (!sid) {
+        finish(host, { ok: false, message: "No active session to share." });
+        return;
+      }
+      const root = await resolveRoot(host.client, sid);
+      const bindings = await readBindings(host.client, root);
+      const binding = bindings[0];
+      dbgLog(`/share gate: sid=${sid} root=${root} bindings=${bindings.length}`);
+      if (bindings.some((b) => b.url && b.enabled !== false)) {
+        await showShareManager(host, sessionID);
+        host.ui.dialog.clear();
+        return;
+      }
+      const result = await runShareFlow(host, sid);
+      if (result.message === "consent required") {
+        const yes = await host.ui.showConfirm({
+          title: "Share Session",
+          message: `Publish this session (and its subagent sessions) to your openshare worker?
+The link lets anyone with it read the conversation.`,
+          confirmLabel: "Share"
+        });
+        if (!yes)
+          return;
+        try {
+          host.kv.set(CONSENT_KV_KEY, true);
+          dbgLog("consent kv.set ok");
+        } catch (e) {
+          dbgLog(`consent kv.set THREW: ${e?.message ?? e}`);
+        }
+        try {
+          finish(host, await confirmShare(host, root));
+        } catch (e) {
+          dbgLog(`confirmShare rejected: ${e?.stack ?? e}`);
+          finish(host, { ok: false, message: "Share failed (see debug log)." });
+        }
+        return;
+      }
+      finish(host, result);
+    }
+  };
+}
+function buildSettingsCommand(host, sessionID) {
+  return {
+    name: "openshare.settings",
+    title: "OpenShare: Settings",
+    desc: "Worker connection, sharing defaults, read auth, this session",
+    slashName: "openshare",
+    category: PALETTE_CATEGORY,
+    group: PALETTE_CATEGORY,
+    run: async () => {
+      host.ui.dialog.clear();
+      await settingsDialog(host, sessionID());
+    }
+  };
+}
+function registerCommands(host, sessionID) {
+  return host.keymap.registerLayer({
+    commands: [buildShareCommand(host, sessionID), buildSettingsCommand(host, sessionID)],
+    bindings: []
+  });
+}
+
+// src/tui.tsx
+init_sidebar();
+
+// src/dialogs.tsx
+init_sidebar();
+import { use as _$use } from "@opentui/solid";
+import { effect as _$effect2 } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode2 } from "@opentui/solid";
+import { insert as _$insert2 } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { setProp as _$setProp2 } from "@opentui/solid";
+import { createElement as _$createElement2 } from "@opentui/solid";
+import { createEffect, createMemo, createSignal, For, onCleanup, Show } from "solid-js";
+import { useTerminalDimensions } from "@opentui/solid";
+var blockKey = (ctx) => {
+  ctx?.event?.preventDefault?.();
+  ctx?.event?.stopPropagation?.();
+};
+var SHIELDED_KEYS = [..."abcdefghijklmnopqrstuvwxyz".split(""), ..."0123456789".split(""), "space", "tab", "backspace", "delete", "home", "end", "left", "right", "/", "?", ":", ";", "'", '"', ",", ".", "-", "=", "[", "]", "\\", "`"];
+function shieldBindings(command, except = []) {
+  const allowed = new Set(except);
+  return SHIELDED_KEYS.filter((key) => !allowed.has(key)).map((key) => ({
+    key,
+    cmd: command,
+    desc: "Keep input inside OpenShare"
+  }));
+}
+function collectEditors(root) {
+  const children = root.getChildren?.() ?? [];
+  return [...root.showCursor !== undefined ? [root] : [], ...children.flatMap((child) => collectEditors(child))];
+}
+function useHidePromptCursor(api) {
+  const editors = collectEditors(api.renderer.root);
+  const previous = editors.map((editor) => ({
+    editor,
+    showCursor: editor.showCursor
+  }));
+  for (const editor of editors) {
+    editor.showCursor = false;
+  }
+  onCleanup(() => {
+    for (const item of previous) {
+      if (item.editor.isDestroyed)
+        continue;
+      item.editor.showCursor = item.showCursor;
+    }
+  });
+}
+var HEIGHT_PRESETS = [{
+  label: "compact",
+  value: 35,
+  key: "1"
+}, {
+  label: "normal",
+  value: 50,
+  key: "2"
+}, {
+  label: "tall",
+  value: 70,
+  key: "3"
+}, {
+  label: "max",
+  value: 100,
+  key: "4"
+}];
+function dialogWidthOf(api) {
+  return kvWidthOf(api.kv);
+}
+function dialogHeightPercentOf(api) {
+  return kvHeightPercentOf(api.kv);
+}
+function dialogMetrics(api, terminalHeight, chromeRows, minRows) {
+  const percent = dialogHeightPercentOf(api);
+  const backdropBudget = Math.max(minRows + chromeRows, Math.floor(terminalHeight * 0.75) - 1);
+  const available = Math.max(minRows, backdropBudget - chromeRows);
+  const requested = Math.max(minRows, Math.floor(terminalHeight * percent / 100) - chromeRows);
+  return {
+    availableRows: available,
+    targetRows: Math.min(requested, available)
+  };
+}
+function maxRows(api, terminalHeight, chromeRows, minRows) {
+  return dialogMetrics(api, terminalHeight, chromeRows, minRows).targetRows;
+}
+function dialogContentWidth(api) {
+  const width = dialogWidthOf(api);
+  return (width === "xlarge" ? 116 : width === "large" ? 88 : 60) - 8;
+}
+function useDialogSize(api) {
+  createEffect(() => {
+    try {
+      api.ui.dialog.setSize(dialogWidthOf(api));
+    } catch {}
+  });
+}
+function cappedHeight(count, max, min = 1) {
+  if (count <= 0)
+    return min;
+  return Math.max(min, Math.min(count, max));
+}
+function preWrap(text, width) {
+  const out = [];
+  for (const raw of text.split(/\r?\n/)) {
+    if (raw.length === 0) {
+      out.push("");
+      continue;
+    }
+    let line = "";
+    for (const word of raw.split(" ")) {
+      const candidate = line.length === 0 ? word : `${line} ${word}`;
+      if (candidate.length <= width) {
+        line = candidate;
+        continue;
+      }
+      if (line.length > 0)
+        out.push(line);
+      line = "";
+      let token = word;
+      while (token.length > width) {
+        out.push(token.slice(0, width));
+        token = token.slice(width);
+      }
+      line = token;
+    }
+    if (line.length > 0)
+      out.push(line);
+  }
+  return out;
+}
+function infoLineAttrs(line) {
+  if (line.length === 0)
+    return {
+      fg: "muted",
+      bold: false
+    };
+  const heading = !line.startsWith(" ") && (line.endsWith(":") || /^[A-Z][A-Za-z0-9 ._-]+$/.test(line));
+  if (/error|failed|refus|invalid|gone|danger|purge|delete/i.test(line))
+    return {
+      fg: "warning",
+      bold: false
+    };
+  if (/saved|enrolled|connected|active|live|success|token saved/i.test(line))
+    return {
+      fg: "positive",
+      bold: false
+    };
+  if (heading)
+    return {
+      fg: "heading",
+      bold: true
+    };
+  return {
+    fg: "muted",
+    bold: false
+  };
+}
+function InfoLines(props) {
+  const theme = () => props.api.theme.current;
+  const colorOf = (kind) => kind === "warning" ? theme().error : kind === "positive" ? theme().success : kind === "heading" ? theme().accent : theme().text;
+  return (() => {
+    var _el$ = _$createElement2("box");
+    _$setProp2(_el$, "flexDirection", "column");
+    _$setProp2(_el$, "gap", 0);
+    _$insert2(_el$, _$createComponent(For, {
+      get each() {
+        return props.lines;
+      },
+      children: (line) => {
+        const attrs = infoLineAttrs(line);
+        return line.length === 0 ? (() => {
+          var _el$2 = _$createElement2("text");
+          _$insertNode2(_el$2, _$createTextNode(` `));
+          return _el$2;
+        })() : (() => {
+          var _el$4 = _$createElement2("text");
+          _$setProp2(_el$4, "wrapMode", "none");
+          _$insert2(_el$4, (() => {
+            var _c$ = _$memo(() => !!attrs.bold);
+            return () => _c$() ? (() => {
+              var _el$5 = _$createElement2("b");
+              _$insert2(_el$5, line);
+              return _el$5;
+            })() : line;
+          })());
+          _$effect2((_$p) => _$setProp2(_el$4, "fg", colorOf(attrs.fg), _$p));
+          return _el$4;
+        })();
+      }
+    }));
+    return _el$;
+  })();
+}
+function menuTitleWidth(width, options) {
+  const longest = Math.max(0, ...options.map((option) => option.title.length)) + 2;
+  if (width === "xlarge")
+    return Math.min(Math.max(20, longest), 28);
+  if (width === "large")
+    return Math.min(Math.max(18, longest), 24);
+  return Math.min(Math.max(16, longest), 20);
+}
+function ellipsize(text, width) {
+  return text.length > width ? `${text.slice(0, Math.max(1, width - 1))}\u2026` : text;
+}
+function DialogFrame(props) {
+  const theme = () => props.api.theme.current;
+  return (() => {
+    var _el$6 = _$createElement2("box"), _el$7 = _$createElement2("box"), _el$8 = _$createElement2("text"), _el$9 = _$createElement2("b"), _el$0 = _$createElement2("box");
+    _$insertNode2(_el$6, _el$7);
+    _$insertNode2(_el$6, _el$0);
+    _$setProp2(_el$6, "flexDirection", "column");
+    _$setProp2(_el$6, "width", "100%");
+    _$setProp2(_el$6, "paddingLeft", 2);
+    _$setProp2(_el$6, "paddingRight", 2);
+    _$insertNode2(_el$7, _el$8);
+    _$setProp2(_el$7, "width", "100%");
+    _$setProp2(_el$7, "marginBottom", 1);
+    _$insertNode2(_el$8, _el$9);
+    _$insert2(_el$9, () => props.title);
+    _$setProp2(_el$0, "width", "100%");
+    _$setProp2(_el$0, "height", 1);
+    _$setProp2(_el$0, "marginBottom", 1);
+    _$insert2(_el$6, () => props.children, null);
+    _$effect2((_p$) => {
+      var _v$ = theme().accent, _v$2 = theme().accent;
+      _v$ !== _p$.e && (_p$.e = _$setProp2(_el$8, "fg", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp2(_el$0, "backgroundColor", _v$2, _p$.t));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined
+    });
+    return _el$6;
+  })();
+}
+function KeyLegend(props) {
+  const theme = () => props.api.theme.current;
+  return (() => {
+    var _el$1 = _$createElement2("box");
+    _$setProp2(_el$1, "flexDirection", "row");
+    _$setProp2(_el$1, "gap", 1);
+    _$setProp2(_el$1, "paddingTop", 1);
+    _$setProp2(_el$1, "paddingLeft", 1);
+    _$setProp2(_el$1, "alignItems", "center");
+    _$insert2(_el$1, _$createComponent(For, {
+      get each() {
+        return props.keys;
+      },
+      children: (pair, index) => [(() => {
+        var _el$10 = _$createElement2("box"), _el$11 = _$createElement2("text"), _el$12 = _$createElement2("b");
+        _$insertNode2(_el$10, _el$11);
+        _$setProp2(_el$10, "paddingLeft", 1);
+        _$setProp2(_el$10, "paddingRight", 1);
+        _$setProp2(_el$10, "onMouseUp", () => {
+          if (pair[0] === "esc")
+            props.onBack?.();
+        });
+        _$insertNode2(_el$11, _el$12);
+        _$insert2(_el$12, () => pair[0]);
+        _$effect2((_p$) => {
+          var _v$3 = theme().backgroundPanel, _v$4 = theme().accent;
+          _v$3 !== _p$.e && (_p$.e = _$setProp2(_el$10, "backgroundColor", _v$3, _p$.e));
+          _v$4 !== _p$.t && (_p$.t = _$setProp2(_el$11, "fg", _v$4, _p$.t));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined
+        });
+        return _el$10;
+      })(), (() => {
+        var _el$13 = _$createElement2("text");
+        _$insert2(_el$13, () => pair[1]);
+        _$effect2((_$p) => _$setProp2(_el$13, "fg", theme().textMuted, _$p));
+        return _el$13;
+      })(), _$createComponent(Show, {
+        get when() {
+          return index() < props.keys.length - 1;
+        },
+        get children() {
+          var _el$14 = _$createElement2("text");
+          _$insertNode2(_el$14, _$createTextNode(`\xB7`));
+          _$effect2((_$p) => _$setProp2(_el$14, "fg", theme().textMuted, _$p));
+          return _el$14;
+        }
+      })]
+    }));
+    return _el$1;
+  })();
+}
+function MenuDialog(props) {
+  const theme = () => props.api.theme.current;
+  useDialogSize(props.api);
+  useHidePromptCursor(props.api);
+  const dimensions = useTerminalDimensions();
+  const listHeight = createMemo(() => cappedHeight(props.options.length, maxRows(props.api, dimensions().height, 12, 4), 4));
+  const width = dialogWidthOf(props.api);
+  const titleWidth = createMemo(() => menuTitleWidth(width, props.options));
+  const hasHelp = createMemo(() => props.options.some((option) => option.help));
+  const hintLines = createMemo(() => props.hint ? preWrap(props.hint, dialogContentWidth(props.api)) : []);
+  const [inspecting, setInspecting] = createSignal(false);
+  let listScroll;
+  let infoScroll;
+  const popMode = props.api.mode.push("openshare.dialog");
+  const [selected, setSelected] = createSignal((() => {
+    const initial = Math.max(0, props.options.findIndex((option) => option.value === props.current));
+    let index = initial;
+    while (index < props.options.length && props.options[index]?.divider)
+      index++;
+    return index < props.options.length ? index : initial;
+  })());
+  const current = createMemo(() => props.options[selected()] ?? props.options[0]);
+  const move = (delta) => setSelected((value) => {
+    let next = Math.max(0, Math.min(props.options.length - 1, value + delta));
+    while (next >= 0 && next < props.options.length && props.options[next]?.divider)
+      next += delta >= 0 ? 1 : -1;
+    if (next < 0 || next >= props.options.length || props.options[next]?.divider)
+      return value;
+    listScroll?.scrollTo(Math.max(0, next - 2));
+    return next;
+  });
+  const helpSections = createMemo(() => {
+    const raw = current()?.help ?? "";
+    const sections = [{
+      title: "",
+      lines: []
+    }];
+    for (const line of raw.split(/\r?\n/)) {
+      const match = /^##\s+(.*)$/.exec(line);
+      if (match)
+        sections.push({
+          title: match[1],
+          lines: []
+        });
+      else
+        sections.at(-1)?.lines.push(line);
+    }
+    for (const section2 of sections) {
+      while (section2.lines.length && section2.lines.at(-1) === "")
+        section2.lines.pop();
+      while (section2.lines.length && section2.lines[0] === "")
+        section2.lines.shift();
+    }
+    const contentWidth = dialogContentWidth(props.api) - 2;
+    return sections.filter((section2, index) => index === 0 ? section2.lines.length > 0 : true).map((section2) => ({
+      title: section2.title,
+      lines: preWrap(section2.lines.join(`
+`), contentWidth)
+    }));
+  });
+  const infoHeight = createMemo(() => cappedHeight(helpSections().reduce((rows, section2) => rows + section2.lines.length + (section2.title ? 2 : 0), 0) + 1, maxRows(props.api, dimensions().height, 8, 4), 4));
+  const [section, setSection] = createSignal(0);
+  const jumpSection = (delta) => {
+    const count = helpSections().length;
+    if (count <= 1)
+      return;
+    const next = (section() + delta + count) % count;
+    setSection(next);
+    infoScroll?.scrollTo(0);
+  };
+  const vertical = (delta) => {
+    if (inspecting())
+      infoScroll?.scrollBy(delta);
+    else
+      move(delta);
+  };
+  const page = (delta) => {
+    if (inspecting())
+      infoScroll?.scrollBy(delta * Math.max(1, (infoScroll?.height ?? infoHeight()) - 1));
+  };
+  const choose = () => {
+    const option = current();
+    if (!option || option.disabled || option.divider)
+      return;
+    props.onDone(option.value);
+  };
+  const inspect = () => {
+    const option = current();
+    if (!option || !option.help)
+      return;
+    setInspecting(true);
+    setSection(0);
+    infoScroll?.scrollTo(0);
+  };
+  const commandPrefix = `openshare.menu.${Math.random().toString(36).slice(2)}`;
+  const sectionJumpBindings = () => helpSections().length > 1 ? [{
+    key: "p",
+    cmd: `${commandPrefix}.prevSection`,
+    desc: "Previous section"
+  }, {
+    key: "n",
+    cmd: `${commandPrefix}.nextSection`,
+    desc: "Next section"
+  }, ...helpSections().slice(0, 9).map((_, index) => ({
+    key: String(index + 1),
+    cmd: `${commandPrefix}.jump${index + 1}`,
+    desc: `Section ${index + 1}`
+  }))] : [];
+  const unregister = props.api.keymap.registerLayer({
+    priority: 1e4,
+    commands: [{
+      name: `${commandPrefix}.up`,
+      title: "Previous item",
+      run: (ctx) => {
+        blockKey(ctx);
+        vertical(-1);
+      }
+    }, {
+      name: `${commandPrefix}.down`,
+      title: "Next item",
+      run: (ctx) => {
+        blockKey(ctx);
+        vertical(1);
+      }
+    }, {
+      name: `${commandPrefix}.pageUp`,
+      title: "Page up",
+      run: (ctx) => {
+        blockKey(ctx);
+        page(-1);
+      }
+    }, {
+      name: `${commandPrefix}.pageDown`,
+      title: "Page down",
+      run: (ctx) => {
+        blockKey(ctx);
+        page(1);
+      }
+    }, {
+      name: `${commandPrefix}.home`,
+      title: "Top",
+      run: (ctx) => {
+        blockKey(ctx);
+        if (inspecting())
+          infoScroll?.scrollTo(0);
+      }
+    }, {
+      name: `${commandPrefix}.end`,
+      title: "Bottom",
+      run: (ctx) => {
+        blockKey(ctx);
+        if (inspecting())
+          infoScroll?.scrollTo(infoScroll.scrollHeight);
+      }
+    }, {
+      name: `${commandPrefix}.select`,
+      title: "Select item",
+      run: (ctx) => {
+        blockKey(ctx);
+        if (inspecting())
+          setInspecting(false);
+        else
+          choose();
+      }
+    }, {
+      name: `${commandPrefix}.inspect`,
+      title: "Option info",
+      run: (ctx) => {
+        blockKey(ctx);
+        if (!inspecting())
+          inspect();
+      }
+    }, {
+      name: `${commandPrefix}.back`,
+      title: "Back",
+      run: (ctx) => {
+        blockKey(ctx);
+        if (inspecting())
+          setInspecting(false);
+        else
+          props.onDone(undefined);
+      }
+    }, {
+      name: `${commandPrefix}.prevSection`,
+      title: "Previous section",
+      run: (ctx) => {
+        blockKey(ctx);
+        jumpSection(-1);
+      }
+    }, {
+      name: `${commandPrefix}.nextSection`,
+      title: "Next section",
+      run: (ctx) => {
+        blockKey(ctx);
+        jumpSection(1);
+      }
+    }, ...helpSections().slice(0, 9).map((_, index) => ({
+      name: `${commandPrefix}.jump${index + 1}`,
+      title: `Section ${index + 1}`,
+      run: (ctx) => {
+        blockKey(ctx);
+        setSection(index);
+        infoScroll?.scrollTo(0);
+      }
+    })), {
+      name: `${commandPrefix}.shield`,
+      title: "Block background input",
+      run: blockKey
+    }],
+    bindings: [{
+      key: "up",
+      cmd: `${commandPrefix}.up`,
+      desc: "Previous item"
+    }, {
+      key: "ctrl+p",
+      cmd: `${commandPrefix}.up`,
+      desc: "Previous item"
+    }, {
+      key: "down",
+      cmd: `${commandPrefix}.down`,
+      desc: "Next item"
+    }, {
+      key: "ctrl+n",
+      cmd: `${commandPrefix}.down`,
+      desc: "Next item"
+    }, {
+      key: "pageup",
+      cmd: `${commandPrefix}.pageUp`,
+      desc: "Page up"
+    }, {
+      key: "ctrl+b",
+      cmd: `${commandPrefix}.pageUp`,
+      desc: "Page up"
+    }, {
+      key: "pagedown",
+      cmd: `${commandPrefix}.pageDown`,
+      desc: "Page down"
+    }, {
+      key: "ctrl+f",
+      cmd: `${commandPrefix}.pageDown`,
+      desc: "Page down"
+    }, {
+      key: "home",
+      cmd: `${commandPrefix}.home`,
+      desc: "Top"
+    }, {
+      key: "end",
+      cmd: `${commandPrefix}.end`,
+      desc: "Bottom"
+    }, {
+      key: "enter",
+      cmd: `${commandPrefix}.select`,
+      desc: "Select item"
+    }, {
+      key: "i",
+      cmd: `${commandPrefix}.inspect`,
+      desc: "Option info"
+    }, {
+      key: "escape",
+      cmd: `${commandPrefix}.back`,
+      desc: "Back"
+    }, ...sectionJumpBindings(), ...shieldBindings(`${commandPrefix}.shield`, ["i", ...sectionJumpBindings().map((binding) => binding.key)])]
+  });
+  onCleanup(() => {
+    unregister();
+    popMode();
+  });
+  return _$createComponent(DialogFrame, {
+    get api() {
+      return props.api;
+    },
+    get title() {
+      return props.title;
+    },
+    get children() {
+      return [_$createComponent(Show, {
+        get when() {
+          return hintLines().length > 0;
+        },
+        get children() {
+          var _el$16 = _$createElement2("box");
+          _$setProp2(_el$16, "flexDirection", "column");
+          _$setProp2(_el$16, "marginBottom", 1);
+          _$setProp2(_el$16, "paddingLeft", 1);
+          _$setProp2(_el$16, "paddingRight", 1);
+          _$insert2(_el$16, _$createComponent(InfoLines, {
+            get api() {
+              return props.api;
+            },
+            get lines() {
+              return hintLines();
+            }
+          }));
+          return _el$16;
+        }
+      }), _$createComponent(Show, {
+        get when() {
+          return _$memo(() => !!inspecting())() && current()?.help;
+        },
+        get fallback() {
+          return (() => {
+            var _el$25 = _$createElement2("scrollbox"), _el$26 = _$createElement2("box");
+            _$insertNode2(_el$25, _el$26);
+            _$use((element) => listScroll = element, _el$25);
+            _$setProp2(_el$26, "flexDirection", "column");
+            _$setProp2(_el$26, "gap", 0);
+            _$insert2(_el$26, _$createComponent(For, {
+              get each() {
+                return props.options;
+              },
+              children: (option, index) => {
+                const active = createMemo(() => selected() === index());
+                const fg = createMemo(() => active() ? theme().background : option.divider ? theme().textMuted : option.disabled ? theme().textMuted : option.danger ? theme().error : option.edited ? theme().success : theme().text);
+                const descFg = createMemo(() => active() ? theme().background : theme().textMuted);
+                if (option.divider) {
+                  return (() => {
+                    var _el$27 = _$createElement2("box"), _el$28 = _$createElement2("text");
+                    _$insertNode2(_el$27, _el$28);
+                    _$setProp2(_el$27, "paddingLeft", 1);
+                    _$setProp2(_el$27, "paddingRight", 1);
+                    _$setProp2(_el$27, "marginTop", 1);
+                    _$setProp2(_el$27, "marginBottom", 1);
+                    _$insert2(_el$28, () => "\u2500".repeat(Math.max(8, dialogContentWidth(props.api) - 4)));
+                    _$effect2((_$p) => _$setProp2(_el$28, "fg", theme().textMuted, _$p));
+                    return _el$27;
+                  })();
+                }
+                return (() => {
+                  var _el$29 = _$createElement2("box"), _el$30 = _$createElement2("text"), _el$31 = _$createElement2("text"), _el$32 = _$createElement2("b"), _el$33 = _$createElement2("text");
+                  _$insertNode2(_el$29, _el$30);
+                  _$insertNode2(_el$29, _el$31);
+                  _$insertNode2(_el$29, _el$33);
+                  _$setProp2(_el$29, "flexDirection", "row");
+                  _$setProp2(_el$29, "width", "100%");
+                  _$setProp2(_el$29, "gap", 1);
+                  _$setProp2(_el$29, "paddingLeft", 1);
+                  _$setProp2(_el$29, "paddingRight", 1);
+                  _$setProp2(_el$29, "onMouseOver", () => {
+                    if (!option.divider)
+                      setSelected(index());
+                  });
+                  _$setProp2(_el$29, "onMouseUp", () => {
+                    if (!option.disabled && !option.divider)
+                      props.onDone(option.value);
+                  });
+                  _$setProp2(_el$30, "width", 2);
+                  _$setProp2(_el$30, "flexShrink", 0);
+                  _$insert2(_el$30, () => active() ? "\u276F" : " ");
+                  _$insertNode2(_el$31, _el$32);
+                  _$setProp2(_el$31, "flexShrink", 0);
+                  _$setProp2(_el$31, "wrapMode", "none");
+                  _$setProp2(_el$31, "overflow", "hidden");
+                  _$insert2(_el$32, () => ellipsize(option.title, titleWidth()));
+                  _$setProp2(_el$33, "flexGrow", 1);
+                  _$setProp2(_el$33, "wrapMode", "none");
+                  _$setProp2(_el$33, "overflow", "hidden");
+                  _$insert2(_el$33, () => option.help ? "\u24D8 " : "", null);
+                  _$insert2(_el$33, () => option.description ?? "", null);
+                  _$effect2((_p$) => {
+                    var _v$7 = active() ? theme().primary : theme().backgroundPanel, _v$8 = fg(), _v$9 = titleWidth(), _v$0 = fg(), _v$1 = descFg();
+                    _v$7 !== _p$.e && (_p$.e = _$setProp2(_el$29, "backgroundColor", _v$7, _p$.e));
+                    _v$8 !== _p$.t && (_p$.t = _$setProp2(_el$30, "fg", _v$8, _p$.t));
+                    _v$9 !== _p$.a && (_p$.a = _$setProp2(_el$31, "width", _v$9, _p$.a));
+                    _v$0 !== _p$.o && (_p$.o = _$setProp2(_el$31, "fg", _v$0, _p$.o));
+                    _v$1 !== _p$.i && (_p$.i = _$setProp2(_el$33, "fg", _v$1, _p$.i));
+                    return _p$;
+                  }, {
+                    e: undefined,
+                    t: undefined,
+                    a: undefined,
+                    o: undefined,
+                    i: undefined
+                  });
+                  return _el$29;
+                })();
+              }
+            }));
+            _$effect2((_$p) => _$setProp2(_el$25, "maxHeight", listHeight(), _$p));
+            return _el$25;
+          })();
+        },
+        get children() {
+          var _el$17 = _$createElement2("box"), _el$18 = _$createElement2("box"), _el$19 = _$createElement2("text"), _el$20 = _$createElement2("b"), _el$21 = _$createElement2("scrollbox"), _el$22 = _$createElement2("box");
+          _$insertNode2(_el$17, _el$18);
+          _$insertNode2(_el$17, _el$21);
+          _$setProp2(_el$17, "flexDirection", "column");
+          _$insertNode2(_el$18, _el$19);
+          _$setProp2(_el$18, "marginBottom", 1);
+          _$setProp2(_el$18, "paddingLeft", 1);
+          _$insertNode2(_el$19, _el$20);
+          _$setProp2(_el$19, "wrapMode", "none");
+          _$setProp2(_el$19, "overflow", "hidden");
+          _$insert2(_el$20, () => current()?.title ?? "");
+          _$insertNode2(_el$21, _el$22);
+          _$use((element) => infoScroll = element, _el$21);
+          _$setProp2(_el$22, "flexDirection", "column");
+          _$setProp2(_el$22, "paddingLeft", 1);
+          _$setProp2(_el$22, "paddingRight", 1);
+          _$insert2(_el$22, _$createComponent(For, {
+            get each() {
+              return helpSections();
+            },
+            children: (sectionData, index) => [_$createComponent(Show, {
+              get when() {
+                return sectionData.title;
+              },
+              get children() {
+                var _el$34 = _$createElement2("box"), _el$35 = _$createElement2("text"), _el$36 = _$createElement2("b");
+                _$insertNode2(_el$34, _el$35);
+                _$setProp2(_el$34, "marginBottom", 1);
+                _$insertNode2(_el$35, _el$36);
+                _$insert2(_el$36, () => `\u2500\u2500 ${sectionData.title} `, null);
+                _$insert2(_el$36, () => "\u2500".repeat(Math.max(0, Math.min(40, 40 - sectionData.title.length))), null);
+                _$effect2((_p$) => {
+                  var _v$10 = index() > 0 ? 1 : 0, _v$11 = theme().accent;
+                  _v$10 !== _p$.e && (_p$.e = _$setProp2(_el$34, "marginTop", _v$10, _p$.e));
+                  _v$11 !== _p$.t && (_p$.t = _$setProp2(_el$35, "fg", _v$11, _p$.t));
+                  return _p$;
+                }, {
+                  e: undefined,
+                  t: undefined
+                });
+                return _el$34;
+              }
+            }), _$createComponent(InfoLines, {
+              get api() {
+                return props.api;
+              },
+              get lines() {
+                return sectionData.lines;
+              }
+            })]
+          }));
+          _$insert2(_el$17, _$createComponent(Show, {
+            get when() {
+              return helpSections().length > 1;
+            },
+            get children() {
+              var _el$23 = _$createElement2("box"), _el$24 = _$createElement2("text");
+              _$insertNode2(_el$23, _el$24);
+              _$setProp2(_el$23, "paddingLeft", 1);
+              _$setProp2(_el$23, "marginTop", 1);
+              _$insert2(_el$24, () => `section ${section() + 1}/${helpSections().length} \xB7 p/n move \xB7 1-${Math.min(9, helpSections().length)} jump`);
+              _$effect2((_$p) => _$setProp2(_el$24, "fg", theme().textMuted, _$p));
+              return _el$23;
+            }
+          }), null);
+          _$effect2((_p$) => {
+            var _v$5 = theme().text, _v$6 = infoHeight();
+            _v$5 !== _p$.e && (_p$.e = _$setProp2(_el$19, "fg", _v$5, _p$.e));
+            _v$6 !== _p$.t && (_p$.t = _$setProp2(_el$21, "maxHeight", _v$6, _p$.t));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined
+          });
+          return _el$17;
+        }
+      }), _$createComponent(KeyLegend, {
+        get api() {
+          return props.api;
+        },
+        get keys() {
+          return _$memo(() => !!inspecting())() ? helpSections().length > 1 ? [["\u2191\u2193", "scroll"], ["p/n", "section"], ["\u23CE", "back"], ["esc", "back"]] : [["\u2191\u2193", "scroll"], ["\u23CE", "back"], ["esc", "back"]] : hasHelp() ? [["\u2191\u2193", "move"], ["\u23CE", "select"], ["i", "info"], ["esc", "back"]] : [["\u2191\u2193", "move"], ["\u23CE", "select"], ["esc", "back"]];
+        },
+        onBack: () => {
+          if (inspecting())
+            setInspecting(false);
+          else
+            props.onDone(undefined);
+        }
+      })];
+    }
+  });
+}
+function showMenuOnce(api, props) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (value, _clear = false) => {
+      if (settled)
+        return;
+      settled = true;
+      dbgLog(`menu(${props.title}) -> ${value === undefined ? "cancel" : String(value)}`);
+      resolve(value);
+    };
+    dbgLog(`menu(${props.title}) OPEN (${props.options.length} options)`);
+    api.ui.dialog.replace(() => _$createComponent(MenuDialog, {
+      api,
+      get title() {
+        return props.title;
+      },
+      get options() {
+        return props.options;
+      },
+      get current() {
+        return props.current;
+      },
+      get hint() {
+        return props.hint;
+      },
+      onDone: done
+    }), () => done(undefined));
+  });
+}
+function showInfoDialog(api, props) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve(value);
+    };
+    api.ui.dialog.replace(() => _$createComponent(InfoDialog, {
+      api,
+      get title() {
+        return props.title;
+      },
+      get message() {
+        return props.message;
+      },
+      get actions() {
+        return props.actions;
+      },
+      onDone: done
+    }), () => done(undefined));
+  });
+}
+function InfoDialog(props) {
+  const theme = () => props.api.theme.current;
+  useDialogSize(props.api);
+  useHidePromptCursor(props.api);
+  const dimensions = useTerminalDimensions();
+  const lines = createMemo(() => preWrap(props.message, dialogContentWidth(props.api)));
+  const bodyHeight = createMemo(() => cappedHeight(lines().length + 1, maxRows(props.api, dimensions().height, 8, 4), 4));
+  let scroll;
+  const page = () => Math.max(1, (scroll?.height ?? bodyHeight()) - 1);
+  const popMode = props.api.mode.push("openshare.dialog");
+  const commandPrefix = `openshare.info.${Math.random().toString(36).slice(2)}`;
+  const okValue = "__ok";
+  const actions = createMemo(() => {
+    const list = props.actions?.length ? props.actions : [{
+      title: "ok",
+      value: okValue,
+      danger: false
+    }];
+    return list.map((action, index) => ({
+      ...action,
+      key: action.key ?? (index === 0 ? "enter" : undefined)
+    }));
+  });
+  const unregister = props.api.keymap.registerLayer({
+    priority: 1e4,
+    commands: [{
+      name: `${commandPrefix}.close`,
+      title: "Close",
+      run: (ctx) => {
+        blockKey(ctx);
+        props.onDone(actions().find((a) => a.key === "enter")?.value ?? okValue);
+      }
+    }, {
+      name: `${commandPrefix}.back`,
+      title: "Back",
+      run: (ctx) => {
+        blockKey(ctx);
+        props.onDone(undefined);
+      }
+    }, {
+      name: `${commandPrefix}.up`,
+      title: "Scroll up",
+      run: (ctx) => {
+        blockKey(ctx);
+        scroll?.scrollBy(-1);
+      }
+    }, {
+      name: `${commandPrefix}.down`,
+      title: "Scroll down",
+      run: (ctx) => {
+        blockKey(ctx);
+        scroll?.scrollBy(1);
+      }
+    }, {
+      name: `${commandPrefix}.pageUp`,
+      title: "Page up",
+      run: (ctx) => {
+        blockKey(ctx);
+        scroll?.scrollBy(-page());
+      }
+    }, {
+      name: `${commandPrefix}.pageDown`,
+      title: "Page down",
+      run: (ctx) => {
+        blockKey(ctx);
+        scroll?.scrollBy(page());
+      }
+    }, {
+      name: `${commandPrefix}.home`,
+      title: "Scroll top",
+      run: (ctx) => {
+        blockKey(ctx);
+        scroll?.scrollTo(0);
+      }
+    }, {
+      name: `${commandPrefix}.end`,
+      title: "Scroll bottom",
+      run: (ctx) => {
+        blockKey(ctx);
+        scroll?.scrollTo(scroll.scrollHeight);
+      }
+    }, {
+      name: `${commandPrefix}.shield`,
+      title: "Block background input",
+      run: blockKey
+    }, ...actions().filter((action) => action.key && action.key !== "enter").map((action) => ({
+      name: `${commandPrefix}.act_${action.value}`,
+      title: action.title,
+      run: (ctx) => {
+        blockKey(ctx);
+        props.onDone(action.value);
+      }
+    }))],
+    bindings: [{
+      key: "enter",
+      cmd: `${commandPrefix}.close`,
+      desc: "Close"
+    }, {
+      key: "escape",
+      cmd: `${commandPrefix}.back`,
+      desc: "Back"
+    }, {
+      key: "up",
+      cmd: `${commandPrefix}.up`,
+      desc: "Scroll up"
+    }, {
+      key: "ctrl+p",
+      cmd: `${commandPrefix}.up`,
+      desc: "Scroll up"
+    }, {
+      key: "down",
+      cmd: `${commandPrefix}.down`,
+      desc: "Scroll down"
+    }, {
+      key: "ctrl+n",
+      cmd: `${commandPrefix}.down`,
+      desc: "Scroll down"
+    }, {
+      key: "pageup",
+      cmd: `${commandPrefix}.pageUp`,
+      desc: "Page up"
+    }, {
+      key: "ctrl+b",
+      cmd: `${commandPrefix}.pageUp`,
+      desc: "Page up"
+    }, {
+      key: "pagedown",
+      cmd: `${commandPrefix}.pageDown`,
+      desc: "Page down"
+    }, {
+      key: "ctrl+f",
+      cmd: `${commandPrefix}.pageDown`,
+      desc: "Page down"
+    }, {
+      key: "home",
+      cmd: `${commandPrefix}.home`,
+      desc: "Scroll top"
+    }, {
+      key: "end",
+      cmd: `${commandPrefix}.end`,
+      desc: "Scroll bottom"
+    }, ...actions().filter((action) => action.key && action.key !== "enter").map((action) => ({
+      key: action.key,
+      cmd: `${commandPrefix}.act_${action.value}`,
+      desc: action.title
+    })), ...shieldBindings(`${commandPrefix}.shield`, ["home", "end", ...actions().filter((a) => a.key && a.key !== "enter").map((a) => a.key)])]
+  });
+  onCleanup(() => {
+    unregister();
+    popMode();
+  });
+  return _$createComponent(DialogFrame, {
+    get api() {
+      return props.api;
+    },
+    get title() {
+      return props.title;
+    },
+    get children() {
+      return [(() => {
+        var _el$37 = _$createElement2("scrollbox"), _el$38 = _$createElement2("box");
+        _$insertNode2(_el$37, _el$38);
+        _$use((element) => scroll = element, _el$37);
+        _$setProp2(_el$38, "flexDirection", "column");
+        _$setProp2(_el$38, "paddingLeft", 1);
+        _$setProp2(_el$38, "paddingRight", 1);
+        _$insert2(_el$38, _$createComponent(InfoLines, {
+          get api() {
+            return props.api;
+          },
+          get lines() {
+            return lines();
+          }
+        }));
+        _$effect2((_$p) => _$setProp2(_el$37, "maxHeight", bodyHeight(), _$p));
+        return _el$37;
+      })(), (() => {
+        var _el$39 = _$createElement2("box"), _el$40 = _$createElement2("box"), _el$41 = _$createElement2("box");
+        _$insertNode2(_el$39, _el$40);
+        _$insertNode2(_el$39, _el$41);
+        _$setProp2(_el$39, "flexDirection", "row");
+        _$setProp2(_el$39, "justifyContent", "space-between");
+        _$setProp2(_el$39, "width", "100%");
+        _$setProp2(_el$39, "paddingTop", 1);
+        _$setProp2(_el$40, "flexDirection", "row");
+        _$setProp2(_el$40, "gap", 1);
+        _$insert2(_el$40, _$createComponent(For, {
+          get each() {
+            return actions().filter((action) => action.key && action.key !== "enter");
+          },
+          children: (action) => (() => {
+            var _el$42 = _$createElement2("text");
+            _$insert2(_el$42, () => `${action.key}: ${action.title}`);
+            _$effect2((_$p) => _$setProp2(_el$42, "fg", action.danger ? theme().error : theme().textMuted, _$p));
+            return _el$42;
+          })()
+        }));
+        _$setProp2(_el$41, "flexDirection", "row");
+        _$setProp2(_el$41, "gap", 1);
+        _$insert2(_el$41, _$createComponent(For, {
+          get each() {
+            return actions();
+          },
+          children: (action) => (() => {
+            var _el$43 = _$createElement2("box"), _el$44 = _$createElement2("text"), _el$45 = _$createElement2("b");
+            _$insertNode2(_el$43, _el$44);
+            _$setProp2(_el$43, "paddingLeft", 2);
+            _$setProp2(_el$43, "paddingRight", 2);
+            _$setProp2(_el$43, "onMouseUp", () => props.onDone(action.value));
+            _$insertNode2(_el$44, _el$45);
+            _$insert2(_el$45, () => action.title);
+            _$effect2((_p$) => {
+              var _v$12 = action.danger ? theme().error : theme().primary, _v$13 = theme().background;
+              _v$12 !== _p$.e && (_p$.e = _$setProp2(_el$43, "backgroundColor", _v$12, _p$.e));
+              _v$13 !== _p$.t && (_p$.t = _$setProp2(_el$44, "fg", _v$13, _p$.t));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined
+            });
+            return _el$43;
+          })()
+        }));
+        return _el$39;
+      })()];
+    }
+  });
+}
+function showConfirmMenu(api, props) {
+  return showInfoDialog(api, {
+    title: props.title,
+    message: props.message,
+    actions: [{
+      title: props.confirmLabel ?? "Confirm",
+      value: "yes",
+      danger: props.danger
+    }, {
+      title: "Cancel",
+      value: "no"
+    }]
+  }).then((value) => value === "yes");
+}
+function showAlertMenu(api, props) {
+  return showInfoDialog(api, {
+    title: props.title,
+    message: props.message
+  }).then(() => {
+    return;
+  });
+}
+var PROMPT_CHARS = [..."abcdefghijklmnopqrstuvwxyz", ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ", ..."0123456789", ..."!@#$%^&*()-_=+[]{};:'\",.<>/?\\|`~", ..."://.-_?&=%~+#@"].join("").split("").filter((ch, index, all) => ch !== " " && all.indexOf(ch) === index).join("");
+function PromptDialog(props) {
+  const theme = () => props.api.theme.current;
+  useDialogSize(props.api);
+  useHidePromptCursor(props.api);
+  const [text, setText] = createSignal(props.value ?? "");
+  const popMode = props.api.mode.push("openshare.dialog");
+  const commandPrefix = `openshare.prompt.${Math.random().toString(36).slice(2)}`;
+  const commands = [{
+    name: `${commandPrefix}.ok`,
+    title: "Confirm",
+    run: (ctx) => {
+      blockKey(ctx);
+      props.onDone(text());
+    }
+  }, {
+    name: `${commandPrefix}.back`,
+    title: "Cancel",
+    run: (ctx) => {
+      blockKey(ctx);
+      props.onDone(undefined);
+    }
+  }, {
+    name: `${commandPrefix}.del`,
+    title: "Backspace",
+    run: (ctx) => {
+      blockKey(ctx);
+      setText((v) => v.slice(0, -1));
+    }
+  }, {
+    name: `${commandPrefix}.shield`,
+    title: "Block background input",
+    run: blockKey
+  }];
+  const bindings = [{
+    key: "enter",
+    cmd: `${commandPrefix}.ok`,
+    desc: "Confirm"
+  }, {
+    key: "escape",
+    cmd: `${commandPrefix}.back`,
+    desc: "Cancel"
+  }, {
+    key: "backspace",
+    cmd: `${commandPrefix}.del`,
+    desc: "Backspace"
+  }, {
+    key: "space",
+    cmd: `${commandPrefix}.type_space`,
+    desc: "Space"
+  }];
+  commands.push({
+    name: `${commandPrefix}.type_space`,
+    title: "Type space",
+    run: (ctx) => {
+      blockKey(ctx);
+      setText((v) => v + " ");
+    }
+  });
+  for (const ch of PROMPT_CHARS) {
+    if (ch === " ")
+      continue;
+    const name = `type_${ch.codePointAt(0)}`;
+    commands.push({
+      name: `${commandPrefix}.${name}`,
+      title: `Type ${ch}`,
+      run: (ctx) => {
+        blockKey(ctx);
+        setText((v) => v + ch);
+      }
+    });
+    bindings.push({
+      key: ch,
+      cmd: `${commandPrefix}.${name}`
+    });
+  }
+  const unregister = props.api.keymap.registerLayer({
+    priority: 1e4,
+    commands,
+    bindings
+  });
+  onCleanup(() => {
+    unregister();
+    popMode();
+  });
+  return _$createComponent(DialogFrame, {
+    get api() {
+      return props.api;
+    },
+    get title() {
+      return props.title;
+    },
+    get children() {
+      return [(() => {
+        var _el$46 = _$createElement2("box"), _el$47 = _$createElement2("text"), _el$48 = _$createElement2("text");
+        _$insertNode2(_el$46, _el$47);
+        _$insertNode2(_el$46, _el$48);
+        _$setProp2(_el$46, "paddingLeft", 1);
+        _$setProp2(_el$46, "paddingRight", 1);
+        _$setProp2(_el$46, "marginBottom", 1);
+        _$insert2(_el$47, () => text() || props.placeholder || "");
+        _$insertNode2(_el$48, _$createTextNode(`\u258C`));
+        _$effect2((_p$) => {
+          var _v$14 = theme().backgroundPanel, _v$15 = text() ? theme().text : theme().textMuted, _v$16 = theme().accent;
+          _v$14 !== _p$.e && (_p$.e = _$setProp2(_el$46, "backgroundColor", _v$14, _p$.e));
+          _v$15 !== _p$.t && (_p$.t = _$setProp2(_el$47, "fg", _v$15, _p$.t));
+          _v$16 !== _p$.a && (_p$.a = _$setProp2(_el$48, "fg", _v$16, _p$.a));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined,
+          a: undefined
+        });
+        return _el$46;
+      })(), _$createComponent(KeyLegend, {
+        get api() {
+          return props.api;
+        },
+        keys: [["a-z0-9", "type"], ["\u232B", "delete"], ["\u23CE", "confirm"], ["esc", "cancel"]],
+        onBack: () => props.onDone(undefined)
+      })];
+    }
+  });
+}
+function showPromptOnce(api, props) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (value, _clear = false) => {
+      if (settled)
+        return;
+      settled = true;
+      dbgLog(`prompt(${props.title}) -> ${value === undefined ? "cancel" : `len=${value.length}`}`);
+      resolve(value);
+    };
+    dbgLog(`prompt(${props.title}) OPEN`);
+    api.ui.dialog.replace(() => _$createComponent(PromptDialog, {
+      api,
+      get title() {
+        return props.title;
+      },
+      get placeholder() {
+        return props.placeholder;
+      },
+      get value() {
+        return props.value;
+      },
+      onDone: done
+    }), () => done(undefined));
+  });
+}
+function toMenuOptions(options) {
+  return options.map((o) => ({
+    title: o.title,
+    description: o.description,
+    value: o.value,
+    disabled: o.disabled,
+    help: o.help,
+    danger: o.danger,
+    edited: o.edited,
+    divider: o.divider
+  }));
+}
+function showSizePickerOnce(api, current) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve(value);
+    };
+    api.ui.dialog.replace(() => _$createComponent(SizePickerDialog, {
+      api,
+      current,
+      onDone: done
+    }), () => done(undefined));
+  });
+}
+function SizePickerDialog(props) {
+  const theme = () => props.api.theme.current;
+  useDialogSize(props.api);
+  useHidePromptCursor(props.api);
+  const dimensions = useTerminalDimensions();
+  const [height, setHeight] = createSignal(clampHeightPercent(props.current.heightPercent));
+  const popMode = props.api.mode.push("openshare.dialog");
+  const commandPrefix = `openshare.size.${Math.random().toString(36).slice(2)}`;
+  const cycleWidth = () => {
+    const next = kvWidthOf(props.api.kv) === "medium" ? "large" : kvWidthOf(props.api.kv) === "large" ? "xlarge" : "medium";
+    props.api.kv.set(UI_WIDTH_KV, next);
+  };
+  const setPreset = (label) => {
+    const preset = HEIGHT_PRESETS.find((p) => p.label === label);
+    if (preset)
+      setHeight(preset.value);
+  };
+  const move = (delta) => setHeight((current) => clampHeightPercent(current + delta));
+  const save = () => {
+    props.api.kv.set(UI_HEIGHT_PERCENT_KV, height());
+    props.onDone({
+      width: kvWidthOf(props.api.kv),
+      heightPercent: height()
+    });
+  };
+  const sliderWidth = () => kvWidthOf(props.api.kv) === "xlarge" ? 64 : kvWidthOf(props.api.kv) === "large" ? 48 : 34;
+  const sliderCells = createMemo(() => {
+    const width = sliderWidth();
+    const selected = Math.round((height() - HEIGHT_PERCENT_MIN) / (HEIGHT_PERCENT_MAX - HEIGHT_PERCENT_MIN) * (width - 1));
+    const presetPositions = new Map(HEIGHT_PRESETS.map((preset) => [Math.round((preset.value - HEIGHT_PERCENT_MIN) / (HEIGHT_PERCENT_MAX - HEIGHT_PERCENT_MIN) * (width - 1)), preset.label]));
+    return Array.from({
+      length: width
+    }, (_, index) => {
+      const isCurrent = index === selected;
+      const preset = presetPositions.get(index);
+      return {
+        char: isCurrent ? "\u25CF" : preset ? "\u2502" : index < selected ? "\u2501" : "\u2500",
+        color: isCurrent ? theme().primary : preset ? theme().accent : index < selected ? theme().success : theme().textMuted
+      };
+    });
+  });
+  const preview = createMemo(() => {
+    const widthColumns = kvWidthOf(props.api.kv) === "xlarge" ? 116 : kvWidthOf(props.api.kv) === "large" ? 88 : 60;
+    const previewWidth = Math.max(10, Math.min(sliderWidth() + 4, 72));
+    const scale = previewWidth / widthColumns;
+    const metrics = dialogMetrics(props.api, dimensions().height, 6, 4);
+    const effective = metrics.targetRows;
+    const requested = Math.floor(dimensions().height * Math.min(100, Math.max(25, height())) / 100);
+    const rows = Math.max(4, Math.round(effective * scale));
+    const fill = (text, width) => {
+      const inner = width - 2;
+      const slice = text.length > inner ? text.slice(0, inner - 1) + "\u2026" : text;
+      return `\u2502${slice}${" ".repeat(Math.max(0, inner - slice.length))}\u2502`;
+    };
+    const lines = [];
+    lines.push(`\u250C${"\u2500".repeat(previewWidth - 2)}\u2510`);
+    lines.push(fill(`OpenShare (preview)${effective < requested ? " [capped]" : ""}`, previewWidth));
+    for (let index = 0;index < rows - 3; index++)
+      lines.push(fill("", previewWidth));
+    lines.push(`\u2514${"\u2500".repeat(previewWidth - 2)}\u2518`);
+    return lines;
+  });
+  const unregister = props.api.keymap.registerLayer({
+    priority: 1e4,
+    commands: [{
+      name: `${commandPrefix}.width`,
+      title: "Cycle width",
+      run: (ctx) => {
+        blockKey(ctx);
+        cycleWidth();
+      }
+    }, {
+      name: `${commandPrefix}.left`,
+      title: "Lower height",
+      run: (ctx) => {
+        blockKey(ctx);
+        move(-1);
+      }
+    }, {
+      name: `${commandPrefix}.right`,
+      title: "Raise height",
+      run: (ctx) => {
+        blockKey(ctx);
+        move(1);
+      }
+    }, {
+      name: `${commandPrefix}.down`,
+      title: "Lower height faster",
+      run: (ctx) => {
+        blockKey(ctx);
+        move(-5);
+      }
+    }, {
+      name: `${commandPrefix}.up`,
+      title: "Raise height faster",
+      run: (ctx) => {
+        blockKey(ctx);
+        move(5);
+      }
+    }, ...HEIGHT_PRESETS.map((preset) => ({
+      name: `${commandPrefix}.preset_${preset.label}`,
+      title: `${preset.label} preset`,
+      run: (ctx) => {
+        blockKey(ctx);
+        setPreset(preset.label);
+      }
+    })), {
+      name: `${commandPrefix}.custom`,
+      title: "Custom percent",
+      run: (ctx) => {
+        blockKey(ctx);
+        props.onDone({
+          width: kvWidthOf(props.api.kv),
+          heightPercent: -1
+        });
+      }
+    }, {
+      name: `${commandPrefix}.save`,
+      title: "Save",
+      run: (ctx) => {
+        blockKey(ctx);
+        save();
+      }
+    }, {
+      name: `${commandPrefix}.back`,
+      title: "Back",
+      run: (ctx) => {
+        blockKey(ctx);
+        props.onDone(undefined);
+      }
+    }, {
+      name: `${commandPrefix}.shield`,
+      title: "Block background input",
+      run: blockKey
+    }],
+    bindings: [{
+      key: "w",
+      cmd: `${commandPrefix}.width`,
+      desc: "Cycle width"
+    }, {
+      key: "left",
+      cmd: `${commandPrefix}.left`,
+      desc: "Lower height"
+    }, {
+      key: "right",
+      cmd: `${commandPrefix}.right`,
+      desc: "Raise height"
+    }, {
+      key: "down",
+      cmd: `${commandPrefix}.down`,
+      desc: "Lower height faster"
+    }, {
+      key: "up",
+      cmd: `${commandPrefix}.up`,
+      desc: "Raise height faster"
+    }, ...HEIGHT_PRESETS.map((preset) => ({
+      key: preset.key,
+      cmd: `${commandPrefix}.preset_${preset.label}`,
+      desc: `${preset.label} preset`
+    })), {
+      key: "c",
+      cmd: `${commandPrefix}.custom`,
+      desc: "Custom percent"
+    }, {
+      key: "enter",
+      cmd: `${commandPrefix}.save`,
+      desc: "Save"
+    }, {
+      key: "escape",
+      cmd: `${commandPrefix}.back`,
+      desc: "Back"
+    }, ...shieldBindings(`${commandPrefix}.shield`, ["w", "c", ...HEIGHT_PRESETS.map((preset) => preset.key)])]
+  });
+  onCleanup(() => {
+    unregister();
+    popMode();
+  });
+  return _$createComponent(DialogFrame, {
+    get api() {
+      return props.api;
+    },
+    title: "Menu size",
+    get children() {
+      return [(() => {
+        var _el$50 = _$createElement2("box"), _el$51 = _$createElement2("text"), _el$52 = _$createTextNode(`width (w): `), _el$53 = _$createTextNode(` (`), _el$54 = _$createTextNode(` cols)`), _el$55 = _$createElement2("text"), _el$56 = _$createElement2("b"), _el$57 = _$createTextNode(`%`);
+        _$insertNode2(_el$50, _el$51);
+        _$insertNode2(_el$50, _el$55);
+        _$setProp2(_el$50, "flexDirection", "row");
+        _$setProp2(_el$50, "justifyContent", "space-between");
+        _$setProp2(_el$50, "width", "100%");
+        _$setProp2(_el$50, "marginBottom", 1);
+        _$setProp2(_el$50, "paddingLeft", 1);
+        _$setProp2(_el$50, "paddingRight", 1);
+        _$insertNode2(_el$51, _el$52);
+        _$insertNode2(_el$51, _el$53);
+        _$insertNode2(_el$51, _el$54);
+        _$insert2(_el$51, () => kvWidthOf(props.api.kv), _el$53);
+        _$insert2(_el$51, (() => {
+          var _c$2 = _$memo(() => kvWidthOf(props.api.kv) === "xlarge");
+          return () => _c$2() ? 116 : kvWidthOf(props.api.kv) === "large" ? 88 : 60;
+        })(), _el$54);
+        _$insertNode2(_el$55, _el$56);
+        _$insertNode2(_el$56, _el$57);
+        _$insert2(_el$56, height, _el$57);
+        _$effect2((_p$) => {
+          var _v$17 = theme().textMuted, _v$18 = theme().accent;
+          _v$17 !== _p$.e && (_p$.e = _$setProp2(_el$51, "fg", _v$17, _p$.e));
+          _v$18 !== _p$.t && (_p$.t = _$setProp2(_el$55, "fg", _v$18, _p$.t));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined
+        });
+        return _el$50;
+      })(), (() => {
+        var _el$58 = _$createElement2("box"), _el$59 = _$createElement2("text"), _el$60 = _$createTextNode(`% `), _el$61 = _$createElement2("text"), _el$62 = _$createTextNode(` `), _el$63 = _$createTextNode(`%`);
+        _$insertNode2(_el$58, _el$59);
+        _$insertNode2(_el$58, _el$61);
+        _$setProp2(_el$58, "flexDirection", "row");
+        _$setProp2(_el$58, "width", "100%");
+        _$setProp2(_el$58, "marginBottom", 1);
+        _$setProp2(_el$58, "paddingLeft", 1);
+        _$setProp2(_el$58, "paddingRight", 1);
+        _$insertNode2(_el$59, _el$60);
+        _$insert2(_el$59, HEIGHT_PERCENT_MIN, _el$60);
+        _$insert2(_el$58, _$createComponent(For, {
+          get each() {
+            return sliderCells();
+          },
+          children: (cell) => (() => {
+            var _el$66 = _$createElement2("text");
+            _$insert2(_el$66, () => cell.char);
+            _$effect2((_$p) => _$setProp2(_el$66, "fg", cell.color, _$p));
+            return _el$66;
+          })()
+        }), _el$61);
+        _$insertNode2(_el$61, _el$62);
+        _$insertNode2(_el$61, _el$63);
+        _$insert2(_el$61, HEIGHT_PERCENT_MAX, _el$63);
+        _$effect2((_p$) => {
+          var _v$19 = theme().textMuted, _v$20 = theme().textMuted;
+          _v$19 !== _p$.e && (_p$.e = _$setProp2(_el$59, "fg", _v$19, _p$.e));
+          _v$20 !== _p$.t && (_p$.t = _$setProp2(_el$61, "fg", _v$20, _p$.t));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined
+        });
+        return _el$58;
+      })(), (() => {
+        var _el$64 = _$createElement2("box");
+        _$setProp2(_el$64, "flexDirection", "column");
+        _$setProp2(_el$64, "gap", 0);
+        _$setProp2(_el$64, "marginBottom", 1);
+        _$setProp2(_el$64, "paddingLeft", 1);
+        _$setProp2(_el$64, "paddingRight", 1);
+        _$insert2(_el$64, _$createComponent(For, {
+          each: HEIGHT_PRESETS,
+          children: (preset) => (() => {
+            var _el$67 = _$createElement2("text"), _el$68 = _$createTextNode(` `), _el$69 = _$createTextNode(`: `), _el$70 = _$createTextNode(`%`);
+            _$insertNode2(_el$67, _el$68);
+            _$insertNode2(_el$67, _el$69);
+            _$insertNode2(_el$67, _el$70);
+            _$insert2(_el$67, () => preset.key, _el$68);
+            _$insert2(_el$67, () => preset.label, _el$69);
+            _$insert2(_el$67, () => preset.value, _el$70);
+            _$insert2(_el$67, () => height() === preset.value ? "  \u25CF current" : "", null);
+            _$effect2((_$p) => _$setProp2(_el$67, "fg", height() === preset.value ? theme().accent : theme().textMuted, _$p));
+            return _el$67;
+          })()
+        }));
+        return _el$64;
+      })(), (() => {
+        var _el$65 = _$createElement2("box");
+        _$setProp2(_el$65, "flexDirection", "column");
+        _$setProp2(_el$65, "paddingLeft", 1);
+        _$setProp2(_el$65, "paddingRight", 1);
+        _$setProp2(_el$65, "marginBottom", 1);
+        _$insert2(_el$65, _$createComponent(For, {
+          get each() {
+            return preview();
+          },
+          children: (line) => (() => {
+            var _el$71 = _$createElement2("text");
+            _$insert2(_el$71, line);
+            _$effect2((_$p) => _$setProp2(_el$71, "fg", theme().textMuted, _$p));
+            return _el$71;
+          })()
+        }));
+        return _el$65;
+      })(), _$createComponent(KeyLegend, {
+        get api() {
+          return props.api;
+        },
+        keys: [["w", "width"], ["\u2190\u2192", "\xB11%"], ["\u2191\u2193", "\xB15%"], ["c", "custom"], ["\u23CE", "save"], ["esc", "back"]],
+        onBack: () => props.onDone(undefined)
+      })];
+    }
+  });
+}
+
+// src/v2-tui.ts
+import { createSignal as createSignal2 } from "solid-js";
+function pickThemeToken(source, ...path) {
+  let current = source;
+  for (const key of path) {
+    if (!current || typeof current !== "object")
+      return;
+    current = current[key];
+  }
+  return current;
+}
+function buildV2Theme(context) {
+  return {
+    get current() {
+      const theme = context.theme;
+      const dark = context.themeMode === "dark";
+      const text = pickThemeToken(theme, "text", "default");
+      return {
+        text,
+        textMuted: pickThemeToken(theme, "text", "subdued") ?? text,
+        background: pickThemeToken(theme, "background", "default"),
+        backgroundPanel: pickThemeToken(theme, "background", "surface", "offset") ?? pickThemeToken(theme, "background", "default"),
+        primary: pickThemeToken(theme, "text", "action", "primary", "selected") ?? text,
+        secondary: pickThemeToken(theme, "hue", dark ? "interactive" : "neutral", dark ? 300 : 700) ?? text,
+        accent: pickThemeToken(theme, "hue", "accent", dark ? 200 : 800) ?? text,
+        success: pickThemeToken(theme, "text", "feedback", "success", "default") ?? text,
+        warning: pickThemeToken(theme, "text", "feedback", "warning", "default") ?? text,
+        error: pickThemeToken(theme, "text", "feedback", "error", "default") ?? text,
+        info: pickThemeToken(theme, "text", "feedback", "info", "default") ?? text
+      };
+    }
+  };
+}
+function convertKeymapLayer(layer) {
+  const bindingsByName = new Map;
+  for (const binding of layer.bindings ?? []) {
+    if (!binding?.cmd)
+      continue;
+    const keys = bindingsByName.get(binding.cmd) ?? [];
+    keys.push(binding.key);
+    bindingsByName.set(binding.cmd, keys);
+  }
+  const commands = (layer.commands ?? []).map((command) => ({
+    id: command.name,
+    title: command.title ?? command.name,
+    description: command.desc,
+    group: command.group ?? command.category,
+    palette: true,
+    ...command.slashName ? { slash: { name: command.slashName, ...command.slashAliases?.length ? { aliases: command.slashAliases } : {} } } : {},
+    ...command.suggested !== undefined ? { suggested: command.suggested } : {},
+    ...command.enabled !== undefined ? { enabled: command.enabled } : {},
+    ...bindingsByName.get(command.name)?.length ? { bind: bindingsByName.get(command.name).join(",") } : {},
+    run: (_input, event) => command.run({
+      event: event ? {
+        preventDefault: () => event.preventDefault?.(),
+        stopPropagation: () => event.stopPropagation?.()
+      } : undefined
+    })
+  }));
+  return { mode: layer.mode ?? "global", priority: layer.priority, commands };
+}
+function buildV2HostApi(context) {
+  const disposeFns = [];
+  const [kvStore, kvMutate] = context.storage.store("kv", { initial: {} });
+  const kvMirror = {};
+  for (const [key, value] of Object.entries(kvStore))
+    kvMirror[key] = value;
+  const kv = {
+    get(key, fallback) {
+      const value = key in kvMirror ? kvMirror[key] : kvStore[key];
+      return value === undefined ? fallback : value;
+    },
+    set(key, value) {
+      kvMirror[key] = value;
+      kvMutate((draft) => {
+        draft[key] = value;
+      }).catch(() => {
+        return;
+      });
+    }
+  };
+  const dialog = context.ui.dialog;
+  let nestedOnClose;
+  const settleNested = (dismissed) => {
+    const onClose = nestedOnClose;
+    nestedOnClose = undefined;
+    if (dismissed)
+      onClose?.();
+  };
+  return {
+    hostVersion: 2,
+    app: { version: context.app?.version },
+    client: context.client,
+    kv,
+    lifecycle: {
+      onDispose(fn) {
+        disposeFns.push(fn);
+      }
+    },
+    theme: buildV2Theme(context),
+    ui: {
+      toast: (input) => {
+        try {
+          context.ui.toast.show({ title: input.title, message: input.message, variant: input.variant, duration: input.duration });
+        } catch {}
+      },
+      dialog: {
+        replace(renderer, onClose) {
+          nestedOnClose = undefined;
+          let content;
+          try {
+            content = typeof renderer === "function" ? renderer() : renderer;
+          } catch {
+            content = undefined;
+          }
+          if (content === undefined || content === null) {
+            nestedOnClose = onClose;
+            return;
+          }
+          dialog.show(() => content, onClose);
+        },
+        clear() {
+          nestedOnClose = undefined;
+          dialog.clear();
+        },
+        setSize(size) {
+          try {
+            dialog.set({ size });
+          } catch {}
+        }
+      },
+      async showMenu(props) {
+        const value = await dialog.select({
+          title: props.title,
+          placeholder: props.hint,
+          current: props.current,
+          options: props.options.map((option) => ({
+            title: option.title,
+            value: option.value,
+            description: option.description,
+            category: option.category,
+            disabled: option.disabled
+          }))
+        });
+        return value;
+      },
+      async showConfirm(props) {
+        return await dialog.confirm({ title: props.title, message: props.message, label: { confirm: props.confirmLabel } }) === true;
+      },
+      async showAlert(props) {
+        await dialog.alert({ title: props.title, message: props.message });
+      },
+      async showPrompt(props) {
+        return await dialog.prompt({ title: props.title, placeholder: props.placeholder, value: props.value });
+      },
+      DialogSelect(props) {
+        dialog.select({
+          title: props.title,
+          placeholder: props.placeholder,
+          current: props.current,
+          options: props.options.map((option) => ({
+            title: option.title,
+            value: option.value,
+            description: option.description,
+            category: option.category,
+            disabled: option.disabled
+          }))
+        }).then((value) => {
+          if (value === undefined) {
+            settleNested(true);
+            return;
+          }
+          settleNested(false);
+          const option = props.options.find((item) => item.value === value);
+          if (option)
+            props.onSelect(option);
+        }).catch(() => settleNested(true));
+      },
+      DialogPrompt(props) {
+        dialog.prompt({ title: props.title, placeholder: props.placeholder, value: props.value }).then((value) => {
+          settleNested(value === undefined);
+          if (value === undefined)
+            props.onCancel?.();
+          else
+            props.onConfirm(value);
+        }).catch(() => {
+          settleNested(true);
+          props.onCancel?.();
+        });
+      },
+      DialogConfirm(props) {
+        dialog.confirm({ title: props.title, message: props.message, label: { confirm: props.confirmLabel } }).then((result) => {
+          settleNested(result !== true);
+          if (result === true)
+            props.onConfirm();
+          else
+            props.onCancel?.();
+        }).catch(() => {
+          settleNested(true);
+          props.onCancel?.();
+        });
+      },
+      DialogAlert(props) {
+        dialog.alert({ title: props.title, message: props.message }).then(() => {
+          settleNested(false);
+          props.onConfirm?.();
+        }).catch(() => {
+          settleNested(true);
+          props.onConfirm?.();
+        });
+      }
+    },
+    keymap: {
+      registerLayer(layer) {
+        const [active, setActive] = createSignal2(true);
+        try {
+          context.keymap.layer(() => active() ? convertKeymapLayer(layer) : { mode: "global", enabled: false, commands: [], bindings: [] });
+        } catch {
+          return () => {
+            return;
+          };
+        }
+        return () => {
+          setActive(false);
+        };
+      }
+    },
+    sessionInfo: () => {
+      return;
+    },
+    currentSessionID: undefined,
+    clipboard: {
+      async write(text) {
+        let ok = false;
+        try {
+          const clip = navigator.clipboard;
+          if (typeof clip?.writeText === "function") {
+            await clip.writeText(text).then(() => {
+              ok = true;
+            }, () => {});
+          }
+        } catch {}
+        try {
+          process.stdout.write(`\x1B]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`);
+          ok = true;
+        } catch {}
+        return ok;
+      }
+    }
+  };
+}
+function createV2TuiSetup() {
+  return async (context) => {
+    const host = buildV2HostApi(context);
+    const sessionID = () => host.currentSessionID?.() ?? undefined;
+    const unregister = registerCommands(host, sessionID);
+    return () => {
+      try {
+        unregister();
+      } catch {}
+    };
+  };
+}
+
+// src/tui.tsx
+async function showSizePickerFlow(api, current) {
+  let heightPercent = clampHeightPercent(current.heightPercent);
+  while (true) {
+    const choice = await showSizePickerOnce(api, {
+      width: kvWidthOf(api.kv),
+      heightPercent
+    });
+    if (!choice)
+      return;
+    if (choice.heightPercent >= 0)
+      return {
+        width: kvWidthOf(api.kv),
+        heightPercent: clampHeightPercent(choice.heightPercent)
+      };
+    const input = await showPromptOnce(api, {
+      title: "Menu height percent",
+      placeholder: "25-100",
+      value: String(heightPercent)
+    });
+    if (input === undefined)
+      continue;
+    const parsed = Number(input);
+    if (!Number.isFinite(parsed)) {
+      await showAlertMenu(api, {
+        title: "Invalid height",
+        message: "Enter a number from 25 to 100."
+      });
+      continue;
+    }
+    heightPercent = clampHeightPercent(parsed);
+  }
+}
+function buildV1HostApi(api) {
+  return {
+    hostVersion: 1,
+    app: {
+      version: api.app?.version
+    },
+    client: (() => {
+      const raw = api.client;
+      const rawSession = raw?.session;
+      if (!rawSession)
+        return raw;
+      const translateArgs = (args) => {
+        if (!args || typeof args !== "object")
+          return args;
+        const a = args;
+        if (a.path && "id" in a.path && !("sessionID" in a.path)) {
+          const {
+            id,
+            ...rest
+          } = a.path;
+          return {
+            ...a,
+            path: {
+              ...rest,
+              sessionID: id
+            }
+          };
+        }
+        return args;
+      };
+      let argShape;
+      const callV2 = async (method, args) => {
+        const orig = rawSession[method];
+        if (!orig)
+          return;
+        const a = args;
+        const flat = {
+          sessionID: a.path?.id ?? a.path?.sessionID,
+          ...a.body ?? {}
+        };
+        const attempts = argShape === "flat" ? [["flat", flat]] : argShape === "path" ? [["path", translateArgs(args)]] : [["path", translateArgs(args)], ["flat", flat]];
+        let last;
+        for (const [shape, callArgs] of attempts) {
+          try {
+            last = await orig.call(rawSession, callArgs);
+          } catch (e) {
+            last = {
+              error: e
+            };
+          }
+          const failed = !last || typeof last === "object" && "error" in last && last.error;
+          if (!failed) {
+            if (!argShape) {
+              argShape = shape;
+              dbgLog(`client.${method} arg shape = ${shape}`);
+            }
+            return last;
+          }
+        }
+        return last;
+      };
+      const adaptedGet = async (args) => {
+        const res = await callV2("get", args);
+        const info = (res && typeof res === "object" && "data" in res ? res.data : res) ?? undefined;
+        if (info && typeof info === "object" && !info.metadata) {
+          const stateInfo = api.state.session.get(args.path.id);
+          if (stateInfo?.metadata) {
+            dbgLog(`client.get metadata fallback: client keys=${Object.keys(info).slice(0, 12).join("|")} -> state metadata used`);
+            if (res && typeof res === "object" && "data" in res)
+              return {
+                ...res,
+                data: {
+                  ...info,
+                  metadata: stateInfo.metadata
+                }
+              };
+            return {
+              ...info,
+              metadata: stateInfo.metadata
+            };
+          }
+        }
+        return res;
+      };
+      const adaptedSession = new Proxy(rawSession, {
+        get(target, key) {
+          if (key === "get")
+            return adaptedGet;
+          if (key === "update")
+            return (args) => callV2("update", args);
+          const value = Reflect.get(target, key, target);
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      });
+      return new Proxy(raw, {
+        get(target, key) {
+          if (key === "session")
+            return adaptedSession;
+          const value = Reflect.get(target, key, target);
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      });
+    })(),
+    kv: api.kv,
+    lifecycle: api.lifecycle,
+    theme: api.theme,
+    ui: {
+      toast: (input) => api.ui.toast(input),
+      dialog: new Proxy({}, {
+        get: (_t, key) => {
+          if (key === "clear")
+            return () => {
+              try {
+                api.ui.dialog.clear();
+              } catch {}
+            };
+          if (key === "replace")
+            return (render, onClose) => {
+              try {
+                api.ui.dialog.replace(render, onClose);
+              } catch (e) {
+                dbgLog(`dialog.replace THREW: ${e?.message ?? e}`);
+              }
+            };
+          const value = api.ui.dialog[key];
+          return typeof value === "function" ? value.bind(api.ui.dialog) : value;
+        }
+      }),
+      showMenu: (props) => showMenuOnce(api, {
+        ...props,
+        options: toMenuOptions(props.options)
+      }),
+      showConfirm: (props) => showConfirmMenu(api, props),
+      showAlert: (props) => showAlertMenu(api, props),
+      showPrompt: (props) => showPromptOnce(api, props),
+      showSizePicker: (current) => showSizePickerFlow(api, current),
+      showBusy: (title) => {
+        const theme = () => api.theme.current;
+        api.ui.dialog.replace(() => (() => {
+          var _el$ = _$createElement3("box"), _el$2 = _$createElement3("text"), _el$3 = _$createElement3("b"), _el$4 = _$createElement3("text");
+          _$insertNode3(_el$, _el$2);
+          _$insertNode3(_el$, _el$4);
+          _$setProp3(_el$, "flexDirection", "column");
+          _$setProp3(_el$, "width", "100%");
+          _$setProp3(_el$, "paddingLeft", 2);
+          _$setProp3(_el$, "paddingRight", 2);
+          _$setProp3(_el$, "paddingTop", 1);
+          _$setProp3(_el$, "paddingBottom", 1);
+          _$insertNode3(_el$2, _el$3);
+          _$insert3(_el$3, title);
+          _$insertNode3(_el$4, _$createTextNode2(`working\u2026 (esc does not cancel)`));
+          _$effect3((_p$) => {
+            var _v$ = theme().accent, _v$2 = theme().textMuted;
+            _v$ !== _p$.e && (_p$.e = _$setProp3(_el$2, "fg", _v$, _p$.e));
+            _v$2 !== _p$.t && (_p$.t = _$setProp3(_el$4, "fg", _v$2, _p$.t));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined
+          });
+          return _el$;
+        })());
+        return () => {
+          try {
+            api.ui.dialog.clear();
+          } catch {}
+        };
+      },
+      DialogSelect: (props) => {
+        showMenuOnce(api, {
+          title: props.title,
+          options: toMenuOptions(props.options),
+          current: props.current,
+          hint: props.placeholder
+        }).then((value) => {
+          if (value === undefined)
+            props.onCancel?.();
+          else {
+            const option = props.options.find((o) => o.value === value);
+            if (option)
+              props.onSelect(option);
+          }
+        });
+        return;
+      },
+      DialogPrompt: (props) => {
+        showPromptOnce(api, {
+          title: props.title,
+          placeholder: props.placeholder,
+          value: props.value
+        }).then((value) => {
+          if (value === undefined)
+            props.onCancel?.();
+          else
+            props.onConfirm(value);
+        });
+        return;
+      },
+      DialogConfirm: (props) => {
+        showConfirmMenu(api, {
+          title: props.title,
+          message: props.message,
+          confirmLabel: props.confirmLabel
+        }).then((yes) => yes ? props.onConfirm() : props.onCancel?.());
+        return;
+      },
+      DialogAlert: (props) => {
+        showAlertMenu(api, {
+          title: props.title,
+          message: props.message
+        }).then(() => props.onConfirm?.());
+        return;
+      }
+    },
+    keymap: {
+      registerLayer(layer) {
+        const commands = layer.commands.map((command) => {
+          const host = {
+            namespace: "palette",
+            name: command.name,
+            title: command.title,
+            run: (ctx) => command.run(ctx ?? {})
+          };
+          if (command.desc !== undefined)
+            host.desc = command.desc;
+          if (command.category !== undefined)
+            host.category = command.category;
+          if (command.slashName !== undefined)
+            host.slashName = command.slashName;
+          if (command.slashAliases?.length)
+            host.slashAliases = command.slashAliases;
+          if (command.suggested !== undefined)
+            host.suggested = command.suggested;
+          if (command.hidden !== undefined)
+            host.hidden = command.hidden;
+          if (command.enabled !== undefined)
+            host.enabled = command.enabled;
+          return host;
+        });
+        return api.keymap.registerLayer({
+          commands,
+          bindings: layer.bindings
+        });
+      }
+    },
+    sessionInfo: (sid) => api.state.session.get(sid),
+    currentSessionID: () => {
+      const route = api.route.current;
+      return route.name === "session" ? route.params?.sessionID : undefined;
+    },
+    clipboard: {
+      async write(text) {
+        let ok = false;
+        try {
+          const clip = navigator.clipboard;
+          if (typeof clip?.writeText === "function") {
+            await clip.writeText(text).then(() => {
+              ok = true;
+            }, () => {});
+          }
+        } catch {}
+        try {
+          process.stdout.write(`\x1B]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`);
+          ok = true;
+        } catch {}
+        return ok;
+      }
+    }
+  };
+}
+var tui = async (api) => {
+  dbgLog(`tui entry running; host v=${dbg(api.app?.version)} slots=${!!api.slots} keymap=${!!api.keymap} state=${!!api.state}`);
+  const host = buildV1HostApi(api);
+  const sessionID = () => host.currentSessionID?.() ?? undefined;
+  const unregister = registerCommands(host, sessionID);
+  try {
+    const shareCommand = buildShareCommand(host, sessionID);
+    const slot = createSidebarSlot(api, {
+      onShareCommand: () => void shareCommand.run({})
+    });
+    dbgLog(`registering sidebar slot: ${Object.keys(slot?.slots ?? {}).join(", ") || "NO SLOTS"}`);
+    const reg = api.slots.register(slot);
+    dbgLog(`sidebar slot registered -> ${dbg(reg)}`);
+  } catch (error) {
+    dbgLog(`sidebar slot REGISTRATION THREW ${error?.stack ?? String(error)}`);
+  }
+  api.lifecycle.onDispose(() => {
+    try {
+      unregister();
+    } catch {}
+  });
+};
+var tui_default = {
+  id: "openshare",
+  tui,
+  setup: createV2TuiSetup()
+};
+export {
+  tui_default as default,
+  buildV1HostApi
+};