@namzu/cli 8.2.0 → 8.4.0

package/dist/tui/credential-entry.d.ts

@@ -7,19 +7,23 @@
  *
  * ## Why session-only, stated as a decision rather than a limitation
  *
- * The obvious durable home is the OS keychain, and here it does not exist. The
- * keychain helper in this package is macOS-only, and it reads and writes a
- * DIFFERENT product's credential store — namzu borrows an OAuth token from it.
- * Writing a namzu key into that envelope would put our secret under their name.
- * On Windows, which is where this was asked for, there is no keychain path at
- * all.
+ * A durable store now exists next door (`credential-store.ts`), and this path
+ * still does not use it — which is the interesting part, because the original
+ * reason for session-only was that no such store had been written.
  *
- * So the durable options were a plaintext file or a per-platform credential
- * store nobody has written. Keeping the key in memory for the session is the
- * honest third answer: nothing lands on disk, it works everywhere, and the
- * screen names the environment variable that makes it durable. A secret at rest
- * should be something the operator chose, not something that arrived because
- * they typed into a text field.
+ * That reason is gone; the decision is not, and it rests on the one thing the
+ * two paths do not share. `/login` OBTAINS a credential: the operator asked for
+ * one, namzu got it, and namzu can refresh it, name where it came from, and
+ * remove it again. A key typed here arrived from somewhere namzu had no part
+ * in — there is nothing to refresh it with, no origin to report, and no
+ * meaningful way to revoke it on the operator's behalf. Writing that to disk
+ * uninvited would be namzu deciding, for someone else, that their secret should
+ * persist.
+ *
+ * So the key stays in memory: nothing lands on disk, it works everywhere, and
+ * the screen names the environment variable that makes it durable. A secret at
+ * rest should be something the operator chose, not something that arrived
+ * because they typed into a text field — and now there are two ways to choose.
  *
  * Everything decidable lives here rather than in the component, because this
  * package has no component tests and a secret is the worst thing to leave

