@adhdev/daemon-core 0.9.82-rc.48 → 0.9.82-rc.480

package/src/providers/sdk/v1/builders/cli/parse-approval.ts

@@ -0,0 +1,261 @@
+/**
+ * buildParseApprovalFromTui
+ *
+ * Turns a `tui/modal@1` block into a runtime
+ * `(input: CliApprovalInput) => CliApprovalModal | null` function.
+ *
+ * Contract rules enforced (sprint-2026-06):
+ *   - Returns null when the question pattern is not visible.
+ *   - Returns null when the button list is empty or shorter than minButtons.
+ *   - Button labels are raw text; never rewritten (e.g. "Yes, and don't ask
+ *     again for X" stays verbatim).
+ *   - Modal scope respects between-last-two-separators / window-around-question
+ *     / whole-screen to avoid false-positives from numbered lists in
+ *     assistant prose.
+ */
+
+import type {
+  CliApprovalInput,
+  CliApprovalModal,
+  CliParseApprovalFn,
+} from '../../types/cli/index.js';
+import {
+  applyVisibleRegion,
+  type VisibleRegionSpec,
+} from './visible-region.js';
+
+// ─── Spec shapes ───────────────────────────────────────────────────────
+
+interface ModalQuestionVariant {
+  regex: string;
+  flags?: string;
+  label?: string;
+}
+
+interface ModalContextHeader {
+  regex: string;
+  flags?: string;
+}
+
+export interface ModalTuiSpec {
+  $schema: 'adhdev:tui/modal@1';
+  questionPattern: string;
+  questionFlags?: string;
+  questionVariants?: ModalQuestionVariant[];
+  buttonPattern: string;
+  buttonFlags?: string;
+  buttonLabelGroup?: number;
+  /**
+   * Optional fallback for terminals that render all options on a single line
+   * (e.g. Antigravity feedback survey: `[0] skip [1] yes [2] no [3] still using`).
+   * When per-line button extraction collects fewer than `minButtons`, the
+   * builder makes a second pass with this regex (global match, capture group 1
+   * is the label).
+   */
+  inlineButtonPattern?: string;
+  inlineButtonFlags?: string;
+  scope?: 'between-last-two-separators' | 'window-around-question' | 'whole-screen';
+  scopeWindowLines?: number;
+  contextHeader?: ModalContextHeader;
+  continuationLines?: boolean;
+  minButtons?: number;
+}
+
+// ─── Helpers ───────────────────────────────────────────────────────────
+
+// A horizontal rule line. Covers solid box-drawing rules (─ ━ ═) AND the dashed
+// variants (╌ ╍ ┄ ┅ ┈ ┉) that Claude Code draws as the INNER separators around a
+// Write/Edit diff body. This matches the coverage of the claude-cli v4 FSM spec
+// anchor `^[─╌]+$` (issue #137) so the SDK-v1 parser recognizes the same modal
+// frames the FSM does — a dashed rule is a separator, not modal content.
+const SEPARATOR_RE = /^[─━═╌╍┄┅┈┉]{10,}\s*$/;
+
+function compile(re: string, flags?: string): RegExp {
+  try {
+    return new RegExp(re, flags);
+  } catch (e) {
+    throw new Error(`Invalid regex /${re}/${flags ?? ''}: ${(e as Error).message}`);
+  }
+}
+
+function findQuestionLineIndex(
+  spec: ModalTuiSpec,
+  lines: string[],
+): { index: number; matchedSource: 'primary' | string } | null {
+  const primary = compile(spec.questionPattern, spec.questionFlags ?? 'i');
+  // Search bottom-up to prefer the most recent modal.
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (primary.test(lines[i])) return { index: i, matchedSource: 'primary' };
+  }
+  for (const variant of spec.questionVariants ?? []) {
+    const re = compile(variant.regex, variant.flags ?? 'i');
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      if (re.test(lines[i])) return { index: i, matchedSource: variant.label ?? 'variant' };
+    }
+  }
+  return null;
+}
+
+function scopeLines(
+  spec: ModalTuiSpec,
+  lines: string[],
+  questionIndex: number,
+): { start: number; end: number } {
+  const scope = spec.scope ?? 'between-last-two-separators';
+  if (scope === 'whole-screen') {
+    return { start: 0, end: lines.length };
+  }
+  if (scope === 'window-around-question') {
+    const window = spec.scopeWindowLines ?? 16;
+    return {
+      start: Math.max(0, questionIndex - 2),
+      end: Math.min(lines.length, questionIndex + window),
+    };
+  }
+  // between-last-two-separators
+  let lastSep = -1;
+  let prevSep = -1;
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (SEPARATOR_RE.test(lines[i].trim())) {
+      if (lastSep < 0) lastSep = i;
+      else if (prevSep < 0) {
+        prevSep = i;
+        break;
+      }
+    }
+  }
+  // Only scope to the separator frame when it actually BRACKETS the question
+  // line. Claude Write/Edit modals draw dashed (╌) inner rules around the diff
+  // body, so the last two separators can enclose the file diff while the
+  // question + button block sit BELOW the lower dashed rule. Scoping to that
+  // inner frame would drop every button (→ null → missed auto-approve, #137).
+  // When the question is outside the frame, fall through to a window around it.
+  if (lastSep >= 0 && prevSep >= 0 && questionIndex >= prevSep && questionIndex < lastSep + 1) {
+    return { start: prevSep, end: lastSep + 1 };
+  }
+  // Fallback: window around question line.
+  return {
+    start: Math.max(0, questionIndex - 4),
+    end: Math.min(lines.length, questionIndex + 16),
+  };
+}
+
+function extractButtons(
+  spec: ModalTuiSpec,
+  lines: string[],
+  windowStart: number,
+  windowEnd: number,
+): string[] {
+  const buttonRe = compile(spec.buttonPattern, spec.buttonFlags ?? 'm');
+  const out: string[] = [];
+  const labelGroup = Number.isInteger(spec.buttonLabelGroup) && (spec.buttonLabelGroup ?? 0) > 0
+    ? spec.buttonLabelGroup!
+    : 1;
+  let i = windowStart;
+  while (i < windowEnd) {
+    const line = lines[i];
+    const m = buttonRe.exec(line);
+    const captured = m?.[labelGroup] ?? (labelGroup === 1 && m && m.length > 2 ? m[m.length - 1] : undefined);
+    if (m && captured) {
+      let label = captured.trim();
+      // Continuation lines: when enabled, append indented lines below until
+      // the next button or blank.
+      if (spec.continuationLines) {
+        let j = i + 1;
+        while (j < windowEnd) {
+          const next = lines[j];
+          if (!next.trim()) break;
+          if (buttonRe.test(next)) break;
+          // continuation must be indented (not at column 0 like a new section).
+          if (!/^\s+/.test(next)) break;
+          label += ' ' + next.trim();
+          j += 1;
+        }
+        i = j;
+      } else {
+        i += 1;
+      }
+      out.push(label);
+    } else {
+      i += 1;
+    }
+  }
+  return out;
+}
+
+function buildMessage(
+  spec: ModalTuiSpec,
+  lines: string[],
+  questionIndex: number,
+  windowStart: number,
+  windowEnd: number,
+): string {
+  const messageParts: string[] = [];
+  if (spec.contextHeader) {
+    const ctxRe = compile(spec.contextHeader.regex, (spec.contextHeader.flags ?? 'i') + 'm');
+    const haystack = lines.slice(windowStart, windowEnd).join('\n');
+    const m = ctxRe.exec(haystack);
+    if (m) messageParts.push(m[1] ? m[1].trim() : m[0].trim());
+  }
+  messageParts.push(lines[questionIndex].trim());
+  return messageParts.filter(Boolean).join(' — ');
+}
+
+// ─── Public builder ────────────────────────────────────────────────────
+
+function extractInlineButtons(
+  spec: ModalTuiSpec,
+  lines: string[],
+  windowStart: number,
+  windowEnd: number,
+): string[] {
+  if (!spec.inlineButtonPattern) return [];
+  // Always force the `g` flag so we can iterate all matches in the line.
+  const declaredFlags = spec.inlineButtonFlags ?? 'gi';
+  const flags = declaredFlags.includes('g') ? declaredFlags : declaredFlags + 'g';
+  const re = compile(spec.inlineButtonPattern, flags);
+  const out: string[] = [];
+  for (let i = windowStart; i < windowEnd; i += 1) {
+    let m: RegExpExecArray | null;
+    re.lastIndex = 0;
+    while ((m = re.exec(lines[i])) !== null) {
+      const label = (m[1] ?? m[0]).trim();
+      if (label && !out.includes(label)) out.push(label);
+      if (m.index === re.lastIndex) re.lastIndex += 1; // safety against zero-width matches
+    }
+  }
+  return out;
+}
+
+export function buildParseApprovalFromTui(
+  spec: ModalTuiSpec,
+  visibleRegion?: VisibleRegionSpec,
+): CliParseApprovalFn {
+  const minButtons = spec.minButtons ?? 2;
+
+  return function parseApproval(input: CliApprovalInput): CliApprovalModal | null {
+    const rawText = input.screenText ?? input.buffer ?? '';
+    if (!rawText) return null;
+    const text = visibleRegion ? applyVisibleRegion(visibleRegion, rawText) : rawText;
+    const lines = text.split('\n');
+    const question = findQuestionLineIndex(spec, lines);
+    if (!question) return null;
+    const { start, end } = scopeLines(spec, lines, question.index);
+    if (question.index < start || question.index >= end) return null;
+    let buttons = extractButtons(spec, lines, question.index + 1, end);
+    // Inline fallback: when per-line extraction came up short, the terminal
+    // may have rendered every option on the same line ("[0] skip [1] yes …").
+    if (buttons.length < minButtons && spec.inlineButtonPattern) {
+      buttons = extractInlineButtons(spec, lines, question.index, end);
+    }
+    if (buttons.length < minButtons) return null;
+    const message = buildMessage(spec, lines, question.index, start, end);
+    return { message, buttons };
+  };
+}
+
+export const __internal = {
+  findQuestionLineIndex,
+  scopeLines,
+  extractButtons,
+};

