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

package/dist/core/tools/edit-core.js

@@ -0,0 +1,175 @@
+import { Type } from "typebox";
+import { splitBom } from "../../utils/text.js";
+import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, } from "./edit-diff.js";
+import { decodeUtf8, encodeUtf8 } from "./encoding.js";
+import { fsErrorCode } from "./fs-error-code.js";
+import { inProcessFileMutationQueue, lexicalCanonicalPath, resolvePosixToolPath, } from "./file-tool-host.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+const replaceEditSchema = Type.Object({
+    oldText: Type.String({
+        description: "Exact text for one targeted replacement. It must be unique in the original file and must not overlap with any other edits[].oldText in the same call.",
+    }),
+    newText: Type.String({ description: "Replacement text for this targeted edit." }),
+}, {});
+const editSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+    edits: Type.Array(replaceEditSchema, {
+        description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
+    }),
+}, {});
+export const editToolSystemPromptContribution = {
+    snippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
+    guidelines: ["All changes to one file -> one edit call."],
+    fullGuidelines: [
+        "Use edit for precise changes (edits[].oldText must match exactly)",
+        "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
+        "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+        "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
+    ],
+};
+function isSingleEditInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const edit = value;
+    return typeof edit.oldText === "string" && typeof edit.newText === "string";
+}
+/** The default edit operations over the shared operation layer; the tool already holds the file's mutation slot. */
+function machineEditOperations(machine, signal) {
+    const ctx = machine.context(signal, "caller");
+    return {
+        readFile: async (path) => (await machine.ops.files.read({ path }, ctx)).bytes,
+        writeFile: async (path, content) => {
+            await machine.ops.files.write({ path, bytes: encodeUtf8(content) }, ctx);
+        },
+        access: async (path) => {
+            await machine.ops.files.stat({ path, access: "readwrite" }, ctx);
+        },
+    };
+}
+function prepareEditArguments(input) {
+    if (!input || typeof input !== "object") {
+        return input;
+    }
+    const args = input;
+    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array.
+    // Others send a single edit object instead of a one-element edits array.
+    if (typeof args.edits === "string") {
+        try {
+            const parsed = JSON.parse(args.edits);
+            if (Array.isArray(parsed)) {
+                args.edits = parsed;
+            }
+            else if (isSingleEditInput(parsed)) {
+                args.edits = [parsed];
+            }
+        }
+        catch { }
+    }
+    else if (isSingleEditInput(args.edits)) {
+        args.edits = [args.edits];
+    }
+    const legacy = args;
+    if (typeof legacy.oldText !== "string" || typeof legacy.newText !== "string") {
+        return args;
+    }
+    const edits = Array.isArray(legacy.edits) ? [...legacy.edits] : [];
+    edits.push({ oldText: legacy.oldText, newText: legacy.newText });
+    const { oldText: _oldText, newText: _newText, ...rest } = legacy;
+    return { ...rest, edits };
+}
+function validateEditInput(input) {
+    if (!Array.isArray(input.edits) || input.edits.length === 0) {
+        throw new Error("Edit tool input is invalid. edits must contain at least one replacement.");
+    }
+    return { path: input.path, edits: input.edits };
+}
+export function createCoreEditToolDefinition(cwd, options) {
+    const machine = options.machine;
+    const filesystemPolicy = options.filesystemPolicy;
+    const resolvePath = options.resolvePath ?? resolvePosixToolPath;
+    const withMutationQueue = options.withMutationQueue ?? inProcessFileMutationQueue;
+    const canonicalizePath = options.canonicalizePath ?? lexicalCanonicalPath;
+    return {
+        name: "edit",
+        label: "edit",
+        description: "Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
+        promptSnippet: editToolSystemPromptContribution.snippet,
+        promptGuidelines: [...editToolSystemPromptContribution.guidelines],
+        fullPromptGuidelines: [...editToolSystemPromptContribution.fullGuidelines],
+        parameters: editSchema,
+        constrainedSampling: { type: "json_schema", strict: "prefer" },
+        renderShell: "self",
+        prepareArguments: prepareEditArguments,
+        async execute(_toolCallId, input, signal, _onUpdate, ctx) {
+            const { path, edits } = validateEditInput(input);
+            const admitted = machine.begin("files.edit", { path, edits }, signal);
+            if (admitted !== undefined)
+                await admitted;
+            const ops = options.operations ?? machineEditOperations(machine, signal);
+            const absolutePath = resolvePath(path, ctx?.cwd || cwd);
+            return withMutationQueue(absolutePath, async () => {
+                // Do not reject from an abort event listener here: that would release the
+                // mutation queue while an in-flight filesystem operation may still finish.
+                // Checking signal.aborted after each await observes the same aborts while
+                // keeping the queue locked until the current operation has settled.
+                const throwIfAborted = () => {
+                    if (signal?.aborted)
+                        throw new Error("Operation aborted");
+                };
+                throwIfAborted();
+                if (filesystemPolicy) {
+                    const decision = await filesystemPolicy({
+                        operation: "write",
+                        canonicalPath: await canonicalizePath(absolutePath),
+                        toolName: "edit",
+                    });
+                    if (!decision.allow)
+                        throw new Error(decision.reason);
+                    throwIfAborted();
+                }
+                // Check if file exists.
+                try {
+                    await ops.access(absolutePath);
+                }
+                catch (error) {
+                    throwIfAborted();
+                    const errorMessage = error instanceof Error && "code" in error
+                        ? `Error code: ${fsErrorCode(error) ?? error.code}`
+                        : String(error);
+                    throw new Error(`Could not edit file: ${path}. ${errorMessage}.`);
+                }
+                throwIfAborted();
+                // Read the file.
+                const buffer = await ops.readFile(absolutePath);
+                const rawContent = decodeUtf8(buffer);
+                throwIfAborted();
+                // Strip BOM before matching. The model will not include an invisible BOM in oldText.
+                const { bom, text: content } = splitBom(rawContent);
+                const originalEnding = detectLineEnding(content);
+                const normalizedContent = normalizeToLF(content);
+                const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
+                throwIfAborted();
+                const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+                await ops.writeFile(absolutePath, finalContent);
+                throwIfAborted();
+                const diffResult = generateDiffString(baseContent, newContent);
+                const patch = generateUnifiedPatch(path, baseContent, newContent);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Successfully replaced ${edits.length} block(s) in ${path}.`,
+                        },
+                    ],
+                    details: { diff: diffResult.diff, patch, firstChangedLine: diffResult.firstChangedLine },
+                };
+            });
+        },
+    };
+}
+export function createCoreEditTool(cwd, options) {
+    return wrapToolDefinition(createCoreEditToolDefinition(cwd, options));
+}
+export { editSchema };
+//# sourceMappingURL=edit-core.js.map

package/dist/core/tools/edit-diff.d.ts

@@ -87,10 +87,5 @@ export interface EditDiffResult {
 export interface EditDiffError {
     error: string;
 }
-/**
- * Compute the diff for one or more edit operations without applying them.
- * Used for preview rendering in the TUI before the tool executes.
- */
-export declare function computeEditsDiff(path: string, edits: Edit[], cwd: string): Promise<EditDiffResult | EditDiffError>;
 export {};
 //# sourceMappingURL=edit-diff.d.ts.map

package/dist/core/tools/edit-diff.js

@@ -2,10 +2,6 @@
  * Shared diff computation utilities for the edit and similar tools.
  */
 import * as Diff from "diff";
-import { constants } from "fs";
-import { access, readFile } from "fs/promises";
-import { splitBom } from "../../utils/text.js";
-import { resolveToCwd } from "./path-utils.js";
 import { createUnifiedPatch } from "./unified-diff.js";
 export function detectLineEnding(content) {
     const crlfIdx = content.indexOf("\r\n");
@@ -381,32 +377,4 @@ export function generateDiffString(oldContent, newContent, contextLines = 4) {
     }
     return { diff: output.join("\n"), firstChangedLine };
 }
-/**
- * Compute the diff for one or more edit operations without applying them.
- * Used for preview rendering in the TUI before the tool executes.
- */
-export async function computeEditsDiff(path, edits, cwd) {
-    const absolutePath = resolveToCwd(path, cwd);
-    try {
-        // Check if file exists and is readable
-        try {
-            await access(absolutePath, constants.R_OK);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
-            return { error: `Could not edit file: ${path}. ${errorMessage}.` };
-        }
-        // Read the file
-        const rawContent = await readFile(absolutePath, "utf-8");
-        // Strip BOM before matching (LLM won't include invisible BOM in oldText)
-        const { text: content } = splitBom(rawContent);
-        const normalizedContent = normalizeToLF(content);
-        const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
-        // Generate the diff
-        return generateDiffString(baseContent, newContent);
-    }
-    catch (err) {
-        return { error: err instanceof Error ? err.message : String(err) };
-    }
-}
 //# sourceMappingURL=edit-diff.js.map

package/dist/core/tools/edit-preview.d.ts

@@ -0,0 +1,7 @@
+import { type Edit, type EditDiffError, type EditDiffResult } from "./edit-diff.ts";
+/**
+ * Compute the diff for one or more edit operations without applying them.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export declare function computeEditsDiff(path: string, edits: Edit[], cwd: string): Promise<EditDiffResult | EditDiffError>;
+//# sourceMappingURL=edit-preview.d.ts.map

package/dist/core/tools/edit-preview.js

@@ -0,0 +1,34 @@
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { splitBom } from "../../utils/text.js";
+import { applyEditsToNormalizedContent, generateDiffString, normalizeToLF, } from "./edit-diff.js";
+import { resolveToCwd } from "./path-utils.js";
+/**
+ * Compute the diff for one or more edit operations without applying them.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export async function computeEditsDiff(path, edits, cwd) {
+    const absolutePath = resolveToCwd(path, cwd);
+    try {
+        // Check if file exists and is readable
+        try {
+            await access(absolutePath, constants.R_OK);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
+            return { error: `Could not edit file: ${path}. ${errorMessage}.` };
+        }
+        // Read the file
+        const rawContent = await readFile(absolutePath, "utf-8");
+        // Strip BOM before matching (LLM won't include invisible BOM in oldText)
+        const { text: content } = splitBom(rawContent);
+        const normalizedContent = normalizeToLF(content);
+        const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
+        // Generate the diff
+        return generateDiffString(baseContent, newContent);
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+//# sourceMappingURL=edit-preview.js.map

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

@@ -1,50 +1,12 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
-import { type Static, Type } from "typebox";
-import type { FilesystemPolicyChecker, ToolDefinition } from "../extensions/types.ts";
-import { type ToolMachine } from "./machine.ts";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type CoreEditToolOptions, type EditToolDetails, type editSchema } from "./edit-core.ts";
 import { type EditRenderState } from "./renderers/edit.ts";
-declare const editSchema: Type.TObject<{
-    path: Type.TString;
-    edits: Type.TArray<Type.TObject<{
-        oldText: Type.TString;
-        newText: Type.TString;
-    }>>;
-}>;
-export declare const editToolSystemPromptContribution: {
-    readonly snippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call";
-    readonly guidelines: readonly ["All changes to one file -> one edit call."];
-    readonly fullGuidelines: readonly ["Use edit for precise changes (edits[].oldText must match exactly)", "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls", "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.", "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions."];
-};
-export type EditToolInput = Static<typeof editSchema>;
-export interface EditToolDetails {
-    /** Display-oriented diff of the changes made */
-    diff: string;
-    /** Standard unified patch of the changes made */
-    patch: string;
-    /** Line number of the first change in the new file (for editor navigation) */
-    firstChangedLine?: number;
-}
-/**
- * Pluggable operations for the edit tool.
- * Override these to delegate file editing to remote systems (for example SSH).
- */
-export interface EditOperations {
-    /** Read file contents as a Buffer */
-    readFile: (absolutePath: string) => Promise<Buffer>;
-    /** Write content to a file */
-    writeFile: (absolutePath: string, content: string) => Promise<void>;
-    /** Check if file is readable and writable (throw if not) */
-    access: (absolutePath: string) => Promise<void>;
-}
-export interface EditToolOptions {
-    /** Custom operations for file editing. Default: local filesystem */
-    operations?: EditOperations;
-    /** Extension-registered filesystem policy checker. */
-    filesystemPolicy?: FilesystemPolicyChecker;
+export { type EditOperations, type EditToolDetails, type EditToolInput, editToolSystemPromptContribution, } from "./edit-core.ts";
+export interface EditToolOptions extends Pick<CoreEditToolOptions, "operations" | "filesystemPolicy"> {
     /** Operation layer and policy gate. Default: the process-wide local machine. */
-    machine?: ToolMachine;
+    machine?: CoreEditToolOptions["machine"];
 }
 export declare function createEditToolDefinition(cwd: string, options?: EditToolOptions): ToolDefinition<typeof editSchema, EditToolDetails | undefined, EditRenderState>;
 export declare function createEditTool(cwd: string, options?: EditToolOptions): AgentTool<typeof editSchema>;
-export {};
 //# sourceMappingURL=edit.d.ts.map

package/dist/core/tools/edit.js

@@ -1,169 +1,21 @@
-import { Type } from "typebox";
-import { splitBom } from "../../utils/text.js";
-import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, } from "./edit-diff.js";
+import { createCoreEditToolDefinition, } from "./edit-core.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { canonicalizeFilesystemPath } from "./filesystem-policy.js";
-import { asBuffer, defaultToolMachine } from "./machine.js";
+import { defaultToolMachine } from "./machine.js";
 import { resolveToCwd } from "./path-utils.js";
 import { editRenderers } from "./renderers/edit.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
-const replaceEditSchema = Type.Object({
-    oldText: Type.String({
-        description: "Exact text for one targeted replacement. It must be unique in the original file and must not overlap with any other edits[].oldText in the same call.",
-    }),
-    newText: Type.String({ description: "Replacement text for this targeted edit." }),
-}, {});
-const editSchema = Type.Object({
-    path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
-    edits: Type.Array(replaceEditSchema, {
-        description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
-    }),
-}, {});
-export const editToolSystemPromptContribution = {
-    snippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
-    guidelines: ["All changes to one file -> one edit call."],
-    fullGuidelines: [
-        "Use edit for precise changes (edits[].oldText must match exactly)",
-        "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
-        "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
-        "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
-    ],
-};
-function isSingleEditInput(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return false;
-    }
-    const edit = value;
-    return typeof edit.oldText === "string" && typeof edit.newText === "string";
-}
-/** The default edit operations over the shared operation layer; the tool already holds the file's mutation slot. */
-function machineEditOperations(machine, signal) {
-    const ctx = machine.context(signal, "caller");
-    return {
-        readFile: async (path) => asBuffer((await machine.ops.files.read({ path }, ctx)).bytes),
-        writeFile: async (path, content) => {
-            await machine.ops.files.write({ path, bytes: Buffer.from(content, "utf-8") }, ctx);
-        },
-        access: async (path) => {
-            await machine.ops.files.stat({ path, access: "readwrite" }, ctx);
-        },
-    };
-}
-function prepareEditArguments(input) {
-    if (!input || typeof input !== "object") {
-        return input;
-    }
-    const args = input;
-    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array.
-    // Others send a single edit object instead of a one-element edits array.
-    if (typeof args.edits === "string") {
-        try {
-            const parsed = JSON.parse(args.edits);
-            if (Array.isArray(parsed)) {
-                args.edits = parsed;
-            }
-            else if (isSingleEditInput(parsed)) {
-                args.edits = [parsed];
-            }
-        }
-        catch { }
-    }
-    else if (isSingleEditInput(args.edits)) {
-        args.edits = [args.edits];
-    }
-    const legacy = args;
-    if (typeof legacy.oldText !== "string" || typeof legacy.newText !== "string") {
-        return args;
-    }
-    const edits = Array.isArray(legacy.edits) ? [...legacy.edits] : [];
-    edits.push({ oldText: legacy.oldText, newText: legacy.newText });
-    const { oldText: _oldText, newText: _newText, ...rest } = legacy;
-    return { ...rest, edits };
-}
-function validateEditInput(input) {
-    if (!Array.isArray(input.edits) || input.edits.length === 0) {
-        throw new Error("Edit tool input is invalid. edits must contain at least one replacement.");
-    }
-    return { path: input.path, edits: input.edits };
-}
+export { editToolSystemPromptContribution, } from "./edit-core.js";
 export function createEditToolDefinition(cwd, options) {
-    const machine = options?.machine ?? defaultToolMachine();
-    const filesystemPolicy = options?.filesystemPolicy;
     return {
         ...(options?.operations !== undefined || options?.filesystemPolicy !== undefined ? { serverPinned: true } : {}),
-        name: "edit",
-        label: "edit",
-        description: "Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
-        promptSnippet: editToolSystemPromptContribution.snippet,
-        promptGuidelines: [...editToolSystemPromptContribution.guidelines],
-        fullPromptGuidelines: [...editToolSystemPromptContribution.fullGuidelines],
-        parameters: editSchema,
-        constrainedSampling: { type: "json_schema", strict: "prefer" },
-        renderShell: "self",
-        prepareArguments: prepareEditArguments,
-        async execute(_toolCallId, input, signal, _onUpdate, ctx) {
-            const { path, edits } = validateEditInput(input);
-            const admitted = machine.begin("files.edit", { path, edits }, signal);
-            if (admitted !== undefined)
-                await admitted;
-            const ops = options?.operations ?? machineEditOperations(machine, signal);
-            const absolutePath = resolveToCwd(path, ctx?.cwd || cwd);
-            return withFileMutationQueue(absolutePath, async () => {
-                // Do not reject from an abort event listener here: that would release the
-                // mutation queue while an in-flight filesystem operation may still finish.
-                // Checking signal.aborted after each await observes the same aborts while
-                // keeping the queue locked until the current operation has settled.
-                const throwIfAborted = () => {
-                    if (signal?.aborted)
-                        throw new Error("Operation aborted");
-                };
-                throwIfAborted();
-                if (filesystemPolicy) {
-                    const decision = await filesystemPolicy({
-                        operation: "write",
-                        canonicalPath: await canonicalizeFilesystemPath(absolutePath),
-                        toolName: "edit",
-                    });
-                    if (!decision.allow)
-                        throw new Error(decision.reason);
-                    throwIfAborted();
-                }
-                // Check if file exists.
-                try {
-                    await ops.access(absolutePath);
-                }
-                catch (error) {
-                    throwIfAborted();
-                    const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
-                    throw new Error(`Could not edit file: ${path}. ${errorMessage}.`);
-                }
-                throwIfAborted();
-                // Read the file.
-                const buffer = await ops.readFile(absolutePath);
-                const rawContent = buffer.toString("utf-8");
-                throwIfAborted();
-                // Strip BOM before matching. The model will not include an invisible BOM in oldText.
-                const { bom, text: content } = splitBom(rawContent);
-                const originalEnding = detectLineEnding(content);
-                const normalizedContent = normalizeToLF(content);
-                const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
-                throwIfAborted();
-                const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-                await ops.writeFile(absolutePath, finalContent);
-                throwIfAborted();
-                const diffResult = generateDiffString(baseContent, newContent);
-                const patch = generateUnifiedPatch(path, baseContent, newContent);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Successfully replaced ${edits.length} block(s) in ${path}.`,
-                        },
-                    ],
-                    details: { diff: diffResult.diff, patch, firstChangedLine: diffResult.firstChangedLine },
-                };
-            });
-        },
+        ...createCoreEditToolDefinition(cwd, {
+            ...options,
+            machine: options?.machine ?? defaultToolMachine(),
+            resolvePath: resolveToCwd,
+            withMutationQueue: withFileMutationQueue,
+            canonicalizePath: canonicalizeFilesystemPath,
+        }),
         ...editRenderers,
     };
 }

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

