@poe-platform/safe-bash 0.1.534 → 0.1.536

package/dist/safe-bash/chunks/chunk-QY2XHZTE.js

@@ -0,0 +1,192 @@
+import {
+  createOutputOperation
+} from "./chunk-PPVCI2F2.js";
+import {
+  FsError,
+  createBytePipe,
+  init_platform,
+  outputFailure
+} from "./chunk-L2GZSOSJ.js";
+
+// packages/safe-bash/src/contracts/filesystem-output.ts
+init_platform();
+var filesystemOutputBudgets = /* @__PURE__ */ new WeakMap();
+function bindFileOutputBudget(context, budget) {
+  if (!context.registerCleanup) throw new TypeError("Shell output budgets require invocation cleanup ownership");
+  filesystemOutputBudgets.set(context.registerCleanup, budget);
+}
+async function writeFileOutput(context, bytes, write) {
+  context.signal.throwIfAborted();
+  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);
+  let pending;
+  const destination = { write(chunk) {
+    context.signal.throwIfAborted();
+    return pending = (async () => {
+      await write(chunk);
+    })();
+  } };
+  try {
+    await (budget?.(destination) ?? destination).write(bytes);
+  } catch (error) {
+    await pending?.catch(() => {
+    });
+    context.signal.throwIfAborted();
+    throw error;
+  }
+  context.signal.throwIfAborted();
+}
+async function openFileOutput(context, path, flag, incremental) {
+  let pipe;
+  let task;
+  let completed = false;
+  let ended = false;
+  let closing = false;
+  let failure;
+  const consumer = new AbortController();
+  let writes = Promise.resolve();
+  let acknowledge;
+  const acknowledgeWrite = () => {
+    const accepted = acknowledge;
+    acknowledge = void 0;
+    accepted?.();
+  };
+  let ready;
+  const opened = new Promise((resolve) => {
+    ready = resolve;
+  });
+  const destination = {
+    [outputFailure]: (reason) => operation.abort(reason),
+    async write(chunk) {
+      if (closing) throw new FsError("EBADF", { path, syscall: "write" });
+      const writing = writes.then(async () => {
+        for (let offset = 0; offset < chunk.byteLength; offset += 64 * 1024) {
+          const accepted = new Promise((resolve) => {
+            acknowledge = resolve;
+          });
+          await pipe.writable.write(chunk.subarray(offset, offset + 64 * 1024));
+          await accepted;
+          if (failure) throw failure.reason;
+          operation.signal.throwIfAborted();
+        }
+      });
+      writes = writing.catch(() => {
+      });
+      await writing;
+    }
+  };
+  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);
+  const operation = createOutputOperation(context, budget?.(destination) ?? destination);
+  operation.registerCleanup(async () => {
+    closing = true;
+    if (!completed) {
+      void operation.abort(operation.signal.aborted ? operation.signal.reason : new FsError("ECANCELED", { path, syscall: "write" }));
+      await pipe?.abort(operation.signal.reason);
+    }
+    await task?.catch(() => {
+    });
+    await writes;
+  });
+  try {
+    pipe = createBytePipe({ highWaterMark: 1, signal: operation.signal });
+    let reading = false;
+    const source = {
+      [Symbol.asyncIterator]() {
+        return (async function* () {
+          reading = true;
+          ready();
+          for await (const chunk of pipe.readable) {
+            yield chunk;
+            acknowledgeWrite();
+          }
+          operation.signal.throwIfAborted();
+          ended = true;
+        })();
+      }
+    };
+    task = (async () => {
+      const { fs } = context;
+      const signal = operation.signal;
+      signal.throwIfAborted();
+      const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
+      if (capabilities.readOnly === true) throw new FsError("EROFS", { path, syscall: "write" });
+      try {
+        await fs.access(path, 2, { signal });
+      } catch (error) {
+        signal.throwIfAborted();
+        if (!(error instanceof FsError) || error.code !== "ENOENT" && error.code !== "ENOTSUP") throw error;
+      }
+      signal.throwIfAborted();
+      const streaming = flag === "a" ? capabilities.streamingAppend ?? capabilities.streamingWrite : capabilities.streamingWrite;
+      if ((!incremental || capabilities.descriptorWriteStream === true) && streaming !== false && fs.writeStream) {
+        try {
+          await fs.writeStream(path, source, { flag, signal });
+          if (!ended) throw new FsError("EIO", { path, message: "Streaming writer returned before consuming output" });
+          return;
+        } catch (error) {
+          signal.throwIfAborted();
+          if (reading || !(error instanceof FsError) || error.code !== "ENOTSUP") throw error;
+        }
+      }
+      if (flag === "w" && capabilities.write === false) throw new FsError("ENOTSUP", { path, syscall: "writeFile" });
+      if ((!incremental || flag === "a") && capabilities.append === false) throw new FsError("ENOTSUP", { path, syscall: "appendFile" });
+      const sink = incremental ? await incremental() : await (async () => {
+        if (flag === "a") await fs.appendFile(path, new Uint8Array(), { signal });
+        else await fs.writeFile(path, new Uint8Array(), { flag, signal });
+        return { write: (chunk) => fs.appendFile(path, chunk, { signal }) };
+      })();
+      for await (const chunk of source) {
+        signal.throwIfAborted();
+        await sink.write(chunk);
+      }
+    })();
+    void task.then(acknowledgeWrite, (error) => {
+      failure = { reason: error };
+      acknowledgeWrite();
+      if (!operation.signal.aborted) consumer.abort(error);
+      void operation.abort(error).catch(() => {
+      });
+    });
+    await Promise.race([opened, task]);
+    operation.signal.throwIfAborted();
+    const write = async (chunk) => {
+      try {
+        await operation.output.write(chunk);
+      } catch (error) {
+        throw failure ? failure.reason : error;
+      }
+    };
+    return {
+      signal: operation.signal,
+      sink: {
+        [outputFailure]: destination[outputFailure],
+        ownedOutput: { consumerClosed: consumer.signal, write },
+        write
+      },
+      async finish() {
+        closing = true;
+        try {
+          await writes;
+          await pipe.close();
+          await task;
+          operation.signal.throwIfAborted();
+          completed = true;
+        } catch (error) {
+          throw failure ? failure.reason : error;
+        } finally {
+          await operation.close();
+        }
+      },
+      abort: (reason) => operation.abort(reason)
+    };
+  } catch (error) {
+    await operation.abort(error);
+    throw error;
+  }
+}
+
+export {
+  bindFileOutputBudget,
+  writeFileOutput,
+  openFileOutput
+};
+//# sourceMappingURL=chunk-QY2XHZTE.js.map

