@poe-platform/safe-bash 0.1.812 → 0.1.813

package/dist/safe-bash/command-chunks/{chunk-KJ4XXZIL.js → chunk-M3Z5PU2M.js}

@@ -1,46 +1,88 @@
+import {
+  stageRetainedArchive
+} from "./chunk-3D24WDND.js";
+import {
+  openPackageArchive
+} from "./chunk-KCE5D4Z4.js";
 import {
   openRetainedPresentationIndex,
   stageRetainedOutput,
   streamJson
-} from "./chunk-L5MCW6CM.js";
+} from "./chunk-X64XGIXZ.js";
 import {
   writePackageArchive
-} from "./chunk-DM2CPMB4.js";
+} from "./chunk-HKOMXGJS.js";
 import {
   SelectionError
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-O675URF4.js";
 import {
   readPackage
-} from "./chunk-XPD636C4.js";
+} from "./chunk-PVGZMLC6.js";
 import {
   readBinary
-} from "./chunk-PNGDJA6M.js";
+} from "./chunk-LD7BONZY.js";
 import {
+  openRetainedPresentationValidation,
   validatePresentation
-} from "./chunk-RNSKXOG3.js";
+} from "./chunk-GVWVRPG6.js";
 import {
-  openRetainedContentTypes
-} from "./chunk-QC5RMGSA.js";
+  dialects,
+  openRetainedContentTypes,
+  openRetainedRelationshipGraph
+} from "./chunk-G3RUXKVY.js";
 import {
   parseXmlPart
-} from "./chunk-554Z6IKP.js";
+} from "./chunk-7PRL6RJ6.js";
 import {
   parseContentTypes
-} from "./chunk-WJCN2IXI.js";
+} from "./chunk-VQOINPVF.js";
 import {
   readRelationshipGraph
-} from "./chunk-ZMHEGDU2.js";
+} from "./chunk-TODWFDYB.js";
 import {
   packageUri,
   partName
-} from "./chunk-36XGIPOG.js";
+} from "./chunk-U5TWQFZY.js";
+import {
+  PackageNotFoundError
+} from "./chunk-D55REQA3.js";
 import {
   OfficeError,
+  RetainedValues,
   characters,
+  equal,
   literal,
   openRetainedXml,
-  openRetainedXmlDocument
-} from "./chunk-Q73EMLLZ.js";
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-X6RHJ6YN.js";
+
+// packages/safe-bash-presentation-engine/src/xml-replacement-rules.ts
+var xmlReplacementSequences = {
+  presentation: [
+    "sldMasterIdLst",
+    "notesMasterIdLst",
+    "handoutMasterIdLst",
+    "sldIdLst",
+    "sldSz",
+    "notesSz",
+    "smartTags",
+    "embeddedFontLst",
+    "custShowLst",
+    "photoAlbum",
+    "custDataLst",
+    "kinsoku",
+    "defaultTextStyle",
+    "modifyVerifier",
+    "extLst"
+  ],
+  sld: ["cSld", "clrMapOvr", "transition", "timing", "extLst"],
+  cSld: ["bg", "spTree", "custDataLst", "controls", "extLst"],
+  nvGrpSpPr: ["cNvPr", "cNvGrpSpPr", "nvPr"],
+  sp: ["nvSpPr", "spPr", "style", "txBody", "extLst"],
+  pic: ["nvPicPr", "blipFill", "spPr", "style", "extLst"],
+  graphicFrame: ["nvGraphicFramePr", "xfrm", "graphic", "extLst"]
+};
 
 // packages/safe-bash-presentation-engine/src/xml-view-validation.ts
 function reject() {
@@ -344,12 +386,12 @@ async function openRetainedXmlPart(archive, requested, settings, options = {}) {
     throw error;
   }
 }
