@poe-platform/safe-bash 0.1.809 → 0.1.810

package/dist/safe-bash/command-chunks/{chunk-62ZAHKFS.js → chunk-2VCKUNDZ.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-66QPYWEF.js";
 import {
   parseRecords
-} from "./chunk-OQCJGUI6.js";
+} from "./chunk-HARUYHH7.js";
 import {
   FileFailure,
   PatchError,
@@ -24,6 +24,111 @@ import {
   writeBytes
 } from "../../safe-bash-contracts/index.js";
 
+// packages/safe-bash-command-apply-patch/src/metadata.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+var MetadataList = class {
+  constructor(storage, work, codec, head = 0, length = 0) {
+    this.storage = storage;
+    this.work = work;
+    this.codec = codec;
+    this.head = head;
+    this.length = length;
+  }
+  storage;
+  work;
+  codec;
+  head;
+  length;
+  tail = 0;
+  async push(value) {
+    this.work.step();
+    await this.work.checkpoint();
+    if (this.length && !this.tail) throw new Error("Cannot append to a retained patch collection");
+    const bytes = new Uint8Array(8 + this.codec.size);
+    this.codec.encode(new DataView(bytes.buffer, 8), value);
+    const address = this.storage.allocate(bytes.length);
+    await this.storage.write(address, bytes);
+    if (this.tail) {
+      const link = new Uint8Array(8);
+      new DataView(link.buffer).setFloat64(0, address, true);
+      await this.storage.write(this.tail, link);
+    } else this.head = address;
+    this.tail = address;
+    this.length++;
+  }
+  async *[Symbol.asyncIterator]() {
+    let address = this.head;
+    for (let index = 0; index < this.length; index++) {
+      this.work.step();
+      await this.work.checkpoint();
+      const bytes = await this.storage.read(address, 8 + this.codec.size);
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      address = view.getFloat64(0, true);
+      yield this.codec.decode(new DataView(bytes.buffer, bytes.byteOffset + 8, this.codec.size));
+    }
+  }
+};
+var PatchMetadata = class {
+  constructor(document, work) {
+    this.work = work;
+    this.storage = new PagedStorage(work.context, 8);
+    this.close = this.storage.close.bind(this.storage);
+    work.context.registerCleanup?.(this.close);
+    this.textCodec = {
+      size: 16,
+      encode(view, value) {
+        view.setFloat64(0, value.start, true);
+        view.setFloat64(8, value.end, true);
+      },
+      decode(view) {
+        return { document, start: view.getFloat64(0, true), end: view.getFloat64(8, true) };
+      }
+    };
+    this.lineCodec = {
+      size: 24,
+      encode: (view, value) => {
+        view.setUint8(0, value.kind.charCodeAt(0));
+        this.textCodec.encode(new DataView(view.buffer, view.byteOffset + 8, 16), value.text);
+      },
+      decode: (view) => ({
+        kind: String.fromCharCode(view.getUint8(0)),
+        text: this.textCodec.decode(new DataView(view.buffer, view.byteOffset + 8, 16))
+      })
+    };
+    this.hunkCodec = {
+      size: 40,
+      encode(view, value) {
+        if (!(value.anchors instanceof MetadataList) || !(value.lines instanceof MetadataList)) throw new Error("Patch metadata must share caller storage");
+        view.setFloat64(0, value.anchors.head, true);
+        view.setFloat64(8, value.anchors.length, true);
+        view.setFloat64(16, value.lines.head, true);
+        view.setFloat64(24, value.lines.length, true);
+        view.setUint8(32, Number(value.eof));
+      },
+      decode: (view) => ({
+        anchors: new MetadataList(this.storage, work, this.textCodec, view.getFloat64(0, true), view.getFloat64(8, true)),
+        lines: new MetadataList(this.storage, work, this.lineCodec, view.getFloat64(16, true), view.getFloat64(24, true)),
+        eof: !!view.getUint8(32)
+      })
+    };
+  }
+  work;
+  storage;
+  close;
+  textCodec;
+  lineCodec;
+  hunkCodec;
+  texts() {
+    return new MetadataList(this.storage, this.work, this.textCodec);
+  }
+  lines() {
+    return new MetadataList(this.storage, this.work, this.lineCodec);
+  }
+  hunks() {
+    return new MetadataList(this.storage, this.work, this.hunkCodec);
+  }
+};
+
 // packages/safe-bash-command-apply-patch/src/stored-text.ts
 async function* textChunks(value) {
   const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
@@ -99,7 +204,7 @@ async function equalText(left, right, pass, work) {
 }
 
 // packages/safe-bash-command-apply-patch/src/stored-parser.ts
-async function parseDocument(document, work) {
+async function parseDocument(document, work, metadata) {
   await work.utf8(work.cwd, work.limits.maxPathBytes, 2);
   if (!work.cwd.startsWith("/") || work.cwd.includes("\0")) throw new PatchError("cwd must be an absolute virtual path", 2);
   if (document.binary) throw new PatchError("NUL bytes are unsupported", 2);
@@ -124,7 +229,7 @@ async function parseDocument(document, work) {
       for await (const chunk of textChunks(value)) result += chunk;
       return result;
     } };
-  } }, work);
+  } }, work, metadata);
 }
 
 // packages/safe-bash-command-apply-patch/src/stored-matcher.ts
