ompchamber 0.6.0 → 0.8.0

package/src/shared/lib/chat/ask-questions.test.ts

@@ -0,0 +1,169 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import type { ToolCallData } from '@/shared/types';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+import {
+  groupAskFrames,
+  parseAskQuestions,
+  parseAskResult,
+  normalizeAskText,
+} from '@/shared/lib/chat/ask-questions';
+
+function askTool(input: unknown, extra: Partial<ToolCallData> = {}): ToolCallData {
+  return { id: 'call_ask_1', type: 'ask', title: 'ask', name: 'ask', input: input as Record<string, unknown>, ...extra };
+}
+
+function selectFrame(id: string, title: string, options: string[] = ['A', 'B']): ExtensionUiDialogRequest {
+  return { type: 'extension_ui_request', id, method: 'select', title, options };
+}
+
+const THREE_QUESTIONS = {
+  questions: [
+    {
+      id: 'language',
+      header: 'Language',
+      question: 'Which language should we use for this test?',
+      options: [{ label: 'Python', description: 'Use Python for testing' }, { label: 'TypeScript' }],
+      recommended: 0,
+    },
+    { id: 'style', question: 'What answer style do you prefer for testing?', options: [{ label: 'Balanced' }] },
+    { id: 'confirm', question: 'Did this render correctly?', options: [{ label: 'Yes' }, { label: 'No' }] },
+  ],
+};
+
+describe('parseAskQuestions', () => {
+  test('reads every question, not just the first', () => {
+    const questions = parseAskQuestions(askTool(THREE_QUESTIONS));
+    expect(questions.map((q) => q.id)).toEqual(['language', 'style', 'confirm']);
+    expect(questions[0].options[0]).toEqual({ label: 'Python', description: 'Use Python for testing' });
+    expect(questions[0].recommended).toBe(0);
+    expect(questions[1].multi).toBe(false);
+  });
+
+  test('is empty for a non-ask payload, so the card falls back to the raw result', () => {
+    expect(parseAskQuestions(askTool({ question: 'single legacy shape' }))).toEqual([]);
+    expect(parseAskQuestions(askTool(undefined))).toEqual([]);
+  });
+
+  test('drops entries without question text instead of rendering a blank block', () => {
+    const questions = parseAskQuestions(askTool({ questions: [{ id: 'a' }, { id: 'b', question: '  Keep me  ' }] }));
+    expect(questions).toEqual([expect.objectContaining({ id: 'b', question: 'Keep me' })]);
+  });
+});
+
+describe('normalizeAskText', () => {
+  test('strips the progress suffix and the multi-select prefix omp decorates titles with', () => {
+    expect(normalizeAskText('Which language? (2/3)')).toBe('which language?');
+    expect(normalizeAskText('(2 selected) Which language?')).toBe('which language?');
+    expect(normalizeAskText('(1 selected) Pick one (3/3)')).toBe('pick one');
+  });
+});
+
+describe('groupAskFrames', () => {
+  const questions = parseAskQuestions(askTool(THREE_QUESTIONS));
+
+  test('puts each dialog on the question that raised it', () => {
+    const frames = [
+      selectFrame('f1', 'Which language should we use for this test? (1/3)'),
+      selectFrame('f2', 'What answer style do you prefer for testing? (2/3)'),
+      selectFrame('f3', 'Did this render correctly? (3/3)'),
+    ];
+    const groups = groupAskFrames(questions, frames);
+    expect(groups.map((group) => group.map((frame) => frame.id))).toEqual([['f1'], ['f2'], ['f3']]);
+  });
+
+  test('keeps the free-text follow-up dialog on the question that asked for it', () => {
+    const frames: ExtensionUiDialogRequest[] = [
+      selectFrame('f1', 'Which language should we use for this test? (1/3)'),
+      { type: 'extension_ui_request', id: 'f1b', method: 'editor', title: 'Which language should we use for this test?' },
+      selectFrame('f2', 'What answer style do you prefer for testing? (2/3)'),
+    ];
+    const groups = groupAskFrames(questions, frames);
+    expect(groups[0].map((frame) => frame.id)).toEqual(['f1', 'f1b']);
+    expect(groups[1].map((frame) => frame.id)).toEqual(['f2']);
+    expect(groups[2]).toEqual([]);
+  });
+
+  test('falls back to order when a rebuild decorates the title in a way we cannot parse', () => {
+    const frames = [
+      selectFrame('f1', 'Some unknown header'),
+      selectFrame('f2', 'Another unknown header'),
+      selectFrame('f3', 'A third unknown header'),
+    ];
+    const groups = groupAskFrames(questions, frames);
+    expect(groups.map((group) => group.map((frame) => frame.id))).toEqual([['f1'], ['f2'], ['f3']]);
+  });
+
+  test('keeps repeated multi-select dialogs on the question being answered', () => {
+    const frames = [
+      selectFrame('f1', '(1 selected) Which language should we use for this test? (1/3)'),
+      selectFrame('f2', '(1 selected) Which language should we use for this test? (1/3)'),
+      selectFrame('f3', 'What answer style do you prefer for testing? (2/3)'),
+    ];
+    const groups = groupAskFrames(questions, frames);
+    expect(groups[0].map((frame) => frame.id)).toEqual(['f1', 'f2']);
+    expect(groups[1].map((frame) => frame.id)).toEqual(['f3']);
+  });
+});
+
+describe('parseAskResult', () => {
+  const questions = parseAskQuestions(askTool(THREE_QUESTIONS));
+
+  test('reads every recorded answer from details.results', () => {
+    const answers = parseAskResult(askTool(THREE_QUESTIONS, {
+      details: {
+        results: [
+          { id: 'language', question: 'Which language?', selectedOptions: ['Python'] },
+          { id: 'style', question: 'Style?', selectedOptions: [], customInput: 'Dadadada' },
+          { id: 'confirm', question: 'Correct?', selectedOptions: ['Yes'], timedOut: true },
+        ],
+      },
+    }), questions);
+
+    expect(answers[0]).toEqual({ selectedOptions: ['Python'], customInput: undefined, timedOut: false });
+    expect(answers[1]?.customInput).toBe('Dadadada');
+    expect(answers[2]?.timedOut).toBe(true);
+  });
+
+  test('reads the flat shape omp returns for a single-question ask', () => {
+    const single = parseAskQuestions(askTool({ questions: [THREE_QUESTIONS.questions[0]] }));
+    const answers = parseAskResult(askTool({}, { details: { selectedOptions: ['Go'], multi: false } }), single);
+    expect(answers[0]?.selectedOptions).toEqual(['Go']);
+  });
+
+  test('leaves every question unanswered while the ask is still running', () => {
+    expect(parseAskResult(askTool(THREE_QUESTIONS), questions)).toEqual([null, null, null]);
+  });
+
+  test('falls back to the rendered text when details never reached the client', () => {
+    const output = 'User answers:\nlanguage: Python\nstyle: Balanced\nconfirm: Yes';
+    const answers = parseAskResult(askTool(THREE_QUESTIONS, { output }), questions);
+    expect(answers.map((answer) => answer?.selectedOptions)).toEqual([['Python'], ['Balanced'], ['Yes']]);
+  });
+
+  test('reads a typed custom answer out of the rendered text', () => {
+    const output = 'User answers:\nlanguage: Python\nstyle: "Dadadada"\nconfirm: Yes';
+    const answers = parseAskResult(askTool(THREE_QUESTIONS, { output }), questions);
+    expect(answers[1]).toEqual({ selectedOptions: [], customInput: 'Dadadada' });
+  });
+
+  test('reads the single-question result shapes', () => {
+    const single = parseAskQuestions(askTool({ questions: [THREE_QUESTIONS.questions[0]] }));
+    expect(parseAskResult(askTool({}, { output: 'User selected: Python' }), single)[0]?.selectedOptions).toEqual(['Python']);
+    expect(parseAskResult(askTool({}, { output: 'User provided custom input: Dadadada' }), single)[0]?.customInput)
+      .toBe('Dadadada');
+  });
+
+  test('never reads a failure message as an answer', () => {
+    const failed = askTool(THREE_QUESTIONS, {
+      output: 'Ask tool was cancelled by the user',
+      status: 'error' as const,
+    });
+    expect(parseAskResult(failed, questions)).toEqual([null, null, null]);
+  });
+});

