@code-yeongyu/senpi 2026.11.15-2 → 2026.11.15-3

package/dist/core/tools/file-tool-host.js

@@ -0,0 +1,109 @@
+// What the file tools need from the host they run for, with defaults that need no Node runtime. The local tools
+// pass their Node implementations (path-utils.ts, the machine-ops mutation queue and realpath canonicalization).
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+function normalizePosixPath(path) {
+    const parts = [];
+    for (const part of path.split("/")) {
+        if (part === "" || part === ".")
+            continue;
+        if (part === "..")
+            parts.pop();
+        else
+            parts.push(part);
+    }
+    return `/${parts.join("/")}`;
+}
+/**
+ * POSIX resolution as `path.posix.resolve` does it, after the same input clean-up the local resolver applies (Unicode
+ * spaces, a leading `@`, `file://` URLs). `~` is not expanded: the host's home directory is unknown here.
+ */
+export const resolvePosixToolPath = (input, cwd) => {
+    let path = input.replace(UNICODE_SPACES, " ");
+    if (path.startsWith("@"))
+        path = path.slice(1);
+    if (path.startsWith("file://"))
+        path = decodeURIComponent(new URL(path).pathname);
+    return normalizePosixPath(path.startsWith("/") ? path : `${cwd}/${path}`);
+};
+export function posixDirname(path) {
+    const trimmed = path.length > 1 ? path.replace(/\/+$/, "") : path;
+    const slash = trimmed.lastIndexOf("/");
+    if (slash === -1)
+        return ".";
+    return slash === 0 ? "/" : trimmed.slice(0, slash);
+}
+const pathTails = new Map();
+/** Serializes mutations per resolved path string within this isolate. */
+export const inProcessFileMutationQueue = async (absolutePath, fn) => {
+    const previous = pathTails.get(absolutePath) ?? Promise.resolve();
+    let release = () => { };
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    const tail = previous.then(() => current);
+    pathTails.set(absolutePath, tail);
+    await previous;
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (pathTails.get(absolutePath) === tail)
+            pathTails.delete(absolutePath);
+    }
+};
+export const lexicalCanonicalPath = async (absolutePath) => absolutePath;
+const NARROW_NO_BREAK_SPACE = "\u202F";
+export function tryMacOSScreenshotPath(filePath) {
+    return filePath.replace(/ (AM|PM)\./gi, `${NARROW_NO_BREAK_SPACE}$1.`);
+}
+export function tryNFDVariant(filePath) {
+    // macOS stores filenames in NFD (decomposed) form, try converting user input to NFD
+    return filePath.normalize("NFD");
+}
+export function tryCurlyQuoteVariant(filePath) {
+    // macOS uses U+2019 (right single quotation mark) in screenshot names like "Capture d'écran"
+    // Users typically type U+0027 (straight apostrophe)
+    return filePath.replace(/'/g, "\u2019");
+}
+// Windows Explorer "Copy as path" wraps the path in double quotes (senpi#2170).
+export function unquotedPath(filePath) {
+    const match = /^@?(["'])(.+)\1$/.exec(filePath.trim());
+    return match?.[2];
+}
+/**
+ * The read tool's path: the resolved path when it exists, else the first existing spelling variant (quoted,
+ * macOS screenshot AM/PM, NFD, curly quote), else the resolved path.
+ */
+export async function resolveReadPathVariants(filePath, cwd, resolve, exists) {
+    const resolved = resolve(filePath, cwd);
+    if (await exists(resolved)) {
+        return resolved;
+    }
+    const unquoted = unquotedPath(filePath);
+    if (unquoted !== undefined) {
+        return resolveReadPathVariants(unquoted, cwd, resolve, exists);
+    }
+    // Try macOS AM/PM variant (narrow no-break space before AM/PM)
+    const amPmVariant = tryMacOSScreenshotPath(resolved);
+    if (amPmVariant !== resolved && (await exists(amPmVariant))) {
+        return amPmVariant;
+    }
+    // Try NFD variant (macOS stores filenames in NFD form)
+    const nfdVariant = tryNFDVariant(resolved);
+    if (nfdVariant !== resolved && (await exists(nfdVariant))) {
+        return nfdVariant;
+    }
+    // Try curly quote variant (macOS uses U+2019 in screenshot names)
+    const curlyVariant = tryCurlyQuoteVariant(resolved);
+    if (curlyVariant !== resolved && (await exists(curlyVariant))) {
+        return curlyVariant;
+    }
+    // Try combined NFD + curly quote (for French macOS screenshots like "Capture d'écran")
+    const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+    if (nfdCurlyVariant !== resolved && (await exists(nfdCurlyVariant))) {
+        return nfdCurlyVariant;
+    }
+    return resolved;
+}
+//# sourceMappingURL=file-tool-host.js.map

package/dist/core/tools/fs-error-code.d.ts

@@ -0,0 +1,2 @@
+export declare function fsErrorCode(error: unknown): string | undefined;
+//# sourceMappingURL=fs-error-code.d.ts.map

package/dist/core/tools/fs-error-code.js

@@ -0,0 +1,15 @@
+// The fs error code a tool shows for a failed operation. A ToolMachine may pass fs errors through unchanged (the
+// local machine does) or report the operation layer's own codes, as a machine reached over a wire does; the
+// tools answer with the same fs code either way.
+const FS_CODE_OF_OP_CODE = {
+    not_found: "ENOENT",
+    permission_denied: "EACCES",
+    aborted: "ABORT_ERR",
+};
+export function fsErrorCode(error) {
+    if (typeof error !== "object" || error === null || !("code" in error) || typeof error.code !== "string") {
+        return undefined;
+    }
+    return FS_CODE_OF_OP_CODE[error.code] ?? error.code;
+}
+//# sourceMappingURL=fs-error-code.js.map

package/dist/core/tools/machine-output-spill.d.ts

@@ -0,0 +1,11 @@
+import { type OutputSpillFactory } from "./output-accumulator-core.ts";
+import type { ToolMachine } from "./tool-machine.ts";
+/**
+ * Spills to a file on the tool machine, so the path a truncation notice names is one the model can read there.
+ * Chunks are written in order at their byte offsets as they arrive. The operation layer has no delete, so `remove`
+ * empties the file instead, and does nothing when no chunk ever reached the machine.
+ */
+export declare function createMachineOutputSpill(machine: ToolMachine, options?: {
+    tempDir?: string;
+}): OutputSpillFactory;
+//# sourceMappingURL=machine-output-spill.d.ts.map

package/dist/core/tools/machine-output-spill.js

@@ -0,0 +1,65 @@
+import { encodeUtf8 } from "./encoding.js";
+import { joinHeadAndTail } from "./output-accumulator-core.js";
+function randomHex(bytes) {
+    return Array.from(crypto.getRandomValues(new Uint8Array(bytes)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+ * Spills to a file on the tool machine, so the path a truncation notice names is one the model can read there.
+ * Chunks are written in order at their byte offsets as they arrive. The operation layer has no delete, so `remove`
+ * empties the file instead, and does nothing when no chunk ever reached the machine.
+ */
+export function createMachineOutputSpill(machine, options) {
+    const tempDir = options?.tempDir ?? "/tmp";
+    return (prefix) => {
+        const path = `${tempDir}/${prefix}-${randomHex(8)}.log`;
+        const ctx = machine.context(undefined);
+        let size = 0;
+        let written = false;
+        let writeFailed = false;
+        let writeError;
+        let pending = Promise.resolve();
+        const read = (offset, limitBytes) => machine.ops.files.read({ path, offset, limitBytes }, ctx).then((result) => result.bytes);
+        return {
+            path,
+            write: (chunk) => {
+                const bytes = typeof chunk === "string" ? encodeUtf8(chunk) : chunk;
+                const offset = size;
+                size += bytes.length;
+                pending = pending.then(async () => {
+                    if (writeFailed)
+                        return;
+                    try {
+                        await machine.ops.files.write({ path, bytes, offset, createParentDirs: true }, ctx);
+                        written = true;
+                    }
+                    catch (error) {
+                        writeFailed = true;
+                        writeError = error;
+                    }
+                });
+            },
+            close: async () => {
+                await pending;
+                if (writeFailed)
+                    throw writeError;
+            },
+            remove: async () => {
+                await pending;
+                // Nothing reached the machine (the first write failed): there is no file to empty.
+                if (!written)
+                    return;
+                await machine.ops.files.write({ path, bytes: new Uint8Array() }, ctx);
+            },
+            readFull: async (maxBytes) => {
+                if (size <= maxBytes) {
+                    return { content: new TextDecoder().decode(await read(0, size)), truncated: false };
+                }
+                const headBytes = Math.floor(maxBytes / 2);
+                const tailBytes = maxBytes - headBytes;
+                const [head, tail] = await Promise.all([read(0, headBytes), read(size - tailBytes, tailBytes)]);
+                return { content: joinHeadAndTail(head, tail, size - headBytes - tailBytes), truncated: true };
+            },
+        };
+    };
+}
+//# sourceMappingURL=machine-output-spill.js.map

package/dist/core/tools/machine.d.ts

@@ -1,31 +1,11 @@
-import { type MachineOps, type OpContext, type OpName, type PolicyHooks } from "../../../vendor/senpi-machine-ops/index.js";
-/**
- * The hooks the tool path honours: only `beforeOp`, once per tool call. The tools run the extension filesystem policy
- * themselves and sub-operations carry no hooks, so `filesystem` and `afterOp` are rejected at compile time instead of
- * being silently ignored.
- */
-export type ToolPathPolicy = Pick<PolicyHooks, "beforeOp"> & {
-    readonly filesystem?: never;
-    readonly afterOp?: never;
-};
-/** One MachineOps bound to the tool path: principal `local-session`, no scope root (the tools resolve paths). */
-export interface ToolMachine {
-    readonly ops: MachineOps;
-    /**
-     * Runs `PolicyHooks.beforeOp` once for one tool call; a denial rejects with `Error(reason)` before any effect.
-     * Without a `beforeOp` it returns undefined synchronously, so a tool that awaits only a returned promise keeps
-     * its exact pre-layer timing (bash emits its first partial update before any await).
-     */
-    begin(op: OpName, args: unknown, signal: AbortSignal | undefined): Promise<void> | undefined;
-    /** Context for a sub-operation inside a call `begin` already admitted. */
-    context(signal: AbortSignal | undefined, pathLock?: "caller"): OpContext;
-}
+import { type MachineOps } from "../../../vendor/senpi-machine-ops/index.js";
+import { type ToolMachine, type ToolPathPolicy } from "./tool-machine.ts";
+export type { ToolMachine, ToolPathPolicy } from "./tool-machine.ts";
+/** A ToolMachine over `ops`, or over the process-wide local machine when the caller supplies none. */
 export declare function createToolMachine(options?: {
     ops?: MachineOps;
     policy?: ToolPathPolicy;
 }): ToolMachine;
 /** The ToolMachine a tool factory uses when its options carry none. */
 export declare function defaultToolMachine(): ToolMachine;
-/** Bytes from the operation layer as the Buffer the tool seams have always returned. */
-export declare function asBuffer(bytes: Uint8Array): Buffer;
 //# sourceMappingURL=machine.d.ts.map

package/dist/core/tools/machine.js

@@ -1,18 +1,8 @@
-import { createLocalMachineOps, DEFAULT_LIMITS, } from "../../../vendor/senpi-machine-ops/index.js";
+import { createLocalMachineOps } from "../../../vendor/senpi-machine-ops/index.js";
 import { createInProcessHolderLink } from "../../../vendor/senpi-machine-ops/process/in-process-holder.js";
 import { killProcessTree } from "../../utils/shell.js";
 import { ensureTool } from "../../utils/tools-manager.js";
-/**
- * Tool-path limits. The tools keep their own truncation (truncate.ts, the output accumulator), so the operation
- * layer reads files whole and streams exec output uncaptured, exactly as the tools did before the layer existed.
- */
-const TOOL_PATH_LIMITS = {
-    ...DEFAULT_LIMITS,
-    readMaxBytes: Number.POSITIVE_INFINITY,
-    execStdoutMaxBytes: 0,
-    execStderrMaxBytes: 0,
-    execTimeoutDefaultMs: Number.POSITIVE_INFINITY,
-};
+import { bindToolMachine } from "./tool-machine.js";
 let processMachineOps;
 /**
  * The process-wide local MachineOps the built-in tools use when no caller supplies one. It has no `stateDir`, so it
@@ -28,35 +18,9 @@ function defaultLocalMachineOps() {
     });
     return processMachineOps;
 }
-const NEVER_ABORTED = new AbortController().signal;
+/** A ToolMachine over `ops`, or over the process-wide local machine when the caller supplies none. */
 export function createToolMachine(options) {
-    const resolveOps = () => options?.ops ?? defaultLocalMachineOps();
-    const context = (signal, pathLock) => ({
-        scope: { id: "local-session" },
-        principal: { kind: "local-session", id: "local-session" },
-        signal: signal ?? NEVER_ABORTED,
-        limits: TOOL_PATH_LIMITS,
-        // The tools run the extension filesystem policy themselves (with their own error text) and the gate below
-        // already ran once for the call, so sub-operations carry no hooks.
-        policy: {},
-        ...(pathLock !== undefined ? { pathLock } : {}),
-    });
-    return {
-        get ops() {
-            return resolveOps();
-        },
-        begin(op, args, signal) {
-            const policy = options?.policy;
-            const beforeOp = policy?.beforeOp;
-            if (beforeOp === undefined)
-                return undefined;
-            return beforeOp(op, args, { ...context(signal), policy: policy ?? {} }).then((decision) => {
-                if (!decision.allow)
-                    throw new Error(decision.reason);
-            });
-        },
-        context,
-    };
+    return bindToolMachine(() => options?.ops ?? defaultLocalMachineOps(), options?.policy);
 }
 let defaultMachine;
 /** The ToolMachine a tool factory uses when its options carry none. */
@@ -64,8 +28,4 @@ export function defaultToolMachine() {
     defaultMachine ??= createToolMachine();
     return defaultMachine;
 }
-/** Bytes from the operation layer as the Buffer the tool seams have always returned. */
-export function asBuffer(bytes) {
-    return Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-}
 //# sourceMappingURL=machine.js.map

package/dist/core/tools/output-accumulator-core.d.ts

@@ -0,0 +1,84 @@
+import { type TruncationResult } from "./truncate.ts";
+export interface OutputSnapshot {
+    content: string;
+    truncation: TruncationResult;
+    fullOutputPath?: string;
+}
+export interface FullOutput {
+    content: string;
+    /** Whether `content` omits part of the output. */
+    truncated: boolean;
+}
+/** Where an accumulator keeps the full output once it outgrows the display limits. */
+export interface OutputSpill {
+    /** The path truncation notices show the model. */
+    readonly path: string;
+    /** Appends a chunk; a failure is latched and reported by `close`. */
+    write(chunk: Uint8Array | string): void;
+    /** Settles every write; rejects with the first write or close failure. */
+    close(): Promise<void>;
+    /** Discards the spill; a rejection leaves it in place for a retry. */
+    remove(): Promise<void>;
+    /** The whole output after `close`, cut by {@link joinHeadAndTail} past `maxBytes`. */
+    readFull(maxBytes: number): Promise<FullOutput>;
+}
+export type OutputSpillFactory = (prefix: string) => OutputSpill;
+export interface OutputAccumulatorOptions {
+    maxLines?: number;
+    maxBytes?: number;
+    tempFilePrefix?: string;
+}
+/**
+ * The first and last bytes of an output too long to return whole, around an omission marker. Cuts at character
+ * boundaries: streaming decode holds back an incomplete trailing sequence, and the tail skips continuation bytes.
+ */
+export declare function joinHeadAndTail(head: Uint8Array, tail: Uint8Array, omittedBytes: number): string;
+/**
+ * Incrementally tracks streaming output with bounded memory.
+ *
+ * Appends decode chunks with a streaming UTF-8 decoder, keeps only a decoded tail for display snapshots, and opens a
+ * spill when the full output needs to be preserved.
+ */
+export declare class OutputAccumulator {
+    private readonly maxLines;
+    private readonly maxBytes;
+    private readonly tempFilePrefix;
+    private readonly createSpill;
+    private readonly decoder;
+    private readonly tail;
+    private rawChunks;
+    private totalRawBytes;
+    private totalDecodedBytes;
+    private completedLines;
+    private totalLines;
+    private currentLineBytes;
+    private hasOpenLine;
+    private finished;
+    /** The spill that owns `fullOutputPath`, until removed. */
+    private spill;
+    /** The same spill while it still takes writes, until closed. */
+    private openSpill;
+    constructor(options: OutputAccumulatorOptions & {
+        spill: OutputSpillFactory;
+    });
+    append(data: Uint8Array): void;
+    appendText(text: string): void;
+    finish(): void;
+    snapshot(options?: {
+        persistIfTruncated?: boolean;
+    }): OutputSnapshot;
+    closeTempFile(): Promise<void>;
+    /**
+     * The complete output, for callers that can take more than the display snapshot. Call after
+     * `finish()` and `closeTempFile()`. Output longer than `maxBytes` raw bytes keeps its first and
+     * last `maxBytes / 2` bytes around an omission marker.
+     */
+    readFullOutput(maxBytes: number): Promise<FullOutput>;
+    getLastLineBytes(): number;
+    removeTempFile(): Promise<void>;
+    private appendDecodedText;
+    private getSnapshotText;
+    private shouldUseTempFile;
+    private ensureTempFile;
+}
+//# sourceMappingURL=output-accumulator-core.d.ts.map

package/dist/core/tools/output-accumulator-core.js

@@ -0,0 +1,200 @@
+import { concatBytes, encodeUtf8, utf8ByteLength } from "./encoding.js";
+import { TailWindow } from "./tail-window.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "./truncate.js";
+/**
+ * The first and last bytes of an output too long to return whole, around an omission marker. Cuts at character
+ * boundaries: streaming decode holds back an incomplete trailing sequence, and the tail skips continuation bytes.
+ */
+export function joinHeadAndTail(head, tail, omittedBytes) {
+    const headText = new TextDecoder().decode(head, { stream: true });
+    let tailStart = 0;
+    while (tailStart < tail.length && (tail[tailStart] & 0xc0) === 0x80)
+        tailStart++;
+    const tailText = new TextDecoder().decode(tail.subarray(tailStart));
+    return `${headText}\n\n[... ${omittedBytes} bytes omitted ...]\n\n${tailText}`;
+}
+/**
+ * Incrementally tracks streaming output with bounded memory.
+ *
+ * Appends decode chunks with a streaming UTF-8 decoder, keeps only a decoded tail for display snapshots, and opens a
+ * spill when the full output needs to be preserved.
+ */
+export class OutputAccumulator {
+    constructor(options) {
+        this.decoder = new TextDecoder();
+        this.rawChunks = [];
+        this.totalRawBytes = 0;
+        this.totalDecodedBytes = 0;
+        this.completedLines = 0;
+        this.totalLines = 0;
+        this.currentLineBytes = 0;
+        this.hasOpenLine = false;
+        this.finished = false;
+        this.maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+        this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+        this.tempFilePrefix = options.tempFilePrefix ?? "pi-output";
+        this.createSpill = options.spill;
+        this.tail = new TailWindow(Math.max(this.maxBytes * 2, 1));
+    }
+    append(data) {
+        if (this.finished) {
+            throw new Error("Cannot append to a finished output accumulator");
+        }
+        const text = this.decoder.decode(data, { stream: true });
+        this.totalRawBytes += data.length;
+        this.appendDecodedText(text, utf8ByteLength(text));
+        if (this.openSpill || this.shouldUseTempFile()) {
+            this.ensureTempFile();
+            this.openSpill?.write(data);
+        }
+        else if (data.length > 0) {
+            this.rawChunks.push(data);
+        }
+    }
+    appendText(text) {
+        if (this.finished) {
+            throw new Error("Cannot append to a finished output accumulator");
+        }
+        if (text.length === 0) {
+            return;
+        }
+        const bytes = utf8ByteLength(text);
+        this.totalRawBytes += bytes;
+        this.appendDecodedText(text, bytes);
+        if (this.openSpill || this.shouldUseTempFile()) {
+            this.ensureTempFile();
+            this.openSpill?.write(text);
+        }
+        else {
+            this.rawChunks.push(text);
+        }
+    }
+    finish() {
+        if (this.finished) {
+            return;
+        }
+        this.finished = true;
+        const finalText = this.decoder.decode();
+        this.appendDecodedText(finalText, utf8ByteLength(finalText));
+        if (this.shouldUseTempFile()) {
+            this.ensureTempFile();
+        }
+    }
+    snapshot(options = {}) {
+        const tailTruncation = truncateTail(this.getSnapshotText(), {
+            maxLines: this.maxLines,
+            maxBytes: this.maxBytes,
+        });
+        const truncated = this.totalLines > this.maxLines || this.totalDecodedBytes > this.maxBytes;
+        const truncatedBy = truncated
+            ? (tailTruncation.truncatedBy ?? (this.totalDecodedBytes > this.maxBytes ? "bytes" : "lines"))
+            : null;
+        const truncation = {
+            ...tailTruncation,
+            truncated,
+            truncatedBy,
+            totalLines: this.totalLines,
+            totalBytes: this.totalDecodedBytes,
+            maxLines: this.maxLines,
+            maxBytes: this.maxBytes,
+        };
+        if (options.persistIfTruncated && truncation.truncated) {
+            this.ensureTempFile();
+        }
+        return {
+            content: truncation.content,
+            truncation,
+            fullOutputPath: this.spill?.path,
+        };
+    }
+    async closeTempFile() {
+        const spill = this.openSpill;
+        this.openSpill = undefined;
+        if (!spill) {
+            return;
+        }
+        try {
+            await spill.close();
+        }
+        catch (error) {
+            try {
+                await this.removeTempFile();
+            }
+            catch (unlinkError) {
+                throw new AggregateError([error, unlinkError], "Output spill cleanup failed");
+            }
+            throw error;
+        }
+    }
+    /**
+     * The complete output, for callers that can take more than the display snapshot. Call after
+     * `finish()` and `closeTempFile()`. Output longer than `maxBytes` raw bytes keeps its first and
+     * last `maxBytes / 2` bytes around an omission marker.
+     */
+    async readFullOutput(maxBytes) {
+        if (!this.spill) {
+            // Fork `appendText()` buffers strings beside raw chunks; encode them back before decoding the whole.
+            const chunks = this.rawChunks.map((chunk) => (typeof chunk === "string" ? encodeUtf8(chunk) : chunk));
+            return { content: new TextDecoder().decode(concatBytes(chunks)), truncated: false };
+        }
+        return this.spill.readFull(maxBytes);
+    }
+    getLastLineBytes() {
+        return this.currentLineBytes;
+    }
+    async removeTempFile() {
+        if (!this.spill) {
+            return;
+        }
+        await this.spill.remove();
+        this.spill = undefined;
+    }
+    appendDecodedText(text, bytes) {
+        if (text.length === 0) {
+            return;
+        }
+        this.totalDecodedBytes += bytes;
+        this.tail.append(text, bytes, !this.hasOpenLine);
+        let newlines = 0;
+        let lastNewline = -1;
+        for (let i = text.indexOf("\n"); i !== -1; i = text.indexOf("\n", i + 1)) {
+            newlines++;
+            lastNewline = i;
+        }
+        if (newlines === 0) {
+            this.currentLineBytes += bytes;
+            this.hasOpenLine = true;
+        }
+        else {
+            this.completedLines += newlines;
+            const tail = text.slice(lastNewline + 1);
+            this.currentLineBytes = utf8ByteLength(tail);
+            this.hasOpenLine = tail.length > 0;
+        }
+        this.totalLines = this.completedLines + (this.hasOpenLine ? 1 : 0);
+    }
+    getSnapshotText() {
+        const text = this.tail.text();
+        if (this.tail.startsAtLineBoundary) {
+            return text;
+        }
+        const firstNewline = text.indexOf("\n");
+        return firstNewline === -1 ? text : text.slice(firstNewline + 1);
+    }
+    shouldUseTempFile() {
+        return (this.totalRawBytes > this.maxBytes || this.totalDecodedBytes > this.maxBytes || this.totalLines > this.maxLines);
+    }
+    ensureTempFile() {
+        if (this.spill) {
+            return;
+        }
+        const spill = this.createSpill(this.tempFilePrefix);
+        this.spill = spill;
+        this.openSpill = spill;
+        for (const chunk of this.rawChunks) {
+            spill.write(chunk);
+        }
+        this.rawChunks = [];
+    }
+}
+//# sourceMappingURL=output-accumulator-core.js.map

package/dist/core/tools/output-accumulator.d.ts

@@ -1,63 +1,11 @@
-import { type TruncationResult } from "./truncate.ts";
-export interface OutputAccumulatorOptions {
-    maxLines?: number;
-    maxBytes?: number;
-    tempFilePrefix?: string;
-}
-export interface OutputSnapshot {
-    content: string;
-    truncation: TruncationResult;
-    fullOutputPath?: string;
-}
-export interface FullOutput {
-    content: string;
-    /** Whether `content` omits part of the output. */
-    truncated: boolean;
-}
-/**
- * Incrementally tracks streaming output with bounded memory.
- *
- * Appends decode chunks with a streaming UTF-8 decoder, keeps only a decoded
- * tail for display snapshots, and opens a temp file when the full output needs
- * to be preserved.
- */
-export declare class OutputAccumulator {
-    private readonly maxLines;
-    private readonly maxBytes;
-    private readonly tempFilePrefix;
-    private readonly decoder;
-    private readonly tail;
-    private rawChunks;
-    private totalRawBytes;
-    private totalDecodedBytes;
-    private completedLines;
-    private totalLines;
-    private currentLineBytes;
-    private hasOpenLine;
-    private finished;
-    private tempFilePath;
-    private tempFileStream;
-    private tempFileError;
-    constructor(options?: OutputAccumulatorOptions);
-    append(data: Buffer): void;
-    appendText(text: string): void;
-    finish(): void;
-    snapshot(options?: {
-        persistIfTruncated?: boolean;
-    }): OutputSnapshot;
-    closeTempFile(): Promise<void>;
-    /**
-     * The complete output, for callers that can take more than the display snapshot. Call after
-     * `finish()` and `closeTempFile()`. Output longer than `maxBytes` raw bytes keeps its first and
-     * last `maxBytes / 2` bytes around an omission marker.
-     */
-    readFullOutput(maxBytes: number): Promise<FullOutput>;
-    getLastLineBytes(): number;
-    private appendDecodedText;
-    private getSnapshotText;
-    private shouldUseTempFile;
-    private ensureTempFile;
-    removeTempFile(): Promise<void>;
-    private takeTempFileStream;
+import { OutputAccumulator as CoreOutputAccumulator, type OutputAccumulatorOptions, type OutputSpillFactory } from "./output-accumulator-core.ts";
+export type { FullOutput, OutputAccumulatorOptions, OutputSnapshot } from "./output-accumulator-core.ts";
+/** The local spill: a temp file under the OS temp directory, streamed as output arrives. */
+export declare const createTempFileSpill: OutputSpillFactory;
+/** The output accumulator of the local tools: it spills to a temp file unless the caller supplies a spill. */
+export declare class OutputAccumulator extends CoreOutputAccumulator {
+    constructor(options?: OutputAccumulatorOptions & {
+        spill?: OutputSpillFactory;
+    });
 }
 //# sourceMappingURL=output-accumulator.d.ts.map