@youdie006/prodex 0.40.50 → 0.40.51

package/dist/mcp.js

@@ -15,7 +15,17 @@ const BridgeFileInputSchema = z.object({
     role: z.enum(["context", "artifact", "result"]).optional(),
     bytes: z.number().int().nonnegative().optional()
 });
-export const DEFAULT_STDIO_MESSAGE_LIMIT_BYTES = 1_048_576;
+/**
+ * Large enough for the largest call the tools accept. That is
+ * bridge_block_task with every list full: 100 commands and 100 warnings of
+ * 100,000 characters, 100 artifact paths of 10,000 and its text fields, about
+ * 21.2 million characters. JSON may write each one as a six-byte \uXXXX escape
+ * (a control character is one byte to the handlers' byte checks), so the frame
+ * can reach 127.3 MB. The old 1 MiB closed the session on a 1,000,000-character
+ * repo_write_file_dry_run that had only its newlines escaped. The limit still
+ * caps what a client that never sends a newline can make this process buffer.
+ */
+export const DEFAULT_STDIO_MESSAGE_LIMIT_BYTES = 128 * 1024 * 1024;
 function asText(value) {
     return {
         content: [
@@ -144,7 +154,7 @@ export function createServer(cwd = process.cwd(), options = {}) {
         inputSchema: { query: McpBridgeTextSchema.min(1), glob: McpShortTextSchema.optional() }
     }, async (input) => asText(await handlers.repo_search(input)));
     server.registerTool("repo_write_file_dry_run", {
-        description: "Create a receipt-gated write preview for an existing repo-relative text file. Does not modify files. The file keeps its CRLF line endings and UTF-8 BOM when the new content leaves them out.",
+        description: "Create a receipt-gated write preview for an existing repo-relative text file. Does not modify files. The file keeps its CRLF line endings, UTF-8 BOM and final newline when the new content leaves them out, and keeps its file mode. A file that is not UTF-8 text is refused.",
         inputSchema: {
             path: McpShortTextSchema,
             content: z.string().max(1_000_000),
@@ -234,7 +244,9 @@ export function createServer(cwd = process.cwd(), options = {}) {
                         // Progress delivery must never break the consult.
                     });
                 };
-            return asText(withServerVersionNotice(await browserConsult({ ...input, session_key: input.session_key ?? mcpSessionKey }, onProgress), serverVersionNotice()));
+            // A client that cancels (Esc, its own timeout) aborts extra.signal.
+            // The consult stops on it until the prompt is submitted.
+            return asText(withServerVersionNotice(await browserConsult({ ...input, session_key: input.session_key ?? mcpSessionKey }, onProgress, extra.signal), serverVersionNotice()));
         });
     }
     const browserRecover = options.browserRecover;
@@ -250,9 +262,23 @@ export function createServer(cwd = process.cwd(), options = {}) {
     }
     return server;
 }
