@poe-platform/safe-bash 0.1.815 → 0.1.817

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

@@ -0,0 +1,398 @@
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-FB2WPI3M.js";
+import {
+  attr,
+  child,
+  escape,
+  invalid,
+  loadShared,
+  nextRel,
+  relPart
+} from "./chunk-A5SPMSKD.js";
+import {
+  SelectionError,
+  decodeSelectionToken
+} from "./chunk-NCNHJRIY.js";
+import {
+  openRetainedPresentationValidation
+} from "./chunk-6W4RMBFH.js";
+import {
+  dialects
+} from "./chunk-6KJDTKE4.js";
+import {
+  parseXmlPart
+} from "./chunk-7PYDVQPB.js";
+import {
+  relativePartReference
+} from "./chunk-MOUCMZZP.js";
+import {
+  OfficeError,
+  RetainedValues,
+  equal,
+  folded,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-KM2SMMXZ.js";
+
+// packages/safe-bash-presentation-engine/src/retained-tags.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function openRetainedTags(archive, fingerprint, options, settings) {
+  validateTagOptions(options);
+  const query = { ...options, ...options.selection ? { selection: { ...options.selection, ...options.selection.position ? { position: { ...options.selection.position } } : {} } } : {} };
+  const context = resolveOfficeResources(settings), working = { ...settings.workingStorage }, signal = context.signal ?? new AbortController().signal;
+  const index = await openRetainedPresentationIndex(archive, fingerprint, { ...context, workingStorage: working });
+  const pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  let closed = false, closing, head = 0, tail = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Tags are closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const outcomes = await Promise.allSettled([index.close(), pages.close()]);
+      for (const outcome of outcomes) if (outcome.status === "rejected") throw outcome.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  const range = (row2, offset) => ({ start: row2[offset], length: row2[offset + 1] });
+  async function row(pointer) {
+    check();
+    const bytes = await pages.read(pointer, 7 /* Count */ * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: 7 /* Count */ }, (_, n) => view.getFloat64(n * 8, true));
+  }
+  async function write(pointer, numbers) {
+    check();
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((number, n) => view.setFloat64(n * 8, number, true));
+    await pages.write(pointer, bytes);
+  }
+  async function bounded(value) {
+    const decoder = new TextDecoder();
+    let result = "";
+    for await (const bytes of values.read(value)) result += decoder.decode(bytes, { stream: true });
+    return result + decoder.decode();
+  }
+  const invalid2 = (message) => {
+    throw new OfficeError("invalid-value", message, "usage");
+  };
+  async function is(document, node, local, namespace) {
+    return await equal(document.raw(node.localName), literal(local)) && await equal(document.namespace(node), namespace);
+  }
+  async function child2(document, parent, local) {
+    let found;
+    for await (const node of document.children(parent)) if (node.kind === "element" && await is(document, node, local, document.namespace(parent))) {
+      if (found) invalid2("Ambiguous shared structure.");
+      found = node;
+    }
+    return found;
+  }
+  async function attribute(document, node, local, namespace = "") {
+    for await (const attr2 of document.attributes(node)) if (await is(document, attr2, local, literal(namespace))) return attr2;
+    return void 0;
+  }
+  try {
+    const validation = await openRetainedPresentationValidation(archive, { ...context, workingStorage: working }, { ...context.xmlLimits, ...context.relationshipLimits, maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes), maxEntries: context.archiveLimits.maxMembers });
+    const valid = validation.valid;
+    try {
+      await validation.close();
+    } catch (error) {
+      if (valid) await Promise.reject(error);
+    }
+    if (!valid) throw new OfficeError("invalid-opc", "Invalid presentation graph.", "validate-intent");
+    for await (const part of archive.parts()) {
+      const key = await values.store(folded(literal(part))), value = await values.store(literal(part));
+      await values.insert("parts", key, value);
+    }
+    const main = await openRetainedXmlDocument(archive.read(index.records.main), { ...context, workingStorage: working });
+    let dialect = dialects[0], failed = false;
+    try {
+      for (const candidate of dialects) if (await equal(main.namespace(main.root), literal(candidate.p))) dialect = candidate;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      try {
+        await main.close();
+      } catch (error) {
+        if (!failed) await Promise.reject(error);
+      }
+    }
+    let token;
+    if (query.selection?.token) {
+      if (Object.keys(query.selection).some((key) => key !== "token")) throw new SelectionError("invalid-selection");
+      token = decodeSelectionToken(query.selection.token);
+      if (token.fingerprint !== fingerprint) throw new SelectionError("stale-selection");
+      if (token.scope !== "slides" && token.scope !== "presentation" || query.scope !== void 0 && query.scope !== token.scope) throw new SelectionError("invalid-selection");
+    }
+    async function* owners2() {
+      if ((token?.scope ?? query.scope) === "presentation") {
+        yield { part: index.records.main, slide: null };
+        return;
+      }
+      const selected = token ? void 0 : query.selection;
+      for await (const record of selected ? index.records.select({ kind: "slide", ...selected }) : index.records.records("slide")) {
+        if (record.kind !== "slide") throw new SelectionError("invalid-selection");
+        yield { part: record.part, slide: record.position };
+      }
+    }
+    for await (const ignoredOwner of owners2()) check();
+    for await (const owner of owners2()) {
+      const document = await openRetainedXmlDocument(archive.read(owner.part), { ...context, workingStorage: working });
+      let failed2 = false, reference;
+      try {
+        const base = owner.part === index.records.main ? document.root : await child2(document, document.root, "cSld");
+        if (!base) invalid2("Tag owner lacks common slide data.");
+        const list = await child2(document, base, "custDataLst"), tags2 = list ? await child2(document, list, "tags") : void 0;
+        if (tags2) {
+          const id = await attribute(document, tags2, "id", dialect.r);
+          let count = 0;
+          if (id) {
+            for await (const edge of index.graph.outgoing(owner.part)) if (edge.owner === owner.part && !edge.external && await equal(edge.type(), literal(`${dialect.r}/tags`)) && await equal(edge.id(), document.text(id))) {
+              count++;
+              if (edge.targetPart) reference = await values.store(edge.targetPart());
+            }
+          }
+          if (count !== 1 || !reference) invalid2("Invalid tag association.");
+        }
+      } catch (error) {
+        failed2 = true;
+        throw error;
+      } finally {
+        try {
+          await document.close();
+        } catch (error) {
+          if (!failed2) await Promise.reject(error);
+        }
+      }
+      if (!reference) continue;
+      const original = await values.find("parts", () => folded(values.read(reference)));
+      if (!original) throw new OfficeError("missing-binding", "Package member is absent.", "index");
+      const part = await bounded(reference), tags = await openRetainedXmlDocument(archive.read(await bounded(original)), { ...context, workingStorage: working });
+      let failedTags = false;
+      try {
+        if (!await is(tags, tags.root, "tagLst", literal(dialect.p))) invalid2("Invalid tag list.");
+        let childIndex = 0;
+        for await (const node of tags.children(tags.root)) {
+          if (node.kind !== "element") continue;
+          const position = childIndex++;
+          if (!await is(tags, node, "tag", literal(dialect.p))) continue;
+          const name = await attribute(tags, node, "name"), value = await attribute(tags, node, "val");
+          if (!name || !value) invalid2("Tag requires name and value attributes.");
+          const location = { fingerprint, scope: owner.slide === null ? "presentation" : "slides", owner: owner.part, objectId: `tag:${part}:${position}`, coordinateSystem: "identity" };
+          const metadata = await values.store(literal(JSON.stringify({ part, owner: owner.part, slide: owner.slide, selector: JSON.stringify(location), location })));
+          const key = await values.store(tags.text(name)), text = await values.store(tags.text(value));
+          const pointer = pages.allocate(7 /* Count */ * 8);
+          await write(pointer, [0, metadata.start, metadata.length, key.start, key.length, text.start, text.length]);
+          if (tail) await write(tail, [pointer]);
+          else head = pointer;
+          tail = pointer;
+        }
+      } catch (error) {
+        failedTags = true;
+        throw error;
+      } finally {
+        try {
+          await tags.close();
+        } catch (error) {
+          if (!failedTags) await Promise.reject(error);
+        }
+      }
+    }
+    await index.close();
+    return Object.freeze({ close, async *records() {
+      check();
+      for (let pointer = head; pointer; ) {
+        const data = await row(pointer);
+        pointer = data[0 /* Next */];
+        const metadata = JSON.parse(await bounded(range(data, 1 /* Metadata */)));
+        if (token && metadata.selector !== query.selection.token) continue;
+        yield { name: () => values.read(range(data, 3 /* Name */)), value: () => values.read(range(data, 5 /* Value */)), ...metadata };
+      }
+      check();
+    } });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Tag storage operation failed.", "index");
+  }
+}
+async function stageRetainedTags(archive, fingerprint, query, settings, output) {
+  const format = { ...output };
+  if (!["tags.list", "tags.get"].includes(format.operation)) throw new OfficeError("invalid-value", "Invalid tag read operation.", "usage");
+  const tags = await openRetainedTags(archive, fingerprint, query, settings);
+  let staged;
+  try {
+    if (format.operation === "tags.get") {
+      let count = 0;
+      for await (const ignoredRecord of tags.records()) count++;
+      if (count !== 1) throw new SelectionError(count ? "ambiguous-selection" : "missing-selection");
+    }
+    async function* locations() {
+      for await (const tag of tags.records()) yield tag.location;
+    }
+    async function* render() {
+      if (format.json) {
+        yield* streamJson({ version: 1, operation: format.operation, ok: true, data: { tags: tags.records() }, affected: 0, warnings: [], errors: [], locations: locations() });
+        yield* literal("\n");
+      } else for await (const tag of tags.records()) {
+        yield* streamJson(tag.name);
+        yield* literal(": ");
+        yield* streamJson(tag.value);
+        yield* literal("\n");
+      }
+    }
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await tags.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([tags.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/tags.ts
+var relns = "http://schemas.openxmlformats.org/package/2006/relationships";
+function validateTagOptions(options, action) {
+  if (!options || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((key) => !["scope", "selection", "name", "value", "allowEmpty"].includes(key)) || options.scope !== void 0 && !["presentation", "slides"].includes(options.scope) || options.allowEmpty !== void 0 && typeof options.allowEmpty !== "boolean") invalid("Invalid tag options.");
+  if (options.scope === "presentation" && options.selection && Object.keys(options.selection).some((key) => key !== "all" && key !== "token")) invalid("Presentation tags do not accept slide selectors.");
+  if (action === "add" && (options.name === void 0 || options.value === void 0)) invalid("New tags require name and value.");
+  if (action === "set" && options.name === void 0 && options.value === void 0) invalid("A tag edit requires name or value.");
+  for (const value of [options.name, options.value]) {
+    if (value === void 0) continue;
+    if (typeof value !== "string") invalid("Tag fields require strings.");
+    for (const c of value) {
+      const n = c.codePointAt(0);
+      if (n < 32 && ![9, 10, 13].includes(n) || n >= 55296 && n <= 57343 || n === 65534 || n === 65535) invalid("Tag fields require XML characters.");
+    }
+  }
+  if (options.name === "") invalid("Tag names cannot be empty.");
+  if (!action && (options.name !== void 0 || options.value !== void 0 || options.allowEmpty !== void 0)) invalid("Tag reads accept selection and scope only.");
+  if (action === "remove" && (options.name !== void 0 || options.value !== void 0)) invalid("Tag removal does not accept edit fields.");
+}
+function owners(s, options) {
+  if (options.scope === "presentation") return [{ part: s.main, slide: null }];
+  const selection = options.selection;
+  return (selection ? s.index.select({ kind: "slide", ...selection }) : s.index.slides).map((record) => {
+    if (record.kind !== "slide") throw new SelectionError("invalid-selection");
+    return { part: record.part, slide: record.position };
+  });
+}
+function association(s, owner) {
+  const doc = s.doc(owner);
+  const base = owner === s.main ? doc.root : child(doc.root, "cSld");
+  if (!base) invalid("Tag owner lacks common slide data.");
+  const list = child(base, "custDataLst");
+  const tags = list ? child(list, "tags") : void 0;
+  if (!tags) return void 0;
+  const id = tags.attributes.find((a) => a.name.namespace === s.r && a.name.localName === "id")?.value;
+  const edges = s.index.inventory.relationships.filter((e) => e.owner === owner && e.id === id && e.type === `${s.r}/tags` && !e.external);
+  if (edges.length !== 1 || !edges[0].targetPart) invalid("Invalid tag association.");
+  return edges[0].targetPart;
+}
+function records(s, options) {
+  let token;
+  if (options.selection?.token) {
+    if (Object.keys(options.selection).some((key) => key !== "token")) throw new SelectionError("invalid-selection");
+    token = decodeSelectionToken(options.selection.token);
+    if (token.fingerprint !== s.index.fingerprint) throw new SelectionError("stale-selection");
+    if (token.scope !== "slides" && token.scope !== "presentation") throw new SelectionError("invalid-selection");
+    if (options.scope !== void 0 && options.scope !== token.scope) throw new SelectionError("invalid-selection");
+  }
+  const selected = owners(s, token ? { scope: token.scope } : options);
+  const result = selected.flatMap((owner) => {
+    const part = association(s, owner.part);
+    if (!part) return [];
+    const doc = s.doc(part);
+    if (doc.root.name.namespace !== s.p || doc.root.name.localName !== "tagLst") invalid("Invalid tag list.");
+    return doc.root.children.flatMap((node, index) => {
+      if (node.name.namespace !== s.p || node.name.localName !== "tag") return [];
+      const name = attr(node, "name"), value = attr(node, "val");
+      if (name === void 0 || value === void 0) invalid("Tag requires name and value attributes.");
+      const location = { fingerprint: s.index.fingerprint, scope: owner.slide === null ? "presentation" : "slides", owner: owner.part, objectId: `tag:${part}:${index}`, coordinateSystem: "identity" };
+      return [{ name, value, part, owner: owner.part, slide: owner.slide, selector: JSON.stringify(location), location }];
+    });
+  });
+  return token ? result.filter((r) => r.selector === options.selection.token) : result;
+}
+async function readTags(input, options, context) {
+  validateTagOptions(options);
+  return records(await loadShared(input, context, false), options);
+}
+function createAssociation(s, owner, context) {
+  let n = 1;
+  while (s.reader.has(`/ppt/tags/tag${n}.xml`) || s.changes.has(`/ppt/tags/tag${n}.xml`)) n++;
+  const part = `/ppt/tags/tag${n}.xml`;
+  s.save(part, parseXmlPart(new TextEncoder().encode(`<p:tagLst xmlns:p="${s.p}"/>`), context.xmlLimits));
+  const types = s.doc("/[Content_Types].xml");
+  s.save("/[Content_Types].xml", types.spliceChildren(types.root, types.root.children.length, 0, [`<Override xmlns="${types.root.name.namespace}" PartName="${part}" ContentType="application/vnd.openxmlformats-officedocument.presentationml.tags+xml"/>`]));
+  const relName = relPart(owner);
+  const rels = s.reader.has(relName) ? s.doc(relName) : parseXmlPart(new TextEncoder().encode(`<Relationships xmlns="${relns}"/>`), context.xmlLimits);
+  const id = nextRel(rels);
+  s.save(relName, rels.spliceChildren(rels.root, rels.root.children.length, 0, [`<Relationship xmlns="${relns}" Id="${id}" Type="${s.r}/tags" Target="${escape(relativePartReference(part, owner.slice(0, owner.lastIndexOf("/"))))}"/>`]));
+  let doc = s.doc(owner);
+  let base = owner === s.main ? doc.root : child(doc.root, "cSld");
+  let list = child(base, "custDataLst");
+  if (!list) {
+    const order = owner === s.main ? ["sldMasterIdLst", "notesMasterIdLst", "handoutMasterIdLst", "sldIdLst", "sldSz", "notesSz", "smartTags", "embeddedFontLst", "custShowLst", "photoAlbum", "custDataLst", "kinsoku", "defaultTextStyle", "modifyVerifier", "extLst"] : ["bg", "spTree", "custDataLst", "controls", "extLst"];
+    doc = doc.merge(base, { children: { sequence: order.map((localName) => ({ namespace: s.p, localName })), upsert: [{ name: { namespace: s.p, localName: "custDataLst" }, merge: {} }] } });
+    base = owner === s.main ? doc.root : child(doc.root, "cSld");
+    list = child(base, "custDataLst");
+  }
+  s.save(owner, doc.spliceChildren(list, list.children.length, 0, [`<p:tags xmlns:p="${s.p}" xmlns:r="${s.r}" r:id="${id}"/>`]));
+  return part;
+}
+async function mutateTags(input, action, options, context) {
+  if (!["add", "set", "remove"].includes(action)) invalid("Invalid tag action.");
+  validateTagOptions(options, action);
+  if ((options.name?.length ?? 0) + (options.value?.length ?? 0) > context.xmlLimits.maxBytes) throw new OfficeError("resource-limit", "Tag exceeds XML limits.", "usage");
+  if (!options.selection && options.scope !== "presentation") throw new SelectionError("missing-selection");
+  const s = await loadShared(input, context);
+  const existing = records(s, options);
+  const locations = [];
+  if (action === "add") {
+    if (options.selection?.token) throw new SelectionError("invalid-selection");
+    const selected = owners(s, options);
+    if (!selected.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+    for (const owner of selected) {
+      if (existing.some((r) => r.owner === owner.part && r.name === options.name)) invalid("Duplicate tag name.");
+      const part = association(s, owner.part) ?? createAssociation(s, owner.part, context);
+      if (s.index.inventory.relationships.filter((e) => e.targetPart === part).length > 1) throw new OfficeError("unsupported-edit", "Shared tag lists cannot be edited.", "validate-intent");
+      const doc = s.doc(part);
+      const location = { fingerprint: s.index.fingerprint, scope: owner.slide === null ? "presentation" : "slides", owner: owner.part, objectId: `tag:${part}:${doc.root.children.length}`, coordinateSystem: "identity" };
+      s.save(part, doc.spliceChildren(doc.root, doc.root.children.length, 0, [`<p:tag xmlns:p="${s.p}" name="${escape(options.name)}" val="${escape(options.value)}"/>`]));
+      locations.push(location);
+    }
+  } else {
+    if (!existing.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+    if (existing.length > 1 && !options.selection?.all) throw new SelectionError("ambiguous-selection");
+    if (options.name !== void 0) {
+      const all = records(s, { scope: existing[0]?.location.scope });
+      for (const record of existing) if (all.some((r) => r.owner === record.owner && r.name === options.name && r.selector !== record.selector)) invalid("Duplicate tag name.");
+      if (existing.some((r, i) => existing.slice(0, i).some((v) => v.owner === r.owner))) invalid("Duplicate tag name.");
+    }
+    for (const record of [...existing].reverse()) {
+      if (s.index.inventory.relationships.filter((e) => e.targetPart === record.part).length > 1) throw new OfficeError("unsupported-edit", "Shared tag lists cannot be edited.", "validate-intent");
+      const doc = s.doc(record.part);
+      const index = Number(record.location.objectId.slice(record.location.objectId.lastIndexOf(":") + 1));
+      const node = doc.root.children[index];
+      if (action === "remove" && (node.children.length || node.attributes.some((a) => a.name.namespace !== "" || !["name", "val"].includes(a.name.localName)))) throw new OfficeError("unsupported-edit", "Decorated tags are preserved on removal.", "validate-intent");
+      s.save(record.part, action === "remove" ? doc.spliceChildren(doc.root, index, 1, []) : doc.merge(doc.root.children[index], { attributes: [...options.name === void 0 ? [] : [{ namespace: "", localName: "name", value: options.name }], ...options.value === void 0 ? [] : [{ namespace: "", localName: "val", value: options.value }]] }));
+      locations.push(record.location);
+    }
+  }
+  const result = await s.finish(s.main, []);
+  return { bytes: result.bytes, affected: locations.length, locations };
+}
+
+export {
+  openRetainedTags,
+  stageRetainedTags,
+  validateTagOptions,
+  readTags,
+  mutateTags
+};

package/dist/safe-bash/command-chunks/{chunk-DZH54L3F.js → chunk-ZM7HMBAJ.js}

@@ -1,15 +1,15 @@
+import {
+  validateDocxSelection
+} from "./chunk-NJ4EIA57.js";
 import {
   validateDocxOptionRules
-} from "./chunk-ROL5AEX6.js";
+} from "./chunk-VVV45NLY.js";
 import {
   normalizeDocxPropertyOptions
-} from "./chunk-Q7UZTMF4.js";
+} from "./chunk-GAROGIVU.js";
 import {
   partProviderReceivers
-} from "./chunk-OVEPYULA.js";
-import {
-  validateDocxSelection
-} from "./chunk-NJ4EIA57.js";
+} from "./chunk-BKK4MS3V.js";
 import {
   assertDocxFields,
   docxCommonOptions,
@@ -17,13 +17,13 @@ import {
   docxOperationSchemas,
   splitDocxType,
   validateDocxValue
-} from "./chunk-RIKNMBLZ.js";
-import {
-  BoundsError
-} from "./chunk-OBK24KGM.js";
+} from "./chunk-FEKECRJP.js";
 import {
   decodeLocation
 } from "./chunk-AW2RHM4G.js";
+import {
+  BoundsError
+} from "./chunk-OBK24KGM.js";
 import {
   DocxUsageError,
   copyDocxBytes,

package/dist/safe-bash/command-chunks/{chunk-NFGCBQN3.js → chunk-ZNCPIZCN.js}

@@ -1,10 +1,10 @@
 import {
   attr,
   child
-} from "./chunk-ADHFF2IM.js";
+} from "./chunk-A5SPMSKD.js";
 import {
   OfficeError
-} from "./chunk-CXME4YHU.js";
+} from "./chunk-KM2SMMXZ.js";
 
 // packages/safe-bash-presentation-engine/src/shape-paths.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-HKGNBH7Z.js → chunk-ZRHKXN6W.js}

@@ -1,12 +1,12 @@
 import {
   zstdDecode
-} from "./chunk-TI52LKLL.js";
-import {
-  boundedCodec
-} from "./chunk-RUXY7GN5.js";
+} from "./chunk-UVM6QG2H.js";
 import {
   gunzipMembers
 } from "./chunk-52DDLGBS.js";
+import {
+  boundedCodec
+} from "./chunk-RUXY7GN5.js";
 import {
   CodecReader,
   codec

package/dist/safe-bash/command-chunks/{chunk-A45UG4KT.js → chunk-ZZERSKAR.js}

@@ -1,7 +1,7 @@
 import {
   NumberingGraph,
   listProperties
-} from "./chunk-WBKB7HBZ.js";
+} from "./chunk-FHQOFEQK.js";
 import {
   Comment,
   Comments,
@@ -24,10 +24,10 @@ import {
   _Header,
   _Row,
   _Rows
-} from "./chunk-NYFYTL5G.js";
+} from "./chunk-345YBIHP.js";
 import {
   acquireImageModelInput
-} from "./chunk-ZXELXF2H.js";
+} from "./chunk-IZ3SD5S2.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
@@ -41,7 +41,7 @@ import {
   paragraphUnits,
   replaceListPropertyXml,
   runElementOpen
-} from "./chunk-Y7AXMCFV.js";
+} from "./chunk-LZY46GYY.js";
 import {
   dialectForNamespace,
   documentDialects
@@ -54,7 +54,7 @@ import {
   isEnumMember,
   isLength,
   plainLength
-} from "./chunk-RIKNMBLZ.js";
+} from "./chunk-FEKECRJP.js";
 import {
   parseDocumentXml
 } from "./chunk-3A7KNHOR.js";