package/dist/tui/credential-entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"credential-entry.d.ts","sourceRoot":"","sources":["../../src/tui/credential-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAE1B,MAAM,oCAAoC,CAAA;AAE3C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,oBAAoB,CAAA;AAE7D;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,EAAE,MAAM,GAAG,cAAc,CAG5F;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAmBxF;AAED,qDAAqD;AACrD,MAAM,MAAM,YAAY,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE;AAC/B,oEAAoE;GAClE;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GACjC;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,qBAAqB,EAC5B,YAAY,EAAE,YAAY,EAC1B,IAAI,GAAE,cAA0B,GAC9B,MAAM,CAmCR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAQ7F"}
+{"version":3,"file":"credential-entry.d.ts","sourceRoot":"","sources":["../../src/tui/credential-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAE1B,MAAM,oCAAoC,CAAA;AAE3C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,oBAAoB,CAAA;AAE7D;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,EAAE,MAAM,GAAG,cAAc,CAG5F;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAmBxF;AAED,qDAAqD;AACrD,MAAM,MAAM,YAAY,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE;AAC/B,oEAAoE;GAClE;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GACjC;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,qBAAqB,EAC5B,YAAY,EAAE,YAAY,EAC1B,IAAI,GAAE,cAA0B,GAC9B,MAAM,CAmCR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAQ7F"}

package/dist/tui/credential-entry.js

@@ -7,19 +7,23 @@
  *
  * ## Why session-only, stated as a decision rather than a limitation
  *
- * The obvious durable home is the OS keychain, and here it does not exist. The
- * keychain helper in this package is macOS-only, and it reads and writes a
- * DIFFERENT product's credential store — namzu borrows an OAuth token from it.
- * Writing a namzu key into that envelope would put our secret under their name.
- * On Windows, which is where this was asked for, there is no keychain path at
- * all.
+ * A durable store now exists next door (`credential-store.ts`), and this path
+ * still does not use it — which is the interesting part, because the original
+ * reason for session-only was that no such store had been written.
  *
- * So the durable options were a plaintext file or a per-platform credential
- * store nobody has written. Keeping the key in memory for the session is the
- * honest third answer: nothing lands on disk, it works everywhere, and the
- * screen names the environment variable that makes it durable. A secret at rest
- * should be something the operator chose, not something that arrived because
- * they typed into a text field.
+ * That reason is gone; the decision is not, and it rests on the one thing the
+ * two paths do not share. `/login` OBTAINS a credential: the operator asked for
+ * one, namzu got it, and namzu can refresh it, name where it came from, and
+ * remove it again. A key typed here arrived from somewhere namzu had no part
+ * in — there is nothing to refresh it with, no origin to report, and no
+ * meaningful way to revoke it on the operator's behalf. Writing that to disk
+ * uninvited would be namzu deciding, for someone else, that their secret should
+ * persist.
+ *
+ * So the key stays in memory: nothing lands on disk, it works everywhere, and
+ * the screen names the environment variable that makes it durable. A secret at
+ * rest should be something the operator chose, not something that arrived
+ * because they typed into a text field — and now there are two ways to choose.
  *
  * Everything decidable lives here rather than in the component, because this
  * package has no component tests and a secret is the worst thing to leave

package/dist/tui/credential-entry.js.map

@@ -1 +1 @@
-{"version":3,"file":"credential-entry.js","sourceRoot":"","sources":["../../src/tui/credential-entry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"credential-entry.js","sourceRoot":"","sources":["../../src/tui/credential-entry.ts"],"names":[],"mappings":"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"}

package/dist/tui/live-window.d.ts

@@ -0,0 +1,97 @@
+/**
+ * How much of the transcript is still ALIVE — redrawable — and how much has
+ * already been handed to the terminal's own scrollback.
+ *
+ * ## Why there is a window at all
+ *
+ * Every finalized row used to go straight into `<Static>`, which prints a row
+ * once and never redraws it. That kept per-frame work bounded, and it also made
+ * changing a row that is already on screen impossible by construction: an
+ * expand key could not reopen a collapsed body, so expansion had to become a
+ * command that appends a second copy of the output further down.
+ *
+ * A small window of the most recent rows is kept live instead. Inside it a row
+ * can be redrawn in place, so expansion works where an operator actually looks;
+ * `/expand <n>` remains the way to reach anything older, and the hint under a
+ * collapsed body already degrades correctly when a row has no number.
+ *
+ * ## Why the window is bounded by HEIGHT, not by a count of rows
+ *
+ * This is the constraint the whole design turns on, and it is a property of the
+ * renderer rather than a preference. When the live region's height reaches the
+ * viewport's, ink stops doing an incremental repaint and instead writes
+ * `clearTerminal` followed by **the entire static output it has accumulated
+ * this session** plus the frame. On a long session that is the whole transcript,
+ * re-serialized on every spinner tick — which is the allocation churn that
+ * pushed `<Static>` to swallow everything in the first place.
+ *
+ * So the window takes rows from the end only while their estimated height fits
+ * a budget the live furniture and a safety margin are already subtracted from.
+ * A single row taller than the budget leaves the window empty, and an empty
+ * window is exactly the previous behaviour — the failure direction is "no
+ * retroactive expansion", never "repaint the session".
+ *
+ * ## Why it only ever moves one way
+ *
+ * `settled` is a floor the caller carries between renders. `<Static>` keeps an
+ * index of how many items it has emitted and renders only what is past it, so a
+ * shrinking item list would leave rows unprinted; and a row that has already
+ * been drawn live must not be handed back to a mechanism that would print it
+ * again. Rows therefore leave the window in one direction, oldest first, and a
+ * row that has settled never comes back.
+ */
+import type { TranscriptMessage } from './types.js';
+/**
+ * The most rows the window will ever hold, whatever the terminal's height.
+ *
+ * A cap on top of the height budget, because the budget alone would put thirty
+ * short rows in the live region on a tall terminal — thirty rows re-laid-out
+ * per spinner tick to make retroactive expansion available on output nobody is
+ * still looking at. Six covers what an operator is working with: a tool call,
+ * its result, and the exchange around them.
+ */
+export declare const MAX_LIVE_ROWS = 6;
+export interface LiveWindowInput {
+    /** Finalized rows, oldest first. The pending row is not one of these. */
+    readonly messages: readonly TranscriptMessage[];
+    /** Terminal height. `undefined` when not a TTY. */
+    readonly rows: number | undefined;
+    /** Terminal width, for wrapping. `undefined` falls back to 80. */
+    readonly columns: number | undefined;
+    /** Rows the live region occupies apart from the window: activity, composer, status bar. */
+    readonly furnitureRows: number;
+    /** How many rows have already settled into scrollback. The window never reaches back past this. */
+    readonly settled: number;
+}
+export interface LiveWindow {
+    /** `messages[0, settled)` are in scrollback; the rest are drawn live. */
+    readonly settled: number;
+    /** The live rows' estimated height, for the bottom spacer to account for. */
+    readonly rows: number;
+}
+/**
+ * Every line the finalized transcript will print, for a height estimate.
+ *
+ * Exported so the wiring is testable rather than only typecheckable. The
+ * spacer's own docblock states the asymmetry it depends on: over-count the
+ * content and the composer merely floats, under-count it and the composer is
+ * pushed off the bottom. The caller used to pass each row's `content` alone,
+ * which counted a six-line collapsed tool body as nothing at all — the estimate
+ * ran low by six per tool call, in the direction that costs the usability
+ * rather than the feature. `/expand` makes it acute: a row whose entire
+ * substance is a two-hundred-line body would have been handed over as one line.
+ *
+ * A pending row is excluded because it is not in the static log yet; the
+ * spacer's `liveRows` covers the live region.
+ */
+export declare function transcriptLines(messages: readonly TranscriptMessage[]): readonly string[];
+/**
+ * How much of the transcript stays live, given the room there is for it.
+ *
+ * Returns `settled === messages.length` — everything in scrollback, nothing
+ * redrawable — whenever the answer is not knowable: no TTY, an implausible
+ * height, or a most-recent row too tall to hold. That is the previous
+ * behaviour, and it is the safe direction.
+ */
+export declare function liveWindow(input: LiveWindowInput): LiveWindow;
+//# sourceMappingURL=live-window.d.ts.map

package/dist/tui/live-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-window.d.ts","sourceRoot":"","sources":["../../src/tui/live-window.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,IAAI,CAAA;AAE9B,MAAM,WAAW,eAAe;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAA;IAC/C,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,2FAA2F;IAC3F,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,mGAAmG;IACnG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,UAAU;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACrB;AAmBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,GAAG,SAAS,MAAM,EAAE,CAGzF;AA4BD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,UAAU,CAmB7D"}

package/dist/tui/live-window.js

@@ -0,0 +1,140 @@
+/**
+ * How much of the transcript is still ALIVE — redrawable — and how much has
+ * already been handed to the terminal's own scrollback.
+ *
+ * ## Why there is a window at all
+ *
+ * Every finalized row used to go straight into `<Static>`, which prints a row
+ * once and never redraws it. That kept per-frame work bounded, and it also made
+ * changing a row that is already on screen impossible by construction: an
+ * expand key could not reopen a collapsed body, so expansion had to become a
+ * command that appends a second copy of the output further down.
+ *
+ * A small window of the most recent rows is kept live instead. Inside it a row
+ * can be redrawn in place, so expansion works where an operator actually looks;
+ * `/expand <n>` remains the way to reach anything older, and the hint under a
+ * collapsed body already degrades correctly when a row has no number.
+ *
+ * ## Why the window is bounded by HEIGHT, not by a count of rows
+ *
+ * This is the constraint the whole design turns on, and it is a property of the
+ * renderer rather than a preference. When the live region's height reaches the
+ * viewport's, ink stops doing an incremental repaint and instead writes
+ * `clearTerminal` followed by **the entire static output it has accumulated
+ * this session** plus the frame. On a long session that is the whole transcript,
+ * re-serialized on every spinner tick — which is the allocation churn that
+ * pushed `<Static>` to swallow everything in the first place.
+ *
+ * So the window takes rows from the end only while their estimated height fits
+ * a budget the live furniture and a safety margin are already subtracted from.
+ * A single row taller than the budget leaves the window empty, and an empty
+ * window is exactly the previous behaviour — the failure direction is "no
+ * retroactive expansion", never "repaint the session".
+ *
+ * ## Why it only ever moves one way
+ *
+ * `settled` is a floor the caller carries between renders. `<Static>` keeps an
+ * index of how many items it has emitted and renders only what is past it, so a
+ * shrinking item list would leave rows unprinted; and a row that has already
+ * been drawn live must not be handed back to a mechanism that would print it
+ * again. Rows therefore leave the window in one direction, oldest first, and a
+ * row that has settled never comes back.
+ */
+import { renderedDetailLines } from './Transcript.js';
+import { SAFETY_ROWS, estimateRenderedLines } from './bottom-spacer.js';
+/**
+ * The most rows the window will ever hold, whatever the terminal's height.
+ *
+ * A cap on top of the height budget, because the budget alone would put thirty
+ * short rows in the live region on a tall terminal — thirty rows re-laid-out
+ * per spinner tick to make retroactive expansion available on output nobody is
+ * still looking at. Six covers what an operator is working with: a tool call,
+ * its result, and the exchange around them.
+ */
+export const MAX_LIVE_ROWS = 6;
+/**
+ * Every line one row will print, including the body under a tool call.
+ *
+ * The blank row `MessageRow` puts above every entry but the first and the `⎿`
+ * result rows is counted, because one row per entry is not negligible: forty
+ * entries is forty rows, which on most terminals is the whole viewport. The
+ * content is indented by the two-column glyph gutter it renders beside, so a
+ * long line is measured against the width it actually has.
+ */
+function messageLines(message, hasPrev) {
+    return [
+        ...(hasPrev && message.glyph !== '⎿' ? [''] : []),
+        `  ${message.content}`,
+        ...renderedDetailLines(message),
+    ];
+}
+/**
+ * Every line the finalized transcript will print, for a height estimate.
+ *
+ * Exported so the wiring is testable rather than only typecheckable. The
+ * spacer's own docblock states the asymmetry it depends on: over-count the
+ * content and the composer merely floats, under-count it and the composer is
+ * pushed off the bottom. The caller used to pass each row's `content` alone,
+ * which counted a six-line collapsed tool body as nothing at all — the estimate
+ * ran low by six per tool call, in the direction that costs the usability
+ * rather than the feature. `/expand` makes it acute: a row whose entire
+ * substance is a two-hundred-line body would have been handed over as one line.
+ *
+ * A pending row is excluded because it is not in the static log yet; the
+ * spacer's `liveRows` covers the live region.
+ */
+export function transcriptLines(messages) {
+    const finalized = messages.filter((m) => !m.pending);
+    return finalized.flatMap((message, i) => messageLines(message, i > 0));
+}
+/**
+ * Rows added to each windowed row's estimate.
+ *
+ * `estimateRenderedLines` is deliberately an UNDER-count, because for the
+ * bottom spacer counting low leaves more apparent room and the safety margin
+ * absorbs the difference. Here the asymmetry runs the other way: under-count a
+ * live row and the window takes more of the viewport than it was budgeted, and
+ * the price of exceeding the viewport is the whole-session repaint this window
+ * exists to stay clear of. Over-count and the window merely holds one row
+ * fewer.
+ *
+ * Two per row covers what the line estimate cannot see — the rule a code block
+ * draws around itself, the blank line markdown puts between blocks — without
+ * needing to model any of it.
+ */
+const ROW_HEIGHT_ALLOWANCE = 2;
+/** How tall one row is expected to render, rounded UP. */
+function messageHeight(message, hasPrev, columns) {
+    return estimateRenderedLines(messageLines(message, hasPrev), columns) + ROW_HEIGHT_ALLOWANCE;
+}
+/**
+ * How much of the transcript stays live, given the room there is for it.
+ *
+ * Returns `settled === messages.length` — everything in scrollback, nothing
+ * redrawable — whenever the answer is not knowable: no TTY, an implausible
+ * height, or a most-recent row too tall to hold. That is the previous
+ * behaviour, and it is the safe direction.
+ */
+export function liveWindow(input) {
+    const { messages, rows, columns, furnitureRows, settled } = input;
+    const floor = Math.min(Math.max(settled, 0), messages.length);
+    if (rows === undefined || !Number.isFinite(rows))
+        return { settled: messages.length, rows: 0 };
+    const budget = rows - furnitureRows - SAFETY_ROWS;
+    if (budget < 1)
+        return { settled: messages.length, rows: 0 };
+    let height = 0;
+    let held = 0;
+    for (let i = messages.length - 1; i >= floor && held < MAX_LIVE_ROWS; i--) {
+        const message = messages[i];
+        if (!message)
+            break;
+        const next = height + messageHeight(message, i > 0, columns);
+        if (next > budget)
+            break;
+        height = next;
+        held += 1;
+    }
+    return { settled: messages.length - held, rows: height };
+}
+//# sourceMappingURL=live-window.js.map

package/dist/tui/live-window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-window.js","sourceRoot":"","sources":["../../src/tui/live-window.ts"],"names":[],"mappings":"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"}

package/dist/tui/login-prompt.d.ts

@@ -0,0 +1,41 @@
+/**
+ * What namzu says while an operator signs in to their subscription.
+ *
+ * Every decidable thing lives here rather than in the component, for the
+ * reason `credential-entry.ts` gives next door: this package has no component
+ * tests, and wording that handles a credential is the worst thing to leave
+ * unverifiable. What the component does with these strings is print them.
+ *
+ * The one rule these functions exist to keep: **an outcome is described by
+ * what happened, never by quoting what came back.** A refusal from a token
+ * endpoint arrives in a document that can contain a token, so no function
+ * here ever receives one — `LoginOutcome.reason` is already sanitised at the
+ * protocol layer, and the success arm is handed a path, not a credential.
+ */
+import type { LoginOutcome } from '../integrations/providers/index.js';
+/**
+ * The screen the operator reads when a sign-in starts.
+ *
+ * The URL is printed WHATEVER happened with the browser. A launcher that
+ * started is not a browser that appeared — no platform reports that — and a
+ * message that says "your browser is opening" and nothing else leaves someone
+ * on a machine with no browser staring at a line that is simply false.
+ */
+export declare function describeLoginStart(start: {
+    readonly url: string;
+    readonly loopback: boolean;
+    readonly browserOpened: boolean;
+}): string;
+/** What the operator reads when the attempt ends, either way. */
+export declare function describeLoginOutcome(outcome: LoginOutcome): string;
+/** What the operator reads after asking namzu to forget the credential. */
+export declare function describeLogout(path: string, removed: boolean): string;
+/**
+ * Whether a `/login` argument is an attempt to finish, rather than to start.
+ *
+ * Bare `/login` starts an attempt; `/login <something>` finishes one. Drawn
+ * here rather than in the command so the rule is testable and so the command
+ * cannot quietly grow a third meaning.
+ */
+export declare function isCompletionArgument(args: readonly string[]): boolean;
+//# sourceMappingURL=login-prompt.d.ts.map

package/dist/tui/login-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login-prompt.d.ts","sourceRoot":"","sources":["../../src/tui/login-prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AAEtE;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACzC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;CAC/B,GAAG,MAAM,CAmBT;AAED,iEAAiE;AACjE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAUlE;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAIrE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAErE"}

package/dist/tui/login-prompt.js

@@ -0,0 +1,69 @@
+/**
+ * What namzu says while an operator signs in to their subscription.
+ *
+ * Every decidable thing lives here rather than in the component, for the
+ * reason `credential-entry.ts` gives next door: this package has no component
+ * tests, and wording that handles a credential is the worst thing to leave
+ * unverifiable. What the component does with these strings is print them.
+ *
+ * The one rule these functions exist to keep: **an outcome is described by
+ * what happened, never by quoting what came back.** A refusal from a token
+ * endpoint arrives in a document that can contain a token, so no function
+ * here ever receives one — `LoginOutcome.reason` is already sanitised at the
+ * protocol layer, and the success arm is handed a path, not a credential.
+ */
+/**
+ * The screen the operator reads when a sign-in starts.
+ *
+ * The URL is printed WHATEVER happened with the browser. A launcher that
+ * started is not a browser that appeared — no platform reports that — and a
+ * message that says "your browser is opening" and nothing else leaves someone
+ * on a machine with no browser staring at a line that is simply false.
+ */
+export function describeLoginStart(start) {
+    const lines = [
+        start.browserOpened
+            ? 'Opening your browser to sign in. If nothing opened, or the browser is on another machine, use this address:'
+            : 'Open this address to sign in — on this machine, or on any machine you can reach it from:',
+        '',
+        start.url,
+        '',
+    ];
+    lines.push(start.loopback
+        ? 'When the page finishes, namzu will pick it up automatically. If your browser is somewhere this machine cannot be reached from — a container, a remote shell — copy the address it lands on and run:'
+        : // Said plainly. The listener is what makes the automatic path work,
+            // and an operator who is not told it is missing will sit waiting for
+            // something that is never going to happen.
+            'The automatic hand-back is not available in this session (the port is in use, or this environment does not allow listening), so finish it by hand. Copy the address the browser lands on and run:');
+    lines.push('', '  /login <the address, or just the code>');
+    return lines.join('\n');
+}
+/** What the operator reads when the attempt ends, either way. */
+export function describeLoginOutcome(outcome) {
+    if (!outcome.ok) {
+        return `${outcome.reason}\n\nRun /login to try again.`;
+    }
+    return [
+        'Signed in. The credential is stored on this machine, readable only by your account:',
+        `  ${outcome.storedAt}`,
+        '',
+        'namzu will refresh it as it expires, and will find it again next time it starts. Run /logout to remove it.',
+    ].join('\n');
+}
+/** What the operator reads after asking namzu to forget the credential. */
+export function describeLogout(path, removed) {
+    return removed
+        ? `Removed the stored credential at ${path}. This session keeps working until it ends; the next one will ask you to sign in again.\n\nSigning out here does not revoke anything at the provider — do that in your account settings if you need to.`
+        : "There was no stored credential to remove. If namzu is using one, it came from your environment or from another tool on this machine, and neither is namzu's to delete.";
+}
+/**
+ * Whether a `/login` argument is an attempt to finish, rather than to start.
+ *
+ * Bare `/login` starts an attempt; `/login <something>` finishes one. Drawn
+ * here rather than in the command so the rule is testable and so the command
+ * cannot quietly grow a third meaning.
+ */
+export function isCompletionArgument(args) {
+    return args.join(' ').trim().length > 0;
+}
+//# sourceMappingURL=login-prompt.js.map

package/dist/tui/login-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"login-prompt.js","sourceRoot":"","sources":["../../src/tui/login-prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAIlC;IACA,MAAM,KAAK,GAAG;QACb,KAAK,CAAC,aAAa;YAClB,CAAC,CAAC,6GAA6G;YAC/G,CAAC,CAAC,0FAA0F;QAC7F,EAAE;QACF,KAAK,CAAC,GAAG;QACT,EAAE;KACF,CAAA;IACD,KAAK,CAAC,IAAI,CACT,KAAK,CAAC,QAAQ;QACb,CAAC,CAAC,qMAAqM;QACvM,CAAC,CAAC,oEAAoE;YACrE,qEAAqE;YACrE,2CAA2C;YAC3C,mMAAmM,CACrM,CAAA;IACD,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,0CAA0C,CAAC,CAAA;IAC1D,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACxB,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,oBAAoB,CAAC,OAAqB;IACzD,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;QACjB,OAAO,GAAG,OAAO,CAAC,MAAM,8BAA8B,CAAA;IACvD,CAAC;IACD,OAAO;QACN,qFAAqF;QACrF,KAAK,OAAO,CAAC,QAAQ,EAAE;QACvB,EAAE;QACF,4GAA4G;KAC5G,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACb,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,cAAc,CAAC,IAAY,EAAE,OAAgB;IAC5D,OAAO,OAAO;QACb,CAAC,CAAC,oCAAoC,IAAI,yMAAyM;QACnP,CAAC,CAAC,wKAAwK,CAAA;AAC5K,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAuB;IAC3D,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAA;AACxC,CAAC"}

package/dist/tui/markdown-block-cache.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Parse a growing markdown document without re-parsing what has not changed.
+ *
+ * ## The cost this removes
+ *
+ * A streaming assistant reply is one message whose text grows by a token at a
+ * time, and the row rendering it re-renders on every one of them. Parsing the
+ * whole message each time makes the work quadratic in the reply's length: a
+ * forty-block answer is parsed forty blocks deep on every token, when
+ * thirty-nine of those blocks are byte-for-byte what they were a token ago.
+ *
+ * So the document is scanned into top-level blocks — cheap, one pass over the
+ * lines — and only the blocks that are new are parsed. The rest come back as
+ * **the same objects**, which is the half that matters to the renderer:
+ * `BlockView` is memoised, so an unchanged block is not re-rendered, not
+ * re-split into inline spans, and not turned into fresh elements either.
+ *
+ * ## Why raw text is a sound key
+ *
+ * `parseBlock` reads only the segment it is given: nothing in this markdown
+ * subset makes one block's meaning depend on another (there are no
+ * reference-style link definitions, which is the construct that would). Same
+ * segment ⇒ same block, so a hit cannot differ from a fresh parse. The
+ * `markdownParser` docblock states that property; it is the contract this file
+ * depends on, and it is why there is no "give up on caching when the document
+ * contains X" escape hatch here. There is no such X.
+ *
+ * ## Why the last two blocks are never cached
+ *
+ * Not for correctness — a key is a whole segment, so a block whose text grows
+ * simply misses under its new text and is parsed. It is to keep the cache from
+ * accumulating garbage: a block that is still being written passes through
+ * every one of its own prefixes, and storing them would put an entry per TOKEN
+ * into a structure meant to hold an entry per block. That is the memory the
+ * quadratic parse was costing, moved rather than removed.
+ *
+ * Two, not one, because the block still being written is not always the last
+ * segment. A half-typed table row is not yet a table row — `| 1 | 2` has no
+ * closing pipe — so it scans as a paragraph of its own, and the table above it
+ * becomes the second-to-last segment while still growing a row at a time. One
+ * excluded segment would have cached that table once per row, at increasing
+ * size. The line being typed can reach back exactly one segment and no further:
+ * it can be absorbed by the block above it, and that block is maximal, so there
+ * is nothing for it to reach past.
+ *
+ * The cost of the wider exclusion is one extra parse per block over the life of
+ * the message, against a saving of one per block per token.
+ */
+import { type MdBlock } from './markdownParser.js';
+export interface BlockCache {
+    /** Blocks of `src`, reusing the block objects of unchanged segments. */
+    parse(src: string): MdBlock[];
+    /** How many segments are being held. One per completed block. */
+    readonly size: number;
+}
+export declare function createBlockCache(): BlockCache;
+//# sourceMappingURL=markdown-block-cache.d.ts.map

package/dist/tui/markdown-block-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-block-cache.d.ts","sourceRoot":"","sources":["../../src/tui/markdown-block-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,EAAE,KAAK,OAAO,EAA0B,MAAM,qBAAqB,CAAA;AAE1E,MAAM,WAAW,UAAU;IAC1B,wEAAwE;IACxE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACrB;AAED,wBAAgB,gBAAgB,IAAI,UAAU,CAqB7C"}

package/dist/tui/markdown-block-cache.js

@@ -0,0 +1,74 @@
+/**
+ * Parse a growing markdown document without re-parsing what has not changed.
+ *
+ * ## The cost this removes
+ *
+ * A streaming assistant reply is one message whose text grows by a token at a
+ * time, and the row rendering it re-renders on every one of them. Parsing the
+ * whole message each time makes the work quadratic in the reply's length: a
+ * forty-block answer is parsed forty blocks deep on every token, when
+ * thirty-nine of those blocks are byte-for-byte what they were a token ago.
+ *
+ * So the document is scanned into top-level blocks — cheap, one pass over the
+ * lines — and only the blocks that are new are parsed. The rest come back as
+ * **the same objects**, which is the half that matters to the renderer:
+ * `BlockView` is memoised, so an unchanged block is not re-rendered, not
+ * re-split into inline spans, and not turned into fresh elements either.
+ *
+ * ## Why raw text is a sound key
+ *
+ * `parseBlock` reads only the segment it is given: nothing in this markdown
+ * subset makes one block's meaning depend on another (there are no
+ * reference-style link definitions, which is the construct that would). Same
+ * segment ⇒ same block, so a hit cannot differ from a fresh parse. The
+ * `markdownParser` docblock states that property; it is the contract this file
+ * depends on, and it is why there is no "give up on caching when the document
+ * contains X" escape hatch here. There is no such X.
+ *
+ * ## Why the last two blocks are never cached
+ *
+ * Not for correctness — a key is a whole segment, so a block whose text grows
+ * simply misses under its new text and is parsed. It is to keep the cache from
+ * accumulating garbage: a block that is still being written passes through
+ * every one of its own prefixes, and storing them would put an entry per TOKEN
+ * into a structure meant to hold an entry per block. That is the memory the
+ * quadratic parse was costing, moved rather than removed.
+ *
+ * Two, not one, because the block still being written is not always the last
+ * segment. A half-typed table row is not yet a table row — `| 1 | 2` has no
+ * closing pipe — so it scans as a paragraph of its own, and the table above it
+ * becomes the second-to-last segment while still growing a row at a time. One
+ * excluded segment would have cached that table once per row, at increasing
+ * size. The line being typed can reach back exactly one segment and no further:
+ * it can be absorbed by the block above it, and that block is maximal, so there
+ * is nothing for it to reach past.
+ *
+ * The cost of the wider exclusion is one extra parse per block over the life of
+ * the message, against a saving of one per block per token.
+ */
+import { parseBlock, scanBlocks } from './markdownParser.js';
+export function createBlockCache() {
+    const blocks = new Map();
+    return {
+        parse(src) {
+            const segments = scanBlocks(src);
+            const settled = segments.length - 2;
+            return segments.map((segment, i) => {
+                // The tail is where the text is still being written, so it is parsed
+                // every time and stored never.
+                if (i >= settled)
+                    return parseBlock(segment);
+                const hit = blocks.get(segment);
+                if (hit)
+                    return hit;
+                const parsed = parseBlock(segment);
+                blocks.set(segment, parsed);
+                return parsed;
+            });
+        },
+        get size() {
+            return blocks.size;
+        },
+    };
+}
+//# sourceMappingURL=markdown-block-cache.js.map

package/dist/tui/markdown-block-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-block-cache.js","sourceRoot":"","sources":["../../src/tui/markdown-block-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,EAAgB,UAAU,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAS1E,MAAM,UAAU,gBAAgB;IAC/B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAmB,CAAA;IACzC,OAAO;QACN,KAAK,CAAC,GAAW;YAChB,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,CAAA;YAChC,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAA;YACnC,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE;gBAClC,qEAAqE;gBACrE,+BAA+B;gBAC/B,IAAI,CAAC,IAAI,OAAO;oBAAE,OAAO,UAAU,CAAC,OAAO,CAAC,CAAA;gBAC5C,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;gBAC/B,IAAI,GAAG;oBAAE,OAAO,GAAG,CAAA;gBACnB,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;gBAClC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;gBAC3B,OAAO,MAAM,CAAA;YACd,CAAC,CAAC,CAAA;QACH,CAAC;QACD,IAAI,IAAI;YACP,OAAO,MAAM,CAAC,IAAI,CAAA;QACnB,CAAC;KACD,CAAA;AACF,CAAC"}