-export async function runMcpServer(cwd = process.cwd(), options = {}) {
+export async function runMcpServer(cwd = process.cwd(), options = {}, stdio = {}) {
     const server = createServer(cwd, options);
-    const transport = new LimitedStdioServerTransport();
+    const transport = new LimitedStdioServerTransport(process.stdin, process.stdout, stdio);
+    // Set before connect, which chains its own close handler after this one.
+    transport.onclose = () => {
+        const reason = transport.fatalInputError;
+        if (!reason)
+            return;
+        // The client is still waiting on its requests, and a closed transport
+        // answers none of them. Only the process exiting tells it the server is
+        // gone; without this it waited out its tool timeout (about 28 hours in
+        // Claude Code), or saw a clean exit 0, with nothing said either way.
+        process.exitCode = 1;
+        const exit = () => process.exit(1);
+        setTimeout(exit, 2_000);
+        process.stderr.write(`prodex mcp: ${reason.message}; closing the stdio session.\n`, exit);
+    };
     await server.connect(transport);
 }
 export class LimitedStdioServerTransport {
@@ -263,7 +289,13 @@ export class LimitedStdioServerTransport {
     onmessage;
     sessionId;
     setProtocolVersion;
-    buffer = Buffer.alloc(0);
+    /** Set when unreadable input closed the transport (an oversize message, a stdin error). */
+    fatalInputError;
+    // The unfinished message, as the chunks it arrived in. Joining each chunk
+    // onto one buffer and rescanning it for a newline made a large message cost
+    // time quadratic in its size.
+    pending = [];
+    pendingBytes = 0;
     started = false;
     closed = false;
     maxMessageBytes;
@@ -290,7 +322,8 @@ export class LimitedStdioServerTransport {
         if (this.stdin.listenerCount("data") === 0) {
             this.stdin.pause();
         }
-        this.buffer = Buffer.alloc(0);
+        this.pending = [];
+        this.pendingBytes = 0;
         this.onclose?.();
     }
     async send(message) {
@@ -328,50 +361,64 @@ export class LimitedStdioServerTransport {
     }
     onData = (chunk) => {
         try {
-            const buffer = Buffer.from(chunk);
-            this.buffer = this.buffer.length === 0 ? buffer : Buffer.concat([this.buffer, buffer]);
-            this.processBuffer();
+            this.processChunk(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
         }
         catch (error) {
-            this.buffer = Buffer.alloc(0);
-            this.onerror?.(error instanceof Error ? error : new Error(String(error)));
-            void this.close();
+            this.failInput(error instanceof Error ? error : new Error(String(error)));
         }
     };
     onInputError = (error) => {
+        this.failInput(error);
+    };
+    failInput(error) {
+        if (this.closed)
+            return;
+        this.fatalInputError = error;
         this.onerror?.(error);
         void this.close();
-    };
-    processBuffer() {
-        while (true) {
-            const newlineIndex = this.buffer.indexOf("\n");
+    }
+    processChunk(chunk) {
+        let start = 0;
+        while (!this.closed) {
+            const newlineIndex = chunk.indexOf(0x0a, start);
             if (newlineIndex === -1) {
-                if (this.buffer.length > this.maxMessageBytes) {
-                    throw new Error(`MCP stdio message is too large (${this.buffer.length} bytes > ${this.maxMessageBytes} bytes)`);
+                if (start < chunk.length) {
+                    this.pending.push(chunk.subarray(start));
+                    this.pendingBytes += chunk.length - start;
+                }
+                if (this.pendingBytes > this.maxMessageBytes) {
+                    throw new Error(`MCP stdio message is too large (at least ${this.pendingBytes} bytes, limit ${this.maxMessageBytes} bytes)`);
                 }
                 return;
             }
-            if (newlineIndex > this.maxMessageBytes) {
-                throw new Error(`MCP stdio message is too large (${newlineIndex} bytes > ${this.maxMessageBytes} bytes)`);
+            const lineBytes = this.pendingBytes + newlineIndex - start;
+            if (lineBytes > this.maxMessageBytes) {
+                throw new Error(`MCP stdio message is too large (${lineBytes} bytes, limit ${this.maxMessageBytes} bytes)`);
             }
-            const line = this.buffer.toString("utf8", 0, newlineIndex).replace(/\r$/, "");
-            this.buffer = this.buffer.subarray(newlineIndex + 1);
-            if (line.trim().length === 0)
-                continue;
-            let message;
-            try {
-                message = JSONRPCMessageSchema.parse(JSON.parse(line));
-            }
-            catch (error) {
-                // A single malformed frame is recoverable: report it and keep
-                // processing the rest of the buffer instead of tearing down the whole
-                // session (which would also drop any valid pipelined messages after
-                // it). This matches the SDK's StdioServerTransport. Only the oversize
-                // guards above stay fatal.
-                this.onerror?.(error instanceof Error ? error : new Error(String(error)));
-                continue;
-            }
-            this.onmessage?.(message);
+            const tail = chunk.subarray(start, newlineIndex);
+            const lineBuffer = this.pending.length === 0 ? tail : Buffer.concat([...this.pending, tail], lineBytes);
+            this.pending = [];
+            this.pendingBytes = 0;
+            start = newlineIndex + 1;
+            this.processLine(lineBuffer.toString("utf8").replace(/\r$/, ""));
+        }
+    }
+    processLine(line) {
+        if (line.trim().length === 0)
+            return;
+        let message;
+        try {
+            message = JSONRPCMessageSchema.parse(JSON.parse(line));
+        }
+        catch (error) {
+            // A single malformed frame is recoverable: report it and keep
+            // processing the rest of the buffer instead of tearing down the whole
+            // session (which would also drop any valid pipelined messages after
+            // it). This matches the SDK's StdioServerTransport. Only the oversize
+            // guards above stay fatal.
+            this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+            return;
         }
+        this.onmessage?.(message);
     }
 }

package/dist/repo-write.js

@@ -4,7 +4,7 @@ import { realpath } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { assertResolvedRepoPathAllowed, resolveRepoPath } from "./repo.js";
-import { readVerifiedUtf8File, replaceVerifiedUtf8File, withCrossProcessFileLock } from "./safe-file.js";
+import { NotUtf8Error, readVerifiedUtf8File, replaceVerifiedUtf8File, withCrossProcessFileLock } from "./safe-file.js";
 const execFileAsync = promisify(execFile);
 const MAX_WRITE_BYTES = 1_000_000;
 let testHooks = {};
@@ -17,12 +17,19 @@ export function setRepoWriteTestHooks(hooks) {
  * a UTF-8 BOM was dropped the same way. Keep what the file already uses, as an
  * editor does: CRLF only when the file uses it throughout and the new content
  * carries no CR of its own, and a BOM only when the new content has none.
+ *
+ * repo_read_file also returns its lines without a newline after the last one,
+ * so writing back what was read dropped the file's final newline (found
+ * 2026-11-09). A file that ends with one keeps it unless the new content is
+ * empty.
  */
 export function keepFileConventions(current, next) {
     let content = next;
     const crlf = current.includes("\r\n") && !/(^|[^\r])\n/.test(current);
     if (crlf && !content.includes("\r"))
         content = content.replace(/\n/g, "\r\n");
+    if (current.endsWith("\n") && content !== "" && !content.endsWith("\n"))
+        content += crlf ? "\r\n" : "\n";
     if (current.startsWith("\uFEFF") && !content.startsWith("\uFEFF"))
         content = `\uFEFF${content}`;
     return content;
@@ -34,6 +41,11 @@ export async function createRepoWriteDryRun(root, store, input) {
     }
     const current = await readWritableExistingFile(root, input.path);
     const content = keepFileConventions(current.content, input.content);
+    // Restoring CRLF and a BOM adds bytes, so the limit is checked again on what
+    // will be written: content that apply refuses used to pass the dry run.
+    if (Buffer.byteLength(content, "utf8") > MAX_WRITE_BYTES) {
+        throw new Error(`New content is too large to write through repo tools`);
+    }
     if (current.content === content) {
         throw new Error(`No changes for ${input.path}`);
     }
@@ -211,7 +223,10 @@ export async function stageReviewedPaths(root, store, input) {
     try {
         await testHooks.beforeGitAdd?.(stagedPaths);
         await assertGitHead(root, input.expected_head);
-        await execFileAsync("git", ["add", "--", ...stagedPaths], { cwd: root });
+        // Literal: read as pathspecs, a reviewed "pages/[id].tsx" also staged an
+        // unreviewed "pages/i.tsx" (found 2026-11-09). Every git call here that
+        // takes a reviewed path reads it literally.
+        await execFileAsync("git", ["--literal-pathspecs", "add", "--", ...stagedPaths], { cwd: root });
         staged = true;
         await verifyStagedContent(root, expectedObjectIdByPath);
         await testHooks.beforeStageReceipt?.(stagedPaths);
@@ -269,7 +284,7 @@ async function verifyStagedContent(root, expectedObjectIdByPath) {
     }
 }
 async function gitObjectIdForStagedPath(root, gitPath) {
-    const { stdout } = await execFileAsync("git", ["ls-files", "--stage", "-z", "--", gitPath], {
+    const { stdout } = await execFileAsync("git", ["--literal-pathspecs", "ls-files", "--stage", "-z", "--", gitPath], {
         cwd: root,
         maxBuffer: MAX_WRITE_BYTES + 1024
     });
@@ -283,7 +298,7 @@ async function gitObjectIdForStagedPath(root, gitPath) {
 async function readGitIndexEntries(root, paths) {
     const entries = new Map();
     for (const gitPath of paths) {
-        const { stdout } = await execFileAsync("git", ["ls-files", "--stage", "-z", "--", gitPath], {
+        const { stdout } = await execFileAsync("git", ["--literal-pathspecs", "ls-files", "--stage", "-z", "--", gitPath], {
             cwd: root,
             encoding: "buffer",
             maxBuffer: MAX_WRITE_BYTES + 1024
@@ -308,7 +323,7 @@ async function restoreGitIndexEntries(root, entries) {
             await execFileAsync("git", ["update-index", "--add", "--cacheinfo", entry.mode, entry.objectId, gitPath], { cwd: root });
         }
         else {
-            await execFileAsync("git", ["rm", "--cached", "--ignore-unmatch", "--", gitPath], { cwd: root });
+            await execFileAsync("git", ["--literal-pathspecs", "rm", "--cached", "--ignore-unmatch", "--", gitPath], { cwd: root });
         }
     }
 }
@@ -375,11 +390,15 @@ async function readWritableExistingFile(root, repoPath) {
     const resolved = resolveRepoPath(root, repoPath);
     await assertResolvedRepoPathAllowed(root, resolved, repoPath);
     const content = await readVerifiedUtf8File(resolved, () => assertResolvedRepoPathAllowed(root, resolved, repoPath), {
-        maxBytes: MAX_WRITE_BYTES
+        maxBytes: MAX_WRITE_BYTES,
+        requireUtf8: true
     }).catch((error) => {
         if (error instanceof Error && /too large/.test(error.message)) {
             throw new Error(`Path ${repoPath} is too large to write through repo tools`);
         }
+        if (error instanceof NotUtf8Error) {
+            throw new Error(`Path ${repoPath} is not UTF-8 text. Repo tools write UTF-8 only, so writing it would change its encoding; edit it with a tool that keeps its encoding.`);
+        }
         throw error;
     });
     return { resolved, content };

package/dist/repo.js

@@ -57,11 +57,16 @@ export function assertRepoRelativePath(repoPath) {
     }
     assertNotSensitiveRepoPath(normalized);
 }
+// "..notes.md" is a file in the root; only ".." itself or a path through it
+// leaves it.
+function escapesRoot(relative) {
+    return relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
+}
 export function resolveRepoPath(root, repoPath) {
     assertRepoRelativePath(repoPath);
     const resolved = path.resolve(root, repoPath);
     const relative = path.relative(root, resolved);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    if (escapesRoot(relative)) {
         throw new Error(`Path ${repoPath} escapes the repository root`);
     }
     return resolved;
@@ -103,6 +108,9 @@ export async function searchRepoWithMetadata(root, query, glob) {
     if (!query.trim()) {
         throw new Error("Search query must not be empty");
     }
+    if (/[\r\n]/.test(query)) {
+        throw new Error("repo_search matches one line at a time, so a query cannot contain a line break; search for one of its lines.");
+    }
     if (glob) {
         assertRepoRelativeGlob(glob);
     }
@@ -110,12 +118,20 @@ export async function searchRepoWithMetadata(root, query, glob) {
         "--no-config",
         "--no-follow",
         "--json",
+        // repo_read_file reads .github/, .eslintrc and the like, and without this
+        // ripgrep skipped every hidden file. Results still pass the same path
+        // policy as reads, and the globs below keep the sensitive ones unopened.
+        "--hidden",
         ...(glob ? ["--glob", glob] : []),
         "--glob",
         "!.bridge/**",
         "--glob",
         "!**/.bridge/**",
         "--glob",
+        "!.git",
+        "--glob",
+        "!**/.git",
+        "--glob",
         "!.git/**",
         "--glob",
         "!**/.git/**",
@@ -154,23 +170,7 @@ export async function searchRepoWithMetadata(root, query, glob) {
             timeout: 10_000,
             maxBuffer: 1024 * 1024
         });
-        const parsedMatches = stdout
-            .split("\n")
-            .filter(Boolean)
-            .map(parseRipgrepJsonMatch)
-            .filter((match) => match !== undefined);
-        const allowedMatches = [];
-        let truncated = false;
-        for (const match of parsedMatches) {
-            if (await isAllowedRepoSearchResult(root, match.path)) {
-                if (allowedMatches.length >= MAX_REPO_SEARCH_MATCHES) {
-                    truncated = true;
-                    break;
-                }
-                allowedMatches.push(match);
-            }
-        }
-        return { matches: allowedMatches, truncated, limit: MAX_REPO_SEARCH_MATCHES };
+        return await allowedSearchResult(root, stdout, false);
     }
     catch (error) {
         const maybe = error;
@@ -178,10 +178,23 @@ export async function searchRepoWithMetadata(root, query, glob) {
             throw new Error("ripgrep (rg) is required on PATH for repo_search");
         }
         if (isSearchOutputTooLarge(error)) {
+            // A broad query outgrew the buffer: return the matches read so far,
+            // marked truncated, rather than none.
+            const partial = await allowedSearchResult(root, maybe.stdout ?? "", true);
+            if (partial.matches.length > 0)
+                return partial;
             throw new Error("repo_search returned too many matches; narrow the query or glob and try again");
         }
         if (maybe.code === 1)
             return { matches: [], truncated: false, limit: MAX_REPO_SEARCH_MATCHES };
+        // ripgrep exits 2 when it could not read some path (a directory it may
+        // not enter, say) but still prints what it found elsewhere; that used to
+        // fail the whole search with the raw command line.
+        if (maybe.code === 2 && !ripgrepRegexError(error.stderr)) {
+            const partial = await allowedSearchResult(root, maybe.stdout ?? "", false);
+            if (partial.matches.length > 0)
+                return partial;
+        }
         // An invalid pattern used to surface as "Command failed: <rg path> ..."
         // with rg's parse error buried in it (measured 2026-10-21, query "(").
         const reason = ripgrepRegexError(error.stderr);
@@ -191,6 +204,24 @@ export async function searchRepoWithMetadata(root, query, glob) {
         throw error;
     }
 }
+async function allowedSearchResult(root, stdout, truncated) {
+    const parsedMatches = stdout
+        .split("\n")
+        .filter(Boolean)
+        .map(parseRipgrepJsonMatch)
+        .filter((match) => match !== undefined);
+    const allowedMatches = [];
+    for (const match of parsedMatches) {
+        if (await isAllowedRepoSearchResult(root, match.path)) {
+            if (allowedMatches.length >= MAX_REPO_SEARCH_MATCHES) {
+                truncated = true;
+                break;
+            }
+            allowedMatches.push(match);
+        }
+    }
+    return { matches: allowedMatches, truncated, limit: MAX_REPO_SEARCH_MATCHES };
+}
 function ripgrepRegexError(stderr) {
     if (!stderr || !/regex parse error/i.test(stderr))
         return undefined;
@@ -208,11 +239,17 @@ function parseRipgrepJsonMatch(line) {
     if (!isRipgrepJsonMatch(event))
         return undefined;
     return {
-        path: normalizeRipgrepMatchPath(event.data.path.text),
+        path: normalizeRipgrepMatchPath(ripgrepText(event.data.path)),
         line: event.data.line_number,
-        text: stripOneTrailingLineEnding(event.data.lines.text)
+        text: stripOneTrailingLineEnding(ripgrepText(event.data.lines))
     };
 }
+function ripgrepText(value) {
+    return "text" in value ? value.text : Buffer.from(value.bytes, "base64").toString("utf8");
+}
+function isRipgrepJsonText(value) {
+    return isRecord(value) && (typeof value.text === "string" || typeof value.bytes === "string");
+}
 function normalizeRipgrepMatchPath(matchPath) {
     return matchPath.split(path.sep).join("/").replace(/^\.\//, "");
 }
@@ -220,12 +257,7 @@ function isRipgrepJsonMatch(value) {
     if (!isRecord(value) || value.type !== "match" || !isRecord(value.data))
         return false;
     const { path: matchPath, line_number: lineNumber, lines } = value.data;
-    return (isRecord(matchPath) &&
-        typeof matchPath.text === "string" &&
-        typeof lineNumber === "number" &&
-        Number.isFinite(lineNumber) &&
-        isRecord(lines) &&
-        typeof lines.text === "string");
+    return isRipgrepJsonText(matchPath) && typeof lineNumber === "number" && Number.isFinite(lineNumber) && isRipgrepJsonText(lines);
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null;
@@ -494,7 +526,7 @@ export async function assertResolvedRepoPathAllowed(root, resolved, repoPath) {
         throw error;
     }
     const relative = path.relative(realRoot, realTarget);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    if (escapesRoot(relative)) {
         throw new Error(`Path ${repoPath} escapes the repository root after resolving symlinks`);
     }
     if (relative) {

package/dist/safe-file.js

@@ -1,3 +1,4 @@
+import { isUtf8 } from "node:buffer";
 import { randomUUID } from "node:crypto";
 import { constants, readFileSync } from "node:fs";
 import { chmod, link, lstat, mkdir, open, realpath, rename, rm } from "node:fs/promises";
@@ -20,6 +21,8 @@ export async function withCrossProcessFileLock(filePath, options, fn) {
     let retriedMissingAtDeadline = false;
     let lease;
     for (;;) {
+        if (options.signal?.aborted)
+            throw options.abortedError?.() ?? new Error("Stopped waiting for the lock: the caller cancelled");
         lease = await tryAcquireFileLock(filePath, parentSnapshot);
         if (lease)
             break;
@@ -49,7 +52,7 @@ export async function withCrossProcessFileLock(filePath, options, fn) {
             waited = true;
             options.onWait?.(snapshot.holder);
         }
-        await delay(Math.min(retryMs, Math.max(1, deadline - Date.now())));
+        await delay(Math.min(retryMs, Math.max(1, deadline - Date.now())), options.signal);
     }
     try {
         return await fn();
@@ -58,6 +61,18 @@ export async function withCrossProcessFileLock(filePath, options, fn) {
         await releaseFileLockLease(filePath, lease, parentSnapshot);
     }
 }
+/**
+ * A file whose bytes are not UTF-8. Read as UTF-8, such bytes become U+FFFD,
+ * and writing the text back destroys them: measured 2026-11-09, an EUC-KR
+ * "한글" line came back as replacement characters through repo writes while
+ * the diff showed the line as unchanged. Writers ask for it to be refused.
+ */
+export class NotUtf8Error extends Error {
+    constructor() {
+        super("Target file is not UTF-8 text");
+        this.name = "NotUtf8Error";
+    }
+}
 export async function readVerifiedUtf8File(filePath, validate, options = {}) {
     await validate();
     const parentSnapshot = await captureParentSnapshot(filePath);
@@ -72,7 +87,7 @@ export async function readVerifiedUtf8File(filePath, validate, options = {}) {
         if (options.maxBytes !== undefined && stat.size > options.maxBytes) {
             throw new Error(`Target file is too large (${stat.size} bytes)`);
         }
-        const content = await readHandleUtf8(handle, filePath, options.maxBytes, options.decodeUtf16Bom === true);
+        const content = await readHandleUtf8(handle, filePath, options.maxBytes, options.decodeUtf16Bom === true, options.requireUtf8 === true);
         if (options.mode !== undefined) {
             await testHooks.beforeChmod?.(filePath, "read");
             await assertSafeOpenFile(handle, filePath, "read");
@@ -127,19 +142,24 @@ export async function replaceVerifiedUtf8File(filePath, content, validate, verif
     const parentSnapshot = await captureParentSnapshot(filePath);
     await testHooks.beforeOpen?.(filePath, "write");
     const handle = await openStableNoFollow(filePath, constants.O_RDWR, "write", parentSnapshot, options.mode);
+    // The replacement is a new file renamed into place, so it takes the mode of
+    // the file it replaces unless one is given: created with the default mode,
+    // an edited script lost its executable bit (found 2026-11-09).
+    let mode = options.mode;
     try {
         const currentContent = await readHandleUtf8(handle, filePath, options.maxBytes);
         await verifyCurrentContent(currentContent);
         await testHooks.beforeReplace?.(filePath);
         const latestContent = await readHandleUtf8(handle, filePath, options.maxBytes);
         await verifyCurrentContent(latestContent);
+        mode ??= (await handle.stat()).mode & 0o777;
         await testHooks.beforeWrite?.(filePath, "write");
     }
     finally {
         await handle.close();
     }
     // Windows cannot replace some files while their verification handle is open.
-    await replaceByVerifiedTempFile(filePath, content, validate, options, {
+    await replaceByVerifiedTempFile(filePath, content, validate, { ...options, mode }, {
         beforeOpenAlreadyRan: true,
         beforeWriteAlreadyRan: true,
         parentSnapshot,
@@ -186,7 +206,7 @@ async function replaceByVerifiedTempFile(filePath, content, validate, options =
         throw error;
     }
 }
-async function readHandleUtf8(handle, filePath, maxBytes, decodeUtf16Bom = false) {
+async function readHandleUtf8(handle, filePath, maxBytes, decodeUtf16Bom = false, requireUtf8 = false) {
     await assertOpenFileMatchesPath(handle, filePath, "read");
     const stat = await handle.stat();
     if (!stat.isFile()) {
@@ -207,7 +227,10 @@ async function readHandleUtf8(handle, filePath, maxBytes, decodeUtf16Bom = false
             throw new Error(`Target file is too large (${offset} bytes)`);
         }
     }
-    return decodeFileText(buffer.subarray(0, offset), decodeUtf16Bom);
+    const bytes = buffer.subarray(0, offset);
+    if (requireUtf8 && !isUtf8(bytes))
+        throw new NotUtf8Error();
+    return decodeFileText(bytes, decodeUtf16Bom);
 }
 /**
  * UTF-8, or UTF-16 when asked and the file starts with its BOM. Windows
@@ -641,8 +664,19 @@ function linuxProcessStartTicks(pid) {
         return undefined;
     }
 }
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+/** Resolves after ms, or as soon as signal aborts. */
+function delay(ms, signal) {
+    if (!signal)
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", done);
+            resolve();
+        };
+        const timer = setTimeout(done, ms);
+        signal.addEventListener("abort", done, { once: true });
+    });
 }
 function procFdPath(fd) {
     return `/proc/self/fd/${fd}`;