@poe-platform/safe-bash 0.1.816 → 0.1.817

package/dist/safe-bash/command-chunks/{chunk-GEDO5V32.js → chunk-FSG6UC2N.js}

@@ -15,19 +15,197 @@ import {
   sideBySide
 } from "./chunk-VXIC7SS3.js";
 
+// packages/safe-bash-command-diff/src/stored-directory.ts
+import { PagedStorage, PagedStorageCache } from "@poe-platform/safe-fs/storage";
+import { closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
+import { host, ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { pathOf } from "../../safe-bash-io-engine/internal.js";
+import { FsError } from "../../safe-bash-contracts/index.js";
+var Rows = class {
+  constructor(budget, cache) {
+    this.budget = budget;
+    this.data = new PagedStorage(budget.context, 16, cache);
+    this.index = new PagedStorage(budget.context, 16, cache);
+  }
+  budget;
+  data;
+  index;
+  length = 0;
+  base = 8;
+  async append(row) {
+    const text = JSON.stringify(row), start = this.data.allocate(0);
+    for (let offset = 0; offset < text.length; ) {
+      let end = Math.min(text.length, offset + 4096);
+      const last = text.charCodeAt(end - 1);
+      if (last >= 55296 && last <= 56319 && end < text.length) end--;
+      await this.data.append(new TextEncoder().encode(text.slice(offset, end)));
+      offset = end;
+    }
+    const cell = new Uint8Array(24), view = new DataView(cell.buffer);
+    view.setFloat64(0, start, true);
+    view.setFloat64(8, this.data.allocate(0) - start, true);
+    await this.index.append(cell);
+    this.length++;
+  }
+  async read(position) {
+    this.budget.step();
+    const pause = this.budget.checkpoint();
+    if (pause) await pause;
+    const cell = await this.index.read(this.base + position * 24, 16), view = new DataView(cell.buffer, cell.byteOffset, cell.byteLength);
+    const start = view.getFloat64(0, true), end = start + view.getFloat64(8, true), decoder = new TextDecoder();
+    let text = "";
+    for (let offset = start; offset < end; offset += 16384) text += decoder.decode(await this.data.read(offset, Math.min(16384, end - offset)), { stream: true });
+    return JSON.parse(text + decoder.decode());
+  }
+  async mark(position) {
+    await this.index.write(this.base + position * 24 + 16, new Uint8Array([1]));
+  }
+  async marked(position) {
+    return (await this.index.read(this.base + position * 24 + 16, 1))[0] === 1;
+  }
+  async sort(compare) {
+    let target = this.index.allocate(this.length * 24);
+    for (let width = 1; width < this.length; width *= 2) {
+      for (let start = 0; start < this.length; start += width * 2) {
+        const middle = Math.min(start + width, this.length), end = Math.min(start + width * 2, this.length);
+        let left = start, right = middle, a = left < middle ? await this.read(left) : void 0, b = right < end ? await this.read(right) : void 0;
+        for (let position = start; position < end; position++) {
+          this.budget.step();
+          const pause = this.budget.checkpoint();
+          if (pause) await pause;
+          const takeLeft = b === void 0 || a !== void 0 && compare(a, b) <= 0;
+          const source = takeLeft ? left : right;
+          await this.index.write(target + position * 24, await this.index.read(this.base + source * 24, 24));
+          if (takeLeft) a = ++left < middle ? await this.read(left) : void 0;
+          else b = ++right < end ? await this.read(right) : void 0;
+        }
+      }
+      const previous = this.base;
+      this.base = target;
+      target = previous;
+    }
+  }
+  close() {
+    return closeDocumentResources([this.data, this.index]);
+  }
+};
+var compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+async function* directoryMatches(left, right, budget, ignoreCase, maxEntries, excluded, startingFile) {
+  const cache = new PagedStorageCache(16), matches = new Rows(budget, cache);
+  let entries = new Rows(budget, cache);
+  const context = budget.context, key = (name) => ignoreCase ? name.replace(/[A-Z]/gu, (letter) => letter.toLowerCase()) : name;
+  try {
+    const restart = /* @__PURE__ */ Symbol("prepare directory backing storage");
+    for (let prepared = false; ; prepared = true) {
+      let admittedBytes = 0;
+      try {
+        for (const [side, path] of [["left", left], ["right", right]]) {
+          if (path === void 0) continue;
+          const absolute = pathOf(context, path);
+          if (Number.isFinite(maxEntries) && (!Number.isSafeInteger(maxEntries) || maxEntries < 0))
+            throw new FsError("EINVAL", { syscall: "readdir", path: absolute, message: "directory entry limit must be a nonnegative safe integer or Infinity" });
+          const source = context.fs.iterateDirectory ? context.fs.iterateDirectory(absolute, { signal: context.signal }) : await host(context, () => context.fs.readdir(absolute, { signal: context.signal, ...Number.isFinite(maxEntries) ? { maxEntries } : {} }));
+          let count2 = 0;
+          const iterator = Array.isArray(source) ? source[Symbol.iterator]() : source[Symbol.asyncIterator]();
+          try {
+            for (; ; ) {
+              const item = await host(context, async () => iterator.next());
+              if (item.done) break;
+              const entry = item.value;
+              if (++count2 > maxEntries) throw new FsError("EFBIG", { syscall: "readdir", path: absolute, message: "directory entry limit exceeded" });
+              budget.step();
+              const pause = budget.checkpoint();
+              if (pause) await pause;
+              if (!entry.name || entry.name === "." || entry.name === ".." || /[/\\\0\r\n\t]/u.test(entry.name)) throw new ToolError("unsafe directory entry name");
+              if (!await excluded(entry.name)) {
+                admittedBytes += entry.name.length * 6 + 128;
+                if (!prepared && admittedBytes > 128 * 1024) throw restart;
+                await entries.append({ name: entry.name, side });
+              }
+            }
+          } finally {
+            await iterator.return?.();
+          }
+        }
+        break;
+      } catch (error) {
+        if (error !== restart) throw error;
+        await entries.close();
+        entries = new Rows(budget, cache);
+        await entries.data.prepare();
+        await entries.index.prepare();
+      }
+    }
+    await entries.sort((a, b) => compareText(key(a.name), key(b.name)) || compareText(a.name, b.name) || compareText(a.side, b.side));
+    let count = 0;
+    for (let begin = 0; begin < entries.length; ) {
+      const group = key((await entries.read(begin)).name);
+      let end = begin, leftCount = 0, rightCount = 0;
+      while (end < entries.length) {
+        const entry = await entries.read(end);
+        if (key(entry.name) !== group) break;
+        if (entry.side === "left") leftCount++;
+        else rightCount++;
+        end++;
+      }
+      count += Math.max(leftCount, rightCount);
+      if (count > maxEntries) throw new ToolError("file/entry limit exceeded");
+      if (startingFile === void 0 || group >= key(startingFile)) {
+        const next = async (position, side, unmatched = false) => {
+          while (position < end) {
+            const entry = await entries.read(position);
+            if (entry.side === side && (!unmatched || !await entries.marked(position))) return { position, name: entry.name };
+            position++;
+          }
+          return void 0;
+        };
+        let a = await next(begin, "left"), b = await next(begin, "right");
+        while (a && b) {
+          budget.step();
+          const pause = budget.checkpoint();
+          if (pause) await pause;
+          const order = compareText(a.name, b.name);
+          if (order === 0) {
+            await matches.append({ left: a.name, right: b.name });
+            await entries.mark(a.position);
+            await entries.mark(b.position);
+          }
+          if (order <= 0) a = await next(a.position + 1, "left");
+          if (order >= 0) b = await next(b.position + 1, "right");
+        }
+        a = await next(begin, "left", true);
+        b = await next(begin, "right", true);
+        while (a || b) {
+          await matches.append({ ...a ? { left: a.name } : {}, ...b ? { right: b.name } : {} });
+          if (a) a = await next(a.position + 1, "left", true);
+          if (b) b = await next(b.position + 1, "right", true);
+        }
+      }
+      begin = end;
+    }
+    await matches.sort((a, b) => {
+      const first = a.left ?? a.right, second = b.left ?? b.right;
+      return compareText(key(first), key(second)) || Number(a.left === void 0 || a.right === void 0) - Number(b.left === void 0 || b.right === void 0) || compareText(first, second);
+    });
+    for (let index = matches.length - 1; index >= 0; index--) yield await matches.read(index);
+  } finally {
+    await closeDocumentResources([entries, matches]);
+  }
+}
+
 // packages/safe-bash-command-diff/src/diff.ts
-import { closeDocumentResources as closeDocumentResources3 } from "../../safe-bash-diff-engine/document.js";
-import { PagedStorage as PagedStorage4 } from "@poe-platform/safe-fs/storage";
+import { closeDocumentResources as closeDocumentResources4 } from "../../safe-bash-diff-engine/document.js";
+import { PagedStorage as PagedStorage5 } from "@poe-platform/safe-fs/storage";
 
 // packages/safe-bash-command-diff/src/indexed.ts
 import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
 
 // packages/safe-bash-command-diff/src/indexed-output.ts
-import { ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { ToolError as ToolError2 } from "../../safe-bash-diff-engine/shared.js";
 import { encodeBytes as encodeBytes2 } from "../../safe-bash-io-engine/byte-encoding.js";
 
 // packages/safe-bash-command-diff/src/indexed-normalization.ts
-import { PagedStorage } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
 import { readBytes } from "../../safe-bash-contracts/index.js";
 import { decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
 async function* stripTrailingCr(source, signal) {
@@ -88,7 +266,7 @@ async function* expandedSource(document, start, end, utf8) {
   if (pending) yield encodeBytes(pending, utf8 ? "utf8" : "latin1");
 }
 async function* comparisonSource(document, options, utf8) {
-  const storage = new PagedStorage(document.budget.context, 16);
+  const storage = new PagedStorage2(document.budget.context, 16);
   document.budget.context.registerCleanup?.(() => storage.close());
   const encoder2 = new TextEncoder();
   let position = 0;
@@ -221,7 +399,7 @@ async function renderSideBySide(old, next, count, group, options, budget, append
   };
   const row = async (left, right, common) => {
     if (common && left !== void 0 && right !== void 0 && options.suppressCommon) return;
-    if (options.width > budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+    if (options.width > budget.limits.maxOutputBytes) throw new ToolError2("output byte limit exceeded");
     const leftLf = await terminated(old, left), rightLf = await terminated(next, right);
     const marker = common ? left === void 0 ? ")" : right === void 0 ? "(" : " " : left === void 0 ? ">" : right === void 0 ? "<" : !leftLf && rightLf ? "\\" : leftLf && !rightLf ? "/" : "|";
     const colored = options.color && (marker === "<" || marker === ">");
@@ -278,14 +456,14 @@ async function renderSideBySide(old, next, count, group, options, budget, append
 import { encodeBytes as encodeBytes3 } from "../../safe-bash-io-engine/byte-encoding.js";
 
 // packages/safe-bash-command-diff/src/indexed-pattern.ts
-import { IntegerTable, PagedStorage as PagedStorage2, PagedStorageCache } from "@poe-platform/safe-fs/storage";
-import { closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
+import { IntegerTable, PagedStorage as PagedStorage3, PagedStorageCache as PagedStorageCache2 } from "@poe-platform/safe-fs/storage";
+import { closeDocumentResources as closeDocumentResources2 } from "../../safe-bash-diff-engine/document.js";
 async function matchesPattern(pattern, document, start, end, utf8, budget) {
   if (await pattern.supportsStreamTest(budget)) return pattern.testStream(documentText(document, start, end, utf8), budget);
-  const cache = new PagedStorageCache(16);
-  const text = new PagedStorage2(budget.context, 16, cache);
-  const records = new PagedStorage2(budget.context, 16, cache);
-  const index = new PagedStorage2(budget.context, 16, cache);
+  const cache = new PagedStorageCache2(16);
+  const text = new PagedStorage3(budget.context, 16, cache);
+  const records = new PagedStorage3(budget.context, 16, cache);
+  const index = new PagedStorage3(budget.context, 16, cache);
   const hashes = new IntegerTable(index, 256);
   let length = 0, cursor = 8, tail = 8;
   const record = async (offset) => {
@@ -344,14 +522,14 @@ async function matchesPattern(pattern, document, start, end, utf8, budget) {
       }
     }, budget);
   } finally {
-    await closeDocumentResources([text, records, index]);
+    await closeDocumentResources2([text, records, index]);
   }
 }
 
 // packages/safe-bash-command-diff/src/indexed.ts
-import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
-import { IndexedDocument, closeDocumentResources as closeDocumentResources2 } from "../../safe-bash-diff-engine/document.js";
-import { ToolError as ToolError2 } from "../../safe-bash-diff-engine/shared.js";
+import { PagedStorage as PagedStorage4 } from "@poe-platform/safe-fs/storage";
+import { IndexedDocument, closeDocumentResources as closeDocumentResources3 } from "../../safe-bash-diff-engine/document.js";
+import { ToolError as ToolError3 } from "../../safe-bash-diff-engine/shared.js";
 var encoder = new TextEncoder();
 async function buildGroups(old, next, matrix, groups, budget, admitLines = true) {
   let prefix = 0, suffix = 0, count = 0;
@@ -361,7 +539,7 @@ async function buildGroups(old, next, matrix, groups, budget, admitLines = true)
   while (suffix < Math.min(old.length, next.length) - prefix && await old.equal(old.length - suffix - 1, next, next.length - suffix - 1)) suffix++;
   const oldCount = old.length - prefix - suffix, newCount = next.length - prefix - suffix;
   const width = newCount + 1, cells = (oldCount + 1) * width;
-  if (oldCount && newCount && (cells > budget.limits.maxMatrixCells || !Number.isSafeInteger(cells * 4))) throw new ToolError2("diff matrix cell limit exceeded");
+  if (oldCount && newCount && (cells > budget.limits.maxMatrixCells || !Number.isSafeInteger(cells * 4))) throw new ToolError3("diff matrix cell limit exceeded");
   const base = oldCount && newCount ? matrix.allocate(cells * 4) : 0;
   const get = async (row2, column2) => {
     const bytes = await matrix.read(base + (row2 * width + column2) * 4, 4);
@@ -459,7 +637,7 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
     else await document.load(input);
   };
   const keys = [];
-  const matrix = new PagedStorage3(budget.context, 8), groups = new PagedStorage3(budget.context, 16);
+  const matrix = new PagedStorage4(budget.context, 8), groups = new PagedStorage4(budget.context, 16);
   budget.context.registerCleanup?.(() => matrix.close());
   budget.context.registerCleanup?.(() => groups.close());
   const text = async (value, color) => {
@@ -733,7 +911,7 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
     }
     return { different: true, trouble };
   } finally {
-    await closeDocumentResources2([
+    await closeDocumentResources3([
       ...rawOld === stdin.document ? [] : [rawOld],
       ...rawNext === stdin.document ? [] : [rawNext],
       ...keys,
@@ -806,9 +984,9 @@ import { createPrCommand } from "../../safe-bash-command-pr/index.js";
 import { basename, createCommandArguments, isFsError, writeBytes } from "../../safe-bash-contracts/index.js";
 import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
 import { writeDiagnostic as writeDiagnostic2 } from "../../safe-bash-contracts/escaping.js";
-import { ToolError as ToolError3, definition, host, inspect, sameIdentity } from "../../safe-bash-diff-engine/shared.js";
+import { ToolError as ToolError4, definition, host as host2, inspect, sameIdentity } from "../../safe-bash-diff-engine/shared.js";
 import { byteLength, decodeBytes as decodeBytes2, encodeBytes as encodeBytes4 } from "../../safe-bash-io-engine/byte-encoding.js";
-import { pathOf } from "../../safe-bash-io-engine/internal.js";
+import { pathOf as pathOf2 } from "../../safe-bash-io-engine/internal.js";
 import { Pattern } from "../../safe-bash-regex-engine/text/regex.js";
 async function comparisonLines(lines, options, budget) {
   const whitespace = options.whitespace;
@@ -860,7 +1038,7 @@ async function edits(oldLines, newLines, oldKeys, newKeys, budget) {
   const oldCount = oldLines.length - prefix - suffix;
   const newCount = newLines.length - prefix - suffix;
   const cells = (oldCount + 1) * (newCount + 1);
-  if (oldCount && newCount && cells > budget.limits.maxMatrixCells) throw new ToolError3("diff matrix cell limit exceeded");
+  if (oldCount && newCount && cells > budget.limits.maxMatrixCells) throw new ToolError4("diff matrix cell limit exceeded");
   const width = newCount + 1;
   const matrix = oldCount && newCount ? new Uint32Array(cells) : void 0;
   const ids = /* @__PURE__ */ new Map();
@@ -937,19 +1115,19 @@ async function exclusionPatterns(options, budget) {
       const c = budget.checkpoint();
       if (c) await c;
     }
-    if (exclusions.length >= budget.limits.maxExcludePatterns) throw new ToolError3("exclusion pattern count limit exceeded");
+    if (exclusions.length >= budget.limits.maxExcludePatterns) throw new ToolError4("exclusion pattern count limit exceeded");
     const remaining = budget.limits.maxExcludePatternBytes - patternBytes;
-    if (end - start > remaining) throw new ToolError3("exclusion pattern byte limit exceeded");
+    if (end - start > remaining) throw new ToolError4("exclusion pattern byte limit exceeded");
     const sourcePattern = source.slice(start, end);
     const bytes = byteLength(sourcePattern);
-    if (bytes > remaining) throw new ToolError3("exclusion pattern byte limit exceeded");
+    if (bytes > remaining) throw new ToolError4("exclusion pattern byte limit exceeded");
     patternBytes += bytes;
     exclusions.push(globPattern(sourcePattern, ignoreCase));
   };
   for (const { pattern, ignoreCase } of options.excludes) await append(pattern, ignoreCase);
   for (const { path, ignoreCase } of options.excludeFiles) {
     if (path !== "-") await inspect(budget, path, "follow");
-    const contents = await (path === "-" ? budget.read("-") : budget.readDiff(pathOf(budget.context, path)));
+    const contents = await (path === "-" ? budget.read("-") : budget.readDiff(pathOf2(budget.context, path)));
     let start = 0;
     while (start < contents.length) {
       const newline = contents.indexOf("\n", start);
@@ -973,13 +1151,13 @@ function childPath(directory, name) {
   return `${directory.slice(0, end)}/${name}`;
 }
 async function run(context, budget) {
-  const storage = new PagedStorage4(context, 32);
+  const storage = new PagedStorage5(context, 32);
   const stdin = {};
   context.registerCleanup?.(() => storage.close());
   try {
     return await runStored(context, budget, storage, stdin);
   } finally {
-    await closeDocumentResources3([storage, ...stdin.document ? [stdin.document] : []]);
+    await closeDocumentResources4([storage, ...stdin.document ? [stdin.document] : []]);
   }
 }
 async function runStored(context, budget, storage, stdinDocument) {
@@ -1025,15 +1203,15 @@ async function runStored(context, budget, storage, stdinDocument) {
     const pair = pending.pop();
     let left = pair.left;
     let right = pair.right;
-    const isStdin = (path) => path === "-" || !options.noDereference && (pathOf(context, path) === "/dev/stdin" || pathOf(context, path) === "/dev/fd/0");
+    const isStdin = (path) => path === "-" || !options.noDereference && (pathOf2(context, path) === "/dev/stdin" || pathOf2(context, path) === "/dev/fd/0");
     let leftStat = pair.leftEntry === false ? void 0 : isStdin(left) ? { type: "file" } : await inspectOperand(left);
     let rightStat = pair.rightEntry === false ? void 0 : isStdin(right) ? { type: "file" } : await inspectOperand(right);
     if (inspectionFailed) continue;
     if (options.format === "ifdef" && (leftStat?.type === "directory" || rightStat?.type === "directory")) {
-      throw new ToolError3("-D option not supported with directories");
+      throw new ToolError4("-D option not supported with directories");
     }
     if (!pair.nested && leftStat && rightStat && leftStat.type === "directory" !== (rightStat.type === "directory")) {
-      if (isStdin(left) || isStdin(right)) throw new ToolError3("cannot compare stdin with a directory");
+      if (isStdin(left) || isStdin(right)) throw new ToolError4("cannot compare stdin with a directory");
       if (leftStat.type === "directory") {
         left = childPath(left, basename(right));
         leftStat = await inspectOperand(left);
@@ -1070,10 +1248,10 @@ async function runStored(context, budget, storage, stdinDocument) {
       continue;
     }
     if (leftStat?.type === "symlink" || rightStat?.type === "symlink") {
-      if (!context.fs.readlink) throw new ToolError3("filesystem cannot read symbolic links");
+      if (!context.fs.readlink) throw new ToolError4("filesystem cannot read symbolic links");
       const readlink = context.fs.readlink.bind(context.fs);
-      const oldTarget = await host(context, () => readlink(pathOf(context, left), { signal: context.signal }));
-      const newTarget = await host(context, () => readlink(pathOf(context, right), { signal: context.signal }));
+      const oldTarget = await host2(context, () => readlink(pathOf2(context, left), { signal: context.signal }));
+      const newTarget = await host2(context, () => readlink(pathOf2(context, right), { signal: context.signal }));
       if (!budget.equal(oldTarget, newTarget)) {
         await append(`Symbolic links ${left} and ${right} differ
 `);
@@ -1088,8 +1266,8 @@ async function runStored(context, budget, storage, stdinDocument) {
 `);
         continue;
       }
-      const leftIdentity = leftStat?.type !== "directory" ? void 0 : sameIdentity(leftStat, leftStat) ? leftStat : await host(context, () => context.fs.realpath(pathOf(context, left), { signal: context.signal }));
-      const rightIdentity = rightStat?.type !== "directory" ? void 0 : sameIdentity(rightStat, rightStat) ? rightStat : await host(context, () => context.fs.realpath(pathOf(context, right), { signal: context.signal }));
+      const leftIdentity = leftStat?.type !== "directory" ? void 0 : sameIdentity(leftStat, leftStat) ? leftStat : await host2(context, () => context.fs.realpath(pathOf2(context, left), { signal: context.signal }));
+      const rightIdentity = rightStat?.type !== "directory" ? void 0 : sameIdentity(rightStat, rightStat) ? rightStat : await host2(context, () => context.fs.realpath(pathOf2(context, right), { signal: context.signal }));
       const isLoop = (identity, parents) => identity !== void 0 && parents.some((parent) => typeof identity === "string" ? parent === identity : typeof parent !== "string" && sameIdentity(identity, parent));
       const cycle = isLoop(leftIdentity, pair.leftParents) ? left : isLoop(rightIdentity, pair.rightParents) ? right : void 0;
       if (cycle !== void 0) {
@@ -1100,74 +1278,34 @@ async function runStored(context, budget, storage, stdinDocument) {
       }
       const leftParents = leftIdentity === void 0 ? pair.leftParents : [...pair.leftParents, leftIdentity];
       const rightParents = rightIdentity === void 0 ? pair.rightParents : [...pair.rightParents, rightIdentity];
-      const names = /* @__PURE__ */ new Map();
-      const key = (name) => options.ignoreFileNameCase ? name.replace(/[A-Z]/gu, (letter) => letter.toLowerCase()) : name;
-      const maxEntries = budget.remainingFiles - pending.length;
-      let count = 0;
-      for (const [side, path] of [["left", leftStat ? left : void 0], ["right", rightStat ? right : void 0]]) {
-        if (path === void 0) continue;
-        const entries = await host(context, () => context.fs.readdir(pathOf(context, path), { signal: context.signal, ...Number.isFinite(maxEntries) ? { maxEntries } : {} }));
-        if (entries.length > maxEntries) throw new ToolError3("file/entry limit exceeded");
-        for (const entry of entries) {
-          budget.step();
-          if (!entry.name || entry.name === "." || entry.name === ".." || /[/\\\0\r\n\t]/u.test(entry.name)) throw new ToolError3("unsafe directory entry name");
-          let excluded = false;
-          const byteName = exclusions.length ? decodeBytes2(encodeBytes4(entry.name), "latin1") : entry.name;
-          for (const pattern of exclusions) if (await pattern.find(byteName, budget)) {
-            excluded = true;
-            break;
-          }
-          if (excluded) continue;
-          const folded = key(entry.name);
-          let group = names.get(folded);
-          if (!group) {
-            group = { left: [], right: [] };
-            names.set(folded, group);
-          }
-          const before = Math.max(group.left.length, group.right.length);
-          group[side].push(entry.name);
-          count += Math.max(group.left.length, group.right.length) - before;
-          if (count > maxEntries) throw new ToolError3("file/entry limit exceeded");
-        }
-      }
-      for (const name of [...names.keys()].sort().reverse()) {
-        if (!pair.nested && options.startingFile !== void 0 && name < key(options.startingFile)) continue;
-        const group = names.get(name);
-        group.left.sort();
-        group.right.sort();
-        const rightNames = new Set(group.right);
-        const matches = [];
-        const unmatchedLeft = [];
-        for (const leftName of group.left) {
-          if (rightNames.delete(leftName)) matches.push({ left: leftName, right: leftName });
-          else unmatchedLeft.push(leftName);
-        }
-        const unmatchedRight = [...rightNames];
-        for (let index = 0; index < Math.max(unmatchedLeft.length, unmatchedRight.length); index++) {
-          const leftName = unmatchedLeft[index], rightName = unmatchedRight[index];
-          matches.push({ ...leftName === void 0 ? {} : { left: leftName }, ...rightName === void 0 ? {} : { right: rightName } });
-        }
-        matches.sort((first, second) => {
-          const unmatched = Number(first.left === void 0 || first.right === void 0) - Number(second.left === void 0 || second.right === void 0);
-          const firstName = first.left ?? first.right, secondName = second.left ?? second.right;
-          return unmatched || (firstName < secondName ? -1 : firstName > secondName ? 1 : 0);
+      const excluded = async (name) => {
+        const byteName = exclusions.length ? decodeBytes2(encodeBytes4(name), "latin1") : name;
+        for (const pattern of exclusions) if (await pattern.find(byteName, budget)) return true;
+        return false;
+      };
+      for await (const match of directoryMatches(
+        leftStat ? left : void 0,
+        rightStat ? right : void 0,
+        budget,
+        options.ignoreFileNameCase,
+        budget.remainingFiles - pending.length,
+        excluded,
+        pair.nested ? void 0 : options.startingFile
+      )) {
+        pending.push({
+          left: childPath(left, match.left ?? match.right),
+          right: childPath(right, match.right ?? match.left),
+          nested: true,
+          leftParents,
+          rightParents,
+          leftEntry: match.left !== void 0,
+          rightEntry: match.right !== void 0
         });
-        for (const match of matches.reverse()) {
-          pending.push({
-            left: childPath(left, match.left ?? match.right),
-            right: childPath(right, match.right ?? match.left),
-            nested: true,
-            leftParents,
-            rightParents,
-            leftEntry: match.left !== void 0,
-            rightEntry: match.right !== void 0
-          });
-        }
       }
       continue;
     }
     if (options.brief && options.whitespace === "exact" && !options.ignoreCase && !options.ignoreTabs && !options.ignoreTrailing && !options.stripTrailingCr && !options.ignoreBlank && options.ignorePatterns.length === 0 && leftStat?.type === "file" && rightStat?.type === "file" && !isStdin(left) && !isStdin(right)) {
-      const same2 = await compareBrief(budget, pathOf(context, left), pathOf(context, right), options.text, options.format === "side" || options.format === "ifdef");
+      const same2 = await compareBrief(budget, pathOf2(context, left), pathOf2(context, right), options.text, options.format === "side" || options.format === "ifdef");
       if (!same2) {
         different = true;
         await append(`Files ${options.labels[0] ?? left} and ${options.labels[1] ?? right} differ
@@ -1179,7 +1317,7 @@ async function runStored(context, budget, storage, stdinDocument) {
     const canIndex = async (path, stat) => {
       if (!stat || stat.type === "file") return true;
       if (pair.nested || !streamType(stat.type) || !context.fs.readStream) return false;
-      const capabilities = await host(context, async () => await context.fs.capabilitiesFor?.(pathOf(context, path), { signal: context.signal }) ?? context.fs.capabilities);
+      const capabilities = await host2(context, async () => await context.fs.capabilitiesFor?.(pathOf2(context, path), { signal: context.signal }) ?? context.fs.capabilities);
       return capabilities.streamingRead !== false;
     };
     let storedPatterns = true;
@@ -1191,8 +1329,8 @@ async function runStored(context, budget, storage, stdinDocument) {
     }
     if (storedPatterns && await canIndex(left, leftStat) && await canIndex(right, rightStat)) {
       const result = await indexedDiff(budget, options, left, right, pair.nested, appendBytes, {
-        left: !leftStat ? void 0 : isStdin(left) ? "-" : streamType(leftStat.type) ? { stream: pathOf(context, left) } : pathOf(context, left),
-        right: !rightStat ? void 0 : isStdin(right) ? "-" : streamType(rightStat.type) ? { stream: pathOf(context, right) } : pathOf(context, right)
+        left: !leftStat ? void 0 : isStdin(left) ? "-" : streamType(leftStat.type) ? { stream: pathOf2(context, left) } : pathOf2(context, left),
+        right: !rightStat ? void 0 : isStdin(right) ? "-" : streamType(rightStat.type) ? { stream: pathOf2(context, right) } : pathOf2(context, right)
       }, stdinDocument);
       different ||= result.different;
       trouble ||= result.trouble;
@@ -1201,8 +1339,8 @@ async function runStored(context, budget, storage, stdinDocument) {
     const read = async (path, stat) => {
       if (!stat) return "";
       if (isStdin(path)) return stdin ??= await budget.read("-", "latin1");
-      if (!pair.nested && streamType(stat.type)) return budget.read(pathOf(context, path), "latin1");
-      return budget.readDiff(pathOf(context, path), "latin1");
+      if (!pair.nested && streamType(stat.type)) return budget.read(pathOf2(context, path), "latin1");
+      return budget.readDiff(pathOf2(context, path), "latin1");
     };
     const oldBytes = await read(left, leftStat);
     const newBytes = await read(right, rightStat);
@@ -1317,7 +1455,7 @@ async function runStored(context, budget, storage, stdinDocument) {
   if (options.paginate && outputSize) {
     const title = ["diff", ...context.args].join(" ");
     const argumentValues = createCommandArguments(["-f", "-h", title]);
-    const pages = new PagedStorage4(context, 16);
+    const pages = new PagedStorage5(context, 16);
     context.registerCleanup?.(() => pages.close());
     let pageBytes = 0;
     try {

package/dist/safe-bash/command-chunks/{chunk-4QEJPP3K.js → chunk-S5X7PBO4.js}

@@ -3503,7 +3503,7 @@ function readCommentGeometry(roots, charge) {
       else if (name === "z-index" && value && Number.isSafeInteger(Number(value))) style[name] = value;
     }
     const flags = [];
-    for (const name of ["MoveWithCells", "SizeWithCells", "Visible", "AutoFill"]) {
+    for (const name of ["MoveWithCells", "SizeWithCells", "Visible", "AutoFill", "Locked", "LockText"]) {
       const field = fields3.get(name);
       if (!field) continue;
       const text = field.text.trim();

package/dist/safe-bash/command-chunks/{chunk-IHLZ6HNQ.js → chunk-TSKJNCKD.js}

@@ -202,6 +202,7 @@ async function stageZip(scope, prepared, consume) {
   const capabilities = await scope.operation(() => fs.capabilitiesFor?.(prepared.parent, { signal }) ?? fs.capabilities);
   if (capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true || !fs.createStagedFile || !fs.removeStagedFile) fail("ZIP temporary path requires atomic owned file staging");
   if (prepared.source && (capabilities.atomicFileMutation !== true && capabilities.trustedOwnedStaging !== true || !fs.writeFileConditional)) fail("ZIP temporary path requires atomic conditional writes");
+  const buffered = prepared.source && capabilities.retainedStagingWrite !== true ? await collectBytes(prepared.source, { signal, maxBytes: scope.limits.maxArchiveBytes }) : void 0;
   let staging;
   let failure;
   const close = retainFileSystemCleanup(fs, async (cleanup) => {
@@ -219,7 +220,7 @@ async function stageZip(scope, prepared, consume) {
       if (path === prepared.reservedPath) continue;
       try {
         await scope.operation(async () => {
-          staging = await fs.createStagedFile(path, "archive.zip", { type: "file", data: prepared.bytes ?? new Uint8Array() }, {
+          staging = await fs.createStagedFile(path, "archive.zip", { type: "file", data: buffered ?? prepared.bytes ?? new Uint8Array() }, {
             signal,
             parent: prepared.parentStat,
             ...capabilities.retainedStagingCleanup ? { retainCleanup: true } : {},
@@ -234,7 +235,7 @@ async function stageZip(scope, prepared, consume) {
       }
     }
     if (!staging) fail("ZIP temporary directory attempt limit exceeded");
-    if (prepared.source) {
+    if (prepared.source && buffered === void 0) {
       for await (const chunk of readBytes(prepared.source, signal)) {
         try {
           await writeFileOutput(scope.context, chunk, (bytes) => scope.operation(async () => {