@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,2849 @@
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { contextData } from "../../safe-bash-docx-engine/model-context.js";
+
+// packages/safe-bash-command-docx/src/discovery.ts
+import { packUriBatchActions } from "../../safe-bash-docx-engine/pack-uri-batch-operations.js";
+import { inspectDocument } from "../../safe-bash-docx-engine/inspection.js";
+import { documentBatchOperations } from "../../safe-bash-docx-engine/batch-operations.js";
+import { documentBatchResultSchema } from "../../safe-bash-docx-engine/batch-result-schema.js";
+import { packageViewBatchActions } from "../../safe-bash-docx-engine/package-view-batch-operations.js";
+import { styleModelBatchOperations as styleOperations } from "../../safe-bash-docx-engine/style-model-batch-operations.js";
+import { structureModelBatchActions } from "../../safe-bash-docx-engine/structure-model-batch-operations.js";
+import { imageBatchActions } from "../../safe-bash-docx-engine/image-batch-operations.js";
+import { styleModelOperationResultSchema } from "../../safe-bash-docx-engine/style-model-result-schema.js";
+
+// packages/safe-bash-command-docx/package.json
+var package_default = {
+  name: "safe-bash-command-docx",
+  version: "0.0.1",
+  private: true,
+  license: "MIT",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      workerd: "./dist/index.js",
+      browser: "./dist/index.js",
+      import: "./dist/index.js"
+    },
+    "./io": {
+      types: "./dist/io.d.ts",
+      workerd: "./dist/io.js",
+      browser: "./dist/io.js",
+      import: "./dist/io.js"
+    },
+    "./sdk": {
+      types: "./dist/sdk.d.ts",
+      import: "./dist/sdk.js"
+    }
+  },
+  files: [
+    "dist",
+    "LICENSE"
+  ],
+  scripts: {
+    build: "node ../../scripts/guard-package-dist.mjs && tsc",
+    typecheck: "tsc --noEmit && tsc -p tsconfig.test.json",
+    lint: "eslint src tests && npm run typecheck",
+    test: "cd ../.. && vitest run packages/safe-bash-command-docx",
+    "test:unit": "cd ../.. && vitest run packages/safe-bash-command-docx"
+  },
+  dependencies: {},
+  devDependencies: {
+    "safe-bash-contracts": "*",
+    "@poe-code/safe-fs": "*",
+    "safe-bash-docx-engine": "*",
+    "@poe-code/terminal-text": "*"
+  }
+};
+
+// packages/terminal-text/src/index.ts
+function escapeTerminalText(text) {
+  let result = "";
+  for (const character of text) {
+    const code = character.codePointAt(0);
+    if (code <= 31 || code >= 127 && code <= 159 || code === 1564 || code === 8206 || code === 8207 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297) {
+      result += `\\u${code.toString(16).padStart(4, "0")}`;
+    } else {
+      result += character;
+    }
+  }
+  return result;
+}
+
+// packages/safe-bash-command-docx/src/discovery.ts
+import { documentValidationProfile } from "../../safe-bash-docx-engine/validation.js";
+import { DocumentBudget as DocumentBudget2 } from "../../safe-bash-docx-engine/budget.js";
+
+// packages/safe-bash-command-docx/src/command.ts
+import { path, usage, schemaFor, optionFields, lowerLimits, validateDocxBatch, validateSelections, docxInvocationBudgets, validateInvocation, SourceError } from "../../safe-bash-docx-engine/invocation.js";
+import { BoundsError } from "../../safe-bash-docx-engine/model-errors.js";
+import { DocumentBudget } from "../../safe-bash-docx-engine/budget.js";
+import { ResourceLimitError } from "../../safe-bash-docx-engine/archive.js";
+import { PermissionError, asPermissionError } from "../../safe-bash-docx-engine/io-errors.js";
+import { normalizeDocxPropertyOptions } from "../../safe-bash-docx-engine/command-properties.js";
+import { DocxUsageError, decodeDocxText, parseDocxJson, docxByteLength, copyDocxBytes } from "../../safe-bash-docx-engine/argument-json.js";
+import { docxOperationSchemas, assertDocxFields, validateDocxValue } from "../../safe-bash-docx-engine/operation-schema.js";
+import { SourceError as SourceError2, validateDocxInvocation, validateDocxBatch as validateDocxBatch2, docxInvocationBudgets as docxInvocationBudgets2 } from "../../safe-bash-docx-engine/invocation.js";
+var switches = /* @__PURE__ */ new Set(["json", "inPlace", "force", "dryRun", "allowEmpty", "allowPartialOutput", "first", "all", "raw", "pretty", "unique", "shared", "before", "deleteContent", "trackChanges"]);
+var sourceFields = /* @__PURE__ */ new Set(["file", "fallback", "template", "contentFile", "dataFile", "opsFile"]);
+var errorContexts = /* @__PURE__ */ new WeakMap();
+function direct(id) {
+  return Object.hasOwn(docxOperationSchemas, id) && schemaFor(id).transport !== "typed-batch";
+}
+function kebab(key) {
+  return [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("");
+}
+function decimal(value) {
+  if (!value || value.trim() !== value) usage("Expected finite decimal notation.");
+  let cursor = 0;
+  if (value[cursor] === "+" || value[cursor] === "-") cursor++;
+  let digits = 0;
+  while (value[cursor] !== void 0 && "0123456789".includes(value[cursor])) {
+    cursor++;
+    digits++;
+  }
+  if (value[cursor] === ".") {
+    cursor++;
+    while (value[cursor] !== void 0 && "0123456789".includes(value[cursor])) {
+      cursor++;
+      digits++;
+    }
+  }
+  if (!digits) usage("Expected finite decimal notation.");
+  if (value[cursor] === "e" || value[cursor] === "E") {
+    cursor++;
+    if (value[cursor] === "+" || value[cursor] === "-") cursor++;
+    let exponent = 0;
+    while (value[cursor] !== void 0 && "0123456789".includes(value[cursor])) {
+      cursor++;
+      exponent++;
+    }
+    if (!exponent) usage("Expected finite decimal notation.");
+  }
+  const number = Number(value);
+  if (cursor !== value.length || !Number.isFinite(number)) usage("Expected finite decimal notation.");
+  return number;
+}
+function tryParseCliLength(raw) {
+  if (typeof raw !== "string") return raw;
+  for (const unit of ["emu", "twip", "dxa", "in", "cm", "mm", "pt"]) {
+    if (raw.endsWith(unit)) {
+      const numPart = raw.slice(0, -unit.length).trim();
+      if (!numPart) return raw;
+      const num = Number(numPart);
+      if (Number.isFinite(num)) return { value: num, unit: unit === "dxa" ? "twip" : unit };
+    }
+  }
+  return raw;
+}
+var LENGTH_JSON_KEYS = /* @__PURE__ */ new Set(["width", "height", "size", "cellMargin", "rowHeight", "space", "position", "top", "right", "bottom", "left", "header", "footer", "gutter"]);
+function normalizeCliJsonLengths(value, keyHint) {
+  if (typeof value === "string") {
+    return keyHint && LENGTH_JSON_KEYS.has(keyHint) ? tryParseCliLength(value) : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => keyHint === "columnWidths" || keyHint === "columnWidthsJson" ? tryParseCliLength(item) : normalizeCliJsonLengths(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = normalizeCliJsonLengths(v, k);
+    }
+    if (keyHint === "cellMargin" && !("value" in out) && !("unit" in out)) {
+      const side = out.top ?? out.left ?? out.bottom ?? out.right;
+      if (side !== void 0) return side;
+    }
+    if (out.kind === "table" && out.repeatHeader !== void 0 && out.headerRows !== void 0) {
+      if (out.repeatHeader === true && typeof out.headerRows === "number" && out.headerRows >= 1 || out.repeatHeader === false && out.headerRows === 0) {
+        delete out.repeatHeader;
+      }
+    }
+    return out;
+  }
+  return value;
+}
+function cliValue(type, raw, name, budget) {
+  if (name.endsWith("Json")) return parseDocxJson(raw, budget);
+  const variants = type.split("|").map((s) => s.trim());
+  if (raw === "null" && variants.includes("null") && name !== "text") return null;
+  if (variants.includes("string") || type === "VfsInput" || type.startsWith("Vfs") || type === "LocationToken") return raw;
+  if (variants.includes("boolean") && (raw === "true" || raw === "false")) return raw === "true";
+  if (type.includes("Length") && type !== "Length | positive decimal multiple | null") {
+    for (const unit of ["emu", "in", "cm", "mm", "pt"]) if (raw.endsWith(unit)) return { value: decimal(raw.slice(0, -unit.length)), unit };
+    if (variants.includes("finite number") || variants.includes("number")) return decimal(raw);
+    usage("Lengths require explicit units.");
+  }
+  if (type.includes("integer") || type === "number" || type.startsWith("number ") || type.startsWith("finite ") || type.includes("fraction") || type.includes("decimal multiple")) return decimal(raw);
+  if (name === "remove") return raw.split(",");
+  if (name === "levels") {
+    const ends = raw.split("-");
+    if (ends.length !== 2) usage("Expected a level range.");
+    return { start: decimal(ends[0]), end: decimal(ends[1]) };
+  }
+  const enumType = variants.find((value) => value.startsWith("WD_") || value.startsWith("MSO_"));
+  if (enumType) return { enum: enumType, name: raw };
+  return raw;
+}
+function parseDocxArguments(args, budget = new DocumentBudget()) {
+  let operation = "";
+  let json = false;
+  try {
+    if (!Array.isArray(args) || Object.getPrototypeOf(args) !== Array.prototype || !validateDocxValue("ReadonlyArray<Uint8Array>", args)) usage("Expected literal byte arguments.");
+    const words = args.map((bytes) => {
+      budget.charge("retainedBytes", docxByteLength(bytes));
+      const word = decodeDocxText(bytes);
+      if (word.includes("\0")) usage("NUL is not permitted in arguments.");
+      return word;
+    });
+    if (words.length === 0) words.push("help");
+    if (words[0] === "--help" || words[0] === "-h") words[0] = "help";
+    if (words[0] === "--version") words[0] = "version";
+    let consumed = 0;
+    for (let count = 1; count <= words.length; count++) {
+      if (words[count - 1].includes(".")) break;
+      const candidate = words.slice(0, count).join(".");
+      if (direct(candidate)) {
+        operation = candidate;
+        consumed = count;
+      }
+      if (words[count]?.startsWith("-")) break;
+    }
+    if (words[0] === "text" && consumed === 0) {
+      operation = "text.get";
+      consumed = 1;
+    }
+    if (!operation) {
+      const valueFlags = new Set(Object.keys(docxOperationSchemas).filter((id) => !id.startsWith("model.")).map((id) => docxOperationSchemas[id]).flatMap((declaration) => Object.keys(optionFields(declaration, true)).filter((name) => !switches.has(name)).map((name) => "--" + kebab(name))));
+      valueFlags.add("-o");
+      for (let index = 1; index < words.length; index++) {
+        const word = words[index];
+        if (word === "--") break;
+        if (word === "--json") json = true;
+        if (valueFlags.has(word)) index++;
+      }
+      const replacement = (/* @__PURE__ */ new Map([
+        ["image", "images"],
+        ["table", "tables"],
+        ["metadata", "properties"],
+        ["replace", "text replace"]
+      ])).get(words[0]);
+      usage(replacement ? `Unknown document command path. Use docx ${replacement}; see docx help for commands.` : "Unknown document command path. Use docx help to discover commands.");
+    }
+    const schema = schemaFor(operation);
+    const fields = optionFields(schema, true);
+    const names = new Map(Object.keys(fields).map((key) => ["--" + kebab(key), key]));
+    if (Object.hasOwn(fields, "output")) names.set("-o", "output");
+    const options = {};
+    const inputs = [];
+    let terminated = false;
+    let help = false;
+    for (let index = consumed; index < words.length; index++) {
+      const word = words[index];
+      if (word === "--") break;
+      const equal = word.indexOf("=");
+      const name = names.get(equal < 0 ? word : word.slice(0, equal));
+      if (name === "json" && equal < 0) json = true;
+      if (name && !switches.has(name) && equal < 0) index++;
+    }
+    for (let index = consumed; index < words.length; index++) {
+      const word = words[index];
+      if (!terminated && word === "--") {
+        terminated = true;
+        continue;
+      }
+      if (!terminated && (word === "--help" || word === "-h")) {
+        if (help || operation === "version") usage("Conflicting discovery options.");
+        help = true;
+        continue;
+      }
+      if (terminated || !word.startsWith("-") || word === "-") {
+        path(word);
+        inputs.push(word);
+        continue;
+      }
+      const equal = word.indexOf("=");
+      const flag = equal < 0 ? word : word.slice(0, equal);
+      const name = names.get(flag);
+      if (!name) usage("Unknown or inapplicable document option.");
+      if (name !== "limit" && Object.hasOwn(options, name)) usage("Repeated scalar option.");
+      if (switches.has(name)) {
+        if (equal >= 0) usage("Presence switches accept no value.");
+        options[name] = true;
+        if (name === "json") json = true;
+        continue;
+      }
+      const raw = equal >= 0 ? word.slice(equal + 1) : words[++index];
+      if (raw === void 0) usage("Missing option value.");
+      if (name === "limit") {
+        const split = raw.indexOf("=");
+        if (split <= 0) usage("Expected a named limit.");
+        const key = raw.slice(0, split);
+        const limits = options.limit ?? [];
+        if (limits.some((item) => item.name === key)) usage("Repeated document limit.");
+        limits.push({ name: key, value: decimal(raw.slice(split + 1)) });
+        budget = lowerLimits(limits, budget);
+        options.limit = limits;
+      } else {
+        options[name] = name.endsWith("Json") ? raw : cliValue(fields[name].type, raw, name, budget);
+        if (!name.endsWith("Json") && !validateDocxValue(fields[name].type, options[name])) usage(`Invalid value for --${kebab(name)}. See docx help ${operation.split(".").join(" ")} for accepted values.`);
+      }
+    }
+    budget = lowerLimits(options.limit, budget);
+    for (const name of Object.keys(options)) if (name.endsWith("Json")) options[name] = normalizeCliJsonLengths(parseDocxJson(options[name], budget), name);
+    if (operation === "properties.set" && !help) Object.assign(options, normalizeDocxPropertyOptions(options, true));
+    if (operation === "help" || operation === "schema") {
+      if (inputs.some((word) => word.includes("."))) usage("Unknown discovery path.");
+      const target = inputs.join(".");
+      if (target && !direct(target) && target !== "text") usage("Unknown discovery path.");
+      if (target) {
+        const id = target === "text" ? "text.get" : target;
+        if (options.operation !== void 0 && id !== "batch" && options.operation !== id) usage("Conflicting discovery path and operation.");
+        if (options.operation === void 0) options.operation = id;
+        else if (id === "batch" && schemaFor(options.operation).transport === "direct") usage("Operation is not available in batch.");
+      }
+      if (options.operation !== void 0) schemaFor(options.operation);
+      return Object.freeze({ operation, inputs: Object.freeze([]), options: Object.freeze(options) });
+    }
+    if (help) {
+      assertDocxFields(Object.fromEntries(Object.entries(fields).map(([name, field]) => [name, { ...field, required: false }])), options, (type, value) => {
+        if (type === "BatchV1") {
+          validateDocxBatch(value, budget, { author: options.author, timestamp: options.timestamp });
+          return true;
+        }
+        return void 0;
+      });
+      if (inputs.length > Number(schema.inputArity === "0|1" ? 1 : schema.inputArity)) usage("Invalid input arity.");
+      for (const [file, json2] of [["contentFile", "contentJson"], ["dataFile", "dataJson"], ["opsFile", "opsJson"]]) if (options[file] !== void 0 && options[json2] !== void 0) usage("Conflicting JSON sources.");
+      if (options.output !== void 0 && options.inPlace === true) usage("Output and in-place conflict.");
+      if (options.raw === true && (options.json === true || options.pretty === true)) usage("Conflicting XML output modes.");
+      validateSelections(operation, options);
+      const invocation = Object.freeze({ operation: "help", inputs: Object.freeze([]), options: Object.freeze({ operation, ...options.json === true ? { json: true } : {} }) });
+      docxInvocationBudgets.set(invocation, budget);
+      return invocation;
+    }
+    for (const name of ["tabStops", "tabStopAdd", "borders", "shading", "columnWidths", "rowOptions", "wrapPolygon"]) {
+      if (options[name + "Json"] !== void 0) {
+        options[name] = options[name + "Json"];
+        delete options[name + "Json"];
+      }
+    }
+    const sources = [];
+    for (const [file, json2, semantic, type] of [["contentFile", "contentJson", "content", "OriginalDocumentContentV1"], ["dataFile", "dataJson", "data", "TemplateData"], ["opsFile", "opsJson", "operations", "BatchV1"]]) {
+      if (options[file] !== void 0 && options[json2] !== void 0) usage("Conflicting JSON sources.");
+      if (options[json2] !== void 0) {
+        if (type === "BatchV1") Object.assign(options, validateDocxBatch(options[json2], budget, { author: options.author, timestamp: options.timestamp }));
+        else options[semantic] = options[json2];
+        delete options[json2];
+      }
+      if (options[file] !== void 0) {
+        const source = options[file];
+        path(source);
+        sources.push({ argument: semantic, path: source, format: "json", type: type === "BatchV1" ? type : schema.sdkFields[semantic].type });
+        delete options[file];
+      }
+    }
+    for (const field of sourceFields) if (options[field] !== void 0) {
+      const source = options[field];
+      path(source);
+      sources.push({ argument: field, path: source, format: "binary", type: "BinaryInput" });
+      options[field] = { kind: "vfs", path: source, capability: "command" };
+    }
+    return validateInvocation({ operation, inputs, options, sources }, budget, true);
+  } catch (error) {
+    if (error instanceof Error) errorContexts.set(error, { operation: operation || "help", json, budget });
+    throw error;
+  }
+}
+function createDocxCommandEngine(handler, hostLimits = {}) {
+  return {
+    async execute(request) {
+      if (request.signal.aborted) return { exitCode: 130 };
+      let invocation;
+      let budget = new DocumentBudget(hostLimits, request.signal);
+      let discoveryOutput;
+      try {
+        invocation = parseDocxArguments(request.args, budget);
+        budget = docxInvocationBudgets.get(invocation) ?? lowerLimits(invocation.options.limit, budget);
+        const discovery = schemaFor(invocation.operation).discovery ? getDocxDiscovery(invocation, budget) : void 0;
+        if (discovery) {
+          const output = invocation.options.json === true || invocation.operation === "schema" ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data: discovery.data, warnings: [], errors: [], affected: 0, locations: [] }) + "\n" : discovery.human;
+          discoveryOutput = new TextEncoder().encode(output);
+          budget.check("serializedOutput", discoveryOutput.byteLength);
+        }
+        const options = { ...invocation.options };
+        const sources = invocation.sources ?? [];
+        for (const source of sources) {
+          if (source.format !== "json") continue;
+          let bytes;
+          try {
+            if (source.path === "-") {
+              const chunks = [];
+              let size = 0;
+              for await (const chunk of request.stdin) {
+                request.signal.throwIfAborted();
+                size += docxByteLength(chunk);
+                budget.check("xmlPartBytes", size);
+                budget.charge("retainedBytes", docxByteLength(chunk));
+                chunks.push(copyDocxBytes(chunk));
+              }
+              budget.charge("retainedBytes", size);
+              bytes = new Uint8Array(size);
+              let offset = 0;
+              for (const chunk of chunks) {
+                bytes.set(chunk, offset);
+                offset += chunk.byteLength;
+              }
+            } else {
+              if (!handler.readSource) throw new SourceError();
+              bytes = await handler.readSource(source, request, budget);
+              request.signal.throwIfAborted();
+            }
+          } catch (error) {
+            request.signal.throwIfAborted();
+            if (error instanceof ResourceLimitError || error instanceof DocxUsageError) throw error;
+            throw asPermissionError(error) ?? new SourceError(error);
+          }
+          const value = parseDocxJson(bytes, budget);
+          if (source.type === "BatchV1") Object.assign(options, validateDocxBatch(value, budget, { author: options.author, timestamp: options.timestamp }));
+          else options[source.argument] = value;
+        }
+        if (invocation.operation === "batch" && sources.filter((source) => source.path === "-").length + invocation.inputs.filter((input) => input === "-").length > 1) usage("Only one stdin consumer is permitted.");
+        if (sources.some((source) => source.format === "json")) invocation = validateInvocation({ ...invocation, options, sources: sources.filter((source) => source.format !== "json") }, budget, true);
+      } catch (error) {
+        if (request.signal.aborted) return { exitCode: 130 };
+        if (!(error instanceof DocxUsageError) && !(error instanceof BoundsError) && !(error instanceof ResourceLimitError) && !(error instanceof SourceError) && !(error instanceof PermissionError)) throw error;
+        const context = errorContexts.get(error) ?? { operation: invocation?.operation ?? "help", json: invocation?.options.json === true, budget };
+        const code = error instanceof BoundsError ? error.code : error instanceof ResourceLimitError ? "limit-exceeded" : error instanceof PermissionError ? "permission" : error instanceof SourceError ? "source-failure" : "usage";
+        const diagnostic = commandDiagnostic(error.message, code, context.budget.limits.diagnosticBytes);
+        try {
+          if (context.json || context.operation === "schema") await request.stdout.write(new TextEncoder().encode(JSON.stringify({ version: 1, operation: context.operation, ok: false, data: null, warnings: [], errors: [{ code, message: diagnostic.message, ..."operationIndex" in error ? { operationIndex: error.operationIndex } : {} }], affected: 0, locations: [] }) + "\n"));
+          if (request.signal.aborted) return { exitCode: 130 };
+          await request.stderr.write(new TextEncoder().encode(diagnostic.human));
+        } catch (transportError) {
+          if (request.signal.aborted) return { exitCode: 130 };
+          throw transportError;
+        }
+        if (request.signal.aborted) return { exitCode: 130 };
+        return { exitCode: context.operation === "diff" ? 2 : error instanceof BoundsError ? 1 : error instanceof ResourceLimitError ? 4 : error instanceof SourceError || error instanceof PermissionError ? 3 : 2 };
+      }
+      if (discoveryOutput) {
+        if (request.signal.aborted) return { exitCode: 130 };
+        try {
+          await request.stdout.write(discoveryOutput);
+        } catch (error) {
+          if (request.signal.aborted) return { exitCode: 130 };
+          throw error;
+        }
+        return { exitCode: request.signal.aborted ? 130 : 0 };
+      }
+      return handler.execute(invocation, request);
+    }
+  };
+}
+function commandDiagnostic(source, code, limit) {
+  if (code === "stale-selection" && source === "Document operation failed: " + code)
+    source += ". Inspect the input again and select a fresh location.";
+  if (code === "ambiguous-selection" && source === "Document operation failed: " + code)
+    source += ". Inspect the input and choose an unambiguous owner or location.";
+  if (code === "conflict" && source === "Document operation failed: " + code)
+    source += ". Review the input and destination before retrying. Choose a new output path, or use --in-place only for intentional input replacement.";
+  const encoder = new TextEncoder();
+  const prefix = limit >= 8 ? "docx: " : "";
+  const suffix = limit >= 2 ? "\n" : "";
+  const jsonOverhead = encoder.encode(JSON.stringify([{ code, message: "" }])).byteLength;
+  const capacity = Math.max(1, limit - Math.max(prefix.length + suffix.length, jsonOverhead));
+  const marker = capacity >= 12 ? " [truncated]" : ".";
+  const pieces = [];
+  let size = 0;
+  let truncated = false;
+  for (const raw of source) {
+    const human = escapeTerminalText(raw);
+    const width = Math.max(encoder.encode(human).byteLength, encoder.encode(JSON.stringify(raw)).byteLength - 2);
+    if (width > capacity - size) {
+      truncated = true;
+      break;
+    }
+    pieces.push({ raw, human, size: width });
+    size += width;
+  }
+  if (truncated) {
+    while (pieces.length && size + marker.length > capacity) size -= pieces.pop().size;
+  }
+  const ending = truncated ? marker : "";
+  return {
+    message: pieces.map((piece) => piece.raw).join("") + ending,
+    human: prefix + pieces.map((piece) => piece.human).join("") + ending + suffix
+  };
+}
+
+// packages/safe-bash-command-docx/src/discovery.ts
+import { docxCommonOptions, docxOperationSchemas as docxOperationSchemas2 } from "../../safe-bash-docx-engine/operation-schema.js";
+import { getDocxOperationSchema } from "../../safe-bash-docx-engine/operation-json-schema.js";
+import { archivePackingContract, archiveExtractionContract, discoveryFailureSchema, objectOperationContracts, equationOperationContracts, diagramOperationContracts, chartOperationContracts, shapeOperationContracts, imageLayoutOperationContracts, imageOperationContracts, inspectionOperationMetadata, propertyOperationContracts, rasterInsertionOperationContracts, rasterReplacementOperationContracts } from "../../safe-bash-docx-engine/discovery-result-schema.js";
+var styleModelBatchOperations = [...styleOperations, ...structureModelBatchActions.keys()];
+function operationSupport(id, declaration) {
+  const supported = imageBatchActions.has(id) || styleModelBatchOperations.includes(id) || id === "batch" || objectOperationContracts[id] || equationOperationContracts[id] || diagramOperationContracts[id] || chartOperationContracts[id] || shapeOperationContracts[id] || inspectionOperationMetadata[id] || imageOperationContracts[id] || rasterInsertionOperationContracts[id] || rasterReplacementOperationContracts[id] || imageLayoutOperationContracts[id] || propertyOperationContracts[id] || declaration.discovery || id === "extract" || id === "pack";
+  return supported ? declaration.mutates ? "edit" : "read" : "reject";
+}
+function commandPath(id, declaration) {
+  return declaration.transport === "typed-batch" ? ["batch"] : id.split(".");
+}
+function usage2(id, declaration) {
+  const path2 = commandPath(id, declaration).join(" ");
+  const input = declaration.transport === "typed-batch" ? " INPUT" : declaration.profile === "discovery" && Object.hasOwn(declaration.fields, "operation") ? " [COMMAND PATH]" : declaration.inputArity === "0|1" ? " [INPUT]" : declaration.inputArity === 2 ? " LEFT RIGHT" : declaration.inputArity === 1 ? id === "pack" ? " INVENTORY" : " INPUT" : "";
+  return `docx ${path2}${input} [OPTIONS]`;
+}
+function description(declaration) {
+  const id = Object.keys(docxOperationSchemas2).find((key) => docxOperationSchemas2[key] === declaration);
+  if (id === "batch") return "Execute admitted ordered utility operations against staged document state with one publication; retain the separate style, font, paragraph-format, tab, bounded XML, package/part/resource, immutable Image, immutable package URI and live table/section/review batch subsets. Other model operations remain unsupported.";
+  if (packUriBatchActions.has(id)) return "Read a checked immutable package URI value through invocation-local batch handles without document mutation authority.";
+  if (imageBatchActions.has(id)) return "Read an immutable Image value through invocation-local batch handles without document mutation authority.";
+  if (id.startsWith("model.XmlElementView.")) return "Bounded live XML traversal and structured mutation with shared owner budgets and guarded publication.";
+  if (id === "model.parts.numbering.NumberingPart.new.call" || id === "model.parts.document.DocumentPart.numbering_part.get") return "Create and attach an empty numbering part to the admitted document owner, or reuse its valid existing part unchanged. Returns a live NumberingPart handle; all graph changes stage together under shared budgets and publication rules.";
+  if (packageViewBatchActions.has(id)) return "Live package, part and resource views with owned values, inert external targets and validated graph edits.";
+  if (structureModelBatchActions.has(id)) return "Implemented live table, section and review operation with checked document-owned receivers and typed values.";
+  if (styleModelBatchOperations.includes(id)) return "Implemented style model operation with checked document-owned receivers and typed values.";
+  return (id === "pack" ? archivePackingContract.description : id === "extract" ? archiveExtractionContract.description : void 0) ?? objectOperationContracts[id]?.description ?? equationOperationContracts[id]?.description ?? diagramOperationContracts[id]?.description ?? chartOperationContracts[id]?.description ?? shapeOperationContracts[id]?.description ?? inspectionOperationMetadata[id]?.description ?? imageOperationContracts[id]?.description ?? rasterInsertionOperationContracts[id]?.description ?? imageLayoutOperationContracts[id]?.description ?? rasterReplacementOperationContracts[id]?.description ?? propertyOperationContracts[id]?.description ?? declaration.discovery?.description ?? "Declared contract; document operation not implemented by this engine.";
+}
+function details(id, declaration) {
+  const lines = [
+    usage2(id, declaration),
+    "",
+    description(declaration),
+    "",
+    `Support for this operation: ${operationSupport(id, declaration)}.`,
+    "Support: edit changes only the admitted subset; read returns snapshots; preserve retains unedited bytes; reject provides no execution support.",
+    "Limits: resources are unlimited unless explicitly set with --limit NAME=VALUE; duplicate names reject. Capabilities lists effective limits.",
+    "Output: reads use stdout; --json emits one version 1 result. Diagnostics use stderr; package --output - is pure binary and conflicts with --json except dry-run.",
+    "Mutations require --output or --in-place unless --dry-run. Existing outputs require --force; aliases of input require --in-place. Dry-run publishes nothing.",
+    "Exit: 0 success; 1 document/edit/selection failure; 2 usage; 3 I/O/publication; 4 limit; 130 cancellation. Diff uses 0 equal, 1 different, 2 failed, 130 cancellation."
+  ];
+  if (id === "diff") lines.push("", "Scope defaults to package for --mode parts (default) or xml, and body for text/structure. Explicit story scopes: headers, footers, footnotes, endnotes, comments, text-boxes or all-stories.", "Text compares final logical text. Structure retains stored story XML, collapses plain run/text wrappers, and compares referenced image bytes.", "Results are bounded part-level changes. Exit: 0 equal; 1 different; 2 trouble; 130 cancellation. Only one input may use stdin (-).");
+  if (id === "batch") lines.push("", `Admitted ordered utility IDs: ${documentBatchOperations.join(", ")}.`, "Use version 1 and an ordered operations array. Optional stable IDs start with an ASCII letter and contain letters, digits, underscores or hyphens, up to 64 characters; omitted IDs use step1, step2 and so on.", "Whole-array syntax is checked before edits. Later semantic selections use staged state; a later failure discards the unpublished result. Publication and limits belong to the outer batch.", "Utility arrays and typed style/XML/package/resource/Image/package URI/table/section/review subsets use their respective executors; unsupported combinations reject.");
+  if (id === "template.apply") lines.push("", "Tags explicitly declare bindings; exact {{tag}} placeholders inside tagged text controls use the same literal fill rules.", "Ordinary brace text outside tagged controls is preserved. No expressions, callbacks or arbitrary code.", "Records have values: [{binding, value}]. Scalars use the control's declared type; native repeat tags require record arrays.", "Top-level arrays require one body repeat and no singleton bindings. Maximum four repeat levels and 1,000 records per region.", "Empty repeats retain one cleared reusable item. All schema, lock, boundary, budget and reference checks precede one publication.", "Only body templates are edited; other stories remain unchanged. Bound controls and affected unsupported structures reject.");
+  if (id === "images.set") lines.push(
+    "",
+    "Edit one existing native inline or anchor picture; --all selects distinct physical drawings atomically.",
+    "Size uses the stored unrotated extent ratio; explicit contain/cover/stretch requires both physical dimensions.",
+    "Axis frames, offsets, alignments, distances and wrapping require an admitted anchor; inline conversion is unsupported.",
+    "Tight/through wrapping requires an explicit native polygon or an admitted retained polygon; no outline is inferred.",
+    "Media bytes, relationships and coherent alternate associations remain exact; ambiguous representations reject before publication.",
+    "Use schema for the admitted utility batch operations and typed model routes."
+  );
+  if (id === "images.replace") lines.push(
+    "",
+    "Select one embedded PNG, JPEG, GIF, BMP or TIFF image occurrence by its location or owner-relative index.",
+    "Occurrence replacement clones and rebinds its resource; --shared replaces all physical owners of the resolved resource.",
+    "Preserve existing extents and crop unless resizing; explicit fit requires both physical dimensions.",
+    "Replacement paths require an explicit stream capability. Linked, alternate and fallback carriers refuse before acquisition.",
+    "Supplying fallback is unsupported. Use schema for the admitted utility batch operations and typed model routes."
+  );
+  if (id === "images.add") lines.push(
+    "",
+    "Select a whole paragraph, admitted block container, or the unique body.",
+    "Header/footer and note containers require an explicit owner.",
+    "There is no all, run, caret or range insertion.",
+    "Use explicit physical units: emu, in, cm, mm or pt. Pixels are not accepted.",
+    "Omitted dimensions use native DPI independently per axis, with 72 DPI fallback.",
+    "One dimension preserves native aspect ratio; two dimensions use contain/cover/stretch.",
+    "Decorative defaults false; true conflicts with nonempty alt text.",
+    "Known PNG/JPEG/GIF/BMP/TIFF source suffixes must match the actual bytes.",
+    "Static safe SVG requires a supplied validated PNG, JPEG, GIF, BMP or TIFF fallback; sizes and native DPI come from that fallback.",
+    "SVG and fallback paths require an explicit stream capability; only explicit CLI file/fallback dashes consume stdin.",
+    "SVG admits bounded static XML with local references only. No scripts, external references, fetching or rasterize step; no rendering parity is claimed.",
+    "Both original resources are retained exactly as one inline occurrence. A raster source with supplied fallback rejects.",
+    "Floating placement, SVG/fallback replacement and other direct raster insertion remain unsupported."
+  );
+  if (["images.add", "images.set", "images.replace"].includes(id)) lines.push("Live inline picture sizing and collection lookup are available through declared typed model routes.");
+  if (id === "pack") lines.push(
+    "",
+    "INVENTORY is a version 1 JSON path or stdin (-); no directory scan.",
+    "Records require sorted canonical part names, VFS paths, content types, byte lengths and SHA-256 hashes.",
+    "File inventories grant their directory; stdin records require explicit absolute VFS paths.",
+    "Full extraction manifests are accepted; media-only manifests reject. Update both length and hash after editing.",
+    "Symlinks, aliases, unsupported kinds, missing graph targets and output inside the input tree reject.",
+    "Retain exact payloads, kind and dialect. Output uses stored sorted entries, fixed 1980 timestamps and no comment.",
+    "One shared staged publication; --force never bypasses validation. --dry-run performs no writes.",
+    "Live package views are available through the declared typed model routes. Packing requires its own publication and cannot be nested in a batch."
+  );
+  if (id === "extract") lines.push(
+    "",
+    "Use --output-dir DIR and --allow-partial-output. The parent directory must already exist.",
+    "--selection all (default) retains all files and empty directories; media-only selects word/media/.",
+    "Default payload bytes stay exact. --pretty formats XML and relationships while retaining mixed text.",
+    "The entire namespace is validated, including excluded members, links and case/Unicode/path aliases.",
+    "Requires atomic conditional directory/file publication; read-only or unsupported VFS targets reject.",
+    "Preexisting trees always reject, including with --force. No user directory is recursively removed.",
+    "I/O or cancellation can leave partial new output; JSON and typed failures retain the publication receipt.",
+    "Live package views are available through the declared typed model routes. Extraction is a separate multiple-output operation."
+  );
+  if (id === "lorem.set") lines.push("", "Provide --seed INTEGER and --paragraph N, a text/owner token, or explicit --all inside --scope (default body).", "Words default to maximal nonempty whitespace-delimited selected logical spans per paragraph; --words overrides the count.", "Seed maps modulo 2^32; amber birch cedar delta elm fern grove heath repeat from (seed + i) modulo 8, restarting per paragraph.", "Generated text uses spaces. Retain tabs, breaks and nontext controls; distribute generated characters into existing text leaves by their original selected lengths, with the remainder in the last leaf.", "A computed zero makes no change. Explicit words can fill an admitted empty whole paragraph. Hidden-format runs follow logical text extraction, without style resolution or rendering.", "This is not anonymization: metadata, images, instructions, inactive markup and unselected text remain unchanged.", "Affected protection, opaque review, grouped shapes and shared stories reject. Generic utility batch execution and live text owners remain pending.");
+  if (id.startsWith("signatures.")) lines.push("", "Signatures are package-global; story selectors are inapplicable.", "Inventory does not verify cryptographic validity. Other mutations reject signed input.", "signatures remove is explicit consent to strip the complete signature graph; inspect its exact removal report before any subsequent edit.", "No signature regeneration or generic utility batch execution is supported.");
+  if (id === "sanitize") lines.push(
+    "",
+    "Use --remove properties,comments,revisions,links,objects; choose only needed categories.",
+    "Order: properties, comments, revisions, links, objects. No implicit scrub-all.",
+    "Revisions require --revision-policy accept|reject; policy without revisions is invalid.",
+    "Actions:",
+    "  properties: remove supported writable scalars; cached or opaque metadata remains.",
+    "  comments: remove supported bodies and markers; unsafe thread metadata rejects.",
+    "  revisions: accept/reject supported decisions; nested, move or structural review rejects.",
+    "  links: unwrap external hyperlinks preserving labels; internal anchors remain.",
+    "  objects: remove direct inert carriers without previews and unused bindings/leaf targets.",
+    "Shared targets, outgoing embedded graphs and other external binding roles remain.",
+    "Preflight all actions, edit staged bytes, validate, then publish once.",
+    "Inspect actions, record IDs, removed parts/relationships, retained categories and gaps.",
+    "No comprehensive privacy or recoverability removal is provided.",
+    "Signed/protected inputs reject. Generic utility batches and live models remain pending."
+  );
+  if (id === "settings.list") lines.push("", "Settings are package-global; story selectors are inapplicable.", "Unknown settings remain opaque; protection credentials are omitted.", "Raw xml set may change only boolean field-update intent in settings.", "No typed settings setter, rights bypass or font installation is supported.");
+  if (declaration.transport === "typed-batch") {
+    lines.push("", `Batch operation: ${id}`, `Receiver: ${declaration.receiver ?? "none"}`, "Arguments:");
+    for (const [key, field] of Object.entries(declaration.batchFields ?? {})) lines.push(`  ${key}: ${field.type}${field.required ? " (required)" : ""}`);
+  } else {
+    lines.push("", "Options:");
+    const fields = { ...Object.fromEntries(declaration.commonOptions.map((key) => [key, docxCommonOptions[key]])), ...declaration.fields };
+    for (const [key, field] of Object.entries(fields)) {
+      if (id.startsWith("tables.") && id !== "tables.add" && (["paragraph", "run", "image", "link", "control", "revision", "shape", "field", "bookmark"].includes(key) || id.split(".").length === 3 && (key === "cell" || key === "all"))) continue;
+      if (["lists.add", "lists.set", "tables.add"].includes(id) && (["run", "image", "link", "control", "revision", "shape", "field", "bookmark"].includes(key) || ["lists.add", "tables.add"].includes(id) && key === "all")) continue;
+      const flag = [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("");
+      lines.push(`  --${flag}${key === "output" ? ", -o" : ""}  ${field.type}${field.required ? " (required)" : ""}`);
+    }
+    lines.push("  --help, -h  Show help without acquiring input.");
+    if (Object.hasOwn(fields, "occurrence") && Object.hasOwn(fields, "first")) lines.push("", "Choose exactly one: --first | --all | --occurrence NUMBER.");
+    if (Object.hasOwn(fields, "output") && Object.hasOwn(fields, "inPlace")) lines.push("", "Publication: --output PATH | --in-place | --dry-run.");
+    if (id.startsWith("objects.")) lines.push("", "Without selectors object inventory is package-global; explicit selectors narrow stored physical occurrences.");
+    if (id !== "diff" && !id.startsWith("objects.") && Object.hasOwn(fields, "scope")) lines.push("", id.startsWith("notes.") && id !== "notes.add" ? id === "notes.list" ? "Scope defaults to both footnotes and endnotes; --kind or --scope narrows it." : "Selection defaults to footnotes; --kind or --scope selects the note kind." : `Scope defaults to ${id.startsWith("comments.") && id !== "comments.add" ? "comments" : id.startsWith("headers.") ? "headers" : id.startsWith("footers.") ? "footers" : "body"}; positions are one-based within their owner.`);
+    if (Object.hasOwn(fields, "select")) lines.push(["section", "paragraph", "run", "table", "cell", "image", "comment", "note", "link", "control", "revision", "shape", "field", "bookmark"].some((key) => Object.hasOwn(fields, key)) ? "Use either --select TOKEN or simple selectors; do not combine them." : "Selection: --select TOKEN.");
+    if (Object.hasOwn(fields, "select")) lines.push("Fingerprinted tokens reject when stale; simple selectors resolve against this input. Missing destructive selection rejects; empty mutation matches require --allow-empty.");
+    if (Object.hasOwn(fields, "scope")) lines.push("Scopes: body, headers, footers, footnotes, endnotes, comments, text-boxes, all-stories, subject to the operation-specific subset above. Unknown or inapplicable scopes reject; all-selection stays inside the chosen scope.");
+    if (["paragraphs.remove", "runs.remove", "tables.remove"].includes(id)) lines.push(
+      "",
+      "Use explicit whole-resource selectors or scoped --all. Cross-paragraph, story and cell ranges reject.",
+      ...id === "tables.remove" ? ["Tables containing section breaks reject."] : [
+        "Scalar ranges require fingerprinted endpoints and --markers exclude|include.",
+        "Exclude retains proof/rendered markers; include removes them at and between both endpoints.",
+        "Whole structures reject --markers. Empty ranges require --allow-empty and do not change content."
+      ],
+      "Surviving text properties, section breaks and required empty paragraphs remain.",
+      "Affected bookmarks, comments, permissions, notes, fields, revisions, graphics and opaque content reject.",
+      "All relationships and resources remain retained. Utility batches and live content models remain pending."
+    );
+    if (id === "text.replace") lines.push("", "--track-changes true requires explicit --author and --timestamp; an empty author is allowed.", "Ordinary replacement rejects author/time. Deleted text retains its formatting; insertion inherits the first match with explicit bold/italic overrides.", "Tracking preserves original/final/all text. Affected existing review, field/control and compound boundaries reject.");
+    if (["controls.list", "controls.set"].includes(id)) lines.push("", "Controls are indexed individually, including nested and unsupported kinds; ordinals are one-based inside the selected owner.", "Inspection returns stored IDs/tags/aliases, lock mode, placeholder/binding descriptors, typed values, declared choices and picture relationships.", "No controls get route is declared. Use controls bind for declared binding synchronization. Available in the ordered utility batch with the same fill/refusal profile.");
+    if (id === "controls.set") lines.push("", "Choose exactly one: --text STRING | --checked true/false | --choice VALUE | --date YYYY-MM-DD | --file PATH.", "Choose one control ordinal or whole token; use --all explicitly inside the scope. Text-range tokens do not select controls.", "Successful filling, including empty text, clears showingPlcHdr and preserves unrelated properties. Parent replacement erasing nested controls rejects.", "Selected controls and ancestors must be unlocked. Bound filling rejects; it does not detach dataBinding.", "Choices use declared values and render their labels. Checkbox glyph/font mappings must be declared.", "Dates use admitted numeric Gregorian formats and explicit en-US/en-GB or absent language; no host locale is consulted.", "Pictures replace one admitted existing internal DrawingML occurrence with bounded PNG; preserve geometry/crop/alt and shared old resources.", "Validate every all-selected candidate before staging. Kind mismatches and unsupported structures fail atomically.");
+    if (["revisions.accept", "revisions.reject"].includes(id)) lines.push("", "Choose one: --revision NUMBER in its scoped owner, a whole --select revision token, or --all inside the selected scope.", "Text-range tokens do not select revisions. No match rejects unless --allow-empty; reruns resolve against the new input.", "Validate every selected revision before mutation. Preserve unselected changes, required owners and faithful annotation/bookmark/field ranges.", "Only admitted inline text and exposed-field run/paragraph property history are editable; unsupported nested, compound, move/table/section and opaque review rejects atomically.", "Reports retain before identities; removed review tokens are not live. Available in the ordered utility batch; use schema for bounded live model routes.");
+    if (id === "revisions.add") lines.push("", "--kind insert requires --text; empty insertion requires --allow-empty.", "Insert at a collapsed paragraph/run token or append to selected paragraph/run text. --kind delete forbids --text and requires nonempty selected text.", "Provide explicit --author and UTC --timestamp. Use --all for scoped creation; affected unsafe structures reject before mutation.", "Acceptance/rejection is a separate bounded subset. Available in the ordered utility batch; use schema for bounded live model routes.");
+    if (id === "create") lines.push("", "Content: version 1 blocks; optional page, styles and theme settings for new packages.", "Defaults: DOCX, Transitional, US Letter portrait, one-inch margins and Normal style.", "Template blocks append before final section properties; kind/dialect and existing settings are retained.", "No executable templates, field evaluation, font discovery or automatic timestamps.");
+    if (id === "inspect") lines.push("", "Theme/font inventory: fontResources contains schemes, table entries, embedding bindings and reference diagnostics.", "Resolved references identify stored package slots; availability and licensing remain unknown.", "Use runs set or styles set/defaults set for typed font/theme references. Embedded font mutation is unsupported.");
+    if (id === "tables.add") lines.push(
+      "",
+      "Rows and cols are required. Default: container width, equal columns, autofit true.",
+      "Append to a story or cell; a paragraph anchor inserts after it, or use --before.",
+      "A collapsed paragraph token inserts at a Unicode caret and retains the suffix section.",
+      "--repeat-header true repeats the first row; --header-rows selects a leading count.",
+      "--content-json/--content-file supplies one typed table matching rows and cols.",
+      "Formatting may be direct or in that table; duplicate sources reject. Nested blocks retain terminal paragraphs.",
+      "Use tables set for cell values/formatting and tables rows/columns add/remove for explicit structural edits. Use tables merge/split for spans. Live table operations are available through declared typed model batches."
+    );
+    if (["tables.get", "tables.set"].includes(id)) lines.push("", "Coordinates are 1-based: --table 1 --cell B2, or an unambiguous --select TOKEN.");
+    if (id === "tables.get") lines.push("Read each physical anchor once, with logical spans, omitted slots and exact text.");
+    if (id === "tables.merge") lines.push("", "Select a table and top-left --from A1 / bottom-right --to B2 corners.", "--join paragraphs preserves rich blocks in row order; --join reject accepts only empty cells.", "Partial overlaps, omitted slots and range markers reject before publication.");
+    if (id === "tables.split") lines.push("", "Select a logical cell. Rows/cols must divide its existing merged grid slots exactly.", "--distribute anchor retains all blocks in the first cell; paragraphs requires exactly one paragraph per resulting cell.", "Covered coordinates identify the whole owner for this explicit operation.");
+    if (id === "tables.set") lines.push(
+      "Set changes values or formatting only; growth and deletion require explicit row/column operations.",
+      "Text requires a cell. Covered coordinates reject writes unless --covered owner is explicit. Fields, nested tables and opaque content reject destructive replacement."
+    );
+    if (["tables.rows.add", "tables.rows.remove", "tables.columns.add", "tables.columns.remove"].includes(id)) lines.push(
+      "",
+      "Select one table using --table or --select. Indexes are 1-based.",
+      "Add inserts before the given index; count+1 appends. Omitted add index appends.",
+      "Remove requires an existing index and leaves at least one row and column.",
+      "Insertion and column removal require an unmerged rectangular grid. Row removal through vertical spans requires --join paragraphs and preserves surviving owner content."
+    );
+    if (id.startsWith("bookmarks.")) {
+      lines.push("", "Inspect paired ranges and structural issues; markers preserve unrelated fields and annotations.");
+      if (id === "bookmarks.add") lines.push("Use --select TOKEN for a nonempty paragraph range with half-open Unicode scalar offsets.", "Obtain the range with document.range(paragraphToken, start, end); multi-run and table-cell paragraphs are supported.");
+      if (id === "bookmarks.set") lines.push("--references update rewrites supported internal links and REF/PAGEREF fields; reject refuses referenced names.");
+      if (id === "bookmarks.remove") lines.push("--references remove unwraps supported references while preserving visible results; reject refuses referenced names.");
+      lines.push("Unsupported reference structures and unsafe range boundaries reject before publication.");
+    }
+    if (["fields", "toc", "captions"].includes(id.split(".")[0])) lines.push("", "Never execute field instructions or recalculate pagination. Results are stored caches.", "Add appends to a selected paragraph. TOC defaults to levels 1-3 and update true; fields default to update false.", "Captions default to a dirty SEQ field; --static true emits label/text only. Existing sequence names require explicit --sequence reuse.", "Set preserves omitted flags and existing contents. --text replaces only the selected TOC/SEQ cache; nested outer cache replacement rejects.", "Typed instruction edits require explicit target for REF/PAGEREF/SEQ. Shared stories and live field models remain unsupported.");
+    if (id.startsWith("notes.")) {
+      lines.push("", "Note positions are one-based; stored IDs are separate from display numbering.", "Preserve document and section numbering/restart rules; no pagination or displayed-number calculation.");
+      if (id === "notes.add") lines.push("--kind is required; text defaults empty. Insert into a selected body paragraph.");
+      if (id === "notes.set") lines.push("Replacing a multiply referenced body requires --shared true. Text replacement retains required note markers.");
+      if (id === "notes.remove") lines.push("Use --reference N for one shared reference or --references all for every reference.", "Remove a body only when no references remain. Required separators survive.");
+      if (id === "notes.add" || id === "notes.remove") lines.push("--renumber preserve is the default; document-order reallocates storage IDs and updates their references.");
+    }
+    if (id.startsWith("links.")) {
+      lines.push("", "Never fetch links. External targets allow absolute https/http/mailto URLs.");
+      if (["links.add", "links.set"].includes(id)) lines.push("Use exactly one of --target URL or --bookmark NAME (an internal anchor).", id === "links.add" ? "Append --text to a selected paragraph; existing runs stay unchanged." : "Retarget the selected link; preserve label runs and formatting.");
+      if (id === "links.remove") lines.push("Unwrap the visible label by default; --delete-content explicitly deletes it.");
+      lines.push("Shared header/footer utility link edits remain pending; live hyperlink traversal is available through typed model batches.");
+    }
+    if (id === "lists.add") lines.push(
+      "",
+      "Append to the body or a selected cell; a paragraph anchor inserts after it.",
+      "Defaults: level 0, start 1, empty text. Levels are 0-8.",
+      "Without --start, a compatible anchor continues its existing list.",
+      "An explicit --start creates a separate instance, including when it is 1.",
+      "A different kind can extend an unused simple level into a mixed list.",
+      "Existing items keep their formats; other definitions create a separate list."
+    );
+    if (id === "lists.set") lines.push(
+      "",
+      "Select existing list paragraphs; --all stays inside the chosen scope.",
+      "--restart true isolates selected items; --start requires restart true.",
+      "An omitted restart start uses the level definition's starting value."
+    );
+    if (["lists.add", "lists.set"].includes(id)) lines.push(
+      "",
+      "Picture bullets and unsupported numbering schemes remain unchanged.",
+      "Edits requiring their interpretation are rejected. Model batches remain pending."
+    );
+    if (id === "xml.get") lines.push(
+      "",
+      "Select one absolute OPC name with --part; no basename or wildcard matching.",
+      "--raw is byte-exact, including BOM and encoding. Default JSON uses base64.",
+      "--pretty is UTF-8 display serialization, not byte-exact XML; existing text whitespace is retained."
+    );
+    if (id === "xml.set") lines.push(
+      "",
+      "--file supplies a complete XML document, never a fragment or expression.",
+      "Root expanded name, document kind/dialect and package references must remain valid.",
+      "Opaque content must retain its structural position and namespace context; protected/signed inputs reject."
+    );
+    if (id === "text.get") lines.push(
+      "",
+      "Alias: docx text INPUT [OPTIONS]. View defaults to final.",
+      "Hidden text is included; formatting is direct context, without style resolution.",
+      "Field instructions and drawing/equation text are omitted.",
+      "Order: body, headers, footers, footnotes, endnotes, comments, text boxes.",
+      "Shared parts appear once. Notes/comments: canonical part, then numeric ID.",
+      "Paragraph/row: LF; cell/tab: TAB; story: two LFs; page: FF; column: VT.",
+      "Cached page breaks add nothing. No extra trailing separator is appended."
+    );
+  }
+  if (documentBatchOperations.includes(id)) {
+    for (const [index, line] of lines.entries()) lines[index] = line.replaceAll("Generic utility batches", "Unregistered utility batches").replaceAll("utility batch execution", "unregistered utility batch execution").replaceAll("Utility batch", "Unregistered utility batch").replaceAll("ordered batches remain unsupported", "unregistered ordered batches remain unsupported");
+    lines.push("", "This operation supports the admitted ordered utility batch subset; later selections resolve against staged state. Use schema to discover individual typed model routes and their supported subsets.");
+  }
+  return formatDiscoveryLines(lines);
+}
+function formatDiscoveryLines(lines) {
+  const wrapped = [];
+  for (const source of lines) {
+    let line = escapeTerminalText(source);
+    const indent = line.slice(0, line.length - line.trimStart().length);
+    while (line.length > 140) {
+      const space = line.lastIndexOf(" ", 140);
+      const end = space > indent.length ? space : 140;
+      wrapped.push(line.slice(0, end));
+      line = indent + line.slice(end).trimStart();
+    }
+    wrapped.push(line);
+  }
+  return wrapped.join("\n") + "\n";
+}
+function getDocxDiscovery(invocation, budget = new DocumentBudget2()) {
+  const parsedBudget = docxInvocationBudgets2.get(invocation);
+  if (parsedBudget) budget = budget.lower(Object.fromEntries(Object.entries(budget.limits).map(([name, ceiling]) => [name, Math.min(ceiling, parsedBudget.limits[name])])), parsedBudget.signal);
+  invocation = validateDocxInvocation(invocation, budget);
+  if (!docxOperationSchemas2[invocation.operation]?.discovery || invocation.inputs.length) return void 0;
+  if (invocation.options.limit !== void 0) budget = budget.lower(Object.fromEntries(
+    invocation.options.limit.map((item) => [item.name, item.value])
+  ));
+  const bounded = (discovery) => {
+    const wire = invocation.options.json === true || invocation.operation === "schema" ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data: discovery.data, warnings: [], errors: [], affected: 0, locations: [] }) + "\n" : discovery.human;
+    const bytes = new TextEncoder().encode(wire).byteLength;
+    budget.check("serializedOutput", bytes);
+    budget.charge("retainedBytes", bytes);
+    return discovery;
+  };
+  if (invocation.operation === "version") return bounded({
+    data: { name: "docx", version: package_default.version, schemaVersion: 1 },
+    human: `docx ${escapeTerminalText(package_default.version)}
+`
+  });
+  if (invocation.operation === "capabilities") {
+    const limits = Object.entries(budget.limits).filter(([, ceiling]) => ceiling !== Infinity).map(([name, ceiling]) => ({ name, ceiling }));
+    const catalog = [
+      { id: "F01", level: "edit", subsets: [{ name: "bounded-opc", level: "edit", reason: "Bounded ZIP/OPC read and validated publication; encrypted and multi-disk packages reject. Full schema validation is not provided." }], detected: null },
+      { id: "F02", level: "edit", subsets: [{ name: "original-dialect", level: "edit", reason: "Admit Strict and Transitional dialects and edit only supported structures in the original dialect. No implicit conversion or full schema certification." }], detected: null },
+      { id: "F03", level: "edit", subsets: [{ name: "macro-free-kinds", level: "edit", reason: "Read and create original DOCX and DOTX packages with explicit kind. Macro-enabled mutations reject; suffixes do not establish package kind." }], detected: null },
+      { id: "F04", level: "preserve", subsets: [{ name: "opaque-xml-retention", level: "preserve", reason: "Namespace-aware bounded edits retain unmodified opaque XML. Recognition does not authorize semantic edits; affected unsupported structures reject." }], detected: null },
+      { id: "F05", level: "read", subsets: [{ name: "declared-compatibility-profile", level: "read", reason: "Bounded logical reads use the declared understood-namespace profile. Unselected alternate branches remain preserved; unknown MustUnderstand requirements and affected unsupported branches reject. No blanket extension support." }], detected: null },
+      { id: "F50", level: "edit", subsets: [{ name: "explicit-inventory-packing", level: "edit", reason: "Sorted authenticated VFS records, retained kind/dialect and exact opaque bytes; complete graph validation and one deterministic staged publication. No scanning or ambient files." }, { name: "exclusive-archive-extraction", level: "read", reason: "Whole namespace admission, exact all/media-only bytes and optional pretty XML into a new explicit tree; conditional VFS directory/file creation and explicit partial-output consent. No rollback or live-model claim." }], detected: null },
+      { id: "F48", level: "read", subsets: [{ name: "bounded-comparison", level: "read", reason: "Explicit package payload/XML or story text/structure scope. Both inputs share cumulative retention, XML, work and change budgets; no rendering, ID renumbering or host I/O." }], detected: null },
+      { id: "F47", level: "edit", subsets: [{ name: "record-template-filling", level: "edit", reason: "Exact tagged body control bindings, typed records and native nested rows/sections; four repeat levels, 1,000 items per region and cumulative budgets. Empty arrays retain reusable cleared prototypes. IDs and occurrence-local relationships remap before one publication; no expressions or host access. Template apply is available in the ordered utility batch. Whole model APIs remain pending." }], detected: null },
+      { id: "F46", level: "edit", subsets: [{ name: "selective-sanitization", level: "edit", reason: "Fixed-order explicit properties/comments/revisions/links/objects actions with exact effects and retained gaps; unsupported affected review/objects reject before publication. No comprehensive privacy or recoverability promise; utility batches remain unsupported." }], detected: null },
+      { id: "F45", level: "edit", subsets: [{ name: "seeded-selected-dummy-text", level: "edit", reason: "Required seed, paragraph-local original vocabulary, explicit count or whitespace-delimited logical span count; retain formatting and nontext data. Not anonymization; no time, randomness, networking or external generator. Generic utility batches and live owners remain pending." }], detected: null },
+      { id: "F44", level: "edit", subsets: [{ name: "bounded-content-removal", level: "edit", reason: "Explicit paragraph/run scalar endpoints and marker inclusion; whole paragraphs, runs and tables. Section breaks, required empty paragraphs and all resource graphs survive. Affected annotations, notes, fields, review and graphics reject; no cross-container ranges, resource garbage collection or utility batches." }], detected: null },
+      { id: "F43", level: "edit", subsets: [{ name: "signature-structure-inventory", level: "read", reason: "Exact declared OPC origin, relationship and part roles, including external metadata; cryptographic validity is unknown." }, { name: "explicit-signature-removal", level: "edit", reason: "Complete safe signature graph and content-type removal with exact reports. Default mutations reject signed input; no signature regeneration. Explicit signature removal is available in the ordered utility batch before other edits." }], detected: null },
+      { id: "F40", level: "preserve", subsets: [{ name: "inert-object-inventory-extraction", level: "read", reason: "OLE/package relationships, shape-bound previews and shared resources; exact bounded VFS payload extraction. No activation, binary decoding or linked fetch. Macro/protection state remains unknown unless declared; external targets are redacted." }], detected: null },
+      { id: "F39", level: "edit", subsets: [{ name: "physical-equation-inventory", level: "read", reason: "Package-global physical outer math units with inert stored/global properties and inactive/opaque preservation." }, { name: "bounded-equation-fragments", level: "edit", reason: "Explicit whole-paragraph append or same-root unit replacement using matching-dialect bounded fragments. Full schema, evaluation, conversion, layout, rendering, utility batch execution and live math models remain unsupported." }], detected: null },
+      { id: "F38", level: "read", subsets: [{ name: "physical-diagram-inventory", level: "read", reason: "Package-global physical role candidates and native bindings with inert graph closure, including orphan parts. Preserve-only snapshots imply no semantic editing, activation, rendering, external acquisition or live model support." }, { name: "opaque-graphics-preservation", level: "preserve", reason: "Eligible unknown graphics and extensions remain separately qualified opaque observations, including inactive alternatives. Unknown-only evidence does not establish a known diagram; utility batch execution remains unsupported." }], detected: null },
+      { id: "F37", level: "read", subsets: [{ name: "physical-chart-part-inventory", level: "read", reason: "Package-wide definitions, including unreferenced parts, with ordered plot groups, indexed string/numeric/multilevel caches and inert formula metadata. Cached freshness unknown; no active occurrence, formula engine, workbook validation or rendering claim." }, { name: "opaque-chart-preservation", level: "preserve", reason: "Extension/wrong-profile definitions remain explicitly opaque. Workbook/style/color descriptors and physical graph references stay inert; utility batch and live models are unsupported." }], detected: null },
+      { id: "F36", level: "edit", subsets: [{ name: "native-shape-inventory", level: "read", reason: "Active native, Office and VML shape/group occurrences with hierarchy, stored metadata, text-box story owners and physical section references. No rendering, geometry editing or live drawing models." }, { name: "simple-text-box-assignment", level: "edit", reason: "Whole simple admitted ungrouped box text assignment replaces run formatting and retains paragraph properties/geometry. Preserving scoped text editors reuse carrier authority. Nested/grouped, linked, opaque, multiple-body and shared-header edits reject; no implicit shared edits or utility batch execution." }], detected: null },
+      { id: "F32", level: "edit", subsets: [{ name: "inline-png-jpeg-insertion", level: "edit", reason: "Original bounded utility insertion of admitted PNG/JPEG bytes into one whole paragraph or admitted body/cell/explicit header/note block container. Native per-axis DPI with independent 72 fallback, explicit physical units, checked contain/cover/stretch and decorative/alt intent. Known suffixes must match bytes; retained exact media and capability publication. Five-format header metadata characterization does not imply insertion of GIF/BMP/TIFF. Floating authoring, SVG without a supplied fallback, pixel decoding and rendering remain unsupported. Live inline picture sizing and collection lookup are available through declared typed model routes. The separate static SVG/fallback insertion subset is qualified under F35." }, { name: "standalone-image-values", level: "read", reason: "Immutable PNG, JPEG, GIF, BMP and TIFF values with bounded headers, effective DPI, native and scaled lengths, owned bytes and compatibility SHA-1. No image-part, shape or collection authority; insertion support remains separate." }, { name: "raster-occurrence-replacement", level: "edit", reason: "Direct bounded PNG, JPEG, GIF, BMP and TIFF occurrence replacement clones and rebinds one drawing; explicit shared intent rebinds the resolved resource across physical owners. Default geometry and inactive references remain preserved. Linked/alternate/fallback replacement and unregistered utility batch execution remain pending. Declared image-part, drawing and collection model routes are available." }], detected: null },
+      { id: "F31", level: "read", subsets: [{ name: "image-inventory-extraction", level: "read", reason: "Bounded selected occurrence/resource inventory and exact original-byte VFS extraction with explicit manifest-inclusive publication intent. Unknown geometry/media stays null or opaque preserve-only; linked resources remain inert. No pixel decoding, DPI/native-size, rendering, live model or full image parity." }], detected: null },
+      { id: "F33", level: "edit", subsets: [{ name: "stored-image-layout", level: "read", reason: "Read admitted native extents, crop, rotation, flips, wrap, z-order, separate axis positions and alt/decorative metadata. Unsupported or invalid metadata stays null with warnings; no rendering is inferred." }, { name: "native-picture-layout", level: "edit", reason: "Direct bounded edits of coherent existing native picture extents, crop, transform, aspect locks and metadata; admitted anchors support separate axis frames, offsets or alignments, distances, stacking and explicit wrapping polygons. Exact media, relationships and admitted coherent alternate associations are preserved. Inline conversion and rendering remain unsupported. Live inline picture sizing and collection lookup are available through declared typed model routes." }], detected: null },
+      { id: "F34", level: "read", subsets: [{ name: "inert-image-alternatives", level: "read", reason: "Selected core-v1 carrier references and exact admitted internal alternate/fallback bytes; raw selected VML remains preserve-only. Inactive MCE evidence stays preserved; no Choice activation, unsupported decoding or external acquisition." }], detected: null },
+      { id: "F35", level: "edit", subsets: [{ name: "shared-image-owners", level: "read", reason: "Occurrence-local geometry and exact selected-owner references remain distinct from shared byte hashes. Unique groups after selection with first selected representative and no null-hash grouping; Live shared-image models remain pending." }, { name: "explicit-shared-raster-replacement", level: "edit", reason: "Explicit direct replacement targets the resolved internal resource across owner-local relationships, preserving geometry and reporting each physical owner. Filename and byte-hash equality never establish shared identity. Utility batch and live model execution remain pending." }, { name: "static-svg-fallback-insertion", level: "edit", reason: "Direct inline insertion of bounded static safe SVG XML with explicitly supplied validated PNG, JPEG, GIF, BMP or TIFF fallback. Fallback pixel dimensions and per-axis DPI supply native geometry; original SVG/fallback bytes, distinct media parts and owner-local relationships form one coherent occurrence. No fetching, rasterization, pixel decoding, MCE activation or rendering parity. Floating insertion and SVG/fallback replacement remain unsupported. Live inline picture sizing and collection lookup are available through declared typed model routes." }], detected: null },
+      { id: "F30", level: "edit", subsets: [{ name: "typed-document-properties", level: "edit", reason: "Read and explicitly set/remove admitted core, extended and custom scalar metadata. Exact qualified or unambiguous stored names; UTC whole-second utility strings and retained custom variants/IDs. Missing-part creation is explicit and collision-safe. Cached, opaque, invalid and ambiguous metadata stays read/preserve-only; unrelated timestamps, counts and XML remain unchanged. Live CoreProperties reads and setters also support typed model batches with explicit metadata for part creation. No automatic clocks, recalculation or corpus conformance claim." }], detected: null },
+      { id: "F28", level: "edit", subsets: [{ name: "control-values", level: "edit", reason: "Bounded plain/rich scalar text, declared checkbox glyphs, stored choice values, numeric Gregorian dates and existing internal PNG picture replacement. Indexed nested/unsupported controls remain inspected. Locked or bound filling, parent replacement erasing nested controls and unsupported affected structures reject atomically. Declared binding synchronization uses the separate controls bind route. Live model owners and ordered batches remain unsupported." }], detected: null },
+      { id: "F29", level: "edit", subsets: [{ name: "native-repetition", level: "edit", reason: "Bounded native block and unmerged grid-row repetition from exact scalar records, including empty reusable placeholders. Remap contained IDs, bookmarks, classic comments and admitted inline PNG drawings while retaining shared media. Affected bindings, locks, review, opaque structures and crossing ownership reject. Template apply, live owners and ordered batches remain pending." }, { name: "binding-synchronization", level: "edit", reason: "Declared tag keys identify one internal custom XML singleton and all complete scoped recipients, including aliases. Root-inclusive namespace-resolved child paths and explicit string/boolean/integer/double types preserve false, zero and empty values. Unresolved same-store recipients, incomplete scope, ambiguity and locks reject before publication. No binding detachment or resource fetch." }], detected: null },
+      { id: "F26", level: "edit", subsets: [{ name: "revision-decisions", level: "edit", reason: "Direct acceptance/rejection of ordinary inline text wrappers and supported exposed-field run/paragraph property history. Scoped ordinal, whole revision token or explicit all; validate every selected candidate before edits, preserving unselected review and required owners. Nested/compound/move/table/section/opaque review and affected field/control/range boundaries reject. Available in the ordered utility batch; use schema for bounded live model routes." }, { name: "tracked-text-creation", level: "edit", reason: "Explicit-author/time insertion, deletion and literal replacement on admitted scalar text ranges. Preserve original/final/all views and run properties; affected existing review and compound boundaries reject. Acceptance/rejection is a separate bounded subset; available in the ordered utility batch; use schema for bounded live model routes." }, { name: "revision-read-views", level: "read", reason: "Final/original/all text and run/paragraph property snapshots; IDs, authors and stored timestamps. Ordinary unrelated edits preserve review markup. Tracked creation and acceptance/rejection are separately bounded editing subsets." }], detected: null },
+      { id: "F27", level: "read", subsets: [{ name: "complex-revision-inventory", level: "read", reason: "Move wrappers/range markers and opaque table, section and extension revisions; affected complex edits reject." }], detected: null },
+      { id: "F25", level: "edit", subsets: [{ name: "classic-comments", level: "edit", reason: "Explicit author/time and run-boundary anchors in admitted body, footnote and endnote stories; utility shared-note occurrences, header/footer and nested-comment anchors reject. List/get/set/remove comments preserve unrelated annotations. Declared live comment owners and typed comment model batches support the bounded rich-content operations listed by schema." }, { name: "comment-extension-synchronization", level: "edit", reason: "Inventories extension parts and IDs; single-paragraph text edits retain thread links and resolution. Removal synchronizes verified IDs and people; surviving replies, opaque affected metadata and unverified structures reject. Thread authoring remains unsupported." }], detected: null },
+      { id: "F24", level: "edit", subsets: [{ name: "footnotes-endnotes", level: "edit", reason: "Read, insert, edit and remove notes and references with reserved separator preservation, scoped IDs and explicit shared-reference policies. Document and section numbering/restart rules remain intact; storage renumbering does not calculate pagination or displayed numbers. Live document model remains pending." }], detected: null },
+      { id: "F23", level: "edit", subsets: [{ name: "toc-caption-structures", level: "edit", reason: "Bounded TOC levels, inert caption sequences and static labels. Explicit cached text and dirty flags; no layout or sequence evaluation. Existing sequence collisions require explicit reuse." }], detected: null },
+      { id: "F22", level: "edit", subsets: [{ name: "cached-fields", level: "edit", reason: "List simple, complex and nested fields; edit supported plain cached results without execution. Preserve instructions, formatting and omitted flags. Create bounded fields and edit typed instructions. Nested-result replacement, shared-story editing and live model remain pending." }], detected: null },
+      { id: "F21", level: "edit", subsets: [{ name: "bookmark-ranges", level: "edit", reason: "List, create, rename and remove checked ranges; explicit reference policy for internal links and REF/PAGEREF fields. Multi-run paragraph and table-cell boundaries; stale, missing, duplicate and crossing structures checked. Complex reference removal, shared-story edits and general field/model APIs remain unsupported." }, { name: "hyperlinks", level: "edit", reason: "Create, list, retarget and unwrap direct paragraph hyperlinks; explicit label deletion. Inert HTTP/HTTPS/mailto and internal anchors, owner-scoped relationship cleanup. Shared story edits remain pending. Declared live hyperlink getters expose stored values through typed model routes." }], detected: null },
+      { id: "F20", level: "edit", subsets: [{ name: "logical-grid", level: "edit", reason: "Inspect logical owners and spans. Explicit rectangular merges join blocks in row order; split restores existing grid slots with anchor or paragraph distribution. Covered writes require owner intent. Row deletion preserves surviving spans. Omitted/wrapped grids, legacy merges and span insertion/column removal remain unsupported." }], detected: null },
+      { id: "F19", level: "edit", subsets: [{ name: "table-construction", level: "edit", reason: "Bounded rectangular grids, nested typed blocks, repeated leading headers, borders/shading, margins and row height/splitting. Selected cell values and table/row/cell formatting, explicit rectangular row/column insertion and deletion. Merged grids support explicit merge/split and row removal; omitted grids remain readable. Span insertion and column removal remain pending. Live table, row and cell owners are available through declared typed model routes." }], detected: null },
+      { id: "F18", level: "edit", subsets: [{ name: "multilevel-numbering", level: "edit", reason: "Bounded list add/set, levels 0-8, scoped IDs and start/restart overrides; resolve paragraph and numbering style links. Preserve mixed levels and unrelated opaque schemes/picture resources. Advanced level-definition setters and whole numbering-model coverage remain pending." }, { name: "owned-numbering-part-creation", level: "edit", reason: "Synchronous NumberingPart.new(ownerPackage) and missing-part getter creation return an attached live part with its dialect, content type and internal relationship staged together. Reuse preserves existing definitions; explicit creation validates the graph. Typed batch handles share owner budgets, rollback and one publication." }], detected: null },
+      { id: "F17", level: "edit", subsets: [{ name: "header-footer-stories", level: "edit", reason: "Noncreating reads of every variant; explicit shared edits, local clone/rebind and removal. Preserve cached fields and outgoing resources; scoped paragraph/text operations reuse story ownership. Whole-story text rejects fields, tables and opaque blocks. Declared live header/footer owners expose their bounded paragraph and table operations through typed model routes." }], detected: null },
+      { id: "F16", level: "edit", subsets: [{ name: "section-page-settings", level: "edit", reason: "Edit owner-local geometry, columns, section starts, page-number and first-page metadata; append sections and inventory inherited header/footer bindings. Even/odd policy is document-wide and requires explicit all-section scope. No pagination claim." }], detected: null },
+      { id: "F41", level: "preserve", subsets: [{ name: "package-resource-inventories", level: "read", reason: "Package-global customXML and glossary metadata, whole-part locations, ancillary closure and inert external references. Missing or ambiguous metadata remains preserved with bounded warnings; no content dump, import, schema fetch or semantic editing." }, { name: "opaque-package-retention", level: "preserve", reason: "Retain unedited ancillary payloads and relationship XML across admitted mutations. Bound raw replacements and unsupported same-store recipients reject rather than detach or partially synchronize." }], detected: null },
+      { id: "F42", level: "read", subsets: [{ name: "settings-and-protection", level: "read", reason: "Package-global stored settings, compatibility, field-update and font embedding flags; credential-free protection state. Only raw boolean field-update intent is editable. Protected packages and changed locked controls reject; unchanged locked owners survive scoped text replacement. Unknown settings remain preserved; no rights bypass, password verification or font installation." }, { name: "theme-and-font-resources", level: "read", reason: "Inspect theme colors, major/minor/script fonts, font tables, embedding metadata and reference diagnostics. Preserve embedded bytes and language metadata; embedded font mutation is unsupported. No installation, availability, licensing or rasterization inference." }], detected: null },
+      { id: "F15", level: "edit", subsets: [{ name: "title-and-heading-creation", level: "edit", reason: "Level 0 creates Title; levels 1-9 create paragraph headings through creation and paragraph insertion. Deterministic style IDs preserve conflicting user definitions and reuse compatible built-ins. Heading creation is also available through the typed Document.add_heading model route." }], detected: null },
+      { id: "F14", level: "edit", subsets: [{ name: "style-definitions", level: "edit", reason: "Paragraph, character and table styles; defaults, inheritance, linked styles and heading definitions. Latent defaults and individual visibility, priority, locking and gallery metadata are editable. Live style collections, inherited font/paragraph objects, latent entries and owned typed batches are implemented; use schema for implemented document content model operations and their supported subsets." }], detected: null },
+      { id: "F13", level: "edit", subsets: [{ name: "paragraph-editing", level: "edit", reason: "Direct paragraph properties and whole text; block and inline caret insertion with suffix retention. Explicit breaks, sorted tab stops, border sides and shading; style-owned paragraph model handles are implemented." }], detected: null },
+      { id: "F12", level: "edit", subsets: [{ name: "bounded-ordered-utility-batch", level: "edit", reason: `F47: Version 1 ordered typed operations with stable IDs, whole-array syntax admission, staged selections, shared budgets, final validation and one publication. Admitted IDs: ${documentBatchOperations.join(", ")}. Use schema to discover individual typed model routes and their supported subsets.` }, { name: "scoped-direct-run-formatting", level: "edit", reason: "Whole-run text assignment retains owning formatting; run or paragraph scalar ranges accept formatting only. Nullable direct properties, explicit font/theme references and half-point sizes. No style resolution, font loading or whole document model execution." }], detected: null },
+      { id: "F11", level: "edit", subsets: [{ name: "structured-creation", level: "edit", reason: "DOCX/DOTX, Strict/Transitional; original paragraphs/tables and explicit new-package settings; append-only supplied templates." }], detected: null },
+      { id: "F06", level: "read", subsets: [{ name: "inventory", level: "read", reason: "No rendering, linked-resource access or signature verification." }], detected: null },
+      { id: "F49", level: "read", subsets: [{ name: "core-v1", level: "read", reason: "Partial core-v1 validation only." }], detected: null },
+      { id: "F08", level: "read", subsets: [{ name: "logical-story-text", level: "read", reason: "Explicit story scopes and review views; hidden text included, cached field results only; no drawing/equation text or rendering." }], detected: null },
+      { id: "F09", level: "read", subsets: [{ name: "logical-unicode", level: "read", reason: "Unicode order and direct language/RTL/font properties; no shaping or style cascade." }], detected: null },
+      { id: "F07", level: "edit", subsets: [{ name: "explicit-xml-part", level: "edit", reason: "Validated whole-part replacement; immutable opaque content, no protection bypass; raw bytes or bounded display serialization." }], detected: null },
+      { id: "F10", level: "edit", subsets: [{ name: "literal-paragraph-text", level: "edit", reason: "Nonoverlapping original-text matches, run formatting preservation, explicit cardinality and bold/italic overrides; structural barriers, protected and shared parts guarded." }], detected: null }
+    ];
+    const data2 = { input: null, features: catalog.map((feature) => ({ ...feature, operationIds: Object.entries(docxOperationSchemas2).filter(([, declaration]) => declaration.featureIds.includes(feature.id)).map(([id]) => id) })), host: { read: false, atomicReplace: false, transactions: false, binaryStdout: true }, limits, validationProfiles: [documentValidationProfile] };
+    return bounded({ data: data2, human: capabilitiesHelp(data2) });
+  }
+  const selected = invocation.options.operation;
+  const declarations = selected ? [[selected, docxOperationSchemas2[selected]]] : Object.entries(docxOperationSchemas2);
+  if (invocation.operation === "help") {
+    const data2 = { name: "docx", paths: declarations.map(([id, declaration]) => ({
+      path: commandPath(id, declaration),
+      usage: usage2(id, declaration),
+      description: description(declaration),
+      operationIds: [id]
+    })) };
+    return bounded({ data: data2, human: selected ? details(selected, declarations[0][1]) : formatDiscoveryLines([
+      "docx \u2014 document utility",
+      "",
+      "Common tasks:",
+      "  docx create -o empty.docx",
+      "  docx text INPUT",
+      "  docx text replace INPUT --find Draft --with Final --all -o final.docx",
+      "  docx images list INPUT",
+      "  docx images replace INPUT --image 1 --file emblem.png --in-place",
+      "  docx tables set INPUT --table 1 --cell B2 --text Harbor --in-place",
+      "  docx properties set INPUT --name title --value 'Coastal caf\xE9' --in-place",
+      "",
+      "Use docx help COMMAND PATH for options, selectors and supported subsets; for example docx help images replace.",
+      "Mutations require --output or --in-place unless --dry-run. Positions are one-based; --select uses a fresh fingerprinted location.",
+      "",
+      "Implemented commands and declared unsupported contracts (read/edit/reject):",
+      ...declarations.filter(([, declaration]) => declaration.transport !== "typed-batch").map(([id, declaration]) => `  ${usage2(id, declaration)} [${operationSupport(id, declaration)}]`),
+      "",
+      "Use docx help batch --operation ID for every typed model declaration; schema enumerates all declarations.",
+      "Edit/read labels cover only admitted subsets. Reject labels are declared contracts without execution support.",
+      "Aliases: --help, -h; --version."
+    ]) });
+  }
+  const data = { schemaVersion: 1, validationProfiles: [documentValidationProfile], operations: declarations.map(([id, declaration]) => ({
+    id,
+    path: commandPath(id, declaration),
+    input: getDocxOperationSchema(id, declaration.transport === "typed-batch" ? "batch" : "sdk"),
+    result: id === "pack" ? archivePackingContract.result : id === "extract" ? archiveExtractionContract.result : id === "batch" ? documentBatchResultSchema() : styleModelBatchOperations.includes(id) ? styleModelOperationResultSchema(id) : objectOperationContracts[id]?.result ?? equationOperationContracts[id]?.result ?? diagramOperationContracts[id]?.result ?? chartOperationContracts[id]?.result ?? shapeOperationContracts[id]?.result ?? inspectionOperationMetadata[id]?.result ?? imageOperationContracts[id]?.result ?? rasterInsertionOperationContracts[id]?.result ?? imageLayoutOperationContracts[id]?.result ?? rasterReplacementOperationContracts[id]?.result ?? propertyOperationContracts[id]?.result ?? declaration.discovery?.result ?? { ...discoveryFailureSchema(id), description: "Only failures are specified here; operation not implemented." },
+    featureIds: declaration.featureIds,
+    support: operationSupport(id, declaration)
+  })) };
+  return bounded({ data, human: JSON.stringify(data) + "\n" });
+}
+async function inspectDocxCapabilities(bytes, context, host = {}) {
+  const budget = context.budget ?? new DocumentBudget2({}, context.signal);
+  const base = getDocxDiscovery({ operation: "capabilities", inputs: [], options: {} }, budget).data;
+  const inspected = await inspectDocument(bytes, { ...context, budget });
+  const detections = new Map(inspected.features.map((feature) => [feature.id, feature.detected]));
+  const data = {
+    ...base,
+    host: { read: host.capabilities?.read !== false && typeof host.readFile === "function", atomicReplace: host.capabilities?.atomicFileStaging === true && typeof host.createStagedFile === "function" && typeof host.publishStagedFile === "function" && typeof host.removeStagedFile === "function", transactions: false, binaryStdout: true },
+    features: base.features.map((feature) => ({ ...feature, detected: feature.id === "F01" || feature.id === "F02" || feature.id === "F03" || feature.id === "F04" ? true : detections.get(feature.id) ?? null })),
+    input: {
+      signed: inspected.signed,
+      protected: inspected.protected,
+      unsupportedNamespaces: inspected.unsupportedNamespaces,
+      unsupportedOperations: Object.entries(docxOperationSchemas2).filter(([id, declaration]) => operationSupport(id, declaration) === "reject" || declaration.mutates && (inspected.signed && id !== "signatures.remove" || inspected.protected)).map(([id]) => id)
+    }
+  };
+  const human = capabilitiesHelp(data);
+  const encoder = new TextEncoder();
+  budget.check("serializedOutput", Math.max(encoder.encode(JSON.stringify(data)).byteLength, encoder.encode(human).byteLength));
+  return { data, human };
+}
+function capabilitiesHelp(data) {
+  const human = "docx capabilities\n\n" + data.features.map((feature) => `${feature.id}: ${feature.level}; detected: ${feature.detected ?? "unknown"}
+  ${feature.subsets.map((subset) => `${subset.name}: ${subset.level} \u2014 ${subset.reason}`).join("\n  ")}`).join("\n") + "\n\nLimits:\n" + data.limits.map((limit) => `  ${limit.name}: ${limit.ceiling}`).join("\n") + (data.input ? "\nUnsupported namespaces: " + (data.input.unsupportedNamespaces.map(escapeTerminalText).join(", ") || "none detected") : "\nNo input inspected; feature presence is unknown.") + "\nRead returns stored data; preserve retains opaque content; edit covers only the listed subsets; reject has no execution support.\nRecognition and absence of a tag do not establish editing support.\n";
+  return formatDiscoveryLines(human.trimEnd().split("\n"));
+}
+
+// packages/safe-bash-command-docx/src/pack-command.ts
+import { dirname, resolvePath } from "@poe-platform/safe-fs/core";
+import { parseDocxJson as parseDocxJson2 } from "../../safe-bash-docx-engine/argument-json.js";
+import { packDocumentArchive } from "../../safe-bash-docx-engine/pack.js";
+import { asPermissionError as asPermissionError2 } from "../../safe-bash-docx-engine/io-errors.js";
+async function executePackCommand(invocation, request, context, io) {
+  const input = invocation.inputs[0], path2 = input === "-" ? void 0 : resolvePath(request.cwd, input);
+  let bytes;
+  try {
+    if (path2 !== void 0) {
+      const fs = request.filesystem;
+      const segments = path2.split("/").slice(1);
+      let current = "";
+      for (let i = 0; i < segments.length; i++) {
+        current += "/" + segments[i];
+        const stat = await fs.lstat(current, { signal: request.signal });
+        if (stat.type !== (i === segments.length - 1 ? "file" : "directory") || await fs.realpath(current, { signal: request.signal }) !== current)
+          throw new SourceError2();
+      }
+    }
+    bytes = await io.readBytes({ open(signal) {
+      if (path2 === void 0) return request.stdin;
+      return request.filesystem.readStream ? request.filesystem.readStream(path2, { signal }) : { async *[Symbol.asyncIterator]() {
+        yield await request.filesystem.readFile(path2, { signal });
+      } };
+    } });
+  } catch (error) {
+    request.signal.throwIfAborted();
+    if (error && typeof error === "object" && "code" in error && ["limit-exceeded", "cancelled"].includes(String(error.code))) throw error;
+    throw asPermissionError2(error) ?? new SourceError2(error);
+  }
+  const inventory = parseDocxJson2(bytes, context.budget);
+  const options = { ...invocation.options, ...typeof invocation.options.output === "string" && invocation.options.output !== "-" ? { output: resolvePath(request.cwd, invocation.options.output) } : {} };
+  const data = await packDocumentArchive(inventory, options, { ...context, filesystem: request.filesystem, stdout: request.stdout, ...path2 === void 0 ? {} : { inventoryDirectory: dirname(path2) } });
+  if (options.output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: "pack", ok: true, data, warnings: [], errors: [], affected: 1, locations: [] }) + "\n" : `docx pack: ${data.dryRun ? "dry-run; " : ""}1 document created
+`);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { extractDocumentArchive, ArchiveExtractionError } from "../../safe-bash-docx-engine/extract.js";
+import { compareDocument } from "../../safe-bash-docx-engine/diff.js";
+
+// packages/safe-bash-command-docx/src/removal-command.ts
+import { resolvePath as resolvePath2 } from "@poe-platform/safe-fs/core";
+import { removeDocumentContent } from "../../safe-bash-docx-engine/removal.js";
+import { PublicationError } from "../../safe-bash-docx-engine/publication.js";
+async function executeContentRemovalCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath2(request.cwd, options.output);
+  const data = await removeDocumentContent(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.flatMap((c) => c.after ? [c.after] : []), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "selection" : "selections"} changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/objects-command.ts
+import { resolvePath as resolvePath3 } from "@poe-platform/safe-fs/core";
+import { measurePackageResourceSerialization } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { archiveSettings, CancellationError } from "../../safe-bash-docx-engine/archive.js";
+import { DocxUsageError as DocxUsageError2 } from "../../safe-bash-docx-engine/argument-json.js";
+import {
+  inspectDocumentObjects,
+  extractDocumentObjects,
+  ObjectExtractionPublicationError,
+  ObjectExtractionCancellationError
+} from "../../safe-bash-docx-engine/objects.js";
+import { PublicationError as PublicationError2 } from "../../safe-bash-docx-engine/publication.js";
+function utf8Length(text) {
+  let bytes = 0;
+  for (const character of text) {
+    const code = character.codePointAt(0);
+    bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+  }
+  return bytes;
+}
+function escapedUtf8Length(text) {
+  let bytes = 0;
+  for (const character of text) bytes += utf8Length(escapeTerminalText(character));
+  return bytes;
+}
+var ObjectCommandPublicationError = class extends ObjectExtractionPublicationError {
+  constructor(error, responseBytes, diagnosticBytes) {
+    super(error, error.data);
+    this.responseBytes = responseBytes;
+    this.diagnosticBytes = diagnosticBytes;
+  }
+  responseBytes;
+  diagnosticBytes;
+};
+async function executeObjectsCommand(invocation, bytes, input, request, context, onExtraction) {
+  if (!["objects.list", "objects.extract"].includes(invocation.operation))
+    throw new DocxUsageError2("Expected an object inspection or extraction operation.");
+  const settings = archiveSettings(context), options = invocation.options;
+  const budget = settings.budget.lower(
+    Object.fromEntries((options.limit ?? []).map((limit) => [limit.name, limit.value]))
+  );
+  const extraction = invocation.operation === "objects.extract";
+  let reserved = false;
+  const admitPublication = (planned) => {
+    const { warnings: warnings2, ...data2 } = planned, locations2 = data2.entries.flatMap((entry) => entry.locations);
+    const diagnosticSize2 = warnings2.reduce(
+      (size, warning) => size + utf8Length(`docx: ${warning.code}: ${warning.message}
+`),
+      0
+    );
+    budget.check(
+      "diagnosticBytes",
+      diagnosticSize2 + utf8Length(
+        "docx: unsupported-publication: Document operation failed: unsupported-publication\n"
+      )
+    );
+    let responseSize;
+    if (options.json) {
+      const envelope2 = {
+        version: 1,
+        operation: invocation.operation,
+        ok: true,
+        data: data2,
+        affected: 0,
+        locations: locations2,
+        warnings: warnings2,
+        errors: []
+      };
+      const success = measurePackageResourceSerialization(envelope2, budget) + 1;
+      const failure = measurePackageResourceSerialization(
+        {
+          ...envelope2,
+          ok: false,
+          data: { ...data2, complete: false },
+          errors: [
+            {
+              code: "unsupported-publication",
+              message: "Document operation failed: unsupported-publication"
+            }
+          ]
+        },
+        budget
+      ) + 1;
+      budget.check("serializedOutput", Math.max(success, failure));
+      responseSize = Math.max(success, failure);
+    } else {
+      responseSize = utf8Length(`Objects extracted: ${data2.entries.length}; complete: false
+`);
+      budget.check("serializedOutput", responseSize);
+    }
+    const diagnostics = diagnosticSize2 + utf8Length(
+      "docx: unsupported-publication: Document operation failed: unsupported-publication\n"
+    );
+    budget.charge(
+      "retainedBytes",
+      responseSize * 12 + diagnostics * 12 + data2.entries.length * 512 + 1024
+    );
+    budget.charge("work", responseSize * 12 + diagnostics * 12 + data2.entries.length * 16 + 1024);
+    reserved = true;
+    return void 0;
+  };
+  const commandError = (error) => {
+    const { warnings: warnings2, ...data2 } = error.data, diagnostic = commandDiagnostic(
+      "Document operation failed: " + error.code,
+      error.code,
+      budget.limits.diagnosticBytes
+    );
+    const envelope2 = {
+      version: 1,
+      operation: invocation.operation,
+      ok: false,
+      data: data2,
+      affected: 0,
+      locations: data2.entries.flatMap((entry) => entry.locations),
+      warnings: warnings2,
+      errors: [{ code: error.code, message: diagnostic.message }]
+    };
+    return new ObjectCommandPublicationError(
+      error,
+      new TextEncoder().encode(options.json ? JSON.stringify(envelope2) + "\n" : ""),
+      new TextEncoder().encode(diagnostic.human)
+    );
+  };
+  let inspected;
+  try {
+    inspected = extraction ? await extractDocumentObjects(
+      bytes,
+      {
+        ...options,
+        outputDir: resolvePath3(request.cwd, options.outputDir),
+        ...input ? { input } : {}
+      },
+      {
+        ...settings,
+        budget,
+        encoding: { order: "input", compression: "store" },
+        filesystem: request.filesystem,
+        admitPublication
+      }
+    ) : await inspectDocumentObjects(
+      bytes,
+      invocation.options,
+      { ...settings, budget }
+    );
+  } catch (error) {
+    if (reserved && error instanceof ObjectExtractionPublicationError) throw commandError(error);
+    throw error;
+  }
+  if ("entries" in inspected && onExtraction) onExtraction(inspected);
+  const { warnings, ...data } = inspected;
+  const records = "items" in data ? data.items : [];
+  const locations = "entries" in data ? data.entries.flatMap((entry) => entry.locations) : records.map((record) => record.location);
+  const envelope = {
+    version: 1,
+    operation: invocation.operation,
+    ok: true,
+    data,
+    affected: 0,
+    locations,
+    warnings,
+    errors: []
+  };
+  let text;
+  if (options.json) {
+    if (!reserved) {
+      const size = measurePackageResourceSerialization(envelope, budget) + 1;
+      budget.check("serializedOutput", size);
+      budget.charge("retainedBytes", size * 6);
+    }
+    text = JSON.stringify(envelope) + "\n";
+  } else if ("entries" in data) {
+    text = `Objects extracted: ${data.entries.filter((entry) => entry.published).length}; complete: ${data.complete}
+`;
+  } else {
+    let size = utf8Length(`Objects: ${records.length}
+`);
+    for (const record of records)
+      size += escapedUtf8Length(record.name ?? "Unresolved object") + escapedUtf8Length(record.details.resource?.contentType ?? "unresolved") + utf8Length(`: ; ${record.details.resource?.bytes ?? "unknown"} bytes; ${record.support}
+`);
+    budget.check("serializedOutput", size);
+    budget.charge("retainedBytes", size * 6);
+    text = `Objects: ${records.length}
+` + records.map(
+      (record) => `${escapeTerminalText(record.name ?? "Unresolved object")}: ${escapeTerminalText(record.details.resource?.contentType ?? "unresolved")}; ${record.details.resource?.bytes ?? "unknown"} bytes; ${record.support}
+`
+    ).join("");
+  }
+  const diagnosticSize = warnings.reduce(
+    (size, warning) => size + utf8Length(`docx: ${warning.code}: ${warning.message}
+`),
+    0
+  );
+  if (!reserved) {
+    budget.check("diagnosticBytes", diagnosticSize);
+    budget.charge("retainedBytes", diagnosticSize * 3 + utf8Length(text) * 3);
+  }
+  if (warnings.length) {
+    try {
+      await request.stderr.write(
+        new TextEncoder().encode(
+          warnings.map((warning) => `docx: ${warning.code}: ${warning.message}
+`).join("")
+        )
+      );
+      settings.signal.throwIfAborted();
+    } catch (cause) {
+      const published = "entries" in data ? [
+        ...data.entries.filter((entry) => entry.published).map((entry) => ({ path: entry.path, bytes: entry.bytes })),
+        ...data.manifest.published ? [{ path: data.manifest.path, bytes: data.manifest.bytes }] : []
+      ] : [];
+      if (settings.signal.aborted) {
+        const error2 = new CancellationError("Object diagnostics cancelled.", { cause });
+        if ("entries" in data)
+          throw new ObjectExtractionCancellationError(
+            error2,
+            { ...data, warnings, complete: false },
+            published
+          );
+        throw error2;
+      }
+      const error = new PublicationError2(
+        "sink-failure",
+        "Object diagnostics could not be written.",
+        published,
+        false,
+        { cause }
+      );
+      if ("entries" in data)
+        throw commandError(
+          new ObjectExtractionPublicationError(error, { ...data, warnings, complete: false })
+        );
+      throw error;
+    }
+  }
+  budget.check("work", 0);
+  return new TextEncoder().encode(text);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { ObjectExtractionCancellationError as ObjectExtractionCancellationError2 } from "../../safe-bash-docx-engine/objects.js";
+import { inspectDocumentRevisions } from "../../safe-bash-docx-engine/revisions.js";
+
+// packages/safe-bash-command-docx/src/revision-edit-command.ts
+import { resolvePath as resolvePath4 } from "@poe-platform/safe-fs/core";
+import { PublicationError as PublicationError3 } from "../../safe-bash-docx-engine/publication.js";
+import { editDocumentRevisions } from "../../safe-bash-docx-engine/revision-edit.js";
+async function executeRevisionEditCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  const destination = options.output === void 0 || options.output === "-" ? options.output : resolvePath4(request.cwd, options.output);
+  if ((options.inPlace || destination !== void 0 && destination !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError3("unsupported-publication", "Tracked file publication requires admitted input identity.");
+  const data = await editDocumentRevisions(
+    bytes,
+    { ...options, ...input ? { input } : {}, ...destination === void 0 ? {} : { output: destination } },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (destination === "-" && !data.dryRun) return new Uint8Array();
+  const message = options.json ? JSON.stringify({ version: 1, operation: "revisions.add", ok: true, data, affected: data.changes.length, locations: data.changes.map((change) => change.after), warnings: [], errors: [] }) : `docx revisions add: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} tracked ${options.kind === "insert" ? "insertions" : "deletions"}`;
+  return new TextEncoder().encode(message + "\n");
+}
+
+// packages/safe-bash-command-docx/src/revision-decisions-command.ts
+import { resolvePath as resolvePath5 } from "@poe-platform/safe-fs/core";
+import { PublicationError as PublicationError4 } from "../../safe-bash-docx-engine/publication.js";
+import { editDocumentRevisionDecisions } from "../../safe-bash-docx-engine/revision-decisions.js";
+async function executeRevisionDecisionCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath5(request.cwd, options.output);
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError4("unsupported-publication", "Revision decision publication requires admitted input identity.");
+  const data = await editDocumentRevisionDecisions(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode((options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.flatMap((change) => change.after ? [change.after] : []), warnings: [], errors: [] }) : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "revision" : "revisions"} decided`) + "\n");
+}
+
+// packages/safe-bash-command-docx/src/controls-command.ts
+import { resolvePath as resolvePath6 } from "@poe-platform/safe-fs/core";
+import { DocumentIo } from "../../safe-bash-docx-engine/io.js";
+import { PublicationError as PublicationError5 } from "../../safe-bash-docx-engine/publication.js";
+import { editDocumentControls, inspectDocumentControls } from "../../safe-bash-docx-engine/controls.js";
+async function executeControlsCommand(invocation, bytes, input, request, context) {
+  if (invocation.operation === "controls.list") {
+    const data2 = await inspectDocumentControls(bytes, invocation.options, context);
+    return new TextEncoder().encode((invocation.options.json ? JSON.stringify({ version: 1, operation: "controls.list", ok: true, data: data2, affected: 0, locations: data2.items.map((item) => item.location), warnings: [], errors: [] }) : data2.items.map((item) => `${item.location.positions.control}: ${item.kind}; ${item.support}; ${escapeTerminalText(item.tag ?? "")}`).join("\n")) + "\n");
+  }
+  const options = invocation.options;
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath6(request.cwd, options.output);
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError5("unsupported-publication", "Control publication requires admitted input identity.");
+  const data = await editDocumentControls(
+    bytes,
+    { ...options, ...output === void 0 ? {} : { output }, ...input ? { input } : {} },
+    {
+      ...context,
+      encoding: { order: "input", compression: "store" },
+      filesystem: request.filesystem,
+      stdout: request.stdout,
+      binaryResolver: { capability: "command", async *open(path2, { signal, maxBytes }) {
+        const source = { open: (inner) => path2 === "-" ? request.stdin : request.filesystem.readStream ? request.filesystem.readStream(resolvePath6(request.cwd, path2), { signal: inner }) : { async *[Symbol.asyncIterator]() {
+          yield await request.filesystem.readFile(resolvePath6(request.cwd, path2), { signal: inner });
+        } } };
+        const bounded = new DocumentIo({ ...context, signal, limits: { ...context.limits, maxArchiveBytes: maxBytes }, ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {} });
+        try {
+          signal.throwIfAborted();
+          yield await bounded.readBytes(source);
+        } finally {
+          await bounded.cleanup();
+        }
+      } }
+    }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode((options.json ? JSON.stringify({ version: 1, operation: "controls.set", ok: true, data, affected: data.changes.length, locations: data.changes.map((change) => change.after), warnings: [], errors: [] }) : `docx controls set: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} controls filled`) + "\n");
+}
+
+// packages/safe-bash-command-docx/src/control-template-command.ts
+import { resolvePath as resolvePath7 } from "@poe-platform/safe-fs/core";
+import { applyDocumentTemplate } from "../../safe-bash-docx-engine/template.js";
+import { editDocumentControlBindings } from "../../safe-bash-docx-engine/control-bindings.js";
+import { editDocumentControlRepeats } from "../../safe-bash-docx-engine/control-repeat.js";
+import { PublicationError as PublicationError6 } from "../../safe-bash-docx-engine/publication.js";
+async function executeControlTemplateCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath7(request.cwd, options.output);
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError6("unsupported-publication", "Control template publication requires admitted input identity.");
+  const args = { ...invocation.options, ...output === void 0 ? {} : { output }, ...input ? { input } : {} };
+  const publication = { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout };
+  const data = invocation.operation === "template.apply" ? await applyDocumentTemplate(bytes, args, publication) : invocation.operation === "controls.repeat" ? await editDocumentControlRepeats(bytes, args, publication) : await editDocumentControlBindings(bytes, args, publication);
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode((options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.map((change) => change.after), warnings: [], errors: [] }) : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} control owners changed`) + "\n");
+}
+
+// packages/safe-bash-command-docx/src/comments-command.ts
+import { resolvePath as resolvePath8 } from "@poe-platform/safe-fs/core";
+import { editDocumentComments, inspectDocumentComments } from "../../safe-bash-docx-engine/comments.js";
+import { PublicationError as PublicationError7 } from "../../safe-bash-docx-engine/publication.js";
+async function executeCommentsCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if (invocation.operation === "comments.list" || invocation.operation === "comments.get") {
+    const data2 = await inspectDocumentComments(bytes, { operation: invocation.operation, options }, context, "resource");
+    const items = "item" in data2 ? [data2.item] : data2.items;
+    return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data: data2, affected: 0, locations: items.map((note) => note.location), warnings: [], errors: [] }) + "\n" : items.map((note) => `${note.properties.find((property) => property.name === "comment_id").value}: ${(note.text ?? "").split("\n").map((line) => escapeTerminalText(line)).join("\n")}`).join("\n") + "\n");
+  }
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError7("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath8(request.cwd, options.output);
+  const data = await editDocumentComments(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.flatMap((change) => change.after ? [change.after] : []), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "selection" : "selections"} changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/fields-command.ts
+import { resolvePath as resolvePath9 } from "@poe-platform/safe-fs/core";
+import { editDocumentFields } from "../../safe-bash-docx-engine/fields.js";
+import { PublicationError as PublicationError8 } from "../../safe-bash-docx-engine/publication.js";
+async function executeFieldsCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError8("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath9(request.cwd, options.output);
+  const data = await editDocumentFields(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.map((c) => c.after), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "selection" : "selections"} changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/notes-command.ts
+import { resolvePath as resolvePath10 } from "@poe-platform/safe-fs/core";
+import { editDocumentNotes, inspectDocumentNotes } from "../../safe-bash-docx-engine/notes.js";
+import { PublicationError as PublicationError9 } from "../../safe-bash-docx-engine/publication.js";
+async function executeNotesCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if (invocation.operation === "notes.list" || invocation.operation === "notes.get") {
+    const data2 = await inspectDocumentNotes(bytes, { operation: invocation.operation, options }, context);
+    return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data: data2, affected: 0, locations: data2.items.map((note) => note.location), warnings: [], errors: [] }) + "\n" : data2.items.map((note) => `${note.kind} ${note.id}: ${note.text.split("\n").map((line) => escapeTerminalText(line)).join("\n")}`).join("\n") + "\n");
+  }
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError9("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath10(request.cwd, options.output);
+  const data = await editDocumentNotes(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.flatMap((change) => change.after ? [change.after] : []), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "selection" : "selections"} changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { inspectDocumentFields } from "../../safe-bash-docx-engine/fields.js";
+
+// packages/safe-bash-command-docx/src/bookmarks-command.ts
+import { resolvePath as resolvePath11 } from "@poe-platform/safe-fs/core";
+import { editDocumentBookmarks } from "../../safe-bash-docx-engine/bookmarks.js";
+import { PublicationError as PublicationError10 } from "../../safe-bash-docx-engine/publication.js";
+async function executeBookmarksCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError10("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath11(request.cwd, options.output);
+  const data = await editDocumentBookmarks(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.map((c) => c.after), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "selection" : "selections"} changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { inspectDocumentBookmarks } from "../../safe-bash-docx-engine/bookmarks.js";
+
+// packages/safe-bash-command-docx/src/links-command.ts
+import { resolvePath as resolvePath12 } from "@poe-platform/safe-fs/core";
+import { editDocumentLinks } from "../../safe-bash-docx-engine/links.js";
+import { PublicationError as PublicationError11 } from "../../safe-bash-docx-engine/publication.js";
+async function executeLinksCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError11("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath12(request.cwd, options.output);
+  const data = await editDocumentLinks(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.map((c) => c.after), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "selection" : "selections"} changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { inspectDocumentLinks } from "../../safe-bash-docx-engine/links.js";
+
+// packages/safe-bash-command-docx/src/table-edit-command.ts
+import { resolvePath as resolvePath13 } from "@poe-platform/safe-fs/core";
+import { editDocumentTables } from "../../safe-bash-docx-engine/table-edit.js";
+import { PublicationError as PublicationError12 } from "../../safe-bash-docx-engine/publication.js";
+async function executeTableEditCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError12("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath13(request.cwd, options.output);
+  const data = await editDocumentTables(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.map((c) => c.after), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "selection" : "selections"} changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { inspectDocumentTable, inspectDocumentTables } from "../../safe-bash-docx-engine/table-read.js";
+import { inspectDocumentParagraph, inspectDocumentRun, inspectDocumentParagraphs, inspectDocumentRuns } from "../../safe-bash-docx-engine/text-resource-read.js";
+
+// packages/safe-bash-command-docx/src/lists-command.ts
+import { resolvePath as resolvePath14 } from "@poe-platform/safe-fs/core";
+import { editDocumentLists } from "../../safe-bash-docx-engine/lists.js";
+import { PublicationError as PublicationError13 } from "../../safe-bash-docx-engine/publication.js";
+async function executeListsCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError13("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath14(request.cwd, options.output);
+  const data = await editDocumentLists(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.map((c) => c.after), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "selection" : "selections"} changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/sections-command.ts
+import { resolvePath as resolvePath15 } from "@poe-platform/safe-fs/core";
+import { PublicationError as PublicationError14 } from "../../safe-bash-docx-engine/publication.js";
+import { editDocumentSections, inspectDocumentSections } from "../../safe-bash-docx-engine/sections.js";
+async function executeSectionsCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if (invocation.operation === "sections.list") {
+    const data2 = await inspectDocumentSections(bytes, options, context);
+    return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data: data2, affected: 0, locations: data2.items.map((s) => s.location), warnings: [], errors: [] }) + "\n" : data2.items.map((s) => escapeTerminalText(`Section ${s.position}: ${s.direct.orientation}, ${s.direct.startType}, ${s.direct.columns} column(s)`)).join("\n") + "\n");
+  }
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError14("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath15(request.cwd, options.output);
+  const data = await editDocumentSections(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.map((c) => c.after), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} section(s) changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/stories-command.ts
+import { resolvePath as resolvePath16 } from "@poe-platform/safe-fs/core";
+import { PublicationError as PublicationError15 } from "../../safe-bash-docx-engine/publication.js";
+import { editDocumentStories, inspectDocumentStories } from "../../safe-bash-docx-engine/stories.js";
+async function executeStoriesCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if (invocation.operation.endsWith(".list") || invocation.operation.endsWith(".get")) {
+    const data2 = await inspectDocumentStories(bytes, { operation: invocation.operation, options }, context);
+    return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data: data2, affected: 0, locations: data2.items.map((s) => s.location), warnings: [], errors: [] }) + "\n" : data2.items.map((s) => escapeTerminalText(`Section ${s.section}, ${s.variant}: ${s.linked ? "linked" : "local"}, ${s.part ?? "absent"}`) + "\n" + s.text.split("\n").map((line) => escapeTerminalText(line)).join("\n")).join("\n") + "\n");
+  }
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError15("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath16(request.cwd, options.output);
+  const data = await editDocumentStories(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.affectedSections.length, locations: data.changes.map((c) => c.after), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.affectedSections.length} section(s) affected
+`);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { UnsupportedEmbeddedFontMutationError } from "../../safe-bash-docx-engine/font-resources.js";
+import { inspectDocumentFonts } from "../../safe-bash-docx-engine/font-inventory.js";
+import { resolvePath as resolvePath34 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings17, ResourceLimitError as ResourceLimitError4, CancellationError as CancellationError7 } from "../../safe-bash-docx-engine/archive.js";
+import { DocumentBudget as DocumentBudget3, documentLimitDefaults } from "../../safe-bash-docx-engine/budget.js";
+import { DocumentIo as DocumentIo5 } from "../../safe-bash-docx-engine/io.js";
+import { inspectDocument as inspectDocument2, inspectionLocationView, selectInspectionLocations, validateDocument } from "../../safe-bash-docx-engine/inspection.js";
+
+// packages/safe-bash-command-docx/src/xml-command.ts
+import { resolvePath as resolvePath17 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings2, ResourceLimitError as ResourceLimitError2, CancellationError as CancellationError2 } from "../../safe-bash-docx-engine/archive.js";
+import { getDocumentXml, replaceDocumentXmlPart } from "../../safe-bash-docx-engine/xml-parts.js";
+import { PublicationError as PublicationError16 } from "../../safe-bash-docx-engine/publication.js";
+import { asPermissionError as asPermissionError3 } from "../../safe-bash-docx-engine/io-errors.js";
+async function executeXmlCommand(invocation, bytes, input, request, context, io) {
+  const options = invocation.options;
+  if (invocation.operation === "xml.get") {
+    const data2 = await getDocumentXml(bytes, context, {
+      part: options.part,
+      raw: options.raw === true || options.json !== true && options.pretty !== true,
+      ...options.pretty === void 0 ? {} : { pretty: options.pretty }
+    });
+    if (data2 instanceof Uint8Array) return data2;
+    if (!options.json) return new TextEncoder().encode(data2.content);
+    return new TextEncoder().encode(JSON.stringify({ version: 1, operation: "xml.get", ok: true, data: data2, warnings: [], errors: [], affected: 0, locations: [] }) + "\n");
+  }
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError16("unsupported-publication", "File publication requires admitted input identity.");
+  const file = invocation.sources.find((source) => source.argument === "file").path;
+  let replacement;
+  try {
+    replacement = await io.readBytes({ open(signal) {
+      const source = file === "-" ? request.stdin : request.filesystem.readStream ? request.filesystem.readStream(resolvePath17(request.cwd, file), { signal }) : { async *[Symbol.asyncIterator]() {
+        yield await request.filesystem.readFile(resolvePath17(request.cwd, file), { signal });
+      } };
+      return { async *[Symbol.asyncIterator]() {
+        let size = 0;
+        for await (const chunk of source) {
+          size += chunk.length;
+          if (size > Math.min(archiveSettings2(context).limits.maxEntryBytes, context.budget.limits.xmlPartBytes)) throw new ResourceLimitError2("XML input byte limit exceeded.");
+          yield chunk;
+        }
+      } };
+    } });
+  } catch (error) {
+    if (error instanceof ResourceLimitError2 || error instanceof CancellationError2) throw error;
+    request.signal.throwIfAborted();
+    throw asPermissionError3(error) ?? new SourceError2(error);
+  }
+  const output = typeof options.output === "string" ? options.output === "-" ? "-" : resolvePath17(request.cwd, options.output) : void 0;
+  const data = await replaceDocumentXmlPart(bytes, replacement, {
+    part: options.part,
+    ...options.allowEmpty === void 0 ? {} : { allowEmpty: options.allowEmpty },
+    ...input ? { input } : {},
+    ...output === void 0 ? {} : { output },
+    ...options.inPlace === void 0 ? {} : { inPlace: options.inPlace },
+    ...options.force === void 0 ? {} : { force: options.force },
+    ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun },
+    ...options.json === void 0 ? {} : { json: options.json }
+  }, { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout });
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({
+    version: 1,
+    operation: "xml.set",
+    ok: true,
+    data,
+    warnings: [],
+    errors: [],
+    affected: data.changed ? 1 : 0,
+    locations: data.changes.map((change) => change.after)
+  }) + "\n" : `docx xml set: ${data.dryRun ? "dry-run; " : ""}${data.changed ? "1 part replaced" : "unchanged"}
+`);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { PublicationError as PublicationError34 } from "../../safe-bash-docx-engine/publication.js";
+import { asPermissionError as asPermissionError6 } from "../../safe-bash-docx-engine/io-errors.js";
+import { extractDocumentText } from "../../safe-bash-docx-engine/text.js";
+
+// packages/safe-bash-command-docx/src/create-command.ts
+import { resolvePath as resolvePath18 } from "@poe-platform/safe-fs/core";
+import { createDocument } from "../../safe-bash-docx-engine/create.js";
+import { PublicationError as PublicationError17 } from "../../safe-bash-docx-engine/publication.js";
+import { asPermissionError as asPermissionError4 } from "../../safe-bash-docx-engine/io-errors.js";
+async function executeCreateCommand(invocation, request, context, io) {
+  const options = invocation.options;
+  const file = invocation.sources?.find((source) => source.argument === "template")?.path;
+  let template, input;
+  if (file !== void 0) {
+    if (file !== "-" && options.output !== void 0 && options.output !== "-" && !request.filesystem.lstat)
+      throw new PublicationError17("unsupported-publication", "Template file publication requires admitted source identity.");
+    try {
+      if (file !== "-" && request.filesystem.lstat) {
+        const path2 = resolvePath18(request.cwd, file);
+        input = { path: path2, stat: await request.filesystem.lstat(path2, { signal: request.signal }) };
+      }
+      template = await io.readBytes({ open(signal) {
+        if (file === "-") return request.stdin;
+        const path2 = resolvePath18(request.cwd, file);
+        return request.filesystem.readStream ? request.filesystem.readStream(path2, { signal }) : { async *[Symbol.asyncIterator]() {
+          yield await request.filesystem.readFile(path2, { signal });
+        } };
+      } });
+    } catch (error) {
+      request.signal.throwIfAborted();
+      if (error && typeof error === "object" && "code" in error && ["limit-exceeded", "cancelled"].includes(String(error.code))) throw error;
+      throw asPermissionError4(error) ?? new SourceError2(error);
+    }
+  }
+  const creation = {
+    ...template === void 0 ? {} : { template },
+    ...Object.fromEntries(["kind", "dialect", "content", "timestamp", "author"].filter((key) => options[key] !== void 0).map((key) => [key, options[key]]))
+  };
+  const output = typeof options.output === "string" ? options.output === "-" ? "-" : resolvePath18(request.cwd, options.output) : void 0;
+  const data = await createDocument(creation, {
+    ...input ? { input } : {},
+    ...output === void 0 ? {} : { output },
+    ...options.force === void 0 ? {} : { force: options.force },
+    ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun },
+    ...options.json === void 0 ? {} : { json: options.json }
+  }, { ...context, encoding: { order: "name", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout });
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: "create", ok: true, data, warnings: [], errors: [], affected: 1, locations: [] }) + "\n" : `docx create: ${data.dryRun ? "dry-run; " : ""}1 document created
+`);
+}
+
+// packages/safe-bash-command-docx/src/text-replace-command.ts
+import { resolvePath as resolvePath19 } from "@poe-platform/safe-fs/core";
+import { PublicationError as PublicationError18 } from "../../safe-bash-docx-engine/publication.js";
+import { setDocumentDummyText, replaceDocumentText } from "../../safe-bash-docx-engine/text-replace.js";
+async function executeTextReplaceCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError18("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath19(request.cwd, options.output);
+  const data = await (invocation.operation === "lorem.set" ? setDocumentDummyText : replaceDocumentText)(
+    bytes,
+    { ...options, ...input ? { input } : {}, ...output === void 0 ? {} : { output } },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({
+    version: 1,
+    operation: invocation.operation,
+    ok: true,
+    data,
+    warnings: [],
+    errors: [],
+    affected: data.changes.length,
+    locations: data.changes.map((change) => change.after)
+  }) + "\n" : `docx ${invocation.operation === "lorem.set" ? "lorem set (not anonymization)" : "text replace"}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "match" : "matches"} replaced
+`);
+}
+
+// packages/safe-bash-command-docx/src/paragraph-edit-command.ts
+import { resolvePath as resolvePath20 } from "@poe-platform/safe-fs/core";
+import { editDocumentParagraphs } from "../../safe-bash-docx-engine/paragraph-edit.js";
+import { PublicationError as PublicationError19 } from "../../safe-bash-docx-engine/publication.js";
+async function executeParagraphEditCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError19("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath20(request.cwd, options.output);
+  const data = await editDocumentParagraphs(
+    bytes,
+    { operation: invocation.operation, options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: data.changes.length, locations: data.changes.map((c) => c.after), warnings: [], errors: [] }) + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${data.changes.length === 1 ? "selection" : "selections"} changed
+`);
+}
+
+// packages/safe-bash-command-docx/src/batch-command.ts
+import { resolvePath as resolvePath22 } from "@poe-platform/safe-fs/core";
+import { executeDocumentBatch as executeDocumentBatch2 } from "../../safe-bash-docx-engine/batch.js";
+import { documentBatchActions } from "../../safe-bash-docx-engine/batch-operations.js";
+import { PublicationError as PublicationError21 } from "../../safe-bash-docx-engine/publication.js";
+
+// packages/safe-bash-command-docx/src/style-model-command.ts
+import { resolvePath as resolvePath21 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings3 } from "../../safe-bash-docx-engine/archive.js";
+import { PublicationError as PublicationError20 } from "../../safe-bash-docx-engine/publication.js";
+import { executeDocumentBatch } from "../../safe-bash-docx-engine/batch.js";
+import { DocumentIo as DocumentIo2 } from "../../safe-bash-docx-engine/io.js";
+import { UnsupportedProfileError } from "../../safe-bash-docx-engine/package-xml.js";
+async function executeStyleModelCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  const settings = archiveSettings3(context);
+  const operations = options.operations.map((item) => {
+    const descriptor = item.arguments.imageDescriptor;
+    if (item.operation !== "model.image.image.Image.from_file.call" || !descriptor || typeof descriptor !== "object" || !("path" in descriptor) || !("capability" in descriptor) || descriptor.capability !== "command") return item;
+    return { ...item, arguments: { ...item.arguments, imageDescriptor: { ...descriptor, path: resolvePath21(request.cwd, descriptor.path) } } };
+  });
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath21(request.cwd, options.output);
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError20("unsupported-publication", "File publication requires admitted input identity.");
+  const { version, operations: ignoredOperations, ...intent } = options;
+  const data = await executeDocumentBatch(bytes, { version, operations }, { ...intent, ...input ? { input } : {}, ...output === void 0 ? {} : { output } }, {
+    ...context,
+    encoding: { order: "input", compression: "store" },
+    filesystem: request.filesystem,
+    stdout: request.stdout,
+    ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {},
+    binaryResolver: { capability: "command", ...request.filesystem.lstat ? { filesystem: request.filesystem } : {}, async *open(path2, { signal, maxBytes }) {
+      const readStream = request.filesystem.readStream;
+      if (!readStream) throw new UnsupportedProfileError("Image paths require an explicit streaming read capability.");
+      const source = { open: (inner) => readStream.call(request.filesystem, path2, { signal: inner }) };
+      const io = new DocumentIo2({ ...settings, signal, limits: { ...settings.limits, maxArchiveBytes: maxBytes }, ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {} });
+      try {
+        signal.throwIfAborted();
+        yield await io.readBytes(source);
+      } finally {
+        await io.cleanup();
+      }
+    } }
+  });
+  if (data.publication && output === "-" && !options.dryRun) return new Uint8Array();
+  const affected = data.results.reduce((sum, result) => sum + result.affected, 0);
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: "batch", ok: true, data, warnings: [], errors: [], affected, locations: [] }) + "\n" : `docx batch: ${options.dryRun ? "dry-run; " : ""}${data.results.length} operations; ${affected} changes
+`);
+}
+
+// packages/safe-bash-command-docx/src/batch-command.ts
+async function executeBatchCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if (options.operations.length && options.operations.some((item) => !documentBatchActions.has(item.operation) || item.resultHandle) && options.operations.every((item) => !documentBatchActions.has(item.operation) || ["paragraphs.get", "runs.get"].includes(item.operation)))
+    return executeStyleModelCommand(invocation, bytes, input, request, context);
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError21("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath22(request.cwd, options.output);
+  const { version, operations, ...intent } = options;
+  const data = await executeDocumentBatch2(
+    bytes,
+    { version, operations },
+    { ...intent, ...input ? { input } : {}, ...output === void 0 ? {} : { output } },
+    {
+      ...context,
+      encoding: { order: "input", compression: "store" },
+      filesystem: request.filesystem,
+      stdout: request.stdout,
+      binaryResolver: { capability: "command", filesystem: request.filesystem, open(path2, { signal }) {
+        const absolute = resolvePath22(request.cwd, path2);
+        return request.filesystem.readStream ? request.filesystem.readStream(absolute, { signal }) : { async *[Symbol.asyncIterator]() {
+          yield await request.filesystem.readFile(absolute, { signal });
+        } };
+      } }
+    }
+  );
+  if (output === "-" && data.publication && !options.dryRun) return new Uint8Array();
+  const affected = data.results.reduce((sum, result) => sum + result.affected, 0);
+  return new TextEncoder().encode(options.json ? JSON.stringify({ version: 1, operation: "batch", ok: true, data, warnings: [], errors: [], affected, locations: [] }) + "\n" : `docx batch: ${options.dryRun ? "dry-run; " : ""}${data.results.length} operations; ${affected} changes
+`);
+}
+
+// packages/safe-bash-command-docx/src/styles-command.ts
+import { resolvePath as resolvePath23 } from "@poe-platform/safe-fs/core";
+import { PublicationError as PublicationError22 } from "../../safe-bash-docx-engine/publication.js";
+import { inspectDocumentStyles, editDocumentStyles } from "../../safe-bash-docx-engine/styles.js";
+async function executeStylesCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  const humanJson = (value) => JSON.stringify(value, null, 2).split("\n").map((line) => escapeTerminalText(line)).join("\n");
+  const edit = ["styles.add", "styles.set", "styles.remove", "styles.defaults.set", "styles.latent.add", "styles.latent.set", "styles.latent.remove", "styles.latent.defaults.set"].includes(invocation.operation);
+  if (edit && (options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError22("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath23(request.cwd, options.output);
+  const data = edit ? await editDocumentStyles(
+    bytes,
+    {
+      ...options,
+      operation: invocation.operation,
+      ...input ? { input } : {},
+      ...output === void 0 ? {} : { output }
+    },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  ) : await inspectDocumentStyles(bytes, { ...options, ...invocation.operation.startsWith("styles.latent.") ? { latent: true } : {} }, context);
+  if (edit && output === "-" && "dryRun" in data && !data.dryRun) return new Uint8Array();
+  const affected = "changes" in data ? data.changes.length : 0;
+  const human = invocation.operation.startsWith("styles.latent.") && "latent" in data ? humanJson(invocation.operation === "styles.latent.defaults.get" ? data.latent?.defaults ?? null : data.latent) + "\n" : invocation.operation === "styles.defaults.get" && "defaults" in data ? humanJson(data.defaults) + "\n" : invocation.operation === "styles.get" && "styles" in data ? data.styles.map((style) => [
+    `${escapeTerminalText(style.id)}: ${escapeTerminalText(style.name)} (${escapeTerminalText(style.type)})`,
+    `Base: ${escapeTerminalText(style.base ?? "none")}; next: ${escapeTerminalText(style.next ?? "none")}; linked: ${escapeTerminalText(style.linkedStyle ?? "none")}`,
+    `Direct: ${escapeTerminalText(JSON.stringify(style.direct, (_key, value) => value === null ? void 0 : value))}`,
+    `Inherited result: ${escapeTerminalText(style.effective === null ? "unresolved" : JSON.stringify(style.effective, (_key, value) => value === null ? void 0 : value))}`
+  ].join("\n")).join("\n") + "\n" : "styles" in data ? data.styles.map((style) => `${escapeTerminalText(style.id)}: ${escapeTerminalText(style.name)}`).join("\n") + "\n" : `docx ${invocation.operation.split(".").join(" ")}: ${"dryRun" in data && data.dryRun ? "dry-run; " : ""}${affected} styles changed
+`;
+  return new TextEncoder().encode(options.json ? JSON.stringify({
+    version: 1,
+    operation: invocation.operation,
+    ok: true,
+    data,
+    warnings: [],
+    errors: [],
+    affected,
+    locations: []
+  }) + "\n" : human);
+}
+
+// packages/safe-bash-command-docx/src/run-format-command.ts
+import { resolvePath as resolvePath24 } from "@poe-platform/safe-fs/core";
+import { PublicationError as PublicationError23 } from "../../safe-bash-docx-engine/publication.js";
+import { formatDocumentRuns } from "../../safe-bash-docx-engine/run-format.js";
+async function executeRunFormatCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  if ((options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError23("unsupported-publication", "File publication requires admitted input identity.");
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath24(request.cwd, options.output);
+  const data = await formatDocumentRuns(
+    bytes,
+    { ...options, ...input ? { input } : {}, ...output === void 0 ? {} : { output } },
+    { ...context, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout }
+  );
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify({
+    version: 1,
+    operation: "runs.set",
+    ok: true,
+    data,
+    warnings: [],
+    errors: [],
+    affected: data.changes.length,
+    locations: data.changes.map((change) => change.after)
+  }) + "\n" : `docx runs set: ${data.dryRun ? "dry-run; " : ""}${data.changes.length} ${options.text === void 0 ? `${data.changes.length === 1 ? "selection" : "selections"} formatted` : `${data.changes.length === 1 ? "run" : "runs"} updated`}
+`);
+}
+
+// packages/safe-bash-command-docx/src/ancillary-resources-command.ts
+import { inspectDocumentPackageResources, measurePackageResourceSerialization as measurePackageResourceSerialization2, packageResourceWarnings } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { archiveSettings as archiveSettings4, CancellationError as CancellationError3 } from "../../safe-bash-docx-engine/archive.js";
+import { PublicationError as PublicationError24 } from "../../safe-bash-docx-engine/publication.js";
+import { DocxUsageError as DocxUsageError3 } from "../../safe-bash-docx-engine/argument-json.js";
+async function executePackageResourcesCommand(invocation, bytes, request, context) {
+  if (invocation.operation !== "custom-xml.list" && invocation.operation !== "glossary.list") throw new DocxUsageError3("Expected a global package resource inventory.");
+  const settings = archiveSettings4(context), budget = settings.budget.lower(Object.fromEntries((invocation.options.limit ?? []).map((limit) => [limit.name, limit.value]))), data = await inspectDocumentPackageResources(bytes, invocation.operation, invocation.options, context);
+  const warnings = packageResourceWarnings(data);
+  const result = { version: 1, operation: invocation.operation, ok: true, data, warnings, errors: [], affected: 0, locations: data.items.map((item) => item.location) };
+  const human = `${invocation.operation === "custom-xml.list" ? "Custom XML" : "Glossary"} resources: ${data.items.length}
+` + data.items.map((item) => `${escapeTerminalText(item.name)}: preserve; ${item.details.parts.length} parts; ${item.references.length} references`).join("\n") + (data.items.length ? "\n" : "");
+  const length = invocation.options.json ? measurePackageResourceSerialization2(result, budget) + 1 : new TextEncoder().encode(human).length;
+  budget.check("serializedOutput", length);
+  budget.charge("retainedBytes", length * 3);
+  const text = invocation.options.json ? JSON.stringify(result) + "\n" : human, output = new TextEncoder().encode(text);
+  const diagnosticLength = warnings.reduce((length2, warning) => length2 + "docx: ".length + warning.code.length + ": ".length + warning.message.length + 1, 0);
+  budget.check("diagnosticBytes", diagnosticLength);
+  budget.charge("retainedBytes", diagnosticLength * 3);
+  if (warnings.length) {
+    const diagnostic = new TextEncoder().encode(warnings.map((warning) => `docx: ${warning.code}: ${warning.message}
+`).join(""));
+    try {
+      await request.stderr.write(diagnostic);
+    } catch (cause) {
+      if (context.signal.aborted) throw new CancellationError3("Resource inventory diagnostics cancelled.", { cause });
+      throw new PublicationError24("sink-failure", "Resource inventory diagnostics could not be written.", [], false, { cause });
+    }
+  }
+  budget.check("work", 0);
+  budget.check("serializedOutput", output.length);
+  return output;
+}
+
+// packages/safe-bash-command-docx/src/signatures-command.ts
+import { resolvePath as resolvePath25 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings5 } from "../../safe-bash-docx-engine/archive.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization3 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { PublicationError as PublicationError25 } from "../../safe-bash-docx-engine/publication.js";
+import { inspectDocumentSignatures, stripDocumentSignatures } from "../../safe-bash-docx-engine/signatures.js";
+async function executeSignaturesCommand(invocation, bytes, input, request, context) {
+  const settings = archiveSettings5(context), encoder = new TextEncoder();
+  const budget = settings.budget.lower(Object.fromEntries((invocation.options.limit ?? []).map((item) => [item.name, item.value])));
+  if (invocation.operation === "signatures.list") {
+    const data2 = await inspectDocumentSignatures(bytes, invocation.options, { ...settings, budget });
+    const envelope2 = { version: 1, operation: invocation.operation, ok: true, data: data2, warnings: [], errors: [], affected: 0, locations: data2.items.map((item) => item.location) };
+    measurePackageResourceSerialization3(envelope2, budget);
+    const text = invocation.options.json ? JSON.stringify(envelope2) + "\n" : `Signature parts: ${data2.items.length}; relationships: ${data2.relationships.length}
+Cryptographic validity: unknown (not verified)
+` + data2.items.flatMap((item) => item.details.parts.map((part) => `${escapeTerminalText(part.name)}: ${escapeTerminalText(part.contentType)}; ${part.bytes} bytes; SHA-256 ${part.sha256}
+`)).join("") + data2.relationships.map((edge) => `  Relationship: ${escapeTerminalText(edge.owner)} ${escapeTerminalText(edge.id)} ${escapeTerminalText(edge.type)} -> ${escapeTerminalText(edge.target ?? "redacted external target")} (${edge.external ? "external" : "internal"})
+`).join("");
+    const output2 = encoder.encode(text);
+    budget.check("serializedOutput", output2.length);
+    budget.charge("retainedBytes", output2.length * 8);
+    budget.charge("work", output2.length * 8);
+    settings.signal.throwIfAborted();
+    return output2;
+  }
+  const options = invocation.options;
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath25(request.cwd, options.output);
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError25("unsupported-publication", "Signature publication requires admitted input identity.");
+  const envelope = (data2) => ({ version: 1, operation: "signatures.remove", ok: true, data: data2, warnings: [], errors: [], affected: data2.removedParts.length, locations: [] });
+  const human = (data2) => `docx signatures remove: ${data2.dryRun ? "dry-run; " : ""}${data2.removedParts.length} parts, ${data2.removedRelationships.length} relationships, ${data2.removedContentTypes.length} content-type entries removed
+` + data2.removedParts.map((name) => `  Part: ${escapeTerminalText(name)}
+`).join("") + data2.removedRelationships.map((edge) => `  Relationship: ${escapeTerminalText(edge.owner)} ${escapeTerminalText(edge.id)} ${escapeTerminalText(edge.type)} -> ${escapeTerminalText(edge.target ?? "redacted external target")} (${edge.external ? "external" : "internal"})
+`).join("") + data2.removedContentTypes.map((entry) => `  Content type: ${entry.kind} ${escapeTerminalText(entry.name)} ${escapeTerminalText(entry.contentType)}
+`).join("");
+  const data = await stripDocumentSignatures(bytes, { ...options, ...input ? { input } : {}, ...output === void 0 ? {} : { output } }, {
+    ...settings,
+    budget,
+    encoding: { order: "input", compression: "store" },
+    filesystem: request.filesystem,
+    stdout: request.stdout,
+    admitPublication(planned) {
+      const size = output === "-" && !planned.dryRun ? 0 : options.json ? measurePackageResourceSerialization3(envelope(planned), budget) + 1 : encoder.encode(human(planned)).length;
+      budget.check("serializedOutput", size);
+      budget.charge("retainedBytes", size * 8);
+      budget.charge("work", size * 8);
+      return void 0;
+    }
+  });
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return encoder.encode(options.json ? JSON.stringify(envelope(data)) + "\n" : human(data));
+}
+
+// packages/safe-bash-command-docx/src/sanitize-command.ts
+import { resolvePath as resolvePath26 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings6 } from "../../safe-bash-docx-engine/archive.js";
+import { PublicationError as PublicationError26 } from "../../safe-bash-docx-engine/publication.js";
+import { sanitizeDocument } from "../../safe-bash-docx-engine/sanitize.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization4 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+async function executeSanitizeCommand(invocation, bytes, input, request, context) {
+  const options = invocation.options;
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath26(request.cwd, options.output);
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError26("unsupported-publication", "Sanitization publication requires admitted input identity.");
+  const settings = archiveSettings6(context), budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value])));
+  const envelope = (data2) => ({ version: 1, operation: "sanitize", ok: true, data: data2, affected: data2.actions.reduce((sum, action) => sum + action.affected, 0), locations: [], warnings: [], errors: [] });
+  const human = (data2) => {
+    const affected = data2.actions.reduce((sum, action) => sum + action.affected, 0);
+    return `docx sanitize: ${data2.dryRun ? "dry-run; " : ""}${affected} ${affected === 1 ? "record" : "records"} affected
+` + data2.actions.map((action) => `  ${action.category}: ${action.action}; ${action.affected}
+`).join("") + `Retained categories: ${data2.retained.join(", ") || "none selected for retention"}
+` + data2.gaps.map((gap) => `  ${gap}
+`).join("");
+  };
+  const data = await sanitizeDocument(bytes, { ...options, ...input ? { input } : {}, ...output === void 0 ? {} : { output } }, { ...settings, budget, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout, admitSanitization(planned) {
+    const size = output === "-" && !planned.dryRun ? 0 : options.json ? measurePackageResourceSerialization4(envelope(planned), budget) + 1 : new TextEncoder().encode(human(planned)).length;
+    budget.check("serializedOutput", size);
+    budget.charge("retainedBytes", size * 8);
+    budget.charge("work", size * 8);
+  } });
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify(envelope(data)) + "\n" : human(data));
+}
+
+// packages/safe-bash-command-docx/src/settings-command.ts
+import { inspectDocumentSettings } from "../../safe-bash-docx-engine/settings.js";
+import { archiveSettings as archiveSettings7 } from "../../safe-bash-docx-engine/archive.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization5 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+async function executeSettingsCommand(invocation, bytes, context) {
+  const settings = archiveSettings7(context), budget = settings.budget.lower(Object.fromEntries((invocation.options.limit ?? []).map((limit) => [limit.name, limit.value])));
+  const data = await inspectDocumentSettings(bytes, invocation.options, { ...settings, budget }, "resource");
+  const result = { version: 1, operation: "settings.list", ok: true, data, warnings: [], errors: [], affected: 0, locations: data.items.map((item) => item.location) };
+  measurePackageResourceSerialization5(result, budget);
+  const text = invocation.options.json ? JSON.stringify(result) + "\n" : `Settings parts: ${data.items.length}
+` + data.items.map((item) => {
+    const field = (name) => item.properties.find((property) => property.name === name)?.value;
+    return `${escapeTerminalText(item.name)}: ${item.support}; ${field("entryCount")} entries; ${field("opaqueCount")} opaque
+  Field updates: ${field("updateFields") ?? "absent or unsupported"}
+` + ["embedTrueTypeFonts", "embedSystemFonts", "saveSubsetFonts"].map((name) => `  ${name}: ${field(name) ?? "absent or unsupported"}
+`).join("") + item.properties.filter((property) => property.name.startsWith("protection[") && property.name.endsWith(".kind")).map((property) => {
+      const prefix = property.name.slice(0, -5);
+      return `  ${escapeTerminalText(String(property.value))}: enforced ${field(prefix + ".enforced") ?? "unknown"}; edit ${escapeTerminalText(String(field(prefix + ".edit") ?? "unspecified"))}
+`;
+    }).join("");
+  }).join("");
+  const output = new TextEncoder().encode(text);
+  budget.check("serializedOutput", output.length);
+  budget.charge("retainedBytes", output.length * 3);
+  return output;
+}
+
+// packages/safe-bash-command-docx/src/properties-command.ts
+import { resolvePath as resolvePath27 } from "@poe-platform/safe-fs/core";
+import { inspectDocumentProperties, editDocumentProperties } from "../../safe-bash-docx-engine/document-properties.js";
+import { normalizeDocxPropertyOptions as normalizeDocxPropertyOptions2 } from "../../safe-bash-docx-engine/command-properties.js";
+import { propertyDeclaration } from "../../safe-bash-docx-engine/property-values.js";
+import { readDocumentArchive } from "../../safe-bash-docx-engine/admission.js";
+import { archiveSettings as archiveSettings8, CancellationError as CancellationError4 } from "../../safe-bash-docx-engine/archive.js";
+import { SelectionError } from "../../safe-bash-docx-engine/location-token.js";
+import { PublicationError as PublicationError27 } from "../../safe-bash-docx-engine/publication.js";
+import { DocxUsageError as DocxUsageError4 } from "../../safe-bash-docx-engine/argument-json.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization6 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+function utf8Length2(text) {
+  let length = 0;
+  for (const character of text) {
+    const code = character.codePointAt(0);
+    length += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+  }
+  return length;
+}
+function escapedUtf8Length2(text) {
+  let length = 0;
+  for (const character of text) length += utf8Length2(escapeTerminalText(character));
+  return length;
+}
+async function executePropertiesCommand(invocation, bytes, input, request, context) {
+  if (!["properties.list", "properties.get", "properties.set", "properties.remove"].includes(invocation.operation)) throw new DocxUsageError4("Expected a document property operation.");
+  const settings = archiveSettings8(context), options = { ...invocation.options }, edit = invocation.operation === "properties.set" || invocation.operation === "properties.remove";
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((v) => [v.name, v.value])));
+  if (edit && (options.inPlace || options.output !== void 0 && options.output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError27("unsupported-publication", "File publication requires admitted input identity.");
+  if (invocation.operation === "properties.set") {
+    let type = options.type, qualified = options.name;
+    if (type === void 0 || !qualified.includes(":")) {
+      try {
+        const snapshot = await inspectDocumentProperties(bytes, { name: qualified }, { ...context, budget }), item = snapshot.items[0];
+        qualified = item.name ?? qualified;
+        type ??= item.properties[0]?.type;
+      } catch (error) {
+        if (!(error instanceof SelectionError) || error.code !== "missing-selection") throw error;
+        const archive = await readDocumentArchive(bytes, { ...context, budget });
+        if (!qualified.includes(":")) {
+          const group = propertyDeclaration("core", qualified, archive.dialect) ? "core" : propertyDeclaration("extended", qualified, archive.dialect) ? "extended" : "custom";
+          qualified = `${group}:${qualified}`;
+        }
+      }
+    }
+    const normalized = normalizeDocxPropertyOptions2({ name: qualified, value: options.value, ...type === void 0 ? {} : { type } }, typeof options.value === "string");
+    options.value = normalized.value;
+  }
+  const output = options.output === void 0 ? void 0 : options.output === "-" ? "-" : resolvePath27(request.cwd, options.output);
+  let data;
+  if (edit) data = await editDocumentProperties(bytes, { ...options, operation: invocation.operation, ...input ? { input } : {}, ...output === void 0 ? {} : { output } }, { ...context, budget, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, stdout: request.stdout });
+  else data = await inspectDocumentProperties(bytes, options, { ...context, budget });
+  if (edit && output === "-" && "dryRun" in data && !data.dryRun) return new Uint8Array();
+  const warnings = "warnings" in data ? data.warnings : [], affected = "changes" in data ? data.changes.length : 0;
+  const resultData = "items" in data ? invocation.operation === "properties.get" ? { item: data.items[0] } : { items: data.items } : data;
+  const locations = "items" in data ? data.items.map((item) => item.location) : data.changes.flatMap((change) => change.after ? [change.after] : change.before ? [change.before] : []);
+  const envelope = { version: 1, operation: invocation.operation, ok: true, data: resultData, warnings, errors: [], affected, locations };
+  if (options.json) {
+    const measured = measurePackageResourceSerialization6(envelope, budget);
+    budget.check("serializedOutput", measured + 1);
+    budget.charge("retainedBytes", (measured + 1) * 6);
+  } else {
+    const retained = "items" in data ? data.items.reduce((size, item) => size + (item.name?.length ?? 16) + (item.properties.length ? String(item.properties[0].value).length : 32) + 4, 16) : 128;
+    budget.charge("retainedBytes", retained * 12);
+    budget.charge("work", retained * 12);
+  }
+  let text;
+  if (options.json) text = JSON.stringify(envelope) + "\n";
+  else if ("items" in data && data.items.length) {
+    const fields = data.items.map((item) => [item.name ?? "Unnamed property", item.properties.length ? String(item.properties[0].value) : "preserved unsupported value"]);
+    const minimum = fields.reduce((size, [name, value]) => size + utf8Length2(name) + utf8Length2(value) + 3, 0);
+    budget.check("serializedOutput", minimum);
+    const exact = fields.reduce((size, [name, value]) => size + escapedUtf8Length2(name) + escapedUtf8Length2(value) + 3, 0);
+    budget.check("serializedOutput", exact);
+    text = fields.map(([name, value]) => `${escapeTerminalText(name)}: ${escapeTerminalText(value)}`).join("\n") + "\n";
+  } else {
+    text = "items" in data ? "Properties: 0\n" : `docx ${invocation.operation.split(".").join(" ")}: ${data.dryRun ? "dry-run; " : ""}${affected} properties changed
+`;
+    budget.check("serializedOutput", utf8Length2(text));
+  }
+  const length = utf8Length2(text);
+  budget.check("serializedOutput", length);
+  budget.charge("retainedBytes", length * 3);
+  budget.charge("work", warnings.reduce((size, warning) => size + 9 + warning.code.length + warning.message.length, 0));
+  const diagnosticLength = warnings.reduce((size, warning) => size + 9 + utf8Length2(warning.code) + utf8Length2(warning.message), 0);
+  budget.check("diagnosticBytes", diagnosticLength);
+  budget.charge("retainedBytes", diagnosticLength * 3);
+  const diagnosticText = warnings.map((warning) => `docx: ${warning.code}: ${warning.message}
+`).join("");
+  if (diagnosticLength) {
+    try {
+      await request.stderr.write(new TextEncoder().encode(diagnosticText));
+    } catch (cause) {
+      if (settings.signal.aborted) throw new CancellationError4("Property diagnostics cancelled.", { cause });
+      throw new PublicationError27("sink-failure", "Property diagnostics could not be written.", [], false, { cause });
+    }
+  }
+  budget.check("work", 0);
+  return new TextEncoder().encode(text);
+}
+
+// packages/safe-bash-command-docx/src/images-command.ts
+import { resolvePath as resolvePath28 } from "@poe-platform/safe-fs/core";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization7 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { archiveSettings as archiveSettings9, CancellationError as CancellationError5 } from "../../safe-bash-docx-engine/archive.js";
+import { DocxUsageError as DocxUsageError5 } from "../../safe-bash-docx-engine/argument-json.js";
+import { inspectDocumentImages, extractDocumentImages, ImageExtractionPublicationError, ImageExtractionCancellationError } from "../../safe-bash-docx-engine/images.js";
+import { PublicationError as PublicationError28 } from "../../safe-bash-docx-engine/publication.js";
+function utf8Length3(text) {
+  let bytes = 0;
+  for (const character of text) {
+    const code = character.codePointAt(0);
+    bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+  }
+  return bytes;
+}
+function escapedUtf8Length3(text) {
+  let bytes = 0;
+  for (const character of text) bytes += utf8Length3(escapeTerminalText(character));
+  return bytes;
+}
+var ImageCommandPublicationError = class extends ImageExtractionPublicationError {
+  constructor(error, responseBytes, diagnosticBytes) {
+    super(error, error.data);
+    this.responseBytes = responseBytes;
+    this.diagnosticBytes = diagnosticBytes;
+  }
+  responseBytes;
+  diagnosticBytes;
+};
+async function executeImagesCommand(invocation, bytes, input, request, context, onExtraction) {
+  if (!["images.list", "images.get", "images.extract"].includes(invocation.operation)) throw new DocxUsageError5("Expected an image inspection or extraction operation.");
+  const settings = archiveSettings9(context), options = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((limit) => [limit.name, limit.value])));
+  const extraction = invocation.operation === "images.extract";
+  let reserved = false;
+  const admitPublication = (planned) => {
+    const { warnings: warnings2, ...data2 } = planned, locations2 = data2.entries.flatMap((entry) => entry.locations);
+    const diagnosticSize2 = warnings2.reduce((size, warning) => size + utf8Length3(`docx: ${warning.code}: ${warning.message}
+`), 0);
+    budget.check("diagnosticBytes", diagnosticSize2 + utf8Length3("docx: unsupported-publication: Document operation failed: unsupported-publication\n"));
+    let responseSize;
+    if (options.json) {
+      const envelope2 = { version: 1, operation: invocation.operation, ok: true, data: data2, affected: 0, locations: locations2, warnings: warnings2, errors: [] };
+      const success = measurePackageResourceSerialization7(envelope2, budget) + 1;
+      const failure = measurePackageResourceSerialization7({ ...envelope2, ok: false, data: { ...data2, complete: false }, errors: [{ code: "unsupported-publication", message: "Document operation failed: unsupported-publication" }] }, budget) + 1;
+      budget.check("serializedOutput", Math.max(success, failure));
+      responseSize = Math.max(success, failure);
+    } else {
+      responseSize = utf8Length3(`Images extracted: ${data2.entries.length}; complete: false
+`);
+      budget.check("serializedOutput", responseSize);
+    }
+    const diagnostics = diagnosticSize2 + utf8Length3("docx: unsupported-publication: Document operation failed: unsupported-publication\n");
+    budget.charge("retainedBytes", responseSize * 12 + diagnostics * 12 + data2.entries.length * 512 + 1024);
+    budget.charge("work", responseSize * 12 + diagnostics * 12 + data2.entries.length * 16 + 1024);
+    reserved = true;
+    return void 0;
+  };
+  const commandError = (error) => {
+    const { warnings: warnings2, ...data2 } = error.data, diagnostic = commandDiagnostic("Document operation failed: " + error.code, error.code, budget.limits.diagnosticBytes);
+    const reportPublication = options.allowPartialOutput === true || error.published.length > 0;
+    const envelope2 = { version: 1, operation: invocation.operation, ok: false, data: reportPublication ? data2 : null, affected: 0, locations: reportPublication ? data2.entries.flatMap((entry) => entry.locations) : [], warnings: warnings2, errors: [{ code: error.code, message: diagnostic.message }] };
+    return new ImageCommandPublicationError(error, new TextEncoder().encode(options.json ? JSON.stringify(envelope2) + "\n" : ""), new TextEncoder().encode(diagnostic.human));
+  };
+  let inspected;
+  try {
+    inspected = extraction ? await extractDocumentImages(bytes, { ...options, outputDir: resolvePath28(request.cwd, options.outputDir), ...input ? { input } : {} }, { ...settings, budget, encoding: { order: "input", compression: "store" }, filesystem: request.filesystem, admitPublication }) : await inspectDocumentImages(bytes, { ...invocation.options, operation: invocation.operation }, { ...settings, budget });
+  } catch (error) {
+    if (reserved && error instanceof ImageExtractionPublicationError) throw commandError(error);
+    throw error;
+  }
+  if ("entries" in inspected && onExtraction) onExtraction(inspected);
+  const { warnings, ...data } = inspected;
+  const records = "items" in data ? data.items ?? [] : "item" in data && data.item ? [data.item] : [];
+  const locations = "entries" in data ? data.entries.flatMap((entry) => entry.locations) : records.map((record) => record.location);
+  const envelope = { version: 1, operation: invocation.operation, ok: true, data, affected: 0, locations, warnings, errors: [] };
+  let text;
+  if (options.json) {
+    if (!reserved) {
+      const size = measurePackageResourceSerialization7(envelope, budget) + 1;
+      budget.check("serializedOutput", size);
+      budget.charge("retainedBytes", size * 6);
+    }
+    text = JSON.stringify(envelope) + "\n";
+  } else if ("entries" in data) {
+    text = `Images extracted: ${data.entries.filter((entry) => entry.published).length}; complete: ${data.complete}
+`;
+  } else {
+    let size = utf8Length3(`Images: ${records.length}
+`);
+    for (const record of records) size += escapedUtf8Length3(record.name ?? "Unresolved image") + utf8Length3(`: ${record.details.mime ?? "unresolved"}; ${record.details.bytes ?? "unknown"} bytes; ${record.support}
+`);
+    budget.check("serializedOutput", size);
+    budget.charge("retainedBytes", size * 6);
+    text = `Images: ${records.length}
+` + records.map((record) => `${escapeTerminalText(record.name ?? "Unresolved image")}: ${record.details.mime ?? "unresolved"}; ${record.details.bytes ?? "unknown"} bytes; ${record.support}
+`).join("");
+  }
+  const diagnosticSize = warnings.reduce((size, warning) => size + utf8Length3(`docx: ${warning.code}: ${warning.message}
+`), 0);
+  if (!reserved) {
+    budget.check("diagnosticBytes", diagnosticSize);
+    budget.charge("retainedBytes", diagnosticSize * 3 + utf8Length3(text) * 3);
+  }
+  if (warnings.length) {
+    try {
+      await request.stderr.write(new TextEncoder().encode(warnings.map((warning) => `docx: ${warning.code}: ${warning.message}
+`).join("")));
+      settings.signal.throwIfAborted();
+    } catch (cause) {
+      const published = "entries" in data ? [...data.entries.filter((entry) => entry.published).map((entry) => ({ path: entry.path, bytes: entry.bytes })), ...data.manifest.published ? [{ path: data.manifest.path, bytes: data.manifest.bytes }] : []] : [];
+      if (settings.signal.aborted) {
+        const error2 = new CancellationError5("Image diagnostics cancelled.", { cause });
+        if ("entries" in data) throw new ImageExtractionCancellationError(error2, { ...data, warnings, complete: false }, published);
+        throw error2;
+      }
+      const error = new PublicationError28("sink-failure", "Image diagnostics could not be written.", published, false, { cause });
+      if ("entries" in data) throw commandError(new ImageExtractionPublicationError(error, { ...data, warnings, complete: false }));
+      throw error;
+    }
+  }
+  budget.check("work", 0);
+  return new TextEncoder().encode(text);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { ImageExtractionCancellationError as ImageExtractionCancellationError2 } from "../../safe-bash-docx-engine/images.js";
+
+// packages/safe-bash-command-docx/src/image-insertion-command.ts
+import { resolvePath as resolvePath29 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings10 } from "../../safe-bash-docx-engine/archive.js";
+import { DocxUsageError as DocxUsageError6 } from "../../safe-bash-docx-engine/argument-json.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization8 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { insertDocumentImage } from "../../safe-bash-docx-engine/image-insertion.js";
+import { DocumentIo as DocumentIo3 } from "../../safe-bash-docx-engine/io.js";
+import { UnsupportedProfileError as UnsupportedProfileError2 } from "../../safe-bash-docx-engine/package-xml.js";
+import { PublicationError as PublicationError29 } from "../../safe-bash-docx-engine/publication.js";
+async function executeImageInsertionCommand(invocation, bytes, input, request, context) {
+  if (invocation.operation !== "images.add") throw new DocxUsageError6("Expected image insertion.");
+  const settings = archiveSettings10(context), options = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value])));
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath29(request.cwd, options.output);
+  const normalizeSource = (source, argument) => {
+    if (source?.kind !== "vfs" || source.capability !== "command") return source;
+    const reserved = source.path === "-" && invocation.sources?.some((item) => item.argument === argument && item.format === "binary" && item.path === "-");
+    return { ...source, path: reserved ? "-" : resolvePath29(request.cwd, source.path) };
+  };
+  const file = normalizeSource(options.file, "file"), fallback = normalizeSource(options.fallback, "fallback");
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError29("unsupported-publication", "Image publication requires admitted input identity.");
+  const envelope = (data2) => ({ version: 1, operation: invocation.operation, ok: true, data: data2, affected: data2.changes.length, locations: data2.changes.map((c) => c.after), warnings: [], errors: [] });
+  const human = (data2) => `docx images add: ${data2.dryRun ? "dry-run; " : ""}${data2.changes.length} ${data2.changes.length === 1 ? "selection" : "selections"} changed
+`;
+  const data = await insertDocumentImage(bytes, { operation: "images.add", options: { ...options, file, ...fallback === void 0 ? {} : { fallback }, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} }, {
+    ...settings,
+    budget,
+    encoding: { order: "input", compression: "store" },
+    filesystem: request.filesystem,
+    stdout: request.stdout,
+    admitPublication(planned) {
+      const size = output === "-" && !planned.dryRun ? 0 : options.json ? measurePackageResourceSerialization8(envelope(planned), budget) + 1 : new TextEncoder().encode(human(planned)).length;
+      const diagnosticSize = new TextEncoder().encode("docx: unsupported-publication: Document operation failed: unsupported-publication\n").length;
+      budget.check("serializedOutput", size);
+      budget.check("diagnosticBytes", diagnosticSize);
+      budget.charge("retainedBytes", size * 8 + diagnosticSize * 8);
+      budget.charge("work", size * 8 + diagnosticSize * 8);
+      return void 0;
+    },
+    binaryResolver: { capability: "command", async *open(path2, { signal, maxBytes }) {
+      const readStream = request.filesystem.readStream;
+      if (path2 !== "-" && !readStream) throw new UnsupportedProfileError2("Image paths require an explicit streaming read capability.");
+      const source = { open: (inner) => path2 === "-" ? request.stdin : readStream.call(request.filesystem, resolvePath29(request.cwd, path2), { signal: inner }) };
+      const io = new DocumentIo3({ ...settings, budget, signal, limits: { ...settings.limits, maxArchiveBytes: maxBytes }, ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {} });
+      try {
+        signal.throwIfAborted();
+        yield await io.readBytes(source);
+      } finally {
+        await io.cleanup();
+      }
+    } }
+  });
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify(envelope(data)) + "\n" : human(data));
+}
+
+// packages/safe-bash-command-docx/src/image-replacement-command.ts
+import { resolvePath as resolvePath30 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings11 } from "../../safe-bash-docx-engine/archive.js";
+import { DocxUsageError as DocxUsageError7 } from "../../safe-bash-docx-engine/argument-json.js";
+import { replaceDocumentImage } from "../../safe-bash-docx-engine/image-replacement.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization9 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { DocumentIo as DocumentIo4 } from "../../safe-bash-docx-engine/io.js";
+import { UnsupportedProfileError as UnsupportedProfileError3 } from "../../safe-bash-docx-engine/package-xml.js";
+import { PublicationError as PublicationError30 } from "../../safe-bash-docx-engine/publication.js";
+async function executeImageReplacementCommand(invocation, bytes, input, request, context) {
+  if (invocation.operation !== "images.replace") throw new DocxUsageError7("Expected image replacement.");
+  const settings = archiveSettings11(context), options = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((limit) => [limit.name, limit.value])));
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath30(request.cwd, options.output);
+  const file = options.file.kind === "vfs" && options.file.capability === "command" ? { ...options.file, path: resolvePath30(request.cwd, options.file.path) } : options.file;
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError30("unsupported-publication", "Image publication requires admitted input identity.");
+  const envelope = (data2) => ({ version: 1, operation: "images.replace", ok: true, data: data2, affected: data2.changes.length, locations: data2.changes.map((change) => change.after), warnings: [], errors: [] });
+  const human = (data2) => `docx images replace: ${data2.dryRun ? "dry-run; " : ""}${data2.changes.length} ${data2.changes.length === 1 ? "occurrence" : "occurrences"} changed
+`;
+  const data = await replaceDocumentImage(bytes, { operation: "images.replace", options: { ...options, file, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} }, {
+    ...settings,
+    budget,
+    encoding: { order: "input", compression: "store" },
+    filesystem: request.filesystem,
+    stdout: request.stdout,
+    ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {},
+    admitPublication(planned) {
+      const size = output === "-" && !planned.dryRun ? 0 : options.json ? measurePackageResourceSerialization9(envelope(planned), budget) + 1 : new TextEncoder().encode(human(planned)).length;
+      const diagnostics = new TextEncoder().encode("docx: unsupported-publication: Document operation failed: unsupported-publication\n").length;
+      budget.check("serializedOutput", size);
+      budget.check("diagnosticBytes", diagnostics);
+      budget.charge("retainedBytes", size * 8 + diagnostics * 8);
+      budget.charge("work", size * 8 + diagnostics * 8);
+      return void 0;
+    },
+    binaryResolver: { capability: "command", async *open(path2, { signal, maxBytes }) {
+      const readStream = request.filesystem.readStream;
+      if (!readStream) throw new UnsupportedProfileError3("Image paths require an explicit streaming read capability.");
+      const source = { open: (inner) => readStream.call(request.filesystem, resolvePath30(request.cwd, path2), { signal: inner }) };
+      const io = new DocumentIo4({ ...settings, budget, signal, limits: { ...settings.limits, maxArchiveBytes: maxBytes }, ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {} });
+      try {
+        signal.throwIfAborted();
+        yield await io.readBytes(source);
+      } finally {
+        await io.cleanup();
+      }
+    } }
+  });
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify(envelope(data)) + "\n" : human(data));
+}
+
+// packages/safe-bash-command-docx/src/image-layout-command.ts
+import { resolvePath as resolvePath31 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings12 } from "../../safe-bash-docx-engine/archive.js";
+import { DocxUsageError as DocxUsageError8 } from "../../safe-bash-docx-engine/argument-json.js";
+import { setDocumentImageLayout } from "../../safe-bash-docx-engine/image-layout.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization10 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { PublicationError as PublicationError31 } from "../../safe-bash-docx-engine/publication.js";
+async function executeImageLayoutCommand(invocation, bytes, input, request, context) {
+  if (invocation.operation !== "images.set") throw new DocxUsageError8("Expected image layout.");
+  const settings = archiveSettings12(context), options = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((limit) => [limit.name, limit.value])));
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath31(request.cwd, options.output);
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError31("unsupported-publication", "Image publication requires admitted input identity.");
+  const envelope = (data2) => ({ version: 1, operation: "images.set", ok: true, data: data2, affected: data2.changes.length, locations: data2.changes.map((change) => change.after), warnings: [], errors: [] });
+  const human = (data2) => `docx images set: ${data2.dryRun ? "dry-run; " : ""}${data2.changes.length} ${data2.changes.length === 1 ? "occurrence" : "occurrences"} changed
+`;
+  const data = await setDocumentImageLayout(bytes, { operation: "images.set", options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} }, {
+    ...settings,
+    budget,
+    encoding: { order: "input", compression: "store" },
+    filesystem: request.filesystem,
+    stdout: request.stdout,
+    ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {},
+    admitPublication(planned) {
+      const size = output === "-" && !planned.dryRun ? 0 : options.json ? measurePackageResourceSerialization10(envelope(planned), budget) + 1 : new TextEncoder().encode(human(planned)).length;
+      const diagnostics = new TextEncoder().encode("docx: unsupported-publication: Document operation failed: unsupported-publication\n").length;
+      budget.check("serializedOutput", size);
+      budget.check("diagnosticBytes", diagnostics);
+      budget.charge("retainedBytes", size * 8 + diagnostics * 8);
+      budget.charge("work", size * 8 + diagnostics * 8);
+      return void 0;
+    }
+  });
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify(envelope(data)) + "\n" : human(data));
+}
+
+// packages/safe-bash-command-docx/src/shapes-command.ts
+import { resolvePath as resolvePath32 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings13 } from "../../safe-bash-docx-engine/archive.js";
+import { DocxUsageError as DocxUsageError9 } from "../../safe-bash-docx-engine/argument-json.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization11 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { PublicationError as PublicationError32 } from "../../safe-bash-docx-engine/publication.js";
+import { inspectDocumentShapes, editDocumentShapes } from "../../safe-bash-docx-engine/shape-edit.js";
+async function executeShapesCommand(invocation, bytes, input, request, context) {
+  if (invocation.operation !== "shapes.list" && invocation.operation !== "shapes.set") throw new DocxUsageError9("Expected a shape inventory or text assignment operation.");
+  const settings = archiveSettings13(context), shapeOptions = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((shapeOptions.limit ?? []).map((limit) => [limit.name, limit.value])));
+  if (invocation.operation === "shapes.list") {
+    const inspected = await inspectDocumentShapes(bytes, invocation.options, { ...settings, budget });
+    const { warnings, ...data2 } = inspected;
+    const envelope2 = { version: 1, operation: "shapes.list", ok: true, data: data2, affected: 0, locations: data2.items.map((item) => item.location), warnings, errors: [] };
+    const retainedSize = measurePackageResourceSerialization11(envelope2, budget);
+    budget.charge("retainedBytes", retainedSize * 12);
+    budget.charge("work", retainedSize * 12);
+    const human2 = `Shapes: ${data2.items.length}
+` + data2.items.map((item) => `${escapeTerminalText(item.name ?? "Unnamed shape")}: ${item.details.representation}; ${item.details.kind}; ${item.support}
+`).join("");
+    const size = invocation.options.json ? measurePackageResourceSerialization11(envelope2, budget) + 1 : new TextEncoder().encode(human2).length;
+    const diagnostic = warnings.map((warning) => `docx: ${escapeTerminalText(warning.code)}: ${escapeTerminalText(warning.message)}
+`).join("");
+    budget.check("serializedOutput", size);
+    budget.check("diagnosticBytes", new TextEncoder().encode(diagnostic).length);
+    budget.charge("retainedBytes", size * 8 + diagnostic.length * 8);
+    budget.charge("work", size * 8 + diagnostic.length * 8);
+    if (diagnostic) await request.stderr.write(new TextEncoder().encode(diagnostic));
+    settings.signal.throwIfAborted();
+    return new TextEncoder().encode(invocation.options.json ? JSON.stringify(envelope2) + "\n" : human2);
+  }
+  const options = invocation.options;
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath32(request.cwd, options.output);
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input) throw new PublicationError32("unsupported-publication", "Shape publication requires admitted input identity.");
+  const envelope = (data2) => ({ version: 1, operation: "shapes.set", ok: true, data: data2, affected: data2.changes.length, locations: data2.changes.map((change) => change.after), warnings: [], errors: [] });
+  const human = (data2) => `docx shapes set: ${data2.dryRun ? "dry-run; " : ""}${data2.changes.length} ${data2.changes.length === 1 ? "shape" : "shapes"} changed
+`;
+  const data = await editDocumentShapes(bytes, { operation: "shapes.set", options: { ...options, ...output === void 0 ? {} : { output } }, ...input ? { input } : {} }, {
+    ...settings,
+    budget,
+    encoding: { order: "input", compression: "store" },
+    filesystem: request.filesystem,
+    stdout: request.stdout,
+    ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {},
+    admitPublication(planned) {
+      const size = output === "-" && !planned.dryRun ? 0 : options.json ? measurePackageResourceSerialization11(envelope(planned), budget) + 1 : new TextEncoder().encode(human(planned)).length;
+      const diagnostics = new TextEncoder().encode("docx: unsupported-publication: Document operation failed: unsupported-publication\n").length;
+      budget.check("serializedOutput", size);
+      budget.check("diagnosticBytes", diagnostics);
+      budget.charge("retainedBytes", size * 8 + diagnostics * 8);
+      budget.charge("work", size * 8 + diagnostics * 8);
+      return void 0;
+    }
+  });
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return new TextEncoder().encode(options.json ? JSON.stringify(envelope(data)) + "\n" : human(data));
+}
+
+// packages/safe-bash-command-docx/src/charts-command.ts
+import { archiveSettings as archiveSettings14 } from "../../safe-bash-docx-engine/archive.js";
+import { DocxUsageError as DocxUsageError10 } from "../../safe-bash-docx-engine/argument-json.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization12 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { inspectDocumentCharts } from "../../safe-bash-docx-engine/charts.js";
+async function executeChartsCommand(invocation, bytes, request, context) {
+  if (invocation.operation !== "charts.list") throw new DocxUsageError10("Expected physical chart inventory.");
+  const options = invocation.options, settings = archiveSettings14(context);
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((limit) => [limit.name, limit.value])));
+  const inspected = await inspectDocumentCharts(bytes, options, { ...settings, budget });
+  const { warnings, ...data } = inspected;
+  const envelope = { version: 1, operation: "charts.list", ok: true, data, affected: 0, locations: data.items.map((item) => item.location), warnings, errors: [] };
+  const retainedSize = measurePackageResourceSerialization12(envelope, budget);
+  budget.charge("retainedBytes", retainedSize * 12);
+  budget.charge("work", retainedSize * 12);
+  const human = `Chart parts: ${data.items.length}
+` + data.items.map((item) => `${escapeTerminalText(item.name ?? item.location.value.part)}: ${escapeTerminalText(item.details.chartTypes.join(", ") || "opaque or no plot groups")}; ${item.support}
+`).join("");
+  const diagnostic = warnings.map((warning) => `docx: ${escapeTerminalText(warning.code)}: ${escapeTerminalText(warning.message)}
+`).join("");
+  const size = options.json ? retainedSize + 1 : new TextEncoder().encode(human).length;
+  budget.check("serializedOutput", size);
+  budget.check("diagnosticBytes", new TextEncoder().encode(diagnostic).length);
+  budget.charge("retainedBytes", size * 8 + diagnostic.length * 8);
+  budget.charge("work", size * 8 + diagnostic.length * 8);
+  if (diagnostic) await request.stderr.write(new TextEncoder().encode(diagnostic));
+  settings.signal.throwIfAborted();
+  return new TextEncoder().encode(options.json ? JSON.stringify(envelope) + "\n" : human);
+}
+
+// packages/safe-bash-command-docx/src/diagrams-command.ts
+import { archiveSettings as archiveSettings15 } from "../../safe-bash-docx-engine/archive.js";
+import { DocxUsageError as DocxUsageError11 } from "../../safe-bash-docx-engine/argument-json.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization13 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { inspectDocumentDiagrams } from "../../safe-bash-docx-engine/diagrams.js";
+function serializeDiagramMutationFailure(operation, error, code, message, budget) {
+  const diagnostic = { code, message, location: error.location.token };
+  const diagnosticSize = measurePackageResourceSerialization13(diagnostic, budget);
+  budget.check("diagnosticBytes", diagnosticSize);
+  const envelope = { version: 1, operation, ok: false, data: null, affected: 0, locations: error.locations, warnings: [], errors: [diagnostic] };
+  const size = measurePackageResourceSerialization13(envelope, budget) + 1;
+  budget.check("serializedOutput", size);
+  budget.charge("retainedBytes", size * 12);
+  budget.charge("work", size * 12);
+  return new TextEncoder().encode(JSON.stringify(envelope) + "\n");
+}
+async function executeDiagramsCommand(invocation, bytes, request, context) {
+  if (invocation.operation !== "diagrams.list") throw new DocxUsageError11("Expected physical diagram inventory.");
+  const options = invocation.options, settings = archiveSettings15(context);
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((limit) => [limit.name, limit.value])));
+  const { warnings, ...data } = await inspectDocumentDiagrams(bytes, options, { ...settings, budget });
+  const envelope = { version: 1, operation: "diagrams.list", ok: true, data, affected: 0, locations: data.items.map((item) => item.location), warnings, errors: [] };
+  const retainedSize = measurePackageResourceSerialization13(envelope, budget);
+  budget.charge("retainedBytes", retainedSize * 12);
+  budget.charge("work", retainedSize * 12);
+  const human = `Diagram records: ${data.items.length}
+` + data.items.map((item) => `${escapeTerminalText(item.name)}: ${escapeTerminalText(item.details.roles.map((role) => role.role).join(", ") || "opaque graphics")}; preserve
+`).join("");
+  const diagnostic = warnings.map((warning) => `docx: ${escapeTerminalText(warning.code)}: ${escapeTerminalText(warning.message)}
+`).join("");
+  const encoder = new TextEncoder(), diagnosticBytes = encoder.encode(diagnostic), size = options.json ? retainedSize + 1 : encoder.encode(human).length;
+  budget.check("serializedOutput", size);
+  budget.check("diagnosticBytes", diagnosticBytes.length);
+  budget.charge("retainedBytes", size * 8 + diagnosticBytes.length * 8);
+  budget.charge("work", size * 8 + diagnosticBytes.length * 8);
+  if (diagnosticBytes.length) await request.stderr.write(diagnosticBytes);
+  settings.signal.throwIfAborted();
+  return encoder.encode(options.json ? JSON.stringify(envelope) + "\n" : human);
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { UnsupportedDiagramMutationError } from "../../safe-bash-docx-engine/diagrams.js";
+
+// packages/safe-bash-command-docx/src/equations-command.ts
+import { resolvePath as resolvePath33 } from "@poe-platform/safe-fs/core";
+import { archiveSettings as archiveSettings16, CancellationError as CancellationError6, ResourceLimitError as ResourceLimitError3 } from "../../safe-bash-docx-engine/archive.js";
+import { DocxUsageError as DocxUsageError12 } from "../../safe-bash-docx-engine/argument-json.js";
+import { measurePackageResourceSerialization as measurePackageResourceSerialization14 } from "../../safe-bash-docx-engine/ancillary-resources.js";
+import { asPermissionError as asPermissionError5 } from "../../safe-bash-docx-engine/io-errors.js";
+import { inspectDocumentEquations, addDocumentEquation, replaceDocumentEquation } from "../../safe-bash-docx-engine/equations.js";
+import { UnsupportedProfileError as UnsupportedProfileError4 } from "../../safe-bash-docx-engine/package-xml.js";
+import { PublicationError as PublicationError33 } from "../../safe-bash-docx-engine/publication.js";
+async function executeEquationsCommand(invocation, bytes, input, request, context, io) {
+  if (!["equations.list", "equations.add", "equations.replace"].includes(invocation.operation)) throw new DocxUsageError12("Expected equation inventory or fragment mutation.");
+  const settings = archiveSettings16(context), encoder = new TextEncoder();
+  const budget = settings.budget.lower(Object.fromEntries((invocation.options.limit ?? []).map((item) => [item.name, item.value])));
+  if (invocation.operation === "equations.list") {
+    const options2 = invocation.options;
+    const { warnings, ...data2 } = await inspectDocumentEquations(bytes, options2, { ...settings, budget });
+    const envelope2 = { version: 1, operation: invocation.operation, ok: true, data: data2, affected: 0, locations: data2.items.map((item) => item.location), warnings, errors: [] };
+    const retainedSize = measurePackageResourceSerialization14(envelope2, budget);
+    budget.charge("retainedBytes", retainedSize * 12);
+    budget.charge("work", retainedSize * 12);
+    const human2 = `Equation units: ${data2.items.length}
+` + data2.items.map((item) => `${escapeTerminalText(item.name)}: ${item.details.mode}; ${item.support}
+`).join("");
+    const diagnostic = warnings.map((warning) => `docx: ${escapeTerminalText(warning.code)}: ${escapeTerminalText(warning.message)}
+`).join("");
+    const diagnosticBytes = encoder.encode(diagnostic), size = options2.json ? retainedSize + 1 : encoder.encode(human2).length;
+    budget.check("serializedOutput", size);
+    budget.check("diagnosticBytes", diagnosticBytes.length);
+    budget.charge("retainedBytes", size * 8 + diagnosticBytes.length * 8);
+    budget.charge("work", size * 8 + diagnosticBytes.length * 8);
+    settings.signal.throwIfAborted();
+    if (diagnosticBytes.length) await request.stderr.write(diagnosticBytes);
+    return encoder.encode(options2.json ? JSON.stringify(envelope2) + "\n" : human2);
+  }
+  const operation = invocation.operation, options = invocation.options;
+  const output = options.output === void 0 || options.output === "-" ? options.output : resolvePath33(request.cwd, options.output);
+  const file = options.file.kind === "vfs" && options.file.capability === "command" ? { ...options.file, path: options.file.path === "-" && invocation.sources?.some((source) => source.argument === "file" && source.path === "-") ? "-" : resolvePath33(request.cwd, options.file.path) } : options.file;
+  if ((options.inPlace || output !== void 0 && output !== "-") && invocation.inputs[0] !== "-" && !input)
+    throw new PublicationError33("unsupported-publication", "Equation publication requires admitted input identity.");
+  const envelope = (data2) => ({ version: 1, operation, ok: true, data: data2, affected: data2.changes.length, locations: data2.changes.map((change) => change.after), warnings: [], errors: [] });
+  const human = (data2) => `docx ${operation.replace(".", " ")}: ${data2.dryRun ? "dry-run; " : ""}${data2.changes.length} selection changed
+`;
+  const mutationContext = {
+    ...settings,
+    budget,
+    encoding: { order: "input", compression: "store" },
+    filesystem: request.filesystem,
+    stdout: request.stdout,
+    admitPublication(planned) {
+      const size = output === "-" && !planned.dryRun ? 0 : options.json ? measurePackageResourceSerialization14(envelope(planned), budget) + 1 : encoder.encode(human(planned)).length;
+      budget.check("serializedOutput", size);
+      budget.charge("retainedBytes", size * 8);
+      budget.charge("work", size * 8);
+      return void 0;
+    },
+    binaryResolver: { capability: "command", async *open(path2, { signal, maxBytes }) {
+      try {
+        if (path2 !== "-" && !request.filesystem.readStream) throw new UnsupportedProfileError4("Equation fragment paths require an explicit streaming read capability.");
+        const source = { open(inner) {
+          const stream = path2 === "-" ? request.stdin : request.filesystem.readStream(resolvePath33(request.cwd, path2), { signal: inner });
+          return { async *[Symbol.asyncIterator]() {
+            let size = 0;
+            for await (const chunk of stream) {
+              size += chunk.length;
+              if (size > Math.min(maxBytes, settings.limits.maxEntryBytes, budget.limits.xmlPartBytes)) throw new ResourceLimitError3("Equation fragment byte limit exceeded.");
+              yield chunk;
+            }
+          } };
+        } };
+        signal.throwIfAborted();
+        yield await io.readBytes(source);
+      } catch (error) {
+        if (error instanceof ResourceLimitError3 || error instanceof CancellationError6 || error instanceof UnsupportedProfileError4) throw error;
+        if (signal.aborted) throw new CancellationError6("Equation fragment acquisition cancelled.", { cause: signal.reason });
+        throw asPermissionError5(error) ?? new SourceError2(error);
+      }
+    } }
+  };
+  const mutationOptions = { ...options, file, ...output === void 0 ? {} : { output } };
+  const data = operation === "equations.add" ? await addDocumentEquation(bytes, { operation, options: mutationOptions, ...input ? { input } : {} }, mutationContext) : await replaceDocumentEquation(bytes, { operation, options: mutationOptions, ...input ? { input } : {} }, mutationContext);
+  if (output === "-" && !data.dryRun) return new Uint8Array();
+  return encoder.encode(options.json ? JSON.stringify(envelope(data)) + "\n" : human(data));
+}
+
+// packages/safe-bash-command-docx/src/inspection-command.ts
+import { UnsupportedEquationMutationError } from "../../safe-bash-docx-engine/equations.js";
+function createDocxInspectionCommandEngine(options = {}) {
+  contextData(options);
+  const limits = Object.freeze(archiveSettings17({ limits: options.limits ?? {}, signal: new AbortController().signal }).limits);
+  let fontResolver;
+  if (options.fontResolver !== void 0) {
+    contextData(options.fontResolver, ["capability", "fonts"]);
+    contextData(options.fontResolver.fonts, ["measure"]);
+    if (typeof options.fontResolver.capability !== "string" || !options.fontResolver.capability || typeof options.fontResolver.fonts.measure !== "function") throw new TypeError("Expected an explicit font capability adapter.");
+    fontResolver = Object.freeze({ capability: options.fontResolver.capability, fonts: Object.freeze({ measure: options.fontResolver.fonts.measure.bind(options.fontResolver.fonts) }) });
+  }
+  return createDocxCommandEngine({
+    async readSource(source, request, budget) {
+      const io = new DocumentIo5({ limits, signal: request.signal, budget, ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {} });
+      try {
+        return await io.readBytes({ open(signal) {
+          const path2 = resolvePath34(request.cwd, source.path);
+          return request.filesystem.readStream ? request.filesystem.readStream(path2, { signal }) : { async *[Symbol.asyncIterator]() {
+            yield await request.filesystem.readFile(path2, { signal });
+          } };
+        } });
+      } finally {
+        await io.cleanup();
+      }
+    },
+    async execute(invocation, request) {
+      const budget = docxInvocationBudgets2.get(invocation) ?? new DocumentBudget3({}, request.signal);
+      const context = { limits, signal: request.signal, budget, ...fontResolver ? { fontResolver } : {} };
+      const io = new DocumentIo5({ ...context, ...request.registerCleanup ? { registerCleanup: request.registerCleanup } : {} });
+      let acquiring = false;
+      let writingDiagnostics = false;
+      let output;
+      let exitCode = 0;
+      let archiveReceipt;
+      let imageReceipt;
+      const sinkFailure = (cause) => {
+        if (archiveReceipt) {
+          const extraction2 = { ...archiveReceipt, complete: false, possiblePartialOutput: archiveReceipt.complete || archiveReceipt.possiblePartialOutput };
+          if (request.signal.aborted || cause instanceof CancellationError7) throw new ArchiveExtractionError(cause, extraction2, true);
+          return { exitCode: 3, extraction: extraction2 };
+        }
+        if (!imageReceipt) return { exitCode: request.signal.aborted || cause instanceof CancellationError7 ? 130 : invocation.operation === "diff" ? 2 : 3 };
+        const extraction = { ...imageReceipt, complete: false };
+        if (request.signal.aborted || cause instanceof CancellationError7) {
+          const published = [...extraction.entries.filter((entry) => entry.published).map((entry) => ({ path: entry.path, bytes: entry.bytes })), ...extraction.manifest.published ? [{ path: extraction.manifest.path, bytes: extraction.manifest.bytes }] : []];
+          const ErrorType = invocation.operation === "objects.extract" ? ObjectExtractionCancellationError2 : ImageExtractionCancellationError2;
+          throw new ErrorType(cause instanceof CancellationError7 ? cause : new CancellationError7("Resource output cancelled.", { cause }), extraction, published);
+        }
+        return { exitCode: 3, extraction };
+      };
+      const controlTemplateOperation = ["controls.repeat", "controls.bind", "template.apply"].includes(invocation.operation);
+      const controlOperation = controlTemplateOperation || ["controls.list", "controls.set"].includes(invocation.operation);
+      const fieldOperation = ["fields.add", "fields.set", "toc.add", "toc.set", "captions.add", "captions.set"].includes(invocation.operation);
+      const commentOperation = ["comments.list", "comments.get", "comments.add", "comments.set", "comments.remove"].includes(invocation.operation);
+      const revisionEditOperation = ["revisions.add", "revisions.accept", "revisions.reject"].includes(invocation.operation);
+      const noteOperation = ["notes.list", "notes.get", "notes.add", "notes.set", "notes.remove"].includes(invocation.operation);
+      const bookmarkOperation = ["bookmarks.add", "bookmarks.set", "bookmarks.remove"].includes(invocation.operation);
+      const linkOperation = ["links.add", "links.set", "links.remove"].includes(invocation.operation);
+      const tableOperation = ["tables.set", "tables.rows.add", "tables.rows.remove", "tables.columns.add", "tables.columns.remove", "tables.merge", "tables.split"].includes(invocation.operation);
+      const listOperation = ["lists.add", "lists.set"].includes(invocation.operation);
+      const storyOperation = ["headers.list", "headers.get", "headers.set", "headers.remove", "footers.list", "footers.get", "footers.set", "footers.remove"].includes(invocation.operation);
+      const propertyOperation = ["properties.list", "properties.get", "properties.set", "properties.remove"].includes(invocation.operation);
+      const objectOperation = ["objects.list", "objects.extract"].includes(invocation.operation);
+      const imageOperation = ["images.list", "images.get", "images.extract"].includes(invocation.operation);
+      const imageInsertionOperation = invocation.operation === "images.add";
+      const imageReplacementOperation = invocation.operation === "images.replace";
+      const imageLayoutOperation = invocation.operation === "images.set";
+      const shapeOperation = ["shapes.list", "shapes.set"].includes(invocation.operation);
+      const chartOperation = invocation.operation === "charts.list";
+      const diagramOperation = invocation.operation === "diagrams.list";
+      const equationOperation = ["equations.list", "equations.add", "equations.replace"].includes(invocation.operation);
+      const equationEditOperation = equationOperation && invocation.operation !== "equations.list";
+      const signatureOperation = ["signatures.list", "signatures.remove"].includes(invocation.operation);
+      const fontOperation = invocation.operation === "fonts.list";
+      const packageResourceOperation = fontOperation || signatureOperation || invocation.operation === "settings.list" || objectOperation || equationOperation || diagramOperation || chartOperation || imageLayoutOperation || imageReplacementOperation || imageInsertionOperation || imageOperation || propertyOperation || ["custom-xml.list", "glossary.list"].includes(invocation.operation);
+      try {
+        if (invocation.operation === "diff") {
+          acquiring = true;
+          const inputs = [];
+          for (const input of invocation.inputs) {
+            inputs.push(await io.readBytes({ open(signal) {
+              if (input === "-") return request.stdin;
+              const path2 = resolvePath34(request.cwd, input);
+              return request.filesystem.readStream ? request.filesystem.readStream(path2, { signal }) : { async *[Symbol.asyncIterator]() {
+                yield await request.filesystem.readFile(path2, { signal });
+              } };
+            } }));
+          }
+          acquiring = false;
+          const data = await compareDocument(inputs[0], inputs[1], context, invocation.options);
+          exitCode = data.equal ? 0 : 1;
+          output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: "diff", ok: true, data, warnings: [], errors: [], affected: 0, locations: [] }) + "\n" : `docx diff: ${data.equal ? "equal" : "different"} (${data.mode}); ${data.differences.length} changed parts
+`);
+          budget.check("serializedOutput", output.length);
+        } else if (invocation.operation === "pack") {
+          output = await executePackCommand(invocation, request, context, io);
+          budget.check("serializedOutput", output.length);
+        } else if (invocation.operation === "create") {
+          output = await executeCreateCommand(invocation, request, context, io);
+          budget.check("serializedOutput", output.length);
+        } else {
+          if (invocation.operation !== "extract" && !shapeOperation && !packageResourceOperation && invocation.operation !== "revisions.list" && !controlOperation && !revisionEditOperation && !commentOperation && !noteOperation && !fieldOperation && invocation.operation !== "fields.list" && !bookmarkOperation && invocation.operation !== "bookmarks.list" && !linkOperation && invocation.operation !== "links.list" && !tableOperation && !["tables.get", "tables.list", "paragraphs.get", "runs.get", "paragraphs.list", "runs.list"].includes(invocation.operation) && !listOperation && !storyOperation && invocation.operation !== "batch" && invocation.operation !== "capabilities" && invocation.operation !== "inspect" && invocation.operation !== "validate" && invocation.operation !== "text.get" && !["sanitize", "text.replace", "lorem.set"].includes(invocation.operation) && invocation.operation !== "runs.set" && !["paragraphs.remove", "runs.remove", "tables.remove", "paragraphs.set", "paragraphs.add", "runs.add", "tables.add"].includes(invocation.operation) && !["sections.list", "sections.set", "sections.add", "batch", "styles.list", "styles.get", "styles.add", "styles.set", "styles.remove", "styles.defaults.get", "styles.defaults.set", "styles.latent.list", "styles.latent.get", "styles.latent.add", "styles.latent.set", "styles.latent.remove", "styles.latent.defaults.get", "styles.latent.defaults.set"].includes(invocation.operation) && invocation.operation !== "xml.get" && invocation.operation !== "xml.set") {
+            throw Object.assign(new Error("This document operation is not implemented."), { code: "unsupported-profile" });
+          }
+          if (!fontOperation && invocation.operation !== "inspect" && invocation.operation !== "revisions.list" && !controlOperation && !revisionEditOperation && !fieldOperation && invocation.operation !== "fields.list" && !bookmarkOperation && invocation.operation !== "bookmarks.list" && !linkOperation && invocation.operation !== "links.list" && ["link", "control", "revision", "shape", "field", "bookmark"].some((key) => invocation.options[key] !== void 0 && !(key === "shape" && (shapeOperation || ["text.get", "text.replace"].includes(invocation.operation))))) {
+            throw Object.assign(new Error("This inspection selector is not implemented."), { code: "unsupported-profile" });
+          }
+          const input = invocation.inputs[0];
+          acquiring = true;
+          let inputIdentity;
+          if ((equationEditOperation || ["images.extract", "objects.extract"].includes(invocation.operation) || imageInsertionOperation || imageReplacementOperation || imageLayoutOperation) && input !== "-" && request.filesystem.lstat) {
+            const path2 = resolvePath34(request.cwd, input);
+            inputIdentity = { path: path2, stat: await request.filesystem.lstat(path2, { signal: request.signal }) };
+          }
+          if ((controlTemplateOperation || invocation.operation === "controls.set" || commentOperation && !["comments.list", "comments.get"].includes(invocation.operation) || noteOperation && !["notes.list", "notes.get"].includes(invocation.operation) || revisionEditOperation || fieldOperation || bookmarkOperation || linkOperation || tableOperation || ["sanitize", "signatures.remove", "shapes.set", "properties.set", "properties.remove", "lists.add", "lists.set", "headers.set", "headers.remove", "footers.set", "footers.remove", "sections.set", "sections.add", "batch", "styles.add", "styles.set", "styles.remove", "styles.defaults.set", "styles.latent.add", "styles.latent.set", "styles.latent.remove", "styles.latent.defaults.set", "xml.set", "text.replace", "lorem.set", "runs.set", "paragraphs.remove", "runs.remove", "tables.remove", "paragraphs.set", "paragraphs.add", "runs.add", "tables.add"].includes(invocation.operation)) && input !== "-" && request.filesystem.lstat && (invocation.operation !== "batch" || invocation.options.inPlace === true || typeof invocation.options.output === "string" && invocation.options.output !== "-")) {
+            const path2 = resolvePath34(request.cwd, input);
+            inputIdentity = { path: path2, stat: await request.filesystem.lstat(path2, { signal: request.signal }) };
+          }
+          const bytes = await io.readBytes({ open(signal) {
+            if (input === "-") return request.stdin;
+            const path2 = resolvePath34(request.cwd, input);
+            if (request.filesystem.readStream) return request.filesystem.readStream(path2, { signal });
+            return { async *[Symbol.asyncIterator]() {
+              yield await request.filesystem.readFile(path2, { signal });
+            } };
+          } });
+          acquiring = false;
+          if (invocation.operation === "extract") {
+            const extraction = await extractDocumentArchive(bytes, { ...invocation.options, outputDir: resolvePath34(request.cwd, invocation.options.outputDir) }, { ...context, filesystem: request.filesystem });
+            archiveReceipt = extraction;
+            const envelope = { version: 1, operation: "extract", ok: true, data: extraction, affected: 0, locations: [], warnings: [], errors: [] };
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify(envelope) + "\n" : `Extracted: ${extraction.entries.length}; complete: true
+`);
+            budget.check("serializedOutput", output.length);
+          } else if (fontOperation) {
+            const data = await inspectDocumentFonts(bytes, invocation.options, context);
+            const human = `Font resources: ${data.items.length}
+` + data.items.map((item) => `${escapeTerminalText(item.name)}: ${item.support}; ${item.details.parts.length} parts; ${item.references.length} references
+`).join("");
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: 0, locations: data.items.map((item) => item.location), warnings: [], errors: [] }) + "\n" : human);
+            budget.check("serializedOutput", output.length);
+          } else if (shapeOperation || packageResourceOperation || controlOperation || revisionEditOperation || commentOperation || noteOperation || fieldOperation || bookmarkOperation || linkOperation || tableOperation || listOperation || storyOperation || ["sanitize", "sections.list", "sections.set", "sections.add", "batch", "styles.list", "styles.get", "styles.add", "styles.set", "styles.remove", "styles.defaults.get", "styles.defaults.set", "styles.latent.list", "styles.latent.get", "styles.latent.add", "styles.latent.set", "styles.latent.remove", "styles.latent.defaults.get", "styles.latent.defaults.set", "xml.get", "xml.set", "text.replace", "lorem.set", "runs.set", "paragraphs.remove", "runs.remove", "tables.remove", "paragraphs.set", "paragraphs.add", "runs.add", "tables.add"].includes(invocation.operation)) {
+            output = invocation.operation === "sanitize" ? await executeSanitizeCommand(invocation, bytes, inputIdentity, request, context) : signatureOperation ? await executeSignaturesCommand(invocation, bytes, inputIdentity, request, context) : invocation.operation === "settings.list" ? await executeSettingsCommand(invocation, bytes, context) : objectOperation ? await executeObjectsCommand(invocation, bytes, inputIdentity, request, context, (data) => {
+              imageReceipt = data;
+              return void 0;
+            }) : equationOperation ? await executeEquationsCommand(invocation, bytes, inputIdentity, request, context, io) : diagramOperation ? await executeDiagramsCommand(invocation, bytes, request, context) : chartOperation ? await executeChartsCommand(invocation, bytes, request, context) : shapeOperation ? await executeShapesCommand(invocation, bytes, inputIdentity, request, context) : imageLayoutOperation ? await executeImageLayoutCommand(invocation, bytes, inputIdentity, request, context) : imageReplacementOperation ? await executeImageReplacementCommand(invocation, bytes, inputIdentity, request, context) : imageInsertionOperation ? await executeImageInsertionCommand(invocation, bytes, inputIdentity, request, context) : imageOperation ? await executeImagesCommand(invocation, bytes, inputIdentity, request, context, (data) => {
+              imageReceipt = data;
+              return void 0;
+            }) : packageResourceOperation ? propertyOperation ? await executePropertiesCommand(invocation, bytes, inputIdentity, request, context) : await executePackageResourcesCommand(invocation, bytes, request, context) : controlOperation ? controlTemplateOperation ? await executeControlTemplateCommand(invocation, bytes, inputIdentity, request, context) : await executeControlsCommand(invocation, bytes, inputIdentity, request, context) : revisionEditOperation ? invocation.operation === "revisions.add" ? await executeRevisionEditCommand(invocation, bytes, inputIdentity, request, context) : await executeRevisionDecisionCommand(invocation, bytes, inputIdentity, request, context) : commentOperation ? await executeCommentsCommand(invocation, bytes, inputIdentity, request, context) : noteOperation ? await executeNotesCommand(invocation, bytes, inputIdentity, request, context) : fieldOperation ? await executeFieldsCommand(invocation, bytes, inputIdentity, request, context) : bookmarkOperation ? await executeBookmarksCommand(invocation, bytes, inputIdentity, request, context) : linkOperation ? await executeLinksCommand(invocation, bytes, inputIdentity, request, context) : tableOperation ? await executeTableEditCommand(invocation, bytes, inputIdentity, request, context) : listOperation ? await executeListsCommand(invocation, bytes, inputIdentity, request, context) : storyOperation ? await executeStoriesCommand(invocation, bytes, inputIdentity, request, context) : invocation.operation.startsWith("sections.") ? await executeSectionsCommand(invocation, bytes, inputIdentity, request, context) : invocation.operation === "batch" ? await executeBatchCommand(invocation, bytes, inputIdentity, request, context) : invocation.operation.startsWith("styles.") ? await executeStylesCommand(invocation, bytes, inputIdentity, request, context) : ["paragraphs.remove", "runs.remove", "tables.remove"].includes(invocation.operation) ? await executeContentRemovalCommand(invocation, bytes, inputIdentity, request, context) : ["paragraphs.set", "paragraphs.add", "runs.add", "tables.add"].includes(invocation.operation) ? await executeParagraphEditCommand(invocation, bytes, inputIdentity, request, context) : invocation.operation === "runs.set" ? await executeRunFormatCommand(invocation, bytes, inputIdentity, request, context) : ["sanitize", "text.replace", "lorem.set"].includes(invocation.operation) ? await executeTextReplaceCommand(invocation, bytes, inputIdentity, request, context) : await executeXmlCommand(invocation, bytes, inputIdentity, request, context, io);
+            budget.check("serializedOutput", output.length);
+          } else if (invocation.operation === "revisions.list") {
+            const data = await inspectDocumentRevisions(bytes, invocation.options, context, "resource");
+            const human = data.items.map((item, i) => {
+              const field = (name) => escapeTerminalText(String(item.properties.find((property) => property.name === name)?.value ?? "unknown"));
+              return `${i + 1}. ${field("markup")} (ID ${field("id")}): ${field("support")}; ${field("author")}; ${field("stored_timestamp")}`;
+            }).join("\n") + (data.items.length ? "\n" : "");
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: 0, locations: data.items.map((i) => i.location), warnings: [], errors: [] }) + "\n" : human);
+            budget.check("serializedOutput", output.length);
+          } else if (invocation.operation === "fields.list") {
+            const data = await inspectDocumentFields(bytes, invocation.options, context);
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: 0, locations: data.items.map((i) => i.location), warnings: [], errors: [] }) + "\n" : data.items.map((item, i) => `${i + 1}. ${escapeTerminalText(item.kind)}: ${escapeTerminalText(item.instruction)} \u2192 ${escapeTerminalText(item.result)}`).join("\n") + (data.items.length ? "\n" : ""));
+            budget.check("serializedOutput", output.length);
+          } else if (invocation.operation === "bookmarks.list") {
+            const data = await inspectDocumentBookmarks(bytes, invocation.options, context);
+            const human = [...data.items.map((item, i) => `${i + 1}. ${escapeTerminalText(item.name)} (ID ${escapeTerminalText(item.id)})`), ...data.issues.map((issue) => `Issue: ${escapeTerminalText(issue)}`)].join("\n") + (data.items.length || data.issues.length ? "\n" : "");
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: 0, locations: data.items.map((i) => i.location), warnings: [], errors: [] }) + "\n" : human);
+            budget.check("serializedOutput", output.length);
+          } else if (invocation.operation === "links.list") {
+            const data = await inspectDocumentLinks(bytes, invocation.options, context);
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: "links.list", ok: true, data, affected: 0, locations: data.items.map((i) => i.location), warnings: [], errors: [] }) + "\n" : data.items.map((item, i) => `${i + 1}. ${escapeTerminalText(item.text)} \u2192 ${escapeTerminalText(item.address || "#" + item.fragment)}`).join("\n") + (data.items.length ? "\n" : ""));
+            budget.check("serializedOutput", output.length);
+          } else if (invocation.operation === "paragraphs.list" || invocation.operation === "runs.list") {
+            const read = invocation.operation === "paragraphs.list" ? inspectDocumentParagraphs : inspectDocumentRuns;
+            const data = await read(bytes, invocation.options, context);
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: 0, locations: data.items.map((item) => item.location), warnings: [], errors: [] }) + "\n" : data.items.map((item, index) => `${index + 1}. ${escapeTerminalText(item.text)}
+`).join(""));
+            budget.check("serializedOutput", output.length);
+          } else if (invocation.operation === "paragraphs.get" || invocation.operation === "runs.get") {
+            const read = invocation.operation === "paragraphs.get" ? inspectDocumentParagraph : inspectDocumentRun;
+            const data = await read(bytes, invocation.options, context);
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: 0, locations: [data.item.location], warnings: [], errors: [] }) + "\n" : escapeTerminalText(data.item.text) + "\n");
+            budget.check("serializedOutput", output.length);
+          } else if (invocation.operation === "tables.list") {
+            const data = await inspectDocumentTables(bytes, invocation.options, context);
+            const human = data.items.map((item) => `Table ${item.location.positions.table}: ${item.details.rows} rows; ${item.details.columns} columns
+`).join("");
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: 0, locations: data.items.map((item) => item.location), warnings: [], errors: [] }) + "\n" : human);
+            budget.check("serializedOutput", output.length);
+          } else if (invocation.operation === "tables.get") {
+            const data = await inspectDocumentTable(bytes, invocation.options, context);
+            const details2 = data.item.details;
+            const human = `docx tables get: ${details2.rows} rows; ${details2.columns} columns
+` + details2.cells.map((cell) => `Row ${cell.row}, column ${cell.column} (${cell.rowSpan}x${cell.columnSpan}): ${escapeTerminalText(cell.text)}
+`).join("");
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: invocation.operation, ok: true, data, affected: 0, locations: [data.item.location, ...details2.cells.map((cell) => cell.location)], warnings: [], errors: [] }) + "\n" : human);
+            budget.check("serializedOutput", output.length);
+          } else if (invocation.operation === "capabilities") {
+            const discovery = await inspectDocxCapabilities(bytes, context, request.filesystem);
+            output = new TextEncoder().encode(invocation.options.json ? JSON.stringify({ version: 1, operation: "capabilities", ok: true, data: discovery.data, warnings: [], errors: [], affected: 0, locations: [] }) + "\n" : discovery.human);
+            budget.check("serializedOutput", output.length);
+          } else {
+            const inspectionView = {};
+            const readContext = { ...context, [inspectionLocationView]: inspectionView };
+            const data = invocation.operation === "text.get" ? await extractDocumentText(bytes, context, invocation.options) : invocation.operation === "inspect" ? await inspectDocument2(bytes, readContext) : await validateDocument(bytes, context, invocation.options.profile === void 0 ? {} : { profile: invocation.options.profile });
+            const locations = [];
+            if ("segments" in data) locations.push(...new Map(data.segments.map((segment) => [segment.location.token, segment.location])).values());
+            if (invocation.operation === "inspect")
+              locations.push(...selectInspectionLocations(inspectionView.document, inspectionView.roots, invocation.options));
+            const valid = !("valid" in data) || data.valid;
+            exitCode = valid ? 0 : 1;
+            const warnings = "warnings" in data ? data.warnings.map((warning) => typeof warning === "string" ? { code: "partial-validation", message: warning } : warning) : [];
+            const errors = "diagnostics" in data ? data.diagnostics.map((item) => ({ code: "invalid-package", message: item.message, part: item.part, location: item.location })) : [];
+            const human = "text" in data ? data.text : "valid" in data ? `docx validate: ${data.valid ? "valid within" : "invalid within"} ${data.profile}
+${data.checks.map((check) => `${check.id}: ${check.status}`).join("\n")}
+` : `docx inspect: ${data.kind}, ${data.dialect}
+Parts: ${data.parts.length}; paragraphs: ${data.counts.paragraphs}; tables: ${data.counts.tables}; images: ${data.counts.images}
+Cached pages: ${data.counts.cachedPages ?? "unknown"}; rendered pages: not calculated
+Themes: ${data.fontResources.themes.length}; font tables: ${data.fontResources.fontTables.length}; unresolved font/theme references: ${data.fontResources.diagnostics.length}
+Font references do not establish installed fonts or licensing.
+Signatures present: ${data.signed}; signatures verified: not performed
+Protected: ${data.protected}
+`;
+            const diagnostic = warnings.map((warning) => `docx: ${escapeTerminalText(warning.code)}: ${escapeTerminalText(warning.message)}
+`).join("") + errors.map((error) => `docx: ${escapeTerminalText(error.code)}: ${escapeTerminalText(error.message)}
+`).join("");
+            budget.check("diagnosticBytes", new TextEncoder().encode(diagnostic).length);
+            output = new TextEncoder().encode(invocation.options.json === true ? JSON.stringify({ version: 1, operation: invocation.operation, ok: valid, data: valid ? data : null, warnings, errors, affected: 0, locations }) + "\n" : human);
+            budget.check("serializedOutput", output.length);
+            if (diagnostic) {
+              writingDiagnostics = true;
+              await request.stderr.write(new TextEncoder().encode(diagnostic));
+              request.signal.throwIfAborted();
+              writingDiagnostics = false;
+            }
+          }
+        }
+      } catch (error) {
+        if (error instanceof ArchiveExtractionError) {
+          archiveReceipt = error.data;
+          const diagnostic2 = commandDiagnostic(error.message, error.code, budget.limits.diagnosticBytes);
+          const envelope = { version: 1, operation: "extract", ok: false, data: error.data, affected: 0, locations: [], warnings: [], errors: [{ code: error.code, message: error.message }] };
+          try {
+            if (invocation.options.json) await request.stdout.write(new TextEncoder().encode(JSON.stringify(envelope) + "\n"));
+            await request.stderr.write(new TextEncoder().encode(diagnostic2.human));
+          } catch (cause) {
+            return sinkFailure(cause);
+          }
+          if (error.code === "cancelled") throw error;
+          return { exitCode: error.code === "limit-exceeded" ? 4 : error.code === "conflict" ? 1 : 3, extraction: error.data };
+        }
+        if (["images.extract", "objects.extract"].includes(invocation.operation) && (error instanceof ImageExtractionCancellationError2 || error instanceof ObjectExtractionCancellationError2)) throw error;
+        const cancelled = request.signal.aborted || error instanceof CancellationError7;
+        if (writingDiagnostics) return { exitCode: cancelled ? 130 : invocation.operation === "diff" ? 2 : 3 };
+        const code = cancelled ? "cancelled" : error instanceof ResourceLimitError4 ? "limit-exceeded" : asPermissionError6(error) ? "permission" : acquiring ? "source-failure" : error && typeof error === "object" && "code" in error ? String(error.code) : "invalid-package";
+        exitCode = error instanceof ResourceLimitError4 ? 4 : code === "conflict" ? 1 : acquiring || error instanceof PublicationError34 || code === "permission" || code === "source-failure" || code === "sink-failure" ? 3 : code === "usage" ? 2 : 1;
+        if (cancelled) exitCode = 130;
+        else if (invocation.operation === "diff") exitCode = 2;
+        const failureMessage = acquiring ? "Unable to read the declared document input." : error instanceof PublicationError34 && error.stdoutMayBePartial ? "Binary stdout may contain partial output." : error instanceof UnsupportedEmbeddedFontMutationError ? error.message : "Document operation failed: " + code;
+        const detail = code === "usage" && error instanceof Error && error.message ? ` (${error.message})` : "";
+        const recoveryMessage = code === "usage" ? `${failureMessage}${detail}. See docx help ${invocation.operation.split(".").join(" ")} for accepted arguments and data schemas.` : code === "missing-selection" && invocation.operation === "text.replace" ? `${failureMessage}. Review --find, --scope and selection; see docx help text replace. Use --allow-empty only when a no-match result is intended.` : failureMessage;
+        const diagnostic = commandDiagnostic(recoveryMessage, code, budget.limits.diagnosticBytes);
+        const message = diagnostic.message;
+        const batchFailure = invocation.operation === "batch" && error instanceof Error && "operationIndex" in error ? { operationIndex: error.operationIndex, ..."operationId" in error ? { operationId: error.operationId } : {} } : {};
+        const imageFailure = ["images.extract", "objects.extract"].includes(invocation.operation) && (error instanceof ImageCommandPublicationError || error instanceof ObjectCommandPublicationError) ? error : void 0;
+        const locatedFailure = error instanceof UnsupportedDiagramMutationError || error instanceof UnsupportedEquationMutationError ? error : void 0;
+        if (imageFailure) imageReceipt = imageFailure.data;
+        output = imageFailure ? imageFailure.responseBytes : locatedFailure && invocation.options.json === true ? serializeDiagramMutationFailure(invocation.operation, locatedFailure, code, message, budget) : new TextEncoder().encode(invocation.options.json === true ? JSON.stringify({ version: 1, operation: invocation.operation, ok: false, data: null, warnings: [], errors: [{ code, message, ...batchFailure }], affected: 0, locations: [] }) + "\n" : "");
+        try {
+          await request.stderr.write(imageFailure ? imageFailure.diagnosticBytes : new TextEncoder().encode(diagnostic.human));
+        } catch (cause) {
+          return sinkFailure(cause);
+        }
+      } finally {
+        await io.cleanup();
+      }
+      try {
+        if (output.length) await request.stdout.write(output);
+      } catch (cause) {
+        return sinkFailure(cause);
+      }
+      if (request.signal.aborted) return sinkFailure(request.signal.reason);
+      return { exitCode, ...archiveReceipt ? { extraction: archiveReceipt } : {} };
+    }
+  }, { compressedInput: limits.maxArchiveBytes, expandedPackage: limits.maxTotalBytes, zipEntries: limits.maxMembers, retainedBytes: limits.maxRetainedBytes, xmlPartBytes: Math.min(limits.maxEntryBytes, documentLimitDefaults.xmlPartBytes), ...options.documentLimits });
+}
+
+export {
+  parseDocxArguments,
+  createDocxCommandEngine,
+  SourceError2 as SourceError,
+  validateDocxInvocation,
+  validateDocxBatch2 as validateDocxBatch,
+  getDocxDiscovery,
+  inspectDocxCapabilities,
+  createDocxInspectionCommandEngine
+};