@poe-platform/safe-bash 0.1.812 → 0.1.814

package/dist/safe-bash/command-chunks/{command-engine-BCUQGJJ4.js → command-engine-7V6PZR7G.js}

@@ -1,10 +1,295 @@
 import "./chunk-37XCUS43.js";
-import "./chunk-IOEUZ4EA.js";
+import {
+  ZipDirectoryIndex
+} from "./chunk-IOEUZ4EA.js";
 import {
   yieldEventLoop
 } from "./chunk-E6SK3OU2.js";
+import {
+  BackedJson,
+  parseBackedJson
+} from "./chunk-NUGQQDGE.js";
 import "./chunk-65DS4IOB.js";
 
+// packages/safe-bash-command-pptx/src/retained-pack-manifest.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+import { resourceContext } from "../../safe-bash-presentation-engine/resource-limits.js";
+import { OfficeError as OfficeError2 } from "../../safe-bash-presentation-engine/errors.js";
+import { asciiKey, partName } from "../../safe-bash-presentation-engine/package-uri.js";
+
+// packages/safe-bash-command-pptx/src/command-package-path.ts
+import { OfficeError } from "../../safe-bash-presentation-engine/errors.js";
+function usage(message) {
+  throw new OfficeError("invalid-value", message, "usage");
+}
+function scopedPackagePath(manifest, path) {
+  if (path === "-") return path;
+  if (path.includes("\\") || [...path].some((c) => c.charCodeAt(0) < 32))
+    usage("Invalid scoped file path.");
+  const prefix = path.startsWith("/") ? "" : manifest === "-" ? "/" : manifest.slice(0, manifest.lastIndexOf("/") + 1);
+  const absolute = (prefix + path).startsWith("/");
+  const segments = [];
+  for (const segment of (prefix + path).split("/")) {
+    if (!segment || segment === ".") continue;
+    if (segment === "..") {
+      if (!segments.length) usage("Scoped path escapes its root.");
+      segments.pop();
+    } else segments.push(segment);
+  }
+  return (absolute ? "/" : "") + segments.join("/");
+}
+
+// packages/safe-bash-command-pptx/src/retained-pack-manifest.ts
+async function openRetainedPackManifest(source3, settings, options2) {
+  const context = resourceContext(settings), signal = context.signal ?? new AbortController().signal;
+  const working = { ...settings.workingStorage }, cacheBytes = working.cacheBytes ?? 1024 * 1024;
+  if (!working.fs || typeof working.directory !== "string" || !working.directory.startsWith("/") || !Number.isSafeInteger(cacheBytes) || cacheBytes < 16384 || cacheBytes % 16384)
+    throw new OfficeError2("invalid-value", "Explicit manifest storage and a valid cache budget are required.", "usage");
+  const manifestPath = options2.manifest, outputPath = options2.output;
+  const pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, cacheBytes / 16384);
+  const index = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, cacheBytes / 16384);
+  let closed = false, closing, count = 0, parts = 0;
+  const check = () => {
+    if (closed) throw new OfficeError2("invalid-handle", "Manifest is closed.", "admit");
+    if (signal.aborted) throw new OfficeError2("cancelled", "Operation cancelled.", "admit");
+  };
+  const usage14 = () => {
+    throw new OfficeError2("invalid-value", "Manifest requires unique canonical parts, hashes and explicit scoped files.", "usage");
+  };
+  const limit = () => {
+    throw new OfficeError2("resource-limit", "Manifest exceeds input limits.", "admit");
+  };
+  const failure = (error) => error instanceof OfficeError2 ? error : new OfficeError2(signal.aborted ? "cancelled" : error && typeof error === "object" && "code" in error && error.code === "EFBIG" ? "resource-limit" : "io-failure", "Manifest input or storage failed.", "admit");
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const outcomes = await Promise.allSettled([pages.close(), index.close()]);
+      for (const outcome of outcomes) if (outcome.status === "rejected") throw outcome.reason;
+    })();
+  };
+  let work = 0;
+  const cooperate = async (units = 1) => {
+    check();
+    work += units;
+    if (work >= 4096) {
+      work = 0;
+      await yieldEventLoop();
+      check();
+    }
+  };
+  const tree = new BackedJson(pages, cooperate), names = new ZipDirectoryIndex(index, { signal });
+  async function text2(position) {
+    let value = "";
+    for await (const fragment of tree.scalarChunks(position)) {
+      check();
+      value += fragment;
+    }
+    return value;
+  }
+  async function fields2(position, keys) {
+    const header = await tree.describe(position);
+    if (header.kind !== "object" || header.children !== keys.length * 2) usage14();
+    const result = {};
+    let key;
+    for await (const child of tree.children(position)) {
+      check();
+      if (key === void 0) {
+        key = await tree.smallText(child, Math.max(...keys.map((key2) => key2.length)));
+        if (key === void 0 || !keys.includes(key)) usage14();
+      } else {
+        result[key] = child;
+        key = void 0;
+      }
+    }
+    return result;
+  }
+  async function member(row) {
+    const fields3 = { part: await tree.property(row, "part"), sha256: await tree.property(row, "sha256") };
+    const part = await tree.smallText(fields3.part, 65535), sha2565 = await tree.smallText(fields3.sha256, 64);
+    if (part === void 0) return limit();
+    if (sha2565 === void 0) return usage14();
+    return { part, sha256: sha2565 };
+  }
+  async function pathAt(row) {
+    const file = await tree.property(row, "file"), path = await tree.property(file, "vfsPath");
+    return scopedPackagePath(manifestPath, await text2(path));
+  }
+  async function* decoded() {
+    let iterator, exhausted = false, size = 0;
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    try {
+      iterator = source3[Symbol.asyncIterator]();
+      for (let reads = 0; reads < context.limits.maxReads; reads++) {
+        await cooperate();
+        const item = await iterator.next();
+        check();
+        if (item.done) {
+          exhausted = true;
+          let tail;
+          try {
+            tail = decoder.decode();
+          } catch {
+            usage14();
+          }
+          if (tail) yield tail;
+          return;
+        }
+        if (!(item.value instanceof Uint8Array)) throw new OfficeError2("invalid-type", "Manifest source returned invalid bytes.", "admit");
+        size += item.value.length;
+        if (!Number.isSafeInteger(size) || size > Math.min(context.limits.maxBytes, context.xmlLimits.maxBytes)) limit();
+        for (let offset = 0; offset < item.value.length; offset += 16384) {
+          check();
+          let fragment;
+          try {
+            fragment = decoder.decode(item.value.subarray(offset, offset + 16384), { stream: true });
+          } catch {
+            usage14();
+          }
+          if (fragment) yield fragment;
+        }
+      }
+      limit();
+    } finally {
+      if (!exhausted) try {
+        await iterator?.return?.();
+      } catch {
+      }
+    }
+  }
+  try {
+    check();
+    await parseBackedJson(decoded(), tree, index, cooperate, usage14, void 0, false, (depth) => {
+      if (depth > 32) usage14();
+    });
+    parts = (await fields2(tree.rootPosition, ["parts"])).parts;
+    const array = await tree.describe(parts);
+    if (array.kind !== "array" || !array.children) usage14();
+    count = array.children;
+    if (count > context.archiveLimits.maxMembers) limit();
+    let stdin = manifestPath === "-" ? 1 : 0;
+    if (outputPath !== "-" && outputPath === manifestPath) usage14();
+    for await (const row of tree.children(parts)) {
+      check();
+      const values3 = await fields2(row, ["part", "sha256", "file"]);
+      for (const key2 of ["part", "sha256"]) if ((await tree.describe(values3[key2])).kind !== "string") usage14();
+      const item = await member(row);
+      try {
+        if (partName(item.part, false) !== item.part) usage14();
+      } catch {
+        usage14();
+      }
+      if (item.sha256.length !== 64 || [...item.sha256].some((character) => !"0123456789abcdef".includes(character))) usage14();
+      const key = asciiKey(item.part);
+      if (await names.get(key) !== void 0) usage14();
+      await names.set(key, row);
+      const file = await fields2(values3.file, ["vfsPath"]);
+      if ((await tree.describe(file.vfsPath)).kind !== "string") usage14();
+      const rawPath = await text2(file.vfsPath);
+      if (!rawPath.length) usage14();
+      const path = scopedPackagePath(manifestPath, rawPath);
+      if (path === "-" && ++stdin > 1 || outputPath !== "-" && path === outputPath) usage14();
+    }
+    return Object.freeze({
+      count,
+      close,
+      async *members() {
+        try {
+          check();
+          for await (const row of tree.children(parts)) {
+            check();
+            yield await member(row);
+          }
+          check();
+        } catch (error) {
+          throw failure(error);
+        }
+      },
+      async path(part) {
+        try {
+          check();
+          const row = await names.get(asciiKey(part));
+          if (row === void 0) throw new OfficeError2("missing-binding", "Manifest member is absent.", "admit");
+          return await pathAt(row);
+        } catch (error) {
+          throw failure(error);
+        }
+      },
+      async *paths() {
+        try {
+          check();
+          yield manifestPath;
+          for await (const row of tree.children(parts)) {
+            check();
+            yield await pathAt(row);
+          }
+          check();
+        } catch (error) {
+          throw failure(error);
+        }
+      }
+    });
+  } catch (error) {
+    const primary = failure(error);
+    await close().catch(() => {
+    });
+    throw primary;
+  }
+}
+
+// packages/safe-bash-command-pptx/src/command-engine.ts
+import { stageRetainedPackage } from "../../safe-bash-presentation-engine/package-tools.js";
+
+// packages/safe-bash-command-pptx/src/command-extract-streaming.ts
+import { openRetainedPackageExtraction, stageRetainedExtractionOutput } from "../../safe-bash-presentation-engine/package-tools.js";
+import { OfficeError as OfficeError3 } from "../../safe-bash-presentation-engine/errors.js";
+async function prepareRetainedExtraction(args, request, options2) {
+  const { streaming, signal } = request, context = { ...options2.context, signal, workingStorage: streaming.workingStorage };
+  const input = await streaming.openInput(args.input, Math.min(context.limits.maxBytes, context.archiveLimits.maxArchiveBytes));
+  const extraction = await openRetainedPackageExtraction(input, context, args.parts ? { parts: args.parts } : {});
+  let response, closing;
+  const close = () => closing ??= (async () => {
+    const results = await Promise.allSettled([response?.close(), extraction.close()]);
+    for (const result of results) if (result.status === "rejected") throw result.reason;
+  })();
+  try {
+    let total = 0;
+    for await (const member of extraction.members()) total += member.size;
+    if (extraction.count > (args.limits?.maxOutputs ?? context.archiveLimits.maxMembers) || !Number.isSafeInteger(total) || total > options2.maxOutputBytes)
+      throw new OfficeError3("resource-limit", "Package extraction exceeds output limits.", "validate-intent");
+    if (!request.publishOutputStreams && (!args.allowPartialOutput || !request.publishOutput)) throw Object.assign(new Error("Extraction requires a publication capability."), { code: "publication-unsupported" });
+    response = await stageRetainedExtractionOutput(extraction, context, { directory: args.outputDir, json: args.json, maxOutputBytes: options2.maxOutputBytes, allowPartialOutput: args.allowPartialOutput ?? false });
+    async function* publications(dryRun) {
+      for await (const member of extraction.members()) {
+        signal.throwIfAborted();
+        yield { inputPath: args.input, outputPath: response.path(member.name), bytes: member.bytes(), originalBytes: input, inPlace: false, force: args.force ?? false, dryRun };
+      }
+    }
+    return { close, async publish() {
+      let published = 0, code;
+      try {
+        for await (const item of publications(true)) {
+          if (request.preflightOutputStream) await request.preflightOutputStream(item);
+          else if (request.publishOutput) await request.publishOutput(item);
+        }
+        if (request.publishOutputStreams) await request.publishOutputStreams(publications(false));
+        else for await (const item of publications(false)) {
+          await request.publishOutput(item);
+          published++;
+        }
+      } catch (error) {
+        const raw = error && typeof error === "object" && "code" in error ? error.code : void 0;
+        code = signal.aborted ? "cancelled" : typeof raw === "string" && ["resource-limit", "stale-input", "publication-unsupported"].includes(raw) ? raw : "io-failure";
+      }
+      await response.write(!code || args.json ? streaming.stdout : streaming.stderr, code ? { code, published } : void 0);
+      return { exitCode: !code ? 0 : code === "cancelled" ? 130 : code === "resource-limit" ? 4 : code === "stale-input" ? 1 : 3, stdout: new Uint8Array(), stderr: new Uint8Array() };
+    } };
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+
 // packages/safe-bash-command-pptx/src/command-engine.ts
 import { stageRetainedText } from "../../safe-bash-presentation-engine/retained-text.js";
 import { stageRetainedInspection } from "../../safe-bash-presentation-engine/retained-inspection.js";
@@ -12,7 +297,7 @@ import { openPackageArchive } from "../../safe-bash-presentation-engine/retained
 
 // packages/safe-bash-command-pptx/src/capabilities-discovery.ts
 import { parseContentTypes } from "../../safe-bash-presentation-engine/content-types.js";
-import { OfficeError } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError4 } from "../../safe-bash-presentation-engine/errors.js";
 import { readRelationshipGraph } from "../../safe-bash-presentation-engine/relationships.js";
 import { readPackage } from "../../safe-bash-presentation-engine/package-reader.js";
 import { parseXmlPart } from "../../safe-bash-presentation-engine/xml.js";
@@ -49,7 +334,7 @@ function declaredFeatureCapabilities(features, operations) {
     Object.entries(features).map(([name, feature]) => {
       const paths = feature.operations ?? (feature.operation ? [feature.operation] : featureOperations[name]);
       if (!paths?.length || paths.some((path) => !Object.hasOwn(operations, path))) {
-        throw new OfficeError(
+        throw new OfficeError4(
           "invalid-value",
           "Capability references an undeclared operation.",
           "usage"
@@ -99,7 +384,7 @@ async function assessCapabilities(input, context) {
       try {
         contentType = types.get(part);
       } catch (error) {
-        if (!(error instanceof OfficeError) || error.code !== "missing-binding") throw error;
+        if (!(error instanceof OfficeError4) || error.code !== "missing-binding") throw error;
       }
     }
     const type = contentType?.split(";", 1)[0].trim().toLowerCase();
@@ -114,7 +399,7 @@ async function assessCapabilities(input, context) {
       const data = reader.get(part);
       xmlBytes += data.length;
       if (xmlBytes > context.xmlLimits.maxBytes || nodes >= context.xmlLimits.maxNodes)
-        throw new OfficeError(
+        throw new OfficeError4(
           "resource-limit",
           "Capability XML inspection limit exceeded.",
           "index"
@@ -125,7 +410,7 @@ async function assessCapabilities(input, context) {
       });
       nodes += xml.nodeCount;
       if (nodes > context.xmlLimits.maxNodes)
-        throw new OfficeError("resource-limit", "Capability XML node limit exceeded.", "index");
+        throw new OfficeError4("resource-limit", "Capability XML node limit exceeded.", "index");
       const pending = [xml.root];
       let visited = 0;
       while (pending.length) {
@@ -3464,7 +3749,7 @@ var discoverySchemas = Object.fromEntries([
 }]));
 
 // packages/safe-bash-command-pptx/src/command-objects-add.ts
-import { OfficeError as OfficeError2 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError5 } from "../../safe-bash-presentation-engine/errors.js";
 import { addOleObject } from "../../safe-bash-presentation-engine/ole-insertion.js";
 var objectsAddUsage = "Usage: pptx objects add INPUT --slide N --file PATH --icon PATH (--program-id TEXT | --program DOCX|PPTX|XLSX) [--icon-content-type TYPE]\n  --left LENGTH --top LENGTH --width LENGTH --height LENGTH --icon-width LENGTH --icon-height LENGTH --name TEXT\n  --output PATH|--in-place|--dry-run [--force] [--json] [--limit NAME=VALUE]\nEmbed explicit inert bytes with an explicit icon. No activation or recursive payload parsing.\n";
 var length = {
@@ -3571,24 +3856,24 @@ var objectsAddSchema = {
     }
   }
 };
-function usage(message) {
-  throw new OfficeError2("invalid-value", message, "usage");
+function usage2(message) {
+  throw new OfficeError5("invalid-value", message, "usage");
 }
 function validateObjectsAddCommand(args, positionals, seen) {
   const allowed = Object.keys(objectsAddSchema.options.properties).map(
     (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("")
   );
   if ([...seen].some((flag) => !allowed.includes(flag)))
-    usage("Option does not apply to object insertion.");
+    usage2("Option does not apply to object insertion.");
   if (positionals.length !== 1 || !positionals[0])
-    usage("Object insertion requires exactly one input.");
+    usage2("Object insertion requires exactly one input.");
   args.input = positionals[0];
   if (seen.has("--program-id") && seen.has("--program"))
-    usage("Program and program ID are mutually exclusive.");
+    usage2("Program and program ID are mutually exclusive.");
   if (!args.slide || !args.file || !args.icon || !args.objectAdd?.progId)
-    usage("Object insertion requires slide, file, icon and program ID.");
+    usage2("Object insertion requires slide, file, icon and program ID.");
   if ([args.input, args.file, args.icon].filter((path) => path === "-").length > 1)
-    usage("Only one input may consume stdin.");
+    usage2("Only one input may consume stdin.");
   if (!args.iconContentType) {
     const extension = args.icon.slice(args.icon.lastIndexOf(".") + 1).toLowerCase();
     const type = {
@@ -3601,16 +3886,16 @@ function validateObjectsAddCommand(args, positionals, seen) {
       tiff: "image/tiff",
       wmf: "image/x-wmf"
     };
-    if (!type[extension]) usage("Icon requires a supported extension or explicit content type.");
+    if (!type[extension]) usage2("Icon requires a supported extension or explicit content type.");
     args.iconContentType = type[extension];
   }
   if (args.inPlace && (args.input === "-" || args.output))
-    usage("In-place requires a named input and no output flag.");
-  if (!args.dryRun && !args.inPlace && !args.output) usage("Mutation requires a destination.");
-  if (args.force && !args.output) usage("Force requires an explicit output.");
+    usage2("In-place requires a named input and no output flag.");
+  if (!args.dryRun && !args.inPlace && !args.output) usage2("Mutation requires a destination.");
+  if (args.force && !args.output) usage2("Force requires an explicit output.");
   if (args.output === args.input && args.output !== "-")
-    usage("Replacing input requires --in-place.");
-  if (args.output === "-" && args.json && !args.dryRun) usage("Binary stdout conflicts with JSON.");
+    usage2("Replacing input requires --in-place.");
+  if (args.output === "-" && args.json && !args.dryRun) usage2("Binary stdout conflicts with JSON.");
 }
 async function executeObjectsAddCommand(args, request, options2) {
   const context = { ...options2.context, signal: request.signal };
@@ -3802,7 +4087,7 @@ var packageToolsSchemas = Object.fromEntries(
 );
 
 // packages/safe-bash-command-pptx/src/command-engine-values.ts
-import { OfficeError as OfficeError3 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError6 } from "../../safe-bash-presentation-engine/errors.js";
 function commandLength(value, minimum = 1) {
   const units = { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700 };
   const unit = Object.keys(units).find((candidate) => value.endsWith(candidate));
@@ -3811,7 +4096,7 @@ function commandLength(value, minimum = 1) {
   if (!unit || pieces.length > 2 || !pieces[0] || pieces.some(
     (piece) => !piece || [...piece].some((character) => character < "0" || character > "9")
   ))
-    throw new OfficeError3(
+    throw new OfficeError6(
       "invalid-value",
       "Lengths require a decimal and emu, in, cm, mm or pt unit.",
       "usage"
@@ -3819,13 +4104,13 @@ function commandLength(value, minimum = 1) {
   const raw = Number(digits) * units[unit];
   const result = Math.sign(raw) * Math.round(Math.abs(raw));
   if (!Number.isFinite(raw) || Math.abs(raw) > Number.MAX_SAFE_INTEGER || !Number.isSafeInteger(result) || result < minimum)
-    throw new OfficeError3("invalid-value", "Length is outside the supported range.", "usage");
+    throw new OfficeError6("invalid-value", "Length is outside the supported range.", "usage");
   return result;
 }
 function commandTimestamp(value) {
   const date = new Date(value);
   if (!Number.isFinite(date.getTime()) || !value.endsWith("Z") || date.toISOString() !== value && date.toISOString() !== value.slice(0, -1) + ".000Z")
-    throw new OfficeError3(
+    throw new OfficeError6(
       "invalid-value",
       "Timestamp requires a valid UTC date with seconds and Z suffix.",
       "usage"
@@ -3859,7 +4144,7 @@ function commandJson(value) {
     }
     return JSON.parse(value);
   } catch {
-    throw new OfficeError3(
+    throw new OfficeError6(
       "invalid-value",
       "Structured slides require valid JSON without duplicate keys, at most 32 levels deep.",
       "usage"
@@ -3869,31 +4154,15 @@ function commandJson(value) {
 
 // packages/safe-bash-command-pptx/src/command-package-tools.ts
 import { sha256 } from "@noble/hashes/sha2.js";
-import { OfficeError as OfficeError4 } from "../../safe-bash-presentation-engine/errors.js";
-import { asciiKey, partName } from "../../safe-bash-presentation-engine/package-uri.js";
+import { OfficeError as OfficeError7 } from "../../safe-bash-presentation-engine/errors.js";
+import { asciiKey as asciiKey2, partName as partName2 } from "../../safe-bash-presentation-engine/package-uri.js";
 import { extractPackage, packPackage } from "../../safe-bash-presentation-engine/package-tools.js";
-function usage2(message) {
-  throw new OfficeError4("invalid-value", message, "usage");
-}
-function scopedPath(manifest, path) {
-  if (path === "-") return path;
-  if (path.includes("\\") || [...path].some((c) => c.charCodeAt(0) < 32))
-    usage2("Invalid scoped file path.");
-  const prefix = path.startsWith("/") ? "" : manifest === "-" ? "/" : manifest.slice(0, manifest.lastIndexOf("/") + 1);
-  const absolute = (prefix + path).startsWith("/");
-  const segments = [];
-  for (const segment of (prefix + path).split("/")) {
-    if (!segment || segment === ".") continue;
-    if (segment === "..") {
-      if (!segments.length) usage2("Scoped path escapes its root.");
-      segments.pop();
-    } else segments.push(segment);
-  }
-  return (absolute ? "/" : "") + segments.join("/");
+function usage3(message) {
+  throw new OfficeError7("invalid-value", message, "usage");
 }
 function canonical(part) {
   try {
-    return typeof part === "string" && partName(part, false) === part;
+    return typeof part === "string" && partName2(part, false) === part;
   } catch {
     return false;
   }
@@ -3903,23 +4172,23 @@ function validatePackageCommand(args, positionals, seen) {
     (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("")
   );
   if ([...seen].some((flag) => !allowed.includes(flag)))
-    usage2("Option does not apply to package tools.");
+    usage3("Option does not apply to package tools.");
   if (args.operation === "extract") {
-    if (positionals.length !== 1 || !positionals[0]) usage2("Extraction requires one input.");
+    if (positionals.length !== 1 || !positionals[0]) usage3("Extraction requires one input.");
     args.input = positionals[0];
     if (!args.outputDir || args.outputDir === "-")
-      usage2("Extraction requires an output directory.");
-    if (args.parts && (!args.parts.length || args.parts.some((part) => !canonical(part)) || new Set(args.parts.map(asciiKey)).size !== args.parts.length))
-      usage2("Parts require unique canonical part URIs.");
+      usage3("Extraction requires an output directory.");
+    if (args.parts && (!args.parts.length || args.parts.some((part) => !canonical(part)) || new Set(args.parts.map(asciiKey2)).size !== args.parts.length))
+      usage3("Parts require unique canonical part URIs.");
   } else {
     if (positionals.length || !args.manifest)
-      usage2("Pack requires a manifest and no positional inputs.");
-    if (!args.output && !args.dryRun) usage2("Pack requires output or dry-run.");
-    if (args.force && !args.output) usage2("Force requires output.");
+      usage3("Pack requires a manifest and no positional inputs.");
+    if (!args.output && !args.dryRun) usage3("Pack requires output or dry-run.");
+    if (args.force && !args.output) usage3("Force requires output.");
     if (args.output === "-" && args.json && !args.dryRun)
-      usage2("Binary stdout cannot be combined with JSON.");
+      usage3("Binary stdout cannot be combined with JSON.");
     if (args.output === args.manifest && args.output !== "-")
-      usage2("Output cannot replace manifest.");
+      usage3("Output cannot replace manifest.");
   }
 }
 async function executePackageCommand(args, request, options2) {
@@ -3940,7 +4209,7 @@ async function executePackageCommand(args, request, options2) {
     );
     const files = await extractPackage(bytes2, context, args.parts ? { parts: args.parts } : {});
     if (files.length > (args.limits?.maxOutputs ?? context.archiveLimits.maxMembers) || files.reduce((sum, file) => sum + file.bytes.length, 0) > options2.maxOutputBytes)
-      throw new OfficeError4(
+      throw new OfficeError7(
         "resource-limit",
         "Package extraction exceeds output limits.",
         "validate-intent"
@@ -3972,7 +4241,7 @@ async function executePackageCommand(args, request, options2) {
     };
   }
   if (args.creation?.author !== void 0 || args.creation?.timestamp !== void 0)
-    throw new OfficeError4(
+    throw new OfficeError7(
       "unsupported-edit",
       "Pack metadata overrides are unavailable; source properties are preserved.",
       "validate-intent"
@@ -3982,28 +4251,28 @@ async function executePackageCommand(args, request, options2) {
     Math.min(context.limits.maxBytes, context.xmlLimits.maxBytes)
   );
   if (encoded.length > Math.min(context.limits.maxBytes, context.xmlLimits.maxBytes))
-    throw new OfficeError4("resource-limit", "Manifest exceeds byte limit.", "admit");
+    throw new OfficeError7("resource-limit", "Manifest exceeds byte limit.", "admit");
   let value;
   try {
     value = commandJson(new TextDecoder("utf-8", { fatal: true }).decode(encoded));
   } catch {
-    usage2("Manifest must be valid JSON.");
+    usage3("Manifest must be valid JSON.");
   }
   if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => key !== "parts") || !("parts" in value) || !Array.isArray(value.parts) || !value.parts.length)
-    usage2("Manifest requires a nonempty parts array.");
+    usage3("Manifest requires a nonempty parts array.");
   if (value.parts.length > context.archiveLimits.maxMembers)
-    throw new OfficeError4("resource-limit", "Manifest exceeds member limit.", "admit");
+    throw new OfficeError7("resource-limit", "Manifest exceeds member limit.", "admit");
   const parts = value.parts;
   for (const item of parts)
     if (!item || typeof item !== "object" || Object.keys(item).some((key) => !["part", "sha256", "file"].includes(key)) || !canonical(item.part) || typeof item.sha256 !== "string" || item.sha256.length !== 64 || [...item.sha256].some((c) => !"0123456789abcdef".includes(c)) || !item.file || typeof item.file !== "object" || Object.keys(item.file).length !== 1 || typeof item.file.vfsPath !== "string" || !item.file.vfsPath.length)
-      usage2("Manifest parts require canonical URIs, hashes and explicit scoped files.");
-  if (new Set(parts.map((item) => asciiKey(item.part))).size !== parts.length)
-    usage2("Manifest parts must be unique.");
-  const paths = parts.map((item) => scopedPath(args.manifest, item.file.vfsPath));
+      usage3("Manifest parts require canonical URIs, hashes and explicit scoped files.");
+  if (new Set(parts.map((item) => asciiKey2(item.part))).size !== parts.length)
+    usage3("Manifest parts must be unique.");
+  const paths = parts.map((item) => scopedPackagePath(args.manifest, item.file.vfsPath));
   if ([args.manifest, ...paths].filter((path) => path === "-").length > 1)
-    usage2("Only one manifest input may consume stdin.");
+    usage3("Only one manifest input may consume stdin.");
   if (args.output !== "-" && paths.includes(args.output))
-    usage2("Output cannot replace a source file.");
+    usage3("Output cannot replace a source file.");
   let total = 0;
   const members = [];
   for (const [index, item] of parts.entries()) {
@@ -4014,7 +4283,7 @@ async function executePackageCommand(args, request, options2) {
     );
     total += bytes2.length;
     if (bytes2.length > context.archiveLimits.maxEntryBytes || total > context.archiveLimits.maxTotalBytes)
-      throw new OfficeError4("resource-limit", "Manifest contents exceed byte limit.", "admit");
+      throw new OfficeError7("resource-limit", "Manifest contents exceed byte limit.", "admit");
     members.push({ part: item.part, sha256: item.sha256, bytes: bytes2 });
   }
   const bytes = await packPackage(
@@ -4023,7 +4292,7 @@ async function executePackageCommand(args, request, options2) {
     args.creation?.kind ? { kind: args.creation.kind } : {}
   );
   if (bytes.length > options2.maxOutputBytes)
-    throw new OfficeError4("resource-limit", "Packed output exceeds byte limit.", "validate-intent");
+    throw new OfficeError7("resource-limit", "Packed output exceeds byte limit.", "validate-intent");
   const dryRun = args.dryRun ?? false;
   const fingerprint = [...sha256(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
   if (args.output && args.output !== "-" && !request.publishOutput)
@@ -4059,7 +4328,7 @@ async function executePackageCommand(args, request, options2) {
 }
 
 // packages/safe-bash-command-pptx/src/command-diff.ts
-import { OfficeError as OfficeError5 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError8 } from "../../safe-bash-presentation-engine/errors.js";
 import { comparePresentations } from "../../safe-bash-presentation-engine/diff.js";
 
 // packages/safe-bash-command-pptx/src/diff-schema.ts
@@ -4165,7 +4434,7 @@ async function executeDiffCommand(request, options2) {
   let human = "";
   let exitCode = 0;
   const failure = (error) => {
-    const office = error instanceof OfficeError5 ? error : void 0;
+    const office = error instanceof OfficeError8 ? error : void 0;
     const code = request.signal.aborted ? "cancelled" : office?.code ?? (error && typeof error === "object" && "code" in error && error.code === "resource-limit" ? "resource-limit" : "io-failure");
     exitCode = code === "cancelled" ? 130 : 2;
     const message = office?.message ?? (code === "cancelled" ? "Comparison cancelled." : "Comparison input could not be read.");
@@ -4182,20 +4451,20 @@ async function executeDiffCommand(request, options2) {
       errors: [{ code, message, context: { phase: office?.phase ?? "admit" } }]
     };
   };
-  const usage13 = (message) => {
-    throw new OfficeError5("invalid-value", message, "usage");
+  const usage14 = (message) => {
+    throw new OfficeError8("invalid-value", message, "usage");
   };
   try {
     let byteCount = 0;
     const args = request.args.map((bytes2) => {
-      if (!(bytes2 instanceof Uint8Array)) usage13("Arguments must be byte arrays.");
+      if (!(bytes2 instanceof Uint8Array)) usage14("Arguments must be byte arrays.");
       byteCount += bytes2.byteLength;
       if (byteCount > options2.maxArgumentBytes)
-        throw new OfficeError5("resource-limit", "Argument limit exceeded.", "admit");
+        throw new OfficeError8("resource-limit", "Argument limit exceeded.", "admit");
       try {
         return new TextDecoder("utf-8", { fatal: true }).decode(bytes2);
       } catch {
-        return usage13("Arguments must be UTF-8.");
+        return usage14("Arguments must be UTF-8.");
       }
     });
     const delimiter = args.indexOf("--");
@@ -4214,31 +4483,31 @@ async function executeDiffCommand(request, options2) {
       }
       if (!positionalOnly && arg.startsWith("-") && arg !== "-") {
         if (!["--json", "--mode", "--limit", "--help"].includes(arg))
-          usage13("Unknown comparison option.");
-        if (seen.has(arg) && arg !== "--limit") usage13("Duplicate comparison option.");
+          usage14("Unknown comparison option.");
+        if (seen.has(arg) && arg !== "--limit") usage14("Duplicate comparison option.");
         seen.add(arg);
         if (arg === "--json" || arg === "--help") continue;
         const value = args[++i];
-        if (!value) usage13("Comparison option requires a value.");
+        if (!value) usage14("Comparison option requires a value.");
         if (arg === "--mode") {
-          if (!diffModes.includes(value)) usage13("Unsupported comparison mode.");
+          if (!diffModes.includes(value)) usage14("Unsupported comparison mode.");
           mode = value;
         } else {
           const parts = value.split("=");
           const name = parts[0];
           const number = Number(parts[1]);
           if (parts.length !== 2 || !["maxBytes", "maxNodes", "maxDepth", "maxOutputBytes"].includes(name) || !parts[1] || ![...parts[1]].every((c) => c >= "0" && c <= "9") || !Number.isSafeInteger(number) || number <= 0 || Object.hasOwn(limits, name))
-            usage13("Invalid comparison limit.");
+            usage14("Invalid comparison limit.");
           limits[name] = number;
         }
       } else {
-        if (!arg || arg.includes("\0")) usage13("Invalid comparison input.");
+        if (!arg || arg.includes("\0")) usage14("Invalid comparison input.");
         positionals.push(arg);
       }
     }
     if (seen.has("--help")) {
       if (positionals.length || [...seen].some((flag) => flag !== "--help" && flag !== "--json"))
-        usage13("Comparison help does not accept inputs or options.");
+        usage14("Comparison help does not accept inputs or options.");
       result = {
         version: 1,
         operation: "help",
@@ -4252,7 +4521,7 @@ async function executeDiffCommand(request, options2) {
       human = diffUsage;
     } else {
       if (positionals.length !== 2 || positionals.every((path) => path === "-"))
-        usage13("Comparison requires two inputs and at most one stdin consumer.");
+        usage14("Comparison requires two inputs and at most one stdin consumer.");
       maxOutputBytes = limits.maxOutputBytes ?? maxOutputBytes;
       const context = {
         ...options2.context,
@@ -4269,7 +4538,7 @@ async function executeDiffCommand(request, options2) {
         }
       };
       if (mode === "effective-formatting")
-        throw new OfficeError5(
+        throw new OfficeError8(
           "unsupported-profile",
           "Effective formatting comparison is not supported.",
           "usage"
@@ -4304,7 +4573,7 @@ async function executeDiffCommand(request, options2) {
   let bytes = encoder.encode(json ? JSON.stringify(result) + "\n" : human);
   if (bytes.length > maxOutputBytes) {
     result = failure(
-      new OfficeError5("resource-limit", "Comparison output limit exceeded.", "admit")
+      new OfficeError8("resource-limit", "Comparison output limit exceeded.", "admit")
     );
     bytes = encoder.encode(json ? JSON.stringify(result) + "\n" : human);
   }
@@ -4424,7 +4693,7 @@ var templateSchema = {
 
 // packages/safe-bash-command-pptx/src/command-template.ts
 import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-import { OfficeError as OfficeError6 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError9 } from "../../safe-bash-presentation-engine/errors.js";
 import {
   applyTemplateBindings,
   validateTemplateBindings
@@ -4437,8 +4706,8 @@ function validateTemplateData(value) {
   if (Array.isArray(value)) validateTemplateBindings(value);
   else validateTemplateRepeat(value);
 }
-function usage3(message) {
-  throw new OfficeError6("invalid-value", message, "usage");
+function usage4(message) {
+  throw new OfficeError9("invalid-value", message, "usage");
 }
 function validateTemplateCommand(args, positionals, seen) {
   if ([...seen].some(
@@ -4453,25 +4722,25 @@ function validateTemplateCommand(args, positionals, seen) {
       "--dry-run"
     ].includes(flag)
   ))
-    usage3("Option does not apply to template apply.");
+    usage4("Option does not apply to template apply.");
   if (positionals.length !== 1 || !positionals[0])
-    usage3("Template apply requires exactly one input.");
+    usage4("Template apply requires exactly one input.");
   args.input = positionals[0];
   if (args.bindings !== void 0 === (args.dataFile !== void 0))
-    usage3("Template apply requires exactly one binding source.");
-  if (args.dataFile === "") usage3("Binding file path must not be empty.");
-  if (args.input === "-" && args.dataFile === "-") usage3("Only one input may consume stdin.");
-  if (args.inPlace && args.input === "-") usage3("Stdin cannot be edited in place.");
-  if (args.inPlace && args.output) usage3("Output and in-place cannot be combined.");
-  if (!args.dryRun && !args.inPlace && !args.output) usage3("Mutation requires a destination.");
-  if (args.force && !args.output) usage3("Force requires an explicit output destination.");
+    usage4("Template apply requires exactly one binding source.");
+  if (args.dataFile === "") usage4("Binding file path must not be empty.");
+  if (args.input === "-" && args.dataFile === "-") usage4("Only one input may consume stdin.");
+  if (args.inPlace && args.input === "-") usage4("Stdin cannot be edited in place.");
+  if (args.inPlace && args.output) usage4("Output and in-place cannot be combined.");
+  if (!args.dryRun && !args.inPlace && !args.output) usage4("Mutation requires a destination.");
+  if (args.force && !args.output) usage4("Force requires an explicit output destination.");
   if (args.output === args.input && args.output !== "-")
-    usage3("Replacing input requires --in-place.");
+    usage4("Replacing input requires --in-place.");
   const destination = args.inPlace ? args.input : args.output;
   if (args.dataFile !== void 0 && args.dataFile !== "-" && destination === args.dataFile)
-    usage3("Output cannot replace the binding source.");
+    usage4("Output cannot replace the binding source.");
   if (args.output === "-" && args.json && !args.dryRun)
-    usage3("Binary stdout cannot be combined with JSON.");
+    usage4("Binary stdout cannot be combined with JSON.");
 }
 async function executeTemplateCommand(args, request, options2) {
   const context = { ...options2.context, signal: request.signal };
@@ -4485,7 +4754,7 @@ async function executeTemplateCommand(args, request, options2) {
     try {
       json = new TextDecoder("utf-8", { fatal: true }).decode(data);
     } catch {
-      usage3("Binding data must be UTF-8 JSON.");
+      usage4("Binding data must be UTF-8 JSON.");
     }
     bindings = commandJson(json);
   }
@@ -4790,40 +5059,40 @@ var commentSchemas = Object.fromEntries(
 );
 
 // packages/safe-bash-command-pptx/src/command-comments.ts
-import { OfficeError as OfficeError7 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError10 } from "../../safe-bash-presentation-engine/errors.js";
 import { mutateComments, readComments, readCommentAuthors } from "../../safe-bash-presentation-engine/comments.js";
 import { SelectionError } from "../../safe-bash-presentation-engine/selectors.js";
-function usage4(message) {
-  throw new OfficeError7("invalid-value", message, "usage");
+function usage5(message) {
+  throw new OfficeError10("invalid-value", message, "usage");
 }
 function validateCommentsCommand(args, positionals, seen) {
   const allowed = Object.keys(commentSchemas[args.operation].options.properties).map(
     (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("")
   );
   if ([...seen].some((flag) => !allowed.includes(flag)))
-    usage4("Option does not apply to comments.");
-  if (positionals.length !== 1 || !positionals[0]) usage4("Comments require exactly one input.");
+    usage5("Option does not apply to comments.");
+  if (positionals.length !== 1 || !positionals[0]) usage5("Comments require exactly one input.");
   args.input = positionals[0];
-  if (args.scope !== void 0 && args.scope !== "slides") usage4("Comments require slides scope.");
+  if (args.scope !== void 0 && args.scope !== "slides") usage5("Comments require slides scope.");
   if (args.token && ["--slide", "--scope", "--id"].some((flag) => seen.has(flag)))
-    usage4("Opaque and simple selectors cannot be combined.");
+    usage5("Opaque and simple selectors cannot be combined.");
   if (args.operation === "comments.list" || args.operation === "comments.get") return;
   if (!args.token && args.slide === void 0 && !args.all)
     throw new SelectionError("missing-selection");
   if (args.operation === "comments.add" && [args.commentEdit?.text, args.commentEdit?.author, args.commentEdit?.timestamp].some(
     (value) => value === void 0
   ))
-    usage4("Comment creation requires text, author and timestamp.");
+    usage5("Comment creation requires text, author and timestamp.");
   if (args.operation === "comments.set" && !Object.keys(args.commentEdit ?? {}).some((key) => key !== "id"))
-    usage4("Comment update requires an edit.");
-  if (args.inPlace && args.input === "-") usage4("Stdin cannot be edited in place.");
-  if (args.inPlace && args.output) usage4("Output and in-place cannot be combined.");
-  if (!args.dryRun && !args.inPlace && !args.output) usage4("Mutation requires a destination.");
-  if (args.force && !args.output) usage4("Force requires an explicit output destination.");
+    usage5("Comment update requires an edit.");
+  if (args.inPlace && args.input === "-") usage5("Stdin cannot be edited in place.");
+  if (args.inPlace && args.output) usage5("Output and in-place cannot be combined.");
+  if (!args.dryRun && !args.inPlace && !args.output) usage5("Mutation requires a destination.");
+  if (args.force && !args.output) usage5("Force requires an explicit output destination.");
   if (args.output === args.input && args.output !== "-")
-    usage4("Replacing input requires --in-place.");
+    usage5("Replacing input requires --in-place.");
   if (args.output === "-" && args.json && !args.dryRun)
-    usage4("Binary stdout cannot be combined with JSON.");
+    usage5("Binary stdout cannot be combined with JSON.");
 }
 async function executeCommentsCommand(args, request, options2) {
   const context = { ...options2.context, signal: request.signal };
@@ -5296,43 +5565,43 @@ var accessibilitySchemas = Object.fromEntries(
 );
 
 // packages/safe-bash-command-pptx/src/command-accessibility.ts
-import { OfficeError as OfficeError8 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError11 } from "../../safe-bash-presentation-engine/errors.js";
 import {
   readAccessibility,
   mutateAccessibility,
   validateAccessibilityUpdate
 } from "../../safe-bash-presentation-engine/accessibility.js";
 import { SelectionError as SelectionError2 } from "../../safe-bash-presentation-engine/selectors.js";
-function usage5(message) {
-  throw new OfficeError8("invalid-value", message, "usage");
+function usage6(message) {
+  throw new OfficeError11("invalid-value", message, "usage");
 }
 function validateAccessibilityCommand(args, positionals, seen) {
   const allowed = Object.keys(accessibilitySchemas[args.operation].options.properties).map(
     (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("")
   );
   if ([...seen].some((flag) => !allowed.includes(flag)))
-    usage5("Option does not apply to accessibility.");
+    usage6("Option does not apply to accessibility.");
   if (positionals.length !== 1 || !positionals[0])
-    usage5("Accessibility requires exactly one input.");
+    usage6("Accessibility requires exactly one input.");
   args.input = positionals[0];
   if (args.scope !== void 0 && !["slides", "layouts", "masters"].includes(args.scope))
-    usage5("Unsupported accessibility scope.");
+    usage6("Unsupported accessibility scope.");
   if (args.token && ["--slide", "--shape", "--scope", "--all"].some((flag) => seen.has(flag)))
-    usage5("Opaque and simple selectors cannot be combined.");
+    usage6("Opaque and simple selectors cannot be combined.");
   if (args.shape !== void 0 && args.slide === void 0)
-    usage5("Shape selection requires a slide.");
+    usage6("Shape selection requires a slide.");
   if (args.operation !== "accessibility.set") return;
   validateAccessibilityUpdate(args.accessibilityEdit ?? {});
   if (!args.token && args.slide === void 0 && !args.all)
-    usage5("Accessibility mutation requires explicit selection.");
-  if (args.inPlace && args.input === "-") usage5("Stdin cannot be edited in place.");
-  if (args.inPlace && args.output) usage5("Output and in-place cannot be combined.");
-  if (!args.dryRun && !args.inPlace && !args.output) usage5("Mutation requires a destination.");
-  if (args.force && !args.output) usage5("Force requires an output destination.");
+    usage6("Accessibility mutation requires explicit selection.");
+  if (args.inPlace && args.input === "-") usage6("Stdin cannot be edited in place.");
+  if (args.inPlace && args.output) usage6("Output and in-place cannot be combined.");
+  if (!args.dryRun && !args.inPlace && !args.output) usage6("Mutation requires a destination.");
+  if (args.force && !args.output) usage6("Force requires an output destination.");
   if (args.output === args.input && args.output !== "-")
-    usage5("Replacing input requires --in-place.");
+    usage6("Replacing input requires --in-place.");
   if (args.output === "-" && args.json && !args.dryRun)
-    usage5("Binary stdout cannot be combined with JSON.");
+    usage6("Binary stdout cannot be combined with JSON.");
 }
 async function executeAccessibilityCommand(args, request, options2) {
   const context = { ...options2.context, signal: request.signal };
@@ -5414,13 +5683,13 @@ async function executeAccessibilityCommand(args, request, options2) {
 }
 
 // packages/safe-bash-command-pptx/src/command-metadata.ts
-import { OfficeError as OfficeError9 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError12 } from "../../safe-bash-presentation-engine/errors.js";
 import { coreDefinition, mutateProperty, readProperties } from "../../safe-bash-presentation-engine/properties.js";
 import { sanitize as sanitizePresentation } from "../../safe-bash-presentation-engine/sanitize.js";
 import { mutateTags, readTags } from "../../safe-bash-presentation-engine/tags.js";
 import { SelectionError as SelectionError3 } from "../../safe-bash-presentation-engine/selectors.js";
-function usage6(message) {
-  throw new OfficeError9("invalid-value", message, "usage");
+function usage7(message) {
+  throw new OfficeError12("invalid-value", message, "usage");
 }
 function removalCategories(value) {
   const categories = ["notes", "comments", "properties", "links", "objects"];
@@ -5429,37 +5698,37 @@ function removalCategories(value) {
     try {
       parsed = JSON.parse(value);
     } catch {
-      usage6("Remove requires a category or a JSON array of categories.");
+      usage7("Remove requires a category or a JSON array of categories.");
     }
   }
   const values3 = Array.isArray(parsed) ? parsed : [parsed];
-  if (!values3.length || values3.some((item) => typeof item !== "string" || !categories.includes(item)) || new Set(values3).size !== values3.length) usage6("Remove requires distinct notes, comments, properties, links or objects categories.");
+  if (!values3.length || values3.some((item) => typeof item !== "string" || !categories.includes(item)) || new Set(values3).size !== values3.length) usage7("Remove requires distinct notes, comments, properties, links or objects categories.");
   return values3;
 }
 function validateMetadataCommand(args, positionals, seen) {
   const allowed = Object.keys(metadataSchemas[args.operation].options.properties).map((key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join(""));
-  if ([...seen].some((flag) => !allowed.includes(flag))) usage6("Option does not apply to this metadata operation.");
-  if (positionals.length !== 1 || !positionals[0]) usage6("Metadata operations require exactly one input.");
+  if ([...seen].some((flag) => !allowed.includes(flag))) usage7("Option does not apply to this metadata operation.");
+  if (positionals.length !== 1 || !positionals[0]) usage7("Metadata operations require exactly one input.");
   args.input = positionals[0];
   const tags = args.operation.startsWith("tags."), sanitize = args.operation === "sanitize";
   const action = args.operation.split(".")[1];
-  if (args.scope !== void 0 && !(tags ? ["slides", "presentation"] : ["presentation"]).includes(args.scope)) usage6("Unsupported metadata scope.");
-  if (args.token && ["--slide", "--scope", "--all"].some((flag) => seen.has(flag))) usage6("Opaque and simple selectors cannot be combined.");
-  if (args.scope === "presentation" && args.slide !== void 0) usage6("Presentation scope rejects slide selection.");
-  if (!tags && !sanitize && action !== "list" && !args.metadataName) usage6("Property name is required.");
-  if (args.metadataName === "") usage6("Metadata names cannot be empty.");
-  if (action === "add" && (!args.metadataName || args.metadataValue === void 0)) usage6("New tags require name and value.");
-  if (action === "set" && (tags ? args.metadataName === void 0 && args.metadataValue === void 0 : args.metadataValue === void 0)) usage6("Metadata edit value is required.");
-  if (args.metadataType !== void 0 && !["string", "number", "boolean", "date"].includes(args.metadataType)) usage6("Unknown property type.");
+  if (args.scope !== void 0 && !(tags ? ["slides", "presentation"] : ["presentation"]).includes(args.scope)) usage7("Unsupported metadata scope.");
+  if (args.token && ["--slide", "--scope", "--all"].some((flag) => seen.has(flag))) usage7("Opaque and simple selectors cannot be combined.");
+  if (args.scope === "presentation" && args.slide !== void 0) usage7("Presentation scope rejects slide selection.");
+  if (!tags && !sanitize && action !== "list" && !args.metadataName) usage7("Property name is required.");
+  if (args.metadataName === "") usage7("Metadata names cannot be empty.");
+  if (action === "add" && (!args.metadataName || args.metadataValue === void 0)) usage7("New tags require name and value.");
+  if (action === "set" && (tags ? args.metadataName === void 0 && args.metadataValue === void 0 : args.metadataValue === void 0)) usage7("Metadata edit value is required.");
+  if (args.metadataType !== void 0 && !["string", "number", "boolean", "date"].includes(args.metadataType)) usage7("Unknown property type.");
   if (sanitize) removalCategories(args.metadataRemove);
   if (!sanitize && ["list", "get"].includes(action)) return;
   if (tags && !args.token && args.slide === void 0 && args.scope !== "presentation" && !args.all) throw new SelectionError3("missing-selection");
-  if (args.inPlace && args.input === "-") usage6("Stdin cannot be edited in place.");
-  if (args.inPlace && args.output) usage6("Output and in-place cannot be combined.");
-  if (!args.dryRun && !args.inPlace && !args.output) usage6("Mutation requires a destination.");
-  if (args.force && !args.output) usage6("Force requires an output destination.");
-  if (args.output === args.input && args.output !== "-") usage6("Replacing input requires --in-place.");
-  if (args.output === "-" && args.json && !args.dryRun) usage6("Binary stdout cannot be combined with JSON.");
+  if (args.inPlace && args.input === "-") usage7("Stdin cannot be edited in place.");
+  if (args.inPlace && args.output) usage7("Output and in-place cannot be combined.");
+  if (!args.dryRun && !args.inPlace && !args.output) usage7("Mutation requires a destination.");
+  if (args.force && !args.output) usage7("Force requires an output destination.");
+  if (args.output === args.input && args.output !== "-") usage7("Replacing input requires --in-place.");
+  if (args.output === "-" && args.json && !args.dryRun) usage7("Binary stdout cannot be combined with JSON.");
 }
 async function executeMetadataCommand(args, request, options2) {
   const context = { ...options2.context, signal: request.signal };
@@ -5494,15 +5763,15 @@ async function executeMetadataCommand(args, request, options2) {
     const type = args.metadataType ?? known[0]?.type ?? coreDefinition(args.metadataName)?.[2];
     let value = args.metadataValue;
     if (action === "set" && type === "boolean") {
-      if (value !== "true" && value !== "false") usage6("Boolean properties require true or false.");
+      if (value !== "true" && value !== "false") usage7("Boolean properties require true or false.");
       value = value === "true";
     } else if (action === "set" && type === "number") {
       try {
         value = JSON.parse(args.metadataValue);
       } catch {
-        usage6("Number properties require a finite JSON number.");
+        usage7("Number properties require a finite JSON number.");
       }
-      if (typeof value !== "number" || !Number.isFinite(value)) usage6("Number properties require a finite JSON number.");
+      if (typeof value !== "number" || !Number.isFinite(value)) usage7("Number properties require a finite JSON number.");
     }
     bytes = (await mutateProperty(original, action, { name: args.metadataName, ...action === "set" ? { value, ...type === void 0 ? {} : { type } } : {} }, context)).bytes;
     affected = 1;
@@ -5522,22 +5791,22 @@ ${sanitization.retained.map((entry) => `Retained ${entry.category} ${entry.kind}
 }
 
 // packages/safe-bash-command-pptx/src/command-notes.ts
-import { OfficeError as OfficeError10 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError13 } from "../../safe-bash-presentation-engine/errors.js";
 import { mutateNotes, readNotes, validateNotesOptions } from "../../safe-bash-presentation-engine/notes.js";
 import { readSelectionIndex, SelectionError as SelectionError4 } from "../../safe-bash-presentation-engine/selectors.js";
-function usage7(message) {
-  throw new OfficeError10("invalid-value", message, "usage");
+function usage8(message) {
+  throw new OfficeError13("invalid-value", message, "usage");
 }
 function validateNotesCommand(args, positionals, seen) {
   const allowed = Object.keys(noteSchemas[args.operation].options.properties).map(
     (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("")
   );
-  if ([...seen].some((flag) => !allowed.includes(flag))) usage7("Option does not apply to notes.");
-  if (positionals.length !== 1 || !positionals[0]) usage7("Notes require exactly one input.");
+  if ([...seen].some((flag) => !allowed.includes(flag))) usage8("Option does not apply to notes.");
+  if (positionals.length !== 1 || !positionals[0]) usage8("Notes require exactly one input.");
   args.input = positionals[0];
-  if (args.scope !== void 0 && args.scope !== "notes") usage7("Notes require notes scope.");
+  if (args.scope !== void 0 && args.scope !== "notes") usage8("Notes require notes scope.");
   if (args.token && ["--slide", "--scope"].some((flag) => seen.has(flag)))
-    usage7("Opaque and simple selectors cannot be combined.");
+    usage8("Opaque and simple selectors cannot be combined.");
   if (args.operation === "notes.list" || args.operation === "notes.get") return;
   if (!args.token && args.slide === void 0 && !args.all)
     throw new SelectionError4("missing-selection");
@@ -5545,14 +5814,14 @@ function validateNotesCommand(args, positionals, seen) {
     selection: { kind: "slide" },
     ...args.noteText === void 0 ? {} : { text: args.noteText }
   });
-  if (args.inPlace && args.input === "-") usage7("Stdin cannot be edited in place.");
-  if (args.inPlace && args.output) usage7("Output and in-place cannot be combined.");
-  if (!args.dryRun && !args.inPlace && !args.output) usage7("Mutation requires a destination.");
-  if (args.force && !args.output) usage7("Force requires an explicit output destination.");
+  if (args.inPlace && args.input === "-") usage8("Stdin cannot be edited in place.");
+  if (args.inPlace && args.output) usage8("Output and in-place cannot be combined.");
+  if (!args.dryRun && !args.inPlace && !args.output) usage8("Mutation requires a destination.");
+  if (args.force && !args.output) usage8("Force requires an explicit output destination.");
   if (args.output === args.input && args.output !== "-")
-    usage7("Replacing input requires --in-place.");
+    usage8("Replacing input requires --in-place.");
   if (args.output === "-" && args.json && !args.dryRun)
-    usage7("Binary stdout cannot be combined with JSON.");
+    usage8("Binary stdout cannot be combined with JSON.");
 }
 async function executeNotesCommand(args, request, options2) {
   const context = { ...options2.context, signal: request.signal };
@@ -5808,33 +6077,33 @@ var linkSchemas = Object.fromEntries(
 // packages/safe-bash-command-pptx/src/command-links.ts
 import { readPackage as readPackage2 } from "../../safe-bash-presentation-engine/package-reader.js";
 import { parseXmlPart as parseXmlPart2 } from "../../safe-bash-presentation-engine/xml.js";
-import { OfficeError as OfficeError11 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError14 } from "../../safe-bash-presentation-engine/errors.js";
 import { listLinks, setLink, removeLink, isOrdinaryLinkUrl } from "../../safe-bash-presentation-engine/links.js";
 import { readShapes } from "../../safe-bash-presentation-engine/shape-operations.js";
 import { SelectionError as SelectionError5 } from "../../safe-bash-presentation-engine/selectors.js";
-function usage8(message) {
-  throw new OfficeError11("invalid-value", message, "usage");
+function usage9(message) {
+  throw new OfficeError14("invalid-value", message, "usage");
 }
 function validateLinkCommand(args, positionals, seen) {
   const allowed = Object.keys(linkSchemas[args.operation].options.properties).map(
     (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("")
   );
-  if ([...seen].some((flag) => !allowed.includes(flag))) usage8("Option does not apply to links.");
-  if (positionals.length !== 1 || !positionals[0]) usage8("Links require exactly one input.");
+  if ([...seen].some((flag) => !allowed.includes(flag))) usage9("Option does not apply to links.");
+  if (positionals.length !== 1 || !positionals[0]) usage9("Links require exactly one input.");
   args.input = positionals[0];
-  if (args.scope !== void 0 && args.scope !== "slides") usage8("Links support slides scope.");
+  if (args.scope !== void 0 && args.scope !== "slides") usage9("Links support slides scope.");
   if (args.token && ["--slide", "--shape", "--scope"].some((flag) => seen.has(flag)))
-    usage8("Opaque and simple selectors cannot be combined.");
+    usage9("Opaque and simple selectors cannot be combined.");
   if (args.shape !== void 0 && args.slide === void 0)
-    usage8("Shape selection requires a slide.");
+    usage9("Shape selection requires a slide.");
   const edit = args.linkEdit ?? {};
   if (edit.trigger !== void 0 && !["click", "hover"].includes(edit.trigger))
-    usage8("Unsupported link trigger.");
+    usage9("Unsupported link trigger.");
   if (edit.path !== void 0 && (!Array.isArray(edit.path) || edit.path.some((value) => !Number.isSafeInteger(value) || value < 0)))
-    usage8("Link path requires an array of nonnegative integer child positions.");
+    usage9("Link path requires an array of nonnegative integer child positions.");
   if (["links.list", "links.get"].includes(args.operation)) return;
   if (!args.token && args.slide === void 0 && !args.all)
-    usage8("Link mutation requires explicit selection.");
+    usage9("Link mutation requires explicit selection.");
   if (args.operation !== "links.remove") {
     const url = edit.url !== void 0, slide = edit.targetSlide !== void 0;
     if (Number(url) + Number(slide) + Number(
@@ -5842,20 +6111,20 @@ function validateLinkCommand(args, positionals, seen) {
         edit.action ?? ""
       )
     ) !== 1)
-      usage8("Provide exactly one link destination.");
+      usage9("Provide exactly one link destination.");
     if (url && (!isOrdinaryLinkUrl(edit.url) || edit.action !== void 0 && edit.action !== "url"))
-      usage8("URL action must agree with its destination.");
+      usage9("URL action must agree with its destination.");
     if (slide && edit.action !== void 0 && edit.action !== "slide")
-      usage8("Slide action must agree with its destination.");
+      usage9("Slide action must agree with its destination.");
   }
-  if (args.inPlace && args.input === "-") usage8("Stdin cannot be edited in place.");
-  if (args.inPlace && args.output) usage8("Output and in-place cannot be combined.");
-  if (!args.dryRun && !args.inPlace && !args.output) usage8("Mutation requires a destination.");
-  if (args.force && !args.output) usage8("Force requires an explicit output destination.");
+  if (args.inPlace && args.input === "-") usage9("Stdin cannot be edited in place.");
+  if (args.inPlace && args.output) usage9("Output and in-place cannot be combined.");
+  if (!args.dryRun && !args.inPlace && !args.output) usage9("Mutation requires a destination.");
+  if (args.force && !args.output) usage9("Force requires an explicit output destination.");
   if (args.output === args.input && args.output !== "-")
-    usage8("Replacing input requires --in-place.");
+    usage9("Replacing input requires --in-place.");
   if (args.output === "-" && args.json && !args.dryRun)
-    usage8("Binary stdout cannot be combined with JSON.");
+    usage9("Binary stdout cannot be combined with JSON.");
 }
 var actionNames = {
   url: "hyperlink",
@@ -5951,7 +6220,7 @@ async function executeLinkCommand(args, request, options2) {
     if (args.operation === "links.add" && selectedLinks.some(
       (link) => link.part === selection.owner && link.shapeId === selection.id && (path ? link.path.length === path.length + 1 && path.every((position, i) => link.path[i] === position) : existingShapeLinks.has(JSON.stringify([link.part, link.shapeId])))
     ))
-      throw new OfficeError11(
+      throw new OfficeError14(
         "unsupported-edit",
         "Selected trigger already contains a link.",
         "validate-intent"
@@ -6978,11 +7247,11 @@ import { readAnimations } from "../../safe-bash-presentation-engine/animations.j
 import { mutateAnimations, mutateAnimationsBatch, validateAnimationOptions as validateAnimationOptions2 } from "../../safe-bash-presentation-engine/animation-editing.js";
 
 // packages/safe-bash-command-pptx/src/animation-batch-command.ts
-import { OfficeError as OfficeError12 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError15 } from "../../safe-bash-presentation-engine/errors.js";
 import { validateAnimationOptions } from "../../safe-bash-presentation-engine/animation-editing.js";
 import { decodeSelectionToken, SelectionError as SelectionError6 } from "../../safe-bash-presentation-engine/selectors.js";
 function invalid(message) {
-  throw new OfficeError12("invalid-value", message, "usage");
+  throw new OfficeError15("invalid-value", message, "usage");
 }
 function record(value, keys) {
   if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => !keys.includes(key))) invalid("Invalid animation batch fields.");
@@ -7190,31 +7459,31 @@ var equationSchemas = Object.fromEntries(["list", "get", "add"].map((action) =>
 }));
 
 // packages/safe-bash-command-pptx/src/command-equations.ts
-import { OfficeError as OfficeError13 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError16 } from "../../safe-bash-presentation-engine/errors.js";
 import { readEquations, mutateEquations } from "../../safe-bash-presentation-engine/equations.js";
 import { SelectionError as SelectionError7 } from "../../safe-bash-presentation-engine/selectors.js";
-function usage9(message) {
-  throw new OfficeError13("invalid-value", message, "usage");
+function usage10(message) {
+  throw new OfficeError16("invalid-value", message, "usage");
 }
 function validateEquationCommand(args, positionals, seen) {
   const schema = equationSchemas[args.operation];
   const allowed = Object.keys(schema.options.properties).map((key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join(""));
-  if ([...seen].some((flag) => !allowed.includes(flag))) usage9("Option does not apply to equations.");
-  if (positionals.length !== 1 || !positionals[0]) usage9("Equations require exactly one input.");
+  if ([...seen].some((flag) => !allowed.includes(flag))) usage10("Option does not apply to equations.");
+  if (positionals.length !== 1 || !positionals[0]) usage10("Equations require exactly one input.");
   args.input = positionals[0];
-  if (args.scope !== void 0 && args.scope !== "slides") usage9("Equations support slides scope.");
-  if (args.token && ["--slide", "--shape", "--scope"].some((flag) => seen.has(flag))) usage9("Opaque and simple selectors cannot be combined.");
-  if (args.shape !== void 0 && args.slide === void 0) usage9("Shape selection requires a slide.");
+  if (args.scope !== void 0 && args.scope !== "slides") usage10("Equations support slides scope.");
+  if (args.token && ["--slide", "--shape", "--scope"].some((flag) => seen.has(flag))) usage10("Opaque and simple selectors cannot be combined.");
+  if (args.shape !== void 0 && args.slide === void 0) usage10("Shape selection requires a slide.");
   if (args.operation !== "equations.add") return;
-  if (!args.file) usage9("Equation insertion requires --file.");
-  if (!args.token && !args.shape) usage9("Equation insertion requires a shape selector.");
-  if (args.input === "-" && args.file === "-") usage9("Only one input may consume stdin.");
-  if (args.inPlace && args.input === "-") usage9("Stdin cannot be edited in place.");
-  if (args.inPlace && args.output) usage9("Output and in-place cannot be combined.");
-  if (!args.dryRun && !args.inPlace && !args.output) usage9("Mutation requires a destination.");
-  if (args.force && !args.output) usage9("Force requires an explicit output destination.");
-  if (args.output === args.input && args.output !== "-") usage9("Replacing input requires --in-place.");
-  if (args.output === "-" && args.json && !args.dryRun) usage9("Binary stdout cannot be combined with JSON.");
+  if (!args.file) usage10("Equation insertion requires --file.");
+  if (!args.token && !args.shape) usage10("Equation insertion requires a shape selector.");
+  if (args.input === "-" && args.file === "-") usage10("Only one input may consume stdin.");
+  if (args.inPlace && args.input === "-") usage10("Stdin cannot be edited in place.");
+  if (args.inPlace && args.output) usage10("Output and in-place cannot be combined.");
+  if (!args.dryRun && !args.inPlace && !args.output) usage10("Mutation requires a destination.");
+  if (args.force && !args.output) usage10("Force requires an explicit output destination.");
+  if (args.output === args.input && args.output !== "-") usage10("Replacing input requires --in-place.");
+  if (args.output === "-" && args.json && !args.dryRun) usage10("Binary stdout cannot be combined with JSON.");
 }
 async function executeEquationCommand(args, request, options2) {
   const context = { ...options2.context, signal: request.signal };
@@ -7345,30 +7614,30 @@ var opaqueSchemas = Object.fromEntries(["objects.list", "objects.extract", "font
 
 // packages/safe-bash-command-pptx/src/command-opaque.ts
 import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
-import { OfficeError as OfficeError14 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError17 } from "../../safe-bash-presentation-engine/errors.js";
 import { extractObject, readFonts, readObjects } from "../../safe-bash-presentation-engine/opaque-objects.js";
-import { partName as partName2 } from "../../safe-bash-presentation-engine/package-uri.js";
-function usage10(message) {
-  throw new OfficeError14("invalid-value", message, "usage");
+import { partName as partName3 } from "../../safe-bash-presentation-engine/package-uri.js";
+function usage11(message) {
+  throw new OfficeError17("invalid-value", message, "usage");
 }
 function validateOpaqueCommand(args, positionals, seen) {
   const schema = opaqueSchemas[args.operation];
   const allowed = Object.keys(schema.options.properties).map((key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join(""));
-  if ([...seen].some((flag) => !allowed.includes(flag))) usage10("Option does not apply to opaque resources.");
-  if (positionals.length !== 1 || !positionals[0]) usage10("Opaque resources require exactly one input.");
+  if ([...seen].some((flag) => !allowed.includes(flag))) usage11("Option does not apply to opaque resources.");
+  if (positionals.length !== 1 || !positionals[0]) usage11("Opaque resources require exactly one input.");
   args.input = positionals[0];
   const scope = args.operation === "fonts.list" ? "presentation" : "shared";
-  if (args.scope !== void 0 && args.scope !== scope) usage10("Unsupported opaque resource scope.");
+  if (args.scope !== void 0 && args.scope !== scope) usage11("Unsupported opaque resource scope.");
   if (args.operation !== "objects.extract") return;
-  if (!args.part) usage10("Object extraction requires --part.");
+  if (!args.part) usage11("Object extraction requires --part.");
   try {
-    if (partName2(args.part, false) !== args.part) usage10("Object extraction requires a canonical package part.");
+    if (partName3(args.part, false) !== args.part) usage11("Object extraction requires a canonical package part.");
   } catch {
-    usage10("Object extraction requires a canonical package part.");
+    usage11("Object extraction requires a canonical package part.");
   }
-  if (!args.outputDir && !args.dryRun) usage10("Object extraction requires --output-dir.");
-  if (args.outputDir === "-") usage10("Output directories cannot be stdout.");
-  if (args.force && !args.outputDir) usage10("Force requires an output directory.");
+  if (!args.outputDir && !args.dryRun) usage11("Object extraction requires --output-dir.");
+  if (args.outputDir === "-") usage11("Output directories cannot be stdout.");
+  if (args.force && !args.outputDir) usage11("Force requires an output directory.");
 }
 async function executeOpaqueCommand(args, request, options2) {
   const context = { ...options2.context, signal: request.signal };
@@ -7386,7 +7655,7 @@ async function executeOpaqueCommand(args, request, options2) {
   }
   const extracted = await extractObject(bytes, { part: args.part }, context);
   const files = [{ part: extracted.part, name: extracted.name, bytes: extracted.bytes }, ...extracted.dependencies];
-  if (files.length > (args.limits?.maxOutputs ?? context.archiveLimits.maxMembers)) throw new OfficeError14("resource-limit", "Opaque output count exceeds limit.", "validate-intent");
+  if (files.length > (args.limits?.maxOutputs ?? context.archiveLimits.maxMembers)) throw new OfficeError17("resource-limit", "Opaque output count exceeds limit.", "validate-intent");
   const dryRun = args.dryRun ?? false;
   const allowPartialOutput = args.allowPartialOutput ?? false;
   if (!dryRun && !request.publishOutputs && (!allowPartialOutput || !request.publishOutput)) throw Object.assign(new Error("Object extraction requires atomic publication or explicit partial output."), { code: "publication-unsupported" });
@@ -7418,7 +7687,7 @@ import { readMedia } from "../../safe-bash-presentation-engine/media.js";
 import { extractMedia } from "../../safe-bash-presentation-engine/media-extraction.js";
 
 // packages/safe-bash-command-pptx/src/command-media-editing.ts
-import { OfficeError as OfficeError15 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError18 } from "../../safe-bash-presentation-engine/errors.js";
 import { addMedia, replaceMedia } from "../../safe-bash-presentation-engine/media-editing.js";
 
 // packages/safe-bash-command-pptx/src/media-schema.ts
@@ -7667,56 +7936,56 @@ for (const action of ["add", "replace", "extract"]) {
 }
 
 // packages/safe-bash-command-pptx/src/command-media-editing.ts
-function usage11(message) {
-  throw new OfficeError15("invalid-value", message, "usage");
+function usage12(message) {
+  throw new OfficeError18("invalid-value", message, "usage");
 }
 function validateMediaEditingCommand(args, positionals, seen) {
   const allowed = Object.keys(mediaSchemas[args.operation].options.properties).map(
     (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("")
   );
   if ([...seen].some((flag) => !allowed.includes(flag)))
-    usage11("Option does not apply to this media operation.");
-  if (positionals.length !== 1 || !positionals[0]) usage11("Media requires exactly one input.");
+    usage12("Option does not apply to this media operation.");
+  if (positionals.length !== 1 || !positionals[0]) usage12("Media requires exactly one input.");
   args.input = positionals[0];
   if (args.token && ["--slide", "--shape", "--scope", "--all"].some((flag) => seen.has(flag)))
-    usage11("Opaque and simple selectors cannot be combined.");
+    usage12("Opaque and simple selectors cannot be combined.");
   if (args.shape !== void 0 && args.slide === void 0)
-    usage11("Shape selection requires an owning slide.");
+    usage12("Shape selection requires an owning slide.");
   if (args.operation === "media.extract") {
     if (!args.outputDir || args.outputDir === "-")
-      usage11("Media extraction requires an output directory.");
+      usage12("Media extraction requires an output directory.");
     return;
   }
   if (args.operation === "media.add" && args.scope !== void 0 && args.scope !== "slides")
-    usage11("Media editing requires slides scope.");
-  if (!args.file) usage11("Media mutation requires --file.");
+    usage12("Media editing requires slides scope.");
+  if (!args.file) usage12("Media mutation requires --file.");
   if (args.operation === "media.add") {
     if (args.slide === void 0 || !args.mediaEdit?.kind || !args.mediaEdit.contentType || ["left", "top", "width", "height"].some(
       (key) => args.mediaEdit?.[key] === void 0
     ))
-      usage11("Media insertion requires slide, kind, MIME type and explicit geometry.");
-    if (!args.poster) usage11("Media insertion requires an explicit poster.");
+      usage12("Media insertion requires slide, kind, MIME type and explicit geometry.");
+    if (!args.poster) usage12("Media insertion requires an explicit poster.");
   } else {
-    if (!args.poster) usage11("Media replacement requires an explicit poster.");
+    if (!args.poster) usage12("Media replacement requires an explicit poster.");
     if (!args.token && args.shape === void 0 && !args.all)
-      usage11("Media replacement requires a shape selector or all.");
+      usage12("Media replacement requires a shape selector or all.");
   }
   if ([args.input, args.file, args.poster].filter((value) => value === "-").length > 1)
-    usage11("Only one input may consume stdin.");
+    usage12("Only one input may consume stdin.");
   if (args.poster && !args.posterContentType) {
     const extension = args.poster.slice(args.poster.lastIndexOf(".") + 1).toLowerCase();
     const inferred = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", bmp: "image/bmp", tif: "image/tiff", tiff: "image/tiff", wmf: "image/x-wmf" }[extension];
-    if (!inferred) usage11("Poster requires an explicit content type or supported extension.");
+    if (!inferred) usage12("Poster requires an explicit content type or supported extension.");
     args.posterContentType = inferred;
   }
-  if (args.inPlace && args.input === "-") usage11("Stdin cannot be edited in place.");
-  if (args.inPlace && args.output) usage11("Output and in-place cannot be combined.");
-  if (!args.dryRun && !args.inPlace && !args.output) usage11("Mutation requires a destination.");
-  if (args.force && !args.output) usage11("Force requires an explicit output destination.");
+  if (args.inPlace && args.input === "-") usage12("Stdin cannot be edited in place.");
+  if (args.inPlace && args.output) usage12("Output and in-place cannot be combined.");
+  if (!args.dryRun && !args.inPlace && !args.output) usage12("Mutation requires a destination.");
+  if (args.force && !args.output) usage12("Force requires an explicit output destination.");
   if (args.output === args.input && args.output !== "-")
-    usage11("Replacing input requires --in-place.");
+    usage12("Replacing input requires --in-place.");
   if (args.output === "-" && args.json && !args.dryRun)
-    usage11("Binary stdout cannot be combined with JSON.");
+    usage12("Binary stdout cannot be combined with JSON.");
 }
 async function executeMediaEditingCommand(args, request, options2) {
   const context = { ...options2.context, signal: request.signal };
@@ -8762,9 +9031,9 @@ import {
 import { readBackgrounds, mutateBackground } from "../../safe-bash-presentation-engine/backgrounds.js";
 import { replacePresentationText } from "../../safe-bash-presentation-engine/text-replacement.js";
 import { readPresentationText } from "../../safe-bash-presentation-engine/text-reading.js";
-import { OfficeError as OfficeError16 } from "../../safe-bash-presentation-engine/errors.js";
+import { OfficeError as OfficeError19 } from "../../safe-bash-presentation-engine/errors.js";
 import { sha256 as sha2564 } from "@noble/hashes/sha2.js";
-import { packageUri, partName as partName3 } from "../../safe-bash-presentation-engine/package-uri.js";
+import { packageUri, partName as partName4 } from "../../safe-bash-presentation-engine/package-uri.js";
 import {
   SelectionError as SelectionError8,
   decodeSelectionToken as decodeSelectionToken2,
@@ -8794,10 +9063,10 @@ import {
   readPresentationSettings,
   mutatePresentationSettings
 } from "../../safe-bash-presentation-engine/presentation-settings.js";
-import { getXmlPart, stageRetainedXmlPart, replaceXmlPart } from "../../safe-bash-presentation-engine/xml-parts.js";
+import { getXmlPart, stageRetainedXmlPart, stageRetainedXmlReplacement, replaceXmlPart } from "../../safe-bash-presentation-engine/xml-parts.js";
 import { validatePresentation, openRetainedPresentationValidation } from "../../safe-bash-presentation-engine/validation.js";
 import { readPackage as readPackage3 } from "../../safe-bash-presentation-engine/package-reader.js";
-import { resourceContext } from "../../safe-bash-presentation-engine/resource-limits.js";
+import { resourceContext as resourceContext2 } from "../../safe-bash-presentation-engine/resource-limits.js";
 var scopes2 = [
   "slides",
   "notes",
@@ -8963,15 +9232,15 @@ Dimension conflicts reject by default; destination policy retains source coordin
 Slides add requires an exact layout name or part URI; position defaults to append.
 Title/body match placeholder types; indexed bindings use --placeholders-json.
 `;
-function usage12(message) {
-  throw new OfficeError16("invalid-value", message, "usage");
+function usage13(message) {
+  throw new OfficeError19("invalid-value", message, "usage");
 }
 function paragraphTabLength(length4) {
   if (Object.keys(length4).some((key) => !["value", "unit"].includes(key)) || typeof length4.value !== "number" || !Number.isFinite(length4.value) || length4.value < 0 || typeof length4.unit !== "string")
-    usage12("Tabs require finite explicit lengths.");
+    usage13("Tabs require finite explicit lengths.");
   const emu = length4.value * commandLength("1" + length4.unit, 0);
   if (!Number.isFinite(emu) || emu > Number.MAX_SAFE_INTEGER)
-    usage12("Tab length is outside the supported range.");
+    usage13("Tab length is outside the supported range.");
   return Math.round(emu) / 12700;
 }
 var runFlags = [
@@ -9219,11 +9488,11 @@ function parse(raw, maximum, output3) {
   const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
   for (let index = 0; index < raw.length; index++) {
     const bytes = raw[index];
-    if (!(bytes instanceof Uint8Array)) usage12("Arguments must be byte arrays.");
+    if (!(bytes instanceof Uint8Array)) usage13("Arguments must be byte arrays.");
     size += bytes.length + 1;
     if (size > maximum) {
-      if (invalidUtf8) usage12("Arguments must be UTF-8.");
-      throw new OfficeError16("resource-limit", "Argument limit exceeded.", "usage");
+      if (invalidUtf8) usage13("Arguments must be UTF-8.");
+      throw new OfficeError19("resource-limit", "Argument limit exceeded.", "usage");
     }
     try {
       args.push(decoder.decode(bytes));
@@ -9294,9 +9563,9 @@ function parse(raw, maximum, output3) {
       else if (scalarOptions.includes(argument)) hintValue = true;
     }
   }
-  if (invalidUtf8) usage12("Arguments must be UTF-8.");
+  if (invalidUtf8) usage13("Arguments must be UTF-8.");
   if (args[0] === "accessibility" && ["--help", "-h"].includes(args[1])) {
-    if (args.slice(2).some((argument) => argument !== "--json")) usage12("Unexpected help option.");
+    if (args.slice(2).some((argument) => argument !== "--json")) usage13("Unexpected help option.");
     return { operation: "help", json: output3.json, schemaPath: "accessibility" };
   }
   if (args[0] === "text" && ["runs", "paragraphs", "frames"].includes(args[1]) && ["get", "set", "list"].includes(args[2])) {
@@ -9401,7 +9670,7 @@ function parse(raw, maximum, output3) {
     "help",
     "version"
   ].includes(operation))
-    usage12("Unsupported operation.");
+    usage13("Unsupported operation.");
   const result = { operation, json: false };
   const positionals = [];
   const seen = /* @__PURE__ */ new Set();
@@ -9431,10 +9700,10 @@ function parse(raw, maximum, output3) {
       "--height",
       "--workbook-policy"
     ].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Chart option requires a value.");
+      if (value2 === void 0) usage13("Chart option requires a value.");
       const key = argument.slice(2);
       if (key === "workbook-policy") result.chartWorkbookPolicy = value2;
       else {
@@ -9442,10 +9711,10 @@ function parse(raw, maximum, output3) {
         if (key === "data" || key === "objects") parsed = commandJson(value2);
         else if (key === "style") {
           if (!value2.length || [...value2].some((c) => c < "0" || c > "9"))
-            usage12("Chart style requires an integer.");
+            usage13("Chart style requires an integer.");
           parsed = Number(value2);
         } else if (key === "legend") {
-          if (!["true", "false"].includes(value2)) usage12("Legend requires true or false.");
+          if (!["true", "false"].includes(value2)) usage13("Legend requires true or false.");
           parsed = value2 === "true";
         } else if (["left", "top", "width", "height"].includes(key))
           parsed = commandLength(
@@ -9459,14 +9728,14 @@ function parse(raw, maximum, output3) {
     if (operation.startsWith("tables.") && (argument === "--table" || argument === "--cell" || ["--from", "--to", "--position", "--span-policy"].includes(argument) || Object.keys(tableValues).some(
       (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("") === argument
     ))) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Table option requires a value.");
+      if (value2 === void 0) usage13("Table option requires a value.");
       const key = argument.slice(2).split("-").map((word, i) => i ? word[0].toUpperCase() + word.slice(1) : word).join("");
       if (key === "table" || key === "rows" || key === "columns" || key === "position") {
         if (!value2.length || [...value2].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(value2)) || Number(value2) < 1)
-          usage12("Table positions and dimensions require positive integers.");
+          usage13("Table positions and dimensions require positive integers.");
         if (key === "position") result.tablePosition = Number(value2);
         else if (key === "table") result.table = Number(value2);
         else result.tableEdit = { ...result.tableEdit, [key]: Number(value2) };
@@ -9475,7 +9744,7 @@ function parse(raw, maximum, output3) {
         try {
           tableCell(value2);
         } catch {
-          usage12("Cell requires one-based row,column coordinates.");
+          usage13("Cell requires one-based row,column coordinates.");
         }
         if (key === "from") result.tableFrom = value2;
         else if (key === "to") result.tableTo = value2;
@@ -9497,7 +9766,7 @@ function parse(raw, maximum, output3) {
         let parsed = value2;
         if (key === "data") parsed = commandJson(value2);
         else if (["firstRow", "lastRow", "firstCol", "lastCol", "horzBand", "vertBand"].includes(key)) {
-          if (!["true", "false"].includes(value2)) usage12("Table style flags require true or false.");
+          if (!["true", "false"].includes(value2)) usage13("Table style flags require true or false.");
           parsed = value2 === "true";
         } else if (value2 === "null" && !["text"].includes(key)) parsed = null;
         else if (lengths.includes(key))
@@ -9522,10 +9791,10 @@ function parse(raw, maximum, output3) {
       "--line-width",
       "--line-color"
     ].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Connector option requires a value.");
+      if (value2 === void 0) usage13("Connector option requires a value.");
       const keys = {
         "--begin-x": "beginX",
         "--begin-y": "beginY",
@@ -9539,7 +9808,7 @@ function parse(raw, maximum, output3) {
       };
       const key = keys[argument] ?? argument.slice(2);
       if (key === "site" && (!value2 || [...value2].some((c) => c < "0" || c > "9")))
-        usage12("Sites require nonnegative decimal integers.");
+        usage13("Sites require nonnegative decimal integers.");
       const parsed = key === "lineWidth" ? value2 === "null" ? null : new Emu(commandLength(value2, 0)) : ["beginX", "beginY", "endX", "endY"].includes(key) ? new Emu(commandLength(value2, -Number.MAX_SAFE_INTEGER)) : ["beginTarget", "endTarget"].includes(key) ? commandJson(value2) : key === "site" ? Number(value2) : key === "kind" && ["1", "2", "3"].includes(value2) ? Number(value2) : key !== "name" && value2 === "null" ? null : value2;
       result.connectorEdit = { ...result.connectorEdit, [key]: parsed };
       continue;
@@ -9556,14 +9825,14 @@ function parse(raw, maximum, output3) {
       "--offset-x",
       "--offset-y"
     ].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Shape selection option requires a value.");
+      if (value2 === void 0) usage13("Shape selection option requires a value.");
       if (argument === "--shapes") {
         const locations = commandJson(value2);
         if (!Array.isArray(locations) || locations.length === 0)
-          usage12("Shapes requires a nonempty location array.");
+          usage13("Shapes requires a nonempty location array.");
         result.shapes = locations;
       } else {
         const key = argument === "--coordinate-system" ? "coordinateSystem" : argument === "--offset-x" ? "offsetX" : argument === "--offset-y" ? "offsetY" : argument.slice(2);
@@ -9576,24 +9845,24 @@ function parse(raw, maximum, output3) {
       continue;
     }
     if (["shapes.group", "shapes.ungroup"].includes(operation) && ["--shapes", "--tolerance"].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Group option requires a value.");
+      if (value2 === void 0) usage13("Group option requires a value.");
       if (argument === "--tolerance") result.tolerance = new Emu(commandLength(value2, 0));
       else {
         const locations = commandJson(value2);
         if (!Array.isArray(locations) || locations.length < 2)
-          usage12("Grouping requires at least two shape locations.");
+          usage13("Grouping requires at least two shape locations.");
         result.shapes = locations;
       }
       continue;
     }
     if (operation.startsWith("fields.") && ["--kind", "--text", "--update", "--timestamp"].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Field option requires a value.");
+      if (value2 === void 0) usage13("Field option requires a value.");
       const key = argument.slice(2);
       result.fieldEdit = {
         ...result.fieldEdit,
@@ -9602,13 +9871,13 @@ function parse(raw, maximum, output3) {
       continue;
     }
     if (operation.startsWith("animations.") && ["--kind", "--trigger", "--duration", "--delay", "--target"].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Animation option requires a value.");
+      if (value2 === void 0) usage13("Animation option requires a value.");
       let parsed = value2;
       if (argument === "--duration" || argument === "--delay") {
-        if (!value2.length || [...value2].some((character) => character < "0" || character > "9")) usage12("Timing requires integer milliseconds.");
+        if (!value2.length || [...value2].some((character) => character < "0" || character > "9")) usage13("Timing requires integer milliseconds.");
         parsed = Number(value2);
       }
       if (argument === "--target") parsed = animationTargetArgument(value2.trimStart().startsWith("{") ? commandJson(value2) : value2);
@@ -9616,31 +9885,31 @@ function parse(raw, maximum, output3) {
       continue;
     }
     if (operation === "batch" && ["--ops-json", "--ops-file"].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (!value2) usage12("Batch option requires a value.");
+      if (!value2) usage13("Batch option requires a value.");
       if (argument === "--ops-json") result.animationBatch = parseAnimationBatch(commandJson(value2));
       else result.opsFile = value2;
       continue;
     }
     if (operation.startsWith("comments.") && ["--id", "--text", "--author", "--author-id", "--initials", "--timestamp", "--left", "--top"].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Comment option requires a value.");
+      if (value2 === void 0) usage13("Comment option requires a value.");
       const key = argument === "--author-id" ? "authorId" : argument.slice(2);
       const parsed = ["left", "top"].includes(key) ? commandLength(value2, -Number.MAX_SAFE_INTEGER) : key === "timestamp" ? commandTimestamp(value2).toISOString() : value2;
       result.commentEdit = { ...result.commentEdit, [key]: parsed };
       continue;
     }
     if (Object.hasOwn(accessibilitySchemas, operation) && ["--title", "--alt-text", "--decorative"].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Accessibility option requires a value.");
+      if (value2 === void 0) usage13("Accessibility option requires a value.");
       if (argument === "--decorative") {
-        if (value2 !== "true" && value2 !== "false") usage12("Decorative requires true or false.");
+        if (value2 !== "true" && value2 !== "false") usage13("Decorative requires true or false.");
         result.accessibilityEdit = { ...result.accessibilityEdit, decorative: value2 === "true" };
       } else {
         const key = argument === "--alt-text" ? "altText" : "title";
@@ -9649,10 +9918,10 @@ function parse(raw, maximum, output3) {
       continue;
     }
     if (Object.hasOwn(metadataSchemas, operation) && ["--name", "--value", "--type", "--remove"].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Metadata option requires a value.");
+      if (value2 === void 0) usage13("Metadata option requires a value.");
       if (argument === "--name") result.metadataName = value2;
       else if (argument === "--value") result.metadataValue = value2;
       else if (argument === "--type") result.metadataType = value2;
@@ -9660,49 +9929,49 @@ function parse(raw, maximum, output3) {
       continue;
     }
     if (operation.startsWith("notes.") && argument === "--text") {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Notes text requires a value.");
+      if (value2 === void 0) usage13("Notes text requires a value.");
       result.noteText = value2;
       continue;
     }
     if (operation.startsWith("links.") && ["--url", "--target-slide", "--action", "--trigger", "--sanitize", "--path"].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       if (argument === "--sanitize") {
         result.linkEdit = { ...result.linkEdit, sanitize: true };
         continue;
       }
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Link option requires a value.");
-      if (argument === "--target-slide" && (!value2.length || [...value2].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(value2)) || Number(value2) < 1)) usage12("Slide target requires a positive integer.");
+      if (value2 === void 0) usage13("Link option requires a value.");
+      if (argument === "--target-slide" && (!value2.length || [...value2].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(value2)) || Number(value2) < 1)) usage13("Slide target requires a positive integer.");
       const key = argument === "--target-slide" ? "targetSlide" : argument.slice(2);
       result.linkEdit = { ...result.linkEdit, [key]: argument === "--target-slide" ? Number(value2) : argument === "--path" ? commandJson(value2) : value2 };
       continue;
     }
     if (operation.startsWith("transitions.") && ["--kind", "--direction", "--duration", "--advance-after", "--advance-on-click"].includes(argument)) {
-      if (seen.has(argument)) usage12("Repeated option.");
+      if (seen.has(argument)) usage13("Repeated option.");
       seen.add(argument);
       const value2 = args[++index];
-      if (value2 === void 0) usage12("Transition option requires a value.");
+      if (value2 === void 0) usage13("Transition option requires a value.");
       let parsed = value2;
       if (argument === "--duration" || argument === "--advance-after") {
         if (argument === "--advance-after" && value2 === "null") parsed = null;
         else {
-          if (!value2.length || [...value2].some((character) => character < "0" || character > "9")) usage12("Timing requires integer milliseconds.");
+          if (!value2.length || [...value2].some((character) => character < "0" || character > "9")) usage13("Timing requires integer milliseconds.");
           parsed = Number(value2);
         }
       }
       if (argument === "--advance-on-click") {
-        if (value2 !== "true" && value2 !== "false") usage12("Advance on click requires true or false.");
+        if (value2 !== "true" && value2 !== "false") usage13("Advance on click requires true or false.");
         parsed = value2 === "true";
       }
       const key = argument === "--advance-after" ? "advanceAfter" : argument === "--advance-on-click" ? "advanceOnClick" : argument.slice(2);
       result.transitionEdit = { ...result.transitionEdit, [key]: parsed };
       continue;
     }
-    if (seen.has(argument) && argument !== "--limit") usage12("Repeated option.");
+    if (seen.has(argument) && argument !== "--limit") usage13("Repeated option.");
     seen.add(argument);
     if (argument === "--json") {
       result.json = true;
@@ -9710,7 +9979,7 @@ function parse(raw, maximum, output3) {
     }
     if (argument === "--unique") {
       if (!["images.list", "images.extract"].includes(operation))
-        usage12("Unique requires images list or extract.");
+        usage13("Unique requires images list or extract.");
       result.unique = true;
       continue;
     }
@@ -9723,7 +9992,7 @@ function parse(raw, maximum, output3) {
       continue;
     }
     if (argument === "--shared") {
-      if (operation !== "images.replace") usage12("Shared requires images replace.");
+      if (operation !== "images.replace") usage13("Shared requires images replace.");
       result.imageReplace = { ...result.imageReplace, shared: true };
       continue;
     }
@@ -9740,12 +10009,12 @@ function parse(raw, maximum, output3) {
     }
     if (argument === "--allow-partial-output") {
       if (!["extract", "slides.split", "images.extract", "media.extract", "objects.extract"].includes(operation))
-        usage12("Partial output requires a multi-file operation.");
+        usage13("Partial output requires a multi-file operation.");
       result.allowPartialOutput = true;
       continue;
     }
     if (argument === "--first") {
-      if (operation !== "text.replace") usage12("First requires text replace.");
+      if (operation !== "text.replace") usage13("First requires text replace.");
       result.first = true;
       continue;
     }
@@ -9753,7 +10022,7 @@ function parse(raw, maximum, output3) {
       result.all = true;
       continue;
     }
-    if (!scalarOptions.includes(argument)) usage12("Unsupported option.");
+    if (!scalarOptions.includes(argument)) usage13("Unsupported option.");
     const booleanValueOptions = [
       "--preserve-geometry",
       "--preserve-crop",
@@ -9778,9 +10047,9 @@ function parse(raw, maximum, output3) {
       "--matching-name",
       "--with"
     ].includes(argument))
-      usage12("Missing option value.");
+      usage13("Missing option value.");
     if (["--data-json", "--data-file"].includes(argument)) {
-      if (operation !== "template.apply") usage12("Binding sources require template apply.");
+      if (operation !== "template.apply") usage13("Binding sources require template apply.");
       if (argument === "--data-file") result.dataFile = value;
       else {
         const bindings = commandJson(value);
@@ -9791,7 +10060,7 @@ function parse(raw, maximum, output3) {
     }
     if (operation === "objects.add" && ["--icon", "--icon-content-type", "--program", "--program-id", "--name", "--left", "--top", "--width", "--height", "--icon-width", "--icon-height"].includes(argument)) {
       if (argument === "--program") {
-        if (!Object.hasOwn(PROG_ID, value)) usage12("Unknown registered program.");
+        if (!Object.hasOwn(PROG_ID, value)) usage13("Unknown registered program.");
         result.objectAdd = { ...result.objectAdd, progId: PROG_ID[value] };
       } else if (argument === "--icon") result.icon = value;
       else if (argument === "--icon-content-type") result.iconContentType = value;
@@ -9807,10 +10076,10 @@ function parse(raw, maximum, output3) {
       else if (argument === "--poster-content-type") result.posterContentType = value;
       else {
         const key = argument === "--mime-type" ? "contentType" : argument.slice(2).split("-").map((part, i) => i ? part[0].toUpperCase() + part.slice(1) : part).join("");
-        if (key === "kind" && !["audio", "video"].includes(value)) usage12("Media kind requires audio or video.");
-        if (key === "loop" && !["true", "false"].includes(value)) usage12("Loop requires true or false.");
+        if (key === "kind" && !["audio", "video"].includes(value)) usage13("Media kind requires audio or video.");
+        if (key === "loop" && !["true", "false"].includes(value)) usage13("Loop requires true or false.");
         const parsed = ["left", "top", "width", "height"].includes(key) ? commandLength(value, ["width", "height"].includes(key) ? 1 : -27273042316900) : key === "loop" ? value === "true" : ["trimStart", "trimEnd", "volume"].includes(key) ? Number(value) : value;
-        if (typeof parsed === "number" && !Number.isFinite(parsed)) usage12("Media values must be finite.");
+        if (typeof parsed === "number" && !Number.isFinite(parsed)) usage13("Media values must be finite.");
         result.mediaEdit = { ...result.mediaEdit, [key]: parsed };
       }
       continue;
@@ -9819,13 +10088,13 @@ function parse(raw, maximum, output3) {
       const key = argument.slice(2).split("-").map((part, i) => i ? part[0].toUpperCase() + part.slice(1) : part).join("");
       let parsed = value;
       if (key === "flipHorizontal" || key === "flipVertical") {
-        if (value !== "true" && value !== "false") usage12("Picture flips require true or false.");
+        if (value !== "true" && value !== "false") usage13("Picture flips require true or false.");
         parsed = value === "true";
       } else if (key === "borderWidth") parsed = commandLength(value, 0);
       else if (key !== "borderColor" && key !== "altText") {
         parsed = Number(value);
         if (!value.trim() || !Number.isFinite(parsed))
-          usage12("Picture values must be finite numbers.");
+          usage13("Picture values must be finite numbers.");
       }
       result.imageSet = { ...result.imageSet, [key]: parsed };
       continue;
@@ -9839,9 +10108,9 @@ function parse(raw, maximum, output3) {
     ].includes(argument)) {
       const key = argument.slice(2).split("-").map((part, i) => i ? part[0].toUpperCase() + part.slice(1) : part).join("");
       if (key === "contentType" && !["image/png", "image/jpeg", "image/gif", "image/bmp", "image/tiff", "image/x-wmf"].includes(value))
-        usage12("Unsupported image content type.");
+        usage13("Unsupported image content type.");
       if (argument.startsWith("--preserve-") && value !== "true" && value !== "false")
-        usage12("Image preservation requires true or false.");
+        usage13("Image preservation requires true or false.");
       result.imageReplace = {
         ...result.imageReplace,
         [key]: argument.startsWith("--preserve-") ? value === "true" : value
@@ -9853,18 +10122,18 @@ function parse(raw, maximum, output3) {
     )) {
       const key = argument === "--content-type" ? "contentType" : argument === "--alt-text" ? "altText" : argument.slice(2);
       if (key === "fit" && !["contain", "cover", "stretch"].includes(value))
-        usage12("Invalid image fit.");
+        usage13("Invalid image fit.");
       if (key === "contentType" && !["image/png", "image/jpeg", "image/gif", "image/bmp", "image/tiff", "image/x-wmf"].includes(value))
-        usage12("Unsupported image content type.");
+        usage13("Unsupported image content type.");
       const parsed = ["left", "top", "width", "height"].includes(key) ? commandLength(value, key === "left" || key === "top" ? -27273042316900 : 1) : value;
       result.imageAdd = { ...result.imageAdd, [key]: parsed };
       continue;
     }
     if (argument === "--image") {
       if (operation !== "images.list" && operation !== "images.extract" && operation !== "images.replace" && operation !== "images.set")
-        usage12("Image selection requires images list, extract, replace or set.");
+        usage13("Image selection requires images list, extract, replace or set.");
       if (!value.length || [...value].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(value)) || Number(value) < 1)
-        usage12("Image positions require positive integers.");
+        usage13("Image positions require positive integers.");
       result.image = Number(value);
       continue;
     }
@@ -9875,17 +10144,17 @@ function parse(raw, maximum, output3) {
         try {
           parsed = admitFontMetrics(JSON.parse(value));
         } catch (error) {
-          if (error instanceof OfficeError16) throw error;
-          usage12("Metrics require a valid JSON metric object.");
+          if (error instanceof OfficeError19) throw error;
+          usage13("Metrics require a valid JSON metric object.");
         }
       } else if (["bold", "italic", "wrap"].includes(key)) {
-        if (!["true", "false"].includes(value)) usage12("Text fit switches require true or false.");
+        if (!["true", "false"].includes(value)) usage13("Text fit switches require true or false.");
         parsed = value === "true";
       } else if (key.startsWith("margin")) parsed = commandLength(value) / 12700;
       else if (key !== "fontFamily") {
         const pieces = value.split(".");
         if (pieces.length > 2 || pieces.some((p) => !p || [...p].some((c) => c < "0" || c > "9")))
-          usage12("Text fit sizes and spacing require decimal numbers.");
+          usage13("Text fit sizes and spacing require decimal numbers.");
         parsed = Number(value);
       }
       result.fitEdit = { ...result.fitEdit, [key]: parsed };
@@ -9897,13 +10166,13 @@ function parse(raw, maximum, output3) {
       if (value === "null" && key !== "text") parsed = null;
       else if (key.startsWith("margin")) parsed = commandLength(value, -2147483648) / 12700;
       else if (key === "wrap") {
-        if (!["true", "false"].includes(value)) usage12("Wrap requires true, false or null.");
+        if (!["true", "false"].includes(value)) usage13("Wrap requires true, false or null.");
         parsed = value === "true";
       } else if (key === "columns" || key === "rotation") {
         const digits = key === "rotation" && value.startsWith("-") ? value.slice(1) : value;
         const pieces = digits.split(".");
         if (pieces.length > (key === "columns" ? 1 : 2) || pieces.some((piece) => !piece || [...piece].some((c) => c < "0" || c > "9")) || !Number.isFinite(Number(value)))
-          usage12("Columns require an integer; rotation requires finite decimal degrees.");
+          usage13("Columns require an integer; rotation requires finite decimal degrees.");
         parsed = Number(value);
       }
       result.frameEdit = { ...result.frameEdit, [key]: parsed };
@@ -9913,12 +10182,12 @@ function parse(raw, maximum, output3) {
       let key = argument.slice(2).split("-").map((part, index2) => index2 ? part[0].toUpperCase() + part.slice(1) : part).join("");
       let parsed = value;
       if (key === "direction") {
-        if (seen.has("--rtl")) usage12("Direction and RTL cannot be combined.");
-        if (!["ltr", "rtl", "null"].includes(value)) usage12("Direction requires ltr, rtl or null.");
+        if (seen.has("--rtl")) usage13("Direction and RTL cannot be combined.");
+        if (!["ltr", "rtl", "null"].includes(value)) usage13("Direction requires ltr, rtl or null.");
         key = "rtl";
         parsed = value === "null" ? null : value === "rtl";
       } else if (key === "numbering") {
-        if (seen.has("--bullet")) usage12("Bullet and numbering cannot be combined.");
+        if (seen.has("--bullet")) usage13("Bullet and numbering cannot be combined.");
         const schemes = {
           decimal: "arabicPeriod",
           "lower-alpha": "alphaLcPeriod",
@@ -9927,7 +10196,7 @@ function parse(raw, maximum, output3) {
           "upper-roman": "romanUcPeriod"
         };
         if (!Object.hasOwn(schemes, value) && !["none", "null"].includes(value))
-          usage12("Unsupported numbering style.");
+          usage13("Unsupported numbering style.");
         key = "bullet";
         parsed = value === "null" ? null : value === "none" ? { kind: "none" } : { kind: "numbered", scheme: schemes[value] };
       } else if (value === "null" && key !== "paragraph") parsed = null;
@@ -9941,11 +10210,11 @@ function parse(raw, maximum, output3) {
       ].includes(key))
         parsed = commandLength(value, key === "indent" ? -Number.MAX_SAFE_INTEGER : 0) / 12700;
       else if (key === "rtl") {
-        if (!["true", "false"].includes(value)) usage12("RTL requires true, false or null.");
+        if (!["true", "false"].includes(value)) usage13("RTL requires true, false or null.");
         parsed = value === "true";
       } else if (["paragraph", "level"].includes(key)) {
         if (![...value].every((c) => c >= "0" && c <= "9") || !Number.isSafeInteger(Number(value)) || key === "paragraph" && Number(value) < 1)
-          usage12("Invalid paragraph position or level.");
+          usage13("Invalid paragraph position or level.");
         parsed = Number(value) - (key === "paragraph" ? 1 : 0);
       } else if (key === "lineSpacing") {
         const pieces = value.split(".");
@@ -9957,7 +10226,7 @@ function parse(raw, maximum, output3) {
         parsed = value.startsWith("{") ? commandJson(value) : { kind: "character", character: value };
       else if (key === "tabs") {
         const tabs = commandJson(value);
-        if (!Array.isArray(tabs)) usage12("Tabs require an array or null.");
+        if (!Array.isArray(tabs)) usage13("Tabs require an array or null.");
         parsed = tabs.map((tab) => {
           if (tab && typeof tab === "object" && "unit" in tab) {
             const record3 = tab;
@@ -9970,7 +10239,7 @@ function parse(raw, maximum, output3) {
             const aligned = tab;
             const length4 = tab.position;
             if (Object.keys(aligned).some((key2) => !["position", "alignment"].includes(key2)))
-              usage12("Tabs require finite explicit lengths.");
+              usage13("Tabs require finite explicit lengths.");
             return {
               position: paragraphTabLength(length4),
               alignment: aligned.alignment
@@ -9980,9 +10249,9 @@ function parse(raw, maximum, output3) {
         });
       }
       if (argument === "--rtl" && seen.has("--direction"))
-        usage12("Direction and RTL cannot be combined.");
+        usage13("Direction and RTL cannot be combined.");
       if (argument === "--bullet" && seen.has("--numbering"))
-        usage12("Bullet and numbering cannot be combined.");
+        usage13("Bullet and numbering cannot be combined.");
       result.paragraphEdit = { ...result.paragraphEdit, [key]: parsed };
       continue;
     }
@@ -9993,20 +10262,20 @@ function parse(raw, maximum, output3) {
       else if (["complexScriptCharset", "complexScriptPitchFamily"].includes(key)) {
         const digits = value.startsWith("-") ? value.slice(1) : value;
         if (!digits || [...digits].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(value)))
-          usage12("Font classification requires an integer or null.");
+          usage13("Font classification requires an integer or null.");
         parsed = Number(value);
       } else if (["size", "spacing"].includes(key))
         parsed = commandLength(value, key === "spacing" ? -Number.MAX_SAFE_INTEGER : 1) / 12700;
       else if (["bold", "italic", "rtl"].includes(key)) {
-        if (!["true", "false"].includes(value)) usage12("Emphasis requires true, false or null.");
+        if (!["true", "false"].includes(value)) usage13("Emphasis requires true, false or null.");
         parsed = value === "true";
       } else if (["paragraph", "run"].includes(key)) {
         if (![...value].every((c) => c >= "0" && c <= "9") || !Number.isSafeInteger(Number(value)) || Number(value) < 1)
-          usage12("Text positions require positive one-based integers.");
+          usage13("Text positions require positive one-based integers.");
         parsed = Number(value) - 1;
       } else if (key === "baseline") {
         if (!value.trim() || !Number.isFinite(Number(value)))
-          usage12("Baseline requires a finite percentage.");
+          usage13("Baseline requires a finite percentage.");
         parsed = Number(value);
       } else if (["color", "highlight"].includes(key) && value.startsWith("{"))
         parsed = commandJson(value);
@@ -10017,20 +10286,20 @@ function parse(raw, maximum, output3) {
       continue;
     }
     if (argument === "--style-json") {
-      if (operation !== "text.replace") usage12("Style override requires text replace.");
+      if (operation !== "text.replace") usage13("Style override requires text replace.");
       const style = commandJson(value);
       if (!style || typeof style !== "object" || Array.isArray(style) || Object.keys(style).length === 0 || Object.entries(style).some(
         ([key, field]) => !["bold", "italic"].includes(key) || typeof field !== "boolean"
       ))
-        usage12("Style requires explicit bold or italic boolean values.");
+        usage13("Style requires explicit bold or italic boolean values.");
       result.style = style;
       continue;
     }
     if (["--find", "--with", "--occurrence"].includes(argument)) {
-      if (operation !== "text.replace") usage12("Match options require text replace.");
+      if (operation !== "text.replace") usage13("Match options require text replace.");
       if (argument === "--occurrence") {
         if (![...value].every((c) => c >= "0" && c <= "9") || !Number.isSafeInteger(Number(value)) || Number(value) < 1)
-          usage12("Occurrence must be a positive integer.");
+          usage13("Occurrence must be a positive integer.");
         result.occurrence = Number(value);
       } else if (argument === "--find") result.find = value;
       else result.with = value;
@@ -10047,7 +10316,7 @@ function parse(raw, maximum, output3) {
     ].includes(argument)) {
       const key = argument === "--placeholder-policy" ? "placeholderPolicy" : argument === "--show-master-shapes" ? "showMasterShapes" : argument === "--matching-name" ? "matchingName" : argument === "--placeholders-json" ? "placeholders" : argument.slice(2);
       if (["preserve", "showMasterShapes"].includes(key) && !["true", "false"].includes(value))
-        usage12("Expected true or false.");
+        usage13("Expected true or false.");
       result.layoutEdit = {
         ...result.layoutEdit,
         [key]: key === "placeholders" ? commandJson(value) : ["preserve", "showMasterShapes"].includes(key) ? value === "true" : value
@@ -10086,18 +10355,18 @@ function parse(raw, maximum, output3) {
     }
     if (operation === "shapes.drawing.set" && ["--fill", "--line", "--shadow-inherit"].includes(argument)) {
       if (argument === "--shadow-inherit" && !["true", "false"].includes(value))
-        usage12("Shadow inheritance requires true or false.");
+        usage13("Shadow inheritance requires true or false.");
       const key = argument === "--shadow-inherit" ? "shadowInherit" : argument.slice(2);
       result.drawingEdit = { ...result.drawingEdit, [key]: commandJson(value) };
       continue;
     }
     if (operation === "shapes.effects.set" && ["--shadow", "--opacity", "--shadow-blur", "--shadow-color"].includes(argument)) {
       if (argument === "--shadow") {
-        if (!["true", "false"].includes(value)) usage12("Shadow requires true or false.");
+        if (!["true", "false"].includes(value)) usage13("Shadow requires true or false.");
         result.shadowEnabled = value === "true";
       } else if (argument === "--opacity") {
         if (!value.trim() || !Number.isFinite(Number(value)) || Number(value) < 0 || Number(value) > 1)
-          usage12("Opacity requires a ratio from zero to one.");
+          usage13("Opacity requires a ratio from zero to one.");
         result.shadowOpacity = Number(value);
       } else if (argument === "--shadow-blur")
         result.shadowBlur = { value: commandLength(value, 0), unit: "emu" };
@@ -10106,7 +10375,7 @@ function parse(raw, maximum, output3) {
       continue;
     }
     if (operation.startsWith("shapes.paths.") && argument === "--close") {
-      if (!["true", "false"].includes(value)) usage12("Close requires true or false.");
+      if (!["true", "false"].includes(value)) usage13("Close requires true or false.");
       result.close = value === "true";
       continue;
     }
@@ -10144,18 +10413,18 @@ function parse(raw, maximum, output3) {
           value,
           ["left", "top"].includes(key) ? -27273042316900 : key === "lineWidth" ? 0 : 1
         );
-        if (Math.abs(length4) > 27273042316900) usage12("Shape geometry exceeds DrawingML bounds.");
+        if (Math.abs(length4) > 27273042316900) usage13("Shape geometry exceeds DrawingML bounds.");
         parsed = { value: length4, unit: "emu" };
       } else if (key === "flipHorizontal" || key === "flipVertical") {
-        if (!["true", "false"].includes(value)) usage12("Flips require true or false.");
+        if (!["true", "false"].includes(value)) usage13("Flips require true or false.");
         parsed = value === "true";
       } else if (key === "locked") {
         if (!["true", "false", "null"].includes(value))
-          usage12("Locked requires true, false or null.");
+          usage13("Locked requires true, false or null.");
         parsed = value === "null" ? null : value === "true";
       } else if (key === "rotation") {
         if (!value.trim() || !Number.isFinite(Number(value)))
-          usage12("Rotation requires finite degrees.");
+          usage13("Rotation requires finite degrees.");
         parsed = Number(value);
       } else if (key === "kind" && value.length && [...value].every((c) => c >= "0" && c <= "9"))
         parsed = Number(value);
@@ -10193,7 +10462,7 @@ function parse(raw, maximum, output3) {
       "--loop",
       "--show-type"
     ].includes(argument) || operation === "settings.set" && ["--width", "--height"].includes(argument)) {
-      if (operation !== "settings.set") usage12("Settings options require settings set.");
+      if (operation !== "settings.set") usage13("Settings options require settings set.");
       if (["--width", "--height", "--notes-width", "--notes-height"].includes(argument)) {
         const key = argument === "--notes-width" ? "notesWidth" : argument === "--notes-height" ? "notesHeight" : argument.slice(2);
         result.settings = {
@@ -10202,7 +10471,7 @@ function parse(raw, maximum, output3) {
         };
       } else if (argument === "--orientation" || argument === "--notes-orientation") {
         if (value !== "portrait" && value !== "landscape")
-          usage12("Orientation requires portrait or landscape.");
+          usage13("Orientation requires portrait or landscape.");
         result.settings = {
           ...result.settings,
           [argument === "--orientation" ? "orientation" : "notesOrientation"]: value
@@ -10210,17 +10479,17 @@ function parse(raw, maximum, output3) {
       } else if (argument === "--slide-number-start") {
         const digits = value.startsWith("-") ? value.slice(1) : value;
         if (!digits.length || ![...digits].every((c) => c >= "0" && c <= "9") || !Number.isSafeInteger(Number(value)))
-          usage12("Slide-number start requires a safe integer.");
+          usage13("Slide-number start requires a safe integer.");
         result.settings = { ...result.settings, slideNumberStart: Number(value) };
       } else if (argument === "--loop" || argument === "--scale-content") {
-        if (value !== "true" && value !== "false") usage12("Boolean settings require true or false.");
+        if (value !== "true" && value !== "false") usage13("Boolean settings require true or false.");
         result.settings = {
           ...result.settings,
           [argument === "--loop" ? "loop" : "scaleContent"]: value === "true"
         };
       } else {
         if (value !== "speaker" && value !== "window" && value !== "kiosk")
-          usage12("Unknown show type.");
+          usage13("Unknown show type.");
         result.settings = { ...result.settings, showType: value };
       }
       continue;
@@ -10230,24 +10499,24 @@ function parse(raw, maximum, output3) {
       else if (argument === "--slides") {
         const slides = commandJson(value);
         if (!Array.isArray(slides) || !slides.length || slides.some((item) => !Number.isSafeInteger(item) || item < 1) || new Set(slides).size !== slides.length)
-          usage12("Members require a nonempty array of unique one-based slide positions.");
+          usage13("Members require a nonempty array of unique one-based slide positions.");
         result.membership = { ...result.membership, slides };
       } else {
         if (![...value].every((c) => c >= "0" && c <= "9") || !Number.isSafeInteger(Number(value)) || Number(value) < 1)
-          usage12("Section positions must be positive integers.");
+          usage13("Section positions must be positive integers.");
         result.membership = { ...result.membership, position: Number(value) };
       }
       continue;
     }
     if (argument === "--sources") {
-      if (operation !== "slides.merge") usage12("Sources require slides merge.");
+      if (operation !== "slides.merge") usage13("Sources require slides merge.");
       const sources = commandJson(value);
       if (!Array.isArray(sources) || !sources.length || sources.some(
         (source3) => !source3 || typeof source3 !== "object" || Array.isArray(source3) || Object.keys(source3).length !== 1 || typeof source3.vfsPath !== "string" || !source3.vfsPath.length
       ))
-        usage12("Sources require a nonempty ordered array of scoped vfsPath inputs.");
+        usage13("Sources require a nonempty ordered array of scoped vfsPath inputs.");
       const paths = sources.map((source3) => source3.vfsPath);
-      if (new Set(paths).size !== paths.length) usage12("Source inputs must be unique.");
+      if (new Set(paths).size !== paths.length) usage13("Source inputs must be unique.");
       result.sources = paths;
       continue;
     }
@@ -10255,57 +10524,57 @@ function parse(raw, maximum, output3) {
       if (argument === "--manifest") result.manifest = value;
       else {
         const parts = commandJson(value);
-        if (!Array.isArray(parts) || parts.some((part) => typeof part !== "string")) usage12("Parts require a string array.");
+        if (!Array.isArray(parts) || parts.some((part) => typeof part !== "string")) usage13("Parts require a string array.");
         result.parts = parts;
       }
       continue;
     }
     if (argument === "--sha256") {
       if (operation !== "images.extract" || value.length !== 64 || !Array.from(value).every((character) => "0123456789abcdef".includes(character)))
-        usage12("Image extraction requires a lowercase SHA256 hash.");
+        usage13("Image extraction requires a lowercase SHA256 hash.");
       result.imageSha256 = value;
       continue;
     }
     if (argument === "--output-dir" || argument === "--slides") {
       if (operation !== "slides.split" && !(["extract", "images.extract", "media.extract", "objects.extract"].includes(operation) && argument === "--output-dir"))
-        usage12("Option requires a multi-file operation.");
+        usage13("Option requires a multi-file operation.");
       if (argument === "--output-dir") result.outputDir = value;
       else {
         const positions = commandJson(value);
         if (!Array.isArray(positions) || !positions.length || positions.some((position) => !Number.isSafeInteger(position) || position < 1) || new Set(positions).size !== positions.length)
-          usage12("Slides require a nonempty array of unique one-based positions.");
+          usage13("Slides require a nonempty array of unique one-based positions.");
         result.splitSlides = positions;
       }
       continue;
     }
     if (argument === "--reference-policy") {
       if (operation !== "slides.remove" || value !== "remove")
-        usage12("Slide removal reference policy must be remove.");
+        usage13("Slide removal reference policy must be remove.");
       result.referencePolicy = value;
       continue;
     }
     if (argument === "--media-policy") {
       if (operation !== "slides.duplicate" || !["shared-media", "isolated-instance"].includes(value))
-        usage12("Slide duplication media policy must be shared-media or isolated-instance.");
+        usage13("Slide duplication media policy must be shared-media or isolated-instance.");
       result.copyMediaPolicy = value;
       continue;
     }
     if (["--source", "--source-slides", "--theme-policy", "--dimension-policy"].includes(argument)) {
       if (operation !== "slides.import" && operation !== "slides.merge")
-        usage12("Option requires slides import or merge.");
+        usage13("Option requires slides import or merge.");
       if (operation === "slides.merge" && argument === "--source")
-        usage12("Merge requires --sources.");
+        usage13("Merge requires --sources.");
       if (argument === "--source") result.source = value;
       else if (argument === "--source-slides") {
         const positions = commandJson(value);
         if (!Array.isArray(positions) || !positions.length || positions.some((position) => !Number.isSafeInteger(position) || position < 1) || new Set(positions).size !== positions.length)
-          usage12("Source slides require a nonempty array of unique one-based positions.");
+          usage13("Source slides require a nonempty array of unique one-based positions.");
         result.importing = { ...result.importing, sourceSlides: positions };
       } else if (argument === "--theme-policy") {
-        if (value !== "source" && value !== "destination") usage12("Unknown theme policy.");
+        if (value !== "source" && value !== "destination") usage13("Unknown theme policy.");
         result.importing = { ...result.importing, themePolicy: value };
       } else {
-        if (value !== "reject" && value !== "destination") usage12("Unknown dimension policy.");
+        if (value !== "reject" && value !== "destination") usage13("Unknown dimension policy.");
         result.importing = { ...result.importing, dimensionPolicy: value };
       }
       continue;
@@ -10323,7 +10592,7 @@ function parse(raw, maximum, output3) {
       if (operation === "slides.import" || operation === "slides.duplicate" || operation === "slides.move" || operation === "slides.set") {
         if (argument === "--position") {
           if (![...value].every((character) => character >= "0" && character <= "9") || !Number.isSafeInteger(Number(value)) || Number(value) < 1)
-            usage12("Slide positions must be positive one-based integers.");
+            usage13("Slide positions must be positive one-based integers.");
           if (operation === "slides.import")
             result.importing = { ...result.importing, position: Number(value) };
           else result.mutation = { ...result.mutation, position: Number(value) };
@@ -10331,30 +10600,30 @@ function parse(raw, maximum, output3) {
           result.mutation = { ...result.mutation, name: value };
         else if (operation === "slides.set" && argument === "--hidden") {
           if (value !== "true" && value !== "false")
-            usage12("Slide boolean options require true or false.");
+            usage13("Slide boolean options require true or false.");
           result.mutation = { ...result.mutation, hidden: value === "true" };
-        } else usage12("Option is unavailable for this slide operation.");
+        } else usage13("Option is unavailable for this slide operation.");
         continue;
       }
-      if (operation !== "slides.add") usage12("Slide addition options require slides add.");
+      if (operation !== "slides.add") usage13("Slide addition options require slides add.");
       result.addition ??= {};
       if (argument === "--position") {
         if (![...value].every((character) => character >= "0" && character <= "9") || !Number.isSafeInteger(Number(value)) || Number(value) < 1)
-          usage12("Insertion positions must be positive one-based integers.");
+          usage13("Insertion positions must be positive one-based integers.");
         result.addition = { ...result.addition, position: Number(value) };
       } else if (argument === "--hidden" || argument === "--follow-master-background") {
         if (value !== "true" && value !== "false")
-          usage12("Slide boolean options require true or false.");
+          usage13("Slide boolean options require true or false.");
         result.addition = {
           ...result.addition,
           [argument === "--hidden" ? "hidden" : "followMasterBackground"]: value === "true"
         };
       } else if (argument === "--placeholders-json") {
         const placeholders = commandJson(value);
-        if (!Array.isArray(placeholders)) usage12("Placeholders require an array.");
+        if (!Array.isArray(placeholders)) usage13("Placeholders require an array.");
         for (const binding of placeholders) {
           if (!binding || typeof binding !== "object" || Array.isArray(binding) || Object.keys(binding).some((key) => !["type", "index", "text"].includes(key)) || typeof binding.type !== "string" || !binding.type.length || typeof binding.text !== "string" || Object.hasOwn(binding, "index") && (!Number.isSafeInteger(binding.index) || binding.index < 0 || binding.index > 4294967295))
-            usage12("Placeholder bindings require type, optional nonnegative index, and text.");
+            usage13("Placeholder bindings require type, optional nonnegative index, and text.");
         }
         result.addition = { ...result.addition, placeholders };
       } else result.addition = { ...result.addition, [argument.slice(2)]: value };
@@ -10371,16 +10640,16 @@ function parse(raw, maximum, output3) {
       "--slides-json",
       "--properties-json"
     ].includes(argument)) {
-      if (operation !== "create" && operation !== "pack") usage12("Creation options require create or pack.");
+      if (operation !== "create" && operation !== "pack") usage13("Creation options require create or pack.");
       result.creation ??= {};
       if (argument === "--template") result.template = value;
       else if (argument === "--width" || argument === "--height")
         result.creation = { ...result.creation, [argument.slice(2)]: commandLength(value) };
       else if (argument === "--kind") {
-        if (!["pptx", "potx", "ppsx"].includes(value)) usage12("Unknown presentation kind.");
+        if (!["pptx", "potx", "ppsx"].includes(value)) usage13("Unknown presentation kind.");
         result.creation = { ...result.creation, kind: value };
       } else if (argument === "--dialect") {
-        if (!["strict", "transitional"].includes(value)) usage12("Unknown presentation dialect.");
+        if (!["strict", "transitional"].includes(value)) usage13("Unknown presentation dialect.");
         result.creation = { ...result.creation, dialect: value };
       } else if (argument === "--author") result.creation = { ...result.creation, author: value };
       else if (argument === "--timestamp")
@@ -10388,7 +10657,7 @@ function parse(raw, maximum, output3) {
       else if (argument === "--properties-json") {
         const properties = commandJson(value);
         if (!properties || typeof properties !== "object" || Array.isArray(properties))
-          usage12("Properties require an object.");
+          usage13("Properties require an object.");
         if (Object.keys(properties).some(
           (key) => ![
             "title",
@@ -10408,11 +10677,11 @@ function parse(raw, maximum, output3) {
             "lastPrinted"
           ].includes(key)
         ))
-          usage12("Unknown creation property.");
+          usage13("Unknown creation property.");
         for (const key of ["created", "modified", "lastPrinted"]) {
           if (Object.hasOwn(properties, key)) {
             const dates = properties;
-            if (typeof dates[key] !== "string") usage12("Property dates require UTC strings.");
+            if (typeof dates[key] !== "string") usage13("Property dates require UTC strings.");
             dates[key] = commandTimestamp(dates[key]);
           }
         }
@@ -10434,36 +10703,36 @@ function parse(raw, maximum, output3) {
     }
     if (argument === "--selection-json") {
       if (operation !== "slides.move" && operation !== "slides.set" && operation !== "slides.remove" && operation !== "slides.duplicate")
-        usage12("Selection JSON requires a supported slide mutation.");
+        usage13("Selection JSON requires a supported slide mutation.");
       const selection = commandJson(value);
       if (!selection || typeof selection !== "object")
-        usage12("Selection JSON requires a query or nonempty query array.");
+        usage13("Selection JSON requires a query or nonempty query array.");
       const queries = Array.isArray(selection) ? selection : [selection];
-      if (!queries.length) usage12("Selection arrays must not be empty.");
+      if (!queries.length) usage13("Selection arrays must not be empty.");
       for (const query of queries) {
         if (!query || typeof query !== "object" || Array.isArray(query) || Object.keys(query).some(
           (key) => !["kind", "scope", "owner", "position", "id", "name", "token", "all"].includes(key)
         ))
-          usage12("Invalid slide selection query.");
+          usage13("Invalid slide selection query.");
         if (query.token !== void 0) {
           if (typeof query.token !== "string" || Object.keys(query).some((key) => !["kind", "token"].includes(key)) || query.kind !== void 0 && query.kind !== "slide")
-            usage12("Invalid slide token query.");
+            usage13("Invalid slide token query.");
           decodeSelectionToken2(query.token);
           continue;
         }
         if (query.kind !== "slide" || query.scope !== void 0 && query.scope !== "slides" || query.all !== void 0 && typeof query.all !== "boolean")
-          usage12("Selection queries must address slides.");
+          usage13("Selection queries must address slides.");
         for (const key of ["id", "name", "owner"])
           if (query[key] !== void 0 && (typeof query[key] !== "string" || key !== "name" && !query[key]))
-            usage12("Invalid slide selection value.");
+            usage13("Invalid slide selection value.");
         if ([query.position, query.id, query.name].filter((item) => item !== void 0).length > 1)
-          usage12("Slide identity selectors cannot be combined.");
+          usage13("Slide identity selectors cannot be combined.");
         if (!query.all && query.position === void 0 && query.id === void 0 && query.name === void 0)
-          usage12("Slide selection requires an identity or all.");
+          usage13("Slide selection requires an identity or all.");
         if (query.position !== void 0) {
           const position = query.position;
           if (!position || typeof position !== "object" || Array.isArray(position) || Object.keys(position).some((key) => !["coordinateSystem", "value"].includes(key)) || !["one-based", "zero-based"].includes(position.coordinateSystem) || !Number.isSafeInteger(position.value) || position.value < (position.coordinateSystem === "one-based" ? 1 : 0))
-            usage12("Invalid slide selection coordinate.");
+            usage13("Invalid slide selection coordinate.");
         }
       }
       result.selection = selection;
@@ -10473,9 +10742,9 @@ function parse(raw, maximum, output3) {
       const pieces = value.split("=");
       const [name, digits] = pieces;
       if (pieces.length !== 2 || !name || !digits || ![...digits].every((c) => c >= "0" && c <= "9") || !Number.isSafeInteger(Number(digits)) || Number(digits) < 1)
-        usage12("Limits require NAME=POSITIVE_INTEGER.");
+        usage13("Limits require NAME=POSITIVE_INTEGER.");
       result.limits ??= {};
-      if (Object.hasOwn(result.limits, name)) usage12("Repeated limit name.");
+      if (Object.hasOwn(result.limits, name)) usage13("Repeated limit name.");
       if (![
         "maxBytes",
         "maxNodes",
@@ -10483,21 +10752,21 @@ function parse(raw, maximum, output3) {
         "maxOutputBytes",
         ...["extract", "images.extract", "media.extract", "objects.extract"].includes(operation) ? ["maxOutputs"] : []
       ].includes(name))
-        usage12("Unknown limit name.");
+        usage13("Unknown limit name.");
       result.limits[name] = Number(digits);
     } else if (argument === "--placeholder") {
-      if (!value.length || ![...value].every((c) => c >= "0" && c <= "9") || (!Number.isSafeInteger(Number(value)) || Number(value) > 4294967295)) usage12("Placeholder idx must be a nonnegative integer.");
+      if (!value.length || ![...value].every((c) => c >= "0" && c <= "9") || (!Number.isSafeInteger(Number(value)) || Number(value) > 4294967295)) usage13("Placeholder idx must be a nonnegative integer.");
       result.placeholder = Number(value);
     } else if (argument === "--slide") {
       if (![...value].every((character) => character >= "0" && character <= "9") || !Number.isSafeInteger(Number(value)) || Number(value) < 1)
-        usage12("Slide positions must be positive one-based integers.");
+        usage13("Slide positions must be positive one-based integers.");
       result.slide = Number(value);
     } else if (argument === "--shape") result.shape = value;
     else if (argument === "--part") {
       if (operation === "objects.list" || operation === "fonts.list")
-        usage12("Part selection requires object extraction.");
+        usage13("Part selection requires object extraction.");
       try {
-        result.part = partName3(value, false);
+        result.part = partName4(value, false);
       } catch {
         throw new SelectionError8("invalid-selection");
       }
@@ -10505,7 +10774,7 @@ function parse(raw, maximum, output3) {
     else if (argument === "--file") result.file = value;
     else if (argument === "--output") result.output = value;
     else {
-      if (!scopes2.includes(value)) usage12("Unknown scope.");
+      if (!scopes2.includes(value)) usage13("Unknown scope.");
       result.scope = value;
     }
   }
@@ -10529,42 +10798,42 @@ function parse(raw, maximum, output3) {
       "--dry-run"
     ];
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to images set.");
-    if (positionals.length !== 1 || !positionals[0]) usage12("Image formatting requires one input.");
-    if (!result.imageSet) usage12("Image formatting requires an update.");
+      usage13("Option does not apply to images set.");
+    if (positionals.length !== 1 || !positionals[0]) usage13("Image formatting requires one input.");
+    if (!result.imageSet) usage13("Image formatting requires an update.");
     if (result.scope === "presentation" || result.scope === "shared")
-      usage12("Image formatting requires an occurrence scope.");
+      usage13("Image formatting requires an occurrence scope.");
     if (result.token && ["--slide", "--image", "--scope", "--all"].some((option) => seen.has(option)))
-      usage12("Opaque and simple selectors cannot be combined.");
+      usage13("Opaque and simple selectors cannot be combined.");
     if (result.image !== void 0 && (!result.scope || result.scope === "slides") && result.slide === void 0)
-      usage12("Slide image selection requires a slide.");
+      usage13("Slide image selection requires a slide.");
     result.input = positionals[0];
     result.imageSet = {
       ...result.imageSet,
       ...result.all ? { all: true } : {},
       ...result.allowEmpty ? { allowEmpty: true } : {}
     };
-    if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-    if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
+    if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+    if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
     if (!result.dryRun && !result.inPlace && !result.output)
-      usage12("Mutation requires a destination.");
-    if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+      usage13("Mutation requires a destination.");
+    if (result.force && !result.output) usage13("Force requires an explicit output destination.");
     if (result.output === result.input && result.output !== "-")
-      usage12("Replacing input requires --in-place.");
+      usage13("Replacing input requires --in-place.");
     if (result.output === "-" && result.json && !result.dryRun)
-      usage12("Binary stdout cannot be combined with JSON.");
+      usage13("Binary stdout cannot be combined with JSON.");
     return result;
   }
   if (result.placeholder !== void 0) {
     if (!["images.add", "tables.add", "charts.add"].includes(operation) || result.slide === void 0)
-      usage12("Placeholder insertion requires an add operation and --slide.");
+      usage13("Placeholder insertion requires an add operation and --slide.");
     if (["--left", "--top", "--width", "--height", "--fit"].some((flag) => seen.has(flag)))
-      usage12("Placeholder insertion uses inherited geometry.");
-    if (operation === "tables.add" && (!result.tableEdit?.rows || !result.tableEdit?.columns)) usage12("Table placeholder insertion requires rows and columns.");
+      usage13("Placeholder insertion uses inherited geometry.");
+    if (operation === "tables.add" && (!result.tableEdit?.rows || !result.tableEdit?.columns)) usage13("Table placeholder insertion requires rows and columns.");
     if (operation === "tables.add" && Object.keys(result.tableEdit ?? {}).some((key) => !["rows", "columns"].includes(key)))
-      usage12("Table placeholder insertion accepts rows and columns.");
+      usage13("Table placeholder insertion accepts rows and columns.");
     if (operation === "charts.add" && Object.keys(result.chartEdit ?? {}).some((key) => !["type", "data"].includes(key)))
-      usage12("Chart placeholder insertion accepts type and data.");
+      usage13("Chart placeholder insertion accepts type and data.");
   }
   if (operation === "images.add" || operation === "images.replace") {
     const replacing = operation === "images.replace";
@@ -10592,19 +10861,19 @@ function parse(raw, maximum, output3) {
       "--dry-run"
     ];
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to this image operation.");
+      usage13("Option does not apply to this image operation.");
     if (positionals.length !== 1 || !positionals[0] || !replacing && result.slide === void 0 || !result.file)
-      usage12("Image mutation requires one input, selection and file.");
+      usage13("Image mutation requires one input, selection and file.");
     if (replacing) {
-      if (result.scope === "presentation") usage12("Presentation scope has no image owners.");
+      if (result.scope === "presentation") usage13("Presentation scope has no image owners.");
       if (result.scope === "shared" && !result.imageReplace?.shared)
-        usage12("Shared scope requires explicit shared replacement.");
+        usage13("Shared scope requires explicit shared replacement.");
       if (result.token && ["--slide", "--image", "--scope", "--all"].some((option) => seen.has(option)))
-        usage12("Opaque and simple selectors cannot be combined.");
+        usage13("Opaque and simple selectors cannot be combined.");
       if (!result.token && result.image === void 0 && !result.all)
-        usage12("Image replacement requires an image selector or all.");
+        usage13("Image replacement requires an image selector or all.");
       if (result.image !== void 0 && (!result.scope || result.scope === "slides") && result.slide === void 0)
-        usage12("Slide image selection requires a slide.");
+        usage13("Slide image selection requires a slide.");
       result.imageReplace = {
         ...result.imageReplace,
         ...result.all ? { all: true } : {},
@@ -10613,28 +10882,28 @@ function parse(raw, maximum, output3) {
     }
     result.input = positionals[0];
     if (result.input === "-" && result.file === "-")
-      usage12("Document and image cannot both use stdin.");
+      usage13("Document and image cannot both use stdin.");
     const imageOptions = replacing ? result.imageReplace : result.imageAdd;
     if (!imageOptions?.contentType) {
       const extension = result.file.slice(result.file.lastIndexOf(".") + 1).toLowerCase();
       const contentType = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", bmp: "image/bmp", tif: "image/tiff", tiff: "image/tiff", wmf: "image/x-wmf" }[extension];
       if (!contentType)
-        usage12("Image file requires an explicit supported content type or extension.");
+        usage13("Image file requires an explicit supported content type or extension.");
       if (replacing) result.imageReplace = { ...result.imageReplace, contentType };
       else result.imageAdd = { ...result.imageAdd, contentType };
     }
     const both = result.imageAdd?.width !== void 0 && result.imageAdd?.height !== void 0;
     if (!replacing && !both && result.imageAdd?.fit !== void 0)
-      usage12("Both dimensions and explicit fit must be supplied together.");
-    if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-    if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
+      usage13("Both dimensions and explicit fit must be supplied together.");
+    if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+    if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
     if (!result.dryRun && !result.inPlace && !result.output)
-      usage12("Mutation requires a destination.");
-    if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+      usage13("Mutation requires a destination.");
+    if (result.force && !result.output) usage13("Force requires an explicit output destination.");
     if (result.output === result.input && result.output !== "-")
-      usage12("Replacing input requires --in-place.");
+      usage13("Replacing input requires --in-place.");
     if (result.output === "-" && result.json && !result.dryRun)
-      usage12("Binary stdout cannot be combined with JSON.");
+      usage13("Binary stdout cannot be combined with JSON.");
     return result;
   }
   if (["media.add", "media.replace", "media.extract"].includes(operation)) {
@@ -10644,9 +10913,9 @@ function parse(raw, maximum, output3) {
   if (Object.hasOwn(mediaSchemas, operation)) {
     const allowed = ["--json", "--limit", "--scope", "--slide", "--shape", "--select"];
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to media inspection.");
+      usage13("Option does not apply to media inspection.");
     if (positionals.length !== 1 || !positionals[0])
-      usage12("Media inspection requires exactly one input.");
+      usage13("Media inspection requires exactly one input.");
     if (result.scope !== void 0 && ![
       "slides",
       "layouts",
@@ -10656,11 +10925,11 @@ function parse(raw, maximum, output3) {
       "handout-master",
       "shared"
     ].includes(result.scope))
-      usage12("Unsupported media scope.");
+      usage13("Unsupported media scope.");
     if (result.token && ["--slide", "--shape", "--scope"].some((option) => seen.has(option)))
-      usage12("Opaque and simple selectors cannot be combined.");
+      usage13("Opaque and simple selectors cannot be combined.");
     if (result.shape !== void 0 && result.slide === void 0)
-      usage12("Shape selection requires an owning slide.");
+      usage13("Shape selection requires an owning slide.");
     result.input = positionals[0];
     return result;
   }
@@ -10709,47 +10978,47 @@ function parse(raw, maximum, output3) {
       (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("")
     );
     if ([...seen].some((flag) => !allowed.includes(flag)))
-      usage12("Option does not apply to chart mutation.");
+      usage13("Option does not apply to chart mutation.");
     if (positionals.length !== 1 || !positionals[0])
-      usage12("Chart mutation requires exactly one input.");
+      usage13("Chart mutation requires exactly one input.");
     result.input = positionals[0];
     if (result.scope !== void 0 && result.scope !== "slides")
-      usage12("Chart mutation supports slides scope.");
+      usage13("Chart mutation supports slides scope.");
     if (result.token && ["--slide", "--shape", "--scope", "--all"].some((flag) => seen.has(flag)))
-      usage12("Opaque and simple selectors cannot be combined.");
+      usage13("Opaque and simple selectors cannot be combined.");
     const edit = result.chartEdit ?? {};
     const { type, ...update } = edit;
     validateChartUpdate(update);
     if (operation === "charts.add") {
       if (!result.slide || result.token || result.shape || result.all || result.allowEmpty)
-        usage12("Chart addition requires one slide.");
+        usage13("Chart addition requires one slide.");
       if (!type || !chartTypes2.includes(type) || !edit.data || result.placeholder === void 0 && [edit.left, edit.top, edit.width, edit.height].some((value) => value === void 0))
-        usage12("Chart addition requires type, data and geometry.");
+        usage13("Chart addition requires type, data and geometry.");
       validateChartData(edit.data, type);
-    } else if (!Object.keys(edit).length) usage12("Chart mutation requires an update.");
+    } else if (!Object.keys(edit).length) usage13("Chart mutation requires an update.");
     if (operation === "charts.replace" && (!edit.data || !["synchronize-simple", "reject-complex"].includes(result.chartWorkbookPolicy)))
-      usage12("Chart replacement requires data and an explicit workbook policy.");
-    if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-    if (result.output && result.inPlace) usage12("Output and in-place are mutually exclusive.");
+      usage13("Chart replacement requires data and an explicit workbook policy.");
+    if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+    if (result.output && result.inPlace) usage13("Output and in-place are mutually exclusive.");
     if (!result.dryRun && !result.inPlace && !result.output)
-      usage12("Mutation requires a destination.");
-    if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+      usage13("Mutation requires a destination.");
+    if (result.force && !result.output) usage13("Force requires an explicit output destination.");
     if (result.output === result.input && result.output !== "-")
-      usage12("Replacing input requires --in-place.");
+      usage13("Replacing input requires --in-place.");
     if (result.output === "-" && result.json && !result.dryRun)
-      usage12("Binary stdout cannot be combined with JSON.");
+      usage13("Binary stdout cannot be combined with JSON.");
     return result;
   }
   if (operation === "charts.list" || operation === "charts.get") {
     const allowed = ["--json", "--limit", "--scope", "--slide", "--shape", "--select"];
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to chart inspection.");
+      usage13("Option does not apply to chart inspection.");
     if (positionals.length !== 1 || !positionals[0])
-      usage12("Chart inspection requires exactly one input.");
+      usage13("Chart inspection requires exactly one input.");
     if (result.scope !== void 0 && result.scope !== "slides")
-      usage12("Chart inspection supports slides scope.");
+      usage13("Chart inspection supports slides scope.");
     if (result.token && ["--slide", "--shape", "--scope"].some((option) => seen.has(option)))
-      usage12("Opaque and simple selectors cannot be combined.");
+      usage13("Opaque and simple selectors cannot be combined.");
     result.input = positionals[0];
     return result;
   }
@@ -10766,33 +11035,33 @@ function parse(raw, maximum, output3) {
       ...extracting ? ["--sha256", "--output-dir", "--allow-partial-output", "--force", "--dry-run"] : []
     ];
     if (extracting) {
-      if (!result.outputDir && !result.dryRun) usage12("Image extraction requires --output-dir.");
-      if (result.outputDir === "-") usage12("Output directories cannot be stdout.");
-      if (result.force && !result.outputDir) usage12("Force requires an output directory.");
+      if (!result.outputDir && !result.dryRun) usage13("Image extraction requires --output-dir.");
+      if (result.outputDir === "-") usage13("Output directories cannot be stdout.");
+      if (result.force && !result.outputDir) usage13("Force requires an output directory.");
     }
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to images list.");
+      usage13("Option does not apply to images list.");
     if (positionals.length !== 1 || !positionals[0])
-      usage12("Image inventory requires exactly one input.");
-    if (result.scope === "presentation") usage12("Presentation scope has no image owners.");
+      usage13("Image inventory requires exactly one input.");
+    if (result.scope === "presentation") usage13("Presentation scope has no image owners.");
     if (result.token && ["--slide", "--image", "--scope"].some((option) => seen.has(option)))
-      usage12("Opaque and simple selectors cannot be combined.");
+      usage13("Opaque and simple selectors cannot be combined.");
     result.input = positionals[0];
     return result;
   }
   if (operation === "batch") {
     const allowed = ["--json", "--limit", "--ops-json", "--ops-file", "--output", "--in-place", "--force", "--dry-run"];
-    if ([...seen].some((flag) => !allowed.includes(flag))) usage12("Option does not apply to batch.");
-    if (positionals.length !== 1 || !positionals[0]) usage12("Batch requires one input.");
-    if (result.animationBatch !== void 0 === (result.opsFile !== void 0)) usage12("Batch requires exactly one operation source.");
+    if ([...seen].some((flag) => !allowed.includes(flag))) usage13("Option does not apply to batch.");
+    if (positionals.length !== 1 || !positionals[0]) usage13("Batch requires one input.");
+    if (result.animationBatch !== void 0 === (result.opsFile !== void 0)) usage13("Batch requires exactly one operation source.");
     result.input = positionals[0];
-    if (result.input === "-" && result.opsFile === "-") usage12("Document and batch cannot both use stdin.");
-    if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-    if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
-    if (result.animationBatch?.length && !result.dryRun && !result.inPlace && !result.output) usage12("Mutation requires a destination.");
-    if (result.force && !result.output) usage12("Force requires an explicit output destination.");
-    if (result.output === result.input && result.output !== "-") usage12("Replacing input requires --in-place.");
-    if (result.output === "-" && result.json && !result.dryRun) usage12("Binary stdout cannot be combined with JSON.");
+    if (result.input === "-" && result.opsFile === "-") usage13("Document and batch cannot both use stdin.");
+    if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+    if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
+    if (result.animationBatch?.length && !result.dryRun && !result.inPlace && !result.output) usage13("Mutation requires a destination.");
+    if (result.force && !result.output) usage13("Force requires an explicit output destination.");
+    if (result.output === result.input && result.output !== "-") usage13("Replacing input requires --in-place.");
+    if (result.output === "-" && result.json && !result.dryRun) usage13("Binary stdout cannot be combined with JSON.");
     return result;
   }
   if (Object.hasOwn(animationSchemas, operation)) {
@@ -10808,21 +11077,21 @@ function parse(raw, maximum, output3) {
       ...mutation2 ? ["--all", "--allow-empty", "--output", "--in-place", "--force", "--dry-run"] : [],
       ...editing ? ["--kind", "--trigger", "--duration", "--delay", "--target"] : []
     ];
-    if ([...seen].some((flag) => !allowed.includes(flag))) usage12("Option does not apply to animations.");
-    if (positionals.length !== 1 || !positionals[0]) usage12("Animations require one input.");
+    if ([...seen].some((flag) => !allowed.includes(flag))) usage13("Option does not apply to animations.");
+    if (positionals.length !== 1 || !positionals[0]) usage13("Animations require one input.");
     result.input = positionals[0];
-    if (result.scope !== void 0 && result.scope !== "slides") usage12("Animations require slides scope.");
-    if (result.token && ["--scope", "--slide", "--shape"].some((flag) => seen.has(flag))) usage12("Opaque and simple selectors cannot be combined.");
-    if (result.shape !== void 0 && result.slide === void 0) usage12("Shape selection requires a slide.");
+    if (result.scope !== void 0 && result.scope !== "slides") usage13("Animations require slides scope.");
+    if (result.token && ["--scope", "--slide", "--shape"].some((flag) => seen.has(flag))) usage13("Opaque and simple selectors cannot be combined.");
+    if (result.shape !== void 0 && result.slide === void 0) usage13("Shape selection requires a slide.");
     if (mutation2) {
       validateAnimationOptions2(operation.slice(11), result.animationEdit ?? {});
-      if (operation !== "animations.add" && !result.token && result.slide === void 0 && !result.all) usage12("Animation mutation requires a selector or --all.");
-      if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-      if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
-      if (!result.dryRun && !result.inPlace && !result.output) usage12("Mutation requires a destination.");
-      if (result.force && !result.output) usage12("Force requires an explicit output destination.");
-      if (result.output === result.input && result.output !== "-") usage12("Replacing input requires --in-place.");
-      if (result.output === "-" && result.json && !result.dryRun) usage12("Binary stdout cannot be combined with JSON.");
+      if (operation !== "animations.add" && !result.token && result.slide === void 0 && !result.all) usage13("Animation mutation requires a selector or --all.");
+      if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+      if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
+      if (!result.dryRun && !result.inPlace && !result.output) usage13("Mutation requires a destination.");
+      if (result.force && !result.output) usage13("Force requires an explicit output destination.");
+      if (result.output === result.input && result.output !== "-") usage13("Replacing input requires --in-place.");
+      if (result.output === "-" && result.json && !result.dryRun) usage13("Binary stdout cannot be combined with JSON.");
     }
     return result;
   }
@@ -10838,20 +11107,20 @@ function parse(raw, maximum, output3) {
       ...mutation2 ? ["--all", "--allow-empty", "--output", "--in-place", "--force", "--dry-run"] : [],
       ...editing ? ["--kind", "--direction", "--duration", "--advance-after", "--advance-on-click"] : []
     ];
-    if ([...seen].some((flag) => !allowed.includes(flag))) usage12("Option does not apply to transitions.");
-    if (positionals.length !== 1 || !positionals[0]) usage12("Transitions require one input.");
+    if ([...seen].some((flag) => !allowed.includes(flag))) usage13("Option does not apply to transitions.");
+    if (positionals.length !== 1 || !positionals[0]) usage13("Transitions require one input.");
     result.input = positionals[0];
-    if (result.scope !== void 0 && result.scope !== "slides") usage12("Transitions require slides scope.");
-    if (result.token && ["--scope", "--slide"].some((flag) => seen.has(flag))) usage12("Opaque and simple selectors cannot be combined.");
+    if (result.scope !== void 0 && result.scope !== "slides") usage13("Transitions require slides scope.");
+    if (result.token && ["--scope", "--slide"].some((flag) => seen.has(flag))) usage13("Opaque and simple selectors cannot be combined.");
     if (mutation2) {
       validateTransitionOptions(operation.slice(12), { ...result.transitionEdit, selection: {} });
-      if (!result.token && result.slide === void 0 && !result.all) usage12("Transition mutation requires a selector or --all.");
-      if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-      if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
-      if (!result.dryRun && !result.inPlace && !result.output) usage12("Mutation requires a destination.");
-      if (result.force && !result.output) usage12("Force requires an explicit output destination.");
-      if (result.output === result.input && result.output !== "-") usage12("Replacing input requires --in-place.");
-      if (result.output === "-" && result.json && !result.dryRun) usage12("Binary stdout cannot be combined with JSON.");
+      if (!result.token && result.slide === void 0 && !result.all) usage13("Transition mutation requires a selector or --all.");
+      if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+      if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
+      if (!result.dryRun && !result.inPlace && !result.output) usage13("Mutation requires a destination.");
+      if (result.force && !result.output) usage13("Force requires an explicit output destination.");
+      if (result.output === result.input && result.output !== "-") usage13("Replacing input requires --in-place.");
+      if (result.output === "-" && result.json && !result.dryRun) usage13("Binary stdout cannot be combined with JSON.");
     }
     return result;
   }
@@ -10892,18 +11161,18 @@ function parse(raw, maximum, output3) {
     if (formatting && [...seen].some(
       (flag) => ["--style-json", "--find", "--with", "--first", "--occurrence"].includes(flag)
     ))
-      usage12("Match options do not apply to runs.");
+      usage13("Match options do not apply to runs.");
     if ([...seen].some((flag) => !allowed.includes(flag)))
-      usage12("Option does not apply to this text operation.");
-    if (positionals.length !== 1 || !positionals[0]) usage12("Text operation requires one input.");
+      usage13("Option does not apply to this text operation.");
+    if (positionals.length !== 1 || !positionals[0]) usage13("Text operation requires one input.");
     if (result.scope === "presentation" || result.scope === "shared")
-      usage12("Text operation requires a text-bearing scope.");
+      usage13("Text operation requires a text-bearing scope.");
     if (result.token && ["--scope", "--slide", "--shape", "--paragraph", "--run"].some((flag) => seen.has(flag)))
-      usage12("Opaque and simple selectors cannot be combined.");
+      usage13("Opaque and simple selectors cannot be combined.");
     if (result.slide !== void 0 && (result.scope === "notes-master" || result.scope === "handout-master"))
-      usage12("Deck-level text master scopes do not accept slide selection.");
+      usage13("Deck-level text master scopes do not accept slide selection.");
     if (result.shape && result.slide === void 0)
-      usage12("Shape selection requires an owning slide.");
+      usage13("Shape selection requires an owning slide.");
     result.input = positionals[0];
     if (mutation2) {
       if (fields2)
@@ -10912,7 +11181,7 @@ function parse(raw, maximum, output3) {
           operation.slice(7)
         );
       if (fitting) {
-        if (!result.fitEdit?.metrics) usage12("Text fit requires --metrics JSON.");
+        if (!result.fitEdit?.metrics) usage13("Text fit requires --metrics JSON.");
         validateTextFitOptions(result.fitEdit);
       }
       if (frames)
@@ -10926,20 +11195,20 @@ function parse(raw, maximum, output3) {
       if (formatting && !result.all && result.token === void 0 && result.slide === void 0 && result.shape === void 0 && result.paragraphEdit?.paragraph === void 0 && result.runEdit?.paragraph === void 0 && result.runEdit?.run === void 0)
         throw new SelectionError8("missing-selection");
       if (!formatting && (result.find === void 0 || result.with === void 0))
-        usage12("Text replace requires find and with.");
+        usage13("Text replace requires find and with.");
       if (!formatting && [result.first === true, result.all === true, result.occurrence !== void 0].filter(
         Boolean
       ).length !== 1)
-        usage12("Text replace requires exactly one of first, all or occurrence.");
-      if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-      if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
+        usage13("Text replace requires exactly one of first, all or occurrence.");
+      if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+      if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
       if (!result.dryRun && !result.inPlace && !result.output)
-        usage12("Mutation requires a destination.");
-      if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+        usage13("Mutation requires a destination.");
+      if (result.force && !result.output) usage13("Force requires an explicit output destination.");
       if (result.output === result.input && result.output !== "-")
-        usage12("Replacing input requires --in-place.");
+        usage13("Replacing input requires --in-place.");
       if (result.output === "-" && result.json && !result.dryRun)
-        usage12("Binary stdout cannot be combined with JSON.");
+        usage13("Binary stdout cannot be combined with JSON.");
     }
     return result;
   }
@@ -10959,11 +11228,11 @@ function parse(raw, maximum, output3) {
       (key) => "--" + [...key].map((c) => c >= "A" && c <= "Z" ? "-" + c.toLowerCase() : c).join("")
     );
     if ([...seen].some((flag) => !flags.includes(flag)))
-      usage12("Option does not apply to this shape operation.");
-    if (positionals.length !== 1 || !positionals[0]) usage12("Shape operations require one input.");
+      usage13("Option does not apply to this shape operation.");
+    if (positionals.length !== 1 || !positionals[0]) usage13("Shape operations require one input.");
     result.input = positionals[0];
     if (result.token && (result.slide !== void 0 || result.part || result.shape || result.all))
-      usage12("Opaque and simple selectors cannot be combined.");
+      usage13("Opaque and simple selectors cannot be combined.");
     if (operation.startsWith("tables."))
       validateTableSelection(
         {
@@ -10981,28 +11250,28 @@ function parse(raw, maximum, output3) {
       if (operation.startsWith("tables.")) {
         if (operation === "tables.merge") {
           if (!result.tableFrom || !result.tableTo)
-            usage12("Merge requires from and to coordinates.");
+            usage13("Merge requires from and to coordinates.");
           result.tableStructure = {
             kind: "merge",
             from: tableCell(result.tableFrom),
             to: tableCell(result.tableTo)
           };
         } else if (operation === "tables.split") {
-          if (!result.cell) usage12("Split requires one merge origin cell.");
+          if (!result.cell) usage13("Split requires one merge origin cell.");
           result.tableStructure = { kind: "split", cell: tableCell(result.cell) };
         } else if (operation.startsWith("tables.rows.") || operation.startsWith("tables.columns.")) {
           const adding = operation.endsWith(".add");
           if (!result.tablePosition || !(adding ? ["expand", "reject"] : ["shrink", "reject"]).includes(
             result.tableSpanPolicy
           ))
-            usage12("A position and explicit span policy are required.");
+            usage13("A position and explicit span policy are required.");
           result.tableStructure = {
             kind: operation.slice(7).split(".").join("-"),
             position: result.tablePosition - 1,
             spanPolicy: result.tableSpanPolicy
           };
         } else {
-          if (!result.tableEdit) usage12("A table edit is required.");
+          if (!result.tableEdit) usage13("A table edit is required.");
           validateTableUpdate(
             {
               ...result.tableEdit,
@@ -11013,14 +11282,14 @@ function parse(raw, maximum, output3) {
         }
       } else if (operation === "shapes.remove") {
         if (result.connectorEdit?.detachPolicy !== void 0 && !["detach", "remove"].includes(result.connectorEdit.detachPolicy))
-          usage12("Invalid detach policy.");
+          usage13("Invalid detach policy.");
       } else if (connector) {
         if (operation !== "connectors.remove")
           validateConnectorOptions(result.connectorEdit ?? {}, operation === "connectors.add");
       } else if (operation === "shapes.effects.set" || operation === "shapes.drawing.set") {
         if (operation === "shapes.effects.set") {
           if (result.shadowEnabled === void 0 || result.shadowOpacity === void 0 || result.shadowBlur === void 0 || result.shadowColor === void 0)
-            usage12("Shadow requires explicit shadow, opacity, blur and color.");
+            usage13("Shadow requires explicit shadow, opacity, blur and color.");
           result.drawingEdit = {
             shadow: result.shadowEnabled ? {
               blur: result.shadowBlur,
@@ -11031,7 +11300,7 @@ function parse(raw, maximum, output3) {
         }
         if (result.drawingFill) {
           if (result.drawingEdit?.fill !== void 0)
-            usage12("Structured fill and simple fill flags cannot be mixed.");
+            usage13("Structured fill and simple fill flags cannot be mixed.");
           result.drawingEdit = {
             ...result.drawingEdit,
             fill: result.drawingFill
@@ -11039,9 +11308,9 @@ function parse(raw, maximum, output3) {
         }
         if (result.file !== void 0) {
           if (result.input === "-" && result.file === "-")
-            usage12("Document and image cannot both use stdin.");
+            usage13("Document and image cannot both use stdin.");
           if (result.drawingEdit?.fill?.kind !== "picture" || result.drawingEdit.fill.relationshipId !== void 0)
-            usage12("File requires picture fill without a relationship ID.");
+            usage13("File requires picture fill without a relationship ID.");
         }
         validateDrawingUpdate(
           result.file !== void 0 && result.drawingEdit?.fill?.kind === "picture" ? {
@@ -11051,7 +11320,7 @@ function parse(raw, maximum, output3) {
         );
       } else if (selectionMutation) {
         if (result.shapes && (result.slide !== void 0 || result.part || result.shape || result.token || result.all || result.allowEmpty))
-          usage12("Location arrays and simple or opaque selectors cannot be combined.");
+          usage13("Location arrays and simple or opaque selectors cannot be combined.");
         result.selectionEdit = {
           ...result.selectionEdit,
           action: operation.slice(7),
@@ -11066,9 +11335,9 @@ function parse(raw, maximum, output3) {
         };
         validateShapeSelectionOptions(result.selectionEdit);
       } else if (grouping) {
-        if (result.tolerance === void 0) usage12("Grouping requires explicit tolerance.");
+        if (result.tolerance === void 0) usage13("Grouping requires explicit tolerance.");
         if (operation === "shapes.group" && result.shapes === void 0)
-          usage12("Grouping requires shape locations.");
+          usage13("Grouping requires shape locations.");
         validateGroupOptions(
           {
             tolerance: result.tolerance,
@@ -11085,30 +11354,30 @@ function parse(raw, maximum, output3) {
         );
       } else if (operation.startsWith("shapes.paths.")) {
         if (result.path !== void 0 && (result.vertices !== void 0 || result.close !== void 0))
-          usage12("Path and vertices/close cannot be combined.");
+          usage13("Path and vertices/close cannot be combined.");
         if (result.vertices !== void 0) {
-          if (result.close === void 0) usage12("Vertices require explicit --close true|false.");
+          if (result.close === void 0) usage13("Vertices require explicit --close true|false.");
           if (!Array.isArray(result.vertices) || result.vertices.some((vertex) => Array.isArray(vertex)))
-            usage12("Vertices require objects with x and y coordinates.");
+            usage13("Vertices require objects with x and y coordinates.");
           result.path = pathFromVertices(result.vertices, result.close);
         }
-        if (result.path === void 0) usage12("Path mutation requires --path or --vertices.");
+        if (result.path === void 0) usage13("Path mutation requires --path or --vertices.");
         validateShapePath(result.path);
         if (operation.endsWith(".add"))
           validateShapeOptions({ ...result.shapeEdit, kind: "text-box" }, true);
       } else {
-        if (!result.shapeEdit) usage12("Shape mutation requires update fields.");
+        if (!result.shapeEdit) usage13("Shape mutation requires update fields.");
         validateShapeOptions(result.shapeEdit, operation === "shapes.add");
       }
-      if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-      if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
+      if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+      if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
       if (!result.dryRun && !result.inPlace && !result.output)
-        usage12("Mutation requires a destination.");
-      if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+        usage13("Mutation requires a destination.");
+      if (result.force && !result.output) usage13("Force requires an explicit output destination.");
       if (result.output === result.input && result.output !== "-")
-        usage12("Replacing input requires --in-place.");
+        usage13("Replacing input requires --in-place.");
       if (result.output === "-" && result.json && !result.dryRun)
-        usage12("Binary stdout cannot be combined with JSON.");
+        usage13("Binary stdout cannot be combined with JSON.");
     }
     return result;
   }
@@ -11123,53 +11392,53 @@ function parse(raw, maximum, output3) {
       (key) => key === "placeholders" ? "--placeholders-json" : "--" + [...key].map((char) => char >= "A" && char <= "Z" ? "-" + char.toLowerCase() : char).join("")
     );
     if ([...seen].some((flag) => !flags.includes(flag)))
-      usage12("Option does not apply to this shared-content operation.");
+      usage13("Option does not apply to this shared-content operation.");
     if (positionals.length !== 1 || !positionals[0])
-      usage12("Shared-content operations require one input.");
+      usage13("Shared-content operations require one input.");
     result.input = positionals[0];
     if (mutation2 && !applying && !background && result.scope === void 0)
-      usage12("Shared-content mutation requires explicit scope.");
+      usage13("Shared-content mutation requires explicit scope.");
     if (result.scope !== void 0 && !(theme ? ["shared"] : background ? ["slides", "layouts", "masters", "shared"] : applying ? ["slides"] : layout ? ["layouts", "shared"] : ["masters", "shared"]).includes(result.scope))
-      usage12("Scope does not match this shared-content operation.");
+      usage13("Scope does not match this shared-content operation.");
     if (applying && result.token && result.scope !== void 0)
-      usage12("Opaque selectors cannot be combined with scope.");
+      usage13("Opaque selectors cannot be combined with scope.");
     if (result.token && (result.part || result.slide !== void 0 || result.shape || result.all))
-      usage12("Opaque and simple selectors cannot be combined.");
+      usage13("Opaque and simple selectors cannot be combined.");
     if (result.part && result.slide !== void 0)
-      usage12("Part and slide selectors cannot be combined.");
+      usage13("Part and slide selectors cannot be combined.");
     const edit = result.masterEdit;
-    if (operation === "masters.add" && !edit?.name) usage12("Master creation requires a name.");
+    if (operation === "masters.add" && !edit?.name) usage13("Master creation requires a name.");
     if (operation === "masters.set" && edit?.name === void 0 && edit?.text === void 0)
-      usage12("Master set requires name or text.");
+      usage13("Master set requires name or text.");
     if (operation === "masters.set" && edit?.text !== void 0 && !result.shape && !result.token)
-      usage12("Master text edits require a selected text shape.");
+      usage13("Master text edits require a selected text shape.");
     if (operation === "layouts.add" && (!edit?.name || !edit.master))
-      usage12("Layout creation requires name and master.");
+      usage13("Layout creation requires name and master.");
     if (operation === "layouts.set" && !edit && !result.layoutEdit)
-      usage12("Layout set requires update fields.");
+      usage13("Layout set requires update fields.");
     if (operation === "layouts.set" && edit?.text !== void 0 && !result.shape && !result.token)
-      usage12("Layout text requires a selected shape.");
+      usage13("Layout text requires a selected shape.");
     if (layout && mutation2 && operation !== "layouts.add" && !result.part && !result.token && result.slide === void 0 && !result.all)
-      usage12("Layout mutation requires an explicit selector.");
+      usage13("Layout mutation requires an explicit selector.");
     if (applying && (!result.layoutEdit?.layout || !["type-index", "reject-unmatched"].includes(result.layoutEdit.placeholderPolicy)))
-      usage12("Layout application requires layout and placeholder policy.");
+      usage13("Layout application requires layout and placeholder policy.");
     if (operation === "shapes.add" && (edit?.kind !== "text-box" || [edit.x, edit.y, edit.width, edit.height].some((value) => value === void 0)))
-      usage12("Master shape creation requires text-box kind and explicit geometry.");
+      usage13("Master shape creation requires text-box kind and explicit geometry.");
     if (operation === "shapes.set" && (!edit || !result.shape && !result.token))
-      usage12("Shape edits require update fields and a selected shape.");
+      usage13("Shape edits require update fields and a selected shape.");
     if (operation === "themes.set" && (!result.themeEdit || result.themeEdit.colorSlot === void 0 !== (result.themeEdit.color === void 0) || result.themeEdit.fontSlot === void 0 !== (result.themeEdit.font === void 0)))
-      usage12("Theme set requires paired palette or font values, or a name.");
+      usage13("Theme set requires paired palette or font values, or a name.");
     if (result.themeEdit?.colorSlot !== void 0 && !themeColorSlots.includes(result.themeEdit.colorSlot))
-      usage12("Unknown theme color slot.");
+      usage13("Unknown theme color slot.");
     if (result.themeEdit?.fontSlot !== void 0 && !themeFontSlots.includes(result.themeEdit.fontSlot))
-      usage12("Unknown theme font slot.");
+      usage13("Unknown theme font slot.");
     if (background && result.scope === "shared" && !result.part && !result.token)
-      usage12("Shared background scope requires an exact part or selector.");
+      usage13("Shared background scope requires an exact part or selector.");
     if (operation === "backgrounds.set") {
       if (!result.part && !result.token && result.slide === void 0 && !result.all)
-        usage12("Background mutation requires a selector or all.");
+        usage13("Background mutation requires a selector or all.");
       if (result.file === "-" && result.input === "-")
-        usage12("Presentation and image cannot both read stdin.");
+        usage13("Presentation and image cannot both read stdin.");
       const edit2 = result.backgroundEdit;
       const required = {
         solid: ["color"],
@@ -11178,24 +11447,24 @@ function parse(raw, maximum, output3) {
         inherit: [],
         "style-reference": ["styleIndex", "styleColor"]
       };
-      if (!edit2?.kind || !Object.hasOwn(required, edit2.kind)) usage12("Background kind is required.");
+      if (!edit2?.kind || !Object.hasOwn(required, edit2.kind)) usage13("Background kind is required.");
       const fields2 = { ...edit2, ...result.file === void 0 ? {} : { file: result.file } };
       const keys = required[edit2.kind];
       if (keys.some((key) => !Object.hasOwn(fields2, key)) || Object.keys(fields2).some(
         (key) => key !== "kind" && !keys.includes(key) && !(edit2.kind === "gradient" && key === "angle")
       ))
-        usage12("Background payload does not match its kind.");
+        usage13("Background payload does not match its kind.");
     }
     if (mutation2) {
-      if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-      if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
+      if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+      if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
       if (!result.dryRun && !result.inPlace && !result.output)
-        usage12("Mutation requires a destination.");
-      if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+        usage13("Mutation requires a destination.");
+      if (result.force && !result.output) usage13("Force requires an explicit output destination.");
       if (result.output === result.input && result.output !== "-")
-        usage12("Replacing input requires --in-place.");
+        usage13("Replacing input requires --in-place.");
       if (result.output === "-" && result.json && !result.dryRun)
-        usage12("Binary stdout cannot be combined with JSON.");
+        usage13("Binary stdout cannot be combined with JSON.");
     }
     return result;
   }
@@ -11222,20 +11491,20 @@ function parse(raw, maximum, output3) {
       ] : []
     ];
     if ([...seen].some((flag) => !allowed.includes(flag)))
-      usage12("Option does not apply to this settings operation.");
-    if (positionals.length !== 1 || !positionals[0]) usage12("Settings require one input.");
+      usage13("Option does not apply to this settings operation.");
+    if (positionals.length !== 1 || !positionals[0]) usage13("Settings require one input.");
     result.input = positionals[0];
     if (mutation2) {
-      if (!result.settings) usage12("Settings set requires update fields.");
-      if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-      if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
+      if (!result.settings) usage13("Settings set requires update fields.");
+      if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+      if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
       if (!result.dryRun && !result.inPlace && !result.output)
-        usage12("Mutation requires a destination.");
-      if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+        usage13("Mutation requires a destination.");
+      if (result.force && !result.output) usage13("Force requires an explicit output destination.");
       if (result.output === result.input && result.output !== "-")
-        usage12("Replacing input requires --in-place.");
+        usage13("Replacing input requires --in-place.");
       if (result.output === "-" && result.json && !result.dryRun)
-        usage12("Binary stdout cannot be combined with JSON.");
+        usage13("Binary stdout cannot be combined with JSON.");
     }
     return result;
   }
@@ -11252,32 +11521,32 @@ function parse(raw, maximum, output3) {
       ...["add", "set"].includes(action) ? ["--name", "--slides", "--position"] : []
     ];
     if ([...seen].some((flag) => !allowed.includes(flag)))
-      usage12("Option does not apply to this membership operation.");
+      usage13("Option does not apply to this membership operation.");
     if (positionals.length !== 1 || !positionals[0])
-      usage12("Membership operations require one input.");
+      usage13("Membership operations require one input.");
     result.input = positionals[0];
     if (result.scope !== void 0 && result.scope !== "presentation")
-      usage12("Membership operations require presentation scope.");
+      usage13("Membership operations require presentation scope.");
     if (result.token && ["--slide", "--scope", "--all"].some((flag) => seen.has(flag)))
-      usage12("Opaque and simple selectors cannot be combined.");
+      usage13("Opaque and simple selectors cannot be combined.");
     if (action === "add" && (result.membership?.name === void 0 || !result.membership.slides))
-      usage12("Membership creation requires name and slides.");
-    if (action === "set" && !result.membership) usage12("Membership set requires update fields.");
+      usage13("Membership creation requires name and slides.");
+    if (action === "set" && !result.membership) usage13("Membership set requires update fields.");
     if (mutation2) {
-      if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-      if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
+      if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+      if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
       if (!result.dryRun && !result.inPlace && !result.output)
-        usage12("Mutation requires a destination.");
-      if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+        usage13("Mutation requires a destination.");
+      if (result.force && !result.output) usage13("Force requires an explicit output destination.");
       if (result.output === result.input && result.output !== "-")
-        usage12("Replacing input requires --in-place.");
+        usage13("Replacing input requires --in-place.");
       if (result.output === "-" && result.json && !result.dryRun)
-        usage12("Binary stdout cannot be combined with JSON.");
+        usage13("Binary stdout cannot be combined with JSON.");
     }
     return result;
   }
   if (result.allowEmpty && !slideMutation)
-    usage12("Allow-empty requires a supported slide mutation.");
+    usage13("Allow-empty requires a supported slide mutation.");
   if (operation === "slides.merge" || operation === "slides.split") {
     const allowed = [
       "--json",
@@ -11294,36 +11563,36 @@ function parse(raw, maximum, output3) {
       ] : ["--slides", "--output-dir", "--allow-partial-output"]
     ];
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to this assembly operation.");
+      usage13("Option does not apply to this assembly operation.");
     if (positionals.length !== 1 || !positionals[0])
-      usage12("Assembly requires one destination or source input.");
+      usage13("Assembly requires one destination or source input.");
     result.input = positionals[0];
     if (operation === "slides.split") {
-      if (!result.splitSlides) usage12("Split requires --slides.");
-      if (!result.outputDir && !result.dryRun) usage12("Split requires --output-dir.");
-      if (result.outputDir === "-") usage12("Output directories cannot be stdout.");
-      if (result.force && !result.outputDir) usage12("Force requires an output directory.");
+      if (!result.splitSlides) usage13("Split requires --slides.");
+      if (!result.outputDir && !result.dryRun) usage13("Split requires --output-dir.");
+      if (result.outputDir === "-") usage13("Output directories cannot be stdout.");
+      if (result.force && !result.outputDir) usage13("Force requires an output directory.");
     } else {
       if (!result.sources || !result.importing?.themePolicy)
-        usage12("Merge requires sources and an explicit theme policy.");
+        usage13("Merge requires sources and an explicit theme policy.");
       if ([result.input, ...result.sources].filter((path) => path === "-").length > 1)
-        usage12("Only one input may consume stdin.");
-      if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-      if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
+        usage13("Only one input may consume stdin.");
+      if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+      if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
       if (!result.dryRun && !result.inPlace && !result.output)
-        usage12("Merge requires a destination.");
-      if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+        usage13("Merge requires a destination.");
+      if (result.force && !result.output) usage13("Force requires an explicit output destination.");
       if (result.output === result.input && result.output !== "-")
-        usage12("Replacing input requires --in-place.");
+        usage13("Replacing input requires --in-place.");
       if (result.sources.includes(result.inPlace ? result.input : result.output ?? "") && (result.inPlace || result.output !== "-"))
-        usage12("Merge output cannot replace a source.");
+        usage13("Merge output cannot replace a source.");
       if (result.output === "-" && result.json && !result.dryRun)
-        usage12("Binary stdout cannot be combined with JSON.");
+        usage13("Binary stdout cannot be combined with JSON.");
     }
     return result;
   }
   if (operation === "create") {
-    if (positionals.length) usage12("Creation takes no input positional arguments.");
+    if (positionals.length) usage13("Creation takes no input positional arguments.");
     const allowed = [
       "--width",
       "--height",
@@ -11341,11 +11610,11 @@ function parse(raw, maximum, output3) {
       "--dry-run"
     ];
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to creation.");
-    if (!result.output && !result.dryRun) usage12("Creation requires an output destination.");
-    if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+      usage13("Option does not apply to creation.");
+    if (!result.output && !result.dryRun) usage13("Creation requires an output destination.");
+    if (result.force && !result.output) usage13("Force requires an explicit output destination.");
     if (result.output === "-" && result.json && !result.dryRun)
-      usage12("Binary stdout cannot be combined with JSON.");
+      usage13("Binary stdout cannot be combined with JSON.");
     return result;
   }
   if (operation === "slides.import") {
@@ -11363,14 +11632,14 @@ function parse(raw, maximum, output3) {
       "--dry-run"
     ];
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to slide import.");
+      usage13("Option does not apply to slide import.");
     if (!result.source || !result.importing?.sourceSlides)
-      usage12("Import requires source and source slides.");
-    if (positionals[0] === "-" && result.source === "-") usage12("Only one input may consume stdin.");
+      usage13("Import requires source and source slides.");
+    if (positionals[0] === "-" && result.source === "-") usage13("Only one input may consume stdin.");
     if (result.output === result.source && result.output !== "-")
-      usage12("Import output cannot replace its source.");
+      usage13("Import output cannot replace its source.");
     if (result.inPlace && positionals[0] === result.source)
-      usage12("Import in-place destination must differ from source.");
+      usage13("Import in-place destination must differ from source.");
   } else if (operation === "slides.add") {
     const allowed = [
       "--layout",
@@ -11389,11 +11658,11 @@ function parse(raw, maximum, output3) {
       "--dry-run"
     ];
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to slide addition.");
+      usage13("Option does not apply to slide addition.");
     if (positionals.length !== 1 || !positionals[0])
-      usage12("Slide addition requires exactly one input.");
+      usage13("Slide addition requires exactly one input.");
     result.input = positionals[0];
-    if (!result.addition?.layout) usage12("Slide addition requires --layout.");
+    if (!result.addition?.layout) usage13("Slide addition requires --layout.");
   } else if (slideMutation) {
     const allowed = [
       "--selection-json",
@@ -11413,29 +11682,29 @@ function parse(raw, maximum, output3) {
       ...operation === "slides.set" ? ["--name", "--hidden"] : []
     ];
     if ([...seen].some((option) => !allowed.includes(option)))
-      usage12("Option does not apply to this slide mutation.");
+      usage13("Option does not apply to this slide mutation.");
     if (seen.has("--selection-json") && ["--slide", "--select", "--scope", "--all"].some((flag) => seen.has(flag)))
-      usage12("Structured and simple selectors cannot be combined.");
+      usage13("Structured and simple selectors cannot be combined.");
     if (!seen.has("--selection-json") && result.slide === void 0 && !result.token && !result.all)
-      usage12("Slide mutation requires a selector or --all.");
+      usage13("Slide mutation requires a selector or --all.");
     if (operation !== "slides.remove" && (!result.mutation || (operation === "slides.move" || operation === "slides.duplicate") && result.mutation.position === void 0))
-      usage12("Slide mutation requires update fields; move/duplicate require --position.");
+      usage13("Slide mutation requires update fields; move/duplicate require --position.");
     if (result.scope !== void 0 && result.scope !== "slides")
-      usage12("Slide mutations require slides scope.");
+      usage13("Slide mutations require slides scope.");
   } else if (operation === "validate") {
     if ([...seen].some((flag) => flag !== "--json" && flag !== "--limit"))
-      usage12("Option does not apply to validation.");
+      usage13("Option does not apply to validation.");
     if (result.limits && ["maxOutputs", "maxOutputBytes"].some((name) => Object.hasOwn(result.limits, name)))
-      usage12("Output limits do not apply to validation.");
-    if (positionals.length !== 1 || !positionals[0]) usage12("Validation requires exactly one nonempty input.");
+      usage13("Output limits do not apply to validation.");
+    if (positionals.length !== 1 || !positionals[0]) usage13("Validation requires exactly one nonempty input.");
     result.input = positionals[0];
     return result;
   } else if (operation !== "inspect" && !xml) {
     if ([...seen].some((option) => option !== "--json" && !(operation === "capabilities" && option === "--limit")))
-      usage12("Selection options require inspect.");
+      usage13("Selection options require inspect.");
     if (operation === "capabilities") {
-      if (result.limits && Object.hasOwn(result.limits, "maxOutputs")) usage12("Output-count limits do not apply to capabilities.");
-      if (positionals.length > 1 || positionals[0] === "") usage12("Capabilities accepts at most one nonempty input.");
+      if (result.limits && Object.hasOwn(result.limits, "maxOutputs")) usage13("Output-count limits do not apply to capabilities.");
+      if (positionals.length > 1 || positionals[0] === "") usage13("Capabilities accepts at most one nonempty input.");
       if (positionals[0] !== void 0) result.input = positionals[0];
       return result;
     }
@@ -11496,43 +11765,43 @@ function parse(raw, maximum, output3) {
       result.schemaPath = positionals.join(".");
       return result;
     }
-    if (positionals.length) usage12("Unexpected input.");
+    if (positionals.length) usage13("Unexpected input.");
     return result;
   }
-  if (positionals.length !== 1) usage12("Inspection requires exactly one input.");
+  if (positionals.length !== 1) usage13("Inspection requires exactly one input.");
   result.input = positionals[0];
-  if (result.input.length === 0) usage12("Input path must not be empty.");
+  if (result.input.length === 0) usage13("Input path must not be empty.");
   if (result.token && ["--slide", "--shape", "--part", "--scope", "--all"].some((option) => seen.has(option)))
-    usage12("Opaque and simple selectors cannot be combined.");
+    usage13("Opaque and simple selectors cannot be combined.");
   if (result.part && result.slide !== void 0)
-    usage12("Part and slide selectors cannot be combined.");
+    usage13("Part and slide selectors cannot be combined.");
   if (result.shape && result.slide === void 0 && !result.part)
-    usage12("Shape selection requires an owning slide or part.");
+    usage13("Shape selection requires an owning slide or part.");
   if (result.slide !== void 0 && result.scope !== void 0 && result.scope !== "slides")
-    usage12("Slide positions require slides scope.");
+    usage13("Slide positions require slides scope.");
   const mutationOptions = ["--file", "--output", "--in-place", "--force", "--dry-run"];
   if (operation !== "xml.set" && operation !== "slides.add" && operation !== "slides.import" && !slideMutation && mutationOptions.some((option) => seen.has(option)))
-    usage12("Publication options require xml set.");
+    usage13("Publication options require xml set.");
   if (!xml && operation !== "inspect" && operation !== "slides.add" && operation !== "slides.import" && !slideMutation && result.limits)
-    usage12("Limit overrides require inspect, XML operations or slides add.");
-  if (operation !== "xml.get" && result.pretty) usage12("Pretty output requires xml get.");
+    usage13("Limit overrides require inspect, XML operations or slides add.");
+  if (operation !== "xml.get" && result.pretty) usage13("Pretty output requires xml get.");
   if (xml) {
     if (result.slide !== void 0 || result.shape || result.all)
-      usage12("XML operations require one part selector.");
-    if (!result.part && !result.token) usage12("XML operations require a part or opaque selector.");
+      usage13("XML operations require one part selector.");
+    if (!result.part && !result.token) usage13("XML operations require a part or opaque selector.");
   }
   if (operation === "xml.set" || operation === "slides.add" || operation === "slides.import" || slideMutation) {
-    if (operation === "xml.set" && !result.file) usage12("XML replacement requires --file.");
-    if (result.input === "-" && result.file === "-") usage12("Only one input may consume stdin.");
-    if (result.inPlace && result.input === "-") usage12("Stdin cannot be edited in place.");
-    if (result.inPlace && result.output) usage12("Output and in-place cannot be combined.");
+    if (operation === "xml.set" && !result.file) usage13("XML replacement requires --file.");
+    if (result.input === "-" && result.file === "-") usage13("Only one input may consume stdin.");
+    if (result.inPlace && result.input === "-") usage13("Stdin cannot be edited in place.");
+    if (result.inPlace && result.output) usage13("Output and in-place cannot be combined.");
     if (!result.dryRun && !result.inPlace && !result.output)
-      usage12("Mutation requires a destination.");
-    if (result.force && !result.output) usage12("Force requires an explicit output destination.");
+      usage13("Mutation requires a destination.");
+    if (result.force && !result.output) usage13("Force requires an explicit output destination.");
     if (result.output === result.input && result.output !== "-")
-      usage12("Replacing input requires --in-place.");
+      usage13("Replacing input requires --in-place.");
     if (result.output === "-" && result.json && !result.dryRun)
-      usage12("Binary stdout cannot be combined with JSON.");
+      usage13("Binary stdout cannot be combined with JSON.");
   }
   return result;
 }
@@ -11601,7 +11870,7 @@ async function transferLocations(bytes, budget) {
     (edge) => relationshipNamespaces.some((namespace) => edge.type === `${namespace}/officeDocument`)
   );
   const root = roots.length === 1 ? roots[0].targetPart : void 0;
-  if (!root) throw new OfficeError16("invalid-opc", "Presentation part is missing.", "index");
+  if (!root) throw new OfficeError19("invalid-opc", "Presentation part is missing.", "index");
   const relationshipNamespace = roots[0].type.slice(0, -"/officeDocument".length);
   const xml = budget.xml(reader.get(root));
   const fingerprint = Array.from(sha2564(bytes), (byte) => byte.toString(16).padStart(2, "0")).join(
@@ -11620,7 +11889,7 @@ async function transferLocations(bytes, budget) {
       (edge) => edge.id === reference && edge.type === `${relationshipNamespace}/slide`
     )?.targetPart;
     if (!id || !owner || !reader.has(owner))
-      throw new OfficeError16("invalid-opc", "Referenced slide is missing.", "index");
+      throw new OfficeError19("invalid-opc", "Referenced slide is missing.", "index");
     return {
       fingerprint,
       scope: "slides",
@@ -11688,6 +11957,7 @@ async function executeRequest(request, options2, owned) {
   if (request.args?.[0] instanceof Uint8Array && request.args[0].length === 4 && request.args[0].every((byte, index) => byte === [100, 105, 102, 102][index]))
     return executeDiffCommand(request, options2);
   const output3 = { json: false, operation: "help" };
+  let retainedExtraction;
   let result;
   let exitCode = 0;
   let stagedOutput;
@@ -11702,7 +11972,7 @@ async function executeRequest(request, options2, owned) {
   let allowPartialOutput = false;
   try {
     request.signal.throwIfAborted();
-    if (!Array.isArray(request.args)) usage12("Arguments must be byte arrays.");
+    if (!Array.isArray(request.args)) usage13("Arguments must be byte arrays.");
     const args = parse(request.args, options2.maxArgumentBytes, output3);
     if (args.limits) {
       const validation = options2.context.validationLimits;
@@ -11728,7 +11998,70 @@ async function executeRequest(request, options2, owned) {
     output3.json = args.json;
     output3.operation = args.operation;
     const operation2 = args.operation;
-    if (args.operation === "slides.set" && request.streaming) {
+    if (args.operation === "pack" && request.streaming) {
+      if (args.creation?.author !== void 0 || args.creation?.timestamp !== void 0) throw new OfficeError19("unsupported-edit", "Pack metadata overrides are unavailable; source properties are preserved.", "validate-intent");
+      const streaming = request.streaming, context = { ...options2.context, signal: request.signal, workingStorage: streaming.workingStorage };
+      const input = await streaming.openInput(args.manifest, Math.min(context.limits.maxBytes, context.xmlLimits.maxBytes));
+      const manifest = await openRetainedPackManifest(input.stream(), context, { manifest: args.manifest, ...args.output === void 0 ? {} : { output: args.output } });
+      owned.push(manifest);
+      let total = 0;
+      const packed = await stageRetainedPackage(manifest.members(), async function* (part) {
+        const source3 = await streaming.openInput(await manifest.path(part), Math.min(context.limits.maxBytes, context.archiveLimits.maxEntryBytes, context.archiveLimits.maxTotalBytes - total));
+        total += source3.size;
+        yield* source3.stream();
+      }, context, args.creation?.kind ? { kind: args.creation.kind } : {});
+      owned.push(packed);
+      if (packed.size > options2.maxOutputBytes) throw new OfficeError19("resource-limit", "Packed output exceeds byte limit.", "validate-intent");
+      const dryRun = args.dryRun ?? false;
+      result = {
+        version: 1,
+        operation: operation2,
+        ok: true,
+        warnings: [],
+        errors: [],
+        locations: [],
+        affected: packed.count,
+        data: { effects: ["packed"], outputs: dryRun ? [] : [{ path: args.output, sha256: packed.fingerprint, bytes: packed.size }], fingerprint: dryRun ? null : packed.fingerprint, dryRun }
+      };
+      human = `${dryRun ? "Validated" : "Packed"} ${packed.count} package part(s)
+`;
+      if (args.output && args.output !== "-") {
+        if (!request.publishOutput) throw Object.assign(new Error("Output publication unavailable."), { code: "publication-unsupported" });
+        publication = { outputPath: args.output, protectedInputPaths: manifest.paths(), bytes: packed.bytes(), originalBytes: input, inPlace: false, force: args.force ?? false, dryRun };
+      } else if (args.output === "-" && !dryRun) stagedOutput = { close: packed.close, async write(sink) {
+        for await (const bytes of packed.bytes()) await sink.write(bytes);
+      } };
+    } else if (args.operation === "extract" && request.streaming && (!request.publishOutputs || request.publishOutputStreams) && (!request.preflightOutput || request.preflightOutputStream)) {
+      retainedExtraction = await prepareRetainedExtraction(args, request, options2);
+      owned.push(retainedExtraction);
+      result = success(operation2, null);
+    } else if (args.operation === "xml.set" && request.streaming) {
+      if (args.token) decodeSelectionToken2(args.token);
+      const streaming = request.streaming, context = { ...options2.context, signal: request.signal, workingStorage: streaming.workingStorage };
+      if (!context.validationLimits) throw new OfficeError19("invalid-value", "XML operations require explicit validation limits.", "usage");
+      const input = await streaming.openInput(args.input, Math.min(context.limits.maxBytes, context.archiveLimits.maxArchiveBytes));
+      const maxReplacementBytes = Math.min(context.validationLimits.maxBytes, context.archiveLimits.maxEntryBytes), file = args.file;
+      async function* replacement() {
+        const source3 = await streaming.openInput(file, maxReplacementBytes);
+        yield* source3.stream();
+      }
+      const destination = args.inPlace ? args.input : args.output, dryRun = args.dryRun ?? false;
+      const staged = await stageRetainedXmlReplacement(input, replacement(), {
+        ...args.token === void 0 ? {} : { token: args.token },
+        ...args.slide === void 0 ? {} : { slide: args.slide },
+        ...args.shape === void 0 ? {} : { shape: args.shape },
+        ...args.part === void 0 ? {} : { part: args.part },
+        ...args.scope === void 0 ? {} : { scope: args.scope },
+        ...args.all === void 0 ? {} : { all: args.all }
+      }, context, { json: args.json, dryRun, ...destination === void 0 ? {} : { destination }, maxOutputBytes: options2.maxOutputBytes });
+      owned.push(staged);
+      stagedOutput = staged.output;
+      if (destination && destination !== "-") {
+        if (!request.publishOutput) throw Object.assign(new Error("Output publication capability is unavailable."), { code: "publication-unsupported" });
+        publication = { inputPath: args.input, outputPath: destination, bytes: staged.bytes(), originalBytes: input, inPlace: args.inPlace ?? false, force: args.force ?? false, dryRun };
+      }
+      result = success(operation2, null);
+    } else if (args.operation === "slides.set" && request.streaming) {
       if (args.token) decodeSelectionToken2(args.token);
       const input = await request.streaming.openInput(args.input, Math.min(options2.context.limits.maxBytes, options2.context.archiveLimits.maxArchiveBytes));
       const destination = args.inPlace ? args.input : args.output;
@@ -11745,7 +12078,7 @@ async function executeRequest(request, options2, owned) {
         publication = { inputPath: args.input, outputPath: destination, bytes: staged.bytes(), originalBytes: input, inPlace: args.inPlace ?? false, force: args.force ?? false, dryRun };
       }
       result = success(operation2, null);
-    } else if ((args.operation === "inspect" || args.operation === "text.get" || args.operation === "fields.list" || args.operation === "fields.get" || args.operation === "xml.get") && request.streaming) {
+    } else if ((args.operation === "inspect" || args.operation === "text.get" || args.operation === "fields.list" || args.operation === "fields.get" || args.operation === "text.frames.list" || args.operation === "text.frames.get" || args.operation === "xml.get") && request.streaming) {
       if (args.token) decodeSelectionToken2(args.token);
       const input = await request.streaming.openInput(args.input, Math.min(options2.context.limits.maxBytes, options2.context.archiveLimits.maxArchiveBytes));
       const hash = sha2564.create();
@@ -11780,7 +12113,7 @@ async function executeRequest(request, options2, owned) {
         }, context, { json: args.json, maxOutputBytes: options2.maxOutputBytes });
       } catch (error) {
         failed = true;
-        if (error instanceof OfficeError16 && error.code === "resource-limit" && error.phase === "publish") return outputLimitFailure(operation2, args.json);
+        if (error instanceof OfficeError19 && error.code === "resource-limit" && error.phase === "publish") return outputLimitFailure(operation2, args.json);
         throw error;
       } finally {
         try {
@@ -11805,7 +12138,7 @@ async function executeRequest(request, options2, owned) {
         let failed = false;
         try {
           validation = await openRetainedPresentationValidation(archive, context, limits);
-          if (!validation.valid) throw new OfficeError16("invalid-opc", "Presentation semantic validation failed.", "index");
+          if (!validation.valid) throw new OfficeError19("invalid-opc", "Presentation semantic validation failed.", "index");
           result = success(operation2, { valid: true, schema: validation.schema, rules: validation.rules, issues: [] });
         } catch (error) {
           failed = true;
@@ -11820,15 +12153,15 @@ async function executeRequest(request, options2, owned) {
         const bytes = await request.readInput(args.input, maxBytes);
         const reader = await readPackage3(bytes, { ...options2.context, signal: request.signal });
         const validation = validatePresentation(reader, limits);
-        if (!validation.valid) throw new OfficeError16("invalid-opc", "Presentation semantic validation failed.", "index");
+        if (!validation.valid) throw new OfficeError19("invalid-opc", "Presentation semantic validation failed.", "index");
         result = success(operation2, validation);
       }
       human = "Presentation is semantically valid; XML schema validation not checked.\n";
     } else if (args.operation === "help") {
-      const usage13 = args.schemaPath === "validate" ? "Usage: pptx validate INPUT [--json] [--limit NAME=VALUE]\nBounded semantic validation; XML schema validation is not checked.\n" : args.schemaPath && Object.hasOwn(packageToolsSchemas, args.schemaPath) ? packageToolsUsage : args.schemaPath === "objects.add" ? objectsAddUsage : args.schemaPath && Object.hasOwn(opaqueSchemas, args.schemaPath) ? opaqueUsage : args.schemaPath?.startsWith("equations.") ? equationsUsage : args.schemaPath === "text.fit" ? "Usage: pptx text fit INPUT --metrics JSON [selection] [output]\nSelection: --slide N --shape NAME | --select TOKEN | --all\nOutput: --output PATH | --in-place | --dry-run\n--font-family NAME --min-size N --max-size N\n--bold true|false --italic true|false --wrap true|false\n--margin-left LENGTH --margin-right LENGTH\n--margin-top LENGTH --margin-bottom LENGTH --line-spacing MULTIPLIER\n--json --allow-empty --force --scope SCOPE --limit NAME=VALUE\nDefaults: Calibri, 1..18pt, regular, wrap, line spacing 1.\nSupplied scalar metrics; horizontal single-column shapes with local extents.\nNo host font discovery. Platform rendering may differ.\n" : args.schemaPath?.startsWith("text.frames.") ? frameHelp : args.schemaPath?.startsWith("text.paragraphs.") ? paragraphHelp : args.schemaPath?.startsWith("text.runs.") ? runHelp : help;
+      const usage14 = args.schemaPath === "validate" ? "Usage: pptx validate INPUT [--json] [--limit NAME=VALUE]\nBounded semantic validation; XML schema validation is not checked.\n" : args.schemaPath && Object.hasOwn(packageToolsSchemas, args.schemaPath) ? packageToolsUsage : args.schemaPath === "objects.add" ? objectsAddUsage : args.schemaPath && Object.hasOwn(opaqueSchemas, args.schemaPath) ? opaqueUsage : args.schemaPath?.startsWith("equations.") ? equationsUsage : args.schemaPath === "text.fit" ? "Usage: pptx text fit INPUT --metrics JSON [selection] [output]\nSelection: --slide N --shape NAME | --select TOKEN | --all\nOutput: --output PATH | --in-place | --dry-run\n--font-family NAME --min-size N --max-size N\n--bold true|false --italic true|false --wrap true|false\n--margin-left LENGTH --margin-right LENGTH\n--margin-top LENGTH --margin-bottom LENGTH --line-spacing MULTIPLIER\n--json --allow-empty --force --scope SCOPE --limit NAME=VALUE\nDefaults: Calibri, 1..18pt, regular, wrap, line spacing 1.\nSupplied scalar metrics; horizontal single-column shapes with local extents.\nNo host font discovery. Platform rendering may differ.\n" : args.schemaPath?.startsWith("text.frames.") ? frameHelp : args.schemaPath?.startsWith("text.paragraphs.") ? paragraphHelp : args.schemaPath?.startsWith("text.runs.") ? runHelp : help;
       let resolvedUsage = args.schemaPath === "shapes.remove" ? "Usage: pptx shapes remove INPUT --slide N --shape NAME [--detach-policy detach|remove] [output]\nSelection also accepts --select TOKEN or --all. Referenced targets require explicit policy.\nDetach keeps connectors with free coordinates; remove deletes affected connectors. Timing references reject deletion.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE.\n" : args.schemaPath?.startsWith("tables.") ? "Usage: pptx tables list|get|add|set|merge|split INPUT [--slide N --table N --cell row,column] [properties] [output]\nMerge: --from row,column --to row,column; split: --cell row,column (merge origin).\nRows/columns: tables rows|columns add|remove INPUT --position N --span-policy expand|shrink|reject\nInsertion accepts expand/reject; deletion accepts shrink/reject. Partial intersecting merges fail.\nAdd: --rows N --columns N --left LENGTH --top LENGTH --width LENGTH --height LENGTH [--data JSON]\nPlaceholder add: --slide N --placeholder IDX --rows N --columns N. Inherits position/width; rows set height.\nSet: --text TEXT (one cell), --data JSON, --row-height LENGTH, --column-width LENGTH, --style ID\nFormatting: --fill RGB --border-color RGB --border-width LENGTH --margin-left|right|top|bottom LENGTH\nStyle flags: --first-row|last-row|first-col|last-col|horz-band|vert-band true|false; --vertical-anchor top|middle|bottom\nOutput: --output PATH or --in-place; --dry-run validates without publication. Selectors are one-based.\n" : args.schemaPath?.startsWith("connectors.") ? "Usage: pptx connectors list|get|add|set|remove INPUT [selection] [properties] [output]\nSelection: --slide N [--shape NAME | --all] | --select TOKEN.\nAdd requires --kind STRAIGHT|ELBOW|CURVE --begin-x LENGTH --begin-y LENGTH --end-x LENGTH --end-y LENGTH.\nAttach: --begin-target LOCATION_JSON --end-target LOCATION_JSON --site N (zero-based).\nSet target null to detach one endpoint; --detach-policy detach detaches both, remove removes the connector.\nLengths use explicit emu/in/cm/mm/pt in parent coordinates. --name TEXT sets the name.\nLine: --line-color RGB|solid|null --line-width LENGTH|null. Solid preserves existing solid color.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE.\nTargets: rect/ellipse/roundRect sites 0..3. Grouped connectors require same-parent targets.\nNonzero-rotated coordinate edits reject; arbitrary routing/guide geometry is preserve-only.\n" : ["shapes.move", "shapes.align", "shapes.distribute", "shapes.duplicate"].includes(
         args.schemaPath ?? ""
-      ) ? "Usage: pptx shapes move|align|distribute|duplicate INPUT [selection] --coordinate-system slide|group [output]\nSelection: --shapes JSON Location array, or --slide N [--shape NAME | --all], or --select TOKEN.\nMove: --order front|back|forward|backward OR --position N (one-based).\nAlign: --alignment left|center|right|top|middle|bottom. Distribute: --axis horizontal|vertical.\nDuplicate: --offset-x LENGTH --offset-y LENGTH (explicit units, signed offsets).\nHidden siblings participate; locked selections fail. Mixed slides or parent groups fail.\nOutput: --output PATH | --in-place | --dry-run; --force, --json, --limit NAME=VALUE.\n" : args.schemaPath?.startsWith("shapes.paths.") ? "Usage: pptx shapes paths list|get|add|set INPUT [selection] [path] [output]\nRead: list|get INPUT [selection]. Add/set require --path JSON or --vertices JSON.\nPath: {unit:emu,width,height,commands:[move|line|quadratic|cubic|close]}\nCoordinates: integer local EMUs, -2147483647..2147483647; viewport 1..2147483647.\nAt most 4096 commands; explicit closure; command order preserved without winding evaluation.\nAlternatively --vertices JSON --close true|false uses {x,y} local EMU vertices and a derived viewport.\nAdd placement: --left LENGTH --top LENGTH --width LENGTH --height LENGTH.\nAdd accepts shape name, text, paint and metadata properties. Lengths require emu/in/cm/mm/pt.\nSelection: --slide N [--shape NAME] | --part URI --scope SCOPE | --select TOKEN.\nSet: selects one shape unless --all; --allow-empty accepts zero matches.\nScopes: slides (default), layouts, masters; shared requires --part URI.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE.\nUnsupported formulas, arcs and arbitrary existing geometry are preserve-only.\n" : ["shapes.group", "shapes.ungroup"].includes(args.schemaPath ?? "") ? "Usage: pptx shapes group|ungroup INPUT --tolerance LENGTH [selection] [output]\nGroup: --shapes JSON array of at least two inspected Location objects.\nShapes must be distinct contiguous siblings; original IDs and z-order are retained.\nUngroup: --slide N --shape NAME | --select TOKEN; selects one group.\nSelection: --part URI --scope SCOPE. Exact cardinality; --all/--allow-empty are unsupported.\nTolerance is explicit nonnegative EMU precision using emu/in/cm/mm/pt lengths.\nIdentity groups preserve child XML; transformed ungrouping supports nested groups and rectangles\nwithout text, styles or strokes.\nTransformed ungrouping supports quarter-turn rotation chains only.\nWorld geometry must remain within tolerance; unsupported geometry and references fail.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE.\n" : args.schemaPath?.startsWith("shapes.drawing.") || args.schemaPath === "shapes.effects.set" ? "Usage: pptx shapes drawing get|set INPUT [selection] [paint] [output]\n       pptx shapes effects set INPUT [selection] --shadow true|false\n         --opacity RATIO --shadow-blur LENGTH --shadow-color COLOR [output]\nPaint: --fill-kind inherit|none|solid|gradient|pattern|picture\n  --color COLOR; gradient: --stops JSON --angle DEGREES\n  pattern: --pattern PRESET [--foreground COLOR --background COLOR]\n  picture: --file PATH --mode stretch|tile\nAdvanced paint: --fill JSON --line JSON --shadow-inherit true|false\nCOLOR is six-digit RGB or JSON with rgb/theme, optional brightness and opacity.\nSelection: --slide N --shape NAME | --part URI --scope SCOPE | --select TOKEN\nScopes: slides (default), layouts, masters; shared requires a part.\nSet selects one shape unless --all; --allow-empty accepts zero matches.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE.\nLengths require emu/in/cm/mm/pt. Simple shadows have zero offset.\nComplex effects and 3D remain intact; editing unsupported effects fails.\n" : args.schemaPath?.startsWith("shapes.") ? "Usage: pptx shapes list|get|add|set INPUT [selection] [properties] [output]\nSelection: --slide N --shape NAME | --select TOKEN; --part URI --scope SCOPE\nScopes: slides (default), layouts, masters; shared requires a part.\nAdd: --kind text-box|PRESET --left LENGTH --top LENGTH --width LENGTH --height LENGTH\nProperties: --name TEXT --text TEXT --title TEXT --description TEXT --alt-text TEXT\n  --locked true|false|null --rotation DEGREES --fill RGB --line-color RGB --line-width LENGTH\n  --flip-horizontal true|false --flip-vertical true|false\n  --adjustments JSON_ARRAY (normalized preset values in guide order)\n  Geometry uses parent coordinates; inspection corners use slide EMUs.\nLengths require emu/in/cm/mm/pt. Presets use enum names or numeric values from schema.\nNull clears direct title/description/lock; null fill/line color disables fill/line.\nOmitted values stay unchanged.\nNull line width restores inherited width.\nFill/line color solid selects solid fill; existing solid colors are retained.\nShape IDs are read-only. Unsupported geometry and advanced formatting are preserve-only.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE\nSet: --all edits every match; --allow-empty accepts zero matches.\n" : args.schemaPath?.startsWith("fields.") ? "Usage: pptx fields list|get|set|add|remove INPUT [options]\nSelection: --slide N --shape NAME | --select TOKEN\n           --scope SCOPE --json --limit NAME=VALUE\nMutation:  --all --allow-empty\nOutput:    --output PATH | --in-place | --dry-run; --force\nSet/add:   --kind slide-number|date|footer|header\n           --update preserve|explicit --text TEXT --timestamp UTC\nAdd requires --kind and one text body; appends to its last paragraph.\nPreserve is default: retains the cache (empty on add), rejects text/time.\nExplicit requires text; date fields also require a caller UTC timestamp.\nNo field evaluation, automatic numbering or inherited-content flattening.\nList/get are read-only; get requires one field. Remove accepts no policy.\n" : usage13;
+      ) ? "Usage: pptx shapes move|align|distribute|duplicate INPUT [selection] --coordinate-system slide|group [output]\nSelection: --shapes JSON Location array, or --slide N [--shape NAME | --all], or --select TOKEN.\nMove: --order front|back|forward|backward OR --position N (one-based).\nAlign: --alignment left|center|right|top|middle|bottom. Distribute: --axis horizontal|vertical.\nDuplicate: --offset-x LENGTH --offset-y LENGTH (explicit units, signed offsets).\nHidden siblings participate; locked selections fail. Mixed slides or parent groups fail.\nOutput: --output PATH | --in-place | --dry-run; --force, --json, --limit NAME=VALUE.\n" : args.schemaPath?.startsWith("shapes.paths.") ? "Usage: pptx shapes paths list|get|add|set INPUT [selection] [path] [output]\nRead: list|get INPUT [selection]. Add/set require --path JSON or --vertices JSON.\nPath: {unit:emu,width,height,commands:[move|line|quadratic|cubic|close]}\nCoordinates: integer local EMUs, -2147483647..2147483647; viewport 1..2147483647.\nAt most 4096 commands; explicit closure; command order preserved without winding evaluation.\nAlternatively --vertices JSON --close true|false uses {x,y} local EMU vertices and a derived viewport.\nAdd placement: --left LENGTH --top LENGTH --width LENGTH --height LENGTH.\nAdd accepts shape name, text, paint and metadata properties. Lengths require emu/in/cm/mm/pt.\nSelection: --slide N [--shape NAME] | --part URI --scope SCOPE | --select TOKEN.\nSet: selects one shape unless --all; --allow-empty accepts zero matches.\nScopes: slides (default), layouts, masters; shared requires --part URI.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE.\nUnsupported formulas, arcs and arbitrary existing geometry are preserve-only.\n" : ["shapes.group", "shapes.ungroup"].includes(args.schemaPath ?? "") ? "Usage: pptx shapes group|ungroup INPUT --tolerance LENGTH [selection] [output]\nGroup: --shapes JSON array of at least two inspected Location objects.\nShapes must be distinct contiguous siblings; original IDs and z-order are retained.\nUngroup: --slide N --shape NAME | --select TOKEN; selects one group.\nSelection: --part URI --scope SCOPE. Exact cardinality; --all/--allow-empty are unsupported.\nTolerance is explicit nonnegative EMU precision using emu/in/cm/mm/pt lengths.\nIdentity groups preserve child XML; transformed ungrouping supports nested groups and rectangles\nwithout text, styles or strokes.\nTransformed ungrouping supports quarter-turn rotation chains only.\nWorld geometry must remain within tolerance; unsupported geometry and references fail.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE.\n" : args.schemaPath?.startsWith("shapes.drawing.") || args.schemaPath === "shapes.effects.set" ? "Usage: pptx shapes drawing get|set INPUT [selection] [paint] [output]\n       pptx shapes effects set INPUT [selection] --shadow true|false\n         --opacity RATIO --shadow-blur LENGTH --shadow-color COLOR [output]\nPaint: --fill-kind inherit|none|solid|gradient|pattern|picture\n  --color COLOR; gradient: --stops JSON --angle DEGREES\n  pattern: --pattern PRESET [--foreground COLOR --background COLOR]\n  picture: --file PATH --mode stretch|tile\nAdvanced paint: --fill JSON --line JSON --shadow-inherit true|false\nCOLOR is six-digit RGB or JSON with rgb/theme, optional brightness and opacity.\nSelection: --slide N --shape NAME | --part URI --scope SCOPE | --select TOKEN\nScopes: slides (default), layouts, masters; shared requires a part.\nSet selects one shape unless --all; --allow-empty accepts zero matches.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE.\nLengths require emu/in/cm/mm/pt. Simple shadows have zero offset.\nComplex effects and 3D remain intact; editing unsupported effects fails.\n" : args.schemaPath?.startsWith("shapes.") ? "Usage: pptx shapes list|get|add|set INPUT [selection] [properties] [output]\nSelection: --slide N --shape NAME | --select TOKEN; --part URI --scope SCOPE\nScopes: slides (default), layouts, masters; shared requires a part.\nAdd: --kind text-box|PRESET --left LENGTH --top LENGTH --width LENGTH --height LENGTH\nProperties: --name TEXT --text TEXT --title TEXT --description TEXT --alt-text TEXT\n  --locked true|false|null --rotation DEGREES --fill RGB --line-color RGB --line-width LENGTH\n  --flip-horizontal true|false --flip-vertical true|false\n  --adjustments JSON_ARRAY (normalized preset values in guide order)\n  Geometry uses parent coordinates; inspection corners use slide EMUs.\nLengths require emu/in/cm/mm/pt. Presets use enum names or numeric values from schema.\nNull clears direct title/description/lock; null fill/line color disables fill/line.\nOmitted values stay unchanged.\nNull line width restores inherited width.\nFill/line color solid selects solid fill; existing solid colors are retained.\nShape IDs are read-only. Unsupported geometry and advanced formatting are preserve-only.\nOutput: --output PATH | --in-place | --dry-run; --force --json --limit NAME=VALUE\nSet: --all edits every match; --allow-empty accepts zero matches.\n" : args.schemaPath?.startsWith("fields.") ? "Usage: pptx fields list|get|set|add|remove INPUT [options]\nSelection: --slide N --shape NAME | --select TOKEN\n           --scope SCOPE --json --limit NAME=VALUE\nMutation:  --all --allow-empty\nOutput:    --output PATH | --in-place | --dry-run; --force\nSet/add:   --kind slide-number|date|footer|header\n           --update preserve|explicit --text TEXT --timestamp UTC\nAdd requires --kind and one text body; appends to its last paragraph.\nPreserve is default: retains the cache (empty on add), rejects text/time.\nExplicit requires text; date fields also require a caller UTC timestamp.\nNo field evaluation, automatic numbering or inherited-content flattening.\nList/get are read-only; get requires one field. Remove accepts no policy.\n" : usage14;
       if (args.schemaPath === "diff") resolvedUsage = diffUsage;
       if (args.schemaPath?.startsWith("comments.")) resolvedUsage = commentsUsage;
       if (args.schemaPath?.startsWith("notes.")) resolvedUsage = notesUsage;
@@ -12177,11 +12510,11 @@ ${JSON.stringify(result.data, null, 2)}
         try {
           text2 = new TextDecoder("utf-8", { fatal: true }).decode(encoded2);
         } catch {
-          usage12("Batch JSON must be UTF-8.");
+          usage13("Batch JSON must be UTF-8.");
         }
         items = parseAnimationBatch(commandJson(text2));
       }
-      if (items.length && !args.dryRun && !args.inPlace && !args.output) usage12("Mutation requires a destination.");
+      if (items.length && !args.dryRun && !args.inPlace && !args.output) usage13("Mutation requires a destination.");
       const bytes = await request.readInput(args.input, Math.min(context.limits.maxBytes, context.archiveLimits.maxArchiveBytes));
       const index = await readSelectionIndex2(bytes, context);
       const changed = await mutateAnimationsBatch(bytes, resolveAnimationBatch(items, index), context);
@@ -13416,13 +13749,13 @@ ${item.parts.map((part) => `  ${part}
       const inputs = [];
       for (const path of [args.input, ...args.sources ?? []]) {
         if (remaining < 1)
-          throw new OfficeError16("resource-limit", "Combined input limit exceeded.", "admit");
+          throw new OfficeError19("resource-limit", "Combined input limit exceeded.", "admit");
         const bytes = await request.readInput(
           path,
           Math.min(remaining, context.archiveLimits.maxArchiveBytes)
         );
         if (bytes.length > remaining || bytes.length > context.archiveLimits.maxArchiveBytes)
-          throw new OfficeError16("resource-limit", "Combined input limit exceeded.", "admit");
+          throw new OfficeError19("resource-limit", "Combined input limit exceeded.", "admit");
         remaining -= bytes.length;
         inputs.push(await budget.read(bytes));
       }
@@ -13523,7 +13856,7 @@ ${JSON.stringify(result.data, null, 2)}
       }
     } else if (args.operation === "create") {
       if (args.template)
-        throw new OfficeError16(
+        throw new OfficeError19(
           "unsupported-profile",
           "Template-based creation is unavailable.",
           "validate-intent"
@@ -13575,7 +13908,7 @@ ${JSON.stringify(result.data, null, 2)}
         );
       } catch (error) {
         if (error && typeof error === "object" && "code" in error && error.code === "resource-limit")
-          throw new OfficeError16("resource-limit", "Input limit exceeded.", "admit");
+          throw new OfficeError19("resource-limit", "Input limit exceeded.", "admit");
         throw error;
       }
       const index = await readSelectionIndex2(bytes, { ...options2.context, signal: request.signal });
@@ -13720,7 +14053,7 @@ ${JSON.stringify(result.data, null, 2)}
         const part = metadata2 ?? records[0].part;
         const validationLimits = options2.context.validationLimits;
         if (!validationLimits)
-          throw new OfficeError16(
+          throw new OfficeError19(
             "invalid-value",
             "XML operations require explicit validation limits.",
             "usage"
@@ -13796,10 +14129,10 @@ ${xml.xml}
     await stagedOutput?.close().catch(() => {
     });
     stagedOutput = void 0;
-    if (error instanceof OfficeError16 && error.code === "resource-limit" && error.phase === "publish") return outputLimitFailure(output3.operation, output3.json);
+    if (error instanceof OfficeError19 && error.code === "resource-limit" && error.phase === "publish") return outputLimitFailure(output3.operation, output3.json);
     if (request.signal.aborted)
       return { exitCode: 130, stdout: new Uint8Array(), stderr: new Uint8Array() };
-    const office = error instanceof OfficeError16 ? error : void 0;
+    const office = error instanceof OfficeError19 ? error : void 0;
     const capabilityCode = error && typeof error === "object" && "code" in error ? error.code : void 0;
     const limit = office?.code === "resource-limit" || capabilityCode === "resource-limit";
     const unsupported = capabilityCode === "publication-unsupported";
@@ -13825,6 +14158,7 @@ ${xml.xml}
     human = `pptx: ${diagnostic.code}: ${diagnostic.message}
 `;
   }
+  if (retainedExtraction && result.ok) return retainedExtraction.publish();
   const { json, operation } = output3;
   const encoded = (stagedOutput ? new Uint8Array() : binary) ?? new TextEncoder().encode(
     json ? `${JSON.stringify(result)}
@@ -13901,7 +14235,7 @@ ${JSON.stringify(failure.data)}
     } catch (error) {
       if (request.signal.aborted)
         return { exitCode: 130, stdout: new Uint8Array(), stderr: new Uint8Array() };
-      const office = error instanceof OfficeError16 ? error : void 0;
+      const office = error instanceof OfficeError19 ? error : void 0;
       const rawCode = error && typeof error === "object" && "code" in error ? error.code : void 0;
       const code = typeof rawCode === "string" && [
         "resource-limit",
@@ -13983,7 +14317,7 @@ async function execute(request, options2) {
   }
 }
 function createPptxCommandEngine(settings = {}) {
-  const context = resourceContext(settings.context);
+  const context = resourceContext2(settings.context);
   const options2 = {
     maxArgumentBytes: settings.maxArgumentBytes ?? Infinity,
     maxOutputBytes: settings.maxOutputBytes ?? Infinity,