@@ -146,8 +251,9 @@ async function find(document, pattern, start, eof, work) {
   for (let pass = 0; pass < 4; pass++) for (let candidate = first; candidate <= last; candidate++) {
     await work.charge(1);
     let equal = true;
-    for (let offset = 0; offset < pattern.length; offset++) {
-      if (!await matches(document, candidate + offset, pattern[offset], pass, work)) {
+    let offset = 0;
+    for await (const expected of pattern) {
+      if (!await matches(document, candidate + offset++, expected, pass, work)) {
         equal = false;
         break;
       }
@@ -158,7 +264,7 @@ async function find(document, pattern, start, eof, work) {
 }
 async function* records(file, original, work, ending) {
   if (file.kind === "add") {
-    for (const value of file.added) {
+    for await (const value of file.added) {
       await work.charge(1);
       yield { start: 0, end: 0, ending: "\n", text: value };
     }
@@ -166,26 +272,33 @@ async function* records(file, original, work, ending) {
   }
   const old = original;
   let cursor = 0, emitted = 0;
-  for (const hunk of file.hunks) {
+  for await (const hunk of file.hunks) {
     let anchorPosition;
-    for (const anchor of hunk.anchors) {
+    for await (const anchor of hunk.anchors) {
       const position = await find(old, [anchor], cursor, false, work);
       if (position < 0) throw new PatchError(`context anchor not found: ${file.label}`);
       cursor = position + 1;
       anchorPosition = position;
     }
-    const pattern = [];
-    for (const line of hunk.lines) {
+    let patternLength = 0;
+    let first;
+    for await (const line of hunk.lines) {
       await work.charge(1);
-      if (line.kind !== "+") pattern.push(line.text);
+      if (line.kind !== "+") {
+        patternLength++;
+        first ??= line.text;
+      }
     }
-    const searchStart = anchorPosition !== void 0 && pattern.length && await matches(old, anchorPosition, pattern[0], 3, work) ? anchorPosition : cursor;
+    const pattern = { length: patternLength, async *[Symbol.asyncIterator]() {
+      for await (const line of hunk.lines) if (line.kind !== "+") yield line.text;
+    } };
+    const searchStart = anchorPosition !== void 0 && first !== void 0 && await matches(old, anchorPosition, first, 3, work) ? anchorPosition : cursor;
     const start = pattern.length ? await find(old, pattern, searchStart, hunk.eof, work) : hunk.eof ? old.length : cursor;
     if (start < 0) throw new PatchError(`expected context not found: ${file.label}`);
     if (start < emitted) throw new PatchError("overlapping update hunks");
     while (emitted < start) yield await record(old, emitted++);
     let matched = start;
-    for (const line of hunk.lines) {
+    for await (const line of hunk.lines) {
       await work.charge(1);
       if (line.kind === " ") yield await record(old, matched++);
       else if (line.kind === "-") matched++;
@@ -547,7 +660,10 @@ var Invocation = class {
     let summary;
     try {
       try {
-        const files = await parseDocument(await this.input(), work);
+        const input = await this.input();
+        const metadata = new PatchMetadata(input, work);
+        this.documents.add(metadata);
+        const files = await parseDocument(input, work, metadata);
         await this.confine(files);
         const plans = await this.prepare(files);
         const lines = ["Success. Updated the following files:\n"];