@poe-platform/safe-bash 0.1.546 → 0.1.548

package/dist/safe-bash/chunks/{chunk-X7C3PN2T.js → chunk-PMBBUNNN.js}

@@ -1,24 +1,20 @@
 import {
   writeFileOutput
-} from "./chunk-WXUZXY35.js";
-import {
-  PublicDiagnostic,
-  publicDiagnosticMessage
-} from "./chunk-TTTOMUAY.js";
+} from "./chunk-FMTBJ7SG.js";
 import {
   dirname,
   resolvePath
 } from "./chunk-DPJWEGIX.js";
 import {
+  FsError,
+  PublicDiagnostic,
   getCommandArguments,
+  publicDiagnosticMessage,
   shellValueByteLength,
-  shellValueBytes
-} from "./chunk-UO33SQJU.js";
-import {
-  FsError,
+  shellValueBytes,
   writeBytes,
   yieldTurn
-} from "./chunk-FDGESHPB.js";
+} from "./chunk-2PQ3XOCQ.js";
 import {
   init_platform
 } from "./chunk-2KL6W6NB.js";
@@ -11291,10 +11287,18 @@ var Budget = class {
   }
   context;
   limits;
+  buffers = /* @__PURE__ */ new Map();
   work = 0;
   checkpoint = 0;
   diagnostics = 0;
   output = 0;
