@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/command-chunks/{chunk-F4TEEZTL.js → chunk-BOEOJS2Q.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-Z6UEDK5T.js";
 import {
   boundedCodec
-} from "./chunk-W5DNF4JH.js";
+} from "./chunk-ZHN3QDCI.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-XS72HTMA.js → chunk-BWGGLYEB.js}

@@ -36,8 +36,6 @@ import { syncCommandEvaluators as syncCommandEvaluators2 } from "../../safe-bash
 import { UsageError as UsageError2 } from "../../safe-bash-contracts/diagnostics.js";
 import { pathOf as pathOf2 } from "../../safe-bash-query-engine/path.js";
 var syncResolved = /* @__PURE__ */ Symbol.for("safe-bash.syncResolved");
-var sharedSmallOutputBuf = new Uint8Array(64);
-var sharedSmallOutputViews = Array.from({ length: 65 }, (_, i) => sharedSmallOutputBuf.subarray(0, i));
 var resolvedVoid = Object.defineProperty(
   Promise.resolve(),
   syncResolved,
@@ -156,34 +154,19 @@ function outputRange(context, src, len) {
     if (typeof stdout.writeRangeSync === "function" && stdout.writeRangeSync(src, len) !== false) {
       return resolvedVoid;
     }
-    if (typeof stdout.writeSync === "function" && stdout.writeSync(src.subarray(0, len)) !== false) {
+    if (typeof stdout.writeSync === "function" && stdout.writeSync(new Uint8Array(src.subarray(0, len))) !== false) {
       return resolvedVoid;
     }
   }
-  return writeBytes(context.stdout, stdout.isPipeStage ? src.subarray(0, len) : src.slice(0, len), context.signal);
+  return writeBytes(context.stdout, stdout.isPipeStage ? src.subarray(0, len) : new Uint8Array(src.subarray(0, len)), context.signal);
 }
 function output(context, text) {
   context.signal.throwIfAborted();
   const stdout = context.stdout;
-  if (typeof text === "string" && !stdout.isPipeStage) {
-    const len = text.length;
-    if (len <= 64 && (typeof stdout.writeRangeSync === "function" || typeof stdout.writeSync === "function")) {
-      let ascii = true;
-      for (let i = 0; i < len; i++) {
-        const code = text.charCodeAt(i);
-        if (code >= 128) {
-          ascii = false;
-          break;
-        }
-        sharedSmallOutputBuf[i] = code;
-      }
-      if (ascii) {
-        const ok = typeof stdout.writeRangeSync === "function" ? stdout.writeRangeSync(sharedSmallOutputBuf, len) : stdout.writeSync(sharedSmallOutputViews[len]);
-        if (ok !== false) return resolvedVoid;
-      }
-    }
-  }
   const bytes = typeof text === "string" ? encoder.encode(text) : text;
+  if (typeof text === "string" && !stdout.isPipeStage && typeof stdout.writeRangeSync === "function" && stdout.writeRangeSync(bytes, bytes.length) !== false) {
+    return resolvedVoid;
+  }
   if (!stdout.isPipeStage && typeof stdout.writeSync === "function" && stdout.writeSync(bytes) !== false) {
     return resolvedVoid;
   }

package/dist/safe-bash/command-chunks/{chunk-PMBFZXTK.js → chunk-C5ZZKP7V.js}

@@ -2,7 +2,7 @@ import {
   createXlsxWriter,
   probeXlsx,
   readXlsx
-} from "./chunk-DZCY63VJ.js";
+} from "./chunk-EV6HIJ5H.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-LHIOAFWW.js → chunk-C7SEB6WU.js}

@@ -2,7 +2,7 @@ import {
   aliasFailure,
   copyAlias,
   yqCaps
-} from "./chunk-EMPU65ZK.js";
+} from "./chunk-A5LBSJGH.js";
 import {
   YqError,
   limit

package/dist/safe-bash/command-chunks/{chunk-XPT2UGBF.js → chunk-CHJKFRT7.js}

@@ -1,6 +1,6 @@
 import {
   builtInDirectContextExecutors
-} from "./chunk-TZZ4WUKH.js";
+} from "./chunk-FZAWGKSE.js";
 import {
   concatShellValues,
   shellValueBytes,

package/dist/safe-bash/command-chunks/{chunk-TIOCQVUQ.js → chunk-CON26Q2O.js}

@@ -1,6 +1,6 @@
 import {
   Exclusions
-} from "./chunk-5TBUOBDE.js";
+} from "./chunk-RZMVRT26.js";
 import {
   Reader
 } from "./chunk-BNOU5YQS.js";

