@ponythewhite/base-context 1.0.6 → 1.0.8

package/dist/core/selective-recovery.js

@@ -1,10 +1,13 @@
+import { randomUUID } from "node:crypto";
 import { StringEnum } from "@ponythewhite/base-context-ai";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { AGENT_RESULT_CUSTOM_TYPE } from "./agent-results.js";
 import { stringifyBoundedJson } from "./bounded-json.js";
+import { decodedTextWindow, PUBLIC_TEXT_WINDOW_BYTES, readRetainedToolOutput, retainedToolOutput, } from "./retained-tool-output.js";
 import { SELECTED_SKILL_CUSTOM_TYPE, selectedSkillCapture } from "./selected-skills.js";
 import { hydrateCapturedHistoryEntry } from "./session-history-index.js";
+import { getSessionArtifactPathForFile } from "./session-manager.js";
 import { projectTaskStateSource } from "./task-state.js";
 /** Defaults match bounded index pages and 64KiB payload parts; all admission units are bytes or items. */
 export const DEFAULT_NATIVE_RECOVERY_LIMITS = Object.freeze({
@@ -18,6 +21,9 @@ const byteLimit = Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER })
 const operationSchema = Type.Object({
     action: Type.Union([Type.Literal("read"), Type.Literal("search"), Type.Literal("recover")]),
     ref: Type.Optional(exactString),
+    cursor: Type.Optional(exactString),
+    startByte: Type.Optional(Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER })),
+    endByte: Type.Optional(byteLimit),
     revision: Type.Optional(exactString),
     sourceSessionId: Type.Optional(exactString),
     field: Type.Optional(exactString),
@@ -234,6 +240,10 @@ function assemble(scope, results) {
             field: record.field,
             startLine: record.startLine,
             endLine: record.endLine,
+            startByte: record.startByte,
+            endByte: record.endByte,
+            prefixOmitted: record.prefixOmitted,
+            suffixOmitted: record.suffixOmitted,
         }))),
     };
 }
@@ -250,15 +260,41 @@ export function parseNativeRecoveryInput(value) {
         throw new Error("Invalid native recovery request");
     return request;
 }
+/** Session-owned, ephemeral searches. No read lease or canonical body survives a call. */
+export class NativeRecoveryCursorStore {
+    states = new Map();
+    generation = 0;
+    clear() {
+        this.states.clear();
+        this.generation++;
+    }
+    get(id) {
+        return this.states.get(id);
+    }
+    delete(id) {
+        this.states.delete(id);
+    }
+    get version() {
+        return this.generation;
+    }
+    save(state, version, id = randomUUID()) {
+        if (version !== this.generation)
+            throw new Error("Expired recovery cursor");
+        this.states.delete(id);
+        this.states.set(id, structuredClone(state));
+        while (this.states.size > 16)
+            this.states.delete(this.states.keys().next().value);
+        return id;
+    }
+}
 /** The caller captures ONE server branch before entering this service, including for a batch. */