@@ -0,0 +1,10 @@
+/** Bytes `text` takes as UTF-8; a lone surrogate counts as its 3-byte replacement character, as `Buffer.byteLength` does. */
+export declare function utf8ByteLength(text: string): number;
+export declare function encodeUtf8(text: string): Uint8Array;
+/** Decodes like `Buffer#toString("utf-8")`: invalid sequences become U+FFFD and a leading BOM is kept. */
+export declare function decodeUtf8(bytes: Uint8Array): string;
+export declare function concatBytes(chunks: readonly Uint8Array[]): Uint8Array;
+export declare function encodeBase64(bytes: Uint8Array): string;
+/** Decodes base64url text to UTF-8 like `Buffer.from(text, "base64url")`: a dangling final character is ignored. */
+export declare function decodeBase64UrlUtf8(text: string): string;
+//# sourceMappingURL=encoding.d.ts.map

package/dist/core/tools/encoding.js

@@ -0,0 +1,58 @@
+// UTF-8 and base64 byte work without the Node `Buffer` global, so the tool cores also run on hosts that lack it.
+const encoder = new TextEncoder();
+/** Bytes `text` takes as UTF-8; a lone surrogate counts as its 3-byte replacement character, as `Buffer.byteLength` does. */
+export function utf8ByteLength(text) {
+    let bytes = 0;
+    for (let index = 0; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {
+            const next = text.charCodeAt(index + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                bytes += 4;
+                index++;
+            }
+            else
+                bytes += 3;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+export function encodeUtf8(text) {
+    return encoder.encode(text);
+}
+/** Decodes like `Buffer#toString("utf-8")`: invalid sequences become U+FFFD and a leading BOM is kept. */
+export function decodeUtf8(bytes) {
+    return new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes);
+}
+export function concatBytes(chunks) {
+    const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const joined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        joined.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return joined;
+}
+const BASE64_CHUNK = 0x8000;
+export function encodeBase64(bytes) {
+    let binary = "";
+    for (let start = 0; start < bytes.length; start += BASE64_CHUNK) {
+        binary += String.fromCharCode(...bytes.subarray(start, start + BASE64_CHUNK));
+    }
+    return btoa(binary);
+}
+/** Decodes base64url text to UTF-8 like `Buffer.from(text, "base64url")`: a dangling final character is ignored. */
+export function decodeBase64UrlUtf8(text) {
+    const usable = text.length % 4 === 1 ? text.slice(0, -1) : text;
+    const base64 = usable.replaceAll("-", "+").replaceAll("_", "/");
+    const binary = atob(base64.padEnd(Math.ceil(base64.length / 4) * 4, "="));
+    return decodeUtf8(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+}
+//# sourceMappingURL=encoding.js.map

package/dist/core/tools/file-tool-host.d.ts

@@ -0,0 +1,25 @@
+/** Resolves a model-given path against the working directory. */
+export type ToolPathResolver = (path: string, cwd: string) => string;
+/** Serializes the mutations of one file. */
+export type FileMutationQueue = <T>(absolutePath: string, fn: () => Promise<T>) => Promise<T>;
+/** The path an extension filesystem policy judges. */
+export type ToolPathCanonicalizer = (absolutePath: string) => Promise<string>;
+/**
+ * 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 declare const resolvePosixToolPath: ToolPathResolver;
+export declare function posixDirname(path: string): string;
+/** Serializes mutations per resolved path string within this isolate. */
+export declare const inProcessFileMutationQueue: FileMutationQueue;
+export declare const lexicalCanonicalPath: ToolPathCanonicalizer;
+export declare function tryMacOSScreenshotPath(filePath: string): string;
+export declare function tryNFDVariant(filePath: string): string;
+export declare function tryCurlyQuoteVariant(filePath: string): string;
+export declare function unquotedPath(filePath: string): string | undefined;
+/**
+ * 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 declare function resolveReadPathVariants(filePath: string, cwd: string, resolve: ToolPathResolver, exists: (path: string) => Promise<boolean>): Promise<string>;
+//# sourceMappingURL=file-tool-host.d.ts.map