@dieulc/workflow 0.7.0 → 0.8.0

package/picker.ts

@@ -0,0 +1,246 @@
+/**
+ * Filterable picker primitives shared by the `/profile` and `/role` overlays.
+ *
+ * pi-tui's `SelectList` deliberately has no text composer: `handleInput()` only
+ * understands Up/Down/Enter/Escape and silently drops printable keys, while
+ * `setFilter()` is a prefix match on `item.value`. pi's own `/model` selector
+ * solves this with an `Input` + `fuzzyFilter`; this module exposes the same
+ * shape as a reusable component because pi's selector lives in pi's internal
+ * `dist/` and is not a public export.
+ *
+ * Contract for `FilterableList.handleInput(data)`:
+ *   - returns `true` when the key was consumed by the composer or list;
+ *   - returns `false` for Enter (`tui.select.confirm`) and for the cancel key
+ *     when the filter is already empty, so the caller can apply its own
+ *     confirm / back / cancel semantics (Enter on a no-match list must stay
+ *     inert instead of closing the overlay).
+ */
+
+import {
+  Input,
+  Key,
+  SelectList,
+  fuzzyFilter,
+  getKeybindings,
+  matchesKey,
+  type SelectItem,
+  type SelectListLayoutOptions,
+  type SelectListTheme,
+} from "@earendil-works/pi-tui";
+
+/** A selectable row plus hidden text that the filter may match but never renders. */
+export interface FilterableItem extends SelectItem {
+  /**
+   * Extra search-only text (e.g. a model's display name). `SelectList` ignores
+   * unknown properties, so this never affects the rendered columns.
+   */
+  searchText?: string;
+}
+
+/** The text a row is matched against: label, value, description and hidden text. */
+export function pickerItemText(item: FilterableItem): string {
+  const parts: string[] = [];
+  const seen = new Set<string>();
+  for (const part of [
+    item.label,
+    item.value,
+    item.description,
+    item.searchText,
+  ]) {
+    if (!part) continue;
+    const text = part.trim();
+    // Model rows use the ref as both label and value; dedupe so the fuzzy
+    // scorer does not weight the same string twice (and can still award the
+    // exact-match bonus).
+    if (!text || seen.has(text)) continue;
+    seen.add(text);
+    parts.push(text);
+  }
+  return parts.join(" ");
+}
+
+/**
+ * Fuzzy-filter `items` (best match first). A blank query returns every item.
+ * Matching uses `fuzzyFilter`, so whitespace- and slash-separated tokens all
+ * have to match; it is case-insensitive.
+ */
+export function filterPickerItems<T extends FilterableItem>(
+  items: readonly T[],
+  query: string,
+  getText: (item: T) => string = pickerItemText,
+): T[] {
+  const all = [...items];
+  if (!query.trim()) return all;
+  return fuzzyFilter(all, query, getText);
+}
+
+export interface FilterableListOptions {
+  items: readonly FilterableItem[];
+  maxVisible: number;
+  theme: SelectListTheme;
+  layout?: SelectListLayoutOptions;
+  /** Seed the composer (e.g. a filter remembered across a re-opened picker). */
+  initialQuery?: string;
+  /** Initial cursor when the query is empty. */
+  initialIndex?: number;
+  /** Filter-text builder; defaults to `pickerItemText`. */
+  searchText?: (item: FilterableItem) => string;
+  /** Message shown when nothing matches (without the two-space indent). */
+  noMatchText?: string;
+}
+
+/**
+ * A `SelectList` paired with an `Input` composer and fuzzy filtering.
+ *
+ * `SelectList` has no item setter, so the inner list is rebuilt whenever the
+ * filtered set changes. The wrapper itself is stable, which is what callers
+ * keep per tab so filter text and cursor survive tab switches.
+ */
+export class FilterableList {
+  private items: FilterableItem[];
+  private filtered: FilterableItem[];
+  private query: string;
+  private readonly maxVisible: number;
+  private readonly theme: SelectListTheme;
+  private readonly layout: SelectListLayoutOptions | undefined;
+  private readonly searchText: (item: FilterableItem) => string;
+  private readonly noMatchText: string;
+  private readonly input: Input;
+  private inner: SelectList;
+
+  constructor(opts: FilterableListOptions) {
+    this.items = [...opts.items];
+    this.maxVisible = opts.maxVisible;
+    this.theme = opts.theme;
+    this.layout = opts.layout;
+    this.searchText = opts.searchText ?? pickerItemText;
+    this.noMatchText = opts.noMatchText ?? "No matching entries";
+    this.input = new Input();
+    // Input.setValue() clamps the cursor instead of moving it to the end, so a
+    // remembered query is seeded by simulating typing. Otherwise the next key
+    // would be inserted at position 0.
+    if (opts.initialQuery) this.input.handleInput(opts.initialQuery);
+    this.query = this.input.getValue();
+    this.filtered = filterPickerItems(this.items, this.query, this.searchText);
+    this.inner = new SelectList(
+      this.filtered,
+      this.maxVisible,
+      this.theme,
+      this.layout,
+    );
+    if (!this.query && opts.initialIndex && opts.initialIndex > 0) {
+      this.inner.setSelectedIndex(opts.initialIndex);
+    }
+  }
+
+  /** Current filter text ("" when unfiltered). */
+  getQuery(): string {
+    return this.query;
+  }
+
+  /** All rows, unfiltered. */
+  getItems(): readonly FilterableItem[] {
+    return this.items;
+  }
+
+  /** Rows matching the current query (the list the user is navigating). */
+  getFilteredItems(): readonly FilterableItem[] {
+    return this.filtered;
+  }
+
+  /** The highlighted row, or null when nothing matches. */
+  getSelectedItem(): SelectItem | null {
+    return this.inner.getSelectedItem();
+  }
+
+  /** Move the cursor (only meaningful while the query is empty). */
+  setSelectedIndex(index: number): void {
+    this.inner.setSelectedIndex(index);
+  }
+
+  /** Reset the filter and restore the full list. */
+  clearFilter(): void {
+    if (!this.query) return;
+    this.applyQuery("");
+  }
+
+  /**
+   * Replace the rows (e.g. Ctrl+O scope toggle). The query and the selected
+   * value are preserved when they still exist in the new set.
+   */
+  setItems(items: readonly FilterableItem[]): void {
+    const previous = this.inner.getSelectedItem()?.value;
+    this.items = [...items];
+    this.refilter(previous);
+  }
+
+  /** One composer line, sized to `width`. */
+  renderQuery(width: number): string[] {
+    return this.input.render(Math.max(1, width));
+  }
+
+  /** The filtered list, or a themed no-match line, sized to `width`. */
+  renderList(width: number): string[] {
+    if (this.filtered.length === 0) {
+      return [this.theme.noMatch(`  ${this.noMatchText}`)];
+    }
+    return this.inner.render(Math.max(1, width));
+  }
+
+  /**
+   * Navigation + filter editing. Returns false for keys the caller owns:
+   * Enter, and Escape/Ctrl+C when the filter is empty.
+   */
+  handleInput(data: string): boolean {
+    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+      if (this.query) {
+        this.applyQuery("");
+        return true;
+      }
+      return false;
+    }
+    const kb = getKeybindings();
+    if (
+      kb.matches(data, "tui.select.up") ||
+      kb.matches(data, "tui.select.down")
+    ) {
+      if (this.filtered.length > 0) this.inner.handleInput(data);
+      return true;
+    }
+    if (kb.matches(data, "tui.select.confirm")) return false;
+    this.input.handleInput(data);
+    const next = this.input.getValue();
+    if (next !== this.query) this.applyQuery(next);
+    return true;
+  }
+
+  /** Apply a new query, resetting to the top match or restoring the previous row. */
+  private applyQuery(next: string): void {
+    const previous = this.inner.getSelectedItem()?.value;
+    this.query = next;
+    if (this.input.getValue() !== next) this.input.setValue(next);
+    this.refilter(previous);
+  }
+
+  private refilter(previous: string | undefined): void {
+    this.filtered = filterPickerItems(
+      this.items,
+      this.query,
+      this.searchText,
+    );
+    this.inner = new SelectList(
+      this.filtered,
+      this.maxVisible,
+      this.theme,
+      this.layout,
+    );
+    if (this.query) {
+      this.inner.setSelectedIndex(0);
+      return;
+    }
+    const index = previous
+      ? this.filtered.findIndex((item) => item.value === previous)
+      : -1;
+    this.inner.setSelectedIndex(Math.max(0, index));
+  }
+}