-export async function recoverCapturedHistory(view, input, limits = DEFAULT_NATIVE_RECOVERY_LIMITS, signal) {
+export async function recoverCapturedHistory(view, input, limits = DEFAULT_NATIVE_RECOVERY_LIMITS, signal, cursors) {
     const cap = { ...limits };
     for (const key of ["maxBytes", "maxSourceBytes", "maxItems", "maxRequests"]) {
         if (!Number.isSafeInteger(cap[key]) || cap[key] < 1)
             throw new NativeRecoveryBudgetRefusal();
         cap[key] = Math.min(cap[key], DEFAULT_NATIVE_RECOVERY_LIMITS[key]);
     }
-    // Bound and detach input before schema traversal or the first await. Unknown selectors are rejected.
     let request;
     try {
         request = parseNativeRecoveryInput(input);
@@ -267,6 +303,24 @@ export async function recoverCapturedHistory(view, input, limits = DEFAULT_NATIV
         return createNativeRecoveryRefusal(error instanceof NativeRecoveryBudgetRefusal ? "budget_refused" : "unavailable", "invalid_request", cap.maxBytes);
     }
     const maxBytes = Math.min(cap.maxBytes, request.maxBytes ?? cap.maxBytes);
+    if (request.action === "skill")
+        return createNativeRecoveryRefusal("not_authorized", "native_skill_selection_owner_required", maxBytes);
+    const operations = request.action === "batch" ? request.requests : [request];
+    const version = cursors?.version ?? 0;
+    const resumed = operations.map((operation) => (operation.cursor ? cursors?.get(operation.cursor) : undefined));
+    const anchor = resumed.find(Boolean)?.source;
+    if (anchor) {
+        if (resumed.some((state) => state && JSON.stringify(state.source) !== JSON.stringify(anchor)))
+            return createNativeRecoveryRefusal("unavailable", "conflicting_selection", maxBytes);
+        try {
+            if (!view.atSnapshot)
+                throw new Error("Captured source is unavailable");
+            view = await view.atSnapshot(anchor);
+        }
+        catch {
+            return createNativeRecoveryRefusal("unavailable", "cursor_source_unavailable", maxBytes);
+        }
+    }
     const { sessionId: sourceSessionId, leafId, sourceSequence } = view.source;
     const scope = {
         kind: "branch",
@@ -275,11 +329,7 @@ export async function recoverCapturedHistory(view, input, limits = DEFAULT_NATIV
         leafId,
         sourceSequence,
     };
-    if (request.action === "skill")
-        return createNativeRecoveryRefusal("not_authorized", "native_skill_selection_owner_required", maxBytes);
-    const operations = request.action === "batch" ? request.requests : [request];
     const results = operations.map((_, i) => outcome(i, "budget_refused", "unknown", [], "not_admitted"));
-    // Reserve an explicit result for EVERY requested operation before touching canonical payloads.
     stringifyNativeRecoveryResponse(assemble(scope, results), maxBytes);
     if (operations.length > cap.maxRequests)
         return assemble(scope, results);
@@ -293,14 +343,10 @@ export async function recoverCapturedHistory(view, input, limits = DEFAULT_NATIV
         if (cached && cached.revision !== metadata.revision)
             throw new Error("Captured revision changed");
         if (!cached) {
-            if (++examined > cap.maxItems || metadata.locator.length > cap.maxSourceBytes - sourceBytes) {
+            if (metadata.locator.length > cap.maxSourceBytes - sourceBytes)
                 throw new NativeRecoveryBudgetRefusal();
-            }
             sourceBytes += metadata.locator.length;
-            const hydrated = await hydrateCapturedHistoryEntry(metadata, metadata.locator.length, async (id, options) => {
-                signal?.throwIfAborted();
-                return view.readPayload(id, options);
-            });
+            const hydrated = await hydrateCapturedHistoryEntry(metadata, metadata.locator.length, (id, options) => view.readPayload(id, options));
             signal?.throwIfAborted();
             cached = { revision: metadata.revision, entry: hydrated.entry };
             cache.set(metadata.id, cached);
@@ -310,8 +356,6 @@ export async function recoverCapturedHistory(view, input, limits = DEFAULT_NATIV
                 metadata.qualification !== "native-admission" ||
                 metadata.retention === "retained-import")
                 return undefined;
-            // Reuse the existing exact native-input qualification, not generic origin traversal.
-            // The first qualifying projection is submitted.text; return before visiting content parts.
             for (const projection of projectTaskStateSource({
                 sessionId: sourceSessionId,
                 sequence: metadata.sequence,
@@ -323,121 +367,396 @@ export async function recoverCapturedHistory(view, input, limits = DEFAULT_NATIV
                 if (projection.source.field === requestedField &&
                     projection.authority === "user" &&
                     projection.attribution === "source-backed" &&
-                    typeof projection.text === "string") {
+                    typeof projection.text === "string")
                     return [{ field: requestedField, text: projection.text }];
-                }
                 return undefined;
             }
             return undefined;
         }
-        return publicFields(cached.entry, cap.maxItems, metadata.qualification);
+        const fields = publicFields(cached.entry, DEFAULT_NATIVE_RECOVERY_LIMITS.maxItems, metadata.qualification);
+        if (cached.entry.type === "message") {
+            const message = object(cached.entry.message);
+            const retained = message?.role === "toolResult" ? retainedToolOutput(object(message.details)?.retainedOutput) : undefined;
+            const field = fields?.find((field) => field.field === retained?.field);
+            if (field && retained) {
+                if (metadata.qualification === "native-tool-execution" && metadata.retention !== "retained-import")
+                    field.retained = retained;
+                else
+                    field.unavailable = true; // A preview is not the complete retained field, nor artifact authority.
+            }
+        }
+        return fields;
     }
-    async function recover(operation, i) {
-        if (operation.sourceSessionId !== undefined && operation.sourceSessionId !== scope.sourceSessionId) {
+    async function recover(supplied, i) {
+        const saved = resumed[i];
+        if (supplied.cursor && !saved)
+            return outcome(i, "unavailable", "unknown", [], "expired_cursor");
+        if (saved && supplied.action === "read")
+            return outcome(i, "unavailable", "unknown", [], "conflicting_selection");
+        const operation = saved ? { ...saved.operation, maxBytes: supplied.maxBytes } : supplied;
+        const needle = operation.need ?? operation.query;
+        if (saved &&
+            Object.entries(supplied).some(([key, value]) => !["action", "cursor", "maxBytes"].includes(key) &&
+                value !==
+                    (key === "need" || key === "query" ? needle : saved.operation[key])))
+            return outcome(i, "unavailable", "unknown", [], "conflicting_selection");
+        if (operation.sourceSessionId !== undefined && operation.sourceSessionId !== sourceSessionId)
             return outcome(i, "not_authorized", "unknown", [], "source_not_in_capture");
-        }
         if ((operation.need !== undefined && operation.query !== undefined && operation.need !== operation.query) ||
-            (operation.endLine !== undefined && operation.endLine < (operation.startLine ?? 1))) {
+            (operation.endLine !== undefined && operation.endLine < (operation.startLine ?? 1)) ||
+            (operation.endByte !== undefined && operation.endByte <= (operation.startByte ?? 0)) ||
+            ((operation.startByte !== undefined || operation.endByte !== undefined) &&
+                (operation.startLine !== undefined || operation.endLine !== undefined)))
             return outcome(i, "unavailable", "unknown", [], "conflicting_selection");
-        }
-        const needle = operation.need ?? operation.query;
-        let candidates;
-        let coverage;
-        if (operation.ref !== undefined) {
-            const metadata = await view.get(operation.ref);
-            if (!metadata || metadata.id !== operation.ref) {
-                return outcome(i, "not_authorized", "unknown", [], "ref_not_in_captured_branch");
-            }
-            if (operation.revision !== undefined && operation.revision !== metadata.revision) {
-                return outcome(i, "unavailable", "unknown", [], "revision_mismatch");
-            }
-            candidates = [metadata];
-            coverage = "complete";
-        }
-        else {
-            if (operation.action === "read" ||
+        if (operation.ref === undefined &&
+            (operation.action === "read" ||
                 needle === undefined ||
                 operation.revision !== undefined ||
-                operation.field !== undefined ||
                 operation.startLine !== undefined ||
-                operation.endLine !== undefined) {
-                return outcome(i, "unavailable", "unknown", [], "exact_selection_requires_ref");
-            }
-            if (Buffer.byteLength(needle) > 8192)
-                throw new NativeRecoveryBudgetRefusal();
-            if (examined >= cap.maxItems)
-                throw new NativeRecoveryBudgetRefusal();
-            const page = await view.search(needle, cap.maxItems - examined);
-            candidates = page.events;
-            // Search indexes token conjunctions, including non-public strings. It is not an exhaustive
-            // literal-substring search even when its indexed text coverage is reported complete.
-            coverage =
-                page.coverage === "partial" || page.truncated || page.indexedThrough < sourceSequence
-                    ? "partial"
-                    : "unknown";
-        }
+                operation.endLine !== undefined ||
+                operation.startByte !== undefined ||
+                operation.endByte !== undefined))
+            return outcome(i, "unavailable", "unknown", [], "exact_selection_requires_ref");
+        if (needle !== undefined && Buffer.byteLength(needle) > 8192)
+            throw new NativeRecoveryBudgetRefusal();
+        const searching = needle !== undefined;
+        const continuable = operation.action !== "read" && searching;
+        const state = saved
+            ? structuredClone(saved)
+            : {
+                source: { ...view.source },
+                operation: { ...operation, cursor: undefined, maxBytes: undefined },
+                after: 0,
+                field: 0,
+                byte: 0,
+                line: 1,
+                overlap: "",
+                unavailable: false,
+                matched: false,
+            };
         const records = [];
-        let unavailable = false;
-        let beyondWindow = false;
-        let needWindow = false;
-        for (const metadata of candidates) {
-            const fields = await fieldsFor(metadata, operation.field);
-            if (!fields || (operation.field !== undefined && !fields.some((field) => field.field === operation.field))) {
-                unavailable = true;
-                continue;
+        let partialWindow = false;
+        let reason;
+        let exhausted = false;
+        let windows = 0;
+        const cursorId = supplied.cursor ?? randomUUID();
+        const progress = (complete) => ({
+            ...outcome(i, complete && !state.unavailable && !partialWindow
+                ? records.length || state.matched
+                    ? "found"
+                    : "complete-miss"
+                : "partial", complete && !state.unavailable && !partialWindow ? "complete" : "partial", records, reason),
+            ...(continuable ? { exhausted: complete, ...(!complete && cursors ? { cursor: cursorId } : {}) } : {}),
+        });
+        const reserve = () => {
+            const candidate = progress(false);
+            candidate.reason = "canonical_source_unavailable";
+            stringifyBoundedJson(candidate, Math.min(maxBytes, supplied.maxBytes ?? maxBytes));
+            const prospective = [...results];
+            prospective[i] = candidate;
+            stringifyNativeRecoveryResponse(assemble(scope, prospective), maxBytes);
+        };
+        reserve(); // Keep cursor/status space before examining any source material.
+        const admit = (record) => {
+            if (selectedItems + records.length >= cap.maxItems)
+                return false;
+            records.push(record);
+            try {
+                reserve();
+                return true;
             }
-            for (const selected of fields) {
-                if (operation.field !== undefined && operation.field !== selected.field)
+            catch {
+                records.pop();
+                return false;
+            }
+        };
+        const resetField = () => {
+            state.byte = 0;
+            state.line = 1;
+            state.overlap = "";
+        };
+        const nextEntry = (metadata) => {
+            state.after = metadata.sequence;
+            delete state.entryId;
+            state.field = 0;
+            resetField();
+        };
+        while (!exhausted) {
+            signal?.throwIfAborted();
+            if (examined >= cap.maxItems) {
+                reason = "scan_limit";
+                break;
+            }
+            let metadata;
+            let afterPage;
+            if (state.entryId || operation.ref) {
+                metadata = await view.get(state.entryId ?? operation.ref);
+                if (!metadata)
+                    return outcome(i, "not_authorized", "unknown", records, "ref_not_in_captured_branch");
+                if (operation.revision !== undefined && metadata.revision !== operation.revision)
+                    return outcome(i, "unavailable", "unknown", records, "revision_mismatch");
+            }
+            else {
+                const page = await view.page(state.after, 1, { scan: true });
+                if (page.coverage !== "complete" || page.indexedThrough < sourceSequence)
+                    state.unavailable = true;
+                metadata = page.events[0];
+                afterPage = page.nextAfter;
+                if (!metadata) {
+                    examined++;
+                    if (afterPage === null) {
+                        exhausted = true;
+                        break;
+                    }
+                    if (afterPage <= state.after)
+                        throw new Error("History scan did not advance");
+                    state.after = afterPage;
                     continue;
-                const lines = selected.text.split("\n");
-                let startLine = operation.startLine ?? 1;
-                let endLine = Math.min(operation.endLine ?? lines.length, lines.length);
-                if (needle !== undefined && operation.startLine === undefined && operation.endLine === undefined) {
-                    const first = selected.text.indexOf(needle);
-                    if (first < 0)
-                        continue;
-                    // Select whole exact lines containing the first literal occurrence, including every
-                    // line of a multiline needle. A required huge line is refused, never prefix-clipped.
-                    startLine = selected.text.slice(0, first).split("\n").length;
-                    endLine = startLine + needle.split("\n").length - 1;
-                    if (startLine > 1 || endLine < lines.length)
-                        needWindow = true;
                 }
-                if (startLine > lines.length)
+            }
+            examined++;
+            state.entryId = metadata.id;
+            if (!operation.ref &&
+                !["message", "custom_message", "compaction", "branch_summary", "custom"].includes(metadata.kind)) {
+                nextEntry(metadata);
+                continue;
+            }
+            if (metadata.locator.length > cap.maxSourceBytes) {
+                if (operation.action === "read")
+                    return outcome(i, operation.startByte !== undefined || operation.endByte !== undefined
+                        ? "unavailable"
+                        : "budget_refused", "unknown", [], "field_window_unsupported");
+                state.unavailable = true;
+                reason = "field_window_unsupported";
+                nextEntry(metadata);
+                if (operation.ref)
+                    exhausted = true;
+                continue;
+            }
+            if (!cache.has(metadata.id) && metadata.locator.length > cap.maxSourceBytes - sourceBytes) {
+                reason = "source_limit";
+                break;
+            }
+            let fields;
+            try {
+                fields = await fieldsFor(metadata, operation.field);
+            }
+            catch (error) {
+                state.unavailable = true;
+                reason =
+                    error instanceof NativeRecoveryBudgetRefusal
+                        ? "unsupported_public_shape"
+                        : "canonical_source_unavailable";
+                nextEntry(metadata);
+                if (operation.ref)
+                    exhausted = true;
+                continue;
+            }
+            if (!fields || (operation.field !== undefined && !fields.some((field) => field.field === operation.field))) {
+                if (operation.ref)
+                    return outcome(i, "unavailable", "unknown", records, "unsupported_public_field");
+                if (!fields)
+                    state.unavailable = true;
+                nextEntry(metadata);
+                continue;
+            }
+            let paused = false;
+            for (; state.field < fields.length; state.field++, resetField()) {
+                const field = fields[state.field];
+                if (operation.field !== undefined && field.field !== operation.field)
                     continue;
-                const text = lines.slice(startLine - 1, endLine).join("\n");
-                if (needle !== undefined && !text.includes(needle))
+                if (field.unavailable) {
+                    state.unavailable = true;
+                    reason = "retained_output_unavailable";
                     continue;
-                if (operation.endLine !== undefined && operation.endLine > lines.length)
-                    beyondWindow = true;
-                if (selectedItems + records.length >= cap.maxItems)
-                    throw new NativeRecoveryBudgetRefusal();
-                records.push({
-                    ref: metadata.id,
-                    revision: metadata.revision,
-                    sourceSessionId,
-                    kind: metadata.kind,
-                    field: selected.field,
-                    startLine,
-                    endLine,
-                    text,
-                });
+                }
+                const total = field.retained?.byteLength ?? Buffer.byteLength(field.text);
+                if (field.retained && !field.retained.captureComplete) {
+                    state.unavailable = true;
+                    reason = "capture_incomplete";
+                }
+                if (state.byte === 0 && operation.startByte !== undefined)
+                    state.byte = operation.startByte;
+                if (operation.endByte !== undefined && operation.endByte > total) {
+                    partialWindow = true;
+                    reason = "requested_end_beyond_source";
+                }
+                const byteSelection = operation.startByte !== undefined || operation.endByte !== undefined;
+                let readText = "";
+                let readStart = state.byte;
+                let readLine = byteSelection && state.byte > 0 ? undefined : state.line;
+                while (state.byte < total || (total === 0 && state.byte === 0)) {
+                    signal?.throwIfAborted();
+                    if (++windows > cap.maxItems) {
+                        paused = true;
+                        reason = "scan_limit";
+                        break;
+                    }
+                    const allowance = field.retained
+                        ? Math.min(PUBLIC_TEXT_WINDOW_BYTES, cap.maxSourceBytes - sourceBytes - 4)
+                        : PUBLIC_TEXT_WINDOW_BYTES;
+                    if (allowance < 4) {
+                        paused = true;
+                        reason = "source_limit";
+                        break;
+                    }
+                    const stop = Math.min(total, operation.endByte ?? total, state.byte + allowance);
+                    if (stop < state.byte)
+                        break;
+                    let window;
+                    try {
+                        if (field.retained) {
+                            if (!view.source.sessionFile)
+                                throw new Error("Retained output owner unavailable");
+                            const selected = await readRetainedToolOutput(getSessionArtifactPathForFile(view.source.sessionFile, sourceSessionId), field.retained, state.byte, stop - state.byte);
+                            sourceBytes += selected.sourceBytes;
+                            window = selected;
+                        }
+                        else
+                            window = decodedTextWindow(field.text, state.byte, stop);
+                    }
+                    catch {
+                        state.unavailable = true;
+                        reason = "retained_output_unavailable";
+                        break;
+                    }
+                    const startLine = state.line;
+                    const combined = state.overlap + window.text;
+                    const combinedStart = window.startByte - Buffer.byteLength(state.overlap);
+                    const combinedLine = startLine - (state.overlap.match(/\n/g)?.length ?? 0);
+                    let text = window.text;
+                    let startByte = window.startByte;
+                    let endByte = window.endByte;
+                    let recordLine = byteSelection && state.byte > 0 ? undefined : startLine;
+                    let selected = !searching;
+                    if (searching) {
+                        const lines = combined.split("\n");
+                        const skip = Math.max(0, (operation.startLine ?? 1) - combinedLine);
+                        const take = Math.min(lines.length, (operation.endLine ?? Infinity) - combinedLine + 1);
+                        const prefix = lines.slice(0, skip).join("\n") + (skip ? "\n" : "");
+                        const selectedText = lines.slice(skip, Math.max(skip, take)).join("\n");
+                        const localMatch = selectedText.indexOf(needle);
+                        const first = localMatch < 0 ? -1 : prefix.length + localMatch;
+                        selected = first >= 0;
+                        if (selected) {
+                            const start = Math.max(prefix.length, first === 0 ? 0 : combined.lastIndexOf("\n", first - 1) + 1);
+                            const newline = combined.indexOf("\n", first + needle.length);
+                            text = combined.slice(start, Math.min(prefix.length + selectedText.length, newline < 0 ? combined.length : newline));
+                            startByte = combinedStart + Buffer.byteLength(combined.slice(0, start));
+                            endByte = startByte + Buffer.byteLength(text);
+                            recordLine =
+                                byteSelection && (operation.startByte ?? 0) > 0
+                                    ? undefined
+                                    : combinedLine + (combined.slice(0, start).match(/\n/g)?.length ?? 0);
+                            if (Buffer.byteLength(text) > Math.max(Buffer.byteLength(needle) + 256, Math.floor(maxBytes / 8))) {
+                                const matchByte = Buffer.byteLength(combined.slice(start, first));
+                                const excerpt = decodedTextWindow(text, Math.max(0, matchByte - 128), matchByte + Buffer.byteLength(needle) + 128);
+                                if (recordLine !== undefined)
+                                    recordLine += decodedTextWindow(text, 0, excerpt.startByte).text.match(/\n/g)?.length ?? 0;
+                                text = excerpt.text;
+                                startByte += excerpt.startByte;
+                                endByte = startByte + Buffer.byteLength(text);
+                            }
+                        }
+                    }
+                    else if (!byteSelection) {
+                        const lines = text.split("\n");
+                        const skip = Math.max(0, (operation.startLine ?? 1) - startLine);
+                        const take = Math.min(lines.length, (operation.endLine ?? Infinity) - startLine + 1);
+                        selected = take > skip;
+                        if (selected) {
+                            const prefix = lines.slice(0, skip).join("\n") + (skip ? "\n" : "");
+                            startByte += Buffer.byteLength(prefix);
+                            text = lines.slice(skip, take).join("\n");
+                            endByte = startByte + Buffer.byteLength(text);
+                            recordLine = startLine + skip;
+                        }
+                    }
+                    if (selected) {
+                        if (!searching) {
+                            if (!readText) {
+                                readStart = startByte;
+                                readLine = recordLine;
+                            }
+                            readText += text;
+                            text = readText;
+                            startByte = readStart;
+                            recordLine = readLine;
+                        }
+                        const record = {
+                            ref: metadata.id,
+                            revision: metadata.revision,
+                            sourceSessionId,
+                            kind: metadata.kind,
+                            field: field.field,
+                            startByte,
+                            endByte,
+                            prefixOmitted: startByte > 0,
+                            suffixOmitted: endByte < total,
+                            ...(recordLine === undefined
+                                ? {}
+                                : { startLine: recordLine, endLine: recordLine + (text.match(/\n/g)?.length ?? 0) }),
+                            text,
+                        };
+                        const done = searching ||
+                            window.endByte >= total ||
+                            (operation.endByte !== undefined && stop >= operation.endByte) ||
+                            (operation.endLine !== undefined &&
+                                startLine + (window.text.match(/\n/g)?.length ?? 0) > operation.endLine);
+                        if (done) {
+                            if (operation.endLine !== undefined &&
+                                window.endByte >= total &&
+                                startLine + (window.text.match(/\n/g)?.length ?? 0) < operation.endLine) {
+                                partialWindow = true;
+                                reason = "requested_end_beyond_source";
+                            }
+                            if (!admit(record)) {
+                                paused = true;
+                                reason = "output_limit";
+                                break;
+                            }
+                            state.matched = true;
+                            if (searching && (startByte > 0 || endByte < total) && operation.ref) {
+                                partialWindow = true;
+                                reason = "need_window";
+                            }
+                            break;
+                        }
+                        if (Buffer.byteLength(readText) > maxBytes)
+                            throw new NativeRecoveryBudgetRefusal();
+                    }
+                    if (window.endByte <= state.byte ||
+                        window.endByte >= total ||
+                        (operation.endByte !== undefined && window.endByte >= operation.endByte))
+                        break;
+                    state.byte = window.endByte;
+                    state.line += window.text.match(/\n/g)?.length ?? 0;
+                    let tail = searching ? combined.slice(-needle.length - 2) : "";
+                    if (tail.charCodeAt(0) >= 0xdc00 && tail.charCodeAt(0) <= 0xdfff)
+                        tail = tail.slice(1);
+                    state.overlap = searching
+                        ? decodedTextWindow(tail, Math.max(0, Buffer.byteLength(tail) - Buffer.byteLength(needle) - 3)).text
+                        : "";
+                }
+                if (paused)
+                    break;
+            }
+            if (paused)
+                break;
+            nextEntry(metadata);
+            if (operation.ref || afterPage === null) {
+                exhausted = true;
+                break;
             }
         }
-        if (operation.ref !== undefined && unavailable)
-            return outcome(i, "unavailable", "unknown", [], "unsupported_public_field");
-        if (unavailable || beyondWindow || needWindow)
-            coverage = "partial";
-        const status = coverage === "complete" ? (records.length ? "found" : "complete-miss") : "partial";
-        return outcome(i, status, coverage, records, coverage === "unknown"
-            ? "candidate_search_not_exhaustive"
-            : unavailable
-                ? "unsupported_public_shape"
-                : beyondWindow
-                    ? "requested_end_beyond_source"
-                    : needWindow
-                        ? "need_window"
-                        : undefined);
+        signal?.throwIfAborted();
+        if (!exhausted && continuable && cursors)
+            cursors.save(state, version, cursorId);
+        else if (supplied.cursor && exhausted)
+            cursors?.delete(supplied.cursor);
+        if (!searching && !exhausted && records.length === 0)
+            return outcome(i, "budget_refused", "unknown", [], reason ?? "operation_budget");
+        return progress(exhausted);
     }
     for (let i = 0; i < operations.length; i++) {
         try {