@tiens.nguyen/gu-cli 1.0.778 → 1.0.780

package/gu-repl.mjs

@@ -74,6 +74,7 @@ import {
   maskKey,
   otherAgentRows,
   updateRow,
+  noticeRow,
   updateNotice,
   answerBlock,
   updateRestartNote,
@@ -1579,12 +1580,11 @@ let imageNoticeTimer = null;
 let agentMissing = false; // no agent model chosen → agent falls back to the coding model
 let embedMissing = false; // no embed model chosen → RAG is off until /embed-model picks one
 // One footer row; the two halves are independent so a model that IS set is never named.
-const missingNoticeText = () => {
-  const parts = [];
-  if (agentMissing) parts.push("agent model is not set — using the coding model (/agent-model to choose one)");
-  if (embedMissing) parts.push("no embed model — RAG is off; choose one with /embed-model");
-  return parts.length ? "⚠ " + parts.join("  ·  ") : "";
-};
+// ONE SHORT ROW EACH (#317): joined, they ran past 80 columns and were cut mid-word.
+const missingNoticeRows = () => [
+  ...(agentMissing ? ["⚠ agent model not set — using the coding model · /agent-model"] : []),
+  ...(embedMissing ? ["⚠ no embed model — RAG is off · /embed-model"] : []),
+];
 
 // #307: the calm note after a quick change of mind — dim, not the ⚠ orange of a warning, and in the
 // bar rather than the transcript (which the whole point is to leave untouched).
@@ -2533,7 +2533,7 @@ const footerRows = () =>
         ? dim(clipVisible(stopNotice, (process.stdout.columns || 80) - visibleLen(GUTTER) - 1))
         : "",
     // Task #14: the skipped-setup warning — persistent (not a timed notice), red, its own row.
-    missing: missingNoticeText() ? red(missingNoticeText()) : "",
+    missing: missingNoticeRows().map((r) => red(r)),
   });
 // An ask()'s hint lines (#305), drawn in yellow under its input while it waits. Plain text.
 let askHint = [];
@@ -2605,6 +2605,28 @@ function syncBarPinning() {
   if (!canPinBar()) unpinBar();
   else pinBar();
 }
