@poe-platform/safe-bash 0.1.788 → 0.1.790

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

@@ -0,0 +1,67 @@
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-docx/dist/index.js
+init_buffer();
+import { shellValueByteLength } from "../safe-bash-contracts/value.js";
+import { FsError, getCommandArguments } from "../safe-bash-contracts/index.js";
+import { validateExitCode } from "../safe-bash-contracts/command.js";
+function createDocxCommand(options) {
+  if (!options?.engine || typeof options.engine.execute !== "function")
+    throw new TypeError("An explicit docx command engine is required.");
+  if (options.replace !== void 0 && typeof options.replace !== "boolean")
+    throw new TypeError("docx replace must be boolean.");
+  const maxArgumentBytes = options.limits?.maxArgumentBytes ?? Infinity;
+  if (maxArgumentBytes !== Infinity && (!Number.isSafeInteger(maxArgumentBytes) || maxArgumentBytes < 0)) {
+    throw new RangeError("maxArgumentBytes must be a nonnegative safe integer or Infinity");
+  }
+  const engine = options.engine;
+  return {
+    name: "docx",
+    async execute(context) {
+      context.signal.throwIfAborted();
+      const arguments_ = getCommandArguments(context);
+      let argumentBytes = 0;
+      for (let index = 0; index < arguments_.args.length; index++) {
+        const bytes = shellValueByteLength(arguments_.values[index]);
+        if (bytes > maxArgumentBytes - argumentBytes)
+          throw new FsError("EFBIG", { message: "document argument limit exceeded" });
+        argumentBytes += bytes;
+      }
+      const result = await engine.execute({
+        args: Object.freeze(arguments_.args.map((_, index) => arguments_.bytes(index))),
+        cwd: context.cwd,
+        filesystem: context.fs,
+        stdin: context.stdin,
+        ...context.stdinIsDefault === void 0 ? {} : { stdinIsDefault: context.stdinIsDefault },
+        stdout: context.stdout,
+        stderr: context.stderr,
+        signal: context.signal,
+        ...context.registerCleanup === void 0 ? {} : { registerCleanup: context.registerCleanup }
+      });
+      context.signal.throwIfAborted();
+      return { exitCode: validateExitCode(result.exitCode) };
+    }
+  };
+}
+function createDocxCommands(options) {
+  return [createDocxCommand(options)];
+}
+function docxCommands(options) {
+  const command = createDocxCommand(options);
+  const replace = options.replace ?? false;
+  return {
+    name: "docx-commands",
+    setup(host) {
+      if (!replace && host.commands.has(command.name))
+        throw new Error("Command already registered: docx");
+      host.commands.register(command, { replace });
+    }
+  };
+}
+export {
+  createDocxCommand,
+  createDocxCommands,
+  docxCommands
+};

package/dist/safe-bash-command-docx/io.d.ts

@@ -0,0 +1,14 @@
+import { type ByteSink, type ByteSource } from "../safe-bash-contracts/io.js";
+import type { CommandContext } from "../safe-bash-contracts/command.js";
+export declare function documentByteSource(source: ByteSource): {
+    open(signal: AbortSignal): AsyncIterable<Uint8Array>;
+};
+export declare function documentByteSink(sink: ByteSink): {
+    write(bytes: Uint8Array, signal: AbortSignal): Promise<void>;
+};
+export declare function createDocumentOutput(context: Pick<CommandContext, "signal" | "registerCleanup">, destination: ByteSink): {
+    readonly sink: {
+        write(bytes: Uint8Array, signal: AbortSignal): Promise<void>;
+    };
+    readonly cleanup: () => Promise<void>;
+};

package/dist/safe-bash-command-docx/io.js

@@ -0,0 +1,26 @@
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-docx/dist/io.js
+init_buffer();
+import { readBytes, writeBytes } from "../safe-bash-contracts/io.js";
+import { createOutputOperation } from "../safe-bash-contracts/output.js";
+function documentByteSource(source) {
+  return { open: (signal) => readBytes(source, signal) };
+}
+function documentByteSink(sink) {
+  return { write: (bytes, signal) => writeBytes(sink, bytes, signal) };
+}
+function createDocumentOutput(context, destination) {
+  const operation = createOutputOperation(context, destination);
+  return {
+    sink: documentByteSink(operation.output),
+    cleanup: operation.close
+  };
+}
+export {
+  createDocumentOutput,
+  documentByteSink,
+  documentByteSource
+};

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