package/dist/safe-bash/command-chunks/{clipboard-BBDK33GP-QZ4ERNQX.js → clipboard-BBDK33GP-VB22F7GI.js}

@@ -4,9 +4,9 @@ import {
   Vr,
   Yn,
   gn
-} from "./chunk-W2FKFEVY.js";
-import "./chunk-5V3TE7XU.js";
+} from "./chunk-4YSBUQPV.js";
 import "./chunk-YXIB6JV5.js";
+import "./chunk-5V3TE7XU.js";
 import "./chunk-VO6Q3KKZ.js";
 import "./chunk-Z7ESJVFP.js";
 import "./chunk-2BKOSQD3.js";

package/dist/safe-bash/command-chunks/{command-engine-M7S4QIXV.js → command-engine-2QXVRRH3.js}

@@ -12,6 +12,8 @@ import {
 import "./chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-pptx/src/command-engine.ts
+import { stageRetainedTags } from "../../safe-bash-presentation-engine/tags.js";
+import { stageRetainedProperties } from "../../safe-bash-presentation-engine/properties.js";
 import { stageRetainedNotes } from "../../safe-bash-presentation-engine/notes.js";
 
 // packages/safe-bash-command-pptx/src/retained-pack-manifest.ts
@@ -4332,7 +4334,7 @@ async function executePackageCommand(args, request, options2) {
 
 // packages/safe-bash-command-pptx/src/command-diff.ts
 import { OfficeError as OfficeError8 } from "../../safe-bash-presentation-engine/errors.js";
-import { comparePresentations } from "../../safe-bash-presentation-engine/diff.js";
+import { comparePresentations, stageRetainedDiff } from "../../safe-bash-presentation-engine/diff.js";
 
 // packages/safe-bash-command-pptx/src/diff-schema.ts
 var diffModes = [
@@ -4436,6 +4438,7 @@ async function executeDiffCommand(request, options2) {
   let result;
   let human = "";
   let exitCode = 0;
+  let staged;
   const failure = (error) => {
     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");
@@ -4547,32 +4550,62 @@ async function executeDiffCommand(request, options2) {
           "usage"
         );
       const maxBytes = Math.min(context.limits.maxBytes, context.archiveLimits.maxArchiveBytes);
-      const left = await request.readInput(positionals[0], maxBytes);
-      request.signal.throwIfAborted();
-      const right = await request.readInput(positionals[1], maxBytes);
-      const data = await comparePresentations(left, right, { mode }, context);
-      result = {
-        version: 1,
-        operation: "diff",
-        ok: true,
-        data,
-        affected: 0,
-        warnings: [],
-        errors: [],
-        locations: []
-      };
-      exitCode = data.equal ? 0 : 1;
-      human = `${data.equal ? "Equal" : "Different"} (${data.mode}; ${data.formatting} formatting)
+      if (request.streaming) {
+        const left = await request.streaming.openInput(positionals[0], maxBytes);
+        request.signal.throwIfAborted();
+        const right = await request.streaming.openInput(positionals[1], maxBytes);
+        try {
+          staged = await stageRetainedDiff(left, right, { mode, json, maxOutputBytes }, { ...context, workingStorage: request.streaming.workingStorage });
+        } catch (error) {
+          if (error instanceof OfficeError8 && error.code === "resource-limit" && error.phase === "publish") throw new OfficeError8("resource-limit", "Comparison output limit exceeded.", "admit");
+          throw error;
+        }
+        exitCode = staged.equal ? 0 : 1;
+        result = { version: 1, operation: "diff", ok: true, data: null, affected: 0, warnings: [], errors: [], locations: [] };
+      } else {
+        const left = await request.readInput(positionals[0], maxBytes);
+        request.signal.throwIfAborted();
+        const right = await request.readInput(positionals[1], maxBytes);
+        const data = await comparePresentations(left, right, { mode }, context);
+        result = {
+          version: 1,
+          operation: "diff",
+          ok: true,
+          data,
+          affected: 0,
+          warnings: [],
+          errors: [],
+          locations: []
+        };
+        exitCode = data.equal ? 0 : 1;
+        human = `${data.equal ? "Equal" : "Different"} (${data.mode}; ${data.formatting} formatting)
 ` + data.changes.map(
-        (change) => `${change.category} ${change.kind} ${change.id}
+          (change) => `${change.category} ${change.kind} ${change.id}
   before: ${JSON.stringify(change.before)}
   after: ${JSON.stringify(change.after)}
 `
-      ).join("");
+        ).join("");
+      }
     }
   } catch (error) {
     result = failure(error);
   }