+/**
+ * THE NOTICE ROW ABOVE THE SEPARATOR (#318) — or null when there is nothing to say.
+ * Priority, highest first: where you are (jump to bottom), what you can act on with a click (an
+ * update), a standing fact about the licence (the gu token notice — yellow only when urgent), and
+ * other agents. Dropped whole, lowest first, when they do not all fit.
+ */
+function zoneNotice(width) {
+  const items = [];
+  if (scrolledBack()) {
+    const n = scrollOffset;
+    items.push({ key: "jump", clickable: true, paint: accent, text: `↓ jump to bottom (click) · ${n} line${n === 1 ? "" : "s"} below` });
+  }
+  if (availableUpdates.any) {
+    const up = updateRow({ ...availableUpdates, width: 400 });
+    if (up) items.push({ key: "update", clickable: true, paint: accent, text: up.text.slice(up.from) });
+  }
+  if (tokenNotice?.text) items.push({ key: "token", paint: tokenNotice.urgent ? yellow : dim, text: tokenNotice.text });
+  const agents = agentsIndicator(otherAgents);
+  if (agents) items.push({ key: "agents", clickable: true, paint: accent, text: `${agents} running (click)` });
+  return noticeRow(items, { width, gutter: GUTTER });
+}
+
 /**
  * The whole frozen zone, top to bottom: a separator, a blank row, the INPUT LINE, then the
  * bar's rule, token and mode rows. The blank is what lifts the separator — and the control it
@@ -2625,17 +2647,12 @@ function frozenZone() {
   // #307: a question held until its turn prints anything sits on top of the status block — where
   // it will land once committed, so nothing moves when it does.
   const status = footerActive ? [] : [...pendingEchoRows(), ...liveStatusRows];
-  // DECIDED BEFORE THE LAYOUT, because the head's height depends on it: the blank under the
-  // separator exists to lift a CONTROL off the typed line, so with no control there is nothing
-  // to lift. The same three conditions the rows[sep] writes below test — kept adjacent so they
-  // cannot drift into disagreeing about whether a control is showing.
-  // The token notice counts only when it FITS — the same test its write below uses. With
-  // Boolean(tokenNotice) alone, a narrow terminal lifted a blank row for a line it never drew.
-  const tokenFits = Boolean(tokenNotice) && visibleLen(tokenNotice.text) + 4 <= width - 1;
-  const headControl =
-    scrolledBack() || availableUpdates.any || tokenFits || Boolean(agentsIndicator(otherAgents));
+  // THE SEPARATOR CARRIES NOTHING (#318). What used to ride on it — jump-to-bottom, the update
+  // control, the gu token notice, the agents count — is on its own NOTICE ROW above it; the head
+  // is just the rule, with no blank to lift a control off the typed line.
+  const notice = zoneNotice(width);
   const zone = inputZoneRows({
-    headControl,
+    headControl: false,
     width,
     // #258: typing during a turn is not sent — the row says so (an ask() label still comes first).
     prompt: secretInput && secretPrompt
@@ -2680,61 +2697,14 @@ function frozenZone() {
     selection: secretInput ? null : inputSelection,
     highlight: highlightRow,
   });
-  const rows = status.concat(zone.rows, askHintRows(width), footerRows());
-  // THE SEPARATOR IS NO LONGER ROW 0. With the status block prepended it sits `status.length`
-  // rows down, and every affordance below writes to it by index — a bare rows[0] would paint
-  // the jump hint over the thought line and hit-test the wrong row.
-  const sep = status.length;
-  // THE SEPARATOR ROW carries at most one affordance, and the two contend for it:
-  //
-  //  · scrolled back → "↓ jump to bottom", which WINS. It is transient and about where you are
-  //    right now; an update is neither, and will still be there when you come back.
-  //  · otherwise, and only when something is genuinely newer → the update control (task #181).
-  //
-  // Both are stored with their COLUMN span, because the row is hit-tested by column now — one
-  // row, two possible targets, and "anywhere on this row" would make the wrong one fire.
-  updateRowTarget = null;
-  agentsRowTarget = null;
-  if (scrolledBack()) {
-    const hint = jumpToBottomRow({ below: scrollOffset, width });
-    rows[sep] = clipVisible(accent(hint.text), width - 1);
-  } else if (availableUpdates.any) {
-    const up = updateRow({ ...availableUpdates, width });
-    if (up) {
-      rows[sep] = clipVisible(dim(up.text.slice(0, up.from)) + accent(up.text.slice(up.from)), width - 1);
-      updateRowTarget = { from: up.from, to: up.to };
-    }
-  } else if (tokenFits) {
-    // The gu token's one line (#232), right-aligned like the controls around it. BELOW the update
-    // control, because an update is actionable with a click and this is a standing fact; ABOVE the
-    // agents count, because it needs the user and that does not. Not clickable. Too narrow to say
-    // it whole → the condition above lets the agents count (or nothing) have the row instead.
-    const len = visibleLen(tokenNotice.text);
-    const from = width - 1 - len;
-    // Yellow only when the user must act (plan ended, over the computer limit); an old token is
-    // routine and reads in the rule's own dim grey (#292 — the yellow line "seems so serious").
-    const paint = tokenNotice.urgent ? yellow : dim;
-    rows[sep] = clipVisible(dim("\u2500".repeat(Math.max(0, from - 1)) + " ") + paint(tokenNotice.text), width - 1);
-  } else if (agentsIndicator(otherAgents)) {
-    // …and when there is no update to offer, the same row carries the agents count (task #195).
-    // THREE THINGS CANNOT SHARE ONE ROW, so they are ranked by how time-critical they are:
-    // the jump hint is about where you are RIGHT NOW, an update is a standing fact, and other
-    // agents change on their own. Update wins over agents because it is rarer and actionable;
-    // agents are always one click away through the same row once it is free.
-    const label = `${agentsIndicator(otherAgents)} running (click)`;
-    const len = visibleLen(label);
-    if (len + 4 <= width - 1) {
-      const from = width - 1 - len;
-      rows[sep] = clipVisible(dim("\u2500".repeat(Math.max(0, from - 1)) + " ") + accent(label), width - 1);
-      agentsRowTarget = { from, to: from + len };
-    }
-  }
-  // Spread, not a hand-written pick: this used to list the fields it forwarded, and adding
-  // rowCount/caretRow to inputZoneRows left them silently undefined here — the caret would have
-  // parked on the first row of a wrapped input forever.
-  // statusRows so paintBar can offset the input row and the separator's absolute position;
-  // without it every click and caret park would be `status.length` rows out.
-  return { ...zone, rows, statusRows: sep };
+  const rows = status.concat(notice ? [notice.row] : [], zone.rows, askHintRows(width), footerRows());
+  // The separator is `status.length (+1 for the notice row)` rows down — everything that writes to
+  // or hit-tests a row by index counts from here.
+  const sep = status.length + (notice ? 1 : 0);
+  updateRowTarget = notice?.spans.update ?? null;
+  agentsRowTarget = notice?.spans.agents ?? null;
+  jumpSpan = notice?.spans.jump ?? null;
+  return { ...zone, rows, statusRows: sep, noticeRow: Boolean(notice) };
 }
 /**
  * Put the output position back at column 0 of its own row — without printing anything.
@@ -2774,8 +2744,10 @@ function paintBar() {
   // The rows exactly as painted, so a double-click reads the same characters the user is
   // looking at rather than re-deriving them from rl.line at a width this may not be.
   inputRowTexts = zone.rows.slice((zone.statusRows ?? 0) + head);
-  jumpRowTarget = scrolledBack() ? { row: sepAbs } : null; // the SEPARATOR row
-  updateRowAbs = updateRowTarget || agentsRowTarget ? sepAbs : 0; // …the same row, when showing
+  // THE NOTICE ROW is the one directly above the separator (#318) — never the separator itself.
+  const noticeAbs = zone.noticeRow ? sepAbs - 1 : 0;
+  jumpRowTarget = scrolledBack() && jumpSpan ? { row: noticeAbs, ...jumpSpan } : null;
+  updateRowAbs = updateRowTarget || agentsRowTarget ? noticeAbs : 0;
   // preserveCaret:false — the save slot holds the OUTPUT position (see regionUi), and the caret
   // is parked on the input line right after, so there is nothing to preserve here.
   ui(
@@ -2929,6 +2901,8 @@ let liveStatusRows = [];
 // Where the "jump to bottom" line currently is (1-based viewport row + column span), so a click
 // can hit it. Null while the view is live.
 let jumpRowTarget = null;
+/** The jump-to-bottom hint's column span on the notice row (#318), set by frozenZone. */
+let jumpSpan = null;
 // The update control's column span on the separator row, and that row's absolute position.
 // Column-scoped (task #181): the row is shared with the jump-to-bottom hint, so a click has to
 // land ON the label rather than anywhere along it.