@@ -4,6 +4,7 @@ import {
 
 // packages/safe-bash-command-envsubst/dist/index.js
 init_buffer();
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
 import { collectBytes, commandRuntimeIdentity, writeBytes, writeText } from "../safe-bash-contracts/index.js";
 function settings(options = {}) {
   const limits = {
@@ -87,6 +88,13 @@ function extractVariablesFromBytes(bytes) {
   return vars;
 }
 function substituteBytes(input, env, allowedVars, maxOutputBytes) {
+  const steps = substituteSteps(input, env, allowedVars, maxOutputBytes);
+  let step = steps.next();
+  while (!step.done)
+    step = steps.next();
+  return step.value;
+}
+function* substituteSteps(input, env, allowedVars, maxOutputBytes) {
   const chunks = [];
   let totalOut = 0;
   const pushChunk = (chunk) => {
@@ -100,7 +108,12 @@ function substituteBytes(input, env, allowedVars, maxOutputBytes) {
   };
   let segStart = 0;
   let i = 0;
+  let nextTurn = 4096;
   while (i < input.byteLength) {
+    if (i >= nextTurn) {
+      yield;
+      nextTurn = i + 4096;
+    }
     if (input[i] !== 36) {
       i++;
       continue;
@@ -116,8 +129,13 @@ function substituteBytes(input, env, allowedVars, maxOutputBytes) {
       let j = i + 2;
       if (j < input.byteLength && isIdentStart(input[j])) {
         j++;
-        while (j < input.byteLength && isIdentPart(input[j]))
+        while (j < input.byteLength && isIdentPart(input[j])) {
+          if (j >= nextTurn) {
+            yield;
+            nextTurn = j + 4096;
+          }
           j++;
+        }
         if (j < input.byteLength && input[j] === 125) {
           varName = sharedDecoder.decode(input.subarray(i + 2, j));
           endIdx = j + 1;
@@ -125,8 +143,13 @@ function substituteBytes(input, env, allowedVars, maxOutputBytes) {
       }
     } else if (isIdentStart(next)) {
       let j = i + 2;
-      while (j < input.byteLength && isIdentPart(input[j]))
+      while (j < input.byteLength && isIdentPart(input[j])) {
+        if (j >= nextTurn) {
+          yield;
+          nextTurn = j + 4096;
+        }
         j++;
+      }
       varName = sharedDecoder.decode(input.subarray(i + 1, j));
       endIdx = j;
     }
@@ -218,12 +241,20 @@ function createEnvsubstCommand(options = {}) {
         return { exitCode: 1 };
       }
       try {
-        const output = substituteBytes(input, context.env, allowedVars, limits.maxOutputBytes);
+        const steps = substituteSteps(input, context.env, allowedVars, limits.maxOutputBytes);
+        let step = steps.next();
+        while (!step.done) {
+          await yieldTurn(context.signal);
+          context.signal.throwIfAborted();
+          step = steps.next();
+        }
+        const output = step.value;
         if (output.byteLength > 0) {
           await writeBytes(context.stdout, output);
         }
         return { exitCode: 0 };
       } catch (err) {
+        context.signal.throwIfAborted();
         await writeText(context.stderr, `${err instanceof Error ? err.message : "envsubst: error"}
 `);
         return { exitCode: 1 };

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

@@ -7,6 +7,7 @@ init_buffer();
 
 // packages/safe-bash-command-exiftool/dist/command.js
 init_buffer();
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
 import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/command.js";
 import { FsError as FsError2 } from "../safe-bash-contracts/errors.js";
 import { readBytes as readBytes2, writeBytes } from "../safe-bash-contracts/io.js";
@@ -2083,6 +2084,8 @@ function createExiftoolCommand(options = {}) {
         };
         let errors = 0, updated = 0, created = 0, unchanged = 0, read = 0;
         for (const file of invocation.files) {
+          await yieldTurn(context.signal);
+          context.signal.throwIfAborted();
           let tags = [];
           try {
             const { path, original, bytes } = await acquire(file);