-async function stageRetainedXmlPart(archive, fingerprint, selection, settings, output) {
-  const options = { ...selection }, format = { ...output }, index = await openRetainedPresentationIndex(archive, fingerprint, settings);
-  let xml, staged;
+async function selectRetainedXmlPart(archive, fingerprint, selection, settings, allowMetadata = true) {
+  const options = { ...selection }, index = await openRetainedPresentationIndex(archive, fingerprint, settings);
+  let failed = false;
   try {
     let metadata = false;
-    if (options.scope === "shared" && options.part) {
+    if (allowMetadata && options.scope === "shared" && options.part) {
       metadata = options.part === "/[Content_Types].xml" || options.part === packageUri("/").relsUri;
       if (!metadata) {
         for await (const record2 of index.records.records("part")) if (packageUri(record2.part).relsUri === options.part) {
@@ -382,6 +424,23 @@ async function stageRetainedXmlPart(archive, fingerprint, selection, settings, o
     }
     const part = metadata ? options.part : record.part;
     const location = metadata ? { fingerprint, scope: "shared", owner: part, objectId: part, coordinateSystem: "identity" } : record.location;
+    return { part, location };
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    try {
+      await index.close();
+    } catch (error) {
+      if (!failed) await Promise.reject(error);
+    }
+  }
+}
+async function stageRetainedXmlPart(archive, fingerprint, selection, settings, output) {
+  const format = { ...output };
+  let xml, staged;
+  try {
+    const { part, location } = await selectRetainedXmlPart(archive, fingerprint, selection, settings);
     xml = await openRetainedXmlPart(archive, part, settings, { pretty: format.pretty ?? false });
     const data = xml;
     async function* render() {
@@ -396,10 +455,497 @@ async function stageRetainedXmlPart(archive, fingerprint, selection, settings, o
     }
     staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
     await xml.close();
-    await index.close();
     return staged;
   } catch (error) {
-    await Promise.allSettled([xml?.close(), index.close(), staged?.close()]);
+    await Promise.allSettled([xml?.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/retained-xml-replacement.ts
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+function unsupported(message) {
+  throw new OfficeError("unsupported-edit", message, "validate-intent");
+}
+function reject2() {
+  return unsupported("Structured XML change exceeds the validated child-operation subset.");
+}
+async function is(doc, node, local, namespaces2) {
+  if (!await equal(doc.raw(node.localName), literal(local))) return false;
+  if (!namespaces2) return true;
+  for (const ns of namespaces2) if (await equal(doc.namespace(node), literal(ns))) return true;
+  return false;
+}
+async function sameName(left, a, right, b) {
+  return await equal(left.raw(a.localName), right.raw(b.localName)) && await equal(left.namespace(a), right.namespace(b));
+}
+async function* children(doc, node) {
+  for await (const child of doc.children(node)) if (child.kind === "element") yield child;
+}
+async function typeInfo(source) {
+  let prefix = "", suffix = "", pending = 0, started = false, dangerous = false, window = "";
+  for await (const value of characters(source)) {
+    if (value === ";") break;
+    const character = value.toLowerCase();
+    if (!character.trim()) {
+      if (started) pending++;
+      continue;
+    }
+    if (pending) {
+      prefix = (prefix + " ".repeat(Math.min(160, pending))).slice(0, 160);
+      suffix = (suffix + " ".repeat(Math.min(4, pending))).slice(-4);
+      window = (window + " ".repeat(Math.min(17, pending))).slice(-17);
+      pending = 0;
+    }
+    started = true;
+    prefix = (prefix + character).slice(0, 160);
+    suffix = (suffix + character).slice(-4);
+    window = (window + character).slice(-17);
+    if (["digital-signature", "macroenabled", "vbaproject"].some((value2) => window.includes(value2))) dangerous = true;
+  }
+  return { name: prefix, xml: prefix === "application/xml" || prefix === "text/xml" || suffix === "+xml", dangerous };
+}
+async function openRetainedXmlReplacement(archive, requested, source, settings) {
+  const limits = settings.validationLimits && { ...settings.validationLimits };
+  if (!limits) throw new OfficeError("invalid-value", "XML operations require explicit validation limits.", "usage");
+  const part = partName(requested, false), working = { ...settings.workingStorage }, signal = settings.signal ?? new AbortController().signal;
+  const context = { ...resolveOfficeResources(settings), workingStorage: working, signal, xmlLimits: limits, relationshipLimits: limits };
+  let found = false;
+  if (part === requested) {
+    for await (const name of archive.parts()) if (name === part) found = true;
+  }
+  if (!found) throw new OfficeError("missing-selection", "An exact existing package part is required.", "select");
+  const types = await openRetainedContentTypes(archive.read("/[Content_Types].xml"), context, limits);
+  const pages = new PagedStorage2({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  let before, after, graph, closed = false, closing, serial = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "XML replacement is closed.", "validate-intent");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "validate-intent");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([before?.close(), after?.close(), graph?.close(), types.close(), pages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  async function row(pointer, count) {
+    check();
+    const bytes = await pages.read(pointer, count * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: count }, (_, i) => view.getFloat64(i * 8, true));
+  }
+  async function write(pointer, row2) {
+    check();
+    const bytes = new Uint8Array(row2.length * 8), view = new DataView(bytes.buffer);
+    row2.forEach((value, i) => view.setFloat64(i * 8, value, true));
+    await pages.write(pointer, bytes);
+  }
+  async function pairs(left, right, visit) {
+    let stack = pages.allocate(24);
+    await write(stack, [0, left.reference(left.root), right.reference(right.root)]);
+    while (stack) {
+      const item = await row(stack, 3);
+      stack = item[0];
+      const a = await left.node(item[1]), b = await right.node(item[2]);
+      if (!await visit(a, b)) continue;
+      const iterator = children(right, b);
+      try {
+        for await (const child of children(left, a)) {
+          const next = await iterator.next();
+          if (next.done) unsupported("XML replacement must preserve element names and sequence.");
+          const pointer = pages.allocate(24);
+          await write(pointer, [stack, left.reference(child), right.reference(next.value)]);
+          stack = pointer;
+        }
+        if (!(await iterator.next()).done) unsupported("XML replacement must preserve element names and sequence.");
+      } finally {
+        await iterator.return(void 0);
+      }
+    }
+  }
+  async function compareAttributes(left, a, right, b, declarations) {
+    const scope = `attributes:${serial++}`;
+    let count = 0, compared = 0;
+    async function* key(doc, attribute) {
+      yield* doc.namespace(attribute);
+      yield* literal("\0");
+      yield* doc.raw(attribute.localName);
+    }
+    for await (const attribute of declarations ? left.declarations(a) : left.attributes(a)) {
+      if (!declarations && await equal(left.namespace(attribute), literal(""))) continue;
+      const name = await values.store(key(left, attribute)), value = await values.store(left.text(attribute));
+      await values.insert(scope, name, value);
+      count++;
+    }
+    for await (const attribute of declarations ? right.declarations(b) : right.attributes(b)) {
+      if (!declarations && await equal(right.namespace(attribute), literal(""))) continue;
+      const value = await values.find(scope, () => key(right, attribute));
+      compared++;
+      if (!declarations) {
+        for (const dialect of dialects) if (await equal(right.namespace(attribute), literal(dialect.r)) && !await graph.get(part, () => right.text(attribute))) throw new OfficeError("invalid-opc", "XML references an absent relationship.", "validate-result");
+      }
+      if (!value || !await equal(values.read(value), right.text(attribute))) unsupported(declarations ? "XML replacement must preserve namespace declarations." : "Namespaced XML attributes must remain unchanged.");
+    }
+    if (count !== compared) unsupported(declarations ? "XML replacement must preserve namespace declarations." : "Namespaced XML attributes must remain unchanged.");
+  }
+  async function guards(current) {
+    let nodes = 0, total = 0;
+    for await (const name of current.parts()) {
+      check();
+      if (name === "/[Content_Types].xml") continue;
+      const type = await typeInfo(await types.get(name));
+      if (type.dangerous || name.toLowerCase().startsWith("/_xmlsignatures/")) unsupported("Signed and macro-enabled packages cannot be changed.");
+      if (!type.xml) continue;
+      total += await current.byteLength(name);
+      if (total > limits.maxBytes || nodes >= limits.maxNodes) throw new OfficeError("resource-limit", "Package XML inspection limit exceeded.", "index");
+      const doc = await openRetainedXmlDocument(current.read(name), { ...context, xmlLimits: { ...limits, maxNodes: limits.maxNodes - nodes } });
+      let failed = false;
+      try {
+        nodes += doc.nodeCount;
+        for await (const node of doc.elements(doc.root)) {
+          for await (const attribute of doc.attributes(node)) for (const dialect of dialects) if (await equal(doc.namespace(attribute), literal(dialect.r)) && !await graph.get(name, () => doc.text(attribute))) throw new OfficeError("invalid-opc", "XML references an absent relationship.", "validate-intent");
+          if (await is(doc, node, "modifyVerifier", dialects.map((d) => d.p))) unsupported("Protected presentations cannot be changed.");
+        }
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        try {
+          await doc.close();
+        } catch (error) {
+          if (!failed) await Promise.reject(error);
+        }
+      }
+    }
+    async function* owners() {
+      yield "/";
+      yield* graph.parts();
+    }
+    for await (const owner of owners()) for await (const edge of graph.outgoing(owner)) {
+      let window = "";
+      for await (const character of characters(edge.type())) {
+        window = (window + character).slice(-19);
+        if (window.includes("/digital-signature/")) unsupported("Signed and macro-enabled packages cannot be changed.");
+      }
+      if (window.endsWith("/vbaProject")) unsupported("Signed and macro-enabled packages cannot be changed.");
+    }
+  }
+  async function validate(current) {
+    const validation = await openRetainedPresentationValidation(current, context, limits);
+    const valid = validation.valid;
+    await validation.close();
+    if (!valid) throw new OfficeError("invalid-opc", "Replacement fails presentation graph validation.", "validate-result");
+  }
+  async function strict(left, right, expected) {
+    for await (const child of children(right, right.root)) if (await is(right, child, "sldSz") && await equal(right.namespace(child), right.namespace(right.root))) {
+      for (const axis of ["cx", "cy"]) {
+        let found2 = false;
+        for await (const attribute of right.attributes(child)) if (await is(right, attribute, axis, [""])) {
+          let number = 0, digits = 0;
+          for await (const character of characters(right.text(attribute))) {
+            if (character < "0" || character > "9") throw new OfficeError("invalid-opc", "Invalid authored slide dimensions.", "validate-result");
+            number = number * 10 + Number(character);
+            digits++;
+            if (number > 51206400) break;
+          }
+          if (digits && number >= 914400 && number <= 51206400) found2 = true;
+        }
+        if (!found2) throw new OfficeError("invalid-opc", "Invalid authored slide dimensions.", "validate-result");
+      }
+    }
+    if (!await is(left, left.root, expected) || !await is(right, right.root, expected)) throw new OfficeError("invalid-opc", "XML root does not match the content type.", "validate-result");
+    let dialect;
+    for (const value of dialects) if (await equal(left.namespace(left.root), literal(value.p))) dialect = value;
+    if (!dialect || !await equal(left.namespace(left.root), right.namespace(right.root))) unsupported("XML replacement must preserve the presentation dialect.");
+    const iterator = right.elements(right.root);
+    try {
+      for await (const node of left.elements(left.root)) {
+        const next = await iterator.next();
+        if (next.done) unsupported("XML replacement must preserve namespace declarations.");
+        await compareAttributes(left, node, right, next.value, true);
+      }
+      if (!(await iterator.next()).done) unsupported("XML replacement must preserve namespace declarations.");
+    } finally {
+      await iterator.return(void 0);
+    }
+    await pairs(left, right, async (a, b) => {
+      if (!await sameName(left, a, right, b)) unsupported("XML replacement must preserve element names and sequence.");
+      let understood = false;
+      for (const ns of [dialect.p, dialect.a]) if (await equal(right.namespace(b), literal(ns))) understood = true;
+      if (!understood || await is(right, b, "graphicData") || await is(right, b, "ext")) {
+        if (!await equal(left.markup(a), right.markup(b))) unsupported("Opaque XML content must remain unchanged.");
+        return false;
+      }
+      await compareAttributes(left, a, right, b, false);
+      if (await is(right, b, "modifyVerifier", dialects.map((d) => d.p))) unsupported("Protection changes are unsupported.");
+      if (await equal(right.namespace(b), literal(dialect.p))) {
+        for (const [local, order] of Object.entries(xmlReplacementSequences)) if (await is(right, b, local)) {
+          let previous = -1;
+          for await (const child of children(right, b)) {
+            let rank = -1;
+            for (let i = 0; i < order.length; i++) if (await is(right, child, order[i])) rank = i;
+            if (rank < 0 || rank <= previous) unsupported("Unsupported XML child sequence.");
+            previous = rank;
+          }
+        }
+      }
+      for await (const attribute of right.attributes(b)) for (const value of dialects) if (value.r !== dialect.r && await equal(right.namespace(attribute), literal(value.r))) unsupported("XML replacement must preserve relationship dialect.");
+      return true;
+    });
+  }
+  async function structural(left, right) {
+    let dialect = dialects[0];
+    for (const value of dialects) if (await equal(left.namespace(left.root), literal(value.p))) dialect = value;
+    async function movable2(node) {
+      for await (const child of left.elements(node)) {
+        let extent = await is(left, child, "ext", [dialect.a]), count = 0;
+        for await (const attribute of left.attributes(child)) {
+          count++;
+          const plain = await equal(left.namespace(attribute), literal(""));
+          if (!plain || !await is(left, attribute, "cx") && !await is(left, attribute, "cy")) extent = false;
+          if (!plain) {
+            let valid = false;
+            for (const ns of [...dialects.map((d) => d.r), "http://www.w3.org/XML/1998/namespace"]) if (await equal(left.namespace(attribute), literal(ns))) valid = true;
+            if (!valid) return false;
+          }
+        }
+        extent = extent && count === 2;
+        if (!await equal(left.namespace(child), literal(dialect.p)) && !await equal(left.namespace(child), literal(dialect.a)) || await is(left, child, "graphicData") || await is(left, child, "ext") && !extent) return false;
+      }
+      return true;
+    }
+    await pairs(left, right, async (a, b) => {
+      if (await equal(left.markup(a), right.markup(b))) return false;
+      if (!await sameName(left, a, right, b) || !await equal(left.shell(a), right.shell(b))) reject2();
+      if (!await equal(left.namespace(a), literal(dialect.p)) && !await equal(left.namespace(a), literal(dialect.a)) || await is(left, a, "graphicData") || await is(left, a, "ext")) reject2();
+      const drawing = await is(left, a, "spTree", [dialect.p]), paragraph = await is(left, a, "p", [dialect.a]);
+      if (!drawing && !paragraph) return true;
+      async function eligible(doc, node) {
+        for (const name of drawing ? ["sp", "pic", "cxnSp", "grpSp"] : ["r", "br"]) if (await is(doc, node, name, [drawing ? dialect.p : dialect.a])) return true;
+        return false;
+      }
+      async function* fixed(doc, node) {
+        for await (const child of children(doc, node)) if (!await eligible(doc, child)) yield child;
+      }
+      const iterator = fixed(right, b);
+      try {
+        for await (const child of fixed(left, a)) {
+          const next = await iterator.next();
+          if (next.done || !await equal(left.markup(child), right.markup(next.value))) reject2();
+        }
+        if (!(await iterator.next()).done) reject2();
+      } finally {
+        await iterator.return(void 0);
+      }
+      const scope = `children:${serial++}`;
+      let first = 0, last = 0, index = 0;
+      for await (const child of children(left, a)) {
+        if (await eligible(left, child)) {
+          const pointer = pages.allocate(40);
+          await write(pointer, [0, left.reference(child), index, -1, 0]);
+          if (last) await write(last, [pointer]);
+          else first = pointer;
+          last = pointer;
+          const existing = await values.find(scope, () => left.markup(child));
+          if (existing) {
+            const queue = await row(existing.start, 2);
+            await write(queue[1] + 32, [pointer]);
+            await write(existing.start + 8, [pointer]);
+          } else {
+            const key = await values.store(left.markup(child)), queue = pages.allocate(16);
+            await write(queue, [pointer, pointer]);
+            await values.insert(scope, key, { start: queue, length: 16 });
+          }
+        }
+        index++;
+      }
+      index = 0;
+      let matched = true;
+      for await (const child of children(right, b)) {
+        if (await eligible(right, child)) {
+          const queue = await values.find(scope, () => right.markup(child)), head = queue ? (await row(queue.start, 2))[0] : 0;
+          if (!head) {
+            matched = false;
+            break;
+          }
+          const item = await row(head, 5);
+          await write(head + 24, [index]);
+          await write(queue.start, [item[4]]);
+        }
+        index++;
+      }
+      if (!matched) return true;
+      for (let pointer = first; pointer; ) {
+        const item = await row(pointer, 5);
+        if (item[2] !== item[3] && !await movable2(await left.node(item[1]))) reject2();
+        pointer = item[0];
+      }
+      index = 0;
+      let extension = false, end = false;
+      for await (const child of children(right, b)) {
+        if (drawing) {
+          if (index === 0 && !await is(right, child, "nvGrpSpPr") || index === 1 && !await is(right, child, "grpSpPr") || index >= 2 && (await is(right, child, "nvGrpSpPr") || await is(right, child, "grpSpPr")) || extension) reject2();
+          if (await is(right, child, "extLst")) extension = true;
+        } else {
+          let allowed = false;
+          for (const name of ["pPr", "r", "br", "endParaRPr"]) if (await is(right, child, name, [dialect.a])) allowed = true;
+          if (!allowed || end || index !== 0 && await is(right, child, "pPr")) reject2();
+          if (await is(right, child, "endParaRPr")) end = true;
+        }
+        index++;
+      }
+      if (drawing && index < 2) reject2();
+      return false;
+    });
+  }
+  try {
+    const selectedType = part === "/[Content_Types].xml" ? { name: "application/xml", xml: true } : await typeInfo(await types.get(part));
+    if (!selectedType.xml) throw new OfficeError("unsupported-profile", "The selected part is not XML.", "select");
+    before = await openRetainedXmlDocument(archive.read(part), context);
+    async function* admittedReplacement() {
+      const checkInput = () => {
+        if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "admit");
+      };
+      let iterator, exhausted = false, size = 0;
+      try {
+        iterator = source[Symbol.asyncIterator]();
+      } catch {
+        checkInput();
+        throw new OfficeError("io-failure", "Byte input failed.", "admit");
+      }
+      try {
+        for (let reads = 0; reads < context.limits.maxReads; reads++) {
+          checkInput();
+          let item;
+          try {
+            item = await iterator.next();
+          } catch (error) {
+            checkInput();
+            if (error && typeof error === "object" && "code" in error) {
+              if (error.code === "ENOENT") throw new PackageNotFoundError();
+              if (error.code === "EFBIG") throw new OfficeError("resource-limit", "Byte input exceeds its limit.", "admit");
+            }
+            throw new OfficeError("io-failure", "Byte input failed.", "admit");
+          }
+          checkInput();
+          if (item.done) {
+            exhausted = true;
+            return;
+          }
+          if (!(item.value instanceof Uint8Array)) throw new OfficeError("invalid-type", "Byte source returned an invalid chunk.", "admit");
+          if (item.value.length > limits.maxBytes - size || !Number.isSafeInteger(size + item.value.length)) throw new OfficeError("resource-limit", "Byte input exceeds its limit.", "admit");
+          size += item.value.length;
+          yield item.value;
+        }
+        throw new OfficeError("resource-limit", "Byte source exceeded its read limit.", "admit");
+      } finally {
+        if (!exhausted) try {
+          await iterator.return?.();
+        } catch {
+        }
+      }
+    }
+    const replacement = await values.store(admittedReplacement());
+    graph = await openRetainedRelationshipGraph(archive, context);
+    await guards(archive);
+    const expected = (/* @__PURE__ */ new Map([
+      ["application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml", "presentation"],
+      ["application/vnd.openxmlformats-officedocument.presentationml.template.main+xml", "presentation"],
+      ["application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml", "presentation"],
+      ["application/vnd.openxmlformats-officedocument.presentationml.slide+xml", "sld"]
+    ])).get(selectedType.name);
+    if (!expected) unsupported("Replacement supports presentation and slide XML with unchanged element structure.");
+    after = await openRetainedXmlDocument(values.read(replacement), context);
+    const changed = !await equal(archive.read(part), values.read(replacement));
+    const candidate = {
+      async *parts() {
+        check();
+        yield* archive.parts();
+        check();
+      },
+      async has(name) {
+        check();
+        return archive.has(name);
+      },
+      async byteLength(name) {
+        check();
+        return name === part ? replacement.length : archive.byteLength(name);
+      },
+      async *read(name) {
+        check();
+        yield* name === part ? values.read(replacement) : archive.read(name);
+        check();
+      }
+    };
+    try {
+      await strict(before, after, expected);
+      await validate(candidate);
+    } catch (error) {
+      if (!(error instanceof OfficeError) || error.code !== "unsupported-edit") throw error;
+      await strict(before, before, expected);
+      await validate(archive);
+      await structural(before, after);
+      await guards(candidate);
+      await strict(after, after, expected);
+      await validate(candidate);
+    }
+    await before.close();
+    before = void 0;
+    await after.close();
+    after = void 0;
+    await graph.close();
+    graph = void 0;
+    await types.close();
+    check();
+    return Object.freeze({ ...candidate, changed, async replacement(name) {
+      check();
+      return changed && name === part ? values.read(replacement) : void 0;
+    }, close });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/retained-xml-publication.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+async function stageRetainedXmlReplacement(input, replacement, selection, settings, output) {
+  const signal = settings.signal ?? new AbortController().signal, hash = sha256.create();
+  for await (const bytes of input.stream()) {
+    signal.throwIfAborted();
+    hash.update(bytes);
+  }
+  const before = Array.from(hash.digest(), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const archive = await openPackageArchive(input, settings);
+  let mutation;
+  let staged, response, closing;
+  const close = () => closing ??= (async () => {
+    const results = await Promise.allSettled([response?.close(), staged?.close(), mutation?.close(), archive.close()]);
+    for (const result of results) if (result.status === "rejected") throw result.reason;
+  })();
+  try {
+    const { part, location } = await selectRetainedXmlPart(archive, before, selection, settings, false);
+    mutation = await openRetainedXmlReplacement(archive, part, replacement, settings);
+    staged = await stageRetainedArchive(input, before, archive, mutation, settings);
+    const { bytes, size, fingerprint } = staged, { dryRun } = output;
+    async function* content() {
+      if (output.destination === "-" && !dryRun) {
+        yield* bytes();
+        return;
+      }
+      if (output.json) {
+        yield* streamJson({ version: 1, operation: "xml.set", ok: true, data: { part, dryRun }, warnings: [], errors: [], affected: 1, locations: [location] });
+        yield new TextEncoder().encode("\n");
+      } else yield new TextEncoder().encode(`${dryRun ? "Validated" : "Replaced"} XML part ${part}
+`);
+    }
+    response = await stageRetainedOutput(content(), settings, output.maxOutputBytes);
+    return Object.freeze({ bytes, size, fingerprint, output: response, close });
+  } catch (error) {
+    await close().catch(() => {
+    });
     throw error;
   }
 }
@@ -413,32 +959,7 @@ var relationshipNamespaces = [
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
   "http://purl.oclc.org/ooxml/officeDocument/relationships"
 ];
-var sequences = {
-  presentation: [
-    "sldMasterIdLst",
-    "notesMasterIdLst",
-    "handoutMasterIdLst",
-    "sldIdLst",
-    "sldSz",
-    "notesSz",
-    "smartTags",
-    "embeddedFontLst",
-    "custShowLst",
-    "photoAlbum",
-    "custDataLst",
-    "kinsoku",
-    "defaultTextStyle",
-    "modifyVerifier",
-    "extLst"
-  ],
-  sld: ["cSld", "clrMapOvr", "transition", "timing", "extLst"],
-  cSld: ["bg", "spTree", "custDataLst", "controls", "extLst"],
-  nvGrpSpPr: ["cNvPr", "cNvGrpSpPr", "nvPr"],
-  sp: ["nvSpPr", "spPr", "style", "txBody", "extLst"],
-  pic: ["nvPicPr", "blipFill", "spPr", "style", "extLst"],
-  graphicFrame: ["nvGraphicFramePr", "xfrm", "graphic", "extLst"]
-};
-function unsupported(message) {
+function unsupported2(message) {
   throw new OfficeError("unsupported-edit", message, "validate-intent");
 }
 function select(reader, requested, context) {
@@ -566,7 +1087,7 @@ function validateXmlPartReplacement(reader, part, bytes, context) {
     if (name === "/[Content_Types].xml") continue;
     const type = contentTypes.get(name).split(";", 1)[0].trim().toLowerCase();
     if (type.includes("digital-signature") || type.includes("macroenabled") || type.includes("vbaproject") || name.toLowerCase().startsWith("/_xmlsignatures/"))
-      unsupported("Signed and macro-enabled packages cannot be changed.");
+      unsupported2("Signed and macro-enabled packages cannot be changed.");
     if (type.endsWith("+xml") || type === "application/xml" || type === "text/xml") {
       const data = reader.get(name);
       total += data.length;
@@ -588,7 +1109,7 @@ function validateXmlPartReplacement(reader, part, bytes, context) {
               "validate-intent"
             );
         if (namespaces.includes(node.name.namespace) && node.name.localName === "modifyVerifier")
-          unsupported("Protected presentations cannot be changed.");
+          unsupported2("Protected presentations cannot be changed.");
         pending2.push(...node.children);
       }
     }
@@ -597,7 +1118,7 @@ function validateXmlPartReplacement(reader, part, bytes, context) {
     if (graph.outgoing(owner).some(
       (edge) => edge.type.includes("/digital-signature/") || edge.type.endsWith("/vbaProject")
     ))
-      unsupported("Signed and macro-enabled packages cannot be changed.");
+      unsupported2("Signed and macro-enabled packages cannot be changed.");
   const root = selected.document.root;
   const expected = (/* @__PURE__ */ new Map([
     [
@@ -615,7 +1136,7 @@ function validateXmlPartReplacement(reader, part, bytes, context) {
     ["application/vnd.openxmlformats-officedocument.presentationml.slide+xml", "sld"]
   ])).get(selected.contentType);
   if (!expected)
-    unsupported(
+    unsupported2(
       "Replacement supports presentation and slide XML with unchanged element structure."
     );
   const changed = parseXmlPart(bytes, context.validationLimits);
@@ -642,9 +1163,9 @@ function validateXmlPartReplacement(reader, part, bytes, context) {
       "validate-result"
     );
   if (!namespaces.includes(root.name.namespace) || root.name.namespace !== changed.root.name.namespace)
-    unsupported("XML replacement must preserve the presentation dialect.");
+    unsupported2("XML replacement must preserve the presentation dialect.");
   if (namespaceDeclarations(selected.document) !== namespaceDeclarations(changed))
-    unsupported("XML replacement must preserve namespace declarations.");
+    unsupported2("XML replacement must preserve namespace declarations.");
   const pending = [{ before: root, after: changed.root }];
   const understood = [
     root.name.namespace,
@@ -654,10 +1175,10 @@ function validateXmlPartReplacement(reader, part, bytes, context) {
   while (pending.length) {
     const { before, after } = pending.pop();
     if (before.name.namespace !== after.name.namespace || before.name.localName !== after.name.localName || before.children.length !== after.children.length)
-      unsupported("XML replacement must preserve element names and sequence.");
+      unsupported2("XML replacement must preserve element names and sequence.");
     if (!understood.includes(after.name.namespace) || ["graphicData", "ext"].includes(after.name.localName)) {
       if (selected.document.markup(before) !== changed.markup(after))
-        unsupported("Opaque XML content must remain unchanged.");
+        unsupported2("Opaque XML content must remain unchanged.");
       continue;
     }
     for (const attribute of [...before.attributes, ...after.attributes]) {
@@ -672,22 +1193,22 @@ function validateXmlPartReplacement(reader, part, bytes, context) {
           "validate-result"
         );
       if (left?.value !== right?.value)
-        unsupported("Namespaced XML attributes must remain unchanged.");
+        unsupported2("Namespaced XML attributes must remain unchanged.");
     }
     if (namespaces.includes(after.name.namespace) && after.name.localName === "modifyVerifier")
-      unsupported("Protection changes are unsupported.");
-    const order = after.name.namespace === root.name.namespace ? sequences[after.name.localName] : void 0;
+      unsupported2("Protection changes are unsupported.");
+    const order = after.name.namespace === root.name.namespace ? xmlReplacementSequences[after.name.localName] : void 0;
     if (order) {
       let previous = -1;
       for (const child of after.children) {
         const rank = order.indexOf(child.name.localName);
-        if (rank < 0 || rank <= previous) unsupported("Unsupported XML child sequence.");
+        if (rank < 0 || rank <= previous) unsupported2("Unsupported XML child sequence.");
         previous = rank;
       }
     }
     for (const attribute of after.attributes) {
       if (relationshipNamespaces.includes(attribute.name.namespace) && attribute.name.namespace !== relationshipNamespaces[namespaces.indexOf(root.name.namespace)])
-        unsupported("XML replacement must preserve relationship dialect.");
+        unsupported2("XML replacement must preserve relationship dialect.");
     }
     after.children.forEach(
       (child, index) => pending.push({ before: before.children[index], after: child })
@@ -712,6 +1233,8 @@ export {
   validateXmlViewReplacement,
   openRetainedXmlPart,
   stageRetainedXmlPart,
+  openRetainedXmlReplacement,
+  stageRetainedXmlReplacement,
   getXmlPart,
   replaceXmlPart,
   validateXmlPartReplacement