package/dist/safe-bash/command-chunks/{chunk-E55UKBIE.js → chunk-DBAT3IK2.js}

@@ -1,7 +1,7 @@
 import {
   Bytes,
   XanError
-} from "./chunk-QOKBZFFD.js";
+} from "./chunk-U3MMODA5.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-Z45N42QC.js → chunk-DPAYAVMS.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-HEYKESED.js";
 import {
   XanError
-} from "./chunk-QOKBZFFD.js";
+} from "./chunk-U3MMODA5.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -51,6 +51,8 @@ function inferDelimiter(path) {
 var shortOptions = { B: "byte-offset", S: "start-condition", E: "end-condition", H: "human-readable", c: "check-alignment", a: "approx", p: "parallel", t: "threads", h: "help", o: "output", d: "delimiter", n: "no-headers", j: "just-names", s: "start", e: "end", l: "len", i: "index", I: "indices", L: "last" };
 var switches = /* @__PURE__ */ new Set(["help", "no-headers", "just-names", "csv", "human-readable", "check-alignment", "approx", "parallel", "raw", "evaluate", "evaluate-file"]);
 var extraShort = {
+  top: { l: "limit", R: "reverse" },
+  table: { s: "select" },
   dedup: { s: "select", l: "keep-last", S: "sorted" },
   enum: { c: "column-name", S: "start" },
   from: { f: "format" },
@@ -69,6 +71,9 @@ var extraShort = {
 for (const name of ["keep-last", "sorted", "keep-duplicates", "pad", "sort-keys", "single-object", "omit", "numeric", "reverse", "uniq", "exact", "ignore-case", "invert-match", "every-column", "all", "no-extra", "inner", "left", "right", "full", "semi", "anti", "cross", "nulls"]) switches.add(name);
 var common = ["help", "output", "delimiter"];
 var allowed = {
+  map: /* @__PURE__ */ new Set([...common, "no-headers"]),
+  top: /* @__PURE__ */ new Set([...common, "no-headers", "limit", "reverse"]),
+  table: /* @__PURE__ */ new Set([...common, "no-headers", "select"]),
   dedup: /* @__PURE__ */ new Set([...common, "no-headers", "select", "keep-last", "sorted", "keep-duplicates"]),
   enum: /* @__PURE__ */ new Set([...common, "no-headers", "column-name", "start"]),
   transpose: new Set(common),
@@ -163,12 +168,21 @@ async function parseArguments(args, cwd, budget) {
   if (values.has("evaluate") && values.has("evaluate-file")) throw new XanError("conflicting expression modes");
   let rightSelection;
   let operand;
+  if (command === "map") {
+    operand = operands.shift();
+    rightSelection = operands.shift();
+    if ((!operand || !rightSelection) && !help) throw new XanError("map requires an expression and a new column name");
+  }
   if (command === "groupby") rightSelection = operands.shift();
   if (["search", "filter", "rename", "agg", "groupby", "to", "cat"].includes(command)) {
     operand = operands.shift();
     if (operand === void 0 && !help) throw new XanError(`${command} requires an argument`);
   }
   let selection = command === "select" || command === "drop" ? operands.shift() : values.get("select") ?? "";
+  if (command === "top") {
+    selection = operands.shift();
+    if (!selection && !help) throw new XanError("top requires a column selection");
+  }
   if (command === "join" && !help) {
     const modes = ["inner", "left", "right", "full", "semi", "anti", "cross"].filter((name) => values.has(name));
     if (modes.length > 1) throw new XanError("conflicting join modes");

package/dist/safe-bash/command-chunks/chunk-DS3NXVUM.js

@@ -0,0 +1,368 @@
+import {
+  createClient,
+  grammarRevision,
+  imageMagickGrammarRevision,
+  imageMagickReference,
+  mediaCommands,
+  mediaFrontendContract,
+  nativeReference,
+  validateCallbackResult
+} from "./chunk-TT4DAFBT.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-media/src/remote.ts
+init_buffer();
+import { readBytes } from "@poe-platform/safe-fs/core";
+function createRemoteMediaCommands(options) {
+  if (!options.service || !options.authToken || !options.buildDigest || !options.resource) throw new TypeError("Explicit media service/auth/build/resource configuration required");
+  options = {
+    ...options,
+    resource: structuredClone(options.resource),
+    ...options.provider ? { provider: structuredClone(options.provider) } : {},
+    ...options.limits ? { limits: structuredClone(options.limits) } : {},
+    ...options.grants ? { grants: structuredClone(options.grants) } : {},
+    ...options.descriptors ? { descriptors: structuredClone(options.descriptors) } : {},
+    ...options.stdin ? { stdin: structuredClone(options.stdin) } : {}
+  };
+  const resource = structuredClone(options.resource);
+  let provider;
+  const transport = async (input, init) => {
+    if (!options.provider) return (options.fetch ?? globalThis.fetch)(input, init);
+    provider ??= import(options.provider.module).then(async (module) => {
+      if (typeof module.createMediaProvider !== "function") throw new TypeError("Media provider must export createMediaProvider(settings)");
+      const { provider: configuration, ...settings } = options;
+      const runtime = await module.createMediaProvider({ ...settings, providerOptions: configuration.options });
+      if (!runtime || typeof runtime.fetch !== "function" || runtime.execute !== void 0 && typeof runtime.execute !== "function") throw new TypeError("Media provider must return a Fetch transport and optional remote engine");
+      return runtime;
+    });
+    return (await provider).fetch(input, init);
+  };
+  async function run(invocation) {
+    const client = createClient({
+      baseUrl: options.service,
+      token: async () => options.authToken,
+      fetch: transport,
+      maxConcurrentUploads: 3
+    });
+    const context = invocation.context;
+    const controller = new AbortController();
+    const signal = AbortSignal.any([context.signal, controller.signal]);
+    const inputController = new AbortController();
+    const inputSignal = AbortSignal.any([signal, inputController.signal]);
+    let session;
+    let job;
+    let cleanup;
+    let acquisition;
+    let processExited = false;
+    let primaryFailed = false;
+    let finalization;
+    let unsubscribe;
+    let cleanupAdmission = true;
+    const ownedCleanups = [];
+    const leases = /* @__PURE__ */ new Map();
+    const work = /* @__PURE__ */ new Set();
+    const close = () => cleanup ??= (async () => {
+      cleanupAdmission = false;
+      controller.abort(new Error("Media invocation finalized"));
+      await acquisition?.catch(() => {
+      });
+      const retirement = Promise.resolve().then(() => unsubscribe?.());
+      const retired = Promise.allSettled(ownedCleanups.map((close2) => Promise.resolve().then(close2)));
+      const results = await Promise.allSettled([...work, retirement]);
+      const failures = (await retired).filter((result) => result.status === "rejected").map((result) => result.reason);
+      if (job && session) {
+        try {
+          const canceled = await client.cancelJob(session, job.jobId, { reason: "Media invocation finalized" }, crypto.randomUUID());
+          if (canceled.outcome?.kind === "unknown" || canceled.cleanup === "unknown") throw new Error("Remote termination could not be confirmed");
+        } catch (cause) {
+          failures.push(cause);
+        }
+      }
+      const releases = await Promise.allSettled([
+        ...Array.from(leases.values(), (lease) => Promise.resolve().then(() => lease.close())),
+        ...session ? [client.closeSession(session, crypto.randomUUID())] : [],
+        retirement
+      ]);
+      for (const result of releases) if (result.status === "rejected") failures.push(result.reason);
+      if (failures.length === 1) throw failures[0];
+      if (failures.length) throw new AggregateError(failures, "Media invocation cleanup failed");
+      void results;
+    })();
+    const finalize = () => finalization ??= (async () => {
+      try {
+        await close();
+      } catch (cause) {
+        if (!primaryFailed) throw cause;
+        try {
+          await context.onInternalError?.(cause);
+        } catch {
+        }
+      }
+    })();
+    context.registerCleanup?.(finalize);
+    try {
+      const capabilities = await client.capabilities(signal);
+      const build = capabilities.builds.find((build2) => build2.digest === options.buildDigest);
+      if (!build || build.grammarRevision !== mediaFrontendContract.grammarRevision || build.sourceRevision !== mediaFrontendContract.sourceRevision || !Object.hasOwn(build.executables, invocation.tool)) throw new Error("Remote build does not match the pinned media frontend");
+      const byteArgv = capabilities.features.includes("byte-argv");
+      if (!byteArgv && !capabilities.features.includes("utf8-argv")) throw new Error("Remote media requires byte argv or lossless UTF-8 argv capabilities");
+      const limits = options.limits ?? capabilities.limits;
+      if (!Number.isSafeInteger(limits.maxArgvBytes) || limits.maxArgvBytes < 1) throw new TypeError("Invalid remote argv byte bound");
+      let argvBytes = 0;
+      for (const arg of invocation.argv) {
+        argvBytes += arg.length + 1;
+        if (argvBytes > limits.maxArgvBytes) throw new TypeError("Remote argv byte bound");
+      }
+      for (const arg of invocation.argv) {
+        if (arg.includes(0)) throw new TypeError("NUL in native argv");
+        if (!byteArgv) {
+          try {
+            new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(arg);
+          } catch {
+            throw new TypeError("Remote UTF-8 launcher cannot preserve these argv bytes");
+          }
+        }
+      }
+      if (!capabilities.features.includes("live-files") || resource.profile !== "live") throw new Error("Remote media requires admitted live resource capabilities");
+      const backend = await provider;
+      if (backend?.execute) {
+        const execution = Promise.resolve().then(() => {
+          signal.throwIfAborted();
+          return backend.execute({
+            ...context,
+            command: invocation.tool,
+            args: invocation.argv,
+            discovery: invocation.discovery,
+            signal,
+            registerCleanup(close2) {
+              if (!cleanupAdmission) throw new Error("Media invocation cleanup admission closed");
+              if (typeof close2 !== "function") throw new TypeError("Invalid media invocation cleanup");
+              ownedCleanups.push(close2);
+            }
+          });
+        });
+        work.add(execution);
+        return await execution;
+      }
+      const input = context.stdinInput;
+      if ((input?.seek || input?.stat?.type === "file") && !options.stdin?.seekable) throw new Error("Explicit remote descriptor bindings required for seekable native stdin");
+      const sinks = /* @__PURE__ */ new Map([[2, context.stdout], [3, context.stderr]]);
+      const descriptors = options.descriptors ?? [];
+      if (descriptors.length > limits.maxHandles || new Set(descriptors.map((descriptor) => descriptor.fd)).size !== descriptors.length || descriptors.some((descriptor) => !Number.isSafeInteger(descriptor.fd) || descriptor.fd < 3 || descriptor.fd > limits.maxHandles + 2)) throw new TypeError("Remote descriptor count or mapping exceeds admission");
+      const streamedDescriptors = (options.descriptors ?? []).filter((descriptor) => !descriptor.seekable && descriptor.rights.some((right) => right === "read" || right === "write"));
+      if (streamedDescriptors.length && (!capabilities.features.includes("descriptors") || !context.admittedHandles)) throw new Error("Remote descriptors require admitted host leases and server capabilities");
+      for (const descriptor of streamedDescriptors) {
+        const rights = descriptor.rights.filter((right) => right === "read" || right === "write");
+        const acquiring = context.admittedHandles.acquire(descriptor.fd, rights, signal).then((lease2) => {
+          leases.set(descriptor.fd, lease2);
+          return lease2;
+        });
+        work.add(acquiring);
+        const lease = await acquiring;
+        if (rights.includes("read") && !lease.read || rights.includes("write") && !lease.write) throw new TypeError("Host descriptor lease lacks requested operations");
+        if (rights.includes("write")) sinks.set(descriptor.fd + 1, { async write(bytes) {
+          let offset = 0;
+          while (offset < bytes.length) {
+            signal.throwIfAborted();
+            lease.consumerClosed?.throwIfAborted();
+            const remaining = Math.min(bytes.length - offset, 65536);
+            const count = await lease.write(bytes.subarray(offset, offset + remaining), signal);
+            if (!Number.isSafeInteger(count) || count < 1 || count > remaining) throw new TypeError("Invalid admitted descriptor write count");
+            offset += count;
+          }
+        } });
+      }
+      acquisition = client.openSession({ buildDigest: build.digest, bindings: [resource], limits }, crypto.randomUUID(), signal).then((value) => {
+        session = value;
+      });
+      await acquisition;
+      acquisition = client.submitJob(session, {
+        buildDigest: build.digest,
+        toolId: invocation.tool,
+        args: invocation.argv.map((arg) => Array.from(arg)),
+        namespaceId: resource.namespaceId,
+        materializationRevision: null,
+        cwd: context.cwd,
+        env: { ...context.env },
+        stdin: options.stdin ?? { kind: "stream", seekable: false },
+        descriptors: [...options.descriptors ?? []],
+        grants: [...options.grants ?? []],
+        freshness: "live",
+        limits,
+        frontendContract: mediaFrontendContract
+      }, crypto.randomUUID(), signal).then((value) => {
+        job = value;
+      });
+      await acquisition;
+      const identity = session;
+      const nativeJob = job;
+      unsubscribe = context.processSignals?.subscribe(async (event) => {
+        signal.throwIfAborted();
+        if (event.target !== "process-group") throw new TypeError("Remote signals require process-group authority");
+        const operation = client.signalJob(identity, nativeJob.jobId, event.name, `signal:${nativeJob.jobId}:${event.sequence}`, signal);
+        work.add(operation);
+        try {
+          await operation;
+          return { sequence: event.sequence };
+        } finally {
+          work.delete(operation);
+        }
+      });
+      const output = await client.attach(identity, nativeJob.jobId, { direction: "output", consumerId: crypto.randomUUID() }, crypto.randomUUID(), signal);
+      const binaryLimits = { maxFrameBytes: output.maxFrameBytes, maxControlBytes: output.maxFrameBytes, channels: [...sinks.keys()], maxChannels: limits.maxHandles + 2 };
+      const cursor = { ...identity, jobId: nativeJob.jobId, laneId: output.laneId, nextSequence: BigInt(output.floorSequence), offsets: new Map([...sinks.keys()].map((channel) => [channel, 0n])), endedChannels: /* @__PURE__ */ new Set() };
+      const download = client.resumeStream(cursor, binaryLimits, async (frame) => {
+        if (frame.kind === "data") {
+          const sink = sinks.get(frame.channelId);
+          if (!sink) throw new Error("Remote channel requires an explicit host control binding");
+          signal.throwIfAborted();
+          sink.ownedOutput?.consumerClosed.throwIfAborted();
+          await (sink.ownedOutput ?? sink).write(frame.payload);
+          await options.onProgress?.({ direction: "download", bytes: frame.payload.length });
+        } else if (frame.kind === "control") {
+          const control = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(frame.payload));
+          if (control.type === "ChannelOpen" && control.direction === "write") {
+            if (control.seekable || !options.onOutputChannel) throw new Error("Remote output channel requires an explicit host stream binding");
+            const sink = await options.onOutputChannel(control, context);
+            if (!sink || typeof sink.write !== "function") throw new TypeError("Remote output channel requires a writable host sink");
+            sinks.set(control.channelId, sink);
+          } else if (control.type === "Callback" || control.type === "CanonicalCallback" || control.type === "ChannelOpen") {
+            if (!options.onControl) throw new Error("Remote resource callback requires an explicit host control binding");
+            const callback = structuredClone(control);
+            const remote = { signal, async respond(result) {
+              signal.throwIfAborted();
+              if (callback.type !== "Callback" || callback.epoch !== identity.epoch || callback.namespaceId !== resource.namespaceId || callback.owner.kind !== "job" || callback.owner.id !== nativeJob.jobId || Date.parse(callback.expiresAt) <= Date.now() || !options.grants?.some((grant) => grant.grantId === callback.grantId && grant.operations.includes(callback.operation.op))) throw new Error("Unauthorized remote callback response");
+              const owned = structuredClone(result);
+              if (owned.callbackId !== callback.callbackId || owned.operationId !== callback.operationId)
+                throw new Error("Remote callback response belongs to another operation");
+              validateCallbackResult(callback.operation, owned);
+              const response = client.answerCallback(identity, nativeJob.jobId, owned, crypto.randomUUID(), signal);
+              work.add(response);
+              try {
+                const receipt = await response;
+                if (receipt.callbackId !== callback.callbackId || receipt.operationId !== callback.operationId)
+                  throw new Error("Remote callback acknowledgement belongs to another operation");
+                return receipt;
+              } finally {
+                work.delete(response);
+              }
+            } };
+            await options.onControl(control, context, remote);
+          } else if (control.type === "Failure") throw new Error(control.error.message);
+          else if (control.type === "JobState" && (control.job.processOutcome || control.job.state === "terminal")) {
+            processExited = true;
+            inputController.abort(new Error("Native process exited"));
+          }
+        }
+      }, signal);
+      work.add(download);
+      void download.catch(() => controller.abort(new Error("Remote output failed")));
+      const upload = (async () => {
+        let receiptFailed = false;
+        let inputFailure;
+        try {
+          let send2 = function(channelId, kind, payload) {
+            const operation = tail.then(async () => {
+              inputSignal.throwIfAborted();
+              const offset = offsets.get(channelId);
+              try {
+                await client.sendFrames(identity, nativeJob.jobId, input2.laneId, [{ kind, channelId, sequence, offset, correlationId: 0n, payload }], { maxFrameBytes: input2.maxFrameBytes, maxControlBytes: input2.maxFrameBytes, channels }, crypto.randomUUID(), signal);
+              } catch (cause) {
+                receiptFailed = true;
+                throw cause;
+              }
+              sequence++;
+              offsets.set(channelId, offset + BigInt(payload.length));
+            });
+            tail = operation;
+            return operation;
+          };
+          var send = send2;
+          const reads = streamedDescriptors.filter((descriptor) => descriptor.rights.includes("read"));
+          const streamStdin = !options.stdin || options.stdin.kind === "stream";
+          if (!streamStdin && !reads.length) return;
+          const input2 = await client.attach(identity, nativeJob.jobId, { direction: "input", consumerId: crypto.randomUUID() }, crypto.randomUUID(), inputSignal);
+          const channels = [...streamStdin ? [1] : [], ...reads.map((descriptor) => descriptor.fd + 1)];
+          const offsets = new Map(channels.map((channel) => [channel, 0n]));
+          let sequence = BigInt(input2.nextSequence);
+          let tail = Promise.resolve();
+          const byteLength = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "byteLength").get;
+          async function* readInput(read, description) {
+            for (; ; ) {
+              const count = Math.min(input2.maxFrameBytes, 65536);
+              const next = await read(count, inputSignal);
+              if (!next || typeof next !== "object" || Array.isArray(next)) throw new TypeError("Invalid process input read result");
+              const done = next.done;
+              if (done === true) return;
+              if (done !== false && done !== void 0) throw new TypeError("Invalid process input read result");
+              const fragment = next.value;
+              if (!(fragment instanceof Uint8Array) || byteLength.call(fragment) > count) throw new TypeError(`Invalid ${description} read size`);
+              yield fragment;
+            }
+          }
+          const stdinRead = context.stdinInput?.read.bind(context.stdinInput);
+          const stdin = stdinRead ? { [Symbol.asyncIterator]: () => readInput(stdinRead, "stdinInput") } : context.stdin;
+          const sources = streamStdin ? [[1, readBytes(stdin, inputSignal)]] : [];
+          for (const descriptor of reads) {
+            const lease = leases.get(descriptor.fd);
+            const read = lease.read.bind(lease);
+            sources.push([descriptor.fd + 1, readBytes({ [Symbol.asyncIterator]: () => readInput(read, "admitted descriptor") }, inputSignal)]);
+          }
+          const producers = sources.map(async ([channel, source]) => {
+            for await (const incoming of source) {
+              for (let start = 0; start < incoming.length; start += input2.maxFrameBytes) {
+                const bytes = Uint8Array.from(incoming.subarray(start, start + input2.maxFrameBytes));
+                await send2(channel, "data", bytes);
+                await options.onProgress?.({ direction: "upload", bytes: bytes.length });
+              }
+            }
+            await send2(channel, "end", new Uint8Array());
+          });
+          for (const producer of producers) void producer.catch((cause) => {
+            if (!(processExited && !receiptFailed && inputSignal.aborted && cause === inputSignal.reason)) inputFailure ??= { cause };
+            inputController.abort(new Error("Remote descriptor input failed"));
+          });
+          const results = await Promise.allSettled(producers);
+          if (inputFailure) throw inputFailure.cause;
+          const failure = results.find((result) => result.status === "rejected");
+          if (failure?.status === "rejected") throw failure.reason;
+        } catch (cause) {
+          if (!receiptFailed && processExited && !signal.aborted && cause === inputSignal.reason) return;
+          throw cause;
+        }
+      })();
+      work.add(upload);
+      void upload.catch(() => controller.abort(new Error("Remote input failed")));
+      await Promise.all([download, upload]);
+      const settled = await client.waitJob(identity, nativeJob.jobId, signal);
+      if (!settled.outputComplete || settled.cleanup !== "complete") throw new Error("Remote media cleanup or output is incomplete");
+      if (settled.outcome?.kind === "exited") return { exitCode: settled.outcome.exitCode };
+      if (settled.outcome?.kind === "signaled" && options.signalStatus) {
+        const exitCode = options.signalStatus(settled.outcome.signal, settled.outcome.signalNumber);
+        if (!Number.isInteger(exitCode) || exitCode < 0 || exitCode > 255) throw new TypeError("Invalid shell signal status");
+        return { exitCode };
+      }
+      throw new Error(`Remote media outcome: ${settled.outcome?.kind ?? "unknown"}`);
+    } catch (cause) {
+      primaryFailed = true;
+      throw cause;
+    } finally {
+      await finalize();
+    }
+  }
+  const plugin = mediaCommands({
+    ...options.replace !== void 0 ? { replace: options.replace } : {},
+    ffmpeg: { build: nativeReference.id, grammarRevision, argv: "bytes", lateAccess: "complete", effects: "live", run },
+    imageMagick: { build: imageMagickReference.id, grammarRevision: imageMagickGrammarRevision, argv: "bytes", lateAccess: "complete", effects: "live", run }
+  });
+  return { ...plugin, async dispose() {
+    const runtime = await provider?.catch(() => void 0);
+    await runtime?.dispose?.();
+  } };
+}
+
+export {
+  createRemoteMediaCommands
+};

package/dist/safe-bash/command-chunks/{chunk-5ZMZ573Q.js → chunk-DSJ3VRL3.js}

@@ -15,6 +15,8 @@ var FindFormatBudget = class {
   }
   context;
   untilYield = 4096;
+  pending = new Uint8Array(4096);
+  used = 0;
   step(count = 1) {
     this.context.signal.throwIfAborted();
     this.untilYield -= count;
@@ -22,14 +24,23 @@ var FindFormatBudget = class {
     this.untilYield = 4096;
     return yieldTurn(this.context.signal);
   }
+  async flush() {
+    if (this.used === 0) return;
+    const chunk = this.pending.slice(0, this.used);
+    this.used = 0;
+    await output(this.context, chunk);
+  }
   async write(bytes) {
-    for (let offset = 0; offset < bytes.length; offset += 4096) {
-      const chunk = bytes.subarray(offset, offset + 4096);
+    for (let offset = 0; offset < bytes.length; ) {
+      const length = Math.min(bytes.length - offset, this.pending.length - this.used);
       {
-        const s = this.step(chunk.length);
+        const s = this.step(length);
         if (s) await s;
       }
-      await output(this.context, chunk);
+      this.pending.set(bytes.subarray(offset, offset + length), this.used);
+      this.used += length;
+      offset += length;
+      if (this.used === this.pending.length) await this.flush();
     }
   }
   async text(text) {
@@ -131,6 +142,7 @@ async function compileFindFormat(value, budget) {
       else if ("byte" in part) await budget.write(Uint8Array.of(part.byte));
       else await budget.write(source.subarray(part.start, part.end));
     }
+    await budget.flush();
   };
 }
 

package/dist/safe-bash/command-chunks/{chunk-K2GDEMEU.js → chunk-EFRCFWVR.js}

@@ -1,14 +1,14 @@
 import {
   streamElevenLabs
 } from "./chunk-LPZXFCTC.js";
+import {
+  acceptsMimeType
+} from "./chunk-PHFOL7T3.js";
 import {
   credential,
   jsonBody,
   providerLimits
-} from "./chunk-2KG2QLJE.js";
-import {
-  acceptsMimeType
-} from "./chunk-PHFOL7T3.js";
+} from "./chunk-RFWGYT7G.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-DZCY63VJ.js → chunk-EV6HIJ5H.js}

@@ -3644,8 +3644,9 @@ async function readXlsx(bytes, context) {
       if (importedName.startsWith("_xlnm.") && name === "Print_Area" && node.text === "!#REF!") continue;
       const sheetIndex = attr(node, "localSheetId"), sheet = sheetIndex === void 0 ? void 0 : sheets[integer(sheetIndex)];
       const position = { sheet: sheet?.id ?? sheets[0]?.id ?? "sheet-1", row: 0, column: 0 };
-      if (node.text && !parseExpression("=" + node.text, { maximumDepth: context.limits.formulaDepth, grammar: excelGrammar, position, signal: context.signal }).ok) {
-        const message = `At A1: '${node.text}' Invalid expression
+      const expression = decodeXlsxString(node.text);
+      if (expression && !parseExpression("=" + expression, { maximumDepth: context.limits.formulaDepth, grammar: excelGrammar, position, signal: context.signal }).ok) {
+        const message = `At A1: '${expression}' Invalid expression
 `;
         await context.diagnostic?.({
           code: "xlsx-name-expression",
@@ -3657,7 +3658,7 @@ async function readXlsx(bytes, context) {
       }
       const semantics = readFormulaSemantics(node);
       const openFormula = readOpenFormula(node);
-      const imported = { name, ...openFormula?.position ? { position: { ...openFormula.position, sheet: sheets.find((s) => s.name === openFormula.position.sheet)?.id ?? openFormula.position.sheet } } : {}, expression: openFormula?.source ?? (node.text ? formula(node.text, position.sheet, 0, 0, context, semantics.arrayStringLiterals) : "=#REF!"), ...semantics, ...sheet ? { sheet: sheet.id } : {} };
+      const imported = { name, ...openFormula?.position ? { position: { ...openFormula.position, sheet: sheets.find((s) => s.name === openFormula.position.sheet)?.id ?? openFormula.position.sheet } } : {}, expression: openFormula?.source ?? (expression ? formula(expression, position.sheet, 0, 0, context, semantics.arrayStringLiterals) : "=#REF!"), ...semantics, ...sheet ? { sheet: sheet.id } : {} };
       opc.charge(names.length);
       const existing = names.findIndex((n) => n.name === name && n.sheet === sheet?.id);
       if (existing < 0) names.push(imported);
@@ -4034,13 +4035,13 @@ function createXlsxWriter(edition) {
           localSheetId: index < 0 ? void 0 : index,
           ...formulaSemanticsAttributes(name.arrayStringLiterals, true, name.expression, name.position ? { ...name.position, sheet: book.sheets.find((s) => s.id === name.position.sheet)?.name ?? name.position.sheet } : void 0)
         },
-        escapeXlsx(exportXlsxFormula(book, name.expression, sheet, name.position?.row ?? 0, name.position?.column ?? 0, context, name.arrayStringLiterals))
+        escapeXlsx(encodeXlsxString(exportXlsxFormula(book, name.expression, sheet, name.position?.row ?? 0, name.position?.column ?? 0, context, name.arrayStringLiterals)))
       );
     }
     for (const [index, sheet] of book.sheets.entries()) {
       for (const [name, expression] of [["Sheet_Title", '"' + sheet.name.split('"').join('""') + '"'], ["Print_Area", "#REF!"]])
         if (!book.names?.some((n) => n.name === name && n.sheet === sheet.id))
-          names += xml("definedName", { name: "_xlnm." + name, localSheetId: index }, escapeXlsx(expression));
+          names += xml("definedName", { name: "_xlnm." + name, localSheetId: index }, escapeXlsx(encodeXlsxString(expression)));
     }
     await add("xl/workbook.xml", xml(
       "workbook",

package/dist/safe-bash/command-chunks/{chunk-JDYXY44P.js → chunk-FJURV46Y.js}

@@ -1,13 +1,13 @@
 import {
   inferDelimiter
-} from "./chunk-Z45N42QC.js";
+} from "./chunk-DPAYAVMS.js";
 import {
   Scanner
-} from "./chunk-E55UKBIE.js";
+} from "./chunk-DBAT3IK2.js";
 import {
   Bytes,
   XanError
-} from "./chunk-QOKBZFFD.js";
+} from "./chunk-U3MMODA5.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";