package/src/providers/sdk/v1/builders/cli/parse-session.ts

@@ -0,0 +1,276 @@
+/**
+ * buildParseSessionFromTui — synthesize a parseSession function from the
+ * manifest tui block alone.
+ *
+ * Composition:
+ *   1. detectStatus from tui.spinner/modal/settledPrompt/dispatchOrder
+ *      (delegated to buildDetectStatusFromTui)
+ *   2. parseApproval from tui.modal (delegated to buildParseApprovalFromTui)
+ *   3. message extraction from tui.transcriptPty (this file)
+ *
+ * The result has the same shape as the legacy parse_output:
+ *   { status, messages, activeModal, transcriptAuthority?, coverage?, providerSessionId? }
+ *
+ * Identity stamping (providerUnitKey, bubbleId, sequence, bubbleState) is
+ * applied by the caller, mirroring _shared/parse_session.js. We export the
+ * stamper as `normalizeMessageIdentity` for reuse.
+ */
+
+import { buildDetectStatusFromTui, type DetectStatusTuiSpec } from './detect-status.js'
+import { buildParseApprovalFromTui, type ModalTuiSpec } from './parse-approval.js'
+import * as crypto from 'node:crypto'
+
+// ─── Schema types ────────────────────────────────
+
+export interface PrefixSpec {
+    regex: string
+    flags?: string
+}
+
+export interface ToolPrefixSpec extends PrefixSpec {
+    skip?: boolean
+}
+
+export interface ChromePatternSpec {
+    regex: string
+    flags?: string
+    label?: string
+}
+
+export interface TranscriptPtySpec {
+    $schema?: 'adhdev:tui/transcript-pty@1'
+    assistantPrefix: PrefixSpec
+    userPrefix?: PrefixSpec
+    toolPrefix?: ToolPrefixSpec
+    continuationLine?: { indented?: boolean }
+    chromePatterns?: ChromePatternSpec[]
+    stripLeadingChrome?: boolean
+    scope?: 'screen' | 'buffer' | 'tail'
+}
+
+export interface SessionIdExtractionSpec {
+    $schema?: 'adhdev:tui/session-id-extraction@1'
+    regex: string
+    flags?: string
+    scope?: 'screen' | 'tail' | 'buffer'
+    label?: string
+}
+
+export interface ParseSessionTuiSpec {
+    spinner?: any
+    settledPrompt?: any
+    modal?: ModalTuiSpec
+    dispatchOrder?: any
+    transcriptPty: TranscriptPtySpec
+    sessionIdExtraction?: SessionIdExtractionSpec
+}
+
+// ─── Output shape ────────────────────────────────
+
+export interface SynthesizedMessage {
+    role: 'user' | 'assistant'
+    kind?: 'standard' | 'tool'
+    content: string
+    receivedAt?: number
+}
+
+export interface SynthesizedSession {
+    status: string | null
+    messages: SynthesizedMessage[]
+    activeModal: { message: string; buttons: string[] } | null
+    modal: { message: string; buttons: string[] } | null
+    parsedStatus: string | null
+    transcriptAuthority?: 'provider' | 'daemon'
+    coverage?: 'full' | 'tail' | 'current-turn'
+    providerSessionId?: string
+}
+
+// ─── ANSI / line helpers ─────────────────────────
+
+const ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g
+const OSC_RE = /\x1b\][^\x07\x1b\n]*(?:\x07|\x1b\\|(?=\n|$))/g
+
+function stripAnsi(text: string): string {
+    return String(text || '')
+        .replace(/\x1b\[(\d*)C/g, (_m, n) => ' '.repeat(Math.max(1, Number(n) || 1)))
+        .replace(/\x1b\[\d*D/g, '')
+        .replace(ANSI_RE, '')
+        .replace(OSC_RE, '')
+        .replace(/\x1b[P^_X][\s\S]*?(?:\x07|\x1b\\)/g, '')
+        .replace(/\x1b(?:[@-Z\\-_])/g, '')
+}
+
+function splitLines(text: string): string[] {
+    return stripAnsi(text)
+        .replace(//g, '')
+        .split(/\r?\n/)
+        .map(l => l.replace(/\s+$/, ''))
+}
+
+function pickInputText(input: any, scope: TranscriptPtySpec['scope']): string {
+    if (!input) return ''
+    if (scope === 'screen') return String(input.screenText || input.screen?.text || '')
+    if (scope === 'tail') return String(input.tail || input.recentBuffer || input.buffer || '')
+    return String(input.buffer || input.rawBuffer || input.screenText || '')
+}
+
+// ─── Identity stamping (mirrors _shared/parse_session.js) ─────
+
+function stableHash(value: string): string {
+    return crypto.createHash('sha1').update(String(value || '')).digest('hex').slice(0, 12)
+}
+
+export function normalizeMessageIdentity<T extends { role?: string; kind?: string; content?: string }>(
+    messages: T[],
+    status: string,
+): Array<T & {
+    providerUnitKey: string
+    bubbleId: string
+    sequence: number
+    _turnKey: string
+    bubbleState: 'streaming' | 'final'
+}> {
+    const list = Array.isArray(messages) ? messages : []
+    let turnIndex = -1
+    return list.map((message, index) => {
+        const role = message?.role || 'assistant'
+        const kind = message?.kind || 'standard'
+        const content = typeof message?.content === 'string' ? message.content : ''
+        if (role === 'user' || turnIndex < 0) turnIndex += 1
+        const seed = [role, kind, '', index, content].join('\n')
+        const providerUnitKey = `v2-pty:${role}:${kind}:${index}:${stableHash(seed)}`
+        const bubbleId = `bubble:${providerUnitKey}`
+        const turnKey = `turn:${turnIndex}`
+        const isStreamingTail = status === 'generating' && role === 'assistant' && index === list.length - 1
+        return {
+            ...message,
+            providerUnitKey,
+            bubbleId,
+            sequence: index,
+            _turnKey: turnKey,
+            bubbleState: isStreamingTail ? 'streaming' as const : 'final' as const,
+        }
+    })
+}
+
+// ─── Main builder ────────────────────────────────
+
+export function buildParseSessionFromTui(spec: ParseSessionTuiSpec): (input: any) => SynthesizedSession {
+    if (!spec.transcriptPty) {
+        throw new Error('buildParseSessionFromTui: spec.transcriptPty is required')
+    }
+
+    // Compile regexes once
+    const assistantRe = new RegExp(spec.transcriptPty.assistantPrefix.regex, spec.transcriptPty.assistantPrefix.flags || '')
+    const userRe = spec.transcriptPty.userPrefix
+        ? new RegExp(spec.transcriptPty.userPrefix.regex, spec.transcriptPty.userPrefix.flags || '')
+        : null
+    const toolRe = spec.transcriptPty.toolPrefix
+        ? new RegExp(spec.transcriptPty.toolPrefix.regex, spec.transcriptPty.toolPrefix.flags || '')
+        : null
+    const toolSkip = spec.transcriptPty.toolPrefix?.skip ?? false
+    const chromeRes = (spec.transcriptPty.chromePatterns || []).map(p =>
+        new RegExp(p.regex, p.flags || ''))
+    const requireIndentForContinuation = spec.transcriptPty.continuationLine?.indented ?? false
+    const stripLeadingChrome = spec.transcriptPty.stripLeadingChrome ?? true
+    const scope = spec.transcriptPty.scope ?? 'buffer'
+
+    // Compose detect + approval helpers if their inputs are present.
+    const detectStatus = (spec.spinner || spec.settledPrompt || spec.modal || spec.dispatchOrder)
+        ? buildDetectStatusFromTui({
+            spinner: spec.spinner,
+            settledPrompt: spec.settledPrompt,
+            modal: spec.modal,
+            dispatchOrder: spec.dispatchOrder,
+        })
+        : () => null
+    const parseApproval = spec.modal ? buildParseApprovalFromTui(spec.modal) : () => null
+
+    // Optional session-id extraction (tui/session-id-extraction@1). Compile once
+    // so each parseSession call is a single regex.exec on the chosen scope.
+    const sessionIdRe = spec.sessionIdExtraction
+        ? new RegExp(
+            spec.sessionIdExtraction.regex,
+            spec.sessionIdExtraction.flags ?? 'i',
+        )
+        : null
+    const sessionIdScope: TranscriptPtySpec['scope'] = spec.sessionIdExtraction?.scope ?? 'tail'
+
+    return function parseSession(input: any): SynthesizedSession {
+        // status + modal first
+        const status = detectStatus(input as any) ?? 'idle'
+        const modal = parseApproval(input as any)
+
+        const text = pickInputText(input, scope)
+        const lines = splitLines(text)
+
+        const messages: SynthesizedMessage[] = []
+        let seenFirstRoleLine = !stripLeadingChrome
+
+        for (const raw of lines) {
+            const line = raw
+            if (line.trim() === '') {
+                // Blank line: ends streaming continuation but doesn't add a message.
+                continue
+            }
+
+            // Chrome filter
+            let isChrome = false
+            for (const cre of chromeRes) {
+                if (cre.test(line)) { isChrome = true; break }
+            }
+            if (isChrome) continue
+
+            // Role detection
+            const userMatch = userRe ? line.match(userRe) : null
+            const toolMatch = toolRe ? line.match(toolRe) : null
+            const assistMatch = line.match(assistantRe)
+
+            if (userMatch) {
+                seenFirstRoleLine = true
+                const content = (userMatch[1] ?? userMatch[0]).trim()
+                if (content) messages.push({ role: 'user', kind: 'standard', content })
+                continue
+            }
+            if (toolMatch) {
+                seenFirstRoleLine = true
+                if (toolSkip) continue
+                const content = (toolMatch[1] ?? toolMatch[0]).trim()
+                if (content) messages.push({ role: 'assistant', kind: 'tool', content })
+                continue
+            }
+            if (assistMatch) {
+                seenFirstRoleLine = true
+                const content = (assistMatch[1] ?? assistMatch[0]).trim()
+                if (content) messages.push({ role: 'assistant', kind: 'standard', content })
+                continue
+            }
+
+            if (!seenFirstRoleLine) continue
+
+            // Continuation rule
+            if (requireIndentForContinuation && !/^\s/.test(line)) continue
+            const last = messages[messages.length - 1]
+            if (!last) continue
+            const cont = line.replace(/^\s+/, '')
+            if (cont) last.content = last.content ? `${last.content}\n${cont}` : cont
+        }
+
+        const result: SynthesizedSession = {
+            status,
+            messages,
+            activeModal: modal,
+            modal,
+            parsedStatus: status,
+        }
+
+        if (sessionIdRe) {
+            const haystack = stripAnsi(pickInputText(input, sessionIdScope))
+            const match = haystack.match(sessionIdRe)
+            const captured = match?.[1]?.trim()
+            if (captured) result.providerSessionId = captured
+        }
+
+        return result
+    }
+}

package/src/providers/sdk/v1/builders/cli/visible-region.ts

@@ -0,0 +1,143 @@
+/**
+ * applyVisibleRegion
+ *
+ * Scopes the raw terminal text to the "visible region" declared by a
+ * `tui/visible-region@1` spec before handing it to detect-status and
+ * parse-approval matchers.
+ *
+ * Scope semantics:
+ *   screen   → full text unchanged  (daemon already passes rendered screen)
+ *   buffer   → full text unchanged
+ *   tail     → last `tailChars` characters (default 4000)
+ *   between-anchors → text between most recent (or first) top/bottom anchor
+ *                     regex matches; falls back to full text if anchors not found
+ *
+ * selectAnchor:
+ *   "last"  → use the LAST occurrence of the top anchor — useful for providers
+ *             like Antigravity that redraw a separator + prompt on every turn;
+ *             this excludes all scrollback above the current session frame.
+ *   "first" → use the FIRST occurrence (default per schema).
+ */
+
+// ─── Spec shape (mirrors tui-visible-region-v1.json) ───────────────────
+
+interface AnchorPatternSpec {
+  pattern: string;
+  flags?: string;
+}
+
+interface AnchorsSpec {
+  top?: AnchorPatternSpec;
+  bottom?: AnchorPatternSpec;
+}
+
+export interface VisibleRegionSpec {
+  $schema?: 'adhdev:tui/visible-region@1';
+  scope: 'screen' | 'tail' | 'buffer' | 'between-anchors';
+  tailChars?: number;
+  anchors?: AnchorsSpec;
+  selectAnchor?: 'first' | 'last';
+  stripCues?: string[];
+}
+
+// ─── Helpers ───────────────────────────────────────────────────────────
+
+function compile(re: string, flags?: string): RegExp {
+  try {
+    return new RegExp(re, flags ?? '');
+  } catch (e) {
+    throw new Error(`Invalid visible-region anchor regex /${re}/${flags ?? ''}: ${(e as Error).message}`);
+  }
+}
+
+/**
+ * Find all non-overlapping matches of `re` in `text`.
+ * Returns them in order of occurrence (earliest first).
+ */
+function findAllMatches(re: RegExp, text: string): RegExpExecArray[] {
+  const results: RegExpExecArray[] = [];
+  // Operate on a non-global copy with sticky-safe iteration to avoid
+  // mutating the caller's RegExp state.
+  const iter = new RegExp(re.source, re.flags.replace('g', '') + 'g');
+  let m: RegExpExecArray | null;
+  while ((m = iter.exec(text)) !== null) {
+    results.push(m);
+    // Advance past zero-width matches to prevent infinite loop.
+    if (m[0].length === 0) iter.lastIndex += 1;
+  }
+  return results;
+}
+
+// ─── Public API ────────────────────────────────────────────────────────
+
+/**
+ * Apply the visible-region spec to `text` and return the scoped substring.
+ * Never throws on missing anchors — falls back to the full text instead.
+ */
+export function applyVisibleRegion(spec: VisibleRegionSpec, text: string): string {
+  if (!text) return text;
+
+  switch (spec.scope) {
+    case 'screen':
+    case 'buffer':
+      return text;
+
+    case 'tail': {
+      const limit = spec.tailChars ?? 4000;
+      if (text.length <= limit) return text;
+      return text.slice(-limit);
+    }
+
+    case 'between-anchors': {
+      const anchors = spec.anchors;
+      if (!anchors?.top && !anchors?.bottom) return text;
+
+      const selectLast = (spec.selectAnchor ?? 'first') === 'last';
+
+      // ── Top anchor ──
+      let topEnd = 0; // default: start of text
+      if (anchors.top) {
+        const topRe = compile(anchors.top.pattern, anchors.top.flags);
+        const topMatches = findAllMatches(topRe, text);
+        if (topMatches.length === 0) {
+          // Top anchor not found — fall back to full text.
+          return text;
+        }
+        const chosen = selectLast
+          ? topMatches[topMatches.length - 1]
+          : topMatches[0];
+        // Region starts just after the end of the top anchor match.
+        topEnd = chosen.index + chosen[0].length;
+      }
+
+      // ── Bottom anchor ──
+      let bottomStart = text.length; // default: end of text
+      if (anchors.bottom) {
+        const bottomRe = compile(anchors.bottom.pattern, anchors.bottom.flags);
+        // Only search the portion that comes AFTER the top anchor end so we
+        // always pick the immediately-following bottom anchor.
+        const searchFrom = topEnd;
+        const suffix = text.slice(searchFrom);
+        const bottomMatches = findAllMatches(bottomRe, suffix);
+        if (bottomMatches.length === 0) {
+          // Bottom anchor not found — fall back to full text.
+          return text;
+        }
+        const chosen = selectLast
+          ? bottomMatches[bottomMatches.length - 1]
+          : bottomMatches[0];
+        bottomStart = searchFrom + chosen.index;
+      }
+
+      if (topEnd >= bottomStart) {
+        // Degenerate / overlapping anchors — fall back to full text.
+        return text;
+      }
+
+      return text.slice(topEnd, bottomStart);
+    }
+
+    default:
+      return text;
+  }
+}