@goodea/echolet 0.1.0

package/dist/tui.js

@@ -0,0 +1,1478 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+
+// src/tui/main.ts
+import { spawn } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/tui/cli-bridge.ts
+var UNREADABLE_CLI_OUTPUT = "UNREADABLE_CLI_OUTPUT";
+function buildArgv(request) {
+  switch (request.command) {
+    case "init":
+      return ["init", "--relay-url", request.relayUrl, "--store-key-env", request.storeKeyEnv, "--profile", request.profileDir, "--json"];
+    case "contact export":
+      return ["contact", "export", "--out", request.out, "--profile", request.profileDir, "--json"];
+    case "contact import":
+      return ["contact", "import", "--from", request.from, "--profile", request.profileDir, "--json"];
+    case "relay publish":
+      return ["relay", "publish", "--profile", request.profileDir, "--json"];
+    case "send":
+      return [
+        "send",
+        "--to",
+        request.to,
+        ...request.messageId === void 0 ? [] : ["--message-id", request.messageId],
+        "--profile",
+        request.profileDir,
+        "--json"
+      ];
+    case "poll":
+      return ["poll", "--profile", request.profileDir, "--json"];
+    case "history":
+      return ["history", "--with", request.contactIdentityId, "--profile", request.profileDir, "--json"];
+    case "doctor":
+      return ["doctor", "--profile", request.profileDir, "--json"];
+    default: {
+      const refused = request.command;
+      throw new Error(`refused: ${String(refused)} is outside the frozen eight-command CLI surface`);
+    }
+  }
+}
+function parseCliOutcome(stdout, exitCode) {
+  const unreadable = { ok: false, code: UNREADABLE_CLI_OUTPUT, exitCode, data: null };
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return unreadable;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return unreadable;
+  const envelope = parsed;
+  if (envelope.ok === true) return { ok: true, code: "ok", exitCode, data: envelope.data ?? null };
+  const error = typeof envelope.error === "object" && envelope.error !== null ? envelope.error : {};
+  const code = typeof error.code === "string" && error.code.length > 0 ? error.code : UNREADABLE_CLI_OUTPUT;
+  return { ok: false, code, exitCode, data: envelope.data ?? null };
+}
+
+// src/limits.ts
+var MAX_PLAINTEXT_BYTES = 65536;
+
+// src/tui/state.ts
+var PANE_IDS = ["profiles", "mailbox", "history", "rejections", "health"];
+var SETUP_STEPS = 6;
+var PENDING_SETUP = ["pending", "pending", "pending", "pending", "pending", "pending"];
+var PATH_MAX_BYTES = 1024;
+var NAME_MAX_BYTES = 128;
+function inputMaxBytes(field) {
+  switch (field) {
+    case "message":
+      return MAX_PLAINTEXT_BYTES;
+    case "contact-name":
+    case "store-key-env":
+      return NAME_MAX_BYTES;
+    case "relay-url":
+    case "profile-dir":
+    case "export-path":
+    case "card-path":
+    default:
+      return PATH_MAX_BYTES;
+  }
+}
+function setupIsComplete(profile) {
+  const setup = profile.setup;
+  if (setup === void 0 || profile.storeKeyPresent !== true) return false;
+  for (let step = 1; step < SETUP_STEPS; step += 1) if (setup[step] !== "ok") return false;
+  return true;
+}
+function profileIsInSetup(profile) {
+  return profile.setup !== void 0 && !setupIsComplete(profile);
+}
+function nextSetupStep(profile) {
+  const setup = profile.setup;
+  if (setup === void 0 || profile.storeKeyPresent !== true) return void 0;
+  for (let step = 1; step < SETUP_STEPS; step += 1) if (setup[step] !== "ok") return step;
+  return void 0;
+}
+function createInitialState(input) {
+  const profiles = [...input.profiles];
+  const first = profiles[0];
+  return {
+    profiles,
+    activeProfile: 0,
+    contacts: [],
+    selectedContactId: null,
+    mailbox: { outboxPending: null, inboxReceived: null, more: false, lastPolledAtMs: null },
+    rejections: [],
+    history: [],
+    health: { relayUrl: first?.relayUrl ?? "", status: "unknown", uptimeMs: null, checkedAtMs: null },
+    pane: "profiles",
+    modal: void 0,
+    activity: [],
+    busy: false
+  };
+}
+
+// src/tui/text.ts
+function codePoints(text) {
+  return [...text];
+}
+function utf8Bytes(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function clipLine(text, width) {
+  const limit = Math.max(0, Math.floor(width));
+  const points = codePoints(text);
+  return points.length <= limit ? text : points.slice(0, limit).join("");
+}
+function padOrClip(text, width) {
+  const limit = Math.max(0, Math.floor(width));
+  const points = codePoints(text);
+  if (points.length >= limit) return points.slice(0, limit).join("");
+  return text + " ".repeat(limit - points.length);
+}
+function labelled(label, value, gutter = 16) {
+  return `${padOrClip(label, gutter)}${value}`;
+}
+function steersTheDisplay(point) {
+  const code = point.codePointAt(0) ?? 0;
+  if (code <= 31 || code === 127 || code >= 128 && code <= 159) return true;
+  if (code === 8206 || code === 8207) return true;
+  if (code >= 8234 && code <= 8238) return true;
+  if (code >= 8294 && code <= 8297) return true;
+  return code === 8232 || code === 8233 || code === 65279;
+}
+function paintable(text) {
+  return [...text].filter((point) => !steersTheDisplay(point)).join("");
+}
+function formatInstant(atMs) {
+  if (atMs === null || !Number.isFinite(atMs)) return "never";
+  return `${new Date(atMs).toISOString().slice(0, 19).replace("T", " ")}Z`;
+}
+
+// src/tui/failure-text.ts
+var CLASSES = [2, 3, 4, 5];
+var isClass = (exitCode) => CLASSES.some((candidate) => candidate === exitCode);
+var fill = (template, code) => template.split("{code}").join(code);
+var ENTRIES = {
+  // ── 2 — input and configuration: the command was wrong, not the world ─────────────────────
+  "INVALID_ARGUMENTS@2": {
+    sentence: "{code} \u2014 the console built this command wrongly. Nothing was read or written.",
+    action: "Report it \u2014 no keystroke here should be able to produce it."
+  },
+  "INVALID_CONFIGURATION@2": {
+    sentence: "{code} \u2014 one code for six causes; the console cannot say which.",
+    action: "Check steps 0 and 1 on the profiles pane; the rest are on disk."
+  },
+  "INVALID_CONTACT_CARD@2": {
+    sentence: "{code} \u2014 that file is not a contact card the CLI can read, or it is too big.",
+    action: "Check the path, and that the file is the card they sent."
+  },
+  "INVALID_MESSAGE_ID@2": {
+    sentence: "{code} \u2014 the message id used here is not a UUID.",
+    action: "Report it: the console names no id of its own, so the CLI minted this one."
+  },
+  "INVALID_MESSAGE@2": {
+    sentence: "{code} \u2014 the body is longer than the CLI accepts; nothing was encrypted.",
+    action: "Shorten it; the compose row counts bytes once you are past half."
+  },
+  // ── 3 — trust and protocol: never flattened, because the CLI took trouble not to ──────────
+  "TRUST_REJECTED@3": {
+    sentence: "{code} \u2014 refused on trust grounds; no pin and no session changed.",
+    action: "Check the contact is pinned and the card you imported is the one they sent."
+  },
+  "CONTACT_NOT_CONFIRMED@3": {
+    sentence: "{code} \u2014 the import was answered with no, so nothing was pinned.",
+    action: "Press i again and answer y once all four identifiers match."
+  },
+  "INVALID_CONTACT_CARD@3": {
+    sentence: "{code} \u2014 the card read cleanly but failed validation; it may have expired.",
+    action: "Ask them to run contact export again and send you the new card."
+  },
+  "PROTOCOL_REJECTED@3": {
+    sentence: "{code} \u2014 the relay refused this, and will refuse the same request again.",
+    action: "Check both sides run the same build against the same relay."
+  },
+  "PREKEY_BUNDLE_UNAVAILABLE@3": {
+    sentence: "{code} \u2014 their side has no claimable prekey bundle. Not a trust failure.",
+    action: "Ask them to run relay publish, then try again."
+  },
+  "UNAUTHORIZED_MAILBOX_ACCESS@3": {
+    sentence: "{code} \u2014 the relay would not accept this profile as the sender.",
+    action: "Run step 2 (r) to publish this profile, then try again."
+  },
+  "SENDER_QUOTA_EXCEEDED@3": {
+    sentence: "{code} \u2014 your unacked allowance in their mailbox is full. Temporary.",
+    action: "It clears when they poll, or when the envelopes expire."
+  },
+  "CONTACT_NOT_TRUSTED@3": {
+    sentence: "{code} \u2014 that correspondent is not pinned in this profile.",
+    action: "Import their card first: profiles pane, i."
+  },
+  "CONTACT_PIN_MISMATCH@3": {
+    sentence: "{code} \u2014 the bundle the relay served is not the one you pinned. Stop.",
+    action: "Do not re-import a card sent the same way; check out of band."
+  },
+  "PREKEY_BUNDLE_EXPIRED@3": {
+    sentence: "{code} \u2014 the bundle pinned for them has expired.",
+    action: "Ask them to run relay publish, then try again."
+  },
+  "MESSAGE_ID_CONFLICT@3": {
+    sentence: "{code} \u2014 that message id was already used for different text.",
+    action: "Send again; each send takes a fresh id from the CLI."
+  },
+  "OUTBOUND_REJECTED@3": {
+    sentence: "{code} \u2014 the relay refused the envelope; nothing was delivered.",
+    action: "Check they are still published, then send again."
+  },
+  "SENDER_NOT_PUBLISHED@3": {
+    sentence: "{code} \u2014 this profile has never published, so this was refused locally.",
+    action: "Run step 2 (r) to publish, then send again."
+  },
+  "INBOUND_REJECTED@3": {
+    sentence: "{code} \u2014 the relay refused this profile's authentication; the poll stopped.",
+    action: "Check this profile is published to that relay, then poll again."
+  },
+  "CHALLENGE_EXPIRED@3": {
+    sentence: "{code} \u2014 the relay's challenge expired before the poll could use it.",
+    action: "Poll again; a slow or loaded relay is the usual cause."
+  },
+  "PROFILE_REJECTED@3": {
+    sentence: "{code} \u2014 the relay refused this profile's own record.",
+    action: "Re-run steps 1 and 2, and check the relay URL on the profiles pane."
+  },
+  // ── 4 — relay and network: the one class where retrying is the answer ─────────────────────
+  "RELAY_UNAVAILABLE@4": {
+    sentence: "{code} \u2014 the relay did not answer, so nothing was committed anywhere.",
+    action: "Check it is up at the URL on the profiles pane; retrying is safe."
+  },
+  // ── 5 — persistence: the one class where retrying is not ──────────────────────────────────
+  "PERSISTENCE_FAILURE@5": {
+    sentence: "{code} \u2014 the encrypted store could not be read or written.",
+    action: "Do not retry blindly: check the profile directory and its store-key variable."
+  }
+};
+var BY_COMMAND = {
+  "PERSISTENCE_FAILURE@5": {
+    "contact export": {
+      sentence: "{code} \u2014 one cause is that the path already exists; export never overwrites.",
+      action: "Export to a new path; a real storage failure looks the same."
+    }
+  }
+};
+var GENERIC = {
+  2: {
+    sentence: "{code} \u2014 the CLI refused the command as it was built, not the state of the world.",
+    action: "Correct the operand this command used and run it again."
+  },
+  3: {
+    sentence: "{code} \u2014 a trust or protocol refusal; no pin, session or trust state changed.",
+    action: "Read the code before retrying: repeated unchanged, it will be refused again."
+  },
+  4: {
+    sentence: "{code} \u2014 a relay or network failure; nothing was committed anywhere.",
+    action: "Check the relay at the URL on the profiles pane; retrying is safe."
+  },
+  5: {
+    sentence: "{code} \u2014 a persistence failure; the encrypted store could not be read or written.",
+    action: "Do not retry blindly \u2014 the store may be locked, or opened with a different key."
+  }
+};
+var UNCLASSED = {
+  sentence: "{code} \u2014 the CLI exited with a status this console has no class for.",
+  action: "Quote the code and the status exactly if you report this."
+};
+var UNREADABLE = {
+  sentence: "{code} \u2014 the CLI printed nothing the console could read, so it knows nothing more.",
+  action: "Run the same command in a terminal and read its output there."
+};
+function wordsFor(command, code, exitCode) {
+  if (code === UNREADABLE_CLI_OUTPUT) return UNREADABLE;
+  const key = `${code}@${String(exitCode)}`;
+  const override = BY_COMMAND[key]?.[command];
+  if (override !== void 0) return override;
+  const entry = ENTRIES[key];
+  if (entry !== void 0) return entry;
+  return isClass(exitCode) ? GENERIC[exitCode] : UNCLASSED;
+}
+function explain(command, code, exitCode) {
+  const words = wordsFor(command, code, exitCode);
+  const shown = paintable(code);
+  return {
+    command,
+    code,
+    exitCode,
+    sentence: fill(words.sentence, shown),
+    action: fill(words.action, shown)
+  };
+}
+
+// src/tui/modal-host.ts
+var TRUST_IDENTIFIER_FIELDS = [
+  "identity_id",
+  "device_id",
+  "device_pubkey",
+  "signal_identity_key"
+];
+var TRUST_MODAL_FOOTER = [
+  { key: "y", label: "trust" },
+  { key: "n", label: "reject" },
+  { key: "esc", label: "cancel" }
+];
+var MODAL_PANEL_CHROME_X = 4;
+var MODAL_PANEL_MIN_WIDTH = 56;
+var MODAL_PANEL_MIN_HEIGHT = 14;
+var MODAL_CHROME_ROWS = 4;
+var MODAL_PANEL_MAX_WIDTH = 80;
+var MODAL_PANEL_MAX_HEIGHT = 20;
+var MODAL_PANEL_MARGIN = 4;
+function resolveModalPanelSize(cols, rows) {
+  const available = (span, min, max) => Math.max(min, Math.min(Math.max(0, Math.floor(span) - MODAL_PANEL_MARGIN), max));
+  return {
+    width: available(cols, MODAL_PANEL_MIN_WIDTH, MODAL_PANEL_MAX_WIDTH),
+    height: available(rows, MODAL_PANEL_MIN_HEIGHT, MODAL_PANEL_MAX_HEIGHT)
+  };
+}
+function modalBodyRows(panelHeight) {
+  return Math.max(1, Math.floor(panelHeight) - MODAL_CHROME_ROWS);
+}
+function resolveModalInnerWidth(availableWidth) {
+  return Math.max(1, Math.floor(availableWidth) - MODAL_PANEL_CHROME_X);
+}
+function formatModalFooter(actions) {
+  return actions.map((action) => `[${action.key}] ${action.label}`).join("  ");
+}
+function trustModalIsComplete(modal) {
+  return TRUST_IDENTIFIER_FIELDS.every((field) => {
+    const value = modal.identifiers[field];
+    return typeof value === "string" && value.length > 0;
+  });
+}
+function renderModal(modal, viewport) {
+  const size = resolveModalPanelSize(viewport.cols, viewport.rows);
+  const inner = resolveModalInnerWidth(size.width);
+  const rule = "\u2500".repeat(Math.max(0, size.width - 2));
+  const body = [`profile: ${modal.profileLabel}`, `card: ${modal.cardPath}`];
+  for (const field of TRUST_IDENTIFIER_FIELDS) {
+    const value = modal.identifiers[field];
+    body.push(`${field}:`);
+    body.push(typeof value === "string" && value.length > 0 ? `  ${value}` : "  (missing)");
+  }
+  const bodyRows2 = modalBodyRows(size.height);
+  const painted = body.slice(0, bodyRows2);
+  while (painted.length < bodyRows2) painted.push("");
+  const boxed = (text) => `\u2502 ${padOrClip(clipLine(text, inner), inner)} \u2502`;
+  const lines = [
+    `\u256D${rule}\u256E`,
+    boxed("Trust these contact identifiers?"),
+    ...painted.map(boxed),
+    boxed(formatModalFooter(TRUST_MODAL_FOOTER)),
+    `\u2570${rule}\u256F`
+  ];
+  while (lines.length < size.height) lines.push(boxed(""));
+  return lines.slice(0, size.height).map((line) => padOrClip(line, size.width));
+}
+function modalIntent(key) {
+  if (key.ctrl) return void 0;
+  switch (key.name) {
+    case "y":
+      return "trust-confirm";
+    case "n":
+      return "trust-cancel";
+    case "escape":
+      return "trust-cancel";
+    default:
+      return void 0;
+  }
+}
+
+// src/tui/pane-fit.ts
+function rowLines(row) {
+  return typeof row === "string" ? [row] : row;
+}
+function truncationMarker(hidden) {
+  return `\u2026 ${String(hidden)} more not shown`;
+}
+function keepItems(rows, keep, room, budget) {
+  const kept = [];
+  let used = 0;
+  if (room <= 0) return { kept, used };
+  const ordered = keep === "tail" ? [...rows].reverse() : rows;
+  for (const row of ordered) {
+    const height = rowLines(row).length;
+    if (kept.length > 0 && used + height > budget) break;
+    kept.push(row);
+    used += height;
+    if (used >= budget) break;
+  }
+  if (keep === "tail") kept.reverse();
+  return { kept, used };
+}
+function fitPane(regions, limit, width) {
+  const tail = regions.tail ?? [];
+  const clip = (line) => clipLine(line, width);
+  const listLines = regions.rows.flatMap((row) => [...rowLines(row)]);
+  const all = [...regions.head, ...listLines, ...tail];
+  if (!Number.isFinite(limit)) return all.map(clip);
+  const cap = Math.max(0, Math.floor(limit));
+  if (all.length <= cap) return all.map(clip);
+  if (regions.rows.length === 0) return all.slice(0, cap).map(clip);
+  const room = Math.max(0, cap - 1);
+  const wanted = regions.head.length + tail.length;
+  const { kept, used } = keepItems(regions.rows, regions.keep, room, room - wanted);
+  const fixed = Math.max(0, Math.min(wanted, room - used));
+  const headRoom = Math.min(regions.head.length, fixed);
+  const tailRoom = Math.max(0, fixed - headRoom);
+  return [
+    ...regions.head.slice(0, headRoom),
+    ...kept.flatMap((row) => [...rowLines(row)]),
+    truncationMarker(regions.rows.length - kept.length),
+    ...tail.slice(tail.length - tailRoom)
+  ].slice(0, cap).map(clip);
+}
+
+// src/tui/history-pane.ts
+var BODY_INDENT = "    ";
+var MAX_BODY_ROWS = 4;
+var ELLIPSIS = "\u2026";
+function bodyRows(body, width) {
+  const room = Math.max(1, Math.floor(width) - BODY_INDENT.length);
+  const points = codePoints(body);
+  if (points.length === 0) return [];
+  const wrapped = [];
+  for (let at = 0; at < points.length; at += room) wrapped.push(points.slice(at, at + room).join(""));
+  if (wrapped.length <= MAX_BODY_ROWS) return wrapped.map((row) => `${BODY_INDENT}${row}`);
+  const kept = wrapped.slice(0, MAX_BODY_ROWS);
+  const last = codePoints(kept[MAX_BODY_ROWS - 1] ?? "");
+  kept[MAX_BODY_ROWS - 1] = `${last.slice(0, Math.max(0, room - 1)).join("")}${ELLIPSIS}`;
+  return kept.map((row) => `${BODY_INDENT}${row}`);
+}
+function buildHistorySnapshot(source) {
+  const { entries, selectedContactId } = source;
+  if (selectedContactId === null) {
+    return { contactIdentityId: null, lines: [], withheldCount: entries.length };
+  }
+  const selected = entries.filter((entry) => entry.contactIdentityId === selectedContactId);
+  const lines = selected.map((entry) => ({
+    meta: `${entry.sequence}  ${entry.direction}  ${entry.messageId}`,
+    body: entry.plaintext
+  }));
+  return { contactIdentityId: selectedContactId, lines, withheldCount: entries.length - selected.length };
+}
+function formatHistoryLines(snapshot, width, limit = Number.POSITIVE_INFINITY) {
+  const head = [];
+  const rows = [];
+  if (snapshot.contactIdentityId === null) {
+    head.push("no contact selected \u2014 history is shown only on an explicit request");
+  } else {
+    head.push(`history with ${snapshot.contactIdentityId}`);
+    if (snapshot.lines.length === 0) head.push("  no entries for this contact");
+    else for (const entry of snapshot.lines) rows.push([`  ${entry.meta}`, ...bodyRows(entry.body, width)]);
+  }
+  const tail = snapshot.withheldCount > 0 ? ["", `${snapshot.withheldCount} entries withheld (other contacts)`] : [];
+  return fitPane({ head, rows, tail, keep: "tail" }, limit, width);
+}
+
+// src/tui/mailbox-pane.ts
+function countedValue(count, unit, absent) {
+  return count === null ? absent : `${String(count)} ${unit}`;
+}
+function buildMailboxSnapshot(source) {
+  const { mailbox, rejections } = source;
+  const rows = [
+    // Two rows, two different silences, and each says which one it is.
+    //
+    // The outbox row is empty because the frozen eight-command surface has nothing that reports a
+    // pending count (see `MailboxView`), so the row names the gap rather than disappearing: an
+    // operator who cannot see that the console has no view of its own outbox will assume it has one.
+    // The inbox row is empty only until the first poll, which is a different sentence.
+    { label: "outbox", value: countedValue(mailbox.outboxPending, "pending", "no command reports an outbox count") },
+    // "received" is what the LAST poll accepted and committed, not a session or store total, so the
+    // row says which poll it is talking about. The `last poll` row below carries when that was.
+    { label: "inbox", value: countedValue(mailbox.inboxReceived, "received by the last poll", "no poll has reported yet") },
+    // The relay's remaining-work signal is what tells the operator to poll again; a pane that hid
+    // it would make a partially drained mailbox look empty.
+    { label: "more", value: mailbox.more ? "yes \u2014 poll again" : "no" },
+    { label: "last poll", value: formatInstant(mailbox.lastPolledAtMs) }
+  ];
+  return { rows, rejectionLines: rejections.map(formatRejectionLine), rejectionCount: rejections.length };
+}
+function formatMailboxLines(snapshot, width, limit = Number.POSITIVE_INFINITY) {
+  const head = snapshot.rows.map((row) => labelled(row.label, row.value));
+  if (snapshot.rejectionCount > 0) {
+    head.push("");
+    head.push(labelled("rejected", `${snapshot.rejectionCount} permanently unacceptable`));
+  }
+  const rows = snapshot.rejectionLines.map((rejection) => `  ${rejection}`);
+  return fitPane({ head, rows, keep: "tail" }, limit, width);
+}
+function formatRejectionLine(rejection) {
+  return `${rejection.envelopeId}  ${rejection.code}`;
+}
+
+// src/tui/profiles-pane.ts
+var SETUP_TITLES = [
+  ["store key", ""],
+  ["create profile", "init"],
+  ["publish", "relay publish"],
+  ["export card", "contact export"],
+  ["import card", "contact import"],
+  ["confirm", "doctor"]
+];
+var STEP_GUTTER = " ".repeat(8);
+var TITLE_WIDTH = 16;
+var COMMAND_WIDTH = 16;
+function storeKeyRecipe(storeKeyEnv) {
+  return `export ${storeKeyEnv}="$(head -c 32 /dev/urandom | base64 | tr '+/' '-_' | tr -d '=')"`;
+}
+function stepStatus(outcome) {
+  if (outcome === void 0 || outcome === "pending") return "pending";
+  if (outcome === "ok") return "ok";
+  return `${outcome.failed} (exit ${String(outcome.exitCode)})`;
+}
+function stepHint(step, outcome) {
+  if (outcome === void 0 || outcome === "pending" || outcome === "ok") return void 0;
+  if (step !== 3 || outcome.exitCode !== 5) return void 0;
+  return "a file at that path already exists \u2014 `contact export` never overwrites one";
+}
+function buildSetupLines(profile) {
+  const setup = profile.setup ?? [];
+  const lines = ["registration \u2014 [enter] starts the next step"];
+  for (let step = 0; step < SETUP_STEPS; step += 1) {
+    const [title, command] = SETUP_TITLES[step] ?? ["", ""];
+    const prefix = `step ${String(step)}  ${padOrClip(title, TITLE_WIDTH)}`;
+    if (step === 0) {
+      if (profile.storeKeyPresent === true) {
+        lines.push(`${prefix}${padOrClip("", COMMAND_WIDTH)}ok`);
+        continue;
+      }
+      lines.push(`${prefix}${profile.storeKeyEnv} is not set in this console's environment`);
+      lines.push(`${STEP_GUTTER}${padOrClip("", TITLE_WIDTH)}run this in your shell, then restart the console:`);
+      lines.push(`${STEP_GUTTER}${padOrClip("", TITLE_WIDTH)}  ${storeKeyRecipe(profile.storeKeyEnv)}`);
+      continue;
+    }
+    lines.push(`${prefix}${padOrClip(command, COMMAND_WIDTH)}${stepStatus(setup[step])}`);
+    const hint = stepHint(step, setup[step]);
+    if (hint !== void 0) lines.push(`${STEP_GUTTER}${padOrClip("", TITLE_WIDTH)}${hint}`);
+  }
+  return lines;
+}
+function formatHealthLine(health) {
+  switch (health.status) {
+    case "healthy": {
+      const uptime = health.uptimeMs === null ? "" : `uptime ${health.uptimeMs} ms, `;
+      return `relay ${health.relayUrl} healthy (${uptime}checked ${formatInstant(health.checkedAtMs)})`;
+    }
+    case "unreachable":
+      return `relay ${health.relayUrl} unreachable (checked ${formatInstant(health.checkedAtMs)})`;
+    case "unknown":
+    default:
+      return `relay ${health.relayUrl} not yet checked`;
+  }
+}
+function buildProfilesSnapshot(source) {
+  const { profile, contacts, health } = source;
+  const rows = [
+    { label: "profile", value: profile.label },
+    { label: "relay", value: profile.relayUrl },
+    // The NAME of the environment variable, so two profiles can be told apart. Never its value:
+    // there is no field on `ProfileView` that could hold one. See `tui.keyMaterial.test.ts`.
+    { label: "store-key-env", value: profile.storeKeyEnv },
+    { label: "identity", value: profile.identityId },
+    { label: "device", value: profile.deviceId },
+    // `send` presupposes `relay publish`; an unpublished profile is refused
+    // UNAUTHORIZED_MAILBOX_ACCESS, and the operator should see why before sending. `doctor` does
+    // not report publication state, so like the roster this is what the SESSION observed — and it
+    // says so, rather than reporting a bare "no" about a profile that may well be published.
+    { label: "published", value: profile.published ? "yes, by this session" : "not observed by this session" },
+    { label: "directory", value: profile.profileDir }
+  ];
+  const contactLines = contacts.map((contact) => `${contact.identityId}  ${contact.deviceId}`);
+  const unseen = profile.contactCount - contacts.length;
+  const rosterDiscrepancy = unseen > 0 ? `+${unseen} pinned by doctor but not seen by this session (no CLI command lists contacts)` : null;
+  return {
+    rows,
+    contactLines,
+    rosterDiscrepancy,
+    healthLine: formatHealthLine(health),
+    setupLines: profileIsInSetup(profile) ? buildSetupLines(profile) : null
+  };
+}
+function formatProfilesLines(snapshot, width, limit = Number.POSITIVE_INFINITY) {
+  if (snapshot.setupLines !== null) {
+    return fitPane({ head: snapshot.setupLines, rows: [], tail: ["", snapshot.healthLine], keep: "head" }, limit, width);
+  }
+  const head = snapshot.rows.map((row) => labelled(row.label, row.value));
+  head.push("");
+  head.push(labelled("contacts", `${snapshot.contactLines.length} observed this session`));
+  if (snapshot.rosterDiscrepancy !== null) head.push(snapshot.rosterDiscrepancy);
+  const rows = snapshot.contactLines.map((contact) => `  ${contact}`);
+  return fitPane({ head, rows, tail: ["", snapshot.healthLine], keep: "head" }, limit, width);
+}
+
+// src/tui/shell-chrome.ts
+var UNAUDITED_NOTICE = "UNAUDITED PROTOTYPE \u2014 not suitable for sensitive communication";
+var MIN_VIEWPORT = { cols: 72, rows: 16 };
+function isBelowMinViewport(viewport) {
+  return Math.floor(viewport.cols) < MIN_VIEWPORT.cols || Math.floor(viewport.rows) < MIN_VIEWPORT.rows;
+}
+function fitLine(text, cols) {
+  return padOrClip(text, cols);
+}
+var FIRST_OVERLAY_ROW = 1;
+var HEAD_ROWS = 3;
+var TAIL_ROWS = 2;
+function headerLine(state) {
+  const profile = state.profiles[state.activeProfile];
+  const tabs = PANE_IDS.map((pane, index) => pane === state.pane ? `[${index + 1} ${pane}]` : ` ${index + 1} ${pane} `).join("");
+  return `echolet operator \xB7 ${profile?.label ?? "no profile"} \xB7${tabs}`;
+}
+var FOOTER_KEYS = [
+  { label: "[1-5] pane", rank: 3 },
+  { label: "[p] poll", rank: 4 },
+  { label: "[d] doctor", rank: 5 },
+  { label: "[r] publish", rank: 6 },
+  { label: "[h] history", rank: 7 },
+  { label: "[i] import", rank: 8 },
+  { label: "[c] contact", rank: 9 },
+  { label: "[t] profile", rank: 10 },
+  { label: "[?] help", rank: 2 },
+  { label: "[q] quit", rank: 1 }
+];
+var FOOTER_KEYS_HELP_OPEN = FOOTER_KEYS.map((entry) => entry.label === "[?] help" ? { label: "[?] close", rank: entry.rank } : entry);
+var FOOTER_SEPARATOR = "  ";
+function fitFooter(entries, cols) {
+  const byRank = entries.map((_, index) => index).sort((left, right) => (entries[left]?.rank ?? 0) - (entries[right]?.rank ?? 0));
+  const paint = (chosen2) => [...chosen2].sort((left, right) => left - right).map((index) => entries[index]?.label ?? "").join(FOOTER_SEPARATOR);
+  const chosen = [];
+  for (const index of byRank) {
+    const candidate = paint([...chosen, index]);
+    if (codePoints(candidate).length > Math.max(0, Math.floor(cols))) break;
+    chosen.push(index);
+  }
+  return paint(chosen);
+}
+function footerLine(state, cols) {
+  if (state.modal !== void 0) return "[y] trust  [n] reject  [esc] cancel  [ctrl-c] quit";
+  const input = state.input;
+  if (input !== void 0) {
+    return `${submitLabel(input)}[esc] cancel  [ctrl-c] quit`;
+  }
+  return fitFooter(state.help === true ? FOOTER_KEYS_HELP_OPEN : FOOTER_KEYS, cols);
+}
+function submitLabel(input) {
+  switch (input.field) {
+    case "message":
+      return "[enter] send  ";
+    case "relay-url":
+    case "export-path":
+    case "card-path":
+      return "[enter] run  ";
+    default:
+      return "";
+  }
+}
+function composeLine(input, cols) {
+  const label = `${input.field} \u25B8 `;
+  const used = utf8Bytes(input.buffer);
+  const counter = used * 2 > input.maxBytes ? `  ${String(used)}/${String(input.maxBytes)} bytes` : "";
+  const room = Math.max(0, Math.floor(cols) - codePoints(label).length - codePoints(counter).length);
+  const points = codePoints(input.buffer);
+  const shown = points.length <= room ? input.buffer : points.slice(points.length - room).join("");
+  return `${label}${shown}${counter}`;
+}
+function activityLine(state) {
+  const latest = state.activity.at(-1);
+  const text = latest?.text ?? "no activity yet";
+  return state.busy ? `running\u2026 (busy \u2014 a command key starts nothing) ${text}` : text;
+}
+var HELP_LINES_HEAD = [
+  "key bindings",
+  "  1-5        select pane",
+  "  enter      start the next registration step (profiles pane, while one is left)",
+  "  p          poll",
+  "  d          doctor",
+  "  r          relay publish",
+  "  h          history for the selected contact",
+  "  w          write a message (history pane, with a contact selected)",
+  "  i          import the contact card named at startup",
+  "  c          next contact",
+  "  t          next profile",
+  "  ?          close this list"
+];
+function helpQuitLine(state) {
+  return state.modal !== void 0 || state.input !== void 0 ? "  ctrl-c     quit" : "  q          quit (ctrl-c also quits)";
+}
+function helpLines(state) {
+  return [...HELP_LINES_HEAD, helpQuitLine(state)];
+}
+function paneLines(state, pane, width, bodyRows2) {
+  if (state.help === true) {
+    const lines = helpLines(state);
+    return fitPane({ head: [lines[0] ?? ""], rows: lines.slice(1), keep: "head" }, bodyRows2, width);
+  }
+  const profile = state.profiles[state.activeProfile];
+  switch (pane) {
+    case "profiles": {
+      if (profile === void 0) return [clipLine("no profile configured \u2014 run init first", width)];
+      return formatProfilesLines(buildProfilesSnapshot({ profile, contacts: state.contacts, health: state.health }), width, bodyRows2);
+    }
+    case "mailbox":
+      return formatMailboxLines(buildMailboxSnapshot({ mailbox: state.mailbox, rejections: state.rejections }), width, bodyRows2);
+    case "history":
+      return formatHistoryLines(buildHistorySnapshot({ entries: state.history, selectedContactId: state.selectedContactId }), width, bodyRows2);
+    case "rejections": {
+      const snapshot = buildMailboxSnapshot({ mailbox: state.mailbox, rejections: state.rejections });
+      if (snapshot.rejectionCount === 0) return [clipLine("no permanently rejected envelopes in the last poll", width)];
+      return fitPane({
+        head: [`${snapshot.rejectionCount} rejected by the last poll`],
+        rows: snapshot.rejectionLines.map((line) => `  ${line}`),
+        // The untriaged rejections are the ones that arrived last; `poll` reports them in arrival
+        // order, so the tail is what the operator has not yet decided about.
+        keep: "tail"
+      }, bodyRows2, width);
+    }
+    case "health": {
+      const snapshot = buildProfilesSnapshot({
+        profile: profile ?? { label: "-", profileDir: "-", relayUrl: state.health.relayUrl, storeKeyEnv: "-", identityId: "-", deviceId: "-", contactCount: 0, published: false },
+        contacts: state.contacts,
+        health: state.health
+      });
+      return [clipLine(snapshot.healthLine, width), "", clipLine(`status  ${state.health.status}`, width)];
+    }
+    default:
+      return [];
+  }
+}
+function tooSmallFrame(state, cols, rows) {
+  const composing = state.input !== void 0;
+  const ctrlCOnly = state.modal !== void 0 || composing;
+  const lines = [
+    ...wrapToWidth(UNAUDITED_NOTICE, cols),
+    "",
+    ...wrapToWidth(`${String(cols)}x${String(rows)} \u2014 this console needs ${String(MIN_VIEWPORT.cols)}x${String(MIN_VIEWPORT.rows)}`, cols),
+    // While a buffer is open `q` is text, and while a modal is open `q` answers nothing, so naming it
+    // here would be the lie `footerLine` refuses. Ctrl-C is the binding that survives both, so it is
+    // the one this frame offers.
+    ...wrapToWidth(ctrlCOnly ? "resize, or press ctrl-c to quit" : "resize, or press q to quit", cols)
+  ];
+  if (state.modal !== void 0) lines.push("", ...wrapToWidth("a trust decision is waiting \u2014 resize to answer it", cols));
+  if (composing) lines.push("", ...wrapToWidth("a message is being composed \u2014 resize to see and send it", cols));
+  return lines;
+}
+function wrapToWidth(text, cols) {
+  const points = codePoints(text);
+  if (points.length === 0) return [""];
+  const lines = [];
+  for (let at = 0; at < points.length; at += cols) lines.push(points.slice(at, at + cols).join(""));
+  return lines;
+}
+function renderFrame(state, viewport) {
+  const cols = Math.max(1, Math.floor(viewport.cols));
+  const rows = Math.max(1, Math.floor(viewport.rows));
+  if (isBelowMinViewport({ cols, rows })) {
+    const degraded = tooSmallFrame(state, cols, rows).slice(0, rows).map((line) => fitLine(line, cols));
+    while (degraded.length < rows) degraded.push(fitLine("", cols));
+    return degraded;
+  }
+  const head = [UNAUDITED_NOTICE, headerLine(state), "\u2500".repeat(cols)].slice(0, Math.min(HEAD_ROWS, rows));
+  const tail = [activityLine(state), footerLine(state, cols)].slice(0, Math.max(0, Math.min(TAIL_ROWS, rows - head.length)));
+  const bodyRows2 = Math.max(0, rows - head.length - tail.length);
+  const input = state.input;
+  const composeRows = input !== void 0 && bodyRows2 > 0 ? 1 : 0;
+  const paneRows = bodyRows2 - composeRows;
+  const body = paneLines(state, state.pane, cols, paneRows).slice(0, paneRows);
+  while (body.length < paneRows) body.push("");
+  if (input !== void 0 && composeRows === 1) body.push(composeLine(input, cols));
+  const frame = [...head, ...body, ...tail].map((line) => fitLine(line, cols));
+  return state.modal === void 0 ? frame : overlayModal(frame, state, { cols, rows });
+}
+function overlayModal(frame, state, viewport) {
+  const modal = state.modal;
+  if (modal === void 0) return frame;
+  const size = resolveModalPanelSize(viewport.cols, viewport.rows);
+  const panel = renderModal(modal, viewport);
+  const top = Math.min(
+    Math.max(FIRST_OVERLAY_ROW, Math.floor((viewport.rows - size.height) / 2)),
+    Math.max(FIRST_OVERLAY_ROW, viewport.rows - size.height)
+  );
+  const left = Math.max(0, Math.floor((viewport.cols - size.width) / 2));
+  const painted = [...frame];
+  panel.forEach((panelLine, index) => {
+    const row = top + index;
+    const base = painted[row];
+    if (base === void 0) return;
+    const cells = codePoints(base);
+    codePoints(panelLine).forEach((cell, offset) => {
+      const column = left + offset;
+      if (column >= 0 && column < cells.length) cells[column] = cell;
+    });
+    painted[row] = cells.join("");
+  });
+  return painted;
+}
+var ESC = String.fromCharCode(27);
+var BOLD = `${ESC}[1m`;
+var DIM = `${ESC}[2m`;
+var RESET = `${ESC}[0m`;
+function styleFrame(frame) {
+  return frame.map((line, index) => {
+    if (line.includes(UNAUDITED_NOTICE)) return `${BOLD}${line}${RESET}`;
+    if (index === 1) return `${BOLD}${line}${RESET}`;
+    return line.startsWith("\u2500") ? `${DIM}${line}${RESET}` : line;
+  });
+}
+
+// src/tui/tui-shell.ts
+function mapKey(key, state) {
+  if (state.modal !== void 0) {
+    if (key.ctrl) return key.name.toLowerCase() === "c" ? { kind: "quit" } : void 0;
+    const intent2 = modalIntent(key);
+    if (intent2 === "trust-confirm") return { kind: "trust-confirm" };
+    if (intent2 === "trust-cancel") return { kind: "trust-cancel" };
+    return void 0;
+  }
+  if (state.input !== void 0) return inputKey(key);
+  if (key.ctrl) return key.name.toLowerCase() === "c" ? { kind: "quit" } : void 0;
+  if (key.name === "q") return { kind: "quit" };
+  if (key.name === "?") return { kind: "toggle-help" };
+  const ordinal = /^[1-9]$/.test(key.name) ? Number(key.name) : 0;
+  const pane = PANE_IDS[ordinal - 1];
+  if (pane !== void 0) return { kind: "select-pane", pane };
+  const intent = paneKeyIntent(key, state);
+  if (state.busy && intent?.kind === "run") return void 0;
+  return intent;
+}
+function inputKey(key) {
+  if (key.ctrl) return key.name.toLowerCase() === "c" ? { kind: "quit" } : void 0;
+  if (key.sequence.startsWith(ESC2)) return key.sequence === ESC2 ? { kind: "input-cancel" } : void 0;
+  if (key.sequence === "\r" || key.sequence === "\n") return { kind: "input-submit" };
+  if (key.sequence === DEL) return { kind: "input-backspace" };
+  if (key.sequence === "") return void 0;
+  return { kind: "input-insert", text: key.sequence };
+}
+function paneKeyIntent(key, state) {
+  const profile = state.profiles[state.activeProfile];
+  if (profile === void 0) return void 0;
+  switch (key.name) {
+    case "p":
+      return { kind: "run", request: { command: "poll", profileDir: profile.profileDir } };
+    case "d":
+      return { kind: "run", request: { command: "doctor", profileDir: profile.profileDir } };
+    case "r":
+      return { kind: "run", request: { command: "relay publish", profileDir: profile.profileDir } };
+    case "h":
+      return state.selectedContactId === null ? void 0 : { kind: "run", request: { command: "history", profileDir: profile.profileDir, contactIdentityId: state.selectedContactId } };
+    case "i":
+      return profile.contactCardPath === void 0 ? void 0 : { kind: "run", request: { command: "contact import", profileDir: profile.profileDir, from: profile.contactCardPath } };
+    case "w":
+      return state.pane !== "history" || state.selectedContactId === null || state.busy || profile.published !== true ? void 0 : { kind: "input-open", field: "message" };
+    case "return":
+      return state.pane !== "profiles" || state.busy ? void 0 : setupStepIntent(profile);
+    case "c": {
+      const next = state.contacts[(state.contacts.findIndex((contact) => contact.identityId === state.selectedContactId) + 1) % Math.max(1, state.contacts.length)];
+      return next === void 0 ? void 0 : { kind: "select-contact", identityId: next.identityId };
+    }
+    case "t":
+      return state.profiles.length < 2 ? void 0 : { kind: "select-profile", index: (state.activeProfile + 1) % state.profiles.length };
+    default:
+      return void 0;
+  }
+}
+function setupStepIntent(profile) {
+  const step = nextSetupStep(profile);
+  const profileDir = profile.profileDir;
+  switch (step) {
+    case 1:
+      return profile.relayUrl === "" ? { kind: "input-open", field: "relay-url" } : { kind: "run", request: { command: "init", profileDir, relayUrl: profile.relayUrl, storeKeyEnv: profile.storeKeyEnv } };
+    case 2:
+      return { kind: "run", request: { command: "relay publish", profileDir } };
+    case 3:
+      return { kind: "input-open", field: "export-path" };
+    case 4:
+      return { kind: "input-open", field: "card-path" };
+    case 5:
+      return { kind: "run", request: { command: "doctor", profileDir } };
+    default:
+      return void 0;
+  }
+}
+function cardInstant(atMs) {
+  const at = Number.isFinite(atMs) ? atMs : 0;
+  return new Date(at).toISOString().replace(/[-:.]/g, "");
+}
+function initialBuffer(state, field) {
+  const profile = state.profiles[state.activeProfile];
+  if (profile === void 0) return "";
+  switch (field) {
+    case "export-path":
+      return `${profile.profileDir}/card-${cardInstant(state.observedAtMs ?? 0)}.json`;
+    case "card-path":
+      return profile.contactCardPath ?? "";
+    default:
+      return "";
+  }
+}
+function reduce(state, intent) {
+  switch (intent.kind) {
+    case "select-pane":
+      return { state: { ...state, pane: intent.pane }, effects: [] };
+    case "select-profile": {
+      const index = Number.isInteger(intent.index) && intent.index >= 0 && intent.index < state.profiles.length ? intent.index : state.activeProfile;
+      return { state: { ...state, activeProfile: index }, effects: [] };
+    }
+    case "select-contact":
+      return { state: { ...state, selectedContactId: intent.identityId }, effects: [] };
+    case "toggle-help":
+      return { state: { ...state, help: state.help !== true }, effects: [] };
+    case "run":
+      if (state.busy) return { state, effects: [] };
+      return { state: { ...state, busy: true }, effects: [{ kind: "run-cli", request: intent.request }] };
+    case "trust-confirm": {
+      const modal = state.modal;
+      if (modal === void 0 || modal.renderedAt === null || !trustModalIsComplete(modal)) {
+        return { state, effects: [] };
+      }
+      return { state: { ...state, modal: void 0 }, effects: [{ kind: "answer-trust-prompt", answer: true }] };
+    }
+    case "trust-cancel":
+      if (state.modal === void 0) return { state, effects: [] };
+      return { state: { ...state, modal: void 0 }, effects: [{ kind: "answer-trust-prompt", answer: false }] };
+    case "input-open":
+      if (state.modal !== void 0 || state.busy) return { state, effects: [] };
+      return {
+        state: {
+          ...state,
+          // Unpainted, exactly like `buildTrustModal`'s `renderedAt: null`: the shell stamps it
+          // after the frame carrying the row was written, and never before.
+          input: { field: intent.field, buffer: initialBuffer(state, intent.field), renderedAt: null, maxBytes: inputMaxBytes(intent.field) }
+        },
+        effects: []
+      };
+    case "input-insert": {
+      const input = state.input;
+      if (input === void 0 || state.modal !== void 0) return { state, effects: [] };
+      const text = paintable(intent.text);
+      if (text === "") return { state, effects: [] };
+      const buffer = input.buffer + text;
+      if (utf8Bytes(buffer) > input.maxBytes) return { state, effects: [] };
+      return { state: { ...state, input: { ...input, buffer } }, effects: [] };
+    }
+    case "input-backspace": {
+      const input = state.input;
+      if (input === void 0 || state.modal !== void 0) return { state, effects: [] };
+      const points = [...input.buffer];
+      points.pop();
+      return { state: { ...state, input: { ...input, buffer: points.join("") } }, effects: [] };
+    }
+    case "input-cancel":
+      if (state.input === void 0) return { state, effects: [] };
+      return { state: { ...state, input: void 0 }, effects: [] };
+    case "input-submit": {
+      const input = state.input;
+      if (input === void 0 || state.modal !== void 0 || state.busy) return { state, effects: [] };
+      if (input.renderedAt === null) return { state, effects: [] };
+      const request = submitRequest(state, input);
+      if (request === void 0) return { state, effects: [] };
+      const profiles = request.command !== "init" ? state.profiles : state.profiles.map((profile, index) => index === state.activeProfile ? { ...profile, relayUrl: request.relayUrl } : profile);
+      return { state: { ...state, profiles, input: void 0, busy: true }, effects: [{ kind: "run-cli", request }] };
+    }
+    case "quit":
+      return { state, effects: [{ kind: "quit" }] };
+    default:
+      return { state, effects: [] };
+  }
+}
+function paintableIdentifiers(identifiers) {
+  const clean = (value) => value === void 0 ? void 0 : paintable(value);
+  return {
+    identity_id: clean(identifiers.identity_id),
+    device_id: clean(identifiers.device_id),
+    device_pubkey: clean(identifiers.device_pubkey),
+    signal_identity_key: clean(identifiers.signal_identity_key)
+  };
+}
+function submitRequest(state, input) {
+  const profile = state.profiles[state.activeProfile];
+  if (profile === void 0) return void 0;
+  const value = input.buffer;
+  const profileDir = profile.profileDir;
+  switch (input.field) {
+    case "message": {
+      const to = state.selectedContactId;
+      if (to === null || value === "" || profile.published !== true) return void 0;
+      return { command: "send", profileDir, to, text: value };
+    }
+    case "relay-url":
+      if (value === "" || profile.storeKeyPresent !== true) return void 0;
+      return { command: "init", profileDir, relayUrl: value, storeKeyEnv: profile.storeKeyEnv };
+    case "export-path":
+      if (value === "") return void 0;
+      return { command: "contact export", profileDir, out: value };
+    case "card-path":
+      if (value === "") return void 0;
+      return { command: "contact import", profileDir, from: value };
+    default:
+      return void 0;
+  }
+}
+var ESC2 = String.fromCharCode(27);
+var CTRL_C = String.fromCharCode(3);
+var DEL = String.fromCharCode(127);
+var ALTERNATE_SCREEN_ON = `${ESC2}[?1049h${ESC2}[?25l`;
+var ALTERNATE_SCREEN_OFF = `${ESC2}[?25h${ESC2}[?1049l`;
+var HOME = `${ESC2}[H${ESC2}[2J`;
+function decodeKey(chunk) {
+  const sequence = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+  if (sequence === CTRL_C) return { name: "c", ctrl: true, sequence };
+  if (sequence === ESC2) return { name: "escape", ctrl: false, sequence };
+  if (sequence === "\r" || sequence === "\n") return { name: "return", ctrl: false, sequence };
+  const first = [...sequence][0] ?? "";
+  const code = first.charCodeAt(0);
+  if (Number.isFinite(code) && code > 0 && code < 27) {
+    return { name: String.fromCharCode(code + 96), ctrl: true, sequence };
+  }
+  return { name: first.toLowerCase(), ctrl: false, sequence };
+}
+function splitKeystrokes(chunk) {
+  const points = [...chunk];
+  const keys = [];
+  for (let at = 0; at < points.length; at += 1) {
+    const point = points[at] ?? "";
+    if (point === ESC2) {
+      keys.push(points.slice(at).join(""));
+      return keys;
+    }
+    keys.push(point);
+  }
+  return keys;
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var asNumber = (value, fallback) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
+function readRejections(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    if (!isRecord(entry)) return [];
+    const envelopeId = entry.envelopeId;
+    const code = entry.code;
+    return typeof envelopeId === "string" && typeof code === "string" ? [{ envelopeId: paintable(envelopeId), code: paintable(code) }] : [];
+  });
+}
+function readHistoryEntries(value) {
+  if (!isRecord(value) || !Array.isArray(value.entries)) return [];
+  return value.entries.flatMap((entry) => {
+    if (!isRecord(entry)) return [];
+    const { sequence, contactIdentityId, messageId, direction, plaintext, createdAtMs } = entry;
+    if (typeof contactIdentityId !== "string" || typeof messageId !== "string" || typeof plaintext !== "string") return [];
+    if (direction !== "inbound" && direction !== "outbound") return [];
+    return [{
+      sequence: asNumber(sequence, 0),
+      contactIdentityId: paintable(contactIdentityId),
+      messageId: paintable(messageId),
+      direction,
+      plaintext: paintable(plaintext),
+      createdAtMs: asNumber(createdAtMs, 0)
+    }];
+  });
+}
+var SETUP_STEP_OF = {
+  init: 1,
+  "relay publish": 2,
+  "contact export": 3,
+  "contact import": 4,
+  doctor: 5
+};
+function stepSucceeded(request, outcome) {
+  if (request.command !== "doctor") return true;
+  return isRecord(outcome.data) && asNumber(outcome.data.contact_count, 0) > 0;
+}
+function reportedIdentity(request, outcome) {
+  if (request.command !== "init" && request.command !== "doctor") return void 0;
+  if (!outcome.ok || !isRecord(outcome.data)) return void 0;
+  return typeof outcome.data.identity_id === "string" ? outcome.data.identity_id : void 0;
+}
+function foldSetup(state, request, outcome) {
+  const step = SETUP_STEP_OF[request.command];
+  const identity = reportedIdentity(request, outcome);
+  const absent = !outcome.ok && outcome.code === "INVALID_CONFIGURATION" && outcome.exitCode === 2;
+  return state.profiles.map((profile, index) => {
+    const setup = profile.setup;
+    if (index !== state.activeProfile || setup === void 0) return profile;
+    const profileState = absent ? "absent" : identity !== void 0 ? "ready" : profile.state;
+    if (step === void 0) return { ...profile, state: profileState };
+    const value = outcome.ok ? stepSucceeded(request, outcome) ? "ok" : "pending" : { failed: paintable(outcome.code), exitCode: outcome.exitCode };
+    const folded = setup.map((previous, at) => at === step ? value : at > step ? "pending" : previous);
+    return { ...profile, state: profileState, setup: folded };
+  });
+}
+function reportedCount(value, previous) {
+  return typeof value === "number" && Number.isFinite(value) ? value : previous;
+}
+function applyOutcome(state, request, outcome, atMs) {
+  const health = outcome.ok ? { ...state.health, status: "healthy", checkedAtMs: atMs } : outcome.exitCode === 4 ? { ...state.health, status: "unreachable", checkedAtMs: atMs } : state.health;
+  const touchedRelay = request.command === "poll" || request.command === "relay publish" || request.command === "send";
+  const next = {
+    ...state,
+    health: touchedRelay ? health : state.health,
+    profiles: foldSetup(state, request, outcome),
+    /*
+     * The outbox figure, decided once for every command and every outcome, refusals included.
+     *
+     * No command in the frozen eight reports one (`MailboxView` enumerates what `doctor` does
+     * report), so the figure a result carried is always the absence of one — there is no earlier
+     * report here for a refusal to erase, which is why this is written unconditionally rather than
+     * carried forward the way `inboxReceived` is. The day a command does report a pending count,
+     * this line becomes `reportedCount(that field, state.mailbox.outboxPending)` and the rest of the
+     * rule is already in place.
+     *
+     * What must never come back is the increment that stood here: `outboxPending + 1` on a
+     * SUCCESSFUL send, which does not merely guess — it guesses in the direction opposite to the one
+     * the store moved, since a delivered message leaves the pending set rather than joining it.
+     */
+    mailbox: { ...state.mailbox, outboxPending: null }
+  };
+  if (!outcome.ok) return next;
+  const data = outcome.data;
+  switch (request.command) {
+    // `init` returns the identical `summary()` shape `doctor` returns — `identity_id`, `device_id`,
+    // `profile_id` — so the same case serves both (t35 §2.1). One fold, no second parser, and no
+    // second place for a child's bytes to enter the state unfiltered.
+    case "init":
+    case "doctor": {
+      if (!isRecord(data)) return next;
+      const profiles = next.profiles.map((profile, index) => index !== next.activeProfile ? profile : {
+        ...profile,
+        identityId: typeof data.identity_id === "string" ? paintable(data.identity_id) : profile.identityId,
+        deviceId: typeof data.device_id === "string" ? paintable(data.device_id) : profile.deviceId,
+        contactCount: asNumber(data.contact_count, profile.contactCount)
+      });
+      return { ...next, profiles };
+    }
+    case "poll": {
+      if (!isRecord(data)) return next;
+      return {
+        ...next,
+        mailbox: {
+          outboxPending: next.mailbox.outboxPending,
+          // `received` VERBATIM, and never added to what a previous poll reported: it is "envelopes
+          // accepted and committed by this poll" (`runtime/inbound.ts:27`), so a second poll that
+          // accepts none honestly reports `0`. A result that carries no number at all reports
+          // nothing, and the last poll's figure stands.
+          inboxReceived: reportedCount(data.received, next.mailbox.inboxReceived),
+          more: data.more === true,
+          lastPolledAtMs: atMs
+        },
+        rejections: readRejections(data.rejected)
+      };
+    }
+    case "relay publish": {
+      const profiles = next.profiles.map((profile, index) => index === next.activeProfile ? { ...profile, published: true } : profile);
+      return { ...next, profiles };
+    }
+    case "send":
+      return next;
+    case "history":
+      return { ...next, history: readHistoryEntries(data) };
+    default:
+      return next;
+  }
+}
+function outcomeLine(command, outcome) {
+  const head = `${command} \u2192 ${outcome.code} (exit ${String(outcome.exitCode)})`;
+  if (outcome.ok) return head;
+  const text = explain(command, outcome.code, outcome.exitCode);
+  return `${head}  ${text.sentence} ${text.action}`;
+}
+function runTuiShell(io, state) {
+  let current = { ...state, observedAtMs: state.observedAtMs ?? io.now() };
+  let running = true;
+  const viewport = () => ({
+    cols: Math.max(1, Math.floor(io.stdout.columns ?? MIN_VIEWPORT.cols)),
+    rows: Math.max(1, Math.floor(io.stdout.rows ?? MIN_VIEWPORT.rows))
+  });
+  const paint = () => {
+    const painted = viewport();
+    io.stdout.write(`${HOME}${styleFrame(renderFrame(current, painted)).join("\r\n")}`);
+    const modal = current.modal;
+    if (modal !== void 0 && modal.renderedAt === null && !isBelowMinViewport(painted)) {
+      current = { ...current, modal: { ...modal, renderedAt: io.now() } };
+    }
+    const input = current.input;
+    if (input !== void 0 && input.renderedAt === null && !isBelowMinViewport(painted)) {
+      current = { ...current, input: { ...input, renderedAt: io.now() } };
+    }
+  };
+  const note = (text) => {
+    current = { ...current, activity: [...current.activity, { at: io.now(), text: paintable(text) }].slice(-64) };
+  };
+  let confirmed;
+  let inFlightCommand;
+  const observeContact = (modal) => {
+    const { identity_id: identityId, device_id: deviceId, device_pubkey: devicePubkey, signal_identity_key: signalIdentityKey } = modal.identifiers;
+    if (identityId === void 0 || deviceId === void 0 || devicePubkey === void 0 || signalIdentityKey === void 0) return;
+    if (current.contacts.some((contact2) => contact2.identityId === identityId)) return;
+    const contact = { identityId, deviceId, devicePubkey, signalIdentityKey };
+    current = { ...current, contacts: [...current.contacts, contact] };
+  };
+  const apply = async (effect) => {
+    switch (effect.kind) {
+      case "run-cli": {
+        inFlightCommand = effect.request.command;
+        const outcome = await io.runCli(effect.request);
+        inFlightCommand = void 0;
+        note(outcomeLine(effect.request.command, outcome));
+        current = { ...applyOutcome(current, effect.request, outcome, io.now()), busy: false, observedAtMs: io.now() };
+        if (effect.request.command === "contact import") {
+          if (outcome.ok && confirmed !== void 0) observeContact(confirmed);
+          confirmed = void 0;
+        }
+        return;
+      }
+      case "answer-trust-prompt":
+        io.answerTrustPrompt(effect.answer);
+        note(effect.answer ? "contact import \u2192 confirmed by operator" : "contact import \u2192 declined by operator");
+        return;
+      case "quit":
+        running = false;
+        return;
+      default:
+        return;
+    }
+  };
+  return new Promise((settle) => {
+    io.stdin.setRawMode?.(true);
+    io.stdin.resume();
+    io.stdout.write(ALTERNATE_SCREEN_ON);
+    io.onTrustIdentifiers?.((input) => {
+      current = {
+        ...current,
+        modal: { kind: "trust", cardPath: input.cardPath, profileLabel: input.profileLabel, identifiers: paintableIdentifiers(input.identifiers), renderedAt: null }
+      };
+      paint();
+    });
+    const askWhatIsThere = () => {
+      const profile = current.profiles[current.activeProfile];
+      if (profile === void 0 || profile.state !== "unknown") return;
+      const step = reduce(current, { kind: "run", request: { command: "doctor", profileDir: profile.profileDir } });
+      current = step.state;
+      paint();
+      void (async () => {
+        for (const effect of step.effects) await apply(effect);
+        if (running) paint();
+      })();
+    };
+    let finished = false;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      io.stdin.setRawMode?.(false);
+      io.stdin.pause();
+      io.stdout.write(ALTERNATE_SCREEN_OFF);
+      if (inFlightCommand !== void 0) {
+        io.stdout.write(clipLine(`${inFlightCommand} is still running`, viewport().cols));
+      }
+      settle(0);
+    };
+    const handleKey = (sequence) => {
+      const intent = mapKey(decodeKey(sequence), current);
+      if (intent === void 0) return;
+      const open = current.modal;
+      const step = reduce(current, intent);
+      if (open !== void 0 && step.effects.some((effect) => effect.kind === "answer-trust-prompt" && effect.answer)) {
+        confirmed = open;
+      }
+      current = step.state;
+      paint();
+      void (async () => {
+        for (const effect of step.effects) await apply(effect);
+        if (running) paint();
+        else finish();
+      })();
+    };
+    io.stdin.on("data", (chunk) => {
+      if (!running) return;
+      const text = chunk.toString("utf8");
+      for (const key of current.input === void 0 ? splitKeystrokes(text) : [text]) {
+        if (!running) return;
+        handleKey(key);
+      }
+    });
+    paint();
+    askWhatIsThere();
+  });
+}
+
+// src/tui/main.ts
+var HERE = dirname(fileURLToPath(import.meta.url));
+var USAGE = [
+  "echolet operator console \u2014 an UNAUDITED PROTOTYPE, not for sensitive communication.",
+  "",
+  "usage: echolet-tui --profile <dir> [options] [--profile <dir> [options] \u2026]",
+  "",
+  "  --profile <dir>        a profile directory; repeat for more than one profile",
+  "  --label <name>         what to call the preceding profile on screen",
+  "  --relay-url <url>      the relay the preceding profile is configured against",
+  "  --store-key-env <var>  the NAME of the environment variable holding that profile's",
+  "                         32-byte store key. The value is never read here: it reaches",
+  "                         the CLI through the inherited environment.",
+  "  --card <path>          a contact card the preceding profile may import with [i]",
+  "  --cli <path>           the CLI bundle to drive (default: cli.js beside this file)",
+  "  --help                 print this and exit",
+  "",
+  "Keys: [1-5] pane  [enter] next registration step  [p] poll  [d] doctor",
+  "      [r] publish  [h] history  [i] import  [c] contact  [t] profile",
+  "      [?] help  [q] quit"
+].join("\n");
+var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+function wantsHelp(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (HELP_FLAGS.has(token)) return true;
+    index += 1;
+  }
+  return false;
+}
+function parseOptions(rawArgv) {
+  const argv = rawArgv.map((token) => paintable(token));
+  const profiles = [];
+  let cliPath = resolve(HERE, "cli.js");
+  const assign = (key, value) => {
+    const current = profiles.at(-1);
+    if (current === void 0) throw new Error(`${key} must follow a --profile`);
+    const patched = { ...current };
+    if (key === "--label") patched.label = value;
+    else if (key === "--relay-url") patched.relayUrl = value;
+    else if (key === "--store-key-env") patched.storeKeyEnv = value;
+    else if (key === "--card") patched.contactCardPath = resolve(value);
+    else throw new Error(`unknown option ${key}`);
+    profiles[profiles.length - 1] = patched;
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const flag = argv[index] ?? "";
+    if (HELP_FLAGS.has(flag)) continue;
+    const value = argv[index + 1];
+    if (value === void 0) throw new Error(`${flag} needs a value`);
+    index += 1;
+    if (flag === "--profile") {
+      profiles.push({
+        label: `profile-${profiles.length + 1}`,
+        profileDir: resolve(value),
+        relayUrl: "",
+        storeKeyEnv: "",
+        identityId: "(run doctor)",
+        deviceId: "(run doctor)",
+        contactCount: 0,
+        published: false,
+        // Nothing has been observed about this profile yet, which is what makes the startup
+        // `doctor` the one command the console runs unasked, and what puts the checklist on the
+        // pane until a result says otherwise.
+        state: "unknown",
+        setup: PENDING_SETUP
+      });
+    } else if (flag === "--cli") {
+      cliPath = resolve(value);
+    } else {
+      assign(flag, value);
+    }
+  }
+  if (profiles.length === 0) throw new Error("at least one --profile <dir> is required");
+  return { profiles, cliPath };
+}
+function withStoreKeyPresence(profile) {
+  const present = Object.hasOwn(process.env, profile.storeKeyEnv);
+  const setup = (profile.setup ?? PENDING_SETUP).map((outcome, step) => step === 0 ? present ? "ok" : "pending" : outcome);
+  return { ...profile, storeKeyPresent: present, setup };
+}
+function readIdentifiers(text) {
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed !== "object" || parsed === null) continue;
+      const record = parsed;
+      if (typeof record.identity_id !== "string") continue;
+      return {
+        identity_id: record.identity_id,
+        device_id: typeof record.device_id === "string" ? record.device_id : void 0,
+        device_pubkey: typeof record.device_pubkey === "string" ? record.device_pubkey : void 0,
+        signal_identity_key: typeof record.signal_identity_key === "string" ? record.signal_identity_key : void 0
+      };
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (wantsHelp(argv)) {
+    process.stdout.write(`${USAGE}
+`);
+    return 0;
+  }
+  const options = parseOptions(argv);
+  let trustListener;
+  let awaitingTrust;
+  const runCli = (request) => new Promise((settle) => {
+    const child = spawn(process.execPath, [options.cliPath, ...buildArgv(request)], {
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    child.stdin.on("error", () => {
+    });
+    let stdout = "";
+    let stderr = "";
+    let announced = false;
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      if (announced || request.command !== "contact import") return;
+      const identifiers = readIdentifiers(stderr);
+      if (identifiers === void 0) return;
+      announced = true;
+      awaitingTrust = child.stdin;
+      const profile = options.profiles.find((candidate) => candidate.profileDir === request.profileDir);
+      trustListener?.({ cardPath: request.from, profileLabel: profile?.label ?? request.profileDir, identifiers });
+    });
+    const done = (exitCode) => {
+      awaitingTrust = void 0;
+      settle(parseCliOutcome(stdout, exitCode));
+    };
+    child.on("error", () => {
+      done(5);
+    });
+    child.on("close", (code) => {
+      done(code ?? 1);
+    });
+    if (request.command === "send") child.stdin.end(request.text, "utf8");
+    else if (request.command !== "contact import") child.stdin.end();
+  });
+  const io = {
+    stdout: process.stdout,
+    stdin: process.stdin,
+    now: () => Date.now(),
+    runCli,
+    answerTrustPrompt: (answer) => {
+      awaitingTrust?.write(answer ? "y\n" : "n\n");
+    },
+    onTrustIdentifiers: (listener) => {
+      trustListener = listener;
+    }
+  };
+  return runTuiShell(io, createInitialState({ profiles: options.profiles.map(withStoreKeyPresence) }));
+}
+main().then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 2;
+  }
+);