package/src/shared/lib/chat/ask-questions.ts

@@ -0,0 +1,264 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Pure helpers for omp's `ask` tool: read its `questions` payload, pair the
+ * per-question dialogs omp raises for them back to the question they belong to,
+ * and read the recorded answers out of the tool result.
+ *
+ * The pairing is load-bearing, and the reason is worth stating: omp's RPC UI
+ * context implements `select`/`confirm`/`input`/`editor` but NOT the rich
+ * `askDialog` primitive the TUI uses. `AskTool` therefore falls back to its
+ * per-question loop, and over RPC a multi-question ask reaches the chamber as
+ * ONE blocking `select` frame per question, in order — never as one payload. The
+ * frame carries the question as its `title` (plus a ` (2/3)` progress suffix and
+ * a `(2 selected) ` prefix for multi-select questions), which is what lets the
+ * inline card put each frame back on the question it asked.
+ */
+
+import type { ToolCallData } from '@/shared/types';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+
+export interface AskOption {
+  label: string;
+  description?: string;
+  preview?: string;
+}
+
+export interface AskQuestion {
+  id?: string;
+  /** Short chip omp shows above the question ("Authentication"). */
+  header?: string;
+  question: string;
+  options: AskOption[];
+  multi: boolean;
+  /** Index of the option omp marks ` (Recommended)`. */
+  recommended?: number;
+}
+
+export interface AskAnswer {
+  selectedOptions: string[];
+  customInput?: string;
+  /** omp auto-selected the answer after `ask.timeout` elapsed. */
+  timedOut?: boolean;
+}
+
+/** The free-text escape hatch omp appends to every question's option list. */
+const OTHER_OPTION = /^other\b/i;
+/** Trailing ` (2/3)` omp adds while looping over several questions. */
+const PROGRESS_SUFFIX = /\s+\(\d+\s*\/\s*\d+\)$/;
+/** Leading `(2 selected) ` omp prepends to a multi-select question's title. */
+const SELECTED_COUNT_PREFIX = /^\(\d+\s+selected\)\s*/;
+
+/** True for the literal "Other (type your own)" row, which is a prompt to type
+ *  an answer rather than an answer itself. */
+export function isOtherOption(label: string): boolean {
+  return OTHER_OPTION.test(label.trim());
+}
+
+/** Normalized question text, with the decorations omp adds to a live dialog
+ *  title stripped, so a frame can be matched against the question that raised it. */
+export function normalizeAskText(value: string): string {
+  return value
+    .replace(SELECTED_COUNT_PREFIX, '')
+    .replace(PROGRESS_SUFFIX, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function readOption(raw: unknown): AskOption | null {
+  if (typeof raw === 'string') {
+    const label = raw.trim();
+    return label ? { label } : null;
+  }
+  if (!raw || typeof raw !== 'object') return null;
+  const record = raw as Record<string, unknown>;
+  const label = typeof record.label === 'string' ? record.label.trim() : '';
+  if (!label) return null;
+  return {
+    label,
+    description: typeof record.description === 'string' ? record.description : undefined,
+    preview: typeof record.preview === 'string' ? record.preview : undefined,
+  };
+}
+
+/** True for a tool call that is omp's `ask` tool. */
+export function isAskToolCall(tool: ToolCallData): boolean {
+  const name = typeof tool.name === 'string' && tool.name ? tool.name : tool.type;
+  return name === 'ask' || tool.title === 'ask';
+}
+
+/**
+ * The `questions` array from an `ask` tool call's arguments. Empty when the tool
+ * is not an ask call or its arguments were truncated — callers fall back to the
+ * raw arguments/output rendering in that case.
+ */
+export function parseAskQuestions(tool: ToolCallData): AskQuestion[] {
+  const input = tool.input;
+  const record = typeof input === 'object' && input !== null ? (input as Record<string, unknown>) : null;
+  const raw = record && Array.isArray(record.questions) ? record.questions : [];
+  const questions: AskQuestion[] = [];
+
+  for (const entry of raw) {
+    if (!entry || typeof entry !== 'object') continue;
+    const question = entry as Record<string, unknown>;
+    const text = typeof question.question === 'string' ? question.question.trim() : '';
+    if (!text) continue;
+    questions.push({
+      id: typeof question.id === 'string' ? question.id : undefined,
+      header: typeof question.header === 'string' && question.header.trim() ? question.header.trim() : undefined,
+      question: text,
+      options: Array.isArray(question.options)
+        ? question.options.map(readOption).filter((option): option is AskOption => option !== null)
+        : [],
+      multi: question.multi === true,
+      recommended: typeof question.recommended === 'number' ? question.recommended : undefined,
+    });
+  }
+
+  return questions;
+}
+
+function readAnswer(row: Record<string, unknown>): AskAnswer {
+  return {
+    selectedOptions: Array.isArray(row.selectedOptions)
+      ? row.selectedOptions.filter((value): value is string => typeof value === 'string')
+      : [],
+    customInput: typeof row.customInput === 'string' && row.customInput ? row.customInput : undefined,
+    timedOut: row.timedOut === true,
+  };
+}
+
+/** One `<id>: <answer>` line of a multi-question result. */
+const ANSWER_LINE = /^([\w.-]+):\s*(.+)$/;
+/** The single-question result's two prose shapes. */
+const SELECTED_LINE = /^User selected:\s*(.+)$/m;
+const CUSTOM_LINE = /^User provided custom input:\s*([\s\S]+)$/m;
+
+/** `value` as omp renders it: a quoted string is typed input, a bare one is a
+ *  picked label (comma-joined when the question allows several). */
+function toAnswer(value: string, multi: boolean): AskAnswer {
+  const text = value.trim();
+  if (/^"[\s\S]*"$/.test(text)) return { selectedOptions: [], customInput: text.slice(1, -1) };
+  const labels = multi && text.includes(', ') ? text.split(', ') : [text];
+  return { selectedOptions: labels.map((label) => label.trim()).filter(Boolean) };
+}
+
+/**
+ * Answers recovered from the tool's rendered text, used when `details` never
+ * reached this client. `details` is the richer source, but it is dropped by the
+ * live `tool_execution_end` frame on some omp builds; the text is the one part
+ * of a settled result every path carries, and it names each answer by question
+ * id (`language: Python`) or as a single sentence for a one-question ask.
+ */
+function parseAskOutputAnswers(output: string, questions: AskQuestion[]): (AskAnswer | null)[] {
+  const answers = questions.map((): AskAnswer | null => null);
+  const text = output.trim();
+  if (!text) return answers;
+
+  const byId = new Map<string, AskAnswer>();
+  for (const line of text.split('\n')) {
+    const match = ANSWER_LINE.exec(line.trim());
+    if (match) byId.set(match[1], toAnswer(match[2], questions.some((question) => question.multi)));
+  }
+  if (byId.size > 0) {
+    const ordered = [...byId.values()];
+    for (let index = 0; index < questions.length; index += 1) {
+      // The question id is the key omp prints; position is what is left when a
+      // payload carries no ids at all (omp requires them, so this is defensive).
+      const id = questions[index].id;
+      answers[index] = (id ? byId.get(id) : undefined) ?? ordered[index] ?? null;
+    }
+    return answers;
+  }
+
+  const selected = SELECTED_LINE.exec(text);
+  if (selected) {
+    answers[0] = toAnswer(selected[1], questions[0].multi);
+    return answers;
+  }
+  const custom = CUSTOM_LINE.exec(text);
+  if (custom) {
+    answers[0] = { selectedOptions: [], customInput: custom[1].trim() };
+    return answers;
+  }
+  if (questions.length === 1 && !text.includes('\n')) {
+    answers[0] = { selectedOptions: [text] };
+  }
+  return answers;
+}
+
+/**
+ * Answers recorded in an `ask` tool result, positionally aligned with
+ * `questions`. omp returns `details.results[]` for a multi-question ask and the
+ * bare answer fields for a single-question one; the rendered text backs both up.
+ */
+export function parseAskResult(tool: ToolCallData, questions: AskQuestion[]): (AskAnswer | null)[] {
+  const answers = questions.map((): AskAnswer | null => null);
+  if (questions.length === 0) return answers;
+
+  const details = tool.details ?? {};
+  const results = Array.isArray(details.results) ? (details.results as Record<string, unknown>[]) : null;
+  if (results) {
+    for (let index = 0; index < answers.length; index += 1) {
+      const row = results[index];
+      if (row && typeof row === 'object') answers[index] = readAnswer(row);
+    }
+    return answers;
+  }
+
+  if (typeof details.selectedOptions !== 'undefined' || typeof details.customInput === 'string') {
+    answers[0] = readAnswer(details);
+    return answers;
+  }
+
+  // A failed/cancelled ask answers nothing; its text is the reason, which would
+  // otherwise read as an answer for whichever id its first sentence names.
+  if (tool.status === 'error' || tool.status === 'aborted' || tool.isError) return answers;
+
+  return parseAskOutputAnswers(typeof tool.output === 'string' ? tool.output : '', questions);
+}
+
+/**
+ * Bucket the ask's dialogs by question index.
+ *
+ * Assignment follows omp's own order rather than pure title matching: a frame
+ * whose title names a question moves the cursor onto it, and any other frame
+ * (the `editor`/`input` dialog omp opens after "Other (type your own)") belongs
+ * to whichever question was last named. A title that names an EARLIER question
+ * is ignored — omp walks the questions forward and never re-asks one, so a
+ * repeat can only be a multi-select re-render of the question already in hand.
+ */
+export function groupAskFrames(
+  questions: AskQuestion[],
+  frames: ExtensionUiDialogRequest[],
+): ExtensionUiDialogRequest[][] {
+  const groups = questions.map((): ExtensionUiDialogRequest[] => []);
+  if (questions.length === 0) return groups;
+  const titles = questions.map((question) => normalizeAskText(question.question));
+
+  let cursor = 0;
+  for (const frame of frames) {
+    const title = typeof frame.title === 'string' ? normalizeAskText(frame.title) : '';
+    const index = titles.indexOf(title);
+    if (index > cursor) {
+      cursor = index;
+    } else if (
+      index === -1 &&
+      frame.method === 'select' &&
+      groups[cursor].some((held) => held.method === 'select') &&
+      cursor + 1 < groups.length
+    ) {
+      // Title matching is the authority, but a question is asked by exactly one
+      // `select` — a second one that matches nothing is the NEXT question with
+      // decorations this build does not know about, not a repeat.
+      cursor += 1;
+    }
+    groups[cursor].push(frame);
+  }
+
+  return groups;
+}

package/src/shared/lib/code/lazy-window.test.ts

@@ -0,0 +1,161 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  codeWindow,
+  clampWindow,
+  firstWindow,
+  measuredGeometry,
+  resolveWindow,
+  shouldWindow,
+  uniformGeometry,
+  windowSpace,
+  WHOLE_DOCUMENT_MAX_CHARS,
+  WHOLE_DOCUMENT_MAX_LINES,
+  WINDOW_OVERSCAN,
+  type LineGeometry,
+} from '@/shared/lib/code/lazy-window';
+
+const ROW = 18;
+
+/** `measuredGeometry` returns null for heights that do not fit the document. */
+function measured(heights: number[]): LineGeometry {
+  const geometry = measuredGeometry(heights, ROW, heights.length);
+  if (!geometry) throw new Error('heights should describe every line');
+  return geometry;
+}
+
+describe('shouldWindow', () => {
+  test('leaves a short document on the plain surface', () => {
+    expect(shouldWindow(120, 4_000)).toBe(false);
+  });
+
+  test('windows a document that is long in lines or in characters', () => {
+    expect(shouldWindow(WHOLE_DOCUMENT_MAX_LINES + 1, 10)).toBe(true);
+    expect(shouldWindow(10, WHOLE_DOCUMENT_MAX_CHARS + 1)).toBe(true);
+  });
+});
+
+describe('uniformGeometry', () => {
+  const geometry = uniformGeometry(ROW, 500);
+
+  test('spaces lines one row apart and totals the document', () => {
+    expect(geometry.offsetOf(0)).toBe(0);
+    expect(geometry.offsetOf(10)).toBe(10 * ROW);
+    expect(geometry.totalHeight).toBe(500 * ROW);
+  });
+
+  test('maps an offset back to the line covering it', () => {
+    expect(geometry.lineAt(0)).toBe(0);
+    expect(geometry.lineAt(ROW - 1)).toBe(0);
+    expect(geometry.lineAt(ROW)).toBe(1);
+    expect(geometry.lineAt(499 * ROW + 3)).toBe(499);
+  });
+
+  test('clamps an offset outside the document', () => {
+    expect(geometry.lineAt(-50)).toBe(0);
+    expect(geometry.lineAt(999_999)).toBe(499);
+    expect(geometry.offsetOf(500)).toBe(geometry.totalHeight);
+    expect(geometry.offsetOf(999)).toBe(geometry.totalHeight);
+  });
+});
+
+describe('measuredGeometry', () => {
+  // Every third line wraps over three rows; the rest are single rows.
+  const heights = Array.from({ length: 9 }, (_, index) => (index % 3 === 2 ? ROW * 3 : ROW));
+  const geometry = measured(heights);
+
+  test('builds offsets from the wrapped heights', () => {
+    expect(geometry.offsetOf(0)).toBe(0);
+    expect(geometry.offsetOf(1)).toBe(ROW);
+    expect(geometry.offsetOf(2)).toBe(2 * ROW);
+    // Line 2 spans three rows, so line 3 starts after all three.
+    expect(geometry.offsetOf(3)).toBe(5 * ROW);
+    expect(geometry.totalHeight).toBe(heights.reduce((sum, height) => sum + height, 0));
+  });
+
+  test('maps an offset inside a wrapped line to that line', () => {
+    expect(geometry.lineAt(2 * ROW)).toBe(2);
+    expect(geometry.lineAt(4 * ROW + 5)).toBe(2);
+    expect(geometry.lineAt(5 * ROW)).toBe(3);
+  });
+
+  test('refuses heights that do not describe every line', () => {
+    expect(measuredGeometry([ROW, ROW], ROW, 5)).toBeNull();
+    expect(measuredGeometry([], ROW, 0)).toBeNull();
+  });
+});
+
+describe('resolveWindow', () => {
+  const geometry = uniformGeometry(ROW, 1_000);
+
+  test('covers the viewport plus overscan on both sides', () => {
+    // Viewport rows 100..128 (the last row is half covered, so it is included).
+    const window = resolveWindow(geometry, 100 * ROW, 28 * ROW);
+    expect(window).toEqual({ start: 100 - WINDOW_OVERSCAN, end: 129 + WINDOW_OVERSCAN });
+  });
+
+  test('never runs past either end of the document', () => {
+    expect(resolveWindow(geometry, 0, ROW)).toEqual({ start: 0, end: 2 + WINDOW_OVERSCAN });
+    expect(resolveWindow(geometry, 999 * ROW, 40 * ROW).end).toBe(1_000);
+  });
+
+  test('keeps a zero-height band to at least the line under it', () => {
+    const window = resolveWindow(geometry, 400 * ROW, 0);
+    expect(window.start).toBeLessThanOrEqual(400);
+    expect(window.end).toBeGreaterThan(400);
+  });
+});
+
+describe('firstWindow', () => {
+  test('bounds the opening render of a long document', () => {
+    expect(firstWindow(20_000).start).toBe(0);
+    expect(firstWindow(20_000).end).toBeLessThan(20_000);
+  });
+
+  test('keeps a short document whole', () => {
+    expect(firstWindow(3)).toEqual({ start: 0, end: 3 });
+  });
+});
+
+describe('clampWindow', () => {
+  test('pulls a window left over from another document back inside it', () => {
+    expect(clampWindow({ start: 9_000, end: 9_500 }, 40)).toEqual({ start: 39, end: 40 });
+    expect(clampWindow({ start: -5, end: 10 }, 40)).toEqual({ start: 0, end: 10 });
+  });
+
+  test('never returns an empty range', () => {
+    expect(clampWindow({ start: 5, end: 5 }, 40).end).toBeGreaterThan(5);
+  });
+});
+
+describe('windowSpace', () => {
+  test('reserves exactly the height of the lines outside the window', () => {
+    const geometry = uniformGeometry(ROW, 100);
+    const space = windowSpace(geometry, { start: 10, end: 30 });
+    expect(space).toEqual({ top: 10 * ROW, bottom: 70 * ROW, breakAtEnd: false });
+    expect(space.top + space.bottom + (30 - 10) * ROW).toBe(geometry.totalHeight);
+  });
+
+  test('flags a window that reaches the last line', () => {
+    const geometry = uniformGeometry(ROW, 100);
+    expect(windowSpace(geometry, { start: 90, end: 100 }).breakAtEnd).toBe(true);
+  });
+});
+
+describe('codeWindow', () => {
+  test('clamps the range and spaces it in one step', () => {
+    const geometry = uniformGeometry(ROW, 50);
+    expect(codeWindow(geometry, { start: 0, end: 5_000 })).toEqual({
+      start: 0,
+      end: 50,
+      top: 0,
+      bottom: 0,
+      breakAtEnd: true,
+    });
+  });
+});