+  if (staged) {
+    let failed = false;
+    try {
+      await staged.output.write(request.streaming.stdout);
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      try {
+        await staged.output.close();
+      } catch (error) {
+        if (!failed) await Promise.reject(error);
+      }
+    }
+    return { exitCode, stdout: new Uint8Array(), stderr: new Uint8Array() };
+  }
   let bytes = encoder.encode(json ? JSON.stringify(result) + "\n" : human);
   if (bytes.length > maxOutputBytes) {
     result = failure(
@@ -12081,8 +12114,8 @@ 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 === "text.frames.list" || args.operation === "text.frames.get" || args.operation === "notes.list" || args.operation === "notes.get" || args.operation === "xml.get") && request.streaming) {
-      if (args.token && args.operation !== "notes.list" && args.operation !== "notes.get") decodeSelectionToken2(args.token);
+    } 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 === "notes.list" || args.operation === "notes.get" || args.operation === "properties.list" || args.operation === "properties.get" || args.operation === "tags.list" || args.operation === "tags.get" || args.operation === "xml.get") && request.streaming) {
+      if (args.token && args.operation !== "notes.list" && args.operation !== "notes.get" && args.operation !== "tags.list" && args.operation !== "tags.get") 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();
       for await (const bytes of input.stream()) {
@@ -12094,8 +12127,11 @@ async function executeRequest(request, options2, owned) {
       const archive = await openPackageArchive(input, context);
       let failed = false;
       try {
-        const scope = args.operation === "notes.list" || args.operation === "notes.get" ? void 0 : args.token ? decodeSelectionToken2(args.token).scope : args.scope;
-        stagedOutput = args.operation === "notes.list" || args.operation === "notes.get" ? await stageRetainedNotes(archive, fingerprint, { selection: {
+        const scope = args.operation === "notes.list" || args.operation === "notes.get" || args.operation === "tags.list" || args.operation === "tags.get" ? void 0 : args.token ? decodeSelectionToken2(args.token).scope : args.scope;
+        stagedOutput = args.operation === "tags.list" || args.operation === "tags.get" ? await stageRetainedTags(archive, fingerprint, {
+          ...args.scope === void 0 ? {} : { scope: args.scope },
+          ...args.token ? { selection: { token: args.token } } : args.slide === void 0 ? args.all ? { selection: { all: true } } : {} : { selection: { kind: "slide", position: { coordinateSystem: "one-based", value: args.slide }, ...args.all ? { all: true } : {} } }
+        }, context, { operation: args.operation, json: args.json, maxOutputBytes: options2.maxOutputBytes }) : args.operation === "properties.list" || args.operation === "properties.get" ? await stageRetainedProperties(archive, fingerprint, args.metadataName === void 0 ? {} : { name: args.metadataName }, context, { operation: args.operation, json: args.json, maxOutputBytes: options2.maxOutputBytes }) : args.operation === "notes.list" || args.operation === "notes.get" ? await stageRetainedNotes(archive, fingerprint, { selection: {
           kind: "slide",
           ...args.token ? { token: args.token } : {},
           ...args.slide === void 0 ? {} : { position: { coordinateSystem: "one-based", value: args.slide } },