package/dist/safe-bash/chunks/chunk-QY2XHZTE.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/contracts/filesystem-output.ts"],
+  "sourcesContent": ["import type { CommandContext } from \"./command.js\";\nimport { FsError } from \"./errors.js\";\nimport { createBytePipe, outputFailure, type BytePipe, type ByteSink, type ByteSource } from \"./io.js\";\nimport { createOutputOperation } from \"./output.js\";\n\nconst filesystemOutputBudgets = new WeakMap<NonNullable<CommandContext[\"registerCleanup\"]>, (sink: ByteSink) => ByteSink>();\n\nexport type FileOutputContext = Pick<CommandContext, \"fs\" | \"signal\" | \"registerCleanup\">;\n\nexport function bindFileOutputBudget(context: Pick<CommandContext, \"registerCleanup\">, budget: (sink: ByteSink) => ByteSink): void {\n  if (!context.registerCleanup) throw new TypeError(\"Shell output budgets require invocation cleanup ownership\");\n  filesystemOutputBudgets.set(context.registerCleanup, budget);\n}\n\nexport async function writeFileOutput(context: Pick<CommandContext, \"signal\" | \"registerCleanup\">, bytes: Uint8Array, write: (bytes: Uint8Array) => Promise<void>): Promise<void> {\n  context.signal.throwIfAborted();\n  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);\n  let pending: Promise<void> | undefined;\n  const destination: ByteSink = { write(chunk) {\n    context.signal.throwIfAborted();\n    return pending = (async () => { await write(chunk); })();\n  } };\n  try { await (budget?.(destination) ?? destination).write(bytes); }\n  catch (error) {\n    // Shell sink cancellation may win its race before the direct host call.\n    // Keep the original awaited-write lifetime without a retained cleanup hook.\n    await pending?.catch(() => {});\n    context.signal.throwIfAborted();\n    throw error;\n  }\n  context.signal.throwIfAborted();\n}\n\nexport interface FileOutput {\n  readonly sink: ByteSink;\n  readonly signal: AbortSignal;\n  finish(): Promise<void>;\n  abort(reason: unknown): Promise<void>;\n}\n\nexport async function openFileOutput(context: FileOutputContext, path: string, flag: \"w\" | \"a\", incremental?: () => Promise<ByteSink>): Promise<FileOutput> {\n  let pipe: BytePipe | undefined;\n  let task: Promise<void> | undefined;\n  let completed = false;\n  let ended = false;\n  let closing = false;\n  let failure: { reason: unknown } | undefined;\n  const consumer = new AbortController();\n  let writes = Promise.resolve();\n  let acknowledge: (() => void) | undefined;\n  const acknowledgeWrite = (): void => {\n    const accepted = acknowledge;\n    acknowledge = undefined;\n    accepted?.();\n  };\n  let ready!: () => void;\n  const opened = new Promise<void>(resolve => { ready = resolve; });\n  const destination: ByteSink = {\n    [outputFailure]: reason => operation.abort(reason),\n    async write(chunk) {\n      if (closing) throw new FsError(\"EBADF\", { path, syscall: \"write\" });\n      const writing = writes.then(async () => {\n        for (let offset = 0; offset < chunk.byteLength; offset += 64 * 1024) {\n          const accepted = new Promise<void>(resolve => { acknowledge = resolve; });\n          await pipe!.writable.write(chunk.subarray(offset, offset + 64 * 1024));\n          await accepted;\n          if (failure) throw failure.reason;\n          operation.signal.throwIfAborted();\n        }\n      });\n      writes = writing.catch(() => {});\n      await writing;\n    },\n  };\n  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);\n  const operation = createOutputOperation(context, budget?.(destination) ?? destination);\n  operation.registerCleanup(async () => {\n    closing = true;\n    if (!completed) {\n      void operation.abort(operation.signal.aborted ? operation.signal.reason : new FsError(\"ECANCELED\", { path, syscall: \"write\" }));\n      await pipe?.abort(operation.signal.reason);\n    }\n    await task?.catch(() => {});\n    await writes;\n  });\n  try {\n    pipe = createBytePipe({ highWaterMark: 1, signal: operation.signal });\n    let reading = false;\n    const source: ByteSource = {\n      [Symbol.asyncIterator]() {\n        return (async function* () {\n          reading = true;\n          ready();\n          for await (const chunk of pipe!.readable) {\n            yield chunk;\n            acknowledgeWrite();\n          }\n          operation.signal.throwIfAborted();\n          ended = true;\n        })();\n      },\n    };\n    task = (async () => {\n      const { fs } = context;\n      const signal = operation.signal;\n      signal.throwIfAborted();\n      const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;\n      if (capabilities.readOnly === true) throw new FsError(\"EROFS\", { path, syscall: \"write\" });\n      try { await fs.access(path, 2, { signal }); }\n      catch (error) {\n        signal.throwIfAborted();\n        if (!(error instanceof FsError) || error.code !== \"ENOENT\" && error.code !== \"ENOTSUP\") throw error;\n      }\n      signal.throwIfAborted();\n      const streaming = flag === \"a\" ? capabilities.streamingAppend ?? capabilities.streamingWrite : capabilities.streamingWrite;\n      if ((!incremental || capabilities.descriptorWriteStream === true) && streaming !== false && fs.writeStream) {\n        try {\n          await fs.writeStream(path, source, { flag, signal });\n          if (!ended) throw new FsError(\"EIO\", { path, message: \"Streaming writer returned before consuming output\" });\n          return;\n        } catch (error) {\n          signal.throwIfAborted();\n          if (reading || !(error instanceof FsError) || error.code !== \"ENOTSUP\") throw error;\n        }\n      }\n      if (flag === \"w\" && capabilities.write === false) throw new FsError(\"ENOTSUP\", { path, syscall: \"writeFile\" });\n      if ((!incremental || flag === \"a\") && capabilities.append === false) throw new FsError(\"ENOTSUP\", { path, syscall: \"appendFile\" });\n      const sink = incremental ? await incremental() : await (async (): Promise<ByteSink> => {\n        if (flag === \"a\") await fs.appendFile(path, new Uint8Array(), { signal });\n        else await fs.writeFile(path, new Uint8Array(), { flag, signal });\n        return { write: chunk => fs.appendFile(path, chunk, { signal }) };\n      })();\n      for await (const chunk of source) {\n        signal.throwIfAborted();\n        await sink.write(chunk);\n      }\n    })();\n    void task.then(acknowledgeWrite, error => {\n      failure = { reason: error };\n      acknowledgeWrite();\n      if (!operation.signal.aborted) consumer.abort(error);\n      void operation.abort(error).catch(() => {});\n    });\n    await Promise.race([opened, task]);\n    operation.signal.throwIfAborted();\n    const write = async (chunk: Uint8Array): Promise<void> => {\n      try { await operation.output.write(chunk); }\n      catch (error) { throw failure ? failure.reason : error; }\n    };\n    return {\n      signal: operation.signal,\n      sink: {\n        [outputFailure]: destination[outputFailure]!,\n        ownedOutput: { consumerClosed: consumer.signal, write },\n        write,\n      },\n      async finish() {\n        closing = true;\n        try {\n          await writes;\n          await pipe!.close();\n          await task;\n          operation.signal.throwIfAborted();\n          completed = true;\n        } catch (error) { throw failure ? failure.reason : error; }\n        finally { await operation.close(); }\n      },\n      abort: reason => operation.abort(reason),\n    };\n  } catch (error) {\n    await operation.abort(error);\n    throw error;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/safe-bash/chunks/{chunk-6MHYEBAJ.js → chunk-UZELUFGF.js}

@@ -21,21 +21,23 @@ import {
   scalarJson,
   truth,
   wellFormed
-} from "./chunk-54Z5EUCW.js";
+} from "./chunk-M7KZ7V4P.js";
+import {
+  escapeText,
+  pathOf
+} from "./chunk-5Y4AEZB2.js";
 import {
   createOutputOperation
-} from "./chunk-2GV4WO7O.js";
+} from "./chunk-PPVCI2F2.js";
 import {
   FsError,
-  escapeText,
   getCommandArguments,
   import_buffer,
   init_platform,
-  pathOf,
   readBytes,
   shellValueByteLength,
   yieldTurn
-} from "./chunk-LUJYX5H5.js";
+} from "./chunk-L2GZSOSJ.js";
 
 // packages/safe-bash/src/commands/yq/index.ts
 init_platform();
@@ -5152,4 +5154,4 @@ export {
   createYqCommands,
   yqCommands
 };
-//# sourceMappingURL=chunk-6MHYEBAJ.js.map
+//# sourceMappingURL=chunk-UZELUFGF.js.map