package/profiles.ts

@@ -419,6 +419,42 @@ export function applyProfileOverlay(
 
 // ── Display ──────────────────────────────────────────────────────────
 
+/** One selectable model row for pi-tui's `SelectList`. */
+export interface ModelPickerItem {
+  value: string;
+  label: string;
+  /**
+   * Hidden search text (the model's display name). Never rendered: `SelectList`
+   * only reads value/label/description, so this cannot reserve a column or
+   * truncate the ref.
+   */
+  searchText?: string;
+}
+
+/**
+ * The rows of a model picker: the **full** `provider/id` in the label, never a
+ * `description`.
+ *
+ * pi-tui reserves a fixed 32-cell primary column whenever a row has a
+ * description (and truncates the label to 30), which is what used to cut long
+ * refs such as `synthetic/hf:deepseek-ai/DeepSeek-V4.1-Flash-1017` even on a wide
+ * pane. Selection and scope state belong in the picker header, not in a column.
+ * The optional display name travels as `searchText`, so typing what `/model`
+ * shows (e.g. "DeepSeek V4.1 Flash") still matches without touching the row's
+ * visible shape.
+ */
+export function modelPickerItems(
+  entries: readonly { provider: string; id: string; name?: string }[],
+): ModelPickerItem[] {
+  return entries.map((entry) => {
+    const ref = `${entry.provider}/${entry.id}`;
+    const name = entry.name?.trim();
+    return name
+      ? { value: ref, label: ref, searchText: name }
+      : { value: ref, label: ref };
+  });
+}
+
 /** One-line summary: `⚡ cheap — 🧠 a/b (high) · 🔍 …` (for picker rows). */
 export function formatProfileOneLine(p: Profile): string {
   const parts = PROFILE_ROLES.map((r) => {
@@ -454,6 +490,24 @@ export function describeProfile(p: Profile): string {
   return lines.join("\n");
 }
 
+// ── Picker flow ──────────────────────────────────────────────────────
+
+/** Result of a `/profile` sub-flow (editor, default picker, action). */
+export type ProfileFlowOutcome = "completed" | "cancelled" | "failed";
+
+/**
+ * Whether a finished `/profile` sub-flow closes the picker overlay.
+ *
+ * Only a completed action closes it. Cancelled or failed sub-flows stay on the
+ * profile list so the user can retry or choose another action, and the action
+ * menu's "back" entry is navigation, never a close.
+ */
+export function profileActionClosesPicker(
+  outcome: ProfileFlowOutcome | "back",
+): boolean {
+  return outcome === "completed";
+}
+
 export function formatProfilesForDisplay(
   config: ProfileConfig,
   activeName?: string | null,
@@ -533,6 +587,25 @@ export function defaultProfileSettingPaths(
   };
 }
 
+/**
+ * Which scope a `workflow.defaultProfile` write should target: the project file
+ * when it already defines the key (so an existing project value stays
+ * effective), otherwise global.
+ *
+ * Mirrors `modelDefaultWriteScope` in model-default.ts. Without this, an
+ * activation would write global while a project value kept shadowing it, and
+ * the write would silently do nothing.
+ */
+export function defaultProfileWriteScope(
+  cwd: string,
+  agentDir: string,
+): "global" | "project" {
+  const paths = defaultProfileSettingPaths(cwd, agentDir);
+  return extractDefaultProfile(readSettingsSafe(paths.project)) !== undefined
+    ? "project"
+    : "global";
+}
+
 /**
  * Extract `workflow.defaultProfile` (a profile name string) from a raw
  * settings object. Anything else (absent, non-string, blank) → undefined.

package/questionnaire-layout.ts

@@ -0,0 +1,340 @@
+/**
+ * Questionnaire viewport geometry and scroll state.
+ *
+ * This module is deliberately pure: no Pi runtime imports and no pi-tui
+ * imports. The questionnaire view is rendered as a flat component (the host's
+ * input dock treats the editor container as a leaf, so an inner layout node
+ * would be ignored), which means the view must bound its own height and slice
+ * its panes by hand. Keeping that math here makes it deterministic and easy to
+ * unit-test.
+ */
+
+/** Hard cap for the questionnaire's rendered height. */
+export const QUESTIONNAIRE_MAX_TOTAL_ROWS = 32;
+
+/** Share of the terminal height the bottom-sheet overlay is allowed to use. */
+export const QUESTIONNAIRE_MAX_FRACTION = 0.8;
+
+/**
+ * The `overlayOptions.maxHeight` string used by the questionnaire host.
+ * Keep in sync with `QUESTIONNAIRE_MAX_FRACTION` (the view caps at
+ * `floor(rows * fraction) - 1`, so it is always inside the overlay).
+ */
+export const QUESTIONNAIRE_OVERLAY_MAX_HEIGHT = "80%";
+
+/** A question longer than this is not pinned above the scroll body. */
+export const QUESTIONNAIRE_MAX_PINNED_QUESTION_LINES = 3;
+
+/** Maximum logical answer lines shown under the freeform row. */
+export const QUESTIONNAIRE_MAX_ANSWER_PREVIEW_LINES = 2;
+
+/**
+ * Maximum number of lines the questionnaire may render for a terminal with
+ * `termRows` rows. Always at least 1 and always at most the overlay's
+ * `floor(termRows * 0.8)` (minus a one-line safety margin), so the overlay's
+ * own `maxHeight` slice can never cut the pinned choices.
+ */
+export function questionnaireMaxRows(termRows: number): number {
+  // A zero/undefined/negative terminal height is not meaningful; fall back to
+  // a typical 24-row terminal instead of collapsing the UI to one line.
+  const raw = Number.isFinite(termRows) && termRows > 0 ? termRows : 24;
+  const rows = Math.max(1, Math.floor(raw));
+  const overlayMax = Math.max(
+    1,
+    Math.floor(rows * QUESTIONNAIRE_MAX_FRACTION),
+  );
+  return Math.max(
+    1,
+    Math.min(QUESTIONNAIRE_MAX_TOTAL_ROWS, overlayMax - 1),
+  );
+}
+
+export interface QuestionnaireBudgetInput {
+  termRows: number;
+  /** Height of the top border / tab row. */
+  topHeight: number;
+  /** Height of a pinned short question (including its trailing blank). */
+  pinnedHeight: number;
+  /** Height of the help / status / bottom border block. */
+  bottomHeight: number;
+  /** Full height of the question/context (or answers summary) body. */
+  questionContentHeight: number;
+  /** Full height of the option list (or editor pane). */
+  optionsContentHeight: number;
+  /** Input mode: give the editor pane every row it can use. */
+  editorPriority?: boolean;
+  minQuestionRows?: number;
+  minOptionRows?: number;
+  /** Optional lower cap (never raises the host cap). */
+  maxTotalRows?: number;
+}
+
+export interface QuestionnaireBudget {
+  /** top + pinned + question + options + bottom. */
+  total: number;
+  /** Viewport height for the question/context body. */
+  question: number;
+  /** Viewport height for the option list / editor pane. */
+  options: number;
+  questionOverflow: boolean;
+  optionsOverflow: boolean;
+}
+
+function toSize(value: number | undefined, fallback = 0): number {
+  if (!Number.isFinite(value as number)) return fallback;
+  return Math.max(0, Math.floor(value as number));
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}
+
+/**
+ * Allocate the available rows between the scrolling question body and the
+ * pinned option list.
+ *
+ * The options are the controls, so they are kept intact whenever they fit
+ * alongside the minimum question height. When both bodies overflow, the
+ * question gets roughly 40% and the options the rest; the selected option is
+ * kept visible by `keepRangeVisible`, and the option list scrolls when even
+ * that is not enough. The returned `total` is the exact rendered height
+ * assuming the caller has already trimmed its chrome below `questionnaireMaxRows`.
+ */
+export function computeQuestionnaireBudget(
+  input: QuestionnaireBudgetInput,
+): QuestionnaireBudget {
+  const hostCap = questionnaireMaxRows(input.termRows);
+  const cap = Math.min(
+    hostCap,
+    toSize(input.maxTotalRows, QUESTIONNAIRE_MAX_TOTAL_ROWS),
+  );
+  const top = toSize(input.topHeight);
+  const pinned = toSize(input.pinnedHeight);
+  const bottom = toSize(input.bottomHeight);
+  const fixed = top + pinned + bottom;
+  const avail = Math.max(0, cap - fixed);
+  const questionContent = toSize(input.questionContentHeight);
+  const optionsContent = toSize(input.optionsContentHeight);
+
+  if (avail === 0) {
+    return {
+      total: fixed,
+      question: 0,
+      options: 0,
+      questionOverflow: questionContent > 0,
+      optionsOverflow: optionsContent > 0,
+    };
+  }
+
+  const minQuestion = Math.min(
+    avail,
+    toSize(input.minQuestionRows, 2),
+  );
+  const minOptions = Math.min(avail, toSize(input.minOptionRows, 2));
+
+  let question: number;
+  let options: number;
+
+  if (input.editorPriority) {
+    // The editor is the thing the user is typing into: show all of it that
+    // fits, then give any remainder to the question/context.
+    options = Math.min(optionsContent, avail);
+    question = Math.min(questionContent, Math.max(0, avail - options));
+  } else if (optionsContent <= Math.max(0, avail - minQuestion)) {
+    // The choices fit while reserving the minimum question area.
+    options = optionsContent;
+    question = Math.min(questionContent, Math.max(0, avail - options));
+  } else {
+    // Both need to scroll. The choices keep a larger share (they are the
+    // controls); the selected row is auto-scrolled by the caller.
+    question = Math.min(
+      questionContent,
+      Math.max(minQuestion, Math.floor(avail * 0.4)),
+    );
+    options = Math.min(optionsContent, Math.max(0, avail - question));
+    // If the question still has slack, honor the minimum option height so
+    // the pinned choice block does not collapse to a single clipped row.
+    const targetOptions = Math.min(minOptions, optionsContent);
+    if (options < targetOptions && question > minQuestion) {
+      const shift = Math.min(question - minQuestion, targetOptions - options);
+      question -= shift;
+      options += shift;
+    }
+    if (options === 0 && optionsContent > 0 && avail > 0) {
+      options = Math.min(1, avail);
+      question = Math.max(0, avail - options);
+    }
+  }
+
+  // Defensive clamps: never exceed the available content/space and never
+  // return a fractional or negative height.
+  question = clamp(question, 0, Math.min(questionContent, avail));
+  options = clamp(options, 0, Math.min(optionsContent, avail - question));
+
+  return {
+    total: fixed + question + options,
+    question,
+    options,
+    questionOverflow: question < questionContent,
+    optionsOverflow: options < optionsContent,
+  };
+}
+
+/** A manually-sliced viewport: which line range of a body is visible. */
+export interface ScrollPane {
+  scrollTop: number;
+  contentHeight: number;
+  viewportHeight: number;
+}
+
+export function createScrollPane(): ScrollPane {
+  return { scrollTop: 0, contentHeight: 0, viewportHeight: 0 };
+}
+
+/** Largest valid `scrollTop` for the pane's current content/viewport. */
+export function maxScrollTop(pane: ScrollPane): number {
+  const content = toSize(pane.contentHeight);
+  const viewport = toSize(pane.viewportHeight);
+  return Math.max(0, content - viewport);
+}
+
+/** Recompute the pane's dimensions and clamp `scrollTop` into range. */
+export function updateScrollPane(
+  pane: ScrollPane,
+  contentHeight: number,
+  viewportHeight: number,
+): void {
+  pane.contentHeight = toSize(contentHeight);
+  pane.viewportHeight = toSize(viewportHeight);
+  const top = Number.isFinite(pane.scrollTop) ? pane.scrollTop : 0;
+  pane.scrollTop = clamp(Math.floor(top), 0, maxScrollTop(pane));
+}
+
+/** Set the pane's scroll position, clamped to its current limits. */
+export function scrollPaneTo(pane: ScrollPane, scrollTop: number): void {
+  const next = Number.isFinite(scrollTop) ? Math.floor(scrollTop) : 0;
+  pane.scrollTop = clamp(next, 0, maxScrollTop(pane));
+}
+
+/** Scroll the pane by `delta` lines (positive = down). */
+export function scrollPaneBy(pane: ScrollPane, delta: number): void {
+  const step = Number.isFinite(delta) ? Math.trunc(delta) : 0;
+  scrollPaneTo(pane, pane.scrollTop + step);
+}
+
+/** Inclusive-exclusive line range in a body. */
+export interface LineRange {
+  start: number;
+  end: number;
+}
+
+/**
+ * Return the scrollTop that keeps `range` visible.
+ *
+ * - A range that fits is fully shown.
+ * - A range taller than the viewport keeps the current scrollTop when it is
+ *   already inside the range, so a long selected description can be read
+ *   instead of snapping back to its first line.
+ * - Out-of-range values are clamped to the pane.
+ */
+export function keepRangeVisible(pane: ScrollPane, range: LineRange): number {
+  const content = toSize(pane.contentHeight);
+  const viewport = toSize(pane.viewportHeight);
+  const maxTop = Math.max(0, content - viewport);
+  const current = clamp(toSize(pane.scrollTop), 0, maxTop);
+
+  if (viewport <= 0 || content <= 0) return 0;
+
+  const rawStart = Math.min(range.start, range.end);
+  const rawEnd = Math.max(range.start, range.end);
+  const start = clamp(toSize(rawStart), 0, content);
+  const end = clamp(toSize(rawEnd), start, content);
+
+  // Already fully visible.
+  if (start >= current && end <= current + viewport) return current;
+
+  // Taller than the viewport: stay inside the range if possible, otherwise
+  // show its first line.
+  if (end - start > viewport) {
+    if (current >= start && current <= end - viewport) return current;
+    return clamp(start, 0, maxTop);
+  }
+
+  // Above the viewport.
+  if (start < current) return clamp(start, 0, maxTop);
+
+  // Below the viewport; scrolling to `end - viewport` shows the whole range.
+  if (end > current + viewport) return clamp(end - viewport, 0, maxTop);
+
+  return current;
+}
+
+/**
+ * Parse a wheel event into a line delta (+3 = down, -3 = up, 0 = not a wheel).
+ * Supports SGR (`\x1b[<64;x;yM`) and X10 (`\x1b[M` + 3 bytes) sequences.
+ * Horizontal wheel events (66/67) are ignored.
+ */
+export function parseWheelScroll(data: string): number {
+  if (!data) return 0;
+
+  const sgr = /\x1b\[<(\d+);\d+;\d+[Mm]/.exec(data);
+  if (sgr) {
+    const button = Number(sgr[1]);
+    if (button === 64) return -3;
+    if (button === 65) return 3;
+    return 0;
+  }
+
+  const x10 = data.indexOf("\x1b[M");
+  if (x10 >= 0 && data.length >= x10 + 6) {
+    const button = data.charCodeAt(x10 + 3) - 32;
+    if (button === 64) return -3;
+    if (button === 65) return 3;
+  }
+
+  return 0;
+}
+
+/** Human-readable position, e.g. `1–12/42` (empty content → `0/0`). */
+export function formatScrollPosition(pane: ScrollPane): string {
+  const content = toSize(pane.contentHeight);
+  if (content <= 0) return "0/0";
+  const viewport = toSize(pane.viewportHeight);
+  const maxTop = Math.max(0, content - viewport);
+  const top = clamp(toSize(pane.scrollTop), 0, maxTop);
+  const first = Math.min(content, top + 1);
+  const last = Math.min(content, top + Math.max(1, viewport));
+  return `${first}–${last}/${content}`;
+}
+
+/**
+ * Split text into at most `maxLines` display lines for the inline
+ * "↳ Your answer" preview, with a rough character wrap. The caller should
+ * still truncate/format each line to the real terminal width; this helper only
+ * guarantees the preview's line cap and reports how many lines were hidden.
+ */
+export function previewTextLines(
+  text: string,
+  width: number,
+  maxLines: number,
+): { lines: string[]; hidden: number } {
+  const safeWidth = Math.max(1, toSize(width, 1));
+  const max = Math.max(0, toSize(maxLines, 0));
+  const wrapped: string[] = [];
+
+  for (const raw of String(text ?? "").split(/\r?\n/)) {
+    if (raw.length === 0) {
+      wrapped.push("");
+      continue;
+    }
+    let rest = raw;
+    while (rest.length > safeWidth) {
+      wrapped.push(rest.slice(0, safeWidth));
+      rest = rest.slice(safeWidth);
+    }
+    wrapped.push(rest);
+  }
+
+  const lines = wrapped.slice(0, max);
+  return { lines, hidden: Math.max(0, wrapped.length - lines.length) };
+}