@@ -7060,6 +7034,83 @@ async function runUndoCommand(line) {
   if (runId === lastStoppedRun) lastStoppedRun = null;
 }
 
+/**
+ * #317: a preset the person ALREADY HAS, brought in by pasting — its JSON, a whole preset file, or
+ * the `/save-preset <name> {…}` command copied from another computer (#312). A multi-line paste
+ * arrives as "[Pasted text #N +M lines]" and is expanded before it is read, so the key is never
+ * echoed. A mistake is named; Enter then opens it IN THE EDITOR with the pasted text (not a blank
+ * template), and Enter on nothing opens the editor on the current setup. Esc cancels.
+ * Saved 0600 like /save-preset. → the file, or "" when cancelled.
+ */
+async function presetFromPaste(pr, home) {
+  const ed = await import("./preset-editor.mjs");
+  console.log(GUTTER + "Paste a preset you already have — its JSON, a preset file, or a /save-preset command.");
+  console.log(GUTTER + dim("Enter on an empty line opens your editor instead  ·  Esc cancels."));
+  let parsed = null;
+  let lastText = "";
+  try {
+    while (!parsed) {
+      const text = String((await ask("preset: ")) ?? "");
+      if (!text.trim()) {
+        const seed = lastText || ed.editorText("preset", ed.presetFromSettings((await fetchWorkerSettings()) ?? {}));
+        parsed = await fixPresetInEditor(ed, seed);
+        if (!parsed) return "";
+        break;
+      }
+      const p = ed.parsePastedPreset(text);
+      if (p.ok) {
+        parsed = p;
+        break;
+      }
+      lastText = text;
+      console.log(GUTTER + yellow(`Not a preset yet — ${p.problem}`));
+      console.log(GUTTER + dim("Paste it again, or press Enter to fix it in your editor."));
+    }
+    const name = await askPresetName(pr, parsed.name || "preset");
+    if (!name) return "";
+    const file = pr.presetFilePath(name, home);
+    if (existsSync(file) && !(await askYesNo(`A preset called "${name}" exists — replace it?`, false))) return "";
+    writeFileSync(file, JSON.stringify(pr.buildPreset({ name, preset: parsed.preset, host: hostname() }), null, 2) + "\n", { mode: 0o600 });
+    console.log(GUTTER + `Preset "${name}" saved to ${file}`);
+    return file;
+  } catch (e) {
+    if (wasPromptCancelled(e)) return "";
+    throw e;
+  }
+}
+
+/** The editor loop of #312, seeded with `text`: → a parsed preset, or null when given up. */
+async function fixPresetInEditor(ed, text) {
+  const editor = ed.pickEditor();
+  if (!editor || !process.stdin.isTTY) {
+    console.log(GUTTER + (editor ? "an editor needs a terminal." : "no editor found (set $EDITOR, e.g. export EDITOR=nano)."));
+    return null;
+  }
+  let t = text;
+  for (;;) {
+    const r = withTerminalHandedOver(() => ed.editText(t, { editor, fileName: "preset.json" }));
+    if (!r.ok) {
+      console.log(GUTTER + `Not saved — ${r.why}.`);
+      return null;
+    }
+    const p = ed.parsePastedPreset(r.text);
+    if (p.ok) return p;
+    console.log(GUTTER + yellow(`Not saved yet — ${p.problem}`));
+    if (!(await askYesNo("Edit again?", true))) return null;
+    t = r.text;
+  }
+}
+
+/** A preset name, defaulting to `dflt` (Enter). "" when cancelled. */
+async function askPresetName(pr, dflt) {
+  for (;;) {
+    const n = String((await ask(`preset name${dflt ? ` [${dflt}]` : ""}: `)) ?? "").trim() || dflt;
+    if (!n) return "";
+    if (pr.isPresetName(n)) return n;
+    console.log(GUTTER + yellow(`"${n}" is not a preset name — one word, no slashes.`));
+  }
+}
+
 async function runLoadPresetsCommand(line) {
   const pr = await import("./presets-transfer.mjs");
   const home = homedir();
@@ -7082,53 +7133,72 @@ async function runLoadPresetsCommand(line) {
     // picker that stayed open could not be clicked until it closed.
     const ed = await import("./preset-editor.mjs");
     const found = pr.presetFilesIn(listJsonFiles(home));
+    // NO DEAD END (#317: "I need a place to input a preset I have already"): with nothing saved,
+    // the command asks for one right here; with presets saved, the picker's LAST row does (last, so
+    // Enter still applies the newest preset, as it always has).
     if (found.length === 0) {
-      console.log(GUTTER + `no presets in ${home} — save one with /save-preset <name>`);
-      console.log("");
-      return;
-    }
-    console.log(dim(`  Presets in ${home}  (${ed.PICKER_HINT}):`));
-    const pick = await pickFromList(found, 0, { keys: ed.PICKER_KEYS });
-    if (!pick || pick.index < 0) {
-      console.log(GUTTER + "load cancelled.");
-      console.log("");
-      return;
-    }
-    file = pr.presetFilePath(found[pick.index], home);
-    if (pick.action === "edit") {
-      await runSavePresetCommand(`/save-preset ${found[pick.index]}`);
-      return;
-    }
-    if (pick.action !== "select") {
-      const shown = pr.validatePresetFile(readFileSync(file, "utf8"));
-      if (!shown.ok) {
-        console.log(GUTTER + `Can't show it — ${shown.problem}`);
+      console.log(GUTTER + "No presets saved yet.");
+      file = await presetFromPaste(pr, home);
+      if (!file) {
+        console.log(GUTTER + "load cancelled.");
         console.log("");
         return;
       }
-      const pname = shown.name || found[pick.index];
-      const command = ed.presetCopyCommand(pname, shown.preset);
-      if (pick.action === "view") {
-        const block = ed.presetBlock(pname, shown.preset, { width: process.stdout.columns || 80, gutter: GUTTER });
-        const [top, ...restRows] = block.rows;
-        const cut = block.button.from;
-        console.log(dim(top.slice(0, cut)) + accent(top.slice(cut, block.button.to)) + dim(top.slice(block.button.to)));
-        for (const r of restRows) console.log(r);
-        registerCopyBlock(block.rows.length, command, 0, { button: block.button, note: "✓ copied — includes the API key" });
-        console.log(GUTTER + dim("click ⧉ copy for a /save-preset command to paste anywhere — it includes the real key."));
-        console.log(GUTTER + dim(`/load-presets ${pname} applies it.`));
+    } else {
+      console.log(dim(`  Presets in ${home}  (${ed.PICKER_HINT}):`));
+      const PASTE_ROW = "+ Paste a preset I already have…";
+      const pick = await pickFromList([...found, PASTE_ROW], 0, { keys: ed.PICKER_KEYS });
+      if (!pick || pick.index < 0) {
+        console.log(GUTTER + "load cancelled.");
+        console.log("");
+        return;
+      }
+      if (pick.index === found.length) {
+        file = await presetFromPaste(pr, home);
+        if (!file) {
+          console.log(GUTTER + "load cancelled.");
+          console.log("");
+          return;
+        }
+        pick.action = "select"; // a pasted preset goes on to be applied, whatever key opened the row
+      } else {
+        file = pr.presetFilePath(found[pick.index], home);
+      }
+      if (pick.action === "edit") {
+        await runSavePresetCommand(`/save-preset ${found[pick.index]}`);
+        return;
+      }
+      if (pick.action !== "select") {
+        const shown = pr.validatePresetFile(readFileSync(file, "utf8"));
+        if (!shown.ok) {
+          console.log(GUTTER + `Can't show it — ${shown.problem}`);
+          console.log("");
+          return;
+        }
+        const pname = shown.name || found[pick.index];
+        const command = ed.presetCopyCommand(pname, shown.preset);
+        if (pick.action === "view") {
+          const block = ed.presetBlock(pname, shown.preset, { width: process.stdout.columns || 80, gutter: GUTTER });
+          const [top, ...restRows] = block.rows;
+          const cut = block.button.from;
+          console.log(dim(top.slice(0, cut)) + accent(top.slice(cut, block.button.to)) + dim(top.slice(block.button.to)));
+          for (const r of restRows) console.log(r);
+          registerCopyBlock(block.rows.length, command, 0, { button: block.button, note: "✓ copied — includes the API key" });
+          console.log(GUTTER + dim("click ⧉ copy for a /save-preset command to paste anywhere — it includes the real key."));
+          console.log(GUTTER + dim(`/load-presets ${pname} applies it.`));
+          console.log("");
+          return;
+        }
+        const res = await writeClipboard(pick.action === "json" ? ed.presetCopyJson(shown.preset) : command);
+        console.log(
+          GUTTER +
+            (res.ok
+              ? accent(`✓ copied ${pick.action === "json" ? "the JSON" : "the /save-preset command"} for "${pname}" — includes the API key.`)
+              : yellow(`couldn't copy (${res.why}) — the preset is in ${file}.`))
+        );
         console.log("");
         return;
       }
-      const res = await writeClipboard(pick.action === "json" ? ed.presetCopyJson(shown.preset) : command);
-      console.log(
-        GUTTER +
-          (res.ok
-            ? accent(`✓ copied ${pick.action === "json" ? "the JSON" : "the /save-preset command"} for "${pname}" — includes the API key.`)
-            : yellow(`couldn't copy (${res.why}) — the preset is in ${file}.`))
-      );
-      console.log("");
-      return;
     }
   }
   const checked = pr.validatePresetFile(readFileSync(file, "utf8"));

package/model-setup-ui.mjs

@@ -98,7 +98,7 @@ export function modelSetupMenu({ presets = 0 } = {}) {
     "  1  Guided — pick the servers and models   (Enter)",
     presets > 0
       ? `  2  Load a saved preset   (${presets} saved)`
-      : "  2  Load a saved preset   (none saved yet — /save-preset makes one)",
+      : "  2  Load a preset   (none saved yet — paste one you already have)",
     "  3  Skip for now — set them later with /model",
   ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.778",
+  "version": "1.0.780",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",

package/preset-editor.mjs

@@ -185,3 +185,38 @@ export function presetBlock(name, preset, { width = 80, gutter = "   " } = {}) {
 /** The keys the /load-presets picker takes, in the order its hint line names them. */
 export const PICKER_KEYS = { v: "view", c: "copy", j: "json", e: "edit" };
 export const PICKER_HINT = "↑↓ · Enter apply · v view · c copy command · j copy JSON · e edit · Esc back";
+
+/**
+ * A PRESET SOMEONE ALREADY HAS, pasted into /load-presets (#317: "I need a place to input a preset
+ * I have already, which is in JSON format"). Three shapes are accepted, because those are the three
+ * things a person could be holding:
+ *
+ *   · the JSON itself            { "apiUrl": …, "apiKey": …, "agentModel": …, … }
+ *   · a whole preset FILE        { "gu": "preset", "name": "home", "version": 1, … }
+ *   · the command copied with c  /save-preset home {"apiUrl":…}   (#312, from another computer)
+ *
+ * → { ok: true, preset, name } (name = the one the text carries, or "") | { ok: false, problem }.
+ * JSON problems name the line and column (parseEdited), and `//` lines are allowed, as in the editor.
+ */
+export function parsePastedPreset(text) {
+  let src = String(text ?? "").trim();
+  if (!src) return { ok: false, empty: true, problem: "nothing was pasted." };
+  let name = "";
+  const cmd = /^\/save-preset\s+(\S+)\s+([\s\S]+)$/.exec(src);
+  if (cmd) {
+    name = cmd[1];
+    src = cmd[2].trim();
+  } else if (/^\/save-preset\b/.test(src)) {
+    return { ok: false, problem: "that /save-preset command has no JSON after its name." };
+  }
+  const parsed = parseEdited(src);
+  if (!parsed.ok) return parsed;
+  // A whole preset file carries its name inside; the command's own name wins when both exist.
+  try {
+    const doc = JSON.parse(src.replace(/^[ \t]*\/\/.*$/gm, ""));
+    if (!name && doc && typeof doc.name === "string" && doc.gu === "preset") name = doc.name.trim();
+  } catch {
+    /* parseEdited already accepted it — a name is optional */
+  }
+  return { ok: true, preset: parsed.preset, name };
+}

package/terminal-layout.mjs

@@ -522,7 +522,9 @@ export function buildFooterRows({
     // Task #14: a skipped model setup stays VISIBLE. When private/client-expert setup was
     // declined the agent model and/or the embed model is unset — say so at the bottom, every
     // frame, until one is chosen. Its own row, under the passing notice, so it persists.
-    ...(missing ? [clipVisible(gutter + missing, w - 1)] : []),
+    // One row EACH (#317): the two warnings joined on one row ran past 80 columns and were cut
+    // mid-word ("…(/agent-model to choose on"). A string still works — one row, as before.
+    ...(Array.isArray(missing) ? missing : missing ? [missing] : []).filter(Boolean).map((m) => clipVisible(gutter + m, w - 1)),
   ];
 }
 
@@ -2812,3 +2814,41 @@ export function hintRows(lines, { width, gutter = "   ", paint = (s) => s } = {}
   }
   return out.map((r) => gutter + paint(r));
 }
+
+/**
+ * THE NOTICE ROW — its own row, directly ABOVE the separator (#318).
+ *
+ * The rule above ">>" is only a separator (the user, angrily: "the line is for separating the
+ * user's input, not for that"). Four things used to ride on it, one at a time — the jump-to-bottom
+ * hint, the update control, the gu token notice, the agents count — because the row looked free.
+ * Now they share this row instead, right-aligned, joined with " · ", in PRIORITY order (the first
+ * item is the most important). What does not fit is dropped WHOLE, lowest priority first — never
+ * cut mid-word. No items → null, and the zone simply has no such row.
+ *
+ * items: [{ key, text, paint?, clickable? }] → { row, spans: { [key]: { from, to } } } | null
+ * `spans` are 0-based columns of the CLICKABLE items, gutter included — what a click is tested on.
+ */
+export function noticeRow(items, { width = 80, gutter = "   ", sep = "  ·  " } = {}) {
+  const w = Math.max(20, width | 0);
+  const room = w - 1 - visibleLen(gutter);
+  const list = (Array.isArray(items) ? items : []).filter((i) => i && i.text);
+  let kept = list;
+  const joinedLen = (xs) => xs.reduce((n, x, i) => n + visibleLen(x.text) + (i ? sep.length : 0), 0);
+  while (kept.length && joinedLen(kept) > room) kept = kept.slice(0, -1);
+  if (!kept.length) return null;
+  const start = w - 1 - joinedLen(kept);
+  let row = " ".repeat(start);
+  let col = start;
+  const spans = {};
+  kept.forEach((x, i) => {
+    if (i) {
+      row += sep;
+      col += sep.length;
+    }
+    const len = visibleLen(x.text);
+    if (x.clickable) spans[x.key] = { from: col, to: col + len };
+    row += (x.paint ?? ((s) => s))(x.text);
+    col += len;
+  });
+  return { row, spans };
+}