@poe-platform/safe-bash 0.1.816 → 0.1.818

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

@@ -1,10 +1,10 @@
-import {
-  flags
-} from "./chunk-QFFJN22S.js";
 import {
   contextual,
   normal
 } from "./chunk-AHZ7UGNB.js";
+import {
+  flags
+} from "./chunk-QFFJN22S.js";
 import {
   colorText,
   expandTabs,
@@ -15,19 +15,547 @@ import {
   sideBySide
 } from "./chunk-VXIC7SS3.js";
 
+// packages/safe-bash-command-diff/src/stored-exclusions.ts
+import { PagedStorage as PagedStorage2, PagedStorageCache } from "@poe-platform/safe-fs/storage";
+import { IndexedDocument, closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
+import { inspect, ToolError as ToolError2 } from "../../safe-bash-diff-engine/shared.js";
+import { pathOf } from "../../safe-bash-io-engine/internal.js";
+
+// packages/safe-bash-command-diff/src/stored-glob.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+import { ToolError } from "../../safe-bash-diff-engine/shared.js";
+var GlobText = class {
+  constructor(storage, offset, length, budget) {
+    this.storage = storage;
+    this.offset = offset;
+    this.length = length;
+    this.budget = budget;
+  }
+  storage;
+  offset;
+  length;
+  budget;
+  start = -1;
+  bytes = new Uint8Array();
+  async at(index) {
+    if (index < 0 || index >= this.length) return "";
+    this.budget.step();
+    const pause = this.budget.checkpoint();
+    if (pause) await pause;
+    if (index < this.start || index >= this.start + this.bytes.length) {
+      this.start = Math.floor(index / 16384) * 16384;
+      this.bytes = await this.storage.read(this.offset + this.start, Math.min(16384, this.length - this.start));
+    }
+    return String.fromCharCode(this.bytes[index - this.start]);
+  }
+  async find(text, start) {
+    for (let index = start; index + text.length <= this.length; index++) {
+      let same = true;
+      for (let part = 0; part < text.length; part++) if (await this.at(index + part) !== text[part]) {
+        same = false;
+        break;
+      }
+      if (same) return index;
+    }
+    return -1;
+  }
+};
+var RegexWriter = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  bytes = new Uint8Array(4096);
+  used = 0;
+  length = 0;
+  async add(text) {
+    for (let index = 0; index < text.length; index++) {
+      this.bytes[this.used++] = text.charCodeAt(index);
+      this.length++;
+      if (this.used === this.bytes.length) await this.flush();
+    }
+  }
+  async flush() {
+    if (this.used) {
+      await this.storage.append(this.bytes.subarray(0, this.used));
+      this.used = 0;
+    }
+  }
+};
+async function translate(source, ignoreCase, output) {
+  const opposite = (ch) => !ignoreCase ? "" : ch >= "A" && ch <= "Z" ? ch.toLowerCase() : ch >= "a" && ch <= "z" ? ch.toUpperCase() : "";
+  await output.add("^");
+  for (let index = 0; index < source.length; index++) {
+    const ch = await source.at(index);
+    if (ch === "\\" && index + 1 < source.length) {
+      const literal = await source.at(++index);
+      await output.add(opposite(literal) ? `[${literal}${opposite(literal)}]` : `\\${literal}`);
+    } else if (ch === "[") {
+      let end = index + 1;
+      const negated = "!^".includes(await source.at(end)) && end < source.length;
+      if (negated) end++;
+      if (await source.at(end) === "]") end++;
+      while (end < source.length && await source.at(end) !== "]") {
+        if (await source.at(end) === "\\" && end + 1 < source.length) end += 2;
+        else if (await source.at(end) === "[" && await source.at(end + 1) === ":") {
+          const closing = await source.find(":]", end + 2);
+          if (closing < 0) break;
+          end = closing + 2;
+        } else end++;
+      }
+      if (await source.at(end) !== "]") {
+        await output.add("\\[");
+        continue;
+      }
+      const literal = (value) => "\\]^-".includes(value) ? `\\${value}` : value;
+      const render = async (emit) => {
+        for (let scan = index + 1 + Number(negated); scan < end; scan++) {
+          if (await source.at(scan) === "[" && await source.at(scan + 1) === ":") {
+            const closing = await source.find(":]", scan + 2) + 1;
+            for (; scan <= closing; scan++) await emit(await source.at(scan));
+            scan--;
+            continue;
+          }
+          if (await source.at(scan) === "\\" && scan + 1 < end) scan++;
+          let first = await source.at(scan);
+          if (ignoreCase && first >= "A" && first <= "Z") first = first.toLowerCase();
+          if (await source.at(scan + 1) === "-" && scan + 2 < end) {
+            let last = await source.at(scan + 2);
+            if (ignoreCase && last >= "A" && last <= "Z") last = last.toLowerCase();
+            for (let code = first.charCodeAt(0); code <= last.charCodeAt(0); code++) {
+              const value = String.fromCharCode(code);
+              await emit(literal(value) + opposite(value));
+            }
+            scan += 2;
+          } else await emit(literal(first) + opposite(first));
+        }
+      };
+      let size = 0;
+      await render(async (text) => {
+        size += text.length;
+      });
+      if (size) {
+        await output.add(negated ? "[^" : "[");
+        await render((text) => output.add(text));
+        await output.add("]");
+      } else await output.add(negated ? "[\0-\xFF]" : "[^\0-\xFF]");
+      index = end;
+    } else if (ch === "*") await output.add(".*");
+    else if (ch === "?") await output.add(".");
+    else await output.add(opposite(ch) ? `[${ch}${opposite(ch)}]` : ".^$+(){}|]".includes(ch) ? `\\${ch}` : ch);
+  }
+  await output.add("$");
+  await output.flush();
+}
+var word = (byte) => byte !== void 0 && (byte >= 48 && byte <= 57 || byte >= 65 && byte <= 90 || byte >= 97 && byte <= 122 || byte === 95);
+var classes = {
+  alpha: (byte) => byte >= 65 && byte <= 90 || byte >= 97 && byte <= 122,
+  alnum: (byte) => byte >= 48 && byte <= 57 || byte >= 65 && byte <= 90 || byte >= 97 && byte <= 122,
+  digit: (byte) => byte >= 48 && byte <= 57,
+  lower: (byte) => byte >= 97 && byte <= 122,
+  upper: (byte) => byte >= 65 && byte <= 90,
+  xdigit: (byte) => byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102,
+  space: (byte) => " 	\n\r\v\f".includes(String.fromCharCode(byte)),
+  blank: (byte) => byte === 32 || byte === 9,
+  cntrl: (byte) => byte < 32 || byte === 127,
+  graph: (byte) => byte >= 33 && byte <= 126,
+  print: (byte) => byte >= 32 && byte <= 126,
+  punct: (byte) => byte >= 33 && byte <= 47 || byte >= 58 && byte <= 64 || byte >= 91 && byte <= 96 || byte >= 123 && byte <= 126
+};
+var shorthand = (reference, byte) => {
+  const lower = reference.toLowerCase(), accepted = lower === "d" ? classes.digit(byte) : lower === "s" ? classes.space(byte) : word(byte);
+  return reference === lower ? accepted : !accepted;
+};
+async function compileGlob(source, ignoreCase, tokens, budget, cache) {
+  const translated = new PagedStorage(budget.context, 16, cache), writer = new RegexWriter(translated);
+  try {
+    await translate(source, ignoreCase, writer);
+    const text = new GlobText(translated, 8, writer.length, budget);
+    let position = 0, count = 0;
+    const escaped = async () => {
+      const ch = await text.at(position++);
+      if (!ch) throw new ToolError("trailing backslash in regular expression");
+      const octal = "01234567".includes(ch);
+      if (octal || ch === "x") {
+        let digits = octal ? ch : "";
+        const alphabet = octal ? "01234567" : "0123456789abcdefABCDEF";
+        while (digits.length < (octal ? 3 : 2) && position < text.length && alphabet.includes(await text.at(position))) digits += await text.at(position++);
+        return digits ? parseInt(digits, octal ? 8 : 16) & 255 : ch.charCodeAt(0);
+      }
+      return { n: 10, t: 9, r: 13, f: 12, v: 11, a: 7, b: 8 }[ch] ?? ch.charCodeAt(0);
+    };
+    while (position < text.length) {
+      const cell = new Uint8Array(40), set = (byte) => {
+        cell[8 + (byte >>> 3)] |= 1 << (byte & 7);
+      };
+      const ch = await text.at(position++);
+      if (ch === "^") cell[0] = 2;
+      else if (ch === "$") cell[0] = 3;
+      else if (ch === ".") {
+        for (let byte = 0; byte < 256; byte++) if (byte !== 10) set(byte);
+        if (await text.at(position) === "*") {
+          cell[0] = 1;
+          position++;
+        }
+      } else if (ch === "[") {
+        const negate = await text.at(position) === "^";
+        if (negate) position++;
+        let first = true;
+        while (position < text.length && (await text.at(position) !== "]" || first)) {
+          first = false;
+          if (await text.at(position) === "[" && await text.at(position + 1) === ":") {
+            position += 2;
+            let name = "";
+            while (position < text.length && !(await text.at(position) === ":" && await text.at(position + 1) === "]")) {
+              const ch2 = await text.at(position++);
+              if (name.length < 1001) name += ch2;
+            }
+            if (!classes[name]) throw new ToolError(`unsupported character class '${name}'`);
+            for (let byte = 0; byte < 256; byte++) if (classes[name](byte)) set(byte);
+            position += 2;
+            continue;
+          }
+          if (await text.at(position) === "[" && [".", "="].includes(await text.at(position + 1))) throw new ToolError("collating and equivalence classes are not supported");
+          if (await text.at(position) === "\\" && "dDsSwW".includes(await text.at(position + 1)) && position + 1 < text.length) {
+            const reference = await text.at(position + 1);
+            position += 2;
+            for (let byte = 0; byte < 256; byte++) if (shorthand(reference, byte)) set(byte);
+            if (await text.at(position) === "-" && await text.at(position + 1) !== "]") throw new ToolError("character class cannot be a range endpoint");
+            continue;
+          }
+          const readChar = async () => await text.at(position++) === "\\" ? escaped() : (await text.at(position - 1)).charCodeAt(0);
+          const start = await readChar();
+          if (await text.at(position) === "-" && position + 1 < text.length && await text.at(position + 1) !== "]") {
+            position++;
+            const end = await readChar();
+            if (start > end) throw new ToolError("reversed character range");
+            for (let byte = start; byte <= end; byte++) set(byte);
+          } else set(start);
+        }
+        if (await text.at(position++) !== "]") throw new ToolError("unterminated bracket expression");
+        if (negate) for (let index = 8; index < 40; index++) cell[index] ^= 255;
+      } else if (ch === "\\") {
+        const reference = await text.at(position);
+        if (["B", "y", "Y", "<", ">"].includes(reference)) {
+          cell[0] = reference === "y" ? 4 : reference === "B" || reference === "Y" ? 5 : reference === "<" ? 6 : 7;
+          position++;
+        } else if ("dDsSwW".includes(reference) && reference) {
+          position++;
+          for (let byte = 0; byte < 256; byte++) if (shorthand(reference, byte)) set(byte);
+        } else set(await escaped());
+      } else set(ch.charCodeAt(0));
+      await tokens.append(cell);
+      count++;
+    }
+    return count;
+  } finally {
+    await translated.close();
+  }
+}
+async function matchesGlob(tokens, start, count, name, budget) {
+  let token = 0, position = 0, star = -1, retry = 0;
+  while (token < count) {
+    budget.step();
+    const pause = budget.checkpoint();
+    if (pause) await pause;
+    const cell = await tokens.read(start + token * 40, 40), kind = cell[0];
+    if (kind === 1) {
+      star = token++;
+      retry = position;
+      continue;
+    }
+    const before = word(name[position - 1]), after = word(name[position]);
+    const accepted = kind === 2 ? position === 0 : kind === 3 ? position === name.length : kind === 4 ? before !== after : kind === 5 ? before === after : kind === 6 ? !before && after : kind === 7 ? before && !after : position < name.length && !!(cell[8 + (name[position] >>> 3)] & 1 << (name[position] & 7));
+    if (accepted) {
+      if (kind === 0) position++;
+      token++;
+    } else if (star >= 0 && retry < name.length && name[retry] !== 10) {
+      position = ++retry;
+      token = star + 1;
+    } else return false;
+  }
+  return true;
+}
+
+// packages/safe-bash-command-diff/src/stored-exclusions.ts
+var StoredExclusions = class {
+  constructor(budget) {
+    this.budget = budget;
+    this.tokens = new PagedStorage2(budget.context, 16, this.cache);
+    this.patterns = new PagedStorage2(budget.context, 16, this.cache);
+  }
+  budget;
+  cache = new PagedStorageCache(16);
+  tokens;
+  patterns;
+  count = 0;
+  bytes = 0;
+  document() {
+    return new IndexedDocument({
+      context: this.budget.context,
+      documentCache: this.cache,
+      step: this.budget.step.bind(this.budget),
+      checkpoint: this.budget.checkpoint.bind(this.budget)
+    });
+  }
+  async append(document, start, end, ignoreCase) {
+    if (this.count >= this.budget.limits.maxExcludePatterns) throw new ToolError2("exclusion pattern count limit exceeded");
+    if (end - start > this.budget.limits.maxExcludePatternBytes - this.bytes) throw new ToolError2("exclusion pattern byte limit exceeded");
+    this.bytes += end - start;
+    const position = this.tokens.allocate(0);
+    const count = await compileGlob(new GlobText(document.data, 8 + start, end - start, this.budget), ignoreCase, this.tokens, this.budget, this.cache);
+    const cell = new Uint8Array(16), view = new DataView(cell.buffer);
+    view.setFloat64(0, position, true);
+    view.setFloat64(8, count, true);
+    await this.patterns.append(cell);
+    this.count++;
+  }
+  async load(options) {
+    for (const { pattern, ignoreCase } of options.excludes) {
+      const document = this.document();
+      try {
+        await document.load({ async *[Symbol.asyncIterator]() {
+          for (let start = 0; start < pattern.length; ) {
+            let end = Math.min(start + 4096, pattern.length);
+            const last = pattern.charCodeAt(end - 1);
+            if (end < pattern.length && last >= 55296 && last <= 56319) end--;
+            yield new TextEncoder().encode(pattern.slice(start, end));
+            start = end;
+          }
+        } });
+        await this.append(document, 0, document.size, ignoreCase);
+      } finally {
+        await document.close();
+      }
+    }
+    for (const { path, ignoreCase } of options.excludeFiles) {
+      this.budget.inspected.clear();
+      if (path !== "-") await inspect(this.budget, path, "follow");
+      const document = this.document();
+      try {
+        await document.load(path === "-" ? this.budget.stdinSource() : this.budget.diffSource(pathOf(this.budget.context, path)));
+        if (document.binary) throw new ToolError2("binary input is unsupported (NUL byte)");
+        if (!document.validUtf8) throw new ToolError2("binary input is unsupported (invalid UTF-8)");
+        for (let index = 0; index < document.length; index++) {
+          const line2 = await document.line(index);
+          const end = (await document.data.read(8 + line2.end - 1, 1))[0] === 10 ? line2.end - 1 : line2.end;
+          if (end > line2.start) await this.append(document, line2.start, end, ignoreCase);
+          else {
+            this.budget.step();
+            const pause = this.budget.checkpoint();
+            if (pause) await pause;
+          }
+        }
+      } finally {
+        await document.close();
+      }
+    }
+  }
+  async matches(name) {
+    if (!this.count) return false;
+    const bytes = new TextEncoder().encode(name);
+    for (let index = 0; index < this.count; index++) {
+      const cell = await this.patterns.read(8 + index * 16, 16), view = new DataView(cell.buffer, cell.byteOffset, cell.byteLength);
+      if (await matchesGlob(this.tokens, view.getFloat64(0, true), view.getFloat64(8, true), bytes, this.budget)) return true;
+    }
+    return false;
+  }
+  close() {
+    return closeDocumentResources([this.tokens, this.patterns]);
+  }
+};
+
+// packages/safe-bash-command-diff/src/stored-directory.ts
+import { PagedStorage as PagedStorage3, PagedStorageCache as PagedStorageCache2 } from "@poe-platform/safe-fs/storage";
+import { closeDocumentResources as closeDocumentResources2 } from "../../safe-bash-diff-engine/document.js";
+import { host, ToolError as ToolError3 } from "../../safe-bash-diff-engine/shared.js";
+import { pathOf as pathOf2 } 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 PagedStorage3(budget.context, 16, cache);
+    this.index = new PagedStorage3(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 closeDocumentResources2([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 PagedStorageCache2(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 = pathOf2(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 ToolError3("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 ToolError3("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 closeDocumentResources2([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 closeDocumentResources5 } from "../../safe-bash-diff-engine/document.js";
+import { PagedStorage as PagedStorage7 } 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 ToolError4 } 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 PagedStorage4 } 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 +616,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 PagedStorage4(document.budget.context, 16);
   document.budget.context.registerCleanup?.(() => storage.close());
   const encoder2 = new TextEncoder();
   let position = 0;
@@ -221,7 +749,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 ToolError4("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 +806,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 PagedStorage5, PagedStorageCache as PagedStorageCache3 } from "@poe-platform/safe-fs/storage";
+import { closeDocumentResources as closeDocumentResources3 } 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 PagedStorageCache3(16);
+  const text = new PagedStorage5(budget.context, 16, cache);
+  const records = new PagedStorage5(budget.context, 16, cache);
+  const index = new PagedStorage5(budget.context, 16, cache);
   const hashes = new IntegerTable(index, 256);
   let length = 0, cursor = 8, tail = 8;
   const record = async (offset) => {
@@ -344,14 +872,14 @@ async function matchesPattern(pattern, document, start, end, utf8, budget) {
       }
     }, budget);
   } finally {
-    await closeDocumentResources([text, records, index]);
+    await closeDocumentResources3([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 PagedStorage6 } from "@poe-platform/safe-fs/storage";
+import { IndexedDocument as IndexedDocument2, closeDocumentResources as closeDocumentResources4 } from "../../safe-bash-diff-engine/document.js";
+import { ToolError as ToolError5 } 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 +889,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 ToolError5("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);
@@ -449,7 +977,7 @@ async function line(document, position, prefix, output, color) {
 }
 async function indexedDiff(budget, options, left, right, nested, append, sources, stdin) {
   let trouble = false;
-  const acquire = (source) => source === "-" ? stdin.document ??= new IndexedDocument(budget) : new IndexedDocument(budget);
+  const acquire = (source) => source === "-" ? stdin.document ??= new IndexedDocument2(budget) : new IndexedDocument2(budget);
   const rawOld = acquire(sources.left), rawNext = acquire(sources.right);
   let old = rawOld, next = rawNext;
   const load = async (document, source) => {
@@ -459,7 +987,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 PagedStorage6(budget.context, 8), groups = new PagedStorage6(budget.context, 16);
   budget.context.registerCleanup?.(() => matrix.close());
   budget.context.registerCleanup?.(() => groups.close());
   const text = async (value, color) => {
@@ -492,16 +1020,16 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
       }
     }
     if (options.stripTrailingCr) {
-      old = new IndexedDocument(budget);
-      next = new IndexedDocument(budget);
+      old = new IndexedDocument2(budget);
+      next = new IndexedDocument2(budget);
       keys.push(old, next);
       await old.load(stripTrailingCr(rawOld.range(0, rawOld.size), budget.context.signal));
       await next.load(stripTrailingCr(rawNext.range(0, rawNext.size), budget.context.signal));
     }
     if (options.format === "ed" && !options.brief && trouble) {
       const before = old, after = next;
-      old = new IndexedDocument(budget);
-      next = new IndexedDocument(budget);
+      old = new IndexedDocument2(budget);
+      next = new IndexedDocument2(budget);
       keys.push(old, next);
       await old.load(terminatedSource(before));
       await next.load(terminatedSource(after));
@@ -516,8 +1044,8 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
     const counted = options.format === "ifdef" || options.format === "side" || normalize && !sameRaw;
     if (counted) budget.countLines(old.length + next.length);
     if (normalize && !sameRaw) {
-      oldKeys = new IndexedDocument(budget);
-      nextKeys = new IndexedDocument(budget);
+      oldKeys = new IndexedDocument2(budget);
+      nextKeys = new IndexedDocument2(budget);
       keys.push(oldKeys, nextKeys);
       const utf8 = old.validUtf8 && next.validUtf8;
       await oldKeys.load(comparisonSource(old, options, utf8));
@@ -733,7 +1261,7 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
     }
     return { different: true, trouble };
   } finally {
-    await closeDocumentResources2([
+    await closeDocumentResources4([
       ...rawOld === stdin.document ? [] : [rawOld],
       ...rawNext === stdin.document ? [] : [rawNext],
       ...keys,
@@ -806,10 +1334,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 { 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 { Pattern } from "../../safe-bash-regex-engine/text/regex.js";
+import { ToolError as ToolError6, definition, host as host2, inspect as inspect2, sameIdentity } from "../../safe-bash-diff-engine/shared.js";
+import { decodeBytes as decodeBytes2, encodeBytes as encodeBytes4 } from "../../safe-bash-io-engine/byte-encoding.js";
+import { pathOf as pathOf3 } from "../../safe-bash-io-engine/internal.js";
 async function comparisonLines(lines, options, budget) {
   const whitespace = options.whitespace;
   if (whitespace === "exact" && !options.ignoreCase && !options.ignoreTabs && !options.ignoreTrailing) return lines;
@@ -860,7 +1387,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 ToolError6("diff matrix cell limit exceeded");
   const width = newCount + 1;
   const matrix = oldCount && newCount ? new Uint32Array(cells) : void 0;
   const ids = /* @__PURE__ */ new Map();
@@ -928,63 +1455,25 @@ async function edits(oldLines, newLines, oldKeys, newKeys, budget) {
   }
   return result;
 }
-async function exclusionPatterns(options, budget) {
-  const exclusions = [];
-  let patternBytes = 0;
-  const append = async (source, ignoreCase, start = 0, end = source.length) => {
-    budget.step(1 + end - start);
-    {
-      const c = budget.checkpoint();
-      if (c) await c;
-    }
-    if (exclusions.length >= budget.limits.maxExcludePatterns) throw new ToolError3("exclusion pattern count limit exceeded");
-    const remaining = budget.limits.maxExcludePatternBytes - patternBytes;
-    if (end - start > remaining) throw new ToolError3("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");
-    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)));
-    let start = 0;
-    while (start < contents.length) {
-      const newline = contents.indexOf("\n", start);
-      const end = newline < 0 ? contents.length : newline;
-      if (end > start) await append(contents, ignoreCase, start, end);
-      else {
-        budget.step();
-        {
-          const c = budget.checkpoint();
-          if (c) await c;
-        }
-      }
-      start = end + 1;
-    }
-  }
-  return exclusions;
-}
 function childPath(directory, name) {
   let end = directory.length;
   while (end > 0 && directory[end - 1] === "/") end--;
   return `${directory.slice(0, end)}/${name}`;
 }
 async function run(context, budget) {
-  const storage = new PagedStorage4(context, 32);
+  const storage = new PagedStorage7(context, 32);
   const stdin = {};
-  context.registerCleanup?.(() => storage.close());
+  const exclusions = new StoredExclusions(budget);
+  context.registerCleanup?.(() => closeDocumentResources5([storage, exclusions]));
   try {
-    return await runStored(context, budget, storage, stdin);
+    return await runStored(context, budget, storage, stdin, exclusions);
   } finally {
-    await closeDocumentResources3([storage, ...stdin.document ? [stdin.document] : []]);
+    await closeDocumentResources5([storage, exclusions, ...stdin.document ? [stdin.document] : []]);
   }
 }
-async function runStored(context, budget, storage, stdinDocument) {
+async function runStored(context, budget, storage, stdinDocument, exclusions) {
   const options = flags(context.args);
-  const exclusions = await exclusionPatterns(options, budget);
+  await exclusions.load(options);
   let outputSize = 0;
   let encoding = "utf8";
   const appendBytes = async (bytes) => {
@@ -1002,7 +1491,7 @@ async function runStored(context, budget, storage, stdinDocument) {
   let inspectionFailed = false;
   const inspectOperand = async (path) => {
     try {
-      return await inspect(budget, path, symlinks);
+      return await inspect2(budget, path, symlinks);
     } catch (error) {
       if (isFsError(error, "ENOENT")) return void 0;
       if (!isFsError(error)) throw error;
@@ -1015,6 +1504,7 @@ async function runStored(context, budget, storage, stdinDocument) {
   const pairs = options.fromFile !== void 0 ? options.files.map((right) => ({ left: options.fromFile, right })) : options.toFile !== void 0 ? options.files.map((left) => ({ left, right: options.toFile })) : [{ left: options.files[0], right: options.files[1] }];
   const pending = pairs.reverse().map((pair) => ({ ...pair, nested: false, leftParents: [], rightParents: [] }));
   while (pending.length) {
+    budget.inspected.clear();
     encoding = "utf8";
     inspectionFailed = false;
     budget.file();
@@ -1025,15 +1515,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 && (pathOf3(context, path) === "/dev/stdin" || pathOf3(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 ToolError6("-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 ToolError6("cannot compare stdin with a directory");
       if (leftStat.type === "directory") {
         left = childPath(left, basename(right));
         leftStat = await inspectOperand(left);
@@ -1070,10 +1560,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 ToolError6("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(pathOf3(context, left), { signal: context.signal }));
+      const newTarget = await host2(context, () => readlink(pathOf3(context, right), { signal: context.signal }));
       if (!budget.equal(oldTarget, newTarget)) {
         await append(`Symbolic links ${left} and ${right} differ
 `);
@@ -1088,8 +1578,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(pathOf3(context, left), { signal: context.signal }));
+      const rightIdentity = rightStat?.type !== "directory" ? void 0 : sameIdentity(rightStat, rightStat) ? rightStat : await host2(context, () => context.fs.realpath(pathOf3(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 +1590,29 @@ 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);
+      for await (const match of directoryMatches(
+        leftStat ? left : void 0,
+        rightStat ? right : void 0,
+        budget,
+        options.ignoreFileNameCase,
+        budget.remainingFiles - pending.length,
+        (name) => exclusions.matches(name),
+        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, pathOf3(context, left), pathOf3(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 +1624,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?.(pathOf3(context, path), { signal: context.signal }) ?? context.fs.capabilities);
       return capabilities.streamingRead !== false;
     };
     let storedPatterns = true;
@@ -1191,8 +1636,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: pathOf3(context, left) } : pathOf3(context, left),
+        right: !rightStat ? void 0 : isStdin(right) ? "-" : streamType(rightStat.type) ? { stream: pathOf3(context, right) } : pathOf3(context, right)
       }, stdinDocument);
       different ||= result.different;
       trouble ||= result.trouble;
@@ -1201,8 +1646,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(pathOf3(context, path), "latin1");
+      return budget.readDiff(pathOf3(context, path), "latin1");
     };
     const oldBytes = await read(left, leftStat);
     const newBytes = await read(right, rightStat);
@@ -1317,7 +1762,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 PagedStorage7(context, 16);
     context.registerCleanup?.(() => pages.close());
     let pageBytes = 0;
     try {
@@ -1346,60 +1791,6 @@ async function runStored(context, budget, storage, stdinDocument) {
   } else for await (const bytes of output) await writeBytes(context.stdout, bytes, context.signal);
   return trouble ? 2 : different ? 1 : 0;
 }
-function globPattern(source, ignoreCase) {
-  source = decodeBytes2(encodeBytes4(source), "latin1");
-  let result = "^";
-  const oppositeCase = (character) => !ignoreCase ? "" : character >= "A" && character <= "Z" ? character.toLowerCase() : character >= "a" && character <= "z" ? character.toUpperCase() : "";
-  for (let index = 0; index < source.length; index++) {
-    const character = source[index];
-    if (character === "\\" && index + 1 < source.length) {
-      const literal = source[++index];
-      result += oppositeCase(literal) ? `[${literal}${oppositeCase(literal)}]` : `\\${literal}`;
-    } else if (character === "[") {
-      let end = index + 1;
-      const negated = source[end] === "!" || source[end] === "^";
-      if (negated) end++;
-      if (source[end] === "]") end++;
-      while (end < source.length && source[end] !== "]") {
-        if (source[end] === "\\" && end + 1 < source.length) end += 2;
-        else if (source[end] === "[" && source[end + 1] === ":") {
-          const classEnd = source.indexOf(":]", end + 2);
-          if (classEnd < 0) break;
-          end = classEnd + 2;
-        } else end++;
-      }
-      if (source[end] === "]") {
-        let body = "";
-        const literal = (value) => "\\]^-".includes(value) ? `\\${value}` : value;
-        for (let scan = index + 1 + Number(negated); scan < end; scan++) {
-          if (source[scan] === "[" && source[scan + 1] === ":") {
-            const closing = source.indexOf(":]", scan + 2) + 1;
-            body += source.slice(scan, closing + 1);
-            scan = closing;
-            continue;
-          }
-          if (source[scan] === "\\" && scan + 1 < end) scan++;
-          let first = source[scan];
-          if (ignoreCase && first >= "A" && first <= "Z") first = first.toLowerCase();
-          if (source[scan + 1] === "-" && scan + 2 < end) {
-            let last = source[scan + 2];
-            if (ignoreCase && last >= "A" && last <= "Z") last = last.toLowerCase();
-            for (let code = first.charCodeAt(0); code <= last.charCodeAt(0); code++) {
-              const value = String.fromCharCode(code);
-              body += literal(value) + oppositeCase(value);
-            }
-            scan += 2;
-          } else body += literal(first) + oppositeCase(first);
-        }
-        result += body ? "[" + (negated ? "^" : "") + body + "]" : negated ? "[\0-\xFF]" : "[^\0-\xFF]";
-        index = end;
-      } else result += "\\[";
-    } else if (character === "*") result += ".*";
-    else if (character === "?") result += ".";
-    else result += oppositeCase(character) ? `[${character}${oppositeCase(character)}]` : ".^$+(){}|]".includes(character) ? `\\${character}` : character;
-  }
-  return new Pattern(result + "$", true, false, "awk");
-}
 async function ignoreChanges(changes, options, budget) {
   if (!options.ignoreBlank && !options.ignorePatterns.length) return;
   let scan = 0;