@poe-platform/safe-bash 0.1.810 → 0.1.812

package/dist/safe-bash-command-diff3/index.js

@@ -961,7 +961,785 @@ function compareDiff3(inputs, invocation, limits = diff3DefaultLimits, signal) {
 }
 
 // packages/safe-bash-command-diff3/src/command.ts
-import { yieldTurn } from "../safe-bash-contracts/yield.js";
+import { resolvePath } from "../safe-bash-contracts/index.js";
+import { Budget as ReadBudget, inspect, ToolError } from "../safe-bash-diff-engine/shared.js";
+
+// packages/safe-bash-command-diff3/src/stored.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+import { IndexedDocument, closeDocumentResources } from "../safe-bash-diff-engine/document.js";
+import { monotonicNow, yieldTurn } from "../safe-bash-contracts/yield.js";
+var StoredWork = class extends Budget {
+  constructor(context, behaviorLimits, charge, retain) {
+    super(behaviorLimits, context.signal);
+    this.context = context;
+    this.behaviorLimits = behaviorLimits;
+    this.charge = charge;
+    this.retain = retain;
+    this.storage = new PagedStorage(context, 8);
+    this.resources.push(this.storage);
+  }
+  context;
+  behaviorLimits;
+  charge;
+  retain;
+  storage;
+  resources = [];
+  nextYield = 4096;
+  nextTime = 0;
+  reserved = false;
+  admit(resource, amount) {
+    if (resource === "work") this.charge?.(amount);
+    super.admit(resource, amount);
+  }
+  step(amount = 1) {
+    this.admit("work", amount);
+  }
+  checkpoint() {
+    this.context.signal.throwIfAborted();
+    if (this.work < this.nextYield) return;
+    this.nextYield = this.work + 4096;
+    const now = monotonicNow();
+    if (now < this.nextTime) return;
+    this.nextTime = now + 16;
+    return yieldTurn(this.context.signal);
+  }
+  reserve() {
+    if (this.reserved) return;
+    this.retain?.(1024 * 1024);
+    this.admit("retainedBytes", 1024 * 1024);
+    this.reserved = true;
+  }
+  async load(source) {
+    const document = new IndexedDocument(this, 2);
+    this.resources.push(document);
+    const iterator = source[Symbol.asyncIterator]();
+    try {
+      const first = await iterator.next();
+      if (!first.done) {
+        this.reserve();
+        await document.load({ async *[Symbol.asyncIterator]() {
+          yield first.value;
+          for (; ; ) {
+            const next = await iterator.next();
+            if (next.done) break;
+            yield next.value;
+          }
+        } });
+      }
+    } finally {
+      await iterator.return?.();
+    }
+    this.admit("tokens", document.length);
+    return document;
+  }
+  output() {
+    const output = new StoredOutput(this);
+    this.resources.push(output);
+    return output;
+  }
+  async close() {
+    try {
+      await closeDocumentResources(this.resources);
+    } finally {
+      this.dispose();
+    }
+  }
+};
+var Numbers = class _Numbers {
+  constructor(work, length, position) {
+    this.work = work;
+    this.length = length;
+    this.position = position ?? work.storage.allocate(length * 8);
+  }
+  work;
+  length;
+  position;
+  async get(index) {
+    if (index < 0 || index >= this.length) return 0;
+    const checkpoint = this.work.checkpoint();
+    if (checkpoint) await checkpoint;
+    const bytes = await this.work.storage.read(this.position + index * 8, 8);
+    return new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, true);
+  }
+  async set(index, value) {
+    if (!Number.isSafeInteger(index) || index < 0 || index >= this.length) throw new RangeError("Diff3 vector index");
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value, true);
+    await this.work.storage.write(this.position + index * 8, bytes);
+    const checkpoint = this.work.checkpoint();
+    if (checkpoint) await checkpoint;
+  }
+  slice(start, end) {
+    return new _Numbers(this.work, end - start, this.position + start * 8);
+  }
+};
+var Edits = class {
+  length = 0;
+  cells;
+  constructor(work, capacity) {
+    this.cells = new Numbers(work, capacity * 4);
+  }
+  async push(edit) {
+    const values = [edit.base.start, edit.base.end, edit.variant.start, edit.variant.end];
+    for (let i = 0; i < 4; i++) await this.cells.set(this.length * 4 + i, values[i]);
+    this.length++;
+  }
+  async get(index) {
+    if (index >= this.length) return void 0;
+    return {
+      base: { start: await this.cells.get(index * 4), end: await this.cells.get(index * 4 + 1) },
+      variant: { start: await this.cells.get(index * 4 + 2), end: await this.cells.get(index * 4 + 3) }
+    };
+  }
+  async *[Symbol.asyncIterator]() {
+    for (let index = 0; index < this.length; index++) yield await this.get(index);
+  }
+};
+var kinds = ["left", "right", "identical", "adjacent", "conflict"];
+var Regions = class {
+  length = 0;
+  cells;
+  constructor(work, capacity) {
+    this.cells = new Numbers(work, capacity * 7);
+  }
+  async push(region) {
+    const values = [kinds.indexOf(region.kind), region.base.start, region.base.end, region.left.start, region.left.end, region.right.start, region.right.end];
+    for (let i = 0; i < 7; i++) await this.cells.set(this.length * 7 + i, values[i]);
+    this.length++;
+  }
+  async *iterate(reverse) {
+    for (let i = 0; i < this.length; i++) {
+      const offset2 = (reverse ? this.length - i - 1 : i) * 7;
+      yield {
+        kind: kinds[await this.cells.get(offset2)],
+        base: { start: await this.cells.get(offset2 + 1), end: await this.cells.get(offset2 + 2) },
+        left: { start: await this.cells.get(offset2 + 3), end: await this.cells.get(offset2 + 4) },
+        right: { start: await this.cells.get(offset2 + 5), end: await this.cells.get(offset2 + 6) }
+      };
+    }
+  }
+};
+async function storedLine(document, index) {
+  const line = await document.line(index);
+  const last = await document.data.read(8 + line.end - 1, 1);
+  return { document, start: line.start, end: line.end, terminated: last[0] === 10 };
+}
+async function bodyEnd(line, options) {
+  const end = line.end - Number(line.terminated);
+  if (options.stripTrailingCR && line.terminated && end > line.start && (await line.document.data.read(8 + end - 1, 1))[0] === 13) return end - 1;
+  return end;
+}
+async function equalStoredLines(a, b, options, work) {
+  work.step();
+  const endA = await bodyEnd(a, options), endB = await bodyEnd(b, options);
+  if (a.terminated !== b.terminated || endA - a.start !== endB - b.start) return false;
+  for (let offset2 = 0; offset2 < endA - a.start; offset2 += 16384) {
+    const size = Math.min(16384, endA - a.start - offset2);
+    const left = await a.document.data.read(8 + a.start + offset2, size), right = await b.document.data.read(8 + b.start + offset2, size);
+    work.step(size);
+    for (let i = 0; i < size; i++) if (left[i] !== right[i]) return false;
+    const checkpoint = work.checkpoint();
+    if (checkpoint) await checkpoint;
+  }
+  return true;
+}
+var StoredOutput = class {
+  constructor(work) {
+    this.work = work;
+    this.data = new PagedStorage(work.context, 2);
+  }
+  work;
+  data;
+  size = 0;
+  async append(bytes) {
+    if (bytes.length) this.work.reserve();
+    await this.data.append(bytes);
+    this.size += bytes.length;
+    const checkpoint = this.work.checkpoint();
+    if (checkpoint) await checkpoint;
+  }
+  async *bytes() {
+    for (let offset2 = 0; offset2 < this.size; offset2 += 16384) yield await this.data.read(8 + offset2, Math.min(16384, this.size - offset2));
+  }
+  close() {
+    return this.data.close();
+  }
+};
+
+// packages/safe-bash-command-diff3/src/stored-alignment.ts
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+async function equivalences2(files, options, work) {
+  const buckets = new IntegerTable(work.storage, 256);
+  const count = files.reduce((sum, file) => sum + file.length, 0);
+  const records = new Numbers(work, count * 4);
+  let next = 1;
+  const result = [];
+  for (let file = 0; file < files.length; file++) {
+    const document = files[file], keys = new Numbers(work, document.length);
+    result.push(keys);
+    for (let index = 0; index < document.length; index++) {
+      const line = await storedLine(document, index), end = await bodyEnd(line, options);
+      let hash = line.terminated ? 2166136261 : 2166136260;
+      for await (const bytes of document.range(line.start, end)) {
+        for (const byte of bytes) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+      }
+      const bucket = BigInt(hash), head = Number(await buckets.get(bucket) ?? 0n);
+      let match = 0;
+      for (let key = head; key; key = await records.get((key - 1) * 4 + 3)) {
+        const offset2 = (key - 1) * 4;
+        if (hash !== await records.get(offset2)) continue;
+        const other = await storedLine(files[await records.get(offset2 + 1)], await records.get(offset2 + 2));
+        if (await equalStoredLines(line, other, options, work)) {
+          match = key;
+          break;
+        }
+      }
+      if (!match) {
+        match = next++;
+        const values = [hash, file, index, head];
+        for (let i = 0; i < 4; i++) await records.set((match - 1) * 4 + i, values[i]);
+        await buckets.set(bucket, BigInt(match));
+      }
+      await keys.set(index, match);
+    }
+  }
+  return result;
+}
+async function alignStoredPair(base, variant, options, work) {
+  const total = base.length + variant.length, previousCells = work.graphCells;
+  const edits = new Edits(work, total);
+  try {
+    if (total > 1073741823) throw new Diff3Error("LIMIT", "Signed edit graph index limit exceeded", "graphCells");
+    work.admit("graphCells", 24 * total + 16);
+    work.step(total);
+    if (total === 0) return edits;
+    const [allA, allB] = await equivalences2([variant, base], options, work);
+    let prefix = 0, suffix = 0;
+    while (prefix < Math.min(allA.length, allB.length) && await allA.get(prefix) === await allB.get(prefix)) {
+      work.step();
+      prefix++;
+    }
+    if (prefix === allA.length && prefix === allB.length) return edits;
+    while (suffix < Math.min(allA.length, allB.length) - prefix && await allA.get(allA.length - suffix - 1) === await allB.get(allB.length - suffix - 1)) {
+      work.step();
+      suffix++;
+    }
+    const low = Math.max(0, prefix - 100), highA = Math.min(allA.length, allA.length - suffix + 100), highB = Math.min(allB.length, allB.length - suffix + 100);
+    const keys = [allA.slice(low, highA), allB.slice(low, highB)];
+    const changed = keys.map((list) => new Numbers(work, list.length + 1));
+    const [a, b] = await discard2(keys, changed, total, work);
+    const width = a.length + b.length + 3, origin = b.length + 1;
+    const forward = new Numbers(work, width), backward = new Numbers(work, width);
+    const pending = new Numbers(work, (total + 1) * 4);
+    let pendingLength = 0;
+    const push = async (x0, x1, y0, y1) => {
+      for (const value of [x0, x1, y0, y1]) await pending.set(pendingLength++, value);
+    };
+    await push(0, a.length, 0, b.length);
+    while (pendingLength) {
+      work.step();
+      const yEnd = await pending.get(--pendingLength), yStart = await pending.get(--pendingLength);
+      const xEnd = await pending.get(--pendingLength), xStart = await pending.get(--pendingLength);
+      let x0 = xStart, x1 = xEnd, y0 = yStart, y1 = yEnd;
+      while (x0 < x1 && y0 < y1 && await a.keys.get(x0) === await b.keys.get(y0)) {
+        work.step();
+        x0++;
+        y0++;
+      }
+      while (x0 < x1 && y0 < y1 && await a.keys.get(x1 - 1) === await b.keys.get(y1 - 1)) {
+        work.step();
+        x1--;
+        y1--;
+      }
+      if (x0 === x1 || y0 === y1) {
+        for (let x3 = x0; x3 < x1; x3++) {
+          work.step();
+          await changed[0].set(await a.indices.get(x3), 1);
+        }
+        for (let y3 = y0; y3 < y1; y3++) {
+          work.step();
+          await changed[1].set(await b.indices.get(y3), 1);
+        }
+        continue;
+      }
+      const [x2, y2] = await midpoint2(x0, x1, y0, y1, a, b, forward, backward, origin, work);
+      if (x2 === x0 && y2 === y0 || x2 === x1 && y2 === y1) throw new Diff3Error("ALIGNMENT", "Non-progressing comparison partition");
+      await push(x2, x1, y2, y1);
+      await push(x0, x2, y0, y2);
+    }
+    await shift2(keys, changed, work);
+    let x = 0, y = 0;
+    while (x < keys[0].length || y < keys[1].length) {
+      work.step();
+      if (await changed[0].get(x) || await changed[1].get(y)) {
+        const startX = x, startY = y;
+        while (await changed[0].get(x)) {
+          work.step();
+          x++;
+        }
+        while (await changed[1].get(y)) {
+          work.step();
+          y++;
+        }
+        work.admit("graphCells", 4);
+        await edits.push({ base: { start: low + startY, end: low + y }, variant: { start: low + startX, end: low + x } });
+      } else {
+        x++;
+        y++;
+      }
+    }
+    return edits;
+  } finally {
+    work.graphCells = previousCells + edits.length * 4;
+  }
+}
+async function discard2(keys, changed, total, work) {
+  const counts = keys.map(() => new Numbers(work, total + 1));
+  for (let file = 0; file < 2; file++) {
+    for (let i = 0; i < keys[file].length; i++) {
+      work.step();
+      const key = await keys[file].get(i);
+      await counts[file].set(key, await counts[file].get(key) + 1);
+    }
+  }
+  const results = [];
+  for (let file = 0; file < 2; file++) {
+    const list = keys[file], marks = new Numbers(work, list.length);
+    const threshold = 5 * 2 ** Math.max(0, Math.floor(Math.log2(Math.max(1, list.length)) / 2) - 3);
+    for (let i = 0; i < list.length; i++) {
+      work.step();
+      const count = await counts[1 - file].get(await list.get(i));
+      await marks.set(i, count === 0 ? 1 : count > threshold ? 2 : 0);
+    }
+    for (let start = 0; start < marks.length; ) {
+      work.step();
+      if (await marks.get(start) !== 1) {
+        if (await marks.get(start) === 2) await marks.set(start, 0);
+        start++;
+        continue;
+      }
+      let end = start + 1;
+      while (end < marks.length && await marks.get(end) !== 0) {
+        work.step();
+        end++;
+      }
+      while (await marks.get(end - 1) === 2) {
+        work.step();
+        await marks.set(--end, 0);
+      }
+      let provisional = 0;
+      for (let i = start; i < end; i++) {
+        work.step();
+        provisional += Number(await marks.get(i) === 2);
+      }
+      const length = end - start;
+      if (provisional > Math.floor(length / 4)) {
+        for (let i = start; i < end; i++) {
+          work.step();
+          if (await marks.get(i) === 2) await marks.set(i, 0);
+        }
+      } else {
+        const minimum = length < 4 ? 2 : 2 ** (Math.floor(Math.log2(length) / 2) - 1) + 1;
+        for (let i = start; i < end; ) {
+          work.step();
+          if (await marks.get(i) !== 2) {
+            i++;
+            continue;
+          }
+          let j = i + 1;
+          while (j < end && await marks.get(j) === 2) {
+            work.step();
+            j++;
+          }
+          if (j - i >= minimum) for (let k = i; k < j; k++) {
+            work.step();
+            await marks.set(k, 0);
+          }
+          i = j;
+        }
+        for (const direction of [1, -1]) {
+          let consecutive = 0;
+          for (let distance = 0; distance < length; distance++) {
+            work.step();
+            const i = direction === 1 ? start + distance : end - distance - 1;
+            if (distance >= 8 && await marks.get(i) === 1) break;
+            if (await marks.get(i) === 2) {
+              await marks.set(i, 0);
+              consecutive = 0;
+            } else consecutive = await marks.get(i) === 1 ? consecutive + 1 : 0;
+            if (consecutive === 3) break;
+          }
+        }
+      }
+      start = end;
+    }
+    const result = { keys: new Numbers(work, list.length), indices: new Numbers(work, list.length), length: 0 };
+    for (let index = 0; index < list.length; index++) {
+      work.step();
+      if (await marks.get(index)) await changed[file].set(index, 1);
+      else {
+        await result.keys.set(result.length, await list.get(index));
+        await result.indices.set(result.length, index);
+        result.length++;
+      }
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function midpoint2(x0, x1, y0, y1, a, b, f, r, origin, work) {
+  const first = x0 - y0, last = x1 - y1, min = x0 - y1, max = x1 - y0;
+  let fLow = first, fHigh = first, rLow = last, rHigh = last;
+  await f.set(origin + first, x0);
+  await r.set(origin + last, x1);
+  const odd = (first - last) % 2 !== 0;
+  for (; ; ) {
+    work.step();
+    if (fLow > min) {
+      fLow--;
+      await f.set(origin + fLow - 1, -1);
+    } else fLow++;
+    if (fHigh < max) {
+      fHigh++;
+      await f.set(origin + fHigh + 1, -1);
+    } else fHigh--;
+    for (let diagonal = fHigh; diagonal >= fLow; diagonal -= 2) {
+      work.step();
+      const left = await f.get(origin + diagonal - 1), right = await f.get(origin + diagonal + 1);
+      let x = left < right ? right : left + 1, y = x - diagonal;
+      while (x < x1 && y < y1 && await a.keys.get(x) === await b.keys.get(y)) {
+        work.step();
+        x++;
+        y++;
+      }
+      await f.set(origin + diagonal, x);
+      if (odd && diagonal >= rLow && diagonal <= rHigh && await r.get(origin + diagonal) <= x) return [x, y];
+    }
+    if (rLow > min) {
+      rLow--;
+      await r.set(origin + rLow - 1, 2147483647);
+    } else rLow++;
+    if (rHigh < max) {
+      rHigh++;
+      await r.set(origin + rHigh + 1, 2147483647);
+    } else rHigh--;
+    for (let diagonal = rHigh; diagonal >= rLow; diagonal -= 2) {
+      work.step();
+      const left = await r.get(origin + diagonal - 1), right = await r.get(origin + diagonal + 1);
+      let x = left < right ? left : right - 1, y = x - diagonal;
+      while (x > x0 && y > y0 && await a.keys.get(x - 1) === await b.keys.get(y - 1)) {
+        work.step();
+        x--;
+        y--;
+      }
+      await r.set(origin + diagonal, x);
+      if (!odd && diagonal >= fLow && diagonal <= fHigh && x <= await f.get(origin + diagonal)) return [x, y];
+    }
+  }
+}
+async function shift2(keys, changed, work) {
+  for (let file = 0; file < 2; file++) {
+    const list = keys[file], own = changed[file], other = changed[1 - file];
+    let i = 0, j = 0;
+    while (i < list.length) {
+      work.step();
+      if (!await own.get(i)) {
+        while (await other.get(j)) {
+          work.step();
+          j++;
+        }
+        i++;
+        j++;
+        continue;
+      }
+      let start = i;
+      while (await own.get(i)) {
+        work.step();
+        i++;
+      }
+      while (await other.get(j)) {
+        work.step();
+        j++;
+      }
+      let corresponding, length;
+      do {
+        work.step();
+        length = i - start;
+        while (start > 0 && await list.get(start - 1) === await list.get(i - 1)) {
+          work.step();
+          await own.set(--start, 1);
+          await own.set(--i, 0);
+          while (start > 0 && await own.get(start - 1)) {
+            work.step();
+            start--;
+          }
+          do {
+            work.step();
+            j--;
+          } while (j >= 0 && await other.get(j));
+        }
+        corresponding = await other.get(j - 1) ? i : list.length;
+        while (i < list.length && await list.get(start) === await list.get(i)) {
+          work.step();
+          await own.set(start++, 0);
+          await own.set(i++, 1);
+          while (await own.get(i)) {
+            work.step();
+            i++;
+          }
+          do {
+            work.step();
+            j++;
+            if (await other.get(j)) corresponding = i;
+          } while (await other.get(j));
+        }
+      } while (length !== i - start);
+      while (corresponding < i) {
+        work.step();
+        await own.set(--start, 1);
+        await own.set(--i, 0);
+        do {
+          work.step();
+          j--;
+        } while (j >= 0 && await other.get(j));
+      }
+    }
+  }
+}
+
+// packages/safe-bash-command-diff3/src/stored-regions.ts
+async function alignStoredRegions(files, left, right, options, budget) {
+  const streams = [left, right], offsets = [0, 0], delta = [0, 0], result = new Regions(budget, left.length + right.length);
+  while (offsets[0] < left.length || offsets[1] < right.length) {
+    budget.admit("work", 1);
+    const nextLeft = await left.get(offsets[0]), nextRight = await right.get(offsets[1]);
+    const firstSide = nextRight === void 0 || nextLeft !== void 0 && nextLeft.base.start <= nextRight.base.start ? 0 : 1;
+    const first = await streams[firstSide].get(offsets[firstSide]);
+    const start = first.base.start;
+    let end = first.base.end;
+    const initialDelta = [...delta], seen = [false, false];
+    let overlap = false;
+    const last = [void 0, void 0];
+    for (; ; ) {
+      budget.admit("work", 1);
+      const a = await left.get(offsets[0]), b = await right.get(offsets[1]);
+      const side = b === void 0 || a !== void 0 && a.base.start <= b.base.start ? 0 : 1;
+      const edit = await streams[side].get(offsets[side]);
+      if (!edit || edit.base.start > end) break;
+      const other = last[1 - side];
+      if (other) {
+        const aEmpty = edit.base.start === edit.base.end, bEmpty = other.start === other.end;
+        overlap ||= aEmpty && bEmpty ? edit.base.start === other.start : aEmpty ? edit.base.start > other.start && edit.base.start < other.end : bEmpty ? other.start > edit.base.start && other.start < edit.base.end : edit.base.start < other.end && other.start < edit.base.end;
+      }
+      last[side] = edit.base;
+      seen[side] = true;
+      end = Math.max(end, edit.base.end);
+      delta[side] = edit.variant.end - edit.base.end;
+      offsets[side]++;
+    }
+    const base = { start, end };
+    const l = { start: start + initialDelta[0], end: end + delta[0] }, r = { start: start + initialDelta[1], end: end + delta[1] };
+    let kind2 = !seen[0] ? "right" : !seen[1] ? "left" : overlap ? "conflict" : "adjacent";
+    if (seen[0] && seen[1] && l.end - l.start === r.end - r.start) {
+      let identical = true;
+      for (let index = 0; index < l.end - l.start; index++) {
+        if (!await equalStoredLines(await storedLine(files.left, l.start + index), await storedLine(files.right, r.start + index), options, budget)) {
+          identical = false;
+          break;
+        }
+      }
+      if (identical) kind2 = "identical";
+    }
+    budget.admit("graphCells", 7);
+    await result.push({ kind: kind2, base, left: l, right: r });
+  }
+  return result;
+}
+
+// packages/safe-bash-command-diff3/src/stored-behavior.ts
+async function compareStoredDiff3(inputs, options, work) {
+  const out = work.output(), err = work.output();
+  let outputBytes = 0;
+  const emit = async (bytes, destination = out) => {
+    work.step(bytes.length + 1);
+    if (bytes.length > work.behaviorLimits.outputBytes - outputBytes) throw new Diff3Error("LIMIT", "Output byte limit exceeded");
+    outputBytes += bytes.length;
+    await destination.append(bytes);
+  };
+  const literal = async (value, destination = out) => {
+    work.step(value.length * 4);
+    if (value.length) work.reserve();
+    for (let start = 0; start < value.length; ) {
+      let end = Math.min(start + 4096, value.length);
+      const unit = value.charCodeAt(end - 1);
+      if (end < value.length && unit >= 55296 && unit <= 56319) end--;
+      await emit(new TextEncoder().encode(value.slice(start, end)), destination);
+      start = end;
+    }
+  };
+  if (options.information) {
+    await literal(options.information === "version" ? "diff3 (safe-bash; GNU diffutils 3.12 qualified profile)\n" : "Usage: diff3 [OPTION]... OURS BASE THEIRS\nReports, -m merge, -A/-e/-E/-3/-x/-X ed scripts; -a -T -L -i --strip-trailing-cr.\nNo external diff/ed programs. One stdin operand in any position. Ed labels must be single-line.\n");
+    return { stdout: out, stderr: err, exitCode: 0, outputBytes };
+  }
+  const report = !options.selector && !options.merge;
+  const preferredCommon = report ? 2 : 1;
+  const common = options.files[preferredCommon] === "-" ? 3 - preferredCommon : preferredCommon;
+  const other = 3 - common;
+  let identical = true;
+  for (const input of inputs.slice(1)) {
+    if (input.size !== inputs[0].size || input.length !== inputs[0].length) {
+      identical = false;
+      break;
+    }
+    for (let index = 0; index < input.length; index++) {
+      if (!await input.equal(index, inputs[0], index)) {
+        identical = false;
+        break;
+      }
+    }
+    if (!identical) break;
+  }
+  if (!identical && !options.text && inputs.some((input) => input.binary)) throw new Diff3Error("BINARY", "Binary input requires text comparison");
+  const documents = { base: inputs[common], left: inputs[0], right: inputs[other] };
+  const leftEdits = await alignStoredPair(documents.base, documents.left, options, work);
+  const rightEdits = await alignStoredPair(documents.base, documents.right, options, work);
+  const regions = await alignStoredRegions(documents, leftEdits, rightEdits, options, work);
+  const analysis = { files: documents, leftEdits, rightEdits, regions };
+  const files = inputs;
+  const labels = options.files.map((file, i) => options.labels?.[i] ?? file);
+  const line = async (token, mode) => {
+    const end = mode === "source" ? token.end : await bodyEnd(token, options);
+    for await (const bytes of token.document.range(token.start, end)) await emit(bytes);
+    if (mode !== "source" && token.terminated) await literal("\n");
+    if (!token.terminated && (mode === "ed" || mode === "report")) await literal("\n");
+    if (!token.terminated && mode === "report") await literal("\\n");
+  };
+  const range = async (file, address2, mode) => {
+    let dots = false;
+    for (let i = address2.start; i < address2.end; i++) {
+      work.step();
+      const token = await storedLine(files[file], i);
+      if (mode === "report") await literal(options.initialTab ? "	" : "  ");
+      if (mode === "ed" && (await token.document.data.read(8 + token.start, 1))[0] === 46) {
+        await literal(".");
+        dots = true;
+      }
+      await line(token, mode);
+    }
+    return dots;
+  };
+  const address = (r) => r.start === r.end ? `${r.start}a` : `${r.start + 1}${r.end > r.start + 1 ? `,${r.end}` : ""}c`;
+  let conflict = false;
+  if (!report && !options.merge) {
+    for (const edits of [analysis.leftEdits, analysis.rightEdits]) for await (const edit of edits) {
+      const variant = edits === analysis.leftEdits ? analysis.files.left : analysis.files.right;
+      for (const [tokens, r] of [[analysis.files.base, edit.base], [variant, edit.variant]]) {
+        if (r.end > r.start && !(await storedLine(tokens, r.end - 1)).terminated) await literal("diff3: No newline at end of file\n", err);
+      }
+    }
+  }
+  let cursor = 0;
+  const orderedRegions = analysis.regions.iterate(!options.merge && !report);
+  for await (const region of orderedRegions) {
+    work.step();
+    const ranges = [];
+    ranges[0] = region.left;
+    ranges[other] = region.right;
+    ranges[common] = region.base;
+    const base = ranges[1], theirs = ranges[2];
+    const different = region.kind === "left" ? 1 : region.kind === "right" ? other + 1 : region.kind === "identical" ? common + 1 : 0;
+    if (report) {
+      await literal(`====${different || ""}
+`);
+      const sequence = different === 2 ? [0, 2, 1] : [0, 1, 2];
+      for (let i = 0; i < sequence.length; i++) {
+        const file = sequence[i];
+        await literal(`${file + 1}:${address(ranges[file])}
+`);
+        if (different === 0 || file === different - 1 || i === 1 && different !== 1 || i === 2 && different === 1) await range(file, ranges[file], "report");
+      }
+      continue;
+    }
+    const selector = options.selector;
+    const flagged = different === 0 && (selector === "A" || selector === "E" || selector === "X") || different === 2 && selector === "A";
+    const replace = different === 3 && ["A", "E", "e", "3"].includes(selector) || different === 0 && ["e", "x"].includes(selector);
+    if (options.merge) {
+      await range(0, { start: cursor, end: region.left.start }, "source");
+      if (flagged) {
+        conflict = true;
+        if (different === 2) {
+          await literal(`<<<<<<< ${labels[1]}
+`);
+          await range(1, base, "changed");
+        } else {
+          await literal(`<<<<<<< ${labels[0]}
+`);
+          await range(0, region.left, "changed");
+          if (selector === "A") {
+            await literal(`||||||| ${labels[1]}
+`);
+            await range(1, base, "changed");
+          }
+        }
+        await literal("=======\n");
+        await range(2, theirs, "changed");
+        await literal(`>>>>>>> ${labels[2]}
+`);
+      } else await range(replace ? 2 : 0, replace ? theirs : region.left, replace ? "changed" : "source");
+      cursor = region.left.end;
+    } else if (replace) {
+      if (theirs.start === theirs.end) {
+        if (region.left.start !== region.left.end) await literal(address(region.left).slice(0, -1) + "d\n");
+      } else {
+        await literal(address(region.left) + "\n");
+        const dots = await range(2, theirs, "ed");
+        await literal(".\n");
+        if (dots) {
+          const start = region.left.start + 1, end = region.left.start + theirs.end - theirs.start;
+          await literal(`${start}${end > start ? `,${end}` : ""}s/^\\.//
+`);
+        }
+      }
+    } else if (flagged) {
+      conflict = true;
+      await literal(`${region.left.end}a
+`);
+      let dots = false;
+      if (different !== 2) {
+        if (selector === "A") {
+          await literal(`||||||| ${labels[1]}
+`);
+          dots = await range(1, base, "ed");
+        }
+        await literal("=======\n");
+        dots = await range(2, theirs, "ed") || dots;
+      }
+      await literal(`>>>>>>> ${labels[2]}
+.
+`);
+      if (dots) await literal(`${region.left.end + 2},${region.left.end + base.end - base.start + theirs.end - theirs.start + 2}s/^\\.//
+`);
+      await literal(`${region.left.start}a
+<<<<<<< ${labels[different === 2 ? 1 : 0]}
+`);
+      if (different === 2) {
+        const baseDots = await range(1, base, "ed");
+        await literal("=======\n.\n");
+        if (baseDots) {
+          const start = region.left.start + 2, end = region.left.start + base.end - base.start + 1;
+          await literal(`${start}${end > start ? `,${end}` : ""}s/^\\.//
+`);
+        }
+      } else await literal(".\n");
+    }
+  }
+  if (options.merge) await range(0, { start: cursor, end: files[0].length }, "source");
+  else if (!report && options.writeQuit) await literal("w\nq\n");
+  return { stdout: out, stderr: err, exitCode: options.merge && conflict ? 1 : 0, outputBytes };
+}
+
+// packages/safe-bash-command-diff3/src/command.ts
+import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
 import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/command.js";
 import { FsError } from "../safe-bash-contracts/errors.js";
 import { readBytes, writeBytes } from "../safe-bash-contracts/io.js";
@@ -977,7 +1755,8 @@ async function executeDiff3(context, configuration, invocation) {
   let closing;
   let accepting = true;
   let inputBytes = 0, decodedBytes = 0, outputBytes = 0, retained = 0, metadataRetained = 0, peakRetained = 0, peakGraphCells = 0, work = 0;
-  const chunks = [], inputs = [];
+  const inputs = [];
+  let stored;
   const cleanup = () => {
     if (closing) return closing;
     accepting = false;
@@ -989,10 +1768,10 @@ async function executeDiff3(context, configuration, invocation) {
     controller.abort(new Diff3Error("CLOSED", "Diff3 invocation closed"));
     void (async () => {
       await Promise.allSettled([task]);
-      chunks.length = inputs.length = 0;
+      inputs.length = 0;
       retained = 0;
       context.signal.removeEventListener("abort", abort);
-      const results = await Promise.allSettled([stdout?.close(), stderr?.close()]);
+      const results = await Promise.allSettled([stdout?.close(), stderr?.close(), stored?.close()]);
       const errors = results.filter((result2) => result2.status === "rejected").map((result2) => result2.reason);
       if (errors.length) throw new AggregateError(errors, "Diff3 output cleanup failed");
     })().then(resolve, reject);
@@ -1015,7 +1794,7 @@ async function executeDiff3(context, configuration, invocation) {
     retained += amount;
     peakRetained = Math.max(peakRetained, retained);
   };
-  const result = (exitCode) => ({ exitCode, accounting: { inputBytes, decodedBytes, outputBytes, retainedBytes: 0, peakRetainedBytes: peakRetained, graphCells: 0, peakGraphCells, tokens: 0, work } });
+  const result = (exitCode) => ({ exitCode, accounting: { inputBytes, decodedBytes, outputBytes, retainedBytes: 0, peakRetainedBytes: peakRetained, graphCells: 0, peakGraphCells: Math.max(peakGraphCells, stored?.peakGraphCells ?? 0), tokens: 0, work } });
   task = Promise.resolve().then(async () => {
     if (!accepting) throw new Diff3Error("CLOSED", "Diff3 invocation closed");
     context.signal.addEventListener("abort", abort, { once: true });
@@ -1057,15 +1836,27 @@ async function executeDiff3(context, configuration, invocation) {
         charge(value.length * 4 + 1);
         metadataRetained = retained;
       }
+      const { registerCleanup: ignoredCleanup, ...storageContext } = context;
+      stored = new StoredWork({ ...storageContext, signal }, limits, charge, hold);
       if (!options.information) for (const file of options.files) {
-        await yieldTurn(signal);
+        await yieldTurn2(signal);
         signal.throwIfAborted();
         signal.throwIfAborted();
         let source, borrowed = 0, acquiredInput;
         if (file === "-") source = context.stdin;
         else {
-          const path = file.startsWith("/") ? file : `${context.cwd}/${file}`;
-          if (context.fs.readStream) source = context.fs.readStream(path, { signal });
+          const path = resolvePath(context.cwd, file);
+          const capabilities = await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;
+          if (capabilities?.retainedRead && context.fs.openReadFile) {
+            const reader2 = new ReadBudget({ ...context, signal }, {});
+            const stat = await inspect(reader2, path, "follow");
+            if (stat?.type === "file") {
+              if (stat.size > limits.inputBytes - inputBytes) throw new Diff3Error("LIMIT", "Input byte limit exceeded");
+              context.inputBudget?.check(inputBytes + stat.size);
+              source = reader2.diffSource(path);
+            } else if (context.fs.readStream) source = context.fs.readStream(path, { signal });
+            else throw new FsError(stat ? "EISDIR" : "ENOENT", { path });
+          } else if (context.fs.readStream) source = context.fs.readStream(path, { signal });
           else {
             const maxBytes = Math.min(limits.inputBytes - inputBytes, limits.retainedBytes - retained);
             const resource = await stdout.acquire(async (readSignal) => ({ bytes: await context.fs.readFile(path, { signal: readSignal, ...Number.isFinite(maxBytes) ? { maxBytes } : {} }) }), (resource2) => {
@@ -1095,44 +1886,29 @@ async function executeDiff3(context, configuration, invocation) {
             return: closeInput
           };
         } }, signal)[Symbol.asyncIterator]();
-        const parts = [];
-        chunks.push(parts);
-        let size = 0, complete = false;
+        let complete = false;
         let readFailure;
         try {
-          for (; ; ) {
-            charge(1);
-            const next = await reader.next();
-            signal.throwIfAborted();
-            if (next.done) {
-              complete = true;
-              break;
+          inputs.push(await stored.load({ async *[Symbol.asyncIterator]() {
+            for (; ; ) {
+              charge(1);
+              const next = await reader.next();
+              signal.throwIfAborted();
+              if (next.done) {
+                complete = true;
+                break;
+              }
+              const bytes = next.value;
+              if (bytes.length === 0) continue;
+              if (bytes.length > limits.inputBytes - inputBytes) throw new Diff3Error("LIMIT", "Input byte limit exceeded");
+              context.inputBudget?.check(inputBytes + bytes.length);
+              inputBytes += bytes.length;
+              charge(bytes.length);
+              stored.reserve();
+              for (let offset2 = 0; offset2 < bytes.length; offset2 += 16384) yield new Uint8Array(bytes.subarray(offset2, offset2 + 16384));
             }
-            const bytes2 = next.value;
-            if (bytes2.length === 0) continue;
-            if (bytes2.length > limits.inputBytes - inputBytes) throw new Diff3Error("LIMIT", "Input byte limit exceeded");
-            context.inputBudget?.check(inputBytes + bytes2.length);
-            inputBytes += bytes2.length;
-            charge(bytes2.length);
-            hold(bytes2.length + 8);
-            const cells = parts.length + inputs.length + chunks.length + 1;
-            if (cells > limits.graphCells) throw new Diff3Error("LIMIT", "Spool fragment limit exceeded");
-            peakGraphCells = Math.max(peakGraphCells, cells);
-            parts.push(new Uint8Array(bytes2));
-            size += bytes2.length;
-          }
-          hold(size);
-          charge(size);
-          const bytes = new Uint8Array(size);
-          let index = 0;
-          for (const part of parts) {
-            charge(1);
-            bytes.set(part, index);
-            index += part.length;
-          }
-          retained -= size + parts.length * 8 + borrowed;
-          parts.length = 0;
-          inputs.push(bytes);
+          } }));
+          retained -= borrowed;
           if (acquiredInput) acquiredInput.bytes = void 0;
         } catch (error) {
           readFailure = { error };
@@ -1148,24 +1924,22 @@ async function executeDiff3(context, configuration, invocation) {
         if (readFailure) throw readFailure.error;
       }
       charge(0);
-      const spoolCells = inputs.length + chunks.length;
-      const rendered = compareDiff3(inputs, options, { ...limits, work: limits.work - work, retainedBytes: limits.retainedBytes - retained, graphCells: limits.graphCells - spoolCells, decodedBytes: limits.decodedBytes - decodedBytes }, signal);
-      work += rendered.accounting.work;
-      decodedBytes += rendered.accounting.decodedBytes;
-      peakGraphCells = Math.max(peakGraphCells, spoolCells + rendered.accounting.peakGraphCells);
-      peakRetained = Math.max(peakRetained, retained + rendered.accounting.peakRetainedBytes);
-      hold(rendered.stdout.length + rendered.stderr.length);
-      outputBytes = rendered.stdout.length + rendered.stderr.length;
+      const rendered = await compareStoredDiff3(inputs, options, stored);
+      peakGraphCells = Math.max(peakGraphCells, stored.peakGraphCells);
+      outputBytes = rendered.outputBytes;
       publishing = true;
-      if (rendered.stderr.length) await writeBytes(stderr.output, rendered.stderr, signal);
-      if (rendered.stdout.length) await writeBytes(stdout.output, rendered.stdout, signal);
+      for await (const bytes of rendered.stderr.bytes()) await writeBytes(stderr.output, bytes, signal);
+      for await (const bytes of rendered.stdout.bytes()) await writeBytes(stdout.output, bytes, signal);
       return result(rendered.exitCode);
-    } catch (error) {
+    } catch (caught) {
+      const error = caught instanceof ToolError ? new Diff3Error("STATE", "VFS input validation failed") : caught;
       signal.throwIfAborted();
       if (publishing) throw error;
       if (!(error instanceof Diff3Error) && !(error instanceof FsError)) throw error;
       await stdout.close();
-      chunks.length = inputs.length = 0;
+      peakGraphCells = Math.max(peakGraphCells, stored?.peakGraphCells ?? 0);
+      await stored?.close();
+      inputs.length = 0;
       retained = metadataRetained;
       const code = Object.getOwnPropertyDescriptor(error, "code")?.value;
       const message = Object.getOwnPropertyDescriptor(error, "message")?.value;
@@ -1189,7 +1963,7 @@ async function executeDiff3(context, configuration, invocation) {
         else {
           bytes[index++] = 92;
           bytes[index++] = 117;
-          for (const shift2 of [12, 8, 4, 0]) bytes[index++] = hex.charCodeAt(char >>> shift2 & 15);
+          for (const shift3 of [12, 8, 4, 0]) bytes[index++] = hex.charCodeAt(char >>> shift3 & 15);
         }
       }
       bytes[index] = 10;