@poe-platform/safe-bash 0.1.757 → 0.1.758

package/dist/safe-bash-command-ssconvert/commands.js

@@ -0,0 +1,871 @@
+import {
+  FileWriteError,
+  compareServiceIds,
+  createEngine,
+  createResourceIO,
+  defaultSsconvertLimits,
+  imageFormats,
+  ioFailure
+} from "../safe-bash/command-chunks/chunk-J2NPH7DO.js";
+import {
+  resourceUri
+} from "../safe-bash/command-chunks/chunk-CE6Z2ULX.js";
+import "../safe-bash/command-chunks/chunk-OZSWW23M.js";
+import "../safe-bash/command-chunks/chunk-444OTXM7.js";
+import "../safe-bash/command-chunks/chunk-TT2DMDBY.js";
+import {
+  snapshotRuntimeFunctions
+} from "../safe-bash/command-chunks/chunk-WKPOGTZY.js";
+import "../safe-bash/command-chunks/chunk-MED2BOOW.js";
+import {
+  SsconvertError,
+  isSsconvertError
+} from "../safe-bash/command-chunks/chunk-FDNCPZQS.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-ssconvert/dist/commands.js
+init_buffer();
+
+// packages/safe-bash-command-ssconvert/dist/command-bindings.js
+init_buffer();
+
+// packages/safe-bash-command-ssconvert/dist/formulas/runtime-functions.js
+init_buffer();
+
+// packages/safe-bash-command-ssconvert/dist/codecs/format-provider.js
+init_buffer();
+
+// packages/spreadsheet-engine/src/codecs/format-provider.ts
+init_buffer();
+function snapshotFormats(formats) {
+  return Object.freeze(formats.map((provider) => Object.freeze({
+    ...provider,
+    services: Object.freeze(provider.services.map((service) => Object.freeze({
+      ...service,
+      extensions: Object.freeze([...service.extensions]),
+      ...service.filenameSuffixes === void 0 ? {} : { filenameSuffixes: Object.freeze([...service.filenameSuffixes]) },
+      ...service.mimeTypes === void 0 ? {} : { mimeTypes: Object.freeze([...service.mimeTypes]) },
+      ...service.exporterOptionKeys === void 0 ? {} : { exporterOptionKeys: Object.freeze([...service.exporterOptionKeys]) },
+      ...service.exportOptionRules === void 0 ? {} : { exportOptionRules: Object.freeze(Object.fromEntries(
+        Object.entries(service.exportOptionRules).map(([key, rule]) => [key, Object.freeze({
+          ...rule,
+          ...rule.kind === "enum" ? { values: Object.freeze([...rule.values]) } : {}
+        })])
+      )) }
+    })))
+  })));
+}
+
+// packages/safe-bash-command-ssconvert/dist/io/index.js
+init_buffer();
+
+// packages/safe-bash-command-ssconvert/dist/io/publication.js
+init_buffer();
+
+// packages/spreadsheet-engine/src/io/publication.ts
+init_buffer();
+function createVfsOutput(fs, writeBytes, retainCleanup) {
+  let serial = 0;
+  return async (filename, context) => {
+    const signal = context.signal;
+    const options = { signal };
+    const uri = resourceUri(filename, context.environment.cwd ?? context.environment.env.PWD ?? "/");
+    let path = filename;
+    let temporary;
+    let finalized = false;
+    let aborting;
+    let closed = false;
+    let releaseAcquisition;
+    const acquiring = new Promise((resolve) => {
+      releaseAcquisition = resolve;
+    });
+    const check = () => {
+      signal.throwIfAborted();
+      if (closed) throw new SsconvertError("invalid-request", "ssconvert file output is closed");
+    };
+    const abort = (remove = (path2) => fs.unlink(path2)) => {
+      closed = true;
+      return aborting ??= (async () => {
+        await acquiring;
+        if (finalized || temporary === void 0) return;
+        const path2 = temporary;
+        temporary = void 0;
+        await remove(path2);
+      })();
+    };
+    try {
+      context.own(retainCleanup ? retainCleanup(abort) : abort);
+      check();
+      let mode = 438 & ~(context.environment.umask ?? 18);
+      const visited = /* @__PURE__ */ new Set();
+      for (let links = 0; ; links++) {
+        check();
+        if (links > (context.limits.outputSymlinks ?? Infinity)) throw new SsconvertError("resource-limit", "ssconvert output symlink limit exceeded");
+        let stat;
+        try {
+          stat = await fs.lstat(path, options);
+        } catch (error) {
+          signal.throwIfAborted();
+          if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") break;
+          ioFailure(error, uri, "write", path);
+        }
+        check();
+        if (stat.type === "symlink") {
+          const identity = resourceUri(path, context.environment.cwd ?? context.environment.env.PWD ?? "/");
+          if (visited.has(identity)) throw new FileWriteError(uri, `${path}: Symlink cycle`);
+          visited.add(identity);
+          if (!fs.readlink) throw new SsconvertError("capability-denied", "Filesystem readlink capability is required for output aliases");
+          const target = await fs.readlink(path, options);
+          check();
+          const dirname2 = path.slice(0, path.lastIndexOf("/") + 1);
+          path = target.startsWith("/") ? target : dirname2 + target;
+          continue;
+        }
+        if (stat.type !== "file") throw new FileWriteError(uri, `${path}: Is not a regular file`);
+        try {
+          await fs.access(path, 2, options);
+        } catch (error) {
+          signal.throwIfAborted();
+          ioFailure(error, uri, "write", path);
+        }
+        check();
+        mode = stat.mode & 4095;
+        break;
+      }
+      check();
+      const capabilities = await fs.capabilitiesFor?.(path, options) ?? fs.capabilities;
+      check();
+      if (!capabilities.exclusiveCreate || !capabilities.atomicRename || !capabilities.permissions || !fs.unlink || !fs.chmod)
+        throw new SsconvertError("capability-denied", "Filesystem exclusive creation, atomic rename, unlink and permissions capabilities are required for ssconvert file publication");
+      const dirname = path.slice(0, path.lastIndexOf("/") + 1);
+      const random = context.random?.next() ?? 0;
+      if (!Number.isFinite(random) || random < 0 || random >= 1) throw new SsconvertError("invalid-request", "Invalid ssconvert random value");
+      for (let attempt = 0; ; attempt++) {
+        check();
+        if (attempt >= Math.max(1, context.limits.operations)) throw new SsconvertError("resource-limit", "ssconvert temporary file collision limit exceeded");
+        const suffix = ((Math.floor(random * 2176782336) + serial++) % 2176782336).toString(36).toUpperCase().padStart(6, "0");
+        const candidate = `${dirname}.gsf-save-${suffix}`;
+        try {
+          await fs.writeFile(candidate, new Uint8Array(), { ...options, flag: "wx", mode: 384 });
+        } catch (error) {
+          signal.throwIfAborted();
+          if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") continue;
+          ioFailure(error, uri, "write", candidate);
+        }
+        temporary = candidate;
+        check();
+        break;
+      }
+      return {
+        abort,
+        async write(bytes) {
+          check();
+          if (finalized || !temporary) throw new SsconvertError("invalid-request", "ssconvert file output is closed");
+          try {
+            await writeBytes(temporary, bytes, signal);
+          } catch (error) {
+            signal.throwIfAborted();
+            await abort();
+            if (error && typeof error === "object" && "code" in error && error.code === "ENOSPC") {
+              await context.diagnostic?.({ code: "close-error", severity: "error", message: "  ==> Failed to close file: No space left on device" });
+              throw new SsconvertError("io", "E Failed to close file: No space left on device");
+            }
+            throw error;
+          }
+        },
+        async close() {
+          check();
+          if (finalized || !temporary) throw new SsconvertError("invalid-request", "ssconvert file output is closed");
+          finalized = true;
+          try {
+            await fs.rename(temporary, path, options);
+          } catch (error) {
+            signal.throwIfAborted();
+            if (error && typeof error === "object" && "code" in error && error.code === "EACCES") {
+              await context.diagnostic?.({ code: "publication-error", severity: "error", message: "  ==> Permission denied" });
+              throw new SsconvertError("io", "E Permission denied");
+            }
+            throw error;
+          }
+          temporary = void 0;
+          try {
+            await fs.chmod(path, mode, options);
+          } catch (error) {
+            signal.throwIfAborted();
+            if (error && typeof error === "object" && "code" in error && error.code === "EACCES") return;
+            throw error;
+          }
+        }
+      };
+    } finally {
+      releaseAcquisition();
+    }
+  };
+}
+
+// packages/safe-bash-command-ssconvert/dist/io/cwd.js
+init_buffer();
+
+// packages/spreadsheet-engine/src/io/cwd.ts
+init_buffer();
+function snapshotDirectory(value) {
+  const { type, identityScope, dev, ino, opaqueIdentity } = value;
+  return { type, identityScope, dev, ino, opaqueIdentity };
+}
+async function resolveVfsCwd(cwd, pwd, filesystem, signal) {
+  signal.throwIfAborted();
+  if (!cwd.startsWith("/") || cwd.includes("\0")) throw new TypeError("ssconvert cwd must be an absolute VFS path");
+  if (!pwd?.startsWith("/") || pwd.includes("\0") || pwd === cwd || !filesystem.stat) return cwd;
+  const stat = filesystem.stat.bind(filesystem);
+  try {
+    const actual = snapshotDirectory(await stat(cwd, { signal }));
+    signal.throwIfAborted();
+    if (actual.type !== "directory" || !(typeof actual.identityScope === "object" && actual.identityScope !== null || typeof actual.identityScope === "symbol")) return cwd;
+    const alias = snapshotDirectory(await stat(pwd, { signal }));
+    signal.throwIfAborted();
+    if (alias.type !== "directory" || actual.identityScope !== alias.identityScope) return cwd;
+    const numeric = (value) => Number.isSafeInteger(value.dev) && value.dev >= 0 && Number.isSafeInteger(value.ino) && value.ino >= 0;
+    if (numeric(actual) && numeric(alias)) return actual.dev === alias.dev && actual.ino === alias.ino ? pwd : cwd;
+    if (typeof actual.opaqueIdentity === "string" && actual.opaqueIdentity.length > 0 && actual.opaqueIdentity.length <= 4096 && actual.opaqueIdentity === alias.opaqueIdentity) return pwd;
+  } catch {
+    signal.throwIfAborted();
+  }
+  return cwd;
+}
+
+// packages/safe-bash-command-ssconvert/dist/cli.js
+init_buffer();
+
+// packages/safe-bash-command-ssconvert/dist/contracts.js
+init_buffer();
+
+// packages/safe-bash-command-ssconvert/dist/cli/parser.js
+init_buffer();
+
+// packages/safe-bash-command-ssconvert/dist/cli/reference.js
+init_buffer();
+var referenceText = Object.freeze({
+  "help": "Usage:\n  ssconvert [OPTION?] INFILE [OUTFILE]\n\nHelp Options:\n  -h, --help                         Show help options\n  --help-all                         Show all help options\n  --help-libspreadsheet              Show Gnumeric Options\n  --help-gtk                         Show GTK+ Options\n\nApplication Options:\n  --version                          Display program version\n  -v, --verbose                      Be somewhat more verbose during conversion\n  -E, --import-encoding=ENCODING     Optionally specify an encoding for imported content\n  -I, --import-type=ID               Optionally specify which importer to use\n  --list-importers                   List the available importers\n  -M, --merge-to=file                Merge listed files (all same format) to make this file\n  -T, --export-type=ID               Optionally specify which exporter to use\n  -O, --export-options=string        Detailed instructions for the chosen exporter\n  --list-exporters                   List the available exporters\n  -S, --export-file-per-sheet        Export a file for each sheet if the exporter only supports one sheet at a time\n  --export-graphs                    Export graphs\n  --list-image-formats               List the available image formats\n  --set                              Change the contents of a cell before writing --set A12=2\n  --recalc                           Recalculate all cells before writing the result\n  --display=DISPLAY                  X display to use\n\n",
+  "help-all": "Usage:\n  ssconvert [OPTION?] INFILE [OUTFILE]\n\nHelp Options:\n  -h, --help                         Show help options\n  --help-all                         Show all help options\n  --help-libspreadsheet              Show Gnumeric Options\n  --help-gtk                         Show GTK+ Options\n\nGnumeric Options\n  --libspreadsheet-version           Display Gnumeric's version\n  -L, --lib-dir=DIR                  Set the root library directory\n  -D, --data-dir=DIR                 Adjust the root data directory\n\nGTK+ Options\n  --class=CLASS                      Program class as used by the window manager\n  --name=NAME                        Program name as used by the window manager\n  --gtk-module=MODULES               Load additional GTK+ modules\n  --g-fatal-warnings                 Make all warnings fatal\n\nApplication Options:\n  --version                          Display program version\n  -v, --verbose                      Be somewhat more verbose during conversion\n  -E, --import-encoding=ENCODING     Optionally specify an encoding for imported content\n  -I, --import-type=ID               Optionally specify which importer to use\n  --list-importers                   List the available importers\n  -M, --merge-to=file                Merge listed files (all same format) to make this file\n  -T, --export-type=ID               Optionally specify which exporter to use\n  -O, --export-options=string        Detailed instructions for the chosen exporter\n  --list-exporters                   List the available exporters\n  -S, --export-file-per-sheet        Export a file for each sheet if the exporter only supports one sheet at a time\n  --export-graphs                    Export graphs\n  --list-image-formats               List the available image formats\n  --set                              Change the contents of a cell before writing --set A12=2\n  --recalc                           Recalculate all cells before writing the result\n  --display=DISPLAY                  X display to use\n\n",
+  "help-libspreadsheet": "Usage:\n  ssconvert [OPTION?] INFILE [OUTFILE]\n\nGnumeric Options\n  --libspreadsheet-version           Display Gnumeric's version\n  -L, --lib-dir=DIR                  Set the root library directory\n  -D, --data-dir=DIR                 Adjust the root data directory\n\n",
+  "help-gtk": "Usage:\n  ssconvert [OPTION?] INFILE [OUTFILE]\n\nGTK+ Options\n  --class=CLASS                      Program class as used by the window manager\n  --name=NAME                        Program name as used by the window manager\n  --display=DISPLAY                  X display to use\n  --gtk-module=MODULES               Load additional GTK+ modules\n  --g-fatal-warnings                 Make all warnings fatal\n\n",
+  "version": "ssconvert version '1.12.61'\ndatadir := '/opt/ssconvert-reference/share/gnumeric/1.12.61'\nlibdir := '/opt/ssconvert-reference/lib/gnumeric/1.12.61'\n",
+  "libspreadsheet-version": "gnumeric version '1.12.61'\ndatadir := '/opt/ssconvert-reference/share/gnumeric/1.12.61'\nlibdir := '/opt/ssconvert-reference/lib/gnumeric/1.12.61'\n"
+});
+
+// packages/safe-bash-command-ssconvert/dist/cli/parser.js
+var scalarNames = {
+  L: "lib-dir",
+  D: "data-dir",
+  "lib-dir": "lib-dir",
+  "data-dir": "data-dir",
+  display: "display",
+  class: "class",
+  name: "name",
+  "gtk-module": "gtk-module",
+  E: "import-encoding",
+  I: "import-type",
+  M: "merge-to",
+  T: "export-type",
+  O: "export-options",
+  "import-encoding": "import-encoding",
+  "import-type": "import-type",
+  "merge-to": "merge-to",
+  "export-type": "export-type",
+  "export-options": "export-options",
+  resize: "resize",
+  clipboard: "clipboard",
+  "export-range": "export-range"
+};
+var flagNames = {
+  "g-fatal-warnings": "g-fatal-warnings",
+  v: "verbose",
+  S: "export-file-per-sheet",
+  verbose: "verbose",
+  "export-file-per-sheet": "export-file-per-sheet",
+  "list-importers": "list-importers",
+  "list-exporters": "list-exporters",
+  "list-image-formats": "list-image-formats",
+  "export-graphs": "export-graphs",
+  recalc: "recalc",
+  solve: "solve",
+  version: "version"
+};
+var inheritedGroups = [
+  { name: "libspreadsheet", entries: {
+    version: "library-version",
+    "lib-dir": "lib-dir",
+    "data-dir": "data-dir"
+  } },
+  { name: "gtk", entries: {
+    display: "display",
+    class: "class",
+    name: "name",
+    "gtk-module": "gtk-module",
+    "g-fatal-warnings": "g-fatal-warnings"
+  } }
+];
+var arrayNames = /* @__PURE__ */ new Set(["set", "goal-seek", "tool-test"]);
+var terminal = (stderr, exitCode = 1, stdout = "") => ({
+  kind: "terminal",
+  exitCode,
+  stdout,
+  stderr
+});
+var parserError = (message) => terminal(`${message}
+Run 'ssconvert --help' to see a full list of available command line options.
+`);
+function parseCommand(supplied, profile) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf8", { ignoreBOM: true });
+  const byteMode = supplied.some((argument) => typeof argument !== "string");
+  const bytes = supplied.map((argument) => typeof argument === "string" ? encoder.encode(argument) : new Uint8Array(argument));
+  const argv = bytes.map((argument) => Array.from(argument, (byte) => String.fromCharCode(byte)).join(""));
+  const operandBytes = [];
+  const unknown = (index) => {
+    const option = bytes[index];
+    if (profile?.listingEncoding !== "utf8") {
+      let message;
+      try {
+        const text = new TextDecoder("utf8", { fatal: true, ignoreBOM: true }).decode(option);
+        message = "Unknown option " + Array.from(text, (character) => character.codePointAt(0) < 128 ? character : "?").join("");
+      } catch {
+        message = "[Invalid UTF-8] Unknown option " + Array.from(option, (byte) => byte >= 32 && byte < 127 || byte === 9 || byte === 10 ? String.fromCharCode(byte) : `\\x${byte.toString(16).padStart(2, "0")}`).join("");
+      }
+      const result = parserError(message);
+      return { ...result, stderrBytes: encoder.encode(result.stderr) };
+    }
+    const prefix = encoder.encode("Unknown option ");
+    const suffix = encoder.encode("\nRun 'ssconvert --help' to see a full list of available command line options.\n");
+    const raw = new Uint8Array(prefix.length + option.length + suffix.length);
+    raw.set(prefix);
+    raw.set(option, prefix.length);
+    raw.set(suffix, prefix.length + option.length);
+    return { kind: "terminal", exitCode: 1, stdout: "", stderr: decoder.decode(raw), stderrBytes: raw };
+  };
+  const operands = [], scalars = {}, scalarBytes = {}, arrays = {}, flags = /* @__PURE__ */ new Set();
+  let options = true;
+  for (let index = 0; index < argv.length; index++) {
+    const argument = argv[index];
+    if (argument.includes("\0"))
+      return parserError("Arguments must not contain NUL");
+    if (options && argument === "--") {
+      options = false;
+      if (argv.slice(index + 1).some((remaining) => remaining.startsWith("-"))) {
+        operands.push(argument);
+        operandBytes.push(bytes[index]);
+      }
+      continue;
+    }
+    if (!options || !argument.startsWith("-") || argument === "-") {
+      operands.push(decoder.decode(bytes[index]));
+      operandBytes.push(bytes[index]);
+      continue;
+    }
+    const long = argument.startsWith("--");
+    const raw = argument.slice(long ? 2 : 1);
+    let consumed = false;
+    for (const entry of long ? [raw] : raw) {
+      if (long && ["help", "help-all", "help-libspreadsheet", "help-gtk"].includes(entry) || !long && (entry === "?" || entry === "h")) {
+        const group = long ? entry : "help";
+        const captured = group === "help" ? profile?.help : profile?.groups?.[group];
+        if (captured !== void 0)
+          return terminal("", 0, captured);
+        if (group !== "help" && profile?.help !== void 0)
+          return terminal(`Unsupported ssconvert feature: --${group} (missing locale help capture; virtual runtime parity blocker)
+`);
+        return terminal("", 0, referenceText[group]);
+      }
+      const equals = long ? entry.indexOf("=") : -1;
+      let name = equals < 0 ? entry : entry.slice(0, equals);
+      let inherited;
+      if (long && !Object.hasOwn(scalarNames, name) && !Object.hasOwn(flagNames, name) && !arrayNames.has(name)) {
+        const dash = name.indexOf("-");
+        if (dash > 0) {
+          const prefix = name.slice(0, dash), option = name.slice(dash + 1);
+          for (const group of inheritedGroups) {
+            if (group.name.startsWith(prefix) && Object.hasOwn(group.entries, option)) {
+              inherited = group.entries[option];
+              name = option;
+              break;
+            }
+          }
+        }
+      }
+      const scalar = (long ? name.length > 1 : name.length === 1) && Object.hasOwn(scalarNames, name) ? scalarNames[name] : void 0;
+      const flag = inherited === "library-version" ? inherited : (long ? name.length > 1 : name.length === 1) && Object.hasOwn(flagNames, name) ? flagNames[name] : void 0;
+      if (scalar || long && arrayNames.has(name)) {
+        const optionName = `${long ? "--" : "-"}${name}`;
+        if (!long && consumed)
+          return parserError(`Error parsing option ${optionName}`);
+        const value = equals < 0 ? argv[index + 1] : entry.slice(equals + 1);
+        if (value === void 0)
+          return parserError(`Missing argument for ${optionName}`);
+        if (value.includes("\0"))
+          return parserError("Arguments must not contain NUL");
+        const valueBytes = equals < 0 ? bytes[index + 1] : bytes[index].subarray(2 + equals + 1);
+        if (scalar !== "lib-dir" && scalar !== "data-dir" && profile?.argumentEncoding !== "utf8" && valueBytes.some((byte) => byte >= 128))
+          return parserError("Invalid byte sequence in conversion input");
+        let decoded;
+        if (scalar === "lib-dir" || scalar === "data-dir") {
+          scalarBytes[scalar] = new Uint8Array(valueBytes);
+          decoded = decoder.decode(valueBytes);
+        } else {
+          try {
+            decoded = new TextDecoder("utf8", { fatal: true, ignoreBOM: true }).decode(valueBytes);
+          } catch {
+            return parserError("Invalid byte sequence in conversion input");
+          }
+        }
+        if (equals < 0)
+          consumed = true;
+        if (scalar === "gtk-module") {
+          if (decoded !== "")
+            (arrays[scalar] ??= []).push(decoded);
+        } else if (scalar)
+          scalars[scalar] = decoded;
+        else
+          (arrays[name] ??= []).push(decoded);
+      } else if (flag)
+        flags.add(flag);
+      else
+        return unknown(index);
+    }
+    if (consumed)
+      index++;
+  }
+  if (flags.has("library-version"))
+    return terminal("", 0, profile?.libraryVersion ?? (profile?.configurationRoots ? `gnumeric version '1.12.61'
+datadir := '${profile.configurationRoots.dataDir}'
+libdir := '${profile.configurationRoots.libDir}'
+` : referenceText["libspreadsheet-version"]));
+  if (arrays["gtk-module"] !== void 0)
+    return terminal("Unsupported ssconvert feature: --gtk-module (virtual runtime parity blocker)\n");
+  if (flags.has("version"))
+    return terminal("", 0, profile?.version ?? (profile?.configurationRoots ? `ssconvert version '1.12.61'
+datadir := '${profile.configurationRoots.dataDir}'
+libdir := '${profile.configurationRoots.libDir}'
+` : referenceText.version));
+  for (const name of ["display", "class", "name", "g-fatal-warnings"])
+    if (scalars[name] !== void 0 || flags.has(name))
+      return terminal(`Unsupported ssconvert feature: --${name} (virtual runtime parity blocker)
+`);
+  if (flags.has("export-file-per-sheet") && scalars["merge-to"] !== void 0)
+    return terminal("--export-file-per-sheet and --merge-to are incompatible\n");
+  if (flags.has("export-graphs"))
+    flags.add("export-file-per-sheet");
+  const action = flags.has("list-exporters") ? "list-exporters" : flags.has("list-importers") ? "list-importers" : flags.has("list-image-formats") ? "list-image-formats" : scalars.clipboard !== void 0 ? "clipboard" : scalars["merge-to"] !== void 0 ? "merge" : "convert";
+  if (!action.startsWith("list-") && (action === "merge" ? operands.length < 2 : action === "clipboard" ? operands.length !== 2 || scalars["export-range"] === void 0 : operands.length < 1 || operands.length > 2))
+    return terminal("Usage: ssconvert [OPTION...] INFILE [OUTFILE]\n");
+  return Object.freeze({
+    kind: "operation",
+    action,
+    operands: Object.freeze(operands),
+    ...byteMode ? { operandBytes: Object.freeze(operandBytes) } : {},
+    scalars: Object.freeze(scalars),
+    ...Object.keys(scalarBytes).length === 0 ? {} : { scalarBytes: Object.freeze(scalarBytes) },
+    arrays: Object.freeze(Object.fromEntries(Object.entries(arrays).map(([key, values]) => [key, Object.freeze(values)]))),
+    flags: Object.freeze([...flags])
+  });
+}
+
+// packages/safe-bash-command-ssconvert/dist/codecs/ordering.js
+init_buffer();
+
+// packages/safe-bash-command-ssconvert/dist/rendering/images/formats.js
+init_buffer();
+
+// packages/safe-bash-command-ssconvert/dist/cli.js
+async function runCommand(argv, engine, operation, profile) {
+  operation.signal.throwIfAborted();
+  let argumentBytes = 0;
+  try {
+    const maximum = engine.limits.argumentBytes ?? Infinity;
+    if (argv.length > maximum)
+      throw new SsconvertError("resource-limit", "ssconvert arguments limit exceeded");
+    for (const argument of argv) {
+      if (typeof argument === "string") {
+        if (argument.length > maximum - argumentBytes)
+          throw new SsconvertError("resource-limit", "ssconvert argument bytes limit exceeded");
+        for (const character of argument) {
+          const code = character.codePointAt(0);
+          argumentBytes += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+          if (argumentBytes > maximum)
+            throw new SsconvertError("resource-limit", "ssconvert argument bytes limit exceeded");
+        }
+      } else
+        argumentBytes += argument.byteLength;
+      if (argumentBytes > maximum)
+        throw new SsconvertError("resource-limit", "ssconvert argument bytes limit exceeded");
+    }
+  } catch (error) {
+    if (!isSsconvertError(error))
+      throw error;
+    await operation.stderr.write(new TextEncoder().encode(`${error.message}
+`));
+    operation.signal.throwIfAborted();
+    return { exitCode: error.exitCode };
+  }
+  const parsed = parseCommand(argv, profile);
+  const encoder = new TextEncoder();
+  let stderrFailed = false;
+  async function report(bytes) {
+    operation.signal.throwIfAborted();
+    try {
+      await operation.stderr.write(bytes);
+    } catch (error) {
+      stderrFailed = true;
+      throw error;
+    }
+    operation.signal.throwIfAborted();
+  }
+  let outputBytes = 0;
+  function encodeOutput(text) {
+    for (const character of text) {
+      const code = character.codePointAt(0);
+      outputBytes += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+      if (outputBytes > (engine.limits.commandOutputBytes ?? Infinity))
+        throw new SsconvertError("resource-limit", "ssconvert output bytes limit exceeded");
+    }
+    return encoder.encode(text);
+  }
+  try {
+    if (parsed.kind === "terminal") {
+      if (parsed.stdout)
+        await operation.stdout.write(encodeOutput(parsed.stdout));
+      if (parsed.stderr) {
+        if (parsed.stderrBytes) {
+          if (parsed.stderrBytes.byteLength > (engine.limits.commandOutputBytes ?? Infinity) - outputBytes)
+            throw new SsconvertError("resource-limit", "ssconvert output bytes limit exceeded");
+          outputBytes += parsed.stderrBytes.byteLength;
+          await report(parsed.stderrBytes);
+        } else
+          await report(encodeOutput(parsed.stderr));
+      }
+      operation.signal.throwIfAborted();
+      return { exitCode: parsed.exitCode };
+    }
+    if (parsed.action === "list-importers" || parsed.action === "list-exporters" || parsed.action === "list-image-formats") {
+      let textLength2 = function(text, ascii2) {
+        let length = 0;
+        for (const character of text) {
+          const code = character.codePointAt(0);
+          length += ascii2 || code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+          if (length > maximum)
+            throw new SsconvertError("resource-limit", "ssconvert output bytes limit exceeded");
+        }
+        return length;
+      };
+      var textLength = textLength2;
+      const services = parsed.action === "list-image-formats" ? imageFormats : [...engine.listServices(parsed.action === "list-importers" ? "read" : "write")].filter((service) => !service.interactiveOnly).sort(compareServiceIds);
+      const maximum = engine.limits.commandOutputBytes ?? Infinity;
+      if (services.length > maximum)
+        throw new SsconvertError("resource-limit", "ssconvert output bytes limit exceeded");
+      const widths = services.map((service) => textLength2(service.id, false));
+      const width = widths.reduce((max, length) => Math.max(max, length), 0);
+      const ascii = profile?.listingEncoding !== "utf8";
+      let total = 2 + Math.max(0, width - 2) + " | Description\n".length;
+      if (total > maximum)
+        throw new SsconvertError("resource-limit", "ssconvert output bytes limit exceeded");
+      for (let index = 0; index < services.length; index++) {
+        const service = services[index];
+        const length = textLength2(service.id, ascii) + Math.max(0, width - widths[index]) + 3 + textLength2(service.description, ascii) + 1;
+        if (length > maximum - total)
+          throw new SsconvertError("resource-limit", "ssconvert output bytes limit exceeded");
+        total += length;
+      }
+      await report(encodeOutput(`ID${" ".repeat(Math.max(0, width - 2))} | Description
+`));
+      for (let index = 0; index < services.length; index++) {
+        operation.signal.throwIfAborted();
+        const service = services[index];
+        const padding = Math.max(0, width - widths[index]);
+        const length = textLength2(service.id, ascii) + padding + 3 + textLength2(service.description, ascii) + 1;
+        if (length > maximum - outputBytes)
+          throw new SsconvertError("resource-limit", "ssconvert output bytes limit exceeded");
+        const line = `${service.id}${" ".repeat(padding)} | ${service.description}
+`;
+        const display = ascii ? Array.from(line, (character) => character.codePointAt(0) < 128 ? character : "?").join("") : line;
+        await report(encodeOutput(display));
+      }
+      operation.signal.throwIfAborted();
+      return { exitCode: 0 };
+    }
+    if (parsed.action !== "convert" && parsed.action !== "merge" && parsed.action !== "clipboard")
+      throw new SsconvertError("unsupported-feature", `Unsupported ssconvert feature: ${parsed.action}`);
+    for (const name of Object.keys(parsed.arrays).filter((name2) => name2 !== "set" && name2 !== "goal-seek" && name2 !== "tool-test"))
+      throw new SsconvertError("unsupported-feature", `Unsupported ssconvert feature: --${name}`);
+    if (parsed.operandBytes) {
+      const filenameDecoder = new TextDecoder("utf8", { fatal: true, ignoreBOM: true });
+      for (const bytes of parsed.operandBytes) {
+        try {
+          filenameDecoder.decode(bytes);
+        } catch {
+          throw new SsconvertError("unsupported-feature", "Unsupported ssconvert feature: non-UTF-8 resource name");
+        }
+      }
+    }
+    const output = parsed.action === "merge" ? parsed.scalars["merge-to"] : parsed.operands[1];
+    const request = {
+      input: { kind: "resource", uri: parsed.operands[0] },
+      ...output === void 0 ? {} : { destination: output === "fd://1" && parsed.scalars["export-type"] !== void 0 ? { kind: "stream", sink: operation.stdout } : { kind: "resource", uri: output } },
+      ...parsed.scalars["import-type"] === void 0 ? {} : { importType: parsed.scalars["import-type"] },
+      ...parsed.scalars["import-encoding"] === void 0 ? {} : { importEncoding: parsed.scalars["import-encoding"] },
+      ...parsed.scalars["export-type"] === void 0 ? {} : { exportType: parsed.scalars["export-type"] },
+      ...parsed.scalars["export-options"] === void 0 ? {} : { exportOptions: [parsed.scalars["export-options"]] },
+      recalc: parsed.flags.includes("recalc"),
+      solve: parsed.flags.includes("solve"),
+      verbose: parsed.flags.includes("verbose"),
+      perSheet: parsed.flags.includes("export-file-per-sheet"),
+      graphs: parsed.flags.includes("export-graphs"),
+      ...parsed.scalars.clipboard === void 0 ? {} : { clipboard: parsed.scalars.clipboard },
+      ...parsed.arrays.set === void 0 ? {} : { updateExpressions: parsed.arrays.set },
+      ...parsed.arrays["goal-seek"] === void 0 ? {} : { goalSeekExpressions: parsed.arrays["goal-seek"] },
+      ...parsed.arrays["tool-test"] === void 0 ? {} : { toolTest: parsed.arrays["tool-test"] },
+      ...parsed.scalars.resize === void 0 ? {} : { resizeExpression: parsed.scalars.resize },
+      ...parsed.scalars["export-range"] === void 0 ? {} : { exportRangeExpression: parsed.scalars["export-range"] }
+    };
+    const emitted = /* @__PURE__ */ new Set();
+    const diagnosticOperation = {
+      ...operation,
+      async diagnostic(diagnostic) {
+        operation.signal.throwIfAborted();
+        await report(diagnostic.bytes ?? encoder.encode(`${diagnostic.message}
+`));
+        emitted.add(diagnostic);
+        operation.signal.throwIfAborted();
+      }
+    };
+    const result = parsed.action === "merge" ? await engine.merge({
+      ...request,
+      inputs: parsed.operands.map((uri) => ({ kind: "resource", uri }))
+    }, diagnosticOperation) : await engine.convert(request, diagnosticOperation);
+    for (const diagnostic of result.diagnostics) {
+      if (emitted.has(diagnostic))
+        continue;
+      operation.signal.throwIfAborted();
+      await report(diagnostic.bytes ?? encoder.encode(`${diagnostic.message}
+`));
+    }
+    operation.signal.throwIfAborted();
+    return result;
+  } catch (error) {
+    operation.signal.throwIfAborted();
+    if (stderrFailed)
+      throw error;
+    if (!isSsconvertError(error))
+      throw error;
+    await report(encoder.encode(`${error.message}
+`));
+    operation.signal.throwIfAborted();
+    return { exitCode: error.exitCode };
+  }
+}
+
+// packages/safe-bash-command-ssconvert/dist/command-bindings.js
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { createOutputOperation, getCommandArguments } from "../safe-bash-contracts/index.js";
+import { builtInDirectContextExecutors } from "../safe-bash-contracts/runtime-control.js";
+import { shellValueByteLength } from "../safe-bash-contracts/value.js";
+import { writeFileOutput } from "../safe-bash-contracts/filesystem-output.js";
+function createCommandBindings(createEngine2, compatibilityDefaults = false) {
+  function createSsconvertCommand2(options = {}) {
+    const configured = { ...options };
+    if (configured.replace !== void 0 && typeof configured.replace !== "boolean")
+      throw new TypeError("ssconvert replace must be boolean");
+    const binding = {
+      ...configured,
+      ...configured.io === void 0 ? {} : { io: Object.freeze({
+        ...configured.io.descriptors === void 0 ? {} : { descriptors: Object.freeze(Object.fromEntries(Object.entries(configured.io.descriptors).map(([key, descriptor]) => [key, Object.freeze({ ...descriptor })]))) },
+        ...configured.io.adapters === void 0 ? {} : { adapters: Object.freeze({ ...configured.io.adapters }) },
+        ...configured.io.transport === void 0 ? {} : { transport: Object.freeze({
+          authorize: configured.io.transport.authorize.bind(configured.io.transport),
+          request: configured.io.transport.request.bind(configured.io.transport),
+          redirects: configured.io.transport.redirects
+        }) }
+      }) },
+      ...configured.runtimeFunctions === void 0 ? {} : { runtimeFunctions: snapshotRuntimeFunctions(configured.runtimeFunctions) },
+      ...configured.profile === void 0 ? {} : { profile: Object.freeze({
+        ...configured.profile,
+        ...configured.profile.groups === void 0 ? {} : { groups: Object.freeze({ ...configured.profile.groups }) },
+        ...configured.profile.configurationRoots === void 0 ? {} : {
+          configurationRoots: Object.freeze({ ...configured.profile.configurationRoots })
+        }
+      }) },
+      codecs: Object.freeze([...configured.codecs ?? []]),
+      ...configured.formats === void 0 ? {} : { formats: snapshotFormats(configured.formats) },
+      limits: Object.freeze({ ...defaultSsconvertLimits, ...configured.limits }),
+      environment: Object.freeze({
+        locale: "C",
+        timezone: "UTC",
+        ...configured.environment,
+        env: Object.freeze({ ...configured.environment?.env })
+      })
+    };
+    const command = {
+      name: "ssconvert",
+      description: "Explicitly bound TypeScript spreadsheet conversion engine",
+      async execute(context) {
+        context.signal.throwIfAborted();
+        const owner = createOutputOperation(context, { async write() {
+        } });
+        const inputBytes = Math.min(binding.limits.inputBytes, context.inputBudget?.maxBytes ?? Infinity);
+        let stdout;
+        const standardOutput = { async write(bytes) {
+          stdout ??= owner.child(context.stdout);
+          await stdout.output.write(bytes);
+        } };
+        let stderr;
+        const standardError = { async write(bytes) {
+          stderr ??= owner.child(context.stderr);
+          await stderr.output.write(bytes);
+        } };
+        const openOutput = createVfsOutput(context.fs, async (path, bytes, signal) => {
+          await owner.acquire(() => writeFileOutput(context, bytes, async (data) => {
+            const capabilities = await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;
+            signal.throwIfAborted();
+            if (context.fs.writeStream && capabilities.streamingWrite !== false)
+              await context.fs.writeStream(path, (async function* () {
+                yield data;
+              })(), { signal });
+            else
+              await context.fs.writeFile(path, data, { signal });
+          }), () => {
+          });
+        }, (cleanup) => retainFileSystemCleanup(context.fs, (view) => cleanup((path) => view.rm(path)), { maxOperations: 1 }));
+        let engine;
+        try {
+          const cwd = await owner.acquire(() => resolveVfsCwd(context.cwd, context.env.PWD, context.fs, owner.signal), () => {
+          });
+          engine = createEngine2({
+            ...binding,
+            environment: {
+              ...binding.environment,
+              cwd,
+              env: Object.freeze({ ...context.env })
+            },
+            limits: { ...binding.limits, inputBytes },
+            filesystem: createResourceIO({
+              ...binding.io,
+              cwd,
+              descriptors: {
+                ...binding.io?.descriptors,
+                0: { source: context.stdin },
+                1: { sink: standardOutput }
+              },
+              filesystem: {
+                openOutput,
+                async read(uri, signal) {
+                  try {
+                    const capabilities = await context.fs.capabilitiesFor?.(uri, { signal }) ?? context.fs.capabilities;
+                    signal.throwIfAborted();
+                    if (context.fs.readStream && capabilities.streamingRead !== false)
+                      return context.fs.readStream(uri, { signal });
+                    const bytes = await owner.acquire(() => context.fs.readFile(uri, {
+                      signal,
+                      ...inputBytes === Infinity ? {} : { maxBytes: inputBytes }
+                    }), () => {
+                    });
+                    context.inputBudget?.check(bytes.byteLength);
+                    return [bytes];
+                  } catch (error) {
+                    signal.throwIfAborted();
+                    throw error;
+                  }
+                },
+                async write(uri, bytes, signal) {
+                  try {
+                    await owner.acquire(() => writeFileOutput(context, bytes, async (data) => {
+                      const capabilities = await context.fs.capabilitiesFor?.(uri, { signal }) ?? context.fs.capabilities;
+                      signal.throwIfAborted();
+                      if (context.fs.writeStream && capabilities.streamingWrite !== false)
+                        await context.fs.writeStream(uri, (async function* () {
+                          yield data;
+                        })(), { signal });
+                      else
+                        await context.fs.writeFile(uri, data, { signal });
+                    }), () => {
+                    });
+                  } catch (error) {
+                    signal.throwIfAborted();
+                    throw error;
+                  }
+                }
+              }
+            })
+          });
+          const maximumArguments = binding.limits.argumentBytes ?? Infinity;
+          const values = context.argumentValues?.values ?? context.args;
+          let argumentBytes = 0;
+          let refusal;
+          if (values.length > maximumArguments)
+            refusal = "ssconvert arguments limit exceeded";
+          for (const value of values) {
+            if (refusal)
+              break;
+            if (typeof value === "string" && value.length > maximumArguments - argumentBytes) {
+              refusal = "ssconvert argument bytes limit exceeded";
+              break;
+            }
+            argumentBytes += shellValueByteLength(value);
+            if (argumentBytes > maximumArguments)
+              refusal = "ssconvert argument bytes limit exceeded";
+          }
+          if (refusal) {
+            await standardError.write(new TextEncoder().encode(`${refusal}
+`));
+            owner.signal.throwIfAborted();
+            return { exitCode: 1 };
+          }
+          const carrier = getCommandArguments(context);
+          return await runCommand(carrier.args.map((_, index) => carrier.bytes(index)), engine, {
+            signal: owner.signal,
+            ...context.stdinIsDefault === void 0 ? {} : { stdinIsDefault: context.stdinIsDefault },
+            stdout: standardOutput,
+            stderr: standardError,
+            registerCleanup: (cleanup) => owner.registerCleanup(cleanup)
+          }, binding.profile);
+        } finally {
+          try {
+            await engine?.dispose();
+          } finally {
+            await owner.close();
+          }
+        }
+      }
+    };
+    if (compatibilityDefaults && Object.entries(configured).every(([key, value]) => key === "replace" || value === void 0)) {
+      builtInDirectContextExecutors.add(command.execute);
+    }
+    return command;
+  }
+  function ssconvertCommands2(options = {}) {
+    const commands = createSsconvertCommands2(options), replace = options.replace ?? false;
+    return {
+      name: "ssconvert-commands",
+      setup(host) {
+        if (!replace && commands.some((command) => host.commands.has(command.name)))
+          throw new Error("Command already registered: ssconvert");
+        for (const command of commands)
+          host.commands.register(command, { replace });
+      }
+    };
+  }
+  function createSsconvertCommands2(options = {}) {
+    return Object.freeze([createSsconvertCommand2(options)]);
+  }
+  return { createSsconvertCommand: createSsconvertCommand2, createSsconvertCommands: createSsconvertCommands2, ssconvertCommands: ssconvertCommands2 };
+}
+
+// packages/safe-bash-command-ssconvert/dist/commands.js
+var bindings = createCommandBindings(createEngine);
+var createSsconvertCommand = bindings.createSsconvertCommand;
+var createSsconvertCommands = bindings.createSsconvertCommands;
+var ssconvertCommands = bindings.ssconvertCommands;
+export {
+  createSsconvertCommand,
+  createSsconvertCommands,
+  ssconvertCommands
+};