privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-G56GYQFZ.mjs

@@ -0,0 +1,2507 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  COLLAPSE_KEY_OFF,
+  DEFAULT_COLLAPSE_KEY,
+  ROW_INTENT_META,
+  displayLabel,
+  formatAnswerScalar,
+  formatKeySpecForDisplay,
+  t
+} from "./c-2IDLKXX6.mjs";
+import "./c-B2Y7VNHU.mjs";
+import {
+  DynamicBorder
+} from "./c-SKMK3PEE.mjs";
+import "./c-I54OKQHW.mjs";
+import "./c-UPBH5AXY.mjs";
+import "./c-7UOG7POX.mjs";
+import "./c-E4Z3Y5B5.mjs";
+import "./c-6ZO2SADQ.mjs";
+import "./c-JKTFXTGF.mjs";
+import {
+  getMarkdownTheme
+} from "./c-CRBXNKFO.mjs";
+import "./c-KP6CRIP4.mjs";
+import "./c-RSKCUPJF.mjs";
+import "./c-PTN4S6G2.mjs";
+import "./c-P6N5DQGZ.mjs";
+import "./c-6LOBR4I6.mjs";
+import "./c-3STKRSVO.mjs";
+import "./c-YRDO2WEF.mjs";
+import "./c-BHNIF2AR.mjs";
+import "./c-ABXULAFL.mjs";
+import "./c-2G3BBHRJ.mjs";
+import "./c-O5PP6CTX.mjs";
+import "./c-CDBEJSBF.mjs";
+import "./c-DEE67DJO.mjs";
+import "./c-WO3QSZUU.mjs";
+import "./c-S2RVHR3M.mjs";
+import {
+  CURSOR_MARKER,
+  Container,
+  Editor,
+  Key,
+  Markdown,
+  Spacer,
+  Text,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi
+} from "./c-EQBKXWNX.mjs";
+import "./c-RQJJ26T4.mjs";
+import "./c-L5GHWG5G.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/scroll-window.ts?ext=rpiv-ask-user-question
+var OVERFLOW_UP = "\u2191";
+var OVERFLOW_DOWN = "\u2193";
+var OVERFLOW_BOTH = "\u2195";
+function computeScrollStart(bodyRange, rowsBeforeBody, availableMiddle, middleRows) {
+  if (!bodyRange) return 0;
+  const focusedRowInMiddle = rowsBeforeBody + bodyRange[0];
+  const focusedHeight = bodyRange[1] - bodyRange[0];
+  const idealStart = focusedRowInMiddle - Math.floor(Math.max(0, availableMiddle - focusedHeight) / 2);
+  return Math.max(0, Math.min(idealStart, middleRows - availableMiddle));
+}
+__name(computeScrollStart, "computeScrollStart");
+function decorateOverflow(scrollableMiddle, hasUp, hasDown, theme, protectedRows) {
+  const drawable = /* @__PURE__ */ __name((row) => !protectedRows || row < protectedRows[0] || row >= protectedRows[1], "drawable");
+  if (hasUp && hasDown && scrollableMiddle.length === 1) {
+    if (drawable(0)) scrollableMiddle[0] = theme.fg("dim", OVERFLOW_BOTH);
+    return;
+  }
+  if (hasUp && scrollableMiddle.length > 0 && drawable(0)) {
+    scrollableMiddle[0] = theme.fg("dim", OVERFLOW_UP);
+  }
+  const last = scrollableMiddle.length - 1;
+  if (hasDown && last > 0 && drawable(last)) {
+    scrollableMiddle[last] = theme.fg("dim", OVERFLOW_DOWN);
+  }
+}
+__name(decorateOverflow, "decorateOverflow");
+function windowLines(lines, rows, focus, theme) {
+  if (lines.length <= rows) return { lines: [...lines], focus };
+  const start = computeScrollStart(focus, 0, rows, lines.length);
+  const visible = lines.slice(start, start + rows);
+  const inWindow = focus && [focus[0] - start, focus[1] - start];
+  decorateOverflow(visible, start > 0, start + rows < lines.length, theme, inWindow);
+  return { lines: visible, focus: inWindow };
+}
+__name(windowLines, "windowLines");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/state/selectors/derivations.ts?ext=rpiv-ask-user-question
+function selectConfirmedIndicator(questions, currentTab, answers, items) {
+  const q = questions[currentTab];
+  if (!q || q.multiSelect === true) return void 0;
+  const prior = answers.get(currentTab);
+  if (!prior) return void 0;
+  if (prior.kind === "custom") {
+    const otherIndex = items.findIndex((it) => it.kind === "other");
+    if (otherIndex < 0) return void 0;
+    return { index: otherIndex, labelOverride: prior.answer ?? "" };
+  }
+  if (prior.kind !== "option" || typeof prior.answer !== "string") return void 0;
+  const index = items.findIndex((it) => it.kind === "option" && it.label === prior.answer);
+  if (index < 0) return void 0;
+  return { index };
+}
+__name(selectConfirmedIndicator, "selectConfirmedIndicator");
+function selectActivePreviewPaneIndex(currentTab, totalQuestions) {
+  if (totalQuestions <= 0) return 0;
+  return Math.min(currentTab, totalQuestions - 1);
+}
+__name(selectActivePreviewPaneIndex, "selectActivePreviewPaneIndex");
+function selectSavedNote(notesByTab, answers, tab) {
+  const note = notesByTab.get(tab) ?? answers.get(tab)?.notes;
+  return note && note.length > 0 ? note : void 0;
+}
+__name(selectSavedNote, "selectSavedNote");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/dialog-copy.ts?ext=rpiv-ask-user-question
+var HINT_PART_ENTER = "Enter to select";
+var HINT_PART_NAV = "\u2191/\u2193 to navigate";
+var HINT_PART_NEW_LINE = "Shift+Enter for newline";
+var HINT_PART_CLEAR = "Ctrl+U to clear";
+var HINT_PART_TOGGLE = "Space to toggle";
+var HINT_PART_NOTES = "n to add notes";
+var HINT_PART_TAB = "Tab to switch questions";
+var HINT_PART_CANCEL = "Esc to cancel";
+var KEY_PLACEHOLDER = "{key}";
+var HINT_PART_COLLAPSE_TEMPLATE = `${KEY_PLACEHOLDER} to collapse`;
+var HINT_PART_EXPAND_TEMPLATE = `${KEY_PLACEHOLDER} to expand`;
+var HINT_PART_COLLAPSE = HINT_PART_COLLAPSE_TEMPLATE.replace(
+  KEY_PLACEHOLDER,
+  formatKeySpecForDisplay(DEFAULT_COLLAPSE_KEY)
+);
+var HINT_SINGLE = [HINT_PART_ENTER, HINT_PART_NAV, HINT_PART_NOTES, HINT_PART_CANCEL].join(" \xB7 ");
+var HINT_MULTI = [HINT_PART_ENTER, HINT_PART_NAV, HINT_PART_NOTES, HINT_PART_TAB, HINT_PART_CANCEL].join(
+  " \xB7 "
+);
+var COLLAPSED_HINT_TEMPLATE = [HINT_PART_EXPAND_TEMPLATE, HINT_PART_CANCEL].join(" \xB7 ");
+var REVIEW_HEADING = "Review your answers";
+var READY_PROMPT = "Ready to submit your answers?";
+var INCOMPLETE_WARNING_PREFIX = "\u26A0 Answer remaining questions before submitting:";
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/tab-content-strategy.ts?ext=rpiv-ask-user-question
+var NOTES_HEADER = "Notes:";
+var GLOBAL_NOTES_HEADER = "Global note:";
+var REVIEW_GLOBAL_HINT = "n to add a note";
+var REVIEW_NOTE_LABEL = "Note";
+var SAVED_NOTE_LABEL = "Note for this answer:";
+var OneLineClippedText = class {
+  constructor(text, paddingLeft = 0) {
+    this.text = text;
+    this.paddingLeft = paddingLeft;
+  }
+  text;
+  paddingLeft;
+  static {
+    __name(this, "OneLineClippedText");
+  }
+  render(width) {
+    const pad = " ".repeat(this.paddingLeft);
+    const avail = Math.max(0, width - this.paddingLeft);
+    return [pad + truncateToWidth(this.text, avail, "\u2026", false)];
+  }
+  invalidate() {
+  }
+  handleInput(_data) {
+  }
+};
+var QuestionTabStrategy = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  static {
+    __name(this, "QuestionTabStrategy");
+  }
+  /** Spacer(1) + OneLineClippedText(hint, 1) = 2 rendered rows. */
+  footerRowCount = 2;
+  headingRows(state) {
+    const out = [];
+    const question = this.config.questions[state.currentTab];
+    if (!this.config.isMulti && question?.header && question.header.length > 0) {
+      out.push(new Text(this.config.theme.bg("selectedBg", ` ${question.header} `), 1, 0));
+      out.push(new Spacer(1));
+    }
+    if (question) {
+      out.push(new Text(this.config.theme.bold(question.question), 1, 0));
+      out.push(new Spacer(1));
+    }
+    return out;
+  }
+  bodyComponent(state) {
+    const question = this.config.questions[state.currentTab];
+    const mso = this.config.tabsByIndex[state.currentTab]?.multiSelect;
+    if (question?.multiSelect === true && mso) return mso;
+    return this.config.getPreviewPane();
+  }
+  bodyHeight(width, _state) {
+    return this.config.getCurrentBodyHeight(width);
+  }
+  midRows(state) {
+    if (state.notesVisible) {
+      return [
+        new Text(this.config.theme.fg("muted", t("notes.header", NOTES_HEADER)), 1, 0),
+        this.config.notesInput,
+        new Spacer(1)
+      ];
+    }
+    const note = selectSavedNote(state.notesByTab, state.answers, state.currentTab);
+    if (note === void 0) return [];
+    const [firstLine = "", ...rest] = note.split("\n");
+    const text = `${t("notes.saved_label", SAVED_NOTE_LABEL)} ${firstLine}${rest.length > 0 ? " \u2026" : ""}`;
+    return [new OneLineClippedText(this.config.theme.fg("dim", text), 1)];
+  }
+  footerRows(state) {
+    const question = this.config.questions[state.currentTab];
+    return [
+      new Spacer(1),
+      new OneLineClippedText(
+        this.config.theme.fg("dim", buildHintText(question, this.config.isMulti, state, this.config.collapseKey)),
+        1
+      )
+    ];
+  }
+  focusedItemRowRange(width, state) {
+    const question = this.config.questions[state.currentTab];
+    const mso = this.config.tabsByIndex[state.currentTab]?.multiSelect;
+    if (question?.multiSelect === true && mso) return mso.focusedItemRowRange(width);
+    return this.config.getPreviewPane().focusedItemRowRange(width);
+  }
+};
+var SubmitTabStrategy = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  static {
+    __name(this, "SubmitTabStrategy");
+  }
+  /** Spacer(1) + Text(prompt, 1) + submitPicker(2) + OneLineClippedText(hint, 1) = 5 rendered rows. Fallback path lands at 5 via 2 Spacer(1)s in the picker slot. */
+  footerRowCount = 5;
+  headingRows(_state) {
+    return [
+      new Text(this.config.theme.bold(this.config.theme.fg("accent", t("review.heading", REVIEW_HEADING))), 1, 0),
+      new Spacer(1)
+    ];
+  }
+  bodyComponent(state) {
+    const c = new Container();
+    for (let i = 0; i < this.config.questions.length; i++) {
+      const q = this.config.questions[i];
+      const a = state.answers.get(i);
+      if (!a) continue;
+      const label = q.header && q.header.length > 0 ? q.header : `Q${i + 1}`;
+      const answerText = formatAnswerScalar(a, "summary");
+      c.addChild(new Text(this.config.theme.fg("muted", ` \u25CF ${label}`), 1, 0));
+      c.addChild(
+        new Text(`   ${this.config.theme.fg("muted", "\u2192")} ${this.config.theme.fg("text", answerText)}`, 1, 0)
+      );
+      if (a.notes && a.notes.length > 0) {
+        c.addChild(
+          new Text(
+            this.config.theme.fg("dim", `     ${t("notes.saved_label", SAVED_NOTE_LABEL)} ${a.notes}`),
+            1,
+            0
+          )
+        );
+      }
+    }
+    const globalNote = state.notesByTab.get(this.config.questions.length);
+    if (!state.notesVisible && globalNote && globalNote.length > 0) {
+      c.addChild(new Text(this.config.theme.fg("muted", ` \u25CF ${t("review.note_label", REVIEW_NOTE_LABEL)}`), 1, 0));
+      c.addChild(
+        new Text(`   ${this.config.theme.fg("muted", "\u2192")} ${this.config.theme.fg("text", globalNote)}`, 1, 0)
+      );
+    }
+    return c;
+  }
+  bodyHeight(width, state) {
+    return this.bodyComponent(state).render(width).length;
+  }
+  midRows(state) {
+    if (!state.notesVisible) return [];
+    return [
+      new Text(this.config.theme.fg("muted", t("notes.global_header", GLOBAL_NOTES_HEADER)), 1, 0),
+      this.config.notesInput,
+      new Spacer(1)
+    ];
+  }
+  footerRows(state) {
+    const missing = [];
+    for (let i = 0; i < this.config.questions.length; i++) {
+      const q = this.config.questions[i];
+      if (!state.answers.has(i)) {
+        missing.push(q.header && q.header.length > 0 ? q.header : `Q${i + 1}`);
+      }
+    }
+    const promptText = missing.length === 0 ? this.config.theme.fg("muted", t("review.ready", READY_PROMPT)) : this.config.theme.fg(
+      "warning",
+      `${t("review.incomplete", INCOMPLETE_WARNING_PREFIX)} ${missing.join(", ")}`
+    );
+    const out = [new Spacer(1), new OneLineClippedText(promptText, 1)];
+    if (this.config.submitPicker) {
+      out.push(this.config.submitPicker);
+    } else {
+      out.push(new Spacer(1));
+      out.push(new Spacer(1));
+    }
+    out.push(new OneLineClippedText(this.config.theme.fg("dim", buildSubmitHintText(state)), 1));
+    return out;
+  }
+  focusedItemRowRange(_width, _state) {
+    return void 0;
+  }
+};
+function buildHintText(question, isMulti, state, collapseKey) {
+  const parts = [t("hint.enter", HINT_PART_ENTER), t("hint.navigate", HINT_PART_NAV)];
+  if (question?.multiSelect === true) parts.push(t("hint.toggle", HINT_PART_TOGGLE));
+  if (question && !state.notesVisible && !state.inputMode) parts.push(t("hint.notes", HINT_PART_NOTES));
+  if (isMulti) parts.push(t("hint.tab", HINT_PART_TAB));
+  parts.push(t("hint.cancel", HINT_PART_CANCEL));
+  if (collapseKey !== COLLAPSE_KEY_OFF) {
+    parts.push(
+      t("hint.collapse", HINT_PART_COLLAPSE_TEMPLATE).replace(KEY_PLACEHOLDER, formatKeySpecForDisplay(collapseKey))
+    );
+  }
+  if (state.notesVisible || state.inputMode) parts.push(t("hint.newline", HINT_PART_NEW_LINE));
+  if (state.inputMode) parts.push(t("hint.clear", HINT_PART_CLEAR));
+  return parts.join(" \xB7 ");
+}
+__name(buildHintText, "buildHintText");
+function buildSubmitHintText(state) {
+  const parts = [t("hint.enter", HINT_PART_ENTER), t("hint.navigate", HINT_PART_NAV)];
+  if (!state.notesVisible) parts.push(t("review.global_hint", REVIEW_GLOBAL_HINT));
+  parts.push(t("hint.cancel", HINT_PART_CANCEL));
+  if (state.notesVisible) parts.push(t("hint.newline", HINT_PART_NEW_LINE));
+  return parts.join(" \xB7 ");
+}
+__name(buildSubmitHintText, "buildSubmitHintText");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/dialog-builder.ts?ext=rpiv-ask-user-question
+var MIN_SCROLL_ROWS_WITH_PINNED_HEADING = 3;
+function renderFitsTerminal(natural, spacerRows) {
+  return spacerRows > 0 ? [...natural, ...Array(spacerRows).fill("")] : natural;
+}
+__name(renderFitsTerminal, "renderFitsTerminal");
+function renderChromeOnly(natural, topFixed, bottomFixed, termRows) {
+  const chromeOnly = [...natural.slice(0, topFixed), ...natural.slice(natural.length - bottomFixed)];
+  return chromeOnly.length > termRows ? chromeOnly.slice(0, termRows) : chromeOnly;
+}
+__name(renderChromeOnly, "renderChromeOnly");
+var DialogView = class {
+  static {
+    __name(this, "DialogView");
+  }
+  liveProps;
+  config;
+  questionStrategy;
+  submitStrategy;
+  maxFooterRowCount;
+  constructor(config, initialProps) {
+    this.config = config;
+    this.liveProps = initialProps;
+    this.questionStrategy = new QuestionTabStrategy({
+      theme: config.theme,
+      questions: config.questions,
+      getPreviewPane: /* @__PURE__ */ __name(() => this.liveProps.activePreviewPane, "getPreviewPane"),
+      tabsByIndex: config.tabsByIndex,
+      notesInput: config.notesInput,
+      isMulti: config.isMulti,
+      getCurrentBodyHeight: config.getCurrentBodyHeight,
+      collapseKey: config.collapseKey
+    });
+    this.submitStrategy = config.isMulti ? new SubmitTabStrategy({
+      theme: config.theme,
+      questions: config.questions,
+      submitPicker: config.submitPicker,
+      notesInput: config.notesInput
+    }) : void 0;
+    this.maxFooterRowCount = Math.max(this.questionStrategy.footerRowCount, this.submitStrategy?.footerRowCount ?? 0);
+  }
+  setProps(props) {
+    this.liveProps = props;
+  }
+  handleInput(_data) {
+  }
+  // Invalidation is driven by `QuestionnairePropsAdapter.invalidate()`, which
+  // owns the full set of renderables (binding registries + extras like
+  // `notesInput`). DialogView has no cached layout of its own.
+  invalidate() {
+  }
+  render(width) {
+    const state = this.liveProps.state;
+    const onSubmit = this.config.isMulti && state.currentTab === this.config.questions.length;
+    const strategy = onSubmit && this.submitStrategy ? this.submitStrategy : this.questionStrategy;
+    const headingRowCache = strategy.headingRows(state);
+    const headingHeight = headingRowCache.reduce((rows, c) => rows + c.render(width).length, 0);
+    const topFixed = 1 + (this.config.isMulti && this.config.tabBar ? 2 : 0) + 1;
+    const bottomFixed = 1 + strategy.footerRowCount;
+    const termRows = this.config.getTerminalRows();
+    this.allotBodyRows(
+      onSubmit,
+      termRows - topFixed - headingHeight - bottomFixed - this.rowsAroundBody(strategy, width)
+    );
+    const natural = this.buildContainerFromStrategy(strategy, headingRowCache).render(width);
+    const restingMidRows = state.notesVisible ? 0 : this.rowsAroundBody(strategy, width) - 1;
+    const spacerRows = Math.max(
+      0,
+      this.config.getBodyHeight(width) + this.maxFooterRowCount - strategy.bodyHeight(width, state) - strategy.footerRowCount - restingMidRows
+    );
+    if (natural.length <= termRows) {
+      return renderFitsTerminal(natural, Math.min(spacerRows, termRows - natural.length));
+    }
+    const pinHeading = termRows - topFixed - headingHeight - bottomFixed >= MIN_SCROLL_ROWS_WITH_PINNED_HEADING;
+    const top = pinHeading ? topFixed + headingHeight : topFixed;
+    const middleRows = natural.length - top - bottomFixed;
+    const availableMiddle = Math.max(0, termRows - top - bottomFixed);
+    if (availableMiddle === 0) {
+      return renderChromeOnly(natural, top, bottomFixed, termRows);
+    }
+    const windowRows = Math.min(availableMiddle, middleRows);
+    const rowsBeforeBody = pinHeading ? 0 : headingHeight;
+    const focusedRange = strategy.focusedItemRowRange(width, state);
+    const scrollStart = computeScrollStart(focusedRange, rowsBeforeBody, windowRows, middleRows);
+    const scrollableMiddle = natural.slice(top + scrollStart, top + scrollStart + windowRows);
+    const focusedInWindow = focusedRange && [
+      rowsBeforeBody + focusedRange[0] - scrollStart,
+      rowsBeforeBody + focusedRange[1] - scrollStart
+    ];
+    decorateOverflow(
+      scrollableMiddle,
+      scrollStart > 0,
+      scrollStart + windowRows < middleRows,
+      this.config.theme,
+      focusedInWindow
+    );
+    const result = [...natural.slice(0, top), ...scrollableMiddle, ...natural.slice(natural.length - bottomFixed)];
+    return result.length > termRows ? result.slice(0, termRows) : result;
+  }
+  /** Rows between the body and the bottom border: the body's trailing Spacer(1) plus any mid rows (e.g. the notes editor). */
+  rowsAroundBody(strategy, width) {
+    return 1 + strategy.midRows(this.liveProps.state).reduce((rows, c) => rows + c.render(width).length, 0);
+  }
+  /**
+   * Hand the active question's preview pane the rows its body may use this frame, so a body
+   * taller than the space fits itself — options scroll in their column, the preview box
+   * shrinks but closes — instead of the scroll window below slicing through it (#210).
+   * Other tabs' panes are cleared so a stale allowance never skews the cross-tab height.
+   * Below `MIN_SCROLL_ROWS_WITH_PINNED_HEADING` the dialog's own scroll window takes over.
+   */
+  allotBodyRows(onSubmit, bodyRows) {
+    const active = onSubmit || bodyRows < MIN_SCROLL_ROWS_WITH_PINNED_HEADING ? void 0 : this.liveProps.activePreviewPane;
+    for (const tab of this.config.tabsByIndex) {
+      tab.preview?.setRowAllowance?.(tab.preview === active ? bodyRows : void 0);
+    }
+  }
+  buildContainerFromStrategy(strategy, headingRowCache) {
+    const { theme, isMulti, tabBar } = this.config;
+    const state = this.liveProps.state;
+    const container = new Container();
+    const border = /* @__PURE__ */ __name(() => new DynamicBorder((s) => theme.fg("accent", s)), "border");
+    container.addChild(border());
+    if (isMulti && tabBar) container.addChild(tabBar);
+    container.addChild(new Spacer(1));
+    for (const c of headingRowCache) container.addChild(c);
+    container.addChild(strategy.bodyComponent(state));
+    container.addChild(new Spacer(1));
+    for (const c of strategy.midRows(state)) container.addChild(c);
+    container.addChild(border());
+    for (const c of strategy.footerRows(state)) container.addChild(c);
+    return container;
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/component-binding.ts?ext=rpiv-ask-user-question
+function globalBinding(spec) {
+  return {
+    apply: /* @__PURE__ */ __name((state, ctx) => spec.component.setProps(spec.select(state, ctx)), "apply"),
+    invalidate: /* @__PURE__ */ __name(() => spec.component.invalidate(), "invalidate")
+  };
+}
+__name(globalBinding, "globalBinding");
+function perTabBinding(spec) {
+  return {
+    apply: /* @__PURE__ */ __name((state, ctx) => {
+      if (spec.predicate && !spec.predicate(state, ctx)) return;
+      spec.resolve(ctx.tab)?.setProps(spec.select(state, ctx));
+    }, "apply")
+  };
+}
+__name(perTabBinding, "perTabBinding");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/inline-input.ts?ext=rpiv-ask-user-question
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function resolveCursorOffset(buffer, requested) {
+  if (requested !== void 0 && requested >= 0 && requested <= buffer.length) return requested;
+  return buffer.length;
+}
+__name(resolveCursorOffset, "resolveCursorOffset");
+function buildCursorRaw(buffer, offset) {
+  const before = buffer.slice(0, offset);
+  const [firstGrapheme] = graphemeSegmenter.segment(buffer.slice(offset));
+  const rawAt = firstGrapheme ? firstGrapheme.segment : "";
+  const cursorAtLineEnd = rawAt === "\n";
+  const atCursor = rawAt === "" || rawAt === " " || cursorAtLineEnd ? "\xA0" : rawAt;
+  const after = buffer.slice(offset + (cursorAtLineEnd ? 0 : rawAt.length));
+  return `${before}${CURSOR_MARKER}\x1B[7m${atCursor}\x1B[27m${after}`;
+}
+__name(buildCursorRaw, "buildCursorRaw");
+function renderInlineInputRow(opts) {
+  const { buffer, cursorOffset, rowPrefix, continuationPrefix, contentWidth, selectedText } = opts;
+  const raw = buildCursorRaw(buffer, resolveCursorOffset(buffer, cursorOffset));
+  return wrapTextWithAnsi(raw, contentWidth).map((segment, index) => {
+    const prefix = index === 0 ? rowPrefix : continuationPrefix;
+    return selectedText(`${prefix}${segment}`);
+  });
+}
+__name(renderInlineInputRow, "renderInlineInputRow");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/multi-select-view.ts?ext=rpiv-ask-user-question
+var ACTIVE_POINTER = "\u276F ";
+var INACTIVE_POINTER = "  ";
+var CHECKED = "[\u2714]";
+var UNCHECKED = "[ ]";
+var NUMBER_SEPARATOR = ". ";
+var BOX_LABEL_GAP = " ";
+var CONTINUATION_INDENT = "  ";
+var MULTI_SUBMIT_LABEL = "Submit";
+var MultiSelectView = class {
+  constructor(theme, question) {
+    this.theme = theme;
+    this.question = question;
+    this.props = {
+      rows: [],
+      other: { active: false, checked: false, inputMode: false, inputBuffer: "", inputCursorOffset: void 0 },
+      nextActive: false,
+      nextLabel: displayLabel("next")
+    };
+  }
+  theme;
+  question;
+  static {
+    __name(this, "MultiSelectView");
+  }
+  props;
+  cachedLayout;
+  setProps(props) {
+    this.props = props;
+    this.cachedLayout = void 0;
+  }
+  handleInput(_data) {
+  }
+  invalidate() {
+    this.cachedLayout = void 0;
+  }
+  render(width) {
+    return this.layout(width).lines;
+  }
+  focusedItemRowRange(width) {
+    return this.layout(width).focusedRange;
+  }
+  naturalHeight(width) {
+    return this.layout(width).lines.length;
+  }
+  layout(width) {
+    if (this.cachedLayout?.width === width) return this.cachedLayout.value;
+    const build = { lines: [], focusedRange: [0, 0] };
+    const contentWidth = Math.max(1, width - this.prefixVisibleWidth());
+    const numberWidth = String(Math.max(1, this.question.options.length + 1)).length;
+    this.appendOptionRows(build, width, contentWidth, numberWidth);
+    const otherStart = build.lines.length;
+    build.lines.push(...this.renderOtherRow(contentWidth, numberWidth));
+    if (this.props.other.active) build.focusedRange = [otherStart, build.lines.length];
+    this.appendNextRow(build, width);
+    const value = { lines: build.lines, focusedRange: build.focusedRange };
+    this.cachedLayout = { width, value };
+    return value;
+  }
+  appendOptionRows(build, width, contentWidth, numberWidth) {
+    for (let i = 0; i < this.question.options.length; i++) {
+      const opt = this.question.options[i];
+      const row = this.props.rows[i];
+      if (!opt || !row) continue;
+      const start = build.lines.length;
+      const pointer = row.active ? this.theme.fg("accent", ACTIVE_POINTER) : INACTIVE_POINTER;
+      const box = row.checked ? this.theme.fg("accent", CHECKED) : this.theme.fg("muted", UNCHECKED);
+      const label = truncateToWidth(opt.label, contentWidth, "\u2026");
+      const styledLabel = row.active ? this.theme.fg("accent", this.theme.bold(label)) : label;
+      const number = String(i + 1).padStart(numberWidth, " ");
+      build.lines.push(
+        truncateToWidth(`${pointer}${number}${NUMBER_SEPARATOR}${box}${BOX_LABEL_GAP}${styledLabel}`, width, "")
+      );
+      if (opt.description) {
+        for (const segment of wrapTextWithAnsi(opt.description, contentWidth)) {
+          build.lines.push(CONTINUATION_INDENT + this.theme.fg("muted", segment));
+        }
+      }
+      if (row.active) build.focusedRange = [start, build.lines.length];
+    }
+  }
+  appendNextRow(build, width) {
+    const nextStart = build.lines.length;
+    const nextPointer = this.props.nextActive ? this.theme.fg("accent", ACTIVE_POINTER) : INACTIVE_POINTER;
+    const nextLabel = this.props.nextActive ? this.theme.fg("accent", this.theme.bold(this.props.nextLabel)) : this.props.nextLabel;
+    build.lines.push(truncateToWidth(`${nextPointer}${nextLabel}`, width, ""));
+    if (this.props.nextActive) build.focusedRange = [nextStart, build.lines.length];
+  }
+  renderOtherRow(contentWidth, numberWidth) {
+    const other = this.props.other;
+    const pointer = other.active ? this.theme.fg("accent", ACTIVE_POINTER) : INACTIVE_POINTER;
+    const box = other.checked ? this.theme.fg("accent", CHECKED) : this.theme.fg("muted", UNCHECKED);
+    const number = String(this.question.options.length + 1).padStart(numberWidth, " ");
+    const rowPrefix = `${pointer}${number}${NUMBER_SEPARATOR}${box}${BOX_LABEL_GAP}`;
+    const continuationPrefix = " ".repeat(visibleWidth(rowPrefix));
+    const selectedText = /* @__PURE__ */ __name((text) => this.theme.fg("accent", this.theme.bold(text)), "selectedText");
+    if (other.active && other.inputMode) {
+      return renderInlineInputRow({
+        buffer: other.inputBuffer,
+        cursorOffset: other.inputCursorOffset,
+        rowPrefix,
+        continuationPrefix,
+        contentWidth,
+        selectedText
+      });
+    }
+    return wrapTextWithAnsi(other.inputBuffer || displayLabel("other"), contentWidth).map((segment, index) => {
+      const line = `${index === 0 ? rowPrefix : continuationPrefix}${segment}`;
+      return other.active ? selectedText(line) : line;
+    });
+  }
+  prefixVisibleWidth() {
+    const numberWidth = String(Math.max(1, this.question.options.length + 1)).length;
+    return visibleWidth(INACTIVE_POINTER) + numberWidth + visibleWidth(`${NUMBER_SEPARATOR}${UNCHECKED}${BOX_LABEL_GAP}`);
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/wrapping-select.ts?ext=rpiv-ask-user-question
+var WrappingSelect = class _WrappingSelect {
+  static {
+    __name(this, "WrappingSelect");
+  }
+  static ACTIVE_POINTER = "\u276F ";
+  static INACTIVE_POINTER = "  ";
+  static NUMBER_SEPARATOR = ". ";
+  static CONFIRMED_MARK = " \u2714";
+  static MIN_CONTENT_WIDTH = 1;
+  items;
+  maxVisible;
+  theme;
+  numberStartOffset;
+  totalItemsForNumbering;
+  selectedIndex = 0;
+  focused = true;
+  inputBuffer = "";
+  inputCursorOffset = void 0;
+  /**
+   * Index of the row that was previously confirmed for this list (e.g. the user's prior
+   * answer when re-entering a multi-question tab). Renders `<label> ✔` in the active-row
+   * styling but WITHOUT the `❯` pointer — pointer is reserved for the live cursor. When
+   * `selectedIndex === confirmedIndex && focused`, the active rendering wins (no double-mark).
+   */
+  confirmedIndex = void 0;
+  /**
+   * When set together with `confirmedIndex`, replaces the row's static label at render time.
+   * Used for the `kind: "other"` sentinel — its label is "Type something." but if the user's
+   * prior answer was custom text, we render that text instead (e.g. `4. Hello ✔`).
+   */
+  confirmedLabelOverride = void 0;
+  constructor(items, maxVisible, theme, options = {}) {
+    this.items = items;
+    this.maxVisible = Math.max(1, maxVisible);
+    this.theme = theme;
+    this.numberStartOffset = options.numberStartOffset ?? 0;
+    this.totalItemsForNumbering = options.totalItemsForNumbering ?? items.length;
+  }
+  /**
+   * Update the numbering offset + total padding width without rebuilding the component.
+   * Lets the host realign the number column when the underlying item set changes.
+   */
+  setNumbering(numberStartOffset, totalItemsForNumbering) {
+    this.numberStartOffset = numberStartOffset;
+    this.totalItemsForNumbering = Math.max(1, totalItemsForNumbering);
+  }
+  setSelectedIndex(index) {
+    this.selectedIndex = Math.max(0, Math.min(index, this.items.length - 1));
+  }
+  setFocused(focused) {
+    this.focused = focused;
+  }
+  /**
+   * Mark a previously-confirmed row. Pass `undefined` to clear. `labelOverride` replaces
+   * the row's static `item.label` at render time — used for the `kind: "other"` sentinel so
+   * the row reads `Hello ✔` instead of `Type something. ✔` when the prior answer was custom
+   * text.
+   */
+  setConfirmedIndex(index, labelOverride) {
+    if (index === void 0) {
+      this.confirmedIndex = void 0;
+      this.confirmedLabelOverride = void 0;
+      return;
+    }
+    this.confirmedIndex = Math.max(0, Math.min(index, this.items.length - 1));
+    this.confirmedLabelOverride = labelOverride;
+  }
+  setInputBuffer(text) {
+    this.inputBuffer = text;
+  }
+  /** Set the cursor offset for the inline input row. `undefined` → end-of-buffer fallback. */
+  setInputCursorOffset(offset) {
+    this.inputCursorOffset = offset;
+  }
+  /** Intentionally empty — input is routed at the container level. */
+  handleInput(_data) {
+  }
+  invalidate() {
+  }
+  render(width) {
+    if (this.items.length === 0) return [];
+    const { startIndex, endIndex } = this.computeVisibleWindow();
+    const numberWidth = String(Math.max(1, this.totalItemsForNumbering)).length;
+    const lines = [];
+    for (let i = startIndex; i < endIndex; i++) {
+      const item = this.items[i];
+      if (!item) continue;
+      const isActive = i === this.selectedIndex && this.focused;
+      lines.push(...this.renderItem(item, i, isActive, width, numberWidth));
+    }
+    if (this.hasItemsOutsideWindow(startIndex, endIndex)) {
+      lines.push(this.theme.scrollInfo(`  (${this.selectedIndex + 1}/${this.items.length})`));
+    }
+    return lines;
+  }
+  /**
+   * Returns the [startRow, endRow) range of the focused (selected) item within
+   * the output of `render(width)`. Computed by iterating the visible window and
+   * summing per-item row counts — O(maxVisible) per call.
+   */
+  focusedItemRowRange(width) {
+    if (this.items.length === 0) return [0, 0];
+    const { startIndex, endIndex } = this.computeVisibleWindow();
+    const numberWidth = String(Math.max(1, this.totalItemsForNumbering)).length;
+    let row = 0;
+    for (let i = startIndex; i < endIndex; i++) {
+      const item = this.items[i];
+      if (!item) continue;
+      const isActive = i === this.selectedIndex && this.focused;
+      const itemRowCount = this.computeItemRowCount(item, i, isActive, width, numberWidth);
+      if (i === this.selectedIndex) {
+        return [row, row + itemRowCount];
+      }
+      row += itemRowCount;
+    }
+    return [0, 1];
+  }
+  /**
+   * Per-item row count. Delegates to `renderItem().length` so `renderItem` remains
+   * the single source of truth for per-item row math — eliminates the prior shadow-copy
+   * that risked silent miscounts when new `kind` values branch in `renderItem` but not here.
+   */
+  computeItemRowCount(item, index, isActive, width, numberWidth) {
+    return this.renderItem(item, index, isActive, width, numberWidth).length;
+  }
+  computeVisibleWindow() {
+    const half = Math.floor(this.maxVisible / 2);
+    const startIndex = Math.max(0, Math.min(this.selectedIndex - half, this.items.length - this.maxVisible));
+    const endIndex = Math.min(startIndex + this.maxVisible, this.items.length);
+    return { startIndex, endIndex };
+  }
+  hasItemsOutsideWindow(startIndex, endIndex) {
+    return startIndex > 0 || endIndex < this.items.length;
+  }
+  renderItem(item, index, isActive, width, numberWidth) {
+    const rowPrefix = this.buildRowPrefix(index, isActive, numberWidth);
+    const continuationPrefix = " ".repeat(visibleWidth(rowPrefix));
+    const contentWidth = Math.max(_WrappingSelect.MIN_CONTENT_WIDTH, width - visibleWidth(rowPrefix));
+    if (this.shouldRenderAsInlineInput(item, isActive)) {
+      return this.renderInlineInputRow(rowPrefix, continuationPrefix, contentWidth);
+    }
+    const { label, isConfirmed } = this.deriveConfirmedState(item, index);
+    const applySelectedStyle = isActive || isConfirmed;
+    return [
+      ...this.renderLabelBlock(label, rowPrefix, continuationPrefix, contentWidth, applySelectedStyle),
+      ...this.renderDescriptionBlock(item.description, continuationPrefix, contentWidth)
+    ];
+  }
+  /**
+   * Derive the confirmed-rendering facts for one row: the final label (custom draft
+   * or confirmed-override aware) and whether the ✔ mark applies.
+   */
+  deriveConfirmedState(item, index) {
+    const customDraft = item.kind === "other" ? this.inputBuffer : void 0;
+    const customDraftDiffersFromConfirmed = item.kind === "other" && customDraft !== "" && index === this.confirmedIndex && customDraft !== (this.confirmedLabelOverride ?? "");
+    const isConfirmed = index === this.confirmedIndex && !customDraftDiffersFromConfirmed;
+    const baseLabel = customDraft ? customDraft : item.label;
+    const label = isConfirmed ? `${this.confirmedLabelOverride ?? baseLabel}${_WrappingSelect.CONFIRMED_MARK}` : baseLabel;
+    return { label, isConfirmed };
+  }
+  buildRowPrefix(index, isActive, numberWidth) {
+    const pointer = isActive ? _WrappingSelect.ACTIVE_POINTER : _WrappingSelect.INACTIVE_POINTER;
+    const displayNumber = this.numberStartOffset + index + 1;
+    const paddedNumber = String(displayNumber).padStart(numberWidth, " ");
+    return `${pointer}${paddedNumber}${_WrappingSelect.NUMBER_SEPARATOR}`;
+  }
+  shouldRenderAsInlineInput(item, isActive) {
+    return item.kind === "other" && isActive;
+  }
+  /** Render the inline editor across logical and visually wrapped lines. */
+  renderInlineInputRow(rowPrefix, continuationPrefix, contentWidth) {
+    return renderInlineInputRow({
+      buffer: this.inputBuffer,
+      cursorOffset: this.inputCursorOffset,
+      rowPrefix,
+      continuationPrefix,
+      contentWidth,
+      selectedText: this.theme.selectedText
+    });
+  }
+  renderLabelBlock(label, rowPrefix, continuationPrefix, contentWidth, applySelectedStyle) {
+    const wrapped = wrapTextWithAnsi(label, contentWidth);
+    return wrapped.map((segment, index) => {
+      const prefix = index === 0 ? rowPrefix : continuationPrefix;
+      const line = `${prefix}${segment}`;
+      return applySelectedStyle ? this.theme.selectedText(line) : line;
+    });
+  }
+  renderDescriptionBlock(description, continuationPrefix, contentWidth) {
+    if (!description) return [];
+    const wrapped = wrapTextWithAnsi(description, contentWidth);
+    return wrapped.map((segment) => `${continuationPrefix}${this.theme.description(segment)}`);
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/option-list-view.ts?ext=rpiv-ask-user-question
+var MAX_VISIBLE_OPTIONS = 10;
+var OptionListView = class {
+  static {
+    __name(this, "OptionListView");
+  }
+  select;
+  constructor(config) {
+    this.select = new WrappingSelect(config.items, Math.min(config.items.length, MAX_VISIBLE_OPTIONS), config.theme, {
+      numberStartOffset: 0,
+      totalItemsForNumbering: config.items.length
+    });
+  }
+  setProps(props) {
+    this.select.setSelectedIndex(props.selectedIndex);
+    this.select.setFocused(props.focused);
+    this.select.setConfirmedIndex(props.confirmed?.index, props.confirmed?.labelOverride);
+    this.select.setInputBuffer(props.inputBuffer);
+    this.select.setInputCursorOffset(props.inputCursorOffset);
+  }
+  handleInput(_data) {
+  }
+  invalidate() {
+    this.select.invalidate();
+  }
+  render(width) {
+    return this.select.render(width);
+  }
+  focusedItemRowRange(width) {
+    return this.select.focusedItemRowRange(width);
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/preview/preview-box-renderer.ts?ext=rpiv-ask-user-question
+var ANSI_SGR_RE = /\x1b\[[0-9;]*m/g;
+var ANSI_OSC8_RE = /\x1b\]8;[^\x07\x1b]*(?:\x07|\x1b\\)/g;
+var FENCE_MARKER_RE = /^`{3}/;
+var BORDER_VERTICAL_OVERHEAD = 2;
+var BORDER_HORIZONTAL_OVERHEAD = 2;
+var BORDER_INNER_PADDING_HORIZONTAL = 1;
+var BOX_MIN_CONTENT_WIDTH = 40;
+function stripFenceMarkers(lines) {
+  return lines.filter((line) => {
+    const clean = line.replace(ANSI_SGR_RE, "").replace(ANSI_OSC8_RE, "");
+    return !FENCE_MARKER_RE.test(clean);
+  });
+}
+__name(stripFenceMarkers, "stripFenceMarkers");
+function renderBorderedBox(lines, width, colorFn, hidden = 0) {
+  const dashSpan = Math.max(1, width - BORDER_HORIZONTAL_OVERHEAD);
+  const contentInner = Math.max(1, dashSpan - 2 * BORDER_INNER_PADDING_HORIZONTAL);
+  const pad = " ".repeat(BORDER_INNER_PADDING_HORIZONTAL);
+  const top = colorFn(`\u250C${"\u2500".repeat(dashSpan)}\u2510`);
+  const out = [top];
+  for (const line of lines) {
+    const padded = truncateToWidth(line, contentInner, "", true);
+    out.push(`${colorFn("\u2502")}${pad}${padded}${pad}${colorFn("\u2502")}`);
+  }
+  if (hidden > 0) {
+    const indicator = ` \u2702 \u2500\u2500 ${hidden} lines hidden \u2500\u2500 `;
+    const space = dashSpan - indicator.length;
+    const leftFill = "\u2500".repeat(Math.max(0, Math.floor(space / 2)));
+    const rightFill = "\u2500".repeat(Math.max(0, dashSpan - leftFill.length - indicator.length));
+    out.push(colorFn(`\u2514${leftFill}${indicator}${rightFill}\u2518`));
+  } else {
+    out.push(colorFn(`\u2514${"\u2500".repeat(dashSpan)}\u2518`));
+  }
+  return out;
+}
+__name(renderBorderedBox, "renderBorderedBox");
+function computeBoxDimensions(contentLines, maxInnerWidth) {
+  let widest = Math.min(BOX_MIN_CONTENT_WIDTH, maxInnerWidth);
+  for (const line of contentLines) {
+    const w = visibleWidth(line.replace(/\s+$/, ""));
+    if (w > widest) widest = w;
+  }
+  const innerWidth = Math.min(widest, maxInnerWidth);
+  const boxWidth = innerWidth + BORDER_HORIZONTAL_OVERHEAD + 2 * BORDER_INNER_PADDING_HORIZONTAL;
+  return { innerWidth, boxWidth };
+}
+__name(computeBoxDimensions, "computeBoxDimensions");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/preview/markdown-content-cache.ts?ext=rpiv-ask-user-question
+var MAX_PREVIEW_HEIGHT_SIDE_BY_SIDE = 20;
+var MAX_PREVIEW_HEIGHT_STACKED = 15;
+var NO_PREVIEW_TEXT = "No preview available";
+var NOTES_AFFORDANCE_OVERHEAD = 2;
+var MarkdownContentCache = class {
+  static {
+    __name(this, "MarkdownContentCache");
+  }
+  previewTexts;
+  markdownCache;
+  cachedWidth;
+  theme;
+  markdownTheme;
+  constructor(question, theme, markdownTheme) {
+    this.theme = theme;
+    this.markdownTheme = markdownTheme;
+    this.previewTexts = /* @__PURE__ */ new Map();
+    for (let i = 0; i < question.options.length; i++) {
+      const raw = question.options[i]?.preview;
+      if (raw && raw.length > 0) this.previewTexts.set(i, raw);
+    }
+    this.markdownCache = /* @__PURE__ */ new Map();
+  }
+  hasAnyPreview() {
+    return this.previewTexts.size > 0;
+  }
+  has(optionIndex) {
+    return this.previewTexts.has(optionIndex);
+  }
+  /**
+   * Compute the body lines for a given option at a given inner width. Width changes
+   * invalidate the per-Markdown render cache.
+   */
+  bodyFor(optionIndex, innerWidth) {
+    if (this.cachedWidth !== innerWidth) {
+      for (const md2 of this.markdownCache.values()) md2.invalidate();
+      this.cachedWidth = innerWidth;
+    }
+    const text = this.previewTexts.get(optionIndex);
+    if (!text) {
+      const placeholder = this.theme.fg("dim", t("preview.no_preview", NO_PREVIEW_TEXT));
+      const pad = Math.max(0, innerWidth - visibleWidth(placeholder));
+      return [placeholder + " ".repeat(pad)];
+    }
+    let md = this.markdownCache.get(optionIndex);
+    if (!md) {
+      md = new Markdown(text, 0, 0, this.markdownTheme);
+      this.markdownCache.set(optionIndex, md);
+    }
+    return stripFenceMarkers(md.render(innerWidth));
+  }
+  invalidate() {
+    for (const md of this.markdownCache.values()) md.invalidate();
+    this.cachedWidth = void 0;
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/preview/preview-block-renderer.ts?ext=rpiv-ask-user-question
+var NOTES_AFFORDANCE_TEXT = "Notes: press n to add notes";
+var NOTES_EDIT_AFFORDANCE_TEXT = "Note saved: press n to edit";
+function affordanceText(affordance) {
+  return affordance === "edit" ? t("preview.notes_edit_affordance", NOTES_EDIT_AFFORDANCE_TEXT) : t("preview.notes_affordance", NOTES_AFFORDANCE_TEXT);
+}
+__name(affordanceText, "affordanceText");
+function contentBudgetFor(mode) {
+  const cap = mode === "side-by-side" ? MAX_PREVIEW_HEIGHT_SIDE_BY_SIDE : MAX_PREVIEW_HEIGHT_STACKED;
+  return Math.max(1, cap - BORDER_VERTICAL_OVERHEAD - NOTES_AFFORDANCE_OVERHEAD);
+}
+__name(contentBudgetFor, "contentBudgetFor");
+function fitBlock(rawRows, mode, maxRows) {
+  const contentRows = Math.min(rawRows, contentBudgetFor(mode));
+  if (maxRows === void 0 || BORDER_VERTICAL_OVERHEAD + contentRows + NOTES_AFFORDANCE_OVERHEAD <= maxRows) {
+    return { contentRows, affordance: true };
+  }
+  const fitted = Math.min(contentRows, maxRows - BORDER_VERTICAL_OVERHEAD);
+  return fitted >= 1 ? { contentRows: fitted, affordance: false } : void 0;
+}
+__name(fitBlock, "fitBlock");
+function innerWidthFor(width) {
+  return Math.max(1, width - BORDER_HORIZONTAL_OVERHEAD - 2 * BORDER_INNER_PADDING_HORIZONTAL);
+}
+__name(innerWidthFor, "innerWidthFor");
+var PreviewBlockRenderer = class {
+  static {
+    __name(this, "PreviewBlockRenderer");
+  }
+  theme;
+  cache;
+  constructor(config) {
+    this.theme = config.theme;
+    this.cache = new MarkdownContentCache(config.question, config.theme, config.markdownTheme);
+  }
+  hasAnyPreview() {
+    return this.cache.hasAnyPreview();
+  }
+  has(optionIndex) {
+    return this.cache.has(optionIndex);
+  }
+  invalidate() {
+    this.cache.invalidate();
+  }
+  /**
+   * Height contribution of the preview block — always equal to `renderBlock(...).length`
+   * for the same arguments (the affordance overhead is not gated by the `NotesAffordance`).
+   * `maxRows` is the row allowance the dialog can give the block; see `fitBlock`.
+   */
+  blockHeight(width, optionIndex, mode, maxRows) {
+    const rawRows = this.cache.bodyFor(optionIndex, innerWidthFor(width)).length;
+    const fit = fitBlock(rawRows, mode, maxRows);
+    return fit ? BORDER_VERTICAL_OVERHEAD + fit.contentRows + (fit.affordance ? NOTES_AFFORDANCE_OVERHEAD : 0) : 0;
+  }
+  /**
+   * Render the preview block at `width`: bordered box, then (when it fits) a blank separator
+   * and the notes-affordance row. `affordance` picks the text (`none` blanks it), shown only when
+   * the option carries a preview; the row is emitted (empty when gated) whenever the block keeps
+   * it, so the row count only depends on the fit. Under a `maxRows` allowance the box always closes and its bottom border
+   * counts the lines left out; with no room for a box the block is empty.
+   */
+  renderBlock(width, optionIndex, mode, affordance, maxRows) {
+    const maxInnerWidth = innerWidthFor(width);
+    const raw = this.cache.bodyFor(optionIndex, maxInnerWidth);
+    const fit = fitBlock(raw.length, mode, maxRows);
+    if (!fit) return [];
+    const hidden = raw.length - fit.contentRows;
+    const contentLines = hidden > 0 ? raw.slice(0, fit.contentRows) : raw;
+    const { boxWidth } = computeBoxDimensions(contentLines, maxInnerWidth);
+    const colorFn = /* @__PURE__ */ __name((s) => this.theme.fg("accent", s), "colorFn");
+    const boxedLines = renderBorderedBox(contentLines, boxWidth, colorFn, hidden);
+    if (!fit.affordance) return boxedLines;
+    const text = affordance !== "none" && this.cache.has(optionIndex) ? affordanceText(affordance) : "";
+    return [...boxedLines, "", text ? this.theme.fg("muted", text) : ""];
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/preview/preview-layout-decider.ts?ext=rpiv-ask-user-question
+var PREVIEW_MIN_WIDTH = 100;
+var PREVIEW_COLUMN_GAP = 2;
+var PREVIEW_PADDING_LEFT = 1;
+var STACKED_GAP_ROWS = 1;
+var MIN_LEFT = 30;
+var MAX_LEFT_RATIO = 0.5;
+var MIN_PREVIEW_WIDTH = 45;
+var CONFIRMED_OVERHEAD = 2;
+function decideLayout(terminalWidth, paneWidth) {
+  return terminalWidth >= PREVIEW_MIN_WIDTH && paneWidth >= PREVIEW_MIN_WIDTH ? "side-by-side" : "stacked";
+}
+__name(decideLayout, "decideLayout");
+function adaptiveLeftWidth(items, totalForNumbering, paneWidth) {
+  const prefixW = String(Math.max(1, totalForNumbering)).length + 4;
+  const confirmedOverhead = CONFIRMED_OVERHEAD;
+  let maxLabel = 0;
+  for (const item of items) {
+    const w = visibleWidth(item.label);
+    if (w > maxLabel) maxLabel = w;
+  }
+  const desired = maxLabel + prefixW + confirmedOverhead;
+  const ratioCapped = Math.min(desired, Math.floor(paneWidth * MAX_LEFT_RATIO));
+  const available = paneWidth - PREVIEW_COLUMN_GAP - MIN_PREVIEW_WIDTH;
+  return Math.max(MIN_LEFT, Math.min(ratioCapped, Math.max(1, available)));
+}
+__name(adaptiveLeftWidth, "adaptiveLeftWidth");
+function crossTabMaxLeftWidth(tabs, itemsByTab, paneWidth) {
+  let max = MIN_LEFT;
+  for (let i = 0; i < tabs.length; i++) {
+    const items = itemsByTab[i] ?? [];
+    const totalForNumbering = items.length;
+    const tabWidth = adaptiveLeftWidth(items, totalForNumbering, paneWidth);
+    if (tabWidth > max) max = tabWidth;
+  }
+  return max;
+}
+__name(crossTabMaxLeftWidth, "crossTabMaxLeftWidth");
+function previewSourceWidth(question) {
+  let max = 0;
+  for (const option of question.options) {
+    const text = option.preview;
+    if (!text) continue;
+    for (const line of text.split("\n")) {
+      const w = visibleWidth(line);
+      if (w > max) max = w;
+    }
+  }
+  return max;
+}
+__name(previewSourceWidth, "previewSourceWidth");
+function crossTabPreviewBudget(questions, paneWidth) {
+  let max = MIN_PREVIEW_WIDTH;
+  for (const question of questions) {
+    const rawWidth = previewSourceWidth(question);
+    const capped = Math.min(rawWidth, paneWidth - PREVIEW_COLUMN_GAP - MIN_LEFT);
+    const budget = capped + BORDER_HORIZONTAL_OVERHEAD + 2 * BORDER_INNER_PADDING_HORIZONTAL + PREVIEW_PADDING_LEFT;
+    if (budget > max) max = budget;
+  }
+  return max;
+}
+__name(crossTabPreviewBudget, "crossTabPreviewBudget");
+function crossTabLeftWidthWithDonation(tabs, itemsByTab, questions, paneWidth) {
+  const labelDriven = crossTabMaxLeftWidth(tabs, itemsByTab, paneWidth);
+  const previewBudget = crossTabPreviewBudget(questions, paneWidth);
+  const slackDonation = paneWidth - PREVIEW_COLUMN_GAP - previewBudget;
+  const previewSafetyCeiling = paneWidth - PREVIEW_COLUMN_GAP - MIN_PREVIEW_WIDTH;
+  const ratioCeiling = Math.floor(paneWidth * MAX_LEFT_RATIO);
+  const ceiling = Math.min(previewSafetyCeiling, ratioCeiling);
+  return Math.min(Math.max(labelDriven, slackDonation), Math.max(1, ceiling));
+}
+__name(crossTabLeftWidthWithDonation, "crossTabLeftWidthWithDonation");
+function columnWidths(paneWidth, adaptiveLeft) {
+  const gap = PREVIEW_COLUMN_GAP;
+  const leftWidth = Math.min(adaptiveLeft, Math.max(1, paneWidth - gap - 1));
+  const rightWidth = Math.max(1, paneWidth - leftWidth - gap);
+  return { leftWidth, rightWidth, gap };
+}
+__name(columnWidths, "columnWidths");
+function bodyWidths(paneWidth, mode, adaptiveLeft) {
+  if (mode === "stacked") return { optionsWidth: paneWidth, previewWidth: paneWidth };
+  const { leftWidth, rightWidth } = columnWidths(paneWidth, adaptiveLeft);
+  return { optionsWidth: leftWidth, previewWidth: Math.max(1, rightWidth - PREVIEW_PADDING_LEFT) };
+}
+__name(bodyWidths, "bodyWidths");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/preview/preview-pane.ts?ext=rpiv-ask-user-question
+var MIN_BOX_ROWS = 3;
+var PreviewPane = class {
+  static {
+    __name(this, "PreviewPane");
+  }
+  question;
+  getTerminalWidth;
+  optionListView;
+  previewBlock;
+  theme;
+  props;
+  /**
+   * Rows the dialog can give this body this frame, set by `DialogView` before each render;
+   * undefined when unconstrained. A body taller than this fits itself instead of being cut
+   * by the dialog's scroll window: the options scroll within their column around the focused
+   * option, and the preview box shrinks but always closes (#210).
+   */
+  rowAllowance;
+  /**
+   * Cross-tab max left-width getter. Set exactly once by `buildQuestionnaire.injectGlobalLeftWidth`
+   * before any render. Initialized to a throwing sentinel so missing injection is a hard fail
+   * rather than a silent fallback to a magic constant — render is illegal until injected.
+   */
+  globalLeftWidth = /* @__PURE__ */ __name(() => {
+    throw new Error("PreviewPane.setGlobalLeftWidth must be called before render()");
+  }, "globalLeftWidth");
+  constructor(config) {
+    this.question = config.question;
+    this.getTerminalWidth = config.getTerminalWidth;
+    this.optionListView = config.optionListView;
+    this.previewBlock = config.previewBlock;
+    this.theme = config.theme;
+    this.props = { notesVisible: false, hasNote: false, selectedIndex: 0, focused: false, inputMode: false };
+  }
+  setGlobalLeftWidth(getter) {
+    this.globalLeftWidth = getter;
+  }
+  getAdaptiveLeft(paneWidth) {
+    return this.globalLeftWidth(paneWidth);
+  }
+  setProps(props) {
+    this.props = props;
+  }
+  /** Render-time geometry from `DialogView` (not canonical state, so not a prop). */
+  /** The notes affordance under the preview: shown while focused with the notes editor closed. */
+  notesAffordance() {
+    const { focused, notesVisible, hasNote } = this.props;
+    if (!focused || notesVisible) return "none";
+    return hasNote ? "edit" : "add";
+  }
+  setRowAllowance(rows) {
+    this.rowAllowance = rows;
+  }
+  handleInput(_data) {
+  }
+  invalidate() {
+    this.previewBlock.invalidate();
+    this.optionListView.invalidate();
+  }
+  render(width) {
+    if (this.question.multiSelect === true) return this.optionListView.render(width);
+    if (!this.previewBlock.hasAnyPreview()) return this.optionListView.render(width);
+    if (this.props.inputMode) return this.optionListView.render(width);
+    return this.layout(width).lines;
+  }
+  /**
+   * Options + preview for the current layout mode, fitted to `rowAllowance` when set. The
+   * returned focus range is in the same row coordinates as `lines`, so `render`,
+   * `focusedItemRowRange` and `naturalHeight` agree by construction.
+   */
+  layout(width) {
+    const mode = decideLayout(this.getTerminalWidth(), width);
+    return mode === "side-by-side" ? this.layoutSideBySide(width, mode) : this.layoutStacked(width, mode);
+  }
+  /**
+   * Stacked: options, a blank gap, then the preview block. When that exceeds the allowance,
+   * keep the focused option (plus a row either side for the overflow arrows) and give the
+   * preview the rest, so the preview of the option being considered stays in view instead
+   * of falling below the dialog's scroll window.
+   */
+  layoutStacked(width, mode) {
+    const { selectedIndex } = this.props;
+    const affordance = this.notesAffordance();
+    const options = this.optionListView.render(width);
+    const focus = this.optionListView.focusedItemRowRange(width);
+    const gap = Array(STACKED_GAP_ROWS).fill("");
+    const allowance = this.rowAllowance;
+    const fullBlock = this.previewBlock.blockHeight(width, selectedIndex, mode);
+    if (allowance === void 0 || options.length + STACKED_GAP_ROWS + fullBlock <= allowance) {
+      return {
+        lines: [...options, ...gap, ...this.previewBlock.renderBlock(width, selectedIndex, mode, affordance)],
+        focus
+      };
+    }
+    const focusRows = focus ? focus[1] - focus[0] : 1;
+    const previewRowsWith = /* @__PURE__ */ __name((optionsFloor) => Math.min(fullBlock, allowance - STACKED_GAP_ROWS - Math.min(options.length, optionsFloor)), "previewRowsWith");
+    const roomy = previewRowsWith(focusRows + 2);
+    const previewRows = roomy >= MIN_BOX_ROWS ? roomy : previewRowsWith(focusRows);
+    const block = this.previewBlock.renderBlock(width, selectedIndex, mode, affordance, previewRows);
+    const optionRows = allowance - (block.length > 0 ? STACKED_GAP_ROWS + block.length : 0);
+    const windowed = windowLines(options, Math.max(1, optionRows), focus, this.theme);
+    return {
+      lines: block.length > 0 ? [...windowed.lines, ...gap, ...block] : windowed.lines,
+      focus: windowed.focus
+    };
+  }
+  /**
+   * Side-by-side: options column left, preview block right. Under an allowance the options
+   * column scrolls around the focused option and the preview block shrinks, so neither
+   * column exceeds it and the dialog never slices through the preview box.
+   */
+  layoutSideBySide(width, mode) {
+    const adaptiveLeft = this.getAdaptiveLeft(width);
+    const { leftWidth, rightWidth, gap } = columnWidths(width, adaptiveLeft);
+    const allowance = this.rowAllowance;
+    const left = allowance === void 0 ? {
+      lines: this.optionListView.render(leftWidth),
+      focus: this.optionListView.focusedItemRowRange(leftWidth)
+    } : windowLines(
+      this.optionListView.render(leftWidth),
+      allowance,
+      this.optionListView.focusedItemRowRange(leftWidth),
+      this.theme
+    );
+    const rightLines = this.renderPaddedPreviewLines(rightWidth, mode, allowance);
+    const rows = Math.max(left.lines.length, rightLines.length);
+    const gapStr = " ".repeat(gap);
+    const out = [];
+    for (let i = 0; i < rows; i++) {
+      const leftRaw = left.lines[i] ?? "";
+      const rightRaw = rightLines[i] ?? "";
+      const leftClamped = truncateToWidth(leftRaw, leftWidth, "");
+      const leftPad = " ".repeat(Math.max(0, leftWidth - visibleWidth(leftClamped)));
+      const joined = `${leftClamped}${leftPad}${gapStr}${rightRaw}`;
+      out.push(truncateToWidth(joined, width, ""));
+    }
+    return { lines: out, focus: left.focus };
+  }
+  focusedItemRowRange(width) {
+    if (this.question.multiSelect === true) return this.optionListView.focusedItemRowRange(width);
+    if (!this.previewBlock.hasAnyPreview()) return this.optionListView.focusedItemRowRange(width);
+    if (this.props.inputMode) return this.optionListView.focusedItemRowRange(width);
+    return this.layout(width).focus ?? [0, 1];
+  }
+  naturalHeight(width) {
+    if (this.question.multiSelect === true) return this.optionListView.render(width).length;
+    if (!this.previewBlock.hasAnyPreview()) return this.optionListView.render(width).length;
+    if (this.props.inputMode) return this.optionListView.render(width).length;
+    if (this.rowAllowance !== void 0) return this.layout(width).lines.length;
+    const mode = decideLayout(this.getTerminalWidth(), width);
+    const adaptiveLeft = this.getAdaptiveLeft(width);
+    const { optionsWidth, previewWidth } = bodyWidths(width, mode, adaptiveLeft);
+    const optionsHeight = this.optionListView.render(optionsWidth).length;
+    const previewBlockHeight = this.previewBlock.blockHeight(previewWidth, this.props.selectedIndex, mode);
+    if (mode === "side-by-side") return Math.max(optionsHeight, previewBlockHeight);
+    return optionsHeight + STACKED_GAP_ROWS + previewBlockHeight;
+  }
+  maxNaturalHeight(width) {
+    if (this.question.multiSelect === true) return this.optionListView.render(width).length;
+    if (!this.previewBlock.hasAnyPreview()) return this.optionListView.render(width).length;
+    if (this.props.inputMode) return this.optionListView.render(width).length;
+    const mode = decideLayout(this.getTerminalWidth(), width);
+    const adaptiveLeft = this.getAdaptiveLeft(width);
+    const { optionsWidth, previewWidth } = bodyWidths(width, mode, adaptiveLeft);
+    const optionsHeight = this.optionListView.render(optionsWidth).length;
+    let maxPreviewBlock = 0;
+    for (let i = 0; i < this.question.options.length; i++) {
+      const h = this.previewBlock.blockHeight(previewWidth, i, mode);
+      if (h > maxPreviewBlock) maxPreviewBlock = h;
+    }
+    const max = mode === "side-by-side" ? Math.max(optionsHeight, maxPreviewBlock) : optionsHeight + STACKED_GAP_ROWS + maxPreviewBlock;
+    return this.rowAllowance === void 0 ? max : Math.min(max, this.rowAllowance);
+  }
+  renderPaddedPreviewLines(colWidth, mode, maxRows) {
+    const inner = Math.max(1, colWidth - PREVIEW_PADDING_LEFT);
+    const contentLines = this.previewBlock.renderBlock(
+      inner,
+      this.props.selectedIndex,
+      mode,
+      this.notesAffordance(),
+      maxRows
+    );
+    const boxWidth = Math.max(1, visibleWidth(contentLines[0] ?? ""));
+    const boxAlignedPad = Math.max(PREVIEW_PADDING_LEFT, colWidth - boxWidth);
+    return contentLines.map((line) => {
+      if (line === "") return "";
+      const pad = Math.max(PREVIEW_PADDING_LEFT, Math.min(boxAlignedPad, colWidth - visibleWidth(line)));
+      return `${" ".repeat(pad)}${truncateToWidth(line, colWidth - pad, "")}`;
+    });
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/submit-picker.ts?ext=rpiv-ask-user-question
+var ACTIVE_POINTER2 = "\u276F ";
+var INACTIVE_POINTER2 = "  ";
+var NUMBER_SEPARATOR2 = ". ";
+var SUBMIT_LABEL = "Submit answers";
+var CANCEL_LABEL = "Cancel";
+var SubmitPicker = class {
+  constructor(theme) {
+    this.theme = theme;
+    this.props = { rows: [{ active: false }, { active: false }] };
+  }
+  theme;
+  static {
+    __name(this, "SubmitPicker");
+  }
+  props;
+  setProps(props) {
+    this.props = props;
+  }
+  handleInput(_data) {
+  }
+  invalidate() {
+  }
+  naturalHeight(_width) {
+    return 2;
+  }
+  render(width) {
+    const lines = [];
+    for (let i = 0; i < 2; i++) {
+      const text = i === 0 ? t("submit.label", SUBMIT_LABEL) : t("submit.cancel", CANCEL_LABEL);
+      const active = this.props.rows[i]?.active ?? false;
+      const pointer = active ? ACTIVE_POINTER2 : INACTIVE_POINTER2;
+      const number = `${i + 1}${NUMBER_SEPARATOR2}`;
+      const label = active ? this.theme.fg("accent", this.theme.bold(text)) : this.theme.fg("text", text);
+      lines.push(truncateToWidth(`${pointer}${number}${label}`, width, ""));
+    }
+    return lines;
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/components/tab-bar.ts?ext=rpiv-ask-user-question
+var TabBar = class {
+  constructor(theme) {
+    this.theme = theme;
+    this.props = { tabs: [], submit: { active: false, allAnswered: false } };
+  }
+  theme;
+  static {
+    __name(this, "TabBar");
+  }
+  props;
+  setProps(props) {
+    this.props = props;
+  }
+  handleInput(_data) {
+  }
+  invalidate() {
+  }
+  render(width) {
+    const pieces = [" \u2190 "];
+    for (const tab of this.props.tabs) {
+      const box = tab.answered ? "\u25A0" : "\u25A1";
+      const rawSeg = ` ${box} ${tab.label} `;
+      const styled = tab.active ? this.theme.bg("selectedBg", this.theme.fg("text", rawSeg)) : this.theme.fg(tab.answered ? "success" : "muted", rawSeg);
+      pieces.push(styled);
+      pieces.push(" ");
+    }
+    const submitText = " \u2713 Submit ";
+    const submitStyled = this.props.submit.active ? this.theme.bg("selectedBg", this.theme.fg("text", submitText)) : this.theme.fg(this.props.submit.allAnswered ? "success" : "dim", submitText);
+    pieces.push(submitStyled);
+    pieces.push(" \u2192");
+    const tabLine = truncateToWidth(pieces.join(""), width, "");
+    return [tabLine, ""];
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/state/selectors/focus.ts?ext=rpiv-ask-user-question
+function selectActiveView(state, totalQuestions) {
+  if (state.notesVisible) return "notes";
+  if (state.currentTab === totalQuestions) return "submit";
+  return "options";
+}
+__name(selectActiveView, "selectActiveView");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/view/props-adapter.ts?ext=rpiv-ask-user-question
+function getInputCursorOffset(input) {
+  const lines = input.getLines();
+  const cursor = input.getCursor();
+  let offset = cursor.col;
+  for (let i = 0; i < cursor.line; i++) offset += (lines[i]?.length ?? 0) + 1;
+  return offset;
+}
+__name(getInputCursorOffset, "getInputCursorOffset");
+var QuestionnairePropsAdapter = class {
+  static {
+    __name(this, "QuestionnairePropsAdapter");
+  }
+  tui;
+  questions;
+  itemsByTab;
+  tabsByIndex;
+  inlineInput;
+  globalBindings;
+  perTabBindings;
+  extraInvalidatables;
+  constructor(config) {
+    this.tui = config.tui;
+    this.questions = config.questions;
+    this.itemsByTab = config.itemsByTab;
+    this.tabsByIndex = config.tabsByIndex;
+    this.inlineInput = config.inlineInput;
+    this.globalBindings = config.globalBindings;
+    this.perTabBindings = config.perTabBindings;
+    this.extraInvalidatables = config.extraInvalidatables ?? [];
+  }
+  apply(state) {
+    const totalQuestions = this.questions.length;
+    const activeView = selectActiveView(state, totalQuestions);
+    const paneIndex = selectActivePreviewPaneIndex(state.currentTab, totalQuestions);
+    const activePreviewPane = this.tabsByIndex[paneIndex]?.preview ?? this.tabsByIndex[0].preview;
+    const ctx = {
+      questions: this.questions,
+      itemsByTab: this.itemsByTab,
+      totalQuestions,
+      activeView,
+      inputBuffer: this.inlineInput.getText(),
+      inputCursorOffset: getInputCursorOffset(this.inlineInput),
+      activePreviewPane
+    };
+    for (const binding of this.globalBindings) {
+      binding.apply(state, ctx);
+    }
+    for (let i = 0; i < this.tabsByIndex.length; i++) {
+      const tab = this.tabsByIndex[i];
+      const tabCtx = { ...ctx, tab, i };
+      for (const binding of this.perTabBindings) {
+        binding.apply(state, tabCtx);
+      }
+    }
+    this.tui.requestRender();
+  }
+  /**
+   * Invalidates every owned renderable. Called by the session in place of
+   * the old `dialog.invalidate()` forwarding chain — DialogView no longer
+   * reaches into siblings (tabBar, notesInput, activePreviewPane).
+   * Iterates the same registries used by `apply()` plus
+   * `extraInvalidatables` for components outside the binding system.
+   */
+  invalidate() {
+    for (const b of this.globalBindings) b.invalidate();
+    for (const tab of this.tabsByIndex) {
+      tab.optionList.invalidate();
+      tab.preview.invalidate();
+      tab.multiSelect?.invalidate();
+    }
+    for (const x of this.extraInvalidatables) x.invalidate();
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/state/selectors/projections.ts?ext=rpiv-ask-user-question
+function emptyMultiSelectProps(ctx) {
+  return {
+    rows: [],
+    other: {
+      active: false,
+      checked: false,
+      inputMode: false,
+      inputBuffer: ctx.inputBuffer,
+      inputCursorOffset: ctx.inputCursorOffset
+    },
+    nextActive: false,
+    nextLabel: displayLabel("next")
+  };
+}
+__name(emptyMultiSelectProps, "emptyMultiSelectProps");
+function nextLabelFor(ctx) {
+  const isLastQuestion = ctx.i === ctx.questions.length - 1;
+  return isLastQuestion ? MULTI_SUBMIT_LABEL : displayLabel("next");
+}
+__name(nextLabelFor, "nextLabelFor");
+var selectMultiSelectProps = /* @__PURE__ */ __name((state, ctx) => {
+  const question = ctx.questions[ctx.i];
+  if (!question) {
+    return emptyMultiSelectProps(ctx);
+  }
+  const focused = ctx.activeView === "options";
+  const rows = [];
+  for (let i = 0; i < question.options.length; i++) {
+    rows.push({
+      checked: state.multiSelectChecked.has(i),
+      active: focused && i === state.optionIndex
+    });
+  }
+  const otherActive = focused && state.optionIndex === question.options.length;
+  const nextActive = focused && state.optionIndex === question.options.length + 1;
+  return {
+    rows,
+    other: {
+      active: otherActive,
+      checked: ctx.inputBuffer.trim().length > 0,
+      inputMode: state.inputMode,
+      inputBuffer: ctx.inputBuffer,
+      inputCursorOffset: ctx.inputCursorOffset
+    },
+    nextActive,
+    nextLabel: nextLabelFor(ctx)
+  };
+}, "selectMultiSelectProps");
+var selectOptionListProps = /* @__PURE__ */ __name((state, ctx) => {
+  const items = ctx.itemsByTab[ctx.i] ?? [];
+  const focused = ctx.activeView === "options";
+  const confirmed = selectConfirmedIndicator(ctx.questions, state.currentTab, state.answers, items);
+  return {
+    selectedIndex: state.optionIndex,
+    focused,
+    inputBuffer: ctx.inputBuffer,
+    inputCursorOffset: ctx.inputCursorOffset,
+    ...confirmed ? { confirmed } : {}
+  };
+}, "selectOptionListProps");
+var selectSubmitPickerProps = /* @__PURE__ */ __name((state, ctx) => {
+  const focused = ctx.activeView === "submit";
+  return {
+    rows: [
+      { active: focused && state.submitChoiceIndex === 0 },
+      { active: focused && state.submitChoiceIndex === 1 }
+    ]
+  };
+}, "selectSubmitPickerProps");
+var selectPreviewPaneProps = /* @__PURE__ */ __name((state, ctx) => ({
+  notesVisible: state.notesVisible,
+  hasNote: selectSavedNote(state.notesByTab, state.answers, ctx.i) !== void 0,
+  selectedIndex: state.optionIndex,
+  focused: ctx.activeView === "options",
+  inputMode: state.inputMode
+}), "selectPreviewPaneProps");
+var selectTabBarProps = /* @__PURE__ */ __name((state, ctx) => {
+  const tabs = ctx.questions.map((q, i) => ({
+    label: q.header && q.header.length > 0 ? q.header : `Q${i + 1}`,
+    answered: state.answers.has(i),
+    active: i === state.currentTab
+  }));
+  return {
+    tabs,
+    submit: {
+      active: state.currentTab === ctx.questions.length,
+      allAnswered: state.answers.size === ctx.questions.length && ctx.questions.length > 0
+    }
+  };
+}, "selectTabBarProps");
+var selectDialogProps = /* @__PURE__ */ __name((state, ctx) => ({
+  state,
+  activePreviewPane: ctx.activePreviewPane
+}), "selectDialogProps");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/state/build-questionnaire.ts?ext=rpiv-ask-user-question
+function previewBodyHeights(pane) {
+  return (width) => {
+    const current = pane.naturalHeight(width);
+    return { current, max: Math.max(current, pane.maxNaturalHeight(width)) };
+  };
+}
+__name(previewBodyHeights, "previewBodyHeights");
+function editorTheme(theme) {
+  return {
+    borderColor: /* @__PURE__ */ __name((text) => theme.fg("borderMuted", text), "borderColor"),
+    selectList: {
+      selectedPrefix: /* @__PURE__ */ __name((text) => theme.bg("selectedBg", theme.fg("accent", text)), "selectedPrefix"),
+      selectedText: /* @__PURE__ */ __name((text) => theme.bg("selectedBg", theme.bold(text)), "selectedText"),
+      description: /* @__PURE__ */ __name((text) => theme.fg("muted", text), "description"),
+      scrollInfo: /* @__PURE__ */ __name((text) => theme.fg("dim", text), "scrollInfo"),
+      noMatch: /* @__PURE__ */ __name((text) => theme.fg("warning", text), "noMatch")
+    }
+  };
+}
+__name(editorTheme, "editorTheme");
+function multiSelectBodyHeights(view) {
+  return (width) => {
+    const h = view.naturalHeight(width);
+    return { current: h, max: h };
+  };
+}
+__name(multiSelectBodyHeights, "multiSelectBodyHeights");
+var isActiveTab = /* @__PURE__ */ __name((s, ctx) => ctx.i === selectActivePreviewPaneIndex(s.currentTab, ctx.totalQuestions), "isActiveTab");
+function buildQuestionnaire(config) {
+  return new QuestionnaireBuilder(config).build();
+}
+__name(buildQuestionnaire, "buildQuestionnaire");
+var QuestionnaireBuilder = class {
+  static {
+    __name(this, "QuestionnaireBuilder");
+  }
+  tui;
+  theme;
+  questions;
+  itemsByTab;
+  isMulti;
+  initialState;
+  getCurrentTab;
+  collapseKey;
+  rowBudget;
+  selectTheme;
+  markdownTheme = getMarkdownTheme();
+  notesInput;
+  inlineInput;
+  getTerminalWidth = /* @__PURE__ */ __name(() => this.tui.terminal.columns, "getTerminalWidth");
+  getTerminalRows = /* @__PURE__ */ __name(() => this.rowBudget(this.tui.terminal.rows), "getTerminalRows");
+  constructor(config) {
+    this.tui = config.tui;
+    this.theme = config.theme;
+    this.questions = config.questions;
+    this.itemsByTab = config.itemsByTab;
+    this.isMulti = config.isMulti;
+    this.initialState = config.initialState;
+    this.getCurrentTab = config.getCurrentTab;
+    this.collapseKey = config.collapseKey;
+    this.rowBudget = config.rowBudget;
+    this.selectTheme = this.makeSelectTheme();
+    const textEditorTheme = editorTheme(this.theme);
+    this.notesInput = new Editor(this.tui, textEditorTheme);
+    this.inlineInput = new Editor(this.tui, textEditorTheme);
+    this.notesInput.disableSubmit = true;
+    this.inlineInput.disableSubmit = true;
+  }
+  build() {
+    const tabs = this.buildTabComponents();
+    this.injectGlobalLeftWidth(tabs);
+    const submitPicker = this.buildSubmitPicker();
+    const tabBar = this.buildTabBar();
+    const heights = this.buildHeightComputers(tabs);
+    const dialog = this.buildDialog(tabs, submitPicker, tabBar, heights);
+    const globalBindings = this.buildGlobalBindings(dialog, submitPicker, tabBar);
+    const perTabBindings = this.buildPerTabBindings();
+    const adapter = this.buildAdapter(tabs, globalBindings, perTabBindings);
+    return this.handle(adapter, dialog);
+  }
+  makeSelectTheme() {
+    const t2 = this.theme;
+    return {
+      selectedText: /* @__PURE__ */ __name((s) => t2.fg("accent", t2.bold(s)), "selectedText"),
+      description: /* @__PURE__ */ __name((s) => t2.fg("muted", s), "description"),
+      scrollInfo: /* @__PURE__ */ __name((s) => t2.fg("dim", s), "scrollInfo")
+    };
+  }
+  buildTabComponents() {
+    return this.questions.map((q, i) => this.buildTabFor(q, i));
+  }
+  buildTabFor(question, index) {
+    const optionList = new OptionListView({
+      items: this.itemsByTab[index] ?? [],
+      theme: this.selectTheme
+    });
+    const previewBlock = new PreviewBlockRenderer({
+      question,
+      theme: this.theme,
+      markdownTheme: this.markdownTheme
+    });
+    const preview = new PreviewPane({
+      question,
+      theme: this.theme,
+      getTerminalWidth: this.getTerminalWidth,
+      optionListView: optionList,
+      previewBlock
+    });
+    const multiSelect = question.multiSelect ? new MultiSelectView(this.theme, question) : void 0;
+    const bodyHeights = this.buildBodyHeights(question, preview, multiSelect);
+    return { optionList, preview, multiSelect, bodyHeights };
+  }
+  buildBodyHeights(question, preview, multiSelect) {
+    return question.multiSelect ? multiSelectBodyHeights(multiSelect) : previewBodyHeights(preview);
+  }
+  /**
+   * Compute cross-tab max adaptive left width and inject into each PreviewPane.
+   * Mirrors buildHeightComputers pattern — iterates all tabs, takes max.
+   * Called after buildTabComponents, before buildDialog (so setGlobalLeftWidth
+   * is set before any rendering occurs).
+   */
+  injectGlobalLeftWidth(tabs) {
+    const questions = this.questions;
+    const itemsByTab = this.itemsByTab;
+    const tabsDescriptor = questions.map((q) => ({ multiSelect: q.multiSelect }));
+    const globalLeftWidth = /* @__PURE__ */ __name((paneWidth) => crossTabLeftWidthWithDonation(tabsDescriptor, itemsByTab, questions, paneWidth), "globalLeftWidth");
+    for (const tab of tabs) {
+      tab.preview.setGlobalLeftWidth(globalLeftWidth);
+    }
+  }
+  buildSubmitPicker() {
+    return this.isMulti ? new SubmitPicker(this.theme) : void 0;
+  }
+  buildTabBar() {
+    return this.isMulti ? new TabBar(this.theme) : void 0;
+  }
+  buildHeightComputers(tabs) {
+    const global = /* @__PURE__ */ __name((width) => {
+      let max = 0;
+      for (const tab of tabs) {
+        const h = tab.bodyHeights(width).max;
+        if (h > max) max = h;
+      }
+      return Math.max(1, max);
+    }, "global");
+    const current = /* @__PURE__ */ __name((width) => {
+      const idx = Math.min(this.getCurrentTab(), tabs.length - 1);
+      return Math.max(0, tabs[idx]?.bodyHeights(width).current ?? 0);
+    }, "current");
+    return { global, current };
+  }
+  pickInitialActivePreview(tabs) {
+    const idx = selectActivePreviewPaneIndex(this.initialState.currentTab, this.questions.length);
+    return tabs[idx]?.preview ?? tabs[0].preview;
+  }
+  buildDialog(tabs, submitPicker, tabBar, heights) {
+    return new DialogView(
+      {
+        theme: this.theme,
+        questions: this.questions,
+        tabBar,
+        notesInput: this.notesInput,
+        isMulti: this.isMulti,
+        tabsByIndex: tabs,
+        submitPicker,
+        getBodyHeight: heights.global,
+        getCurrentBodyHeight: heights.current,
+        getTerminalRows: this.getTerminalRows,
+        collapseKey: this.collapseKey
+      },
+      { state: this.initialState, activePreviewPane: this.pickInitialActivePreview(tabs) }
+    );
+  }
+  buildGlobalBindings(dialog, submitPicker, tabBar) {
+    return [
+      globalBinding({ component: dialog, select: selectDialogProps }),
+      ...submitPicker ? [globalBinding({ component: submitPicker, select: selectSubmitPickerProps })] : [],
+      ...tabBar ? [globalBinding({ component: tabBar, select: selectTabBarProps })] : []
+    ];
+  }
+  buildPerTabBindings() {
+    return [
+      perTabBinding({
+        resolve: /* @__PURE__ */ __name((tab) => tab.optionList, "resolve"),
+        predicate: isActiveTab,
+        select: selectOptionListProps
+      }),
+      perTabBinding({
+        resolve: /* @__PURE__ */ __name((tab) => tab.preview, "resolve"),
+        predicate: isActiveTab,
+        select: selectPreviewPaneProps
+      }),
+      perTabBinding({
+        resolve: /* @__PURE__ */ __name((tab) => tab.multiSelect, "resolve"),
+        select: selectMultiSelectProps
+      })
+    ];
+  }
+  buildAdapter(tabs, globalBindings, perTabBindings) {
+    return new QuestionnairePropsAdapter({
+      tui: this.tui,
+      questions: this.questions,
+      itemsByTab: this.itemsByTab,
+      tabsByIndex: tabs,
+      inlineInput: this.inlineInput,
+      globalBindings,
+      perTabBindings,
+      extraInvalidatables: [this.notesInput]
+    });
+  }
+  handle(adapter, dialog) {
+    return {
+      adapter,
+      notesInput: this.notesInput,
+      inlineInput: this.inlineInput,
+      render: /* @__PURE__ */ __name((w) => dialog.render(w), "render"),
+      invalidate: /* @__PURE__ */ __name(() => adapter.invalidate(), "invalidate")
+    };
+  }
+};
+
+// node_modules/@juicesharp/rpiv-ask-user-question/state/key-router.ts?ext=rpiv-ask-user-question
+var KEYBIND_UP = "tui.select.up";
+var KEYBIND_DOWN = "tui.select.down";
+var KEYBIND_CONFIRM = "tui.select.confirm";
+var KEYBIND_SUBMIT = "tui.input.submit";
+var KEYBIND_CANCEL = "tui.select.cancel";
+var KEYBIND_NEW_LINE = "tui.input.newLine";
+var KEYBIND_EDITOR_UP = "tui.editor.cursorUp";
+var KEYBIND_EDITOR_DOWN = "tui.editor.cursorDown";
+var KEYBIND_CLEAR = "tui.editor.deleteToLineStart";
+var KEYBIND_EXTERNAL_EDITOR = "app.editor.external";
+var NOTES_ACTIVATE_KEY = "n";
+var SPACE_KEY = " ";
+function isConfirm(kb, data) {
+  return kb.matches(data, KEYBIND_CONFIRM) || kb.matches(data, KEYBIND_SUBMIT);
+}
+__name(isConfirm, "isConfirm");
+function wrapTab(index, total) {
+  if (total <= 0) return 0;
+  return (index % total + total) % total;
+}
+__name(wrapTab, "wrapTab");
+function totalTabs(runtime) {
+  return runtime.isMulti ? runtime.questions.length + 1 : 1;
+}
+__name(totalTabs, "totalTabs");
+function computeAutoAdvanceTab(state, runtime) {
+  if (!runtime.isMulti) return void 0;
+  if (state.currentTab < runtime.questions.length - 1) return state.currentTab + 1;
+  return runtime.questions.length;
+}
+__name(computeAutoAdvanceTab, "computeAutoAdvanceTab");
+function buildSingleSelectAnswer(state, runtime) {
+  const q = runtime.questions[state.currentTab];
+  if (!q) return null;
+  const item = runtime.currentItem;
+  if (state.inputMode) {
+    const label = runtime.inputBuffer;
+    return {
+      questionIndex: state.currentTab,
+      question: q.question,
+      kind: "custom",
+      answer: label.length > 0 ? label : null
+    };
+  }
+  if (!item) return null;
+  if (item.kind === "other") {
+    return null;
+  }
+  if (item.kind === "next") {
+    return null;
+  }
+  return {
+    questionIndex: state.currentTab,
+    question: q.question,
+    kind: "option",
+    answer: item.label
+  };
+}
+__name(buildSingleSelectAnswer, "buildSingleSelectAnswer");
+function buildMultiSelected(state, runtime) {
+  const q = runtime.questions[state.currentTab];
+  if (!q) return [];
+  const out = [];
+  for (let i = 0; i < q.options.length; i++) {
+    if (state.multiSelectChecked.has(i)) {
+      const label = q.options[i]?.label;
+      if (typeof label === "string") out.push(label);
+    }
+  }
+  return out;
+}
+__name(buildMultiSelected, "buildMultiSelected");
+function buildMultiConfirmAction(state, runtime) {
+  return {
+    kind: "multi_confirm",
+    selected: buildMultiSelected(state, runtime),
+    answer: runtime.inputBuffer.trim().length > 0 ? runtime.inputBuffer : null,
+    autoAdvanceTab: computeAutoAdvanceTab(state, runtime)
+  };
+}
+__name(buildMultiConfirmAction, "buildMultiConfirmAction");
+function tabSwitchAction(data, state, runtime) {
+  if (!runtime.isMulti) return null;
+  const total = totalTabs(runtime);
+  if (matchesKey(data, Key.tab) || matchesKey(data, Key.right)) {
+    return { kind: "tab_switch", nextTab: wrapTab(state.currentTab + 1, total) };
+  }
+  if (matchesKey(data, Key.shift("tab")) || matchesKey(data, Key.left)) {
+    return { kind: "tab_switch", nextTab: wrapTab(state.currentTab - 1, total) };
+  }
+  return null;
+}
+__name(tabSwitchAction, "tabSwitchAction");
+function nextNavOnDown(state, runtime) {
+  return {
+    kind: "nav",
+    nextIndex: wrapTab(state.optionIndex + 1, Math.max(1, runtime.items.length)),
+    inputValue: runtime.inputBuffer
+  };
+}
+__name(nextNavOnDown, "nextNavOnDown");
+function prevNavOnUp(state, runtime) {
+  return {
+    kind: "nav",
+    nextIndex: wrapTab(state.optionIndex - 1, Math.max(1, runtime.items.length)),
+    inputValue: runtime.inputBuffer
+  };
+}
+__name(prevNavOnUp, "prevNavOnUp");
+function routeCollapsed(kb, data) {
+  if (kb.matches(data, KEYBIND_CANCEL)) return { kind: "cancel" };
+  return { kind: "ignore" };
+}
+__name(routeCollapsed, "routeCollapsed");
+function routeNotesMode(kb, data) {
+  if (kb.matches(data, KEYBIND_CANCEL)) return { kind: "notes_exit" };
+  if (kb.matches(data, KEYBIND_NEW_LINE)) return { kind: "notes_forward", data };
+  if (isConfirm(kb, data)) return { kind: "notes_exit" };
+  return { kind: "notes_forward", data };
+}
+__name(routeNotesMode, "routeNotesMode");
+function routeInputMode(kb, data, state, runtime) {
+  if (kb.matches(data, KEYBIND_NEW_LINE)) return { kind: "ignore" };
+  if (isConfirm(kb, data)) {
+    const q = runtime.questions[state.currentTab];
+    if (q?.multiSelect) return buildMultiConfirmAction(state, runtime);
+    const answer = buildSingleSelectAnswer(state, runtime);
+    if (!answer) return { kind: "ignore" };
+    return { kind: "confirm", answer, autoAdvanceTab: computeAutoAdvanceTab(state, runtime) };
+  }
+  if (kb.matches(data, KEYBIND_CLEAR)) return { kind: "input_clear" };
+  if (kb.matches(data, KEYBIND_EXTERNAL_EDITOR)) return { kind: "input_edit", value: runtime.inputBuffer };
+  if (kb.matches(data, KEYBIND_CANCEL)) return { kind: "cancel" };
+  if (kb.matches(data, KEYBIND_EDITOR_UP) && runtime.canMoveInputUp) return { kind: "ignore" };
+  if (kb.matches(data, KEYBIND_EDITOR_DOWN) && runtime.canMoveInputDown) return { kind: "ignore" };
+  if (kb.matches(data, KEYBIND_UP)) return prevNavOnUp(state, runtime);
+  if (kb.matches(data, KEYBIND_DOWN)) return nextNavOnDown(state, runtime);
+  return { kind: "ignore" };
+}
+__name(routeInputMode, "routeInputMode");
+function routeSubmitTab(kb, data, state, runtime) {
+  if (kb.matches(data, KEYBIND_CANCEL)) return { kind: "cancel" };
+  const tab = tabSwitchAction(data, state, runtime);
+  if (tab) return tab;
+  if (kb.matches(data, KEYBIND_UP) || kb.matches(data, KEYBIND_DOWN)) {
+    const delta = kb.matches(data, KEYBIND_DOWN) ? 1 : -1;
+    const next = wrapTab(state.submitChoiceIndex + delta, 2);
+    return { kind: "submit_nav", nextIndex: next === 1 ? 1 : 0 };
+  }
+  if (isConfirm(kb, data)) {
+    return state.submitChoiceIndex === 1 ? { kind: "cancel" } : { kind: "submit" };
+  }
+  if (data === NOTES_ACTIVATE_KEY) {
+    return { kind: "notes_enter" };
+  }
+  return { kind: "ignore" };
+}
+__name(routeSubmitTab, "routeSubmitTab");
+function routeMultiSelectTab(kb, data, state, runtime) {
+  const focusedKind = runtime.currentItem?.kind;
+  const focusedMeta = focusedKind ? ROW_INTENT_META[focusedKind] : void 0;
+  if (data === SPACE_KEY) {
+    if (focusedMeta?.blocksMultiToggle) return { kind: "ignore" };
+    if (focusedMeta?.activatesInputMode) return { kind: "ignore" };
+    return { kind: "toggle", index: state.optionIndex };
+  }
+  if (isConfirm(kb, data)) {
+    if (focusedMeta?.activatesInputMode) return { kind: "ignore" };
+    if (!focusedMeta?.autoSubmitsInMulti) return { kind: "toggle", index: state.optionIndex };
+    return buildMultiConfirmAction(state, runtime);
+  }
+  if (kb.matches(data, KEYBIND_CANCEL)) return { kind: "cancel" };
+  return { kind: "ignore" };
+}
+__name(routeMultiSelectTab, "routeMultiSelectTab");
+function routeSingleSelectTab(kb, data, state, runtime) {
+  if (isConfirm(kb, data)) {
+    const answer = buildSingleSelectAnswer(state, runtime);
+    if (!answer) return { kind: "ignore" };
+    return { kind: "confirm", answer, autoAdvanceTab: computeAutoAdvanceTab(state, runtime) };
+  }
+  if (kb.matches(data, KEYBIND_CANCEL)) return { kind: "cancel" };
+  return { kind: "ignore" };
+}
+__name(routeSingleSelectTab, "routeSingleSelectTab");
+function routeKey(data, state, runtime) {
+  const kb = runtime.keybindings;
+  if (typeof runtime.collapseKey === "string" && runtime.collapseKey !== "off" && matchesKey(data, runtime.collapseKey)) {
+    return { kind: "toggle_collapsed" };
+  }
+  if (state.collapsed) return routeCollapsed(kb, data);
+  if (state.notesVisible) return routeNotesMode(kb, data);
+  if (state.inputMode) return routeInputMode(kb, data, state, runtime);
+  if (runtime.isMulti && state.currentTab === runtime.questions.length) {
+    return routeSubmitTab(kb, data, state, runtime);
+  }
+  const tab = tabSwitchAction(data, state, runtime);
+  if (tab) return tab;
+  const q = runtime.questions[state.currentTab];
+  if (!q) return { kind: "ignore" };
+  if (data === NOTES_ACTIVATE_KEY) {
+    return { kind: "notes_enter" };
+  }
+  if (kb.matches(data, KEYBIND_UP)) {
+    return prevNavOnUp(state, runtime);
+  }
+  if (kb.matches(data, KEYBIND_DOWN)) {
+    return nextNavOnDown(state, runtime);
+  }
+  if (q.multiSelect) return routeMultiSelectTab(kb, data, state, runtime);
+  return routeSingleSelectTab(kb, data, state, runtime);
+}
+__name(routeKey, "routeKey");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/state/state-reducer.ts?ext=rpiv-ask-user-question
+function orderedAnswers(state, questions) {
+  const out = [];
+  for (let i = 0; i < questions.length; i++) {
+    const a = state.answers.get(i);
+    if (a) out.push(a);
+  }
+  return out;
+}
+__name(orderedAnswers, "orderedAnswers");
+function syncMultiSelectFromAnswers(answers, questions, tab) {
+  const q = questions[tab];
+  if (!q?.multiSelect) return /* @__PURE__ */ new Set();
+  const saved = answers.get(tab);
+  const labels = saved?.selected ?? [];
+  const indices = /* @__PURE__ */ new Set();
+  for (let i = 0; i < q.options.length; i++) {
+    if (labels.includes(q.options[i].label)) indices.add(i);
+  }
+  return indices;
+}
+__name(syncMultiSelectFromAnswers, "syncMultiSelectFromAnswers");
+function selectedLabels(state, question) {
+  const selected = [];
+  for (let i = 0; i < question.options.length; i++) {
+    if (state.multiSelectChecked.has(i)) selected.push(question.options[i].label);
+  }
+  return selected;
+}
+__name(selectedLabels, "selectedLabels");
+function persistMultiSelectAnswer(state, ctx) {
+  const q = ctx.questions[state.currentTab];
+  if (!q?.multiSelect) return state.answers;
+  const selected = selectedLabels(state, q);
+  const custom = customDraftValueFor(state, state.currentTab);
+  const hasCustom = custom.trim().length > 0;
+  const out = new Map(state.answers);
+  if (selected.length === 0 && !hasCustom) {
+    out.delete(state.currentTab);
+    return out;
+  }
+  const pendingNotes = state.notesByTab.get(state.currentTab);
+  out.set(state.currentTab, {
+    questionIndex: state.currentTab,
+    question: q.question,
+    kind: "multi",
+    answer: hasCustom ? custom : null,
+    selected,
+    ...pendingNotes && pendingNotes.length > 0 ? { notes: pendingNotes } : {}
+  });
+  return out;
+}
+__name(persistMultiSelectAnswer, "persistMultiSelectAnswer");
+function notesValueFor(state, tab) {
+  return state.notesByTab.get(tab) ?? state.answers.get(tab)?.notes ?? "";
+}
+__name(notesValueFor, "notesValueFor");
+function customDraftValueFor(state, tab) {
+  const draft = state.customDraftsByTab.get(tab);
+  if (draft !== void 0) return draft;
+  const answer = state.answers.get(tab);
+  if (answer?.kind !== "custom" && answer?.kind !== "multi") return "";
+  return typeof answer.answer === "string" ? answer.answer : "";
+}
+__name(customDraftValueFor, "customDraftValueFor");
+function setCustomDraft(state, tab, value) {
+  const drafts = new Map(state.customDraftsByTab);
+  drafts.set(tab, value);
+  return drafts;
+}
+__name(setCustomDraft, "setCustomDraft");
+function withoutCustomDraft(state, tab) {
+  if (!state.customDraftsByTab.has(tab)) return state.customDraftsByTab;
+  const drafts = new Map(state.customDraftsByTab);
+  drafts.delete(tab);
+  return drafts;
+}
+__name(withoutCustomDraft, "withoutCustomDraft");
+function switchTabResult(state, nextTab, ctx) {
+  const notesValue = notesValueFor(state, nextTab);
+  const transitioned = {
+    ...state,
+    currentTab: nextTab,
+    optionIndex: 0,
+    inputMode: false,
+    notesVisible: false,
+    submitChoiceIndex: 0,
+    multiSelectChecked: syncMultiSelectFromAnswers(state.answers, ctx.questions, nextTab),
+    notesDraft: notesValue
+  };
+  return {
+    state: transitioned,
+    effects: [
+      { kind: "set_notes_focused", focused: false },
+      { kind: "set_notes_value", value: notesValue },
+      { kind: "set_input_buffer", value: customDraftValueFor(state, nextTab) }
+    ]
+  };
+}
+__name(switchTabResult, "switchTabResult");
+function doneFor(state, ctx, cancelled) {
+  const globalNote = state.notesByTab.get(ctx.questions.length);
+  const result = {
+    answers: orderedAnswers(state, ctx.questions),
+    cancelled,
+    ...globalNote && globalNote.length > 0 ? { globalNote } : {}
+  };
+  return { state, effects: [{ kind: "done", result }] };
+}
+__name(doneFor, "doneFor");
+var navHandler = /* @__PURE__ */ __name((state, action, ctx) => {
+  const items = ctx.itemsByTab[state.currentTab] ?? [];
+  const item = items[action.nextIndex];
+  const inputMode = item ? ROW_INTENT_META[item.kind].activatesInputMode : false;
+  const customDraftsByTab = state.inputMode ? setCustomDraft(state, state.currentTab, action.inputValue) : state.customDraftsByTab;
+  let next = { ...state, optionIndex: action.nextIndex, inputMode, customDraftsByTab };
+  if (state.inputMode && !inputMode && ctx.questions[state.currentTab]?.multiSelect) {
+    next = { ...next, answers: persistMultiSelectAnswer(next, ctx) };
+  }
+  if (!inputMode) return { state: next, effects: [] };
+  return {
+    state: next,
+    effects: [{ kind: "set_input_buffer", value: customDraftValueFor(next, state.currentTab) }]
+  };
+}, "navHandler");
+var inputClearHandler = /* @__PURE__ */ __name((state, _action, _ctx) => ({
+  state: { ...state, customDraftsByTab: setCustomDraft(state, state.currentTab, "") },
+  effects: [{ kind: "clear_input_buffer" }]
+}), "inputClearHandler");
+var inputEditHandler = /* @__PURE__ */ __name((state, action, _ctx) => ({
+  state,
+  effects: [{ kind: "open_input_editor", value: action.value }]
+}), "inputEditHandler");
+var inputReplaceHandler = /* @__PURE__ */ __name((state, action, _ctx) => ({
+  state: { ...state, customDraftsByTab: setCustomDraft(state, state.currentTab, action.value) },
+  effects: [{ kind: "set_input_buffer", value: action.value }]
+}), "inputReplaceHandler");
+var tabSwitchHandler = /* @__PURE__ */ __name((state, action, ctx) => switchTabResult(state, action.nextTab, ctx), "tabSwitchHandler");
+var confirmHandler = /* @__PURE__ */ __name((state, action, ctx) => {
+  let answer = action.answer;
+  const q = ctx.questions[answer.questionIndex];
+  if (answer.kind === "custom" && q?.multiSelect) {
+    answer = { ...answer, kind: "multi", selected: selectedLabels(state, q) };
+  } else if (answer.kind === "option" && answer.answer) {
+    const matched = q?.options.find((o) => o.label === answer.answer);
+    if (matched?.preview && matched.preview.length > 0) {
+      answer = { ...answer, preview: matched.preview };
+    }
+  }
+  const pendingNotes = state.notesByTab.get(answer.questionIndex);
+  if (pendingNotes && pendingNotes.length > 0) {
+    answer = { ...answer, notes: pendingNotes };
+  }
+  const answers = new Map(state.answers);
+  answers.set(answer.questionIndex, answer);
+  const hasCustomAnswer = answer.kind === "custom" || answer.kind === "multi" && answer.answer !== null;
+  const customDraftsByTab = hasCustomAnswer ? withoutCustomDraft(state, answer.questionIndex) : state.customDraftsByTab;
+  const next = {
+    ...state,
+    answers,
+    customDraftsByTab
+  };
+  if (action.autoAdvanceTab !== void 0) return switchTabResult(next, action.autoAdvanceTab, ctx);
+  return doneFor(next, ctx, false);
+}, "confirmHandler");
+var toggleHandler = /* @__PURE__ */ __name((state, action, ctx) => {
+  const checked = new Set(state.multiSelectChecked);
+  if (checked.has(action.index)) checked.delete(action.index);
+  else checked.add(action.index);
+  const intermediate = { ...state, multiSelectChecked: checked };
+  const answers = persistMultiSelectAnswer(intermediate, ctx);
+  return { state: { ...intermediate, answers }, effects: [] };
+}, "toggleHandler");
+var multiConfirmHandler = /* @__PURE__ */ __name((state, action, ctx) => {
+  const q = ctx.questions[state.currentTab];
+  if (!q) return { state, effects: [] };
+  const pendingNotes = state.notesByTab.get(state.currentTab);
+  const answers = new Map(state.answers);
+  answers.set(state.currentTab, {
+    questionIndex: state.currentTab,
+    question: q.question,
+    kind: "multi",
+    answer: action.answer,
+    selected: action.selected,
+    ...pendingNotes && pendingNotes.length > 0 ? { notes: pendingNotes } : {}
+  });
+  const synced = {
+    ...state,
+    answers,
+    customDraftsByTab: withoutCustomDraft(state, state.currentTab),
+    multiSelectChecked: syncMultiSelectFromAnswers(answers, ctx.questions, state.currentTab)
+  };
+  if (action.autoAdvanceTab !== void 0) return switchTabResult(synced, action.autoAdvanceTab, ctx);
+  return doneFor(synced, ctx, false);
+}, "multiConfirmHandler");
+var notesEnterHandler = /* @__PURE__ */ __name((state, _action, _ctx) => {
+  const value = notesValueFor(state, state.currentTab);
+  return {
+    state: { ...state, notesVisible: true, notesDraft: value },
+    effects: [
+      { kind: "set_notes_value", value },
+      { kind: "set_notes_focused", focused: true }
+    ]
+  };
+}, "notesEnterHandler");
+var notesExitHandler = /* @__PURE__ */ __name((state, _action, _ctx) => {
+  const trimmed = state.notesDraft.trim();
+  const notes = new Map(state.notesByTab);
+  const answers = new Map(state.answers);
+  if (trimmed.length === 0) {
+    notes.delete(state.currentTab);
+    const prev = answers.get(state.currentTab);
+    if (prev?.notes) {
+      const stripped = { ...prev };
+      delete stripped.notes;
+      answers.set(state.currentTab, stripped);
+    }
+  } else {
+    notes.set(state.currentTab, trimmed);
+    const prev = answers.get(state.currentTab);
+    if (prev) answers.set(state.currentTab, { ...prev, notes: trimmed });
+  }
+  return {
+    state: { ...state, notesByTab: notes, answers, notesVisible: false },
+    effects: [{ kind: "set_notes_focused", focused: false }]
+  };
+}, "notesExitHandler");
+var cancelHandler = /* @__PURE__ */ __name((s, _a, c) => doneFor(s, c, true), "cancelHandler");
+var submitHandler = /* @__PURE__ */ __name((s, _a, c) => doneFor(s, c, false), "submitHandler");
+var submitNavHandler = /* @__PURE__ */ __name((s, a, _c) => ({
+  state: { ...s, submitChoiceIndex: a.nextIndex },
+  effects: []
+}), "submitNavHandler");
+var notesForwardHandler = /* @__PURE__ */ __name((s, a, _c) => ({
+  state: s,
+  effects: [{ kind: "forward_notes_keystroke", data: a.data }]
+}), "notesForwardHandler");
+var toggleCollapsedHandler = /* @__PURE__ */ __name((s, _a, _c) => ({
+  state: { ...s, collapsed: !s.collapsed },
+  effects: [{ kind: "set_overlay_hidden", hidden: !s.collapsed }]
+}), "toggleCollapsedHandler");
+var ignoreHandler = /* @__PURE__ */ __name((s, _a, _c) => ({ state: s, effects: [] }), "ignoreHandler");
+var HANDLERS = {
+  nav: navHandler,
+  input_clear: inputClearHandler,
+  input_edit: inputEditHandler,
+  input_replace: inputReplaceHandler,
+  tab_switch: tabSwitchHandler,
+  confirm: confirmHandler,
+  toggle: toggleHandler,
+  multi_confirm: multiConfirmHandler,
+  cancel: cancelHandler,
+  notes_enter: notesEnterHandler,
+  notes_exit: notesExitHandler,
+  notes_forward: notesForwardHandler,
+  submit: submitHandler,
+  submit_nav: submitNavHandler,
+  toggle_collapsed: toggleCollapsedHandler,
+  ignore: ignoreHandler
+};
+function reduce(state, action, ctx) {
+  const handler = HANDLERS[action.kind];
+  return handler(state, action, ctx);
+}
+__name(reduce, "reduce");
+
+// node_modules/@juicesharp/rpiv-ask-user-question/state/questionnaire-session.ts?ext=rpiv-ask-user-question
+function initialState() {
+  return {
+    currentTab: 0,
+    optionIndex: 0,
+    inputMode: false,
+    notesVisible: false,
+    answers: /* @__PURE__ */ new Map(),
+    multiSelectChecked: /* @__PURE__ */ new Set(),
+    customDraftsByTab: /* @__PURE__ */ new Map(),
+    notesByTab: /* @__PURE__ */ new Map(),
+    submitChoiceIndex: 0,
+    notesDraft: "",
+    collapsed: false
+  };
+}
+__name(initialState, "initialState");
+var QuestionnaireSession = class {
+  static {
+    __name(this, "QuestionnaireSession");
+  }
+  state = initialState();
+  questions;
+  isMulti;
+  itemsByTab;
+  notesInput;
+  inlineInput;
+  viewAdapter;
+  keybindings;
+  editInput;
+  collapseKey;
+  canReopenWhileHidden;
+  inputEditorOpen = false;
+  /**
+   * Overlay handle captured by `ctx.ui.custom`'s `onHandle` callback. Lets the session
+   * call `setHidden(true/false)` so pi-tui's overlay stack reflects the collapsed state
+   * and overlay-aware consumers (e.g. `pi-station`) can resume normal behaviour.
+   */
+  overlayHandle;
+  tui;
+  done;
+  component;
+  constructor(config) {
+    this.tui = config.tui;
+    this.done = config.done;
+    this.questions = config.params.questions;
+    this.isMulti = this.questions.length > 1;
+    this.itemsByTab = config.itemsByTab;
+    this.keybindings = config.keybindings;
+    this.editInput = config.editInput;
+    this.collapseKey = config.collapseKey;
+    this.canReopenWhileHidden = config.canReopenWhileHidden;
+    const built = buildQuestionnaire({
+      tui: this.tui,
+      theme: config.theme,
+      questions: this.questions,
+      itemsByTab: this.itemsByTab,
+      isMulti: this.isMulti,
+      initialState: this.state,
+      getCurrentTab: /* @__PURE__ */ __name(() => this.state.currentTab, "getCurrentTab"),
+      collapseKey: this.collapseKey,
+      rowBudget: config.rowBudget
+    });
+    this.notesInput = built.notesInput;
+    this.inlineInput = built.inlineInput;
+    this.viewAdapter = built.adapter;
+    this.component = this.assembleComponent(built, config.theme);
+    this.viewAdapter.apply(this.state);
+  }
+  assembleComponent(built, theme) {
+    const collapsedRender = this.buildCollapsedRender(theme);
+    return {
+      render: /* @__PURE__ */ __name((width) => this.state.collapsed ? collapsedRender(width) : built.render(width), "render"),
+      invalidate: built.invalidate,
+      handleInput: /* @__PURE__ */ __name((data) => this.dispatch(data), "handleInput")
+    };
+  }
+  /**
+   * Collapsed render: a single dim row (inline presentation: in the editor slot, where it
+   * keeps focus so the same key expands it). For the overlay, pi-tui sizes
+   * the overlay to `min(lines.length, maxHeight)`, so returning one line shrinks
+   * the bottom-anchored overlay from full-height to one row and the transcript
+   * behind it becomes readable (#47). The overlay stays focused and in the
+   * stack, so the collapse key still routes here to expand. `t` stays inside the
+   * closure (live locale updates); the key display is static per session.
+   *
+   * With collapseKey "off" the router and raw listener never toggle `collapsed`,
+   * but `toggleCollapsedExternal()` is a public ungated entry — fall back to the
+   * cancel-only line rather than rendering a literal "Off to expand".
+   */
+  buildCollapsedRender(theme) {
+    const collapseKeyDisplay = formatKeySpecForDisplay(this.collapseKey);
+    const collapsedHintLine = /* @__PURE__ */ __name(() => this.collapseKey === COLLAPSE_KEY_OFF ? t("hint.cancel", HINT_PART_CANCEL) : t("hint.expand_line", COLLAPSED_HINT_TEMPLATE).replace(KEY_PLACEHOLDER, collapseKeyDisplay), "collapsedHintLine");
+    return (_width) => [theme.fg("dim", ` ${collapsedHintLine()} `)];
+  }
+  dispatch(data) {
+    if (this.inputEditorOpen) return;
+    const action = routeKey(data, this.state, this.runtime());
+    if (action.kind === "ignore") {
+      this.handleIgnoreInline(data);
+      return;
+    }
+    this.commit(action);
+  }
+  commit(action) {
+    const result = reduce(this.state, action, this.applyContext());
+    this.state = result.state;
+    for (const effect of result.effects) this.runEffect(effect);
+    this.state = this.mirrorNotesDraft(this.state);
+    this.viewAdapter.apply(this.state);
+  }
+  mirrorNotesDraft(s) {
+    const draft = this.notesInput.getExpandedText?.() ?? this.notesInput.getText();
+    return s.notesDraft === draft ? s : { ...s, notesDraft: draft };
+  }
+  runEffect(effect) {
+    switch (effect.kind) {
+      case "set_input_buffer":
+        this.inlineInput.setText(effect.value);
+        return;
+      case "clear_input_buffer":
+        this.inlineInput.setText("");
+        return;
+      case "open_input_editor":
+        this.openInputEditorAsync(effect.value);
+        return;
+      case "set_notes_value":
+        this.notesInput.setText(effect.value);
+        return;
+      case "set_notes_focused":
+        this.notesInput.focused = effect.focused;
+        return;
+      case "forward_notes_keystroke":
+        this.notesInput.handleInput(effect.data);
+        return;
+      case "set_overlay_hidden":
+        if (this.canReopenWhileHidden) this.overlayHandle?.setHidden(effect.hidden);
+        return;
+      case "done":
+        this.done(effect.result);
+        return;
+    }
+  }
+  /** Opens Pi's configured external editor; on success commits the replacement buffer, on reported failure retains the draft. */
+  openInputEditorAsync(value) {
+    if (this.inputEditorOpen) return;
+    this.inputEditorOpen = true;
+    void this.editInput(value).then(
+      (edited) => {
+        this.inputEditorOpen = false;
+        if (edited !== void 0) this.commit({ kind: "input_replace", value: edited });
+      },
+      () => {
+        this.inputEditorOpen = false;
+      }
+    );
+  }
+  /**
+   * Per-keystroke `ignore` fast path: delegates text editing to Pi's headless
+   * multiline `Editor`, including paste, undo, cursor movement, and configured
+   * `tui.input.newLine` handling. `viewAdapter.apply` then projects its public
+   * text/cursor state without a reducer round-trip.
+   */
+  handleIgnoreInline(data) {
+    if (!this.state.inputMode) return;
+    this.inlineInput.handleInput(data);
+    this.viewAdapter.apply(this.state);
+  }
+  runtime() {
+    const cursor = this.inlineInput.getCursor();
+    const lastLine = this.inlineInput.getLines().length - 1;
+    return {
+      keybindings: this.keybindings,
+      inputBuffer: this.inlineInput.getExpandedText?.() ?? this.inlineInput.getText(),
+      canMoveInputUp: cursor.line > 0,
+      canMoveInputDown: cursor.line < lastLine,
+      questions: this.questions,
+      isMulti: this.isMulti,
+      currentItem: this.currentItem(),
+      items: this.itemsByTab[this.state.currentTab] ?? [],
+      collapseKey: this.collapseKey
+    };
+  }
+  applyContext() {
+    return {
+      questions: this.questions,
+      itemsByTab: this.itemsByTab
+    };
+  }
+  currentItem() {
+    const arr = this.itemsByTab[this.state.currentTab] ?? [];
+    return this.state.optionIndex < arr.length ? arr[this.state.optionIndex] : void 0;
+  }
+  /**
+   * Setter for the overlay handle, called by `ctx.ui.custom`'s `onHandle` callback once
+   * the TUI has created the overlay. Until this is called, `set_overlay_hidden` effects
+   * are no-ops — the session still tracks `state.collapsed` for the view layer.
+   */
+  setOverlayHandle(handle) {
+    this.overlayHandle = handle;
+  }
+  /**
+   * Public toggle used by the raw terminal input listener registered in `execute()`.
+   * pi-tui does not route input to a hidden overlay's `component.handleInput`, so the
+   * raw listener (which fires for terminal data regardless of overlay visibility)
+   * reaches the session through this method instead of the dispatch path. Routed
+   * through `commit` so the transition stays in the reducer and the overlay hide
+   * happens via the `set_overlay_hidden` effect like every other side effect.
+   */
+  toggleCollapsedExternal() {
+    if (!this.inputEditorOpen) this.commit({ kind: "toggle_collapsed" });
+  }
+};
+export {
+  QuestionnaireSession
+};