@poe-platform/safe-bash 0.1.710 → 0.1.712

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

@@ -1,6 +1,1401 @@
-export { createExiftoolCommand, exiftoolCommand, exiftoolCommands } from "./command.js";
-export { inspectPng, editPng } from "./png.js";
-export { encodeJsonScalar, printable } from "./scalar.js";
-export { exiftoolLimits } from "./resources.js";
-export { exiftoolRegistry } from "./registry.js";
-export { createExiftoolArguments } from "./sdk.js";
+// packages/safe-bash-command-exiftool/dist/command.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";
+import { createOutputOperation } from "../safe-bash-contracts/output.js";
+import { shellValueByteLength } from "../safe-bash-contracts/value.js";
+
+// packages/safe-bash-command-exiftool/dist/registry.js
+var textChunks = Object.freeze(["tEXt", "iTXt"]);
+var writeChunks = Object.freeze({
+  Title: textChunks,
+  Author: textChunks,
+  Description: textChunks,
+  Comment: textChunks,
+  Copyright: textChunks,
+  ModifyDate: Object.freeze(["tIME"])
+});
+var exiftoolRegistry = Object.freeze({
+  version: 2,
+  source: Object.freeze({ version: "13.59", commit: "2200871d9cef988051d2a99d67df3bda6cbb30a8", archiveSha256: "e1e2ad6c6fbf568afee5993ef8b2b91ab013d21698c9304e079e633ad82776f5" }),
+  formats: Object.freeze({ PNG: Object.freeze({ reader: "uncompressed-text-time", writer: "selected-text-time" }) }),
+  tags: Object.freeze(Object.keys(writeChunks)),
+  writeChunks,
+  scalarShiftErrorGroups: Object.freeze({ Title: "XMP-xmp" })
+});
+
+// packages/safe-bash-command-exiftool/dist/arguments.js
+function parseArguments(args, limits) {
+  if (args.length > 4096)
+    throw new RangeError("ExifTool argument count exceeded");
+  let extent = 0;
+  for (const arg of args) {
+    extent += arg.length * 2;
+    if (extent > limits.maxDecodedBytes)
+      throw new RangeError("ExifTool argument decoded budget exceeded");
+  }
+  const result = {
+    files: [],
+    tags: [],
+    assignments: [],
+    json: false,
+    csv: false,
+    quoteScalars: false,
+    duplicates: false,
+    binary: false,
+    missing: false,
+    style: "short",
+    overwrite: "backup",
+    destination: void 0,
+    groupFamily: void 0
+  };
+  let literal = false;
+  let valueConvSelector = false;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    const option = arg.toLowerCase();
+    const value = () => {
+      if (++index >= args.length)
+        throw new Error("Missing argument for " + arg);
+      return args[index];
+    };
+    if (literal || !arg.startsWith("-") || arg === "-") {
+      result.files.push(arg);
+      continue;
+    }
+    if (arg === "--") {
+      literal = true;
+      continue;
+    }
+    if (option === "-config") {
+      if (value() !== "")
+        throw new Error("User configuration modules are not supported");
+      continue;
+    }
+    if (option === "-j" || option === "-json") {
+      result.json = true;
+      continue;
+    }
+    if (option === "-csv") {
+      result.csv = true;
+      continue;
+    }
+    if (arg === "-G4") {
+      result.groupFamily = 4;
+      continue;
+    }
+    if (option === "-api") {
+      if (value().toLowerCase() !== "structformat=jsonq")
+        throw new Error("API option not yet supported");
+      result.quoteScalars = true;
+      continue;
+    }
+    if (option === "-a") {
+      result.duplicates = true;
+      continue;
+    }
+    if (option === "-b") {
+      result.binary = true;
+      continue;
+    }
+    if (option === "-f") {
+      result.missing = true;
+      continue;
+    }
+    if (arg === "-S") {
+      result.style = "compact";
+      continue;
+    }
+    if (option === "-s" || option === "-s1") {
+      result.style = "short";
+      continue;
+    }
+    if (option === "-s3") {
+      result.style = "values";
+      continue;
+    }
+    if (option === "-n")
+      continue;
+    if (option === "-overwrite_original") {
+      result.overwrite = "replace";
+      continue;
+    }
+    if (option === "-overwrite_original_in_place") {
+      result.overwrite = "in-place";
+      continue;
+    }
+    if (option === "-o") {
+      result.destination = value();
+      continue;
+    }
+    if (["-if", "-p", "-stay_open", "-@", "-common_args"].includes(option) || option.startsWith("-execute"))
+      throw new Error("ExifTool option not yet supported (no code evaluation or ambient polling): " + arg);
+    const equals = arg.indexOf("=");
+    let name = arg.slice(1, equals < 0 ? void 0 : equals);
+    const operation = name.endsWith("+") ? "add" : name.endsWith("-") ? "remove" : "set";
+    if (operation !== "set")
+      name = name.slice(0, -1);
+    if (name.endsWith("#")) {
+      if (equals < 0)
+        valueConvSelector = true;
+      name = name.slice(0, -1);
+    }
+    const known = exiftoolRegistry.tags.find((tag) => tag.toLowerCase() === name.toLowerCase());
+    if (equals >= 0)
+      result.assignments.push({ name: known ?? name, operation, value: arg.slice(equals + 1) });
+    else if (known || name === "MissingTag")
+      result.tags.push(known ?? name);
+    else
+      throw new Error("ExifTool option/tag not yet supported: " + arg);
+  }
+  if (!result.files.length)
+    throw new Error("No file specified");
+  if (result.files.filter((file) => file === "-").length > 1)
+    throw new Error("Repeated stdin operands are not supported");
+  if (result.files.includes("-") && result.assignments.length)
+    throw new Error("Writing stdin metadata is not yet supported");
+  if (result.files.length > 64)
+    throw new RangeError("ExifTool file count exceeded");
+  if (result.destination !== void 0 && (result.files.length !== 1 || !result.assignments.length))
+    throw new Error("-o requires a single file with tag assignments in this profile");
+  if (result.json && result.binary)
+    throw new Error("JSON binary policy not yet supported");
+  if (result.csv && (result.json || result.binary || result.assignments.length))
+    throw new Error("CSV combined output/import policy not yet supported");
+  if (result.csv && valueConvSelector)
+    throw new Error("CSV ValueConv-qualified headers not yet supported");
+  if (result.groupFamily !== void 0 && (!result.json || result.assignments.length))
+    throw new Error("Group-family qualification outside JSON not yet supported");
+  return result;
+}
+
+// packages/safe-bash-command-exiftool/dist/resources.js
+var exiftoolLimits = Object.freeze({
+  maxInputBytes: 16777216,
+  maxDecodedBytes: 8388608,
+  maxRetainedBytes: 33554432,
+  maxOutputBytes: 16777216,
+  maxWork: 268435456
+});
+var ResourceLimitError = class extends RangeError {
+};
+var Resources = class {
+  limits;
+  signal;
+  usage = { input: 0, decoded: 0, retained: 0, output: 0, work: 0 };
+  constructor(options) {
+    this.signal = options.signal;
+    this.signal.throwIfAborted();
+    this.limits = Object.freeze({ ...exiftoolLimits, ...options });
+    for (const key of Object.keys(exiftoolLimits)) {
+      if (!Number.isSafeInteger(this.limits[key]) || this.limits[key] < 0)
+        throw new RangeError("Invalid resource limit: " + key);
+    }
+  }
+  admit(kind, amount) {
+    this.signal.throwIfAborted();
+    const limits = { input: "maxInputBytes", decoded: "maxDecodedBytes", retained: "maxRetainedBytes", output: "maxOutputBytes", work: "maxWork" };
+    const total = this.usage[kind] + amount;
+    if (!Number.isSafeInteger(amount) || amount < 0 || !Number.isSafeInteger(total) || total > this.limits[limits[kind]])
+      throw new ResourceLimitError("ExifTool " + kind + " budget exceeded");
+    this.usage[kind] = total;
+  }
+};
+
+// packages/safe-bash-command-exiftool/dist/shifts.js
+function isNumericShift(value) {
+  const end = value.endsWith("\n") ? value.length - 1 : value.length;
+  let index = value[0] === "+" || value[0] === "-" ? 1 : 0;
+  const digit = () => index < end && value.charCodeAt(index) >= 48 && value.charCodeAt(index) <= 57;
+  const start = index;
+  while (digit())
+    index++;
+  let digits = index - start;
+  if (value[index] === "." || value[index] === ",") {
+    const start2 = ++index;
+    while (digit())
+      index++;
+    digits += index - start2;
+  }
+  if (!digits)
+    return false;
+  if (value[index] === "e" || value[index] === "E") {
+    index++;
+    if (value[index] === "+" || value[index] === "-")
+      index++;
+    const start2 = index;
+    while (digit())
+      index++;
+    if (index === start2)
+      return false;
+  }
+  return index === end;
+}
+
+// packages/safe-bash-command-exiftool/dist/png.js
+var signature = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+var bitDepths = Object.freeze({
+  0: [1, 2, 4, 8, 16],
+  2: [8, 16],
+  3: [1, 2, 4, 8],
+  4: [8, 16],
+  6: [8, 16]
+});
+function checksum(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit++)
+      crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function encodePngTime(value, resources) {
+  resources.admit("work", value.length * 2 + 32);
+  const invalid = () => {
+    throw new Error("PNG timestamp syntax/range not yet supported");
+  };
+  const decimal = (start, end) => {
+    let number = 0;
+    for (let index2 = start; index2 < end; index2++) {
+      const digit = value.charCodeAt(index2) - 48;
+      if (!(digit >= 0 && digit <= 9))
+        invalid();
+      number = number * 10 + digit;
+    }
+    return number;
+  };
+  if (value.length < 19 || ![":", "-"].includes(value[4]) || value[7] !== value[4] || ![" ", "T"].includes(value[10]) || value[13] !== ":" || value[16] !== ":")
+    invalid();
+  const year = decimal(0, 4), month = decimal(5, 7), day = decimal(8, 10);
+  const hour = decimal(11, 13), minute = decimal(14, 16), second = decimal(17, 19);
+  if (!year || month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59 || second > 59)
+    invalid();
+  let index = 19;
+  if (value[index] === ".") {
+    const start = ++index;
+    while (index < value.length && value.charCodeAt(index) >= 48 && value.charCodeAt(index) <= 57)
+      index++;
+    if (start === index)
+      invalid();
+  }
+  if (value[index] === "Z")
+    index++;
+  else if (value[index] === "+" || value[index] === "-") {
+    if (value.length - index !== 6 || value[index + 3] !== ":" || decimal(index + 1, index + 3) > 23 || decimal(index + 4, index + 6) > 59)
+      invalid();
+    index += 6;
+  }
+  if (index !== value.length)
+    invalid();
+  resources.admit("retained", 26);
+  return new Uint8Array([year >>> 8, year & 255, month, day, hour, minute, second]);
+}
+function pngChunk(type, data, maxBytes = 16777216) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0 || data.length + 12 > maxBytes)
+    throw new RangeError("PNG output budget exceeded");
+  if (type.length !== 4 || [...type].some((character) => !(character >= "A" && character <= "Z" || character >= "a" && character <= "z")))
+    throw new TypeError("Invalid PNG chunk type");
+  const bytes = new Uint8Array(data.length + 12);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, data.length);
+  for (let index = 0; index < 4; index++)
+    bytes[index + 4] = type.charCodeAt(index);
+  bytes.set(data, 8);
+  view.setUint32(bytes.length - 4, checksum(bytes.subarray(4, bytes.length - 4)));
+  return bytes;
+}
+function parse(input, resources) {
+  resources.admit("input", input.length);
+  resources.admit("retained", input.length);
+  resources.admit("work", input.length * 10);
+  const bytes = new Uint8Array(input);
+  if (bytes.length < 8 || signature.some((byte, index) => bytes[index] !== byte))
+    throw new Error("Not a PNG file");
+  const view = new DataView(bytes.buffer);
+  const chunks = [];
+  const tags = [];
+  const instances = /* @__PURE__ */ new Map();
+  let offset = 8;
+  let ended = false;
+  let imageData = false;
+  while (offset < bytes.length) {
+    resources.signal.throwIfAborted();
+    resources.admit("retained", 128);
+    if (ended)
+      throw new Error("PNG trailing data not yet supported");
+    if (bytes.length - offset < 12)
+      throw new Error("PNG truncated chunk");
+    const size = view.getUint32(offset);
+    if (size > bytes.length - offset - 12)
+      throw new Error("PNG truncated chunk data");
+    const end = offset + size + 12;
+    const type = String.fromCharCode(...bytes.subarray(offset + 4, offset + 8));
+    if (checksum(bytes.subarray(offset + 4, end - 4)) !== view.getUint32(end - 4))
+      throw new Error("PNG CRC mismatch");
+    const data = bytes.subarray(offset + 8, end - 4);
+    if (offset === 8 && type !== "IHDR")
+      throw new Error("PNG missing initial IHDR");
+    if (type === "IHDR") {
+      if (offset !== 8 || size !== 13)
+        throw new Error("Invalid PNG IHDR");
+      const header = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      if (!header.getUint32(0) || !header.getUint32(4) || header.getUint32(0) > 2147483647 || header.getUint32(4) > 2147483647)
+        throw new Error("Invalid PNG dimensions");
+      if (!bitDepths[data[9]]?.includes(data[8]) || data[10] !== 0 || data[11] !== 0 || data[12] > 1)
+        throw new Error("Invalid PNG IHDR encoding fields");
+    }
+    if (type === "IDAT")
+      imageData = true;
+    if (type === "IEND" && !imageData)
+      throw new Error("PNG missing IDAT");
+    let tag;
+    let rawName, name = "", value = "";
+    let raw;
+    let start = 0;
+    if (type === "zTXt" || type === "eXIf")
+      throw new Error("PNG " + type + " metadata not yet supported");
+    if (type === "tEXt" || type === "iTXt") {
+      const separator = data.indexOf(0);
+      if (separator < 1 || separator > 79)
+        throw new Error("Invalid PNG text keyword");
+      resources.admit("decoded", data.length * 2);
+      resources.admit("work", data.length * 8);
+      const keyword = Array.from(data.subarray(0, separator), (byte) => String.fromCharCode(byte)).join("");
+      start = separator + 1;
+      if (type === "iTXt") {
+        if (start + 2 > data.length)
+          throw new Error("PNG truncated iTXt header");
+        if (data[start] !== 0)
+          throw new Error("PNG compressed iTXt not yet supported");
+        if (data[start + 1] !== 0)
+          throw new Error("Invalid PNG iTXt compression method");
+        const languageEnd = data.indexOf(0, start + 2);
+        const translatedEnd = languageEnd < 0 ? -1 : data.indexOf(0, languageEnd + 1);
+        if (translatedEnd < 0)
+          throw new Error("PNG truncated iTXt language fields");
+        if (languageEnd !== start + 2 || translatedEnd !== languageEnd + 1 || keyword === "XML:com.adobe.xmp")
+          throw new Error("PNG qualified/XMP iTXt not yet supported");
+        start = translatedEnd + 1;
+      }
+      raw = data.subarray(start);
+      resources.admit("retained", raw.length + data.length * 40 + 128);
+      value = type === "tEXt" ? Array.from(raw, (byte) => String.fromCharCode(byte)).join("") : new TextDecoder("utf-8", { ignoreBOM: true }).decode(raw);
+      name = exiftoolRegistry.tags.find((name2) => name2.toLowerCase() === keyword.toLowerCase()) ?? keyword;
+      rawName = keyword;
+    }
+    if (type === "tIME") {
+      if (size !== 7)
+        throw new Error("Invalid PNG tIME length");
+      resources.admit("decoded", 50);
+      resources.admit("retained", 256);
+      resources.admit("work", 128);
+      rawName = "tIME";
+      name = "ModifyDate";
+      raw = data;
+      const fields = [data[0] << 8 | data[1], ...data.subarray(2)];
+      const parts = fields.map((field, index) => String(field).padStart(index === 0 ? 4 : 2, "0"));
+      value = parts.slice(0, 3).join(":") + " " + parts.slice(3).join(":");
+    }
+    if (rawName !== void 0 && raw !== void 0) {
+      const instance = instances.get(name) ?? 0;
+      instances.set(name, instance + 1);
+      tag = Object.freeze({ name, rawName, chunkType: type, index: chunks.length, value, raw: new Uint8Array(raw), instance, offset: offset + 8 + start, group: "PNG" });
+      tags.push(tag);
+    }
+    chunks.push({ type, bytes: bytes.subarray(offset, end), ...tag ? { tag } : {} });
+    if (type === "IEND") {
+      if (size)
+        throw new Error("Invalid PNG IEND");
+      ended = true;
+    }
+    offset = end;
+  }
+  if (!ended)
+    throw new Error("PNG truncated: missing IEND");
+  return { chunks, tags };
+}
+function inspectPng(input, options) {
+  const resources = options instanceof Resources ? options : new Resources(options);
+  return Object.freeze({ tags: Object.freeze(parse(input, resources).tags) });
+}
+function editPng(input, assignments, options) {
+  const resources = options instanceof Resources ? options : new Resources(options);
+  const { chunks } = parse(input, resources);
+  resources.admit("retained", assignments.length * 128);
+  resources.admit("work", assignments.length * (chunks.length + 1));
+  const all = assignments.length === 1 && assignments[0].name.toLowerCase() === "all" && assignments[0].operation === "set" && assignments[0].value === "";
+  if (all && chunks.some((chunk) => !["IHDR", "PLTE", "IDAT", "IEND", "tEXt", "iTXt", "tIME"].includes(chunk.type)))
+    throw new Error("PNG all deletion with unqualified chunks is not yet supported");
+  const operations = /* @__PURE__ */ new Map();
+  for (const assignment of assignments) {
+    resources.admit("decoded", (assignment.name.length + assignment.value.length) * 2);
+    resources.admit("work", assignment.name.length * 5 + assignment.value.length * 3);
+    resources.admit("work", (chunks.length + assignments.length) * (assignment.value.length + assignment.name.length + 1));
+    resources.admit("retained", assignment.name.length * 10 + assignment.value.length * 6);
+    if (all)
+      continue;
+    const name = exiftoolRegistry.tags.find((name2) => name2.toLowerCase() === assignment.name.toLowerCase());
+    if (!name)
+      throw new Error("Tag write not yet supported: " + assignment.name);
+    if (name === "ModifyDate" && assignment.operation !== "set")
+      throw new Error("Temporal shifts are not yet supported for ModifyDate");
+    if (assignment.operation === "add") {
+      const group = exiftoolRegistry.scalarShiftErrorGroups[name];
+      if (group && !isNumericShift(assignment.value))
+        throw new Error("Shift value for " + group + ":" + name + " is not a number");
+      throw new Error("Scalar numeric shifts are not yet supported for " + name);
+    }
+    if (assignment.operation !== "set" && assignment.operation !== "remove")
+      throw new Error("Invalid tag operation");
+    const prior = assignment.operation === "set" ? [] : operations.get(name) ?? [];
+    prior.push(assignment);
+    operations.set(name, prior);
+  }
+  const output = [signature];
+  let outputSize = 8;
+  resources.admit("output", 8);
+  const append = (bytes) => {
+    resources.admit("output", bytes.length);
+    outputSize += bytes.length;
+    output.push(bytes);
+  };
+  let inserted = false;
+  for (const chunk of chunks) {
+    if (all && chunk.tag)
+      continue;
+    const ops = chunk.tag && exiftoolRegistry.writeChunks[chunk.tag.name]?.includes(chunk.type) ? operations.get(chunk.tag.name) : void 0;
+    if (ops?.some((op) => op.operation === "set" || op.value === chunk.tag.value))
+      continue;
+    if (chunk.type === "IDAT" && !inserted) {
+      inserted = true;
+      for (const [name, ops2] of operations) {
+        const set = ops2.find((op) => op.operation === "set");
+        if (!set?.value || ops2.some((op) => op.operation === "remove" && op.value === set.value))
+          continue;
+        if (name === "ModifyDate") {
+          const data2 = encodePngTime(set.value, resources);
+          resources.admit("work", 128);
+          resources.admit("retained", 19);
+          resources.admit("output", 19);
+          outputSize += 19;
+          output.push(pngChunk("tIME", data2, 19));
+          continue;
+        }
+        resources.admit("work", set.value.length * 2);
+        let valueBytes = 0;
+        let international = false;
+        for (let index = 0; index < set.value.length; index++) {
+          const code = set.value.charCodeAt(index);
+          international ||= code > 127;
+          if (code >= 55296 && code <= 56319) {
+            const next = set.value.charCodeAt(++index);
+            if (!(next >= 56320 && next <= 57343))
+              throw new Error("Unpaired surrogate in PNG text write");
+            valueBytes += 4;
+          } else {
+            if (code >= 56320 && code <= 57343)
+              throw new Error("Unpaired surrogate in PNG text write");
+            valueBytes += code < 128 ? 1 : code < 2048 ? 2 : 3;
+          }
+        }
+        const prefix = name + (international ? "\0\0\0\0\0" : "\0");
+        const dataSize = prefix.length + valueBytes;
+        const size = dataSize + 12;
+        resources.admit("work", dataSize * 12);
+        resources.admit("retained", prefix.length * 2 + valueBytes + dataSize + size);
+        resources.admit("output", size);
+        const data = new Uint8Array(dataSize);
+        for (let index = 0; index < prefix.length; index++)
+          data[index] = prefix.charCodeAt(index);
+        data.set(new TextEncoder().encode(set.value), prefix.length);
+        outputSize += size;
+        output.push(pngChunk(international ? "iTXt" : "tEXt", data, size));
+        let instances = 0;
+        for (const existing of chunks) {
+          resources.signal.throwIfAborted();
+          resources.admit("work", 1);
+          if (existing.tag?.name === name && exiftoolRegistry.writeChunks[name]?.includes(existing.type))
+            instances++;
+        }
+        for (let instance = 1; instance < instances; instance++)
+          append(output[output.length - 1]);
+      }
+    }
+    append(chunk.bytes);
+  }
+  resources.admit("retained", outputSize);
+  resources.admit("work", outputSize);
+  const result = new Uint8Array(outputSize);
+  let position = 0;
+  for (const bytes of output) {
+    result.set(bytes, position);
+    position += bytes.length;
+  }
+  resources.signal.throwIfAborted();
+  return result;
+}
+
+// packages/safe-bash-command-exiftool/dist/publication.js
+import { FsError } from "../safe-bash-contracts/errors.js";
+var Publication = class {
+  #context;
+  #pending = /* @__PURE__ */ new Set();
+  #stages = [];
+  #closed = false;
+  #closing;
+  #serial = 0;
+  constructor(context) {
+    this.#context = context;
+  }
+  async track(operation) {
+    if (this.#closed)
+      throw new Error("ExifTool invocation closed");
+    this.#context.signal.throwIfAborted();
+    const pending = Promise.resolve().then(operation);
+    this.#pending.add(pending);
+    try {
+      return await pending;
+    } finally {
+      this.#pending.delete(pending);
+    }
+  }
+  close() {
+    if (this.#closing)
+      return this.#closing;
+    this.#closed = true;
+    this.#closing = (async () => {
+      await Promise.allSettled([...this.#pending]);
+      const failures = [];
+      const signal = new AbortController().signal;
+      for (const staging of this.#stages.splice(0).reverse()) {
+        try {
+          await this.#context.fs.removeStagedFile(staging, { signal });
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+      if (failures.length)
+        throw new AggregateError(failures, "ExifTool staging cleanup failed");
+    })();
+    return this.#closing;
+  }
+  async publish(path, bytes, expected, inPlace) {
+    const { fs, signal } = this.#context;
+    const slash = path.lastIndexOf("/");
+    const directory = path.slice(0, slash) || "/";
+    const parent = await this.track(() => fs.stat(directory, { signal }));
+    const capabilities = fs.capabilitiesFor ? await this.track(() => fs.capabilitiesFor(path, { signal })) : fs.capabilities;
+    if (inPlace) {
+      if (!expected || !fs.writeFileConditional || !capabilities.atomicFileMutation)
+        throw new Error("VFS atomic in-place publication not supported");
+      await this.track(() => fs.writeFileConditional(path, bytes, { expected, parent, signal }));
+      return;
+    }
+    if (expected && expected.nlink !== 1)
+      throw new Error("VFS hardlink replacement is not yet supported");
+    if (!fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile || !capabilities.atomicFileStaging)
+      throw new Error("VFS atomic replacement publication not supported");
+    let stage;
+    for (let attempt = 0; attempt < 32; attempt++) {
+      try {
+        stage = await this.track(async () => {
+          const owned = await fs.createStagedFile(directory + (directory === "/" ? "" : "/") + ".exiftool-" + ++this.#serial, "output", { type: "file", data: bytes }, { parent, signal, mode: expected ? expected.mode & 4095 : 438 });
+          this.#stages.push(owned);
+          return owned;
+        });
+        break;
+      } catch (error) {
+        if (!(error instanceof FsError) || error.code !== "EEXIST")
+          throw error;
+      }
+    }
+    if (!stage)
+      throw new Error("ExifTool staging collision limit exceeded");
+    await this.track(() => fs.publishStagedFile(stage, path, { destination: expected, parent, signal }));
+  }
+};
+
+// packages/safe-bash-command-exiftool/dist/scalar.js
+var jsonEscapes = Object.freeze({ 9: "\\t", 10: "\\n", 13: "\\r", 34: '\\"', 92: "\\\\" });
+function admit(value, options) {
+  options.signal?.throwIfAborted();
+  const limits = [options.maxDecodedBytes ?? 2097152, options.maxOutputBytes ?? 6291458, options.maxWork ?? 4194304, options.maxRetainedBytes ?? 14680068];
+  if (limits.some((limit) => !Number.isSafeInteger(limit) || limit < 0))
+    throw new RangeError("Invalid scalar limit");
+  if (value.length * 2 > limits[0])
+    throw new RangeError("Scalar decoded bytes exceeded");
+  if (value.length * 4 > limits[2])
+    throw new RangeError("Scalar work exceeded");
+  if (4 + value.length * 14 > limits[3])
+    throw new RangeError("Scalar retained bytes exceeded");
+}
+function numericSpelling(value) {
+  const length = value.endsWith("\n") ? value.length - 1 : value.length;
+  let index = value[0] === "-" ? 1 : 0;
+  const start = index;
+  const digit = () => index < length && value.charCodeAt(index) >= 48 && value.charCodeAt(index) <= 57;
+  while (digit())
+    index++;
+  const integers = index - start;
+  if (!integers || integers > 15 || integers > 1 && value[start] === "0")
+    return false;
+  if (value[index] === ".") {
+    const fraction = ++index;
+    while (digit())
+      index++;
+    if (index === fraction || index - fraction > 16)
+      return false;
+  }
+  if (value[index] === "e" || value[index] === "E") {
+    index++;
+    if (value[index] === "+" || value[index] === "-")
+      index++;
+    const exponent = index;
+    while (digit())
+      index++;
+    if (index === exponent || index - exponent > 3)
+      return false;
+  }
+  return index === length;
+}
+function encodeJsonScalar(value, options = {}) {
+  admit(value, options);
+  const limit = options.maxOutputBytes ?? 6291458;
+  if (!options.quoteScalars) {
+    const lower = value.toLowerCase();
+    const boolean = lower.endsWith("\n") ? lower.slice(0, -1) : lower;
+    const token = boolean === "true" || boolean === "false" ? lower : numericSpelling(value) ? value : void 0;
+    if (token !== void 0) {
+      if (token.length > limit)
+        throw new RangeError("Scalar output bytes exceeded");
+      return token;
+    }
+  }
+  if (2 + value.length * 6 > limit)
+    throw new RangeError("Scalar output bytes exceeded");
+  let output = '"';
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code === 0)
+      continue;
+    const escape = jsonEscapes[code];
+    if (escape)
+      output += escape;
+    else if (code < 32 || code === 127)
+      output += "\\u" + code.toString(16).toUpperCase().padStart(4, "0");
+    else if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343)
+        output += value[index] + value[++index];
+      else
+        output += "\uFFFD";
+    } else if (code >= 56320 && code <= 57343)
+      output += "\uFFFD";
+    else
+      output += value[index];
+  }
+  options.signal?.throwIfAborted();
+  return output + '"';
+}
+function printable(value, options = {}) {
+  admit(value, options);
+  if (value.length * 3 > (options.maxOutputBytes ?? 6291458))
+    throw new RangeError("Scalar output bytes exceeded");
+  let end = value.length;
+  while (end && (value.charCodeAt(end - 1) === 0 || value[end - 1] === " "))
+    end--;
+  let output = "";
+  for (let index = 0; index < end; index++) {
+    const code = value.charCodeAt(index);
+    if (code)
+      output += code < 32 || code === 127 ? "." : value[index];
+  }
+  return output;
+}
+
+// packages/safe-bash-command-exiftool/dist/csv.js
+var CsvTable = class {
+  resources;
+  missing;
+  headers = /* @__PURE__ */ new Map();
+  records = [];
+  sortHeaders = false;
+  constructor(resources, missing, names) {
+    this.resources = resources;
+    this.missing = missing;
+    for (const name of names) {
+      resources.admit("work", name.length * 2 + 1);
+      resources.admit("retained", name.length * 4 + 128);
+      const key = name.toLowerCase();
+      if (key !== "sourcefile" && !this.headers.has(key))
+        this.headers.set(key, { name, found: missing });
+    }
+  }
+  add(file, tags) {
+    this.resources.admit("work", file.length + tags.length);
+    this.resources.admit("retained", file.length * 2 + 256);
+    const fields = /* @__PURE__ */ new Map();
+    for (const tag of tags) {
+      this.resources.admit("work", tag.name.length * 2 + tag.value.length + 1);
+      this.resources.admit("retained", (tag.name.length + tag.value.length) * 4 + 256);
+      const key = tag.name.toLowerCase();
+      if (key === "sourcefile")
+        continue;
+      if (!this.headers.has(key)) {
+        if (this.records.length)
+          this.sortHeaders = true;
+        this.headers.set(key, { name: tag.name, found: true });
+      } else {
+        this.headers.set(key, { name: tag.name, found: true });
+      }
+      fields.set(key, tag.value);
+    }
+    this.records.push({ file, fields });
+  }
+  render() {
+    const extent = [...this.headers.keys()].reduce((total, key) => total + key.length + 1, 0);
+    this.resources.admit("work", extent * (this.headers.size + 1) + this.records.length * (this.headers.size + 1));
+    this.resources.admit("retained", this.headers.size * 64 + this.records.length * 32);
+    const columns = [...this.headers].filter(([, header]) => header.found);
+    if (this.sortHeaders)
+      columns.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    const quote = (value) => {
+      this.resources.admit("work", value.length * 4 + 1);
+      this.resources.admit("retained", value.length * 8 + 16);
+      let quoted = false;
+      let text = "";
+      for (const character of value) {
+        if (character === '"') {
+          text += '""';
+          quoted = true;
+        } else
+          text += character;
+        if (character === "," || character === "\n" || character === "\r")
+          quoted = true;
+      }
+      const whitespace2 = (character) => " 	\n\r\f\v\x85\xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000".includes(character);
+      if (value.length && (whitespace2(value[0]) || whitespace2(value[value.length - 1])))
+        quoted = true;
+      return quoted ? '"' + text + '"' : text;
+    };
+    const lines = [["SourceFile", ...columns.map(([, header]) => quote(header.name))].join(",")];
+    for (const record of this.records) {
+      this.resources.admit("retained", (columns.length + 1) * 16);
+      lines.push([quote(record.file), ...columns.map(([key]) => quote(record.fields.get(key) ?? (this.missing ? "-" : "")))].join(","));
+    }
+    const size = lines.reduce((total, line) => total + line.length + 1, 0);
+    this.resources.admit("work", size * 2);
+    this.resources.admit("retained", size * 4);
+    return lines.join("\n") + "\n";
+  }
+};
+
+// packages/safe-bash-command-exiftool/dist/argfiles.js
+import { readBytes } from "../safe-bash-contracts/io.js";
+
+// packages/safe-bash-command-exiftool/dist/paths.js
+function virtualPath(cwd, input, resources) {
+  if (input.includes("\0") || input === "-")
+    throw new Error("Invalid or unsupported ExifTool file path");
+  const extent = input.length + (input.startsWith("/") ? 0 : cwd.length + 1);
+  resources.admit("decoded", extent * 2);
+  resources.admit("retained", extent * 32 + 256);
+  resources.admit("work", extent * 24 + 16);
+  const parts = [];
+  for (const part of (input.startsWith("/") ? input : cwd + "/" + input).split("/")) {
+    if (part === "..")
+      parts.pop();
+    else if (part && part !== ".")
+      parts.push(part);
+  }
+  return "/" + parts.join("/");
+}
+
+// packages/safe-bash-command-exiftool/dist/argfiles.js
+var escapes = Object.freeze({ a: "\x07", b: "\b", f: "\f", n: "\n", r: "\r", t: "	", '"': '"', "\\": "\\" });
+function whitespace(character) {
+  return character === " " || character === "	" || character === "\n" || character === "\r" || character === "\f" || character === "\v";
+}
+function filterArgfileLine(line) {
+  const cstr = line.startsWith("#[CSTR]");
+  if (line.startsWith("#") && !cstr)
+    return void 0;
+  let start = cstr ? 7 : 0, end = line.length;
+  if (!cstr)
+    while (start < end && whitespace(line[start]))
+      start++;
+  while (end > start && (line[end - 1] === "\r" || line[end - 1] === "\n"))
+    end--;
+  const value = line.slice(start, end);
+  if (cstr) {
+    const parts = [];
+    for (let index2 = 0; index2 < value.length; index2++) {
+      const character = value[index2];
+      if (character === "\\" && index2 + 1 < value.length) {
+        const next = value[++index2];
+        parts.push(Object.hasOwn(escapes, next) ? escapes[next] : "\\" + next);
+      } else
+        parts.push(character);
+    }
+    return parts.join("");
+  }
+  if (!value)
+    return void 0;
+  if (value[0] !== "-")
+    return value;
+  let index = 1;
+  while (index < value.length) {
+    const character = value[index];
+    if (!(character === "-" || character === "_" || character === ":" || character >= "0" && character <= "9" || character >= "A" && character <= "Z" || character >= "a" && character <= "z"))
+      break;
+    index++;
+  }
+  if (index === 1)
+    return value;
+  if (value[index] === "#")
+    index++;
+  const nameEnd = index;
+  while (index < value.length && whitespace(value[index]))
+    index++;
+  const operationStart = index;
+  if (value[index] === "+" || value[index] === "-" || value[index] === "<")
+    index++;
+  if (value[index] !== "=")
+    return value;
+  index++;
+  const operationEnd = index;
+  if (value[index] === " ")
+    index++;
+  return value.slice(0, nameEnd) + value.slice(operationStart, operationEnd) + value.slice(index);
+}
+async function expandArgfiles(args, context, publication, resources) {
+  const frames = [{ args, index: 0 }];
+  const result = [];
+  let literal = false;
+  let takesValue = false;
+  while (frames.length) {
+    resources.signal.throwIfAborted();
+    const frame = frames[frames.length - 1];
+    if (frame.index >= frame.args.length) {
+      frames.pop();
+      continue;
+    }
+    const arg = frame.args[frame.index++];
+    resources.admit("work", arg.length + 1);
+    const option = arg.toLowerCase();
+    if (!literal && !takesValue && frame.path && (option === "-config" || option === "-common_args"))
+      throw new Error("Configuration/common arguments are not allowed in argument files");
+    if (!literal && !takesValue && option === "-@") {
+      while (frames.length && frames[frames.length - 1].index >= frames[frames.length - 1].args.length)
+        frames.pop();
+      const owner = frames[frames.length - 1];
+      if (!owner)
+        throw new Error("Missing argument for -@");
+      const input = owner.args[owner.index++];
+      if (input === "-" || input.includes("\0"))
+        throw new Error("Argument-file stdin/invalid paths are not supported");
+      const path = virtualPath(context.cwd, input, resources);
+      if (frames.some((active) => active.path === path))
+        throw new Error("Argument-file cycle is not supported");
+      if (frames.length >= 16)
+        throw new Error("Argument-file nesting limit exceeded");
+      const stat = await publication.track(() => context.fs.lstat(path, { signal: context.signal }));
+      if (stat.type !== "file")
+        throw new Error("Only regular VFS argument files are admitted");
+      resources.admit("input", stat.size);
+      resources.admit("decoded", stat.size * 2);
+      resources.admit("retained", stat.size * 48 + 256);
+      resources.admit("work", stat.size * 24 + path.length);
+      const bytes = await publication.track(async () => {
+        if (!context.fs.readStream) {
+          const result2 = await context.fs.readFile(path, { signal: context.signal, maxBytes: stat.size });
+          context.signal.throwIfAborted();
+          if (result2.length > stat.size)
+            throw new RangeError("ExifTool argument file grew beyond admitted size");
+          return result2;
+        }
+        const chunks = [];
+        let extent = 0;
+        for await (const chunk of readBytes(context.fs.readStream(path, { signal: context.signal }), context.signal)) {
+          if (chunk.length > stat.size - extent)
+            throw new Error("Argument file grew beyond admitted size");
+          resources.admit("retained", chunk.length + 128);
+          resources.admit("work", chunk.length + 1);
+          chunks.push(new Uint8Array(chunk));
+          extent += chunk.length;
+        }
+        const owned = new Uint8Array(extent);
+        let offset = 0;
+        for (const chunk of chunks) {
+          owned.set(chunk, offset);
+          offset += chunk.length;
+        }
+        return owned;
+      });
+      if (bytes.length > stat.size)
+        throw new Error("Argument file grew beyond admitted size");
+      let text;
+      try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+      } catch {
+        throw new Error("Only UTF-8 argument files are currently supported");
+      }
+      const expanded = [];
+      let start = 0;
+      for (let index = 0; index <= text.length; index++) {
+        if (index !== text.length && text[index] !== "\n")
+          continue;
+        const value = filterArgfileLine(text.slice(start, index === text.length ? index : index + 1));
+        start = index + 1;
+        if (value !== void 0) {
+          resources.admit("retained", value.length * 2 + 128);
+          if (expanded.length >= 4096)
+            throw new Error("Argument-file argument count exceeded");
+          expanded.push(value);
+        }
+      }
+      frames.push({ args: expanded, index: 0, path });
+      continue;
+    }
+    if (!literal && !takesValue && arg === "--")
+      literal = true;
+    const wasValue = takesValue;
+    takesValue = !literal && !wasValue && ["-config", "-api", "-o", "-if", "-p", "-stay_open"].includes(option);
+    resources.admit("retained", arg.length * 2 + 128);
+    if (result.length >= 4096)
+      throw new Error("ExifTool argument count exceeded");
+    result.push(arg);
+  }
+  return result;
+}
+
+// packages/safe-bash-command-exiftool/dist/command.js
+function selected(tags, names, duplicates, resources) {
+  resources.admit("work", tags.length + names.length);
+  resources.admit("retained", tags.length * 32);
+  const requested = names.length ? names : [...new Set(tags.map((tag) => tag.name))];
+  const requestedExtent = requested.reduce((sum, name) => sum + name.length + 1, 0);
+  const tagExtent = tags.reduce((sum, tag) => sum + tag.name.length + 1, 0);
+  resources.admit("work", tags.length * requestedExtent + tagExtent * requested.length * 2);
+  resources.admit("retained", requested.length * (128 + tags.length * 16));
+  const values = [];
+  for (const name of requested) {
+    const matching = tags.filter((tag) => tag.name.toLowerCase() === name.toLowerCase());
+    if (duplicates)
+      values.push(...matching);
+    else if (matching.length)
+      values.push(matching[matching.length - 1]);
+  }
+  return values;
+}
+function createExiftoolCommand(options = {}) {
+  const limits = Object.freeze({ ...options.limits });
+  return Object.freeze({
+    name: "exiftool",
+    runtimeIdentity: commandRuntimeIdentity,
+    description: "Inspect and edit admitted PNG metadata through virtual files",
+    async execute(context) {
+      const publication = new Publication(context);
+      let stdout, stderr;
+      let failed = false, failure;
+      let closing;
+      const cleanup = () => {
+        closing ??= (async () => {
+          const results = await Promise.allSettled([publication.close(), stdout?.close(), stderr?.close()]);
+          const failures = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+          if (failures.length) {
+            if (failed)
+              failures.unshift(failure);
+            throw new AggregateError(failures, "ExifTool invocation and cleanup failed");
+          }
+        })();
+        return closing;
+      };
+      context.registerCleanup?.(cleanup);
+      try {
+        stdout = createOutputOperation(context, context.stdout);
+        stderr = createOutputOperation(context, context.stderr);
+        const resources = new Resources({ ...limits, signal: context.signal });
+        const output = async (text, error = false) => {
+          resources.admit("work", text.length * 2);
+          resources.admit("output", text.length * 3);
+          resources.admit("retained", text.length * 5);
+          await writeBytes(error ? stderr.output : stdout.output, new TextEncoder().encode(text), context.signal);
+        };
+        let invocation;
+        try {
+          const carrier = getCommandArguments(context);
+          for (let index = 0; index < carrier.values.length; index++) {
+            const extent = shellValueByteLength(carrier.values[index]);
+            resources.admit("decoded", context.args[index].length * 2);
+            resources.admit("retained", extent + 128);
+            resources.admit("work", extent * 4);
+            const bytes = carrier.bytes(index);
+            try {
+              if (new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes) !== context.args[index])
+                throw new Error("Argv Unicode mismatch");
+            } catch {
+              throw new Error("Only qualified UTF-8 argv is currently supported");
+            }
+          }
+          invocation = parseArguments(await expandArgfiles(context.args, context, publication, resources), resources.limits);
+        } catch (error) {
+          context.signal.throwIfAborted();
+          if (error instanceof ResourceLimitError)
+            throw error;
+          await output("Error: " + (error instanceof Error ? error.message : String(error)) + "\n", true);
+          return { exitCode: 1 };
+        }
+        const json = [];
+        const csv = invocation.csv ? new CsvTable(resources, invocation.missing, invocation.tags) : void 0;
+        const assignment = invocation.assignments.length === 1 ? invocation.assignments[0] : void 0;
+        if (assignment?.operation === "add" && Object.hasOwn(exiftoolRegistry.scalarShiftErrorGroups, assignment.name) && !isNumericShift(assignment.value)) {
+          await output("Warning: Shift value for " + exiftoolRegistry.scalarShiftErrorGroups[assignment.name] + ":" + assignment.name + " is not a number\nNothing to do.\n", true);
+          return { exitCode: 1 };
+        }
+        let errors = 0, updated = 0, created = 0, unchanged = 0, read = 0;
+        for (const file of invocation.files) {
+          let tags = [];
+          try {
+            const path = file === "-" ? "-" : virtualPath(context.cwd, file, resources);
+            const original = file === "-" ? void 0 : await publication.track(() => context.fs.lstat(path, { signal: context.signal }));
+            if (original && original.type !== "file")
+              throw new Error("Only regular VFS files are admitted");
+            if (original) {
+              resources.admit("input", original.size);
+              resources.admit("retained", original.size * 32 + 256);
+              resources.admit("decoded", original.size * 2);
+              resources.admit("work", original.size * 20);
+            }
+            const bytes = await publication.track(async () => {
+              if (original && !context.fs.readStream) {
+                const result2 = await context.fs.readFile(path, { signal: context.signal, maxBytes: original.size });
+                context.signal.throwIfAborted();
+                if (result2.length > original.size)
+                  throw new RangeError("ExifTool input grew beyond admitted size");
+                return result2;
+              }
+              const chunks = [];
+              let size = 0;
+              const source = original ? context.fs.readStream(path, { signal: context.signal }) : context.stdin;
+              for await (const chunk of readBytes2(source, context.signal)) {
+                resources.admit("work", chunk.length + 64);
+                if (original && chunk.length > original.size - size)
+                  throw new RangeError("ExifTool input grew beyond admitted size");
+                if (!original) {
+                  resources.admit("input", chunk.length);
+                  resources.admit("retained", chunk.length * 32 + 256);
+                  resources.admit("decoded", chunk.length * 2);
+                  resources.admit("work", chunk.length * 20);
+                }
+                resources.admit("retained", chunk.length + 128);
+                if (chunk.length)
+                  chunks.push(new Uint8Array(chunk));
+                size += chunk.length;
+              }
+              resources.admit("retained", size);
+              const result = new Uint8Array(size);
+              let position = 0;
+              for (const chunk of chunks) {
+                result.set(chunk, position);
+                position += chunk.length;
+              }
+              return result;
+            });
+            if (!bytes.length)
+              throw new Error("File is empty");
+            const extension = file.slice(file.lastIndexOf(".") + 1).toUpperCase();
+            if (invocation.assignments.length && ["DOCX", "PPTX", "XLSX"].includes(extension))
+              throw new Error("Writing of " + extension + " files is not yet supported");
+            if (extension === "PDF")
+              throw new Error("PDF parser/writer not yet supported; metadata deletion retains historical revisions and never guarantees redaction");
+            const png = bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
+            if (invocation.assignments.length) {
+              if (!original)
+                throw new Error("Writing stdin metadata is not yet supported");
+              if (!png)
+                throw new Error("Format writer not yet supported");
+              const edited = editPng(bytes, invocation.assignments, resources);
+              resources.admit("retained", edited.length * 3);
+              resources.admit("work", bytes.length);
+              if (invocation.destination === void 0 && !invocation.assignments.some((op) => op.operation === "set" && op.value !== "") && edited.length === bytes.length && edited.every((byte, index) => byte === bytes[index])) {
+                unchanged++;
+                continue;
+              }
+              resources.admit("output", edited.length);
+              const inPlace = invocation.overwrite === "in-place";
+              const destination = invocation.destination === void 0 ? path : virtualPath(context.cwd, invocation.destination, resources);
+              if (invocation.destination === void 0) {
+                await publication.track(() => context.fs.access(path, 2, { signal: context.signal }));
+                if (!inPlace && original.nlink !== 1)
+                  throw new Error("VFS hardlink replacement is not yet supported");
+                if (invocation.overwrite === "backup") {
+                  const backup = path + "_original";
+                  let existing = false;
+                  try {
+                    await publication.track(() => context.fs.lstat(backup, { signal: context.signal }));
+                    existing = true;
+                  } catch (error) {
+                    if (!(error instanceof FsError2) || error.code !== "ENOENT")
+                      throw error;
+                  }
+                  if (!existing) {
+                    resources.admit("output", bytes.length);
+                    await publication.publish(backup, bytes, null, false);
+                  }
+                }
+              }
+              await publication.publish(destination, edited, invocation.destination === void 0 ? original : null, invocation.destination === void 0 && inPlace);
+              if (invocation.destination === void 0)
+                updated++;
+              else
+                created++;
+              continue;
+            }
+            if (!png && ["XMP", "DOCX", "PPTX", "XLSX", "JPG", "JPEG", "TIF", "TIFF"].includes(extension))
+              throw new Error(extension + " reader not yet supported");
+            tags = png ? inspectPng(bytes, resources).tags : [];
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (error instanceof ResourceLimitError)
+              throw error;
+            errors++;
+            const message = error instanceof FsError2 && error.code === "ENOENT" ? "File not found" : error instanceof Error ? error.message : String(error);
+            await output("Error: " + message + " - " + file + "\n", true);
+            continue;
+          }
+          read++;
+          const chosen = selected(tags, invocation.tags, invocation.json ? invocation.groupFamily === 4 : invocation.duplicates && !invocation.csv, resources);
+          if (csv) {
+            csv.add(file, chosen);
+            continue;
+          }
+          const present = /* @__PURE__ */ new Set();
+          if (invocation.missing) {
+            resources.admit("retained", chosen.length * 64);
+            for (const tag of chosen) {
+              resources.admit("work", tag.name.length + 1);
+              present.add(tag.name);
+            }
+            resources.admit("work", invocation.tags.reduce((sum, name) => sum + name.length + 1, 0));
+          }
+          const scalarOptions = {
+            quoteScalars: invocation.quoteScalars,
+            signal: context.signal,
+            maxDecodedBytes: resources.limits.maxDecodedBytes,
+            maxOutputBytes: resources.limits.maxOutputBytes,
+            maxWork: resources.limits.maxWork,
+            maxRetainedBytes: resources.limits.maxRetainedBytes
+          };
+          if (invocation.json) {
+            const entries = ['  "SourceFile": ' + encodeJsonScalar(file, { ...scalarOptions, quoteScalars: true })];
+            const tokens = /* @__PURE__ */ new Set(['"SourceFile"']);
+            const primaryInstances = /* @__PURE__ */ new Map();
+            if (invocation.groupFamily === 4)
+              for (const tag of tags) {
+                resources.admit("work", tag.name.length + 1);
+                resources.admit("retained", tag.name.length * 2 + 64);
+                primaryInstances.set(tag.name, Math.max(primaryInstances.get(tag.name) ?? 0, tag.instance));
+              }
+            for (const tag of chosen) {
+              resources.admit("work", tag.name.length * 4);
+              const name = invocation.groupFamily === 4 ? (tag.instance === primaryInstances.get(tag.name) ? "" : "Copy" + (tag.instance + 1)) + ":" + tag.name : tag.name;
+              const token = encodeJsonScalar(name, { ...scalarOptions, quoteScalars: true });
+              if (tokens.has(token))
+                continue;
+              tokens.add(token);
+              resources.admit("work", tag.value.length * 4);
+              entries.push("  " + token + ": " + encodeJsonScalar(tag.value, scalarOptions));
+            }
+            if (invocation.missing)
+              for (const name of invocation.tags) {
+                if (present.has(name))
+                  continue;
+                resources.admit("work", name.length * 4 + 1);
+                const token = encodeJsonScalar((invocation.groupFamily === 4 ? ":" : "") + name, { ...scalarOptions, quoteScalars: true });
+                if (tokens.has(token))
+                  continue;
+                tokens.add(token);
+                entries.push("  " + token + ': "-"');
+              }
+            const record = "{\n" + entries.join(",\n") + "\n}";
+            resources.admit("retained", record.length * 2);
+            json.push(record);
+          } else {
+            for (const tag of chosen) {
+              if (invocation.binary) {
+                const converted = tag.chunkType !== "iTXt";
+                const extent = converted ? tag.value.length * 3 : tag.raw.length;
+                resources.admit("work", extent);
+                resources.admit("output", extent);
+                if (converted)
+                  resources.admit("retained", extent);
+                await writeBytes(stdout.output, converted ? new TextEncoder().encode(tag.value) : tag.raw, context.signal);
+              } else {
+                resources.admit("work", (tag.name.length + tag.value.length) * 4);
+                const value = printable(tag.value, scalarOptions);
+                await output(invocation.style === "values" ? value + "\n" : (invocation.style === "compact" ? tag.name + ": " : tag.name.padEnd(32) + ": ") + value + "\n");
+              }
+            }
+            if (invocation.missing && !invocation.binary)
+              for (const name of invocation.tags) {
+                if (!present.has(name))
+                  await output(invocation.style === "values" ? "-\n" : (invocation.style === "compact" ? name + ": " : name.padEnd(32) + ": ") + "-\n");
+              }
+          }
+        }
+        if (invocation.json && !invocation.assignments.length)
+          await output("[" + json.join(",\n") + "]\n");
+        if (csv) {
+          await output(csv.render());
+          if (invocation.files.length > 1)
+            await output(String(read).padStart(5) + " image files read\n", true);
+        }
+        if (updated || unchanged)
+          await output(String(updated).padStart(5) + " image files updated\n");
+        if (created)
+          await output(String(created).padStart(5) + " image files created\n");
+        if (unchanged)
+          await output(String(unchanged).padStart(5) + " image files unchanged\n");
+        return { exitCode: errors ? 1 : 0 };
+      } catch (error) {
+        failed = true;
+        failure = error;
+        throw error;
+      } finally {
+        await cleanup();
+      }
+    }
+  });
+}
+var exiftoolCommand = createExiftoolCommand();
+function exiftoolCommands(options = {}) {
+  const command = createExiftoolCommand(options);
+  return { name: "exiftool", setup(host) {
+    host.commands.register(command);
+  } };
+}
+
+// packages/safe-bash-command-exiftool/dist/sdk.js
+import { createCommandArguments } from "../safe-bash-contracts/command.js";
+function createExiftoolArguments(options, engine) {
+  const resources = new Resources(engine);
+  const supported = ["files", "tags", "assignments", "format", "style", "duplicates", "missing", "numeric", "quoteScalars", "groupFamily", "overwrite", "destination"];
+  resources.admit("retained", 256);
+  for (const key in options) {
+    if (!Object.hasOwn(options, key))
+      continue;
+    resources.admit("work", key.length * 2 + supported.length);
+    resources.admit("retained", key.length * 2 + 32);
+    if (!supported.includes(key))
+      throw new TypeError("Unsupported ExifTool SDK option: " + key);
+  }
+  const count = options.files.length + (options.tags?.length ?? 0) + (options.assignments?.length ?? 0);
+  if (!Number.isSafeInteger(count) || count > 4096)
+    throw new RangeError("ExifTool argument count exceeded");
+  resources.admit("retained", 256);
+  const args = [];
+  const append = (...parts) => {
+    if (args.length >= 4096)
+      throw new RangeError("ExifTool argument count exceeded");
+    let length = 0;
+    for (const part of parts) {
+      if (typeof part !== "string")
+        throw new TypeError("ExifTool option values must be strings");
+      length += part.length;
+    }
+    resources.admit("decoded", length * 2);
+    resources.admit("retained", length * 8 + 128);
+    resources.admit("work", length * 4 + 32);
+    args.push(parts.join(""));
+  };
+  const tagName = (name, assignment) => {
+    if (typeof name !== "string")
+      throw new TypeError("ExifTool tag names must be strings");
+    resources.admit("work", name.length * 4 + 32);
+    resources.admit("retained", name.length * 4 + 64);
+    const selector = !assignment && name.endsWith("#") ? name.slice(0, -1) : name;
+    if (!exiftoolRegistry.tags.some((tag) => tag.toLowerCase() === selector.toLowerCase()) && selector !== "MissingTag" && !(assignment && selector === "all")) {
+      throw new Error("ExifTool option/tag not yet supported: " + name);
+    }
+  };
+  if (options.format !== void 0 && options.format !== "text") {
+    const flag = { json: "-j", csv: "-csv", binary: "-b" }[options.format];
+    if (!flag)
+      throw new TypeError("Unsupported ExifTool output format");
+    append(flag);
+  }
+  if (options.style !== void 0) {
+    const flag = { short: "-s", compact: "-S", values: "-s3" }[options.style];
+    if (!flag)
+      throw new TypeError("Unsupported ExifTool output style");
+    append(flag);
+  }
+  if (options.duplicates)
+    append("-a");
+  if (options.missing)
+    append("-f");
+  if (options.numeric)
+    append("-n");
+  if (options.quoteScalars) {
+    append("-api");
+    append("StructFormat=JSONQ");
+  }
+  if (options.groupFamily !== void 0) {
+    if (options.groupFamily !== 4)
+      throw new TypeError("Unsupported ExifTool group family");
+    append("-G4");
+  }
+  if (options.overwrite !== void 0 && options.overwrite !== "backup") {
+    const flag = { replace: "-overwrite_original", "in-place": "-overwrite_original_in_place" }[options.overwrite];
+    if (!flag)
+      throw new TypeError("Unsupported ExifTool overwrite policy");
+    append(flag);
+  }
+  if (options.destination !== void 0) {
+    append("-o");
+    append(options.destination);
+  }
+  for (const tag of options.tags ?? []) {
+    tagName(tag, false);
+    append("-", tag);
+  }
+  for (const assignment of options.assignments ?? []) {
+    tagName(assignment.name, true);
+    const suffix = { set: "=", remove: "-=", add: "+=" }[assignment.operation];
+    if (!suffix)
+      throw new TypeError("Unsupported ExifTool assignment operation");
+    append("-", assignment.name, suffix, assignment.value);
+  }
+  append("--");
+  for (const file of options.files)
+    append(file);
+  resources.admit("retained", args.length * 128);
+  resources.admit("work", resources.usage.decoded * 4 + args.length * 64);
+  parseArguments(args, resources.limits);
+  return createCommandArguments(args, {
+    assertOpen() {
+      engine.signal.throwIfAborted();
+    },
+    reserve(bytes, slots) {
+      resources.admit("retained", bytes + slots * 16);
+      return { commit() {
+      }, release() {
+      } };
+    }
+  });
+}
+export {
+  createExiftoolArguments,
+  createExiftoolCommand,
+  editPng,
+  encodeJsonScalar,
+  exiftoolCommand,
+  exiftoolCommands,
+  exiftoolLimits,
+  exiftoolRegistry,
+  inspectPng,
+  printable
+};
+//# sourceMappingURL=index.js.map