+  reserveBuffered(owner, bytes2) {
+    let total = bytes2;
+    for (const [key, value] of this.buffers) if (key !== owner) total += value;
+    this.check(total, this.limits.maxBufferedBytes, "buffered bytes");
+    if (bytes2) this.buffers.set(owner, bytes2);
+    else this.buffers.delete(owner);
+  }
   quote(value) {
     const locale = this.context.env.LC_ALL || this.context.env.LC_CTYPE || this.context.env.LANG || "C";
     this.charge(value.length);
@@ -11378,6 +11382,9 @@ function fsDetail(error) {
 // packages/safe-bash/src/commands/csplit/io.ts
 init_platform();
 import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+var retainedLineUnits = 128;
+var retainedOutputUnits = 256;
+var outputBufferBytes = 65536;
 function sameIdentity(first, second) {
   return (typeof first.identityScope === "object" && first.identityScope !== null || typeof first.identityScope === "symbol") && first.identityScope === second.identityScope && Number.isSafeInteger(first.dev) && Number.isSafeInteger(first.ino) && first.dev >= 0 && first.ino >= 0 && first.dev === second.dev && first.ino === second.ino;
 }
@@ -11388,11 +11395,19 @@ var Lifecycle = class {
   }
   budget;
   pending = /* @__PURE__ */ new Set();
-  cleanups = [];
+  cleanups = /* @__PURE__ */ new Set();
   closing;
   cleanup(action) {
     this.assertOpen();
-    this.cleanups.push(action);
+    const owned = async () => {
+      try {
+        await action();
+      } finally {
+        this.cleanups.delete(owned);
+      }
+    };
+    this.cleanups.add(owned);
+    return owned;
   }
   assertOpen() {
     this.budget.context.signal.throwIfAborted();
@@ -11434,10 +11449,18 @@ var Lines = class {
   constructor(lifecycle) {
     this.lifecycle = lifecycle;
     lifecycle.cleanup(async () => {
-      if (!this.ended) await this.iterator?.return?.();
+      try {
+        if (!this.ended) await this.iterator?.return?.();
+      } finally {
+        this.lines.length = 0;
+        this.partial = [];
+        lifecycle.budget.reserveBuffered(this, 0);
+        lifecycle.budget.reserveBuffered(this.fallbackAllocation, 0);
+      }
     });
   }
   lifecycle;
+  fallbackAllocation = {};
   lines = [];
   partial = [];
   partialBytes = 0;
@@ -11447,6 +11470,9 @@ var Lines = class {
   ended = false;
   path;
   identity;
+  reserve(extraLines = 0, extraParts = 0) {
+    this.lifecycle.budget.reserveBuffered(this, this.total * 2 + (this.lines.length + extraLines + this.partial.length + extraParts) * retainedLineUnits);
+  }
   async open(name) {
     if (name === "-") {
       this.identity = this.lifecycle.budget.context.stdinInput?.stat;
@@ -11469,7 +11495,11 @@ var Lines = class {
     const capabilities = await this.lifecycle.operation(async () => await fs.capabilitiesFor?.(this.path, { signal }) ?? fs.capabilities);
     if (fs.readStream && capabilities.streamingRead !== false) return fs.readStream(this.path, { signal, chunkSize: 65536 });
     if (this.identity.size > Math.min(limits.maxInputBytes, limits.maxBufferedBytes / 2)) throw new CsplitError("buffered input bytes limit exceeded");
-    const value = await this.lifecycle.operation(() => fs.readFile(this.path, { signal, maxBytes: limits.maxInputBytes }));
+    const admittedBytes = this.identity.size;
+    this.lifecycle.budget.reserveBuffered(this.fallbackAllocation, admittedBytes);
+    this.lifecycle.budget.reserveBuffered(this, admittedBytes * 2);
+    const value = await this.lifecycle.operation(() => fs.readFile(this.path, { signal, maxBytes: admittedBytes }));
+    this.lifecycle.budget.check(value.length, admittedBytes, "input bytes");
     return { async *[Symbol.asyncIterator]() {
       yield value;
     } };
@@ -11477,6 +11507,7 @@ var Lines = class {
   appendLine() {
     const { budget } = this.lifecycle;
     budget.check(this.lines.length + 1, budget.limits.maxLines, "line count");
+    this.reserve(1);
     const line = new Uint8Array(this.partialBytes);
     let offset = 0;
     for (const part of this.partial) {
@@ -11486,6 +11517,7 @@ var Lines = class {
     this.lines.push(line);
     this.partial = [];
     this.partialBytes = 0;
+    this.reserve();
   }
   async get(number) {
     const { budget } = this.lifecycle;
@@ -11504,7 +11536,7 @@ var Lines = class {
       if (!(chunk instanceof Uint8Array)) throw new CsplitError("input produced a non-byte chunk");
       this.total += chunk.length;
       budget.check(this.total, budget.limits.maxInputBytes, "input bytes");
-      budget.check(this.total * 2, budget.limits.maxBufferedBytes, "buffered bytes");
+      this.reserve();
       if (!chunk.length) budget.check(++this.emptyChunks, budget.limits.maxEmptyChunks, "empty input chunks");
       budget.charge(chunk.length);
       const owned = Uint8Array.from(chunk);
@@ -11513,6 +11545,7 @@ var Lines = class {
         if (owned[offset] === 10) {
           this.partialBytes += offset + 1 - start;
           budget.check(this.partialBytes, budget.limits.maxLineBytes, "line bytes");
+          this.reserve(0, 1);
           this.partial.push(owned.subarray(start, offset + 1));
           this.appendLine();
           start = offset + 1;
@@ -11525,6 +11558,7 @@ var Lines = class {
       if (start < owned.length) {
         this.partialBytes += owned.length - start;
         budget.check(this.partialBytes, budget.limits.maxLineBytes, "line bytes");
+        this.reserve(0, 1);
         this.partial.push(owned.subarray(start));
       }
       await budget.checkpointWork();
@@ -11557,18 +11591,12 @@ var Outputs = class {
     let current = "/";
     for (const component of ["", ...components]) {
       if (component) current = resolvePath(current, component);
-      const identity = await this.lifecycle.operation(() => context.fs.lstat(current, { signal: context.signal }));
+      const identity = Object.freeze({ ...await this.lifecycle.operation(() => context.fs.lstat(current, { signal: context.signal })) });
       if (identity.type !== "directory" || !sameIdentity(identity, identity)) throw new CsplitError("unsafe output directory identity");
       parents.push({ path: current, identity });
     }
     return parents;
   }
-  async checked(output) {
-    await this.checkedParents(output.parents);
-    const { context } = this.lifecycle.budget;
-    const current = await this.lifecycle.operation(() => context.fs.lstat(output.path, { signal: context.signal }));
-    if (!output.identity || current.type !== "file" || !sameIdentity(current, output.identity)) throw new CsplitError("output changed before mutation");
-  }
   async checkedParents(parents) {
     const { context } = this.lifecycle.budget;
     for (const parent of parents) {
@@ -11585,53 +11613,48 @@ var Outputs = class {
     budget.check(name.length, limits.maxPathBytes, "output filename bytes");
     const path = resolvePath(context.cwd, pathText(name));
     try {
+      const capabilities = await this.lifecycle.operation(async () => await context.fs.capabilitiesFor?.(path, { signal: context.signal, create: true }) ?? context.fs.capabilities);
+      if (capabilities.atomicFileMutation !== true || !context.fs.writeFileConditional || !context.fs.removeFileConditional) throw new CsplitError("atomic output mutations are not supported");
       const parents = await this.parents(path);
       let existing;
       try {
-        existing = await this.lifecycle.operation(() => context.fs.lstat(path, { signal: context.signal }));
+        existing = Object.freeze({ ...await this.lifecycle.operation(() => context.fs.lstat(path, { signal: context.signal })) });
       } catch (error) {
         context.signal.throwIfAborted();
         if (!missing(error)) throw error;
       }
       if (existing && (existing.type !== "file" || !sameIdentity(existing, existing))) throw new CsplitError(`unsafe output file ${budget.quote(name)}`);
       this.input.assertOutput(path, existing);
-      const output = { path, name, parents, created: false, removed: false, elided: false, failed: false, size: 0, cleanup: async () => {
+      const metadataBytes = retainedOutputUnits + path.length * 2;
+      const output = { path, parent: parents.at(-1).identity, metadataBytes, created: false, removed: false, elided: false, failed: false, size: 0, buffered: 0, cleanup: async () => {
       } };
-      output.cleanup = retainFileSystemCleanup(context.fs, async (view) => {
+      budget.reserveBuffered(output, metadataBytes);
+      output.cleanup = this.lifecycle.cleanup(retainFileSystemCleanup(context.fs, async (view) => {
+        delete output.buffer;
+        output.buffered = 0;
+        budget.reserveBuffered(output, 0);
         if (!output.created || !output.identity || !output.elided && (this.succeeded || this.options.keep || this.preserve)) return;
         try {
-          for (const parent of parents) {
-            const current2 = await view.lstat(parent.path);
-            if (current2.type !== "directory" || !sameIdentity(current2, parent.identity)) return;
-          }
-          const current = await view.lstat(path);
-          if (current.type === "file" && sameIdentity(current, output.identity)) {
-            await view.rm(path);
-            output.removed = true;
-          }
+          if (!view.removeFileConditional) throw new FsError("ENOTSUP");
+          await view.removeFileConditional(path, { expected: output.identity, parent: output.parent });
+          output.removed = true;
         } catch (error) {
-          if (!missing(error)) throw error;
+          if (!missing(error) && !(error instanceof FsError && error.code === "EAGAIN")) throw error;
         }
-      }, { maxOperations: limits.maxPathDepth + 3 });
-      this.lifecycle.cleanup(output.cleanup);
-      await this.checkedParents(parents);
-      let admitted;
+      }, { maxOperations: 1 }));
       try {
-        admitted = await this.lifecycle.operation(() => context.fs.lstat(path, { signal: context.signal }));
-      } catch (error) {
-        context.signal.throwIfAborted();
-        if (!missing(error)) throw error;
+        await this.checkedParents(parents);
+        await this.lifecycle.operation(async () => {
+          output.identity = Object.freeze({ ...await context.fs.writeFileConditional(path, new Uint8Array(), {
+            signal: context.signal,
+            expected: existing ?? null,
+            parent: output.parent
+          }) });
+          output.created = true;
+        });
+      } finally {
+        parents.length = 0;
       }
-      if (admitted ? !existing || admitted.type !== "file" || !sameIdentity(admitted, existing) : existing !== void 0) throw new CsplitError("output changed before creation");
-      await this.checkedParents(parents);
-      await this.lifecycle.operation(async () => {
-        await context.fs.writeFile(path, new Uint8Array(), { signal: context.signal, flag: existing ? "w" : "wx" });
-        output.created = true;
-        if (existing) output.identity = existing;
-        const identity = await context.fs.lstat(path, { signal: context.signal });
-        if (identity.type !== "file" || !sameIdentity(identity, identity) || existing && !sameIdentity(existing, identity)) throw new CsplitError("output creation identity unavailable");
-        output.identity = identity;
-      });
       this.index++;
       this.current = output;
     } catch (error) {
@@ -11639,18 +11662,42 @@ var Outputs = class {
       throw error;
     }
   }
+  async flush(output) {
+    if (!output.buffered) return;
+    const { context } = this.lifecycle.budget;
+    try {
+      await this.lifecycle.operation(() => writeFileOutput(context, output.buffer.subarray(0, output.buffered), async (chunk) => {
+        output.identity = Object.freeze({ ...await context.fs.writeFileConditional(output.path, chunk, {
+          signal: context.signal,
+          expected: output.identity,
+          parent: output.parent,
+          append: true
+        }) });
+        output.buffered = 0;
+      }));
+    } catch (error) {
+      output.failed = true;
+      throw error;
+    }
+  }
   async write(value) {
     const output = this.current;
     if (!output) throw new CsplitError("output is not open");
     const { budget } = this.lifecycle;
     budget.fileBytes(value.length);
-    try {
-      await this.checked(output);
-      await this.lifecycle.operation(() => writeFileOutput(budget.context, value, (chunk) => budget.context.fs.appendFile(output.path, chunk, { signal: budget.context.signal })));
-      output.size += value.length;
-    } catch (error) {
-      output.failed = true;
-      throw error;
+    if (!output.buffer) {
+      const capacity = Math.min(outputBufferBytes, budget.limits.maxBufferedBytes);
+      budget.reserveBuffered(output, output.metadataBytes + capacity);
+      output.buffer = new Uint8Array(capacity);
+    }
+    for (let offset = 0; offset < value.length; ) {
+      this.lifecycle.assertOpen();
+      const count = Math.min(value.length - offset, output.buffer.length - output.buffered);
+      output.buffer.set(value.subarray(offset, offset + count), output.buffered);
+      output.buffered += count;
+      output.size += count;
+      offset += count;
+      if (output.buffered === output.buffer.length) await this.flush(output);
     }
   }
   async finish() {
@@ -11658,8 +11705,10 @@ var Outputs = class {
     if (!output) return;
     this.current = void 0;
     if (output.failed) return;
+    await this.flush(output);
+    delete output.buffer;
+    this.lifecycle.budget.reserveBuffered(output, output.metadataBytes);
     if (!output.size && this.options.elide) {
-      await this.checked(output);
       output.elided = true;
       await output.cleanup();
       if (!output.removed) throw new CsplitError("output changed before empty-file removal");
@@ -12002,62 +12051,67 @@ var Splitter = class {
 // packages/safe-bash/src/commands/csplit/command.ts
 function createCsplitCommandWithExecutor(executor, options2 = {}) {
   const limits = settings(options2);
-  return { name: "csplit", description: "Split files at bounded line and BRE boundaries", async execute(context) {
-    return withRegexSession(context, executor, async (session) => {
-      const budget = new Budget(context, limits);
-      const lifecycle = new Lifecycle(budget);
-      let output;
-      let failure;
-      let primary;
-      let exitCode = 0;
-      try {
-        const parsed = parseOptions(budget.arguments(), budget);
-        if (parsed.information) {
-          await budget.print(parsed.information === "version" ? "csplit (virtual-bash)\n" : "Usage: csplit [OPTION]... FILE PATTERN...\nOptions: -f PREFIX, -b SUFFIX, -k, -z, -n DIGITS, -s, --suppress-matched\nPatterns: INTEGER, /REGEXP/[OFFSET], %REGEXP%[OFFSET], {INTEGER}, {*}\n");
-        } else {
-          const format = suffixFormatter(parsed, budget);
-          const input = new Lines(lifecycle);
-          try {
-            await input.open(parsed.operands[0]);
-          } catch (error) {
-            if (error instanceof FsError) throw new CsplitError(`cannot open ${budget.quote(parsed.operands[0])} for reading: ${fsDetail(error)}`);
-            throw error;
+  return {
+    name: "csplit",
+    description: "Split files at bounded line and BRE boundaries",
+    filesystemRequirements: [{ id: "split", description: "Atomically mutate owned VFS outputs", capabilities: ["atomicFileMutation"], mutates: true }],
+    async execute(context) {
+      return withRegexSession(context, executor, async (session) => {
+        const budget = new Budget(context, limits);
+        const lifecycle = new Lifecycle(budget);
+        let output;
+        let failure;
+        let primary;
+        let exitCode = 0;
+        try {
+          const parsed = parseOptions(budget.arguments(), budget);
+          if (parsed.information) {
+            await budget.print(parsed.information === "version" ? "csplit (virtual-bash)\n" : "Usage: csplit [OPTION]... FILE PATTERN...\nOptions: -f PREFIX, -b SUFFIX, -k, -z, -n DIGITS, -s, --suppress-matched\nPatterns: INTEGER, /REGEXP/[OFFSET], %REGEXP%[OFFSET], {INTEGER}, {*}\n");
+          } else {
+            const format = suffixFormatter(parsed, budget);
+            const input = new Lines(lifecycle);
+            try {
+              await input.open(parsed.operands[0]);
+            } catch (error) {
+              if (error instanceof FsError) throw new CsplitError(`cannot open ${budget.quote(parsed.operands[0])} for reading: ${fsDetail(error)}`);
+              throw error;
+            }
+            const matcher = new Matcher(session, budget);
+            const patterns = await preparePatterns(parsed.operands.slice(1), matcher);
+            output = new Outputs(lifecycle, parsed, format, input);
+            await new Splitter(input, output, matcher).run(patterns);
+            output.succeeded = true;
           }
-          const matcher = new Matcher(session, budget);
-          const patterns = await preparePatterns(parsed.operands.slice(1), matcher);
-          output = new Outputs(lifecycle, parsed, format, input);
-          await new Splitter(input, output, matcher).run(patterns);
-          output.succeeded = true;
-        }
-      } catch (error) {
-        primary = { reason: error };
-        failure = { reason: error };
-        if (output && error instanceof CsplitError && error.preserve) output.preserve = true;
-        if (!context.signal.aborted) {
-          exitCode = 1;
-          try {
-            const message = error instanceof ExprMatchError ? error.message : error instanceof FsError ? fsDetail(error) : publicDiagnosticMessage(error, context.onInternalError);
-            await budget.print(`csplit: ${message}
+        } catch (error) {
+          primary = { reason: error };
+          failure = { reason: error };
+          if (output && error instanceof CsplitError && error.preserve) output.preserve = true;
+          if (!context.signal.aborted) {
+            exitCode = 1;
+            try {
+              const message = error instanceof ExprMatchError ? error.message : error instanceof FsError ? fsDetail(error) : publicDiagnosticMessage(error, context.onInternalError);
+              await budget.print(`csplit: ${message}
 `, true);
-            if (error instanceof CsplitError && error.usage) await budget.print("Try 'csplit --help' for more information.\n", true);
-            if (!(error instanceof CsplitError && error.preserve)) await output?.finish();
-            failure = void 0;
-          } catch (reporting) {
-            failure = { reason: new AggregateError([error, reporting], "csplit failure reporting failed") };
+              if (error instanceof CsplitError && error.usage) await budget.print("Try 'csplit --help' for more information.\n", true);
+              if (!(error instanceof CsplitError && error.preserve)) await output?.finish();
+              failure = void 0;
+            } catch (reporting) {
+              failure = { reason: new AggregateError([error, reporting], "csplit failure reporting failed") };
+            }
           }
         }
-      }
-      try {
-        await lifecycle.close();
-      } catch (cleanup) {
-        const previous = failure ?? primary;
-        failure = { reason: previous ? new AggregateError([previous.reason, cleanup], "csplit execution and cleanup failed") : cleanup };
-      }
-      context.signal.throwIfAborted();
-      if (failure) throw failure.reason;
-      return { exitCode };
-    });
-  } };
+        try {
+          await lifecycle.close();
+        } catch (cleanup) {
+          const previous = failure ?? primary;
+          failure = { reason: previous ? new AggregateError([previous.reason, cleanup], "csplit execution and cleanup failed") : cleanup };
+        }
+        context.signal.throwIfAborted();
+        if (failure) throw failure.reason;
+        return { exitCode };
+      });
+    }
+  };
 }
 
 // packages/safe-bash/src/commands/csplit/index.ts
@@ -12100,4 +12154,4 @@ export {
   createCsplitCommands,
   csplitCommands
 };
-//# sourceMappingURL=chunk-X7C3PN2T.js.map
+//# sourceMappingURL=chunk-PMBBUNNN.js.map