@poe-platform/safe-bash 0.1.816 → 0.1.817

package/dist/safe-bash/command-chunks/{chunk-DBZCTL7C.js → chunk-UYZ6EFZE.js}

@@ -1,6 +1,7 @@
 import {
+  StoredNamespaces,
   StoredXmlDocument
-} from "./chunk-RINR7XPR.js";
+} from "./chunk-E64ZI2YB.js";
 import {
   escape
 } from "./chunk-IJE65P52.js";
@@ -139,7 +140,7 @@ function declaration(source) {
   }
   return result + "?>\n";
 }
-async function attributes(element, source, inherited, budget, exclusive, stored) {
+async function attributes(element, source, namespaces, inherited, budget, exclusive, stored) {
   const selected = stored ? new StoredAttributes(stored.storage, budget) : [];
   for await (const attribute of source()) {
     {
@@ -151,7 +152,7 @@ async function attributes(element, source, inherited, budget, exclusive, stored)
       else await selected.append(attribute);
     }
   }
-  for (const [prefix, uri] of element.namespaces) {
+  for await (const [prefix, uri] of namespaces) {
     {
       const _p = budget.tick(uri.length + prefix.length + 1);
       if (_p) await _p;
@@ -169,7 +170,7 @@ async function attributes(element, source, inherited, budget, exclusive, stored)
       }
       if (!used) continue;
     }
-    if (uri === (inherited.get(prefix) ?? "")) continue;
+    if (uri === (await inherited.get(prefix) ?? "")) continue;
     const attribute = {
       name: prefix ? `xmlns:${prefix}` : "xmlns",
       namespace: xmlns,
@@ -200,7 +201,6 @@ var StoredFrames = class {
   }
   document;
   head = 0;
-  namespaces = /* @__PURE__ */ new WeakMap();
   async store(value) {
     const bytes = new TextEncoder().encode(JSON.stringify(value));
     const header = new Uint8Array(8);
@@ -219,11 +219,8 @@ var StoredFrames = class {
     for await (const frame of source) {
       const checkpoint = this.document.budget.tick();
       if (checkpoint) await checkpoint;
-      let namespaces = this.namespaces.get(frame.namespaces);
-      if (namespaces === void 0) {
-        namespaces = await this.store([...frame.namespaces]);
-        this.namespaces.set(frame.namespaces, namespaces);
-      }
+      if (!(frame.namespaces instanceof StoredNamespaces)) throw new TypeError("Stored frames require backed namespace scopes");
+      const namespaces = frame.namespaces.reference;
       const value = await this.store({ ...frame, namespaces });
       const link = new Uint8Array(16), view = new DataView(link.buffer);
       view.setFloat64(0, reversed, true);
@@ -247,8 +244,7 @@ var StoredFrames = class {
     const view = new DataView(link.buffer, link.byteOffset, 16);
     this.head = view.getFloat64(0, true);
     const frame = await this.load(view.getFloat64(8, true));
-    const namespaces = new Map(await this.load(frame.namespaces));
-    this.namespaces.set(namespaces, frame.namespaces);
+    const namespaces = new StoredNamespaces(this.document.storage, this.document.budget, frame.namespaces);
     return { ...frame, namespaces };
   }
 };
@@ -272,6 +268,9 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
     if (typeof reference === "number") yield* stored.attributes(reference);
     else if (reference.kind === "element") yield* reference.attributes;
   }
+  async function namespaceScope(reference, element) {
+    return typeof reference === "number" ? stored.namespaceScope(reference) : element.namespaces;
+  }
   const root = await load(rootReference);
   const canonical = mode !== "format";
   const documentDeclaration = options.declaration ?? root.declaration;
@@ -302,7 +301,7 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
         const p = budget.tick();
         if (p) await p;
       }
-      for (const [prefix, uri] of element.namespaces) {
+      for await (const [prefix, uri] of await namespaceScope(reference, element)) {
         {
           const p = budget.tick(uri.length + prefix.length + 1);
           if (p) await p;
@@ -317,7 +316,7 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
       }
     }
   } else yield declaration(documentDeclaration);
-  const namespaces = /* @__PURE__ */ new Map([["xml", xml]]);
+  const namespaces = stored ? await new StoredNamespaces(stored.storage, budget).set("xml", xml) : /* @__PURE__ */ new Map([["xml", xml]]);
   async function* siblings() {
     if (stored) yield* stored.children(stored.document);
     else {
@@ -430,7 +429,7 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
         count++;
         mixed = child.mixed;
       }
-      const ordered = canonical ? await attributes(current, () => elementAttributes(reference), frame.namespaces, budget, mode === "exc-c14n", stored) : [];
+      const ordered = canonical ? await attributes(current, () => elementAttributes(reference), await namespaceScope(reference, current), frame.namespaces, budget, mode === "exc-c14n", stored) : [];
       async function* outputAttributes() {
         if (canonical) yield* ordered;
         else for (const namespace of [true, false]) for await (const attribute of elementAttributes(reference)) {
@@ -444,9 +443,12 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
       yield `<${current.name}`;
       for await (const attribute of outputAttributes()) {
         if (canonical && attribute.namespace === xmlns) {
-          changed ??= new Map(frame.namespaces);
-          changed.set(attribute.localName, attribute.value);
-          childNamespaces = changed;
+          if (childNamespaces instanceof StoredNamespaces) childNamespaces = await childNamespaces.set(attribute.localName, attribute.value);
+          else {
+            changed ??= new Map(childNamespaces);
+            changed.set(attribute.localName, attribute.value);
+            childNamespaces = changed;
+          }
         }
         {
           const p = budget.tick();

package/dist/safe-bash/command-chunks/{chunk-B2C3UPJS.js → chunk-W42SUPD6.js}

@@ -18,6 +18,7 @@ import {
 // packages/safe-bash-command-apply-patch/src/apply.ts
 import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
 import {
+  collectBytes,
   createOutputOperation,
   dirname,
   readBytes,
@@ -398,7 +399,7 @@ var Invocation = class {
     for (const file of files) for (const path of [file.path, file.destination]) {
       if (!path) continue;
       const capabilities = await this.work.fs(path, async () => await this.fs.capabilitiesFor?.(path, { signal: this.context.signal }) ?? this.fs.capabilities);
-      if (capabilities.atomicFileMutation !== true || capabilities.retainedStagingWrite !== true || capabilities.retainedStagingCleanup !== true || capabilities.atomicStagedFileMutation !== true) throw new PatchError("filesystem does not support atomic conditional patch mutations");
+      if (capabilities.atomicFileMutation !== true || !this.fs.writeFileConditional && (capabilities.retainedStagingWrite !== true || capabilities.retainedStagingCleanup !== true || capabilities.atomicStagedFileMutation !== true)) throw new PatchError("filesystem does not support atomic conditional patch mutations");
       let parent = dirname(path);
       while (!await this.inspect(parent, false)) {
         await this.work.charge(1);
@@ -609,6 +610,17 @@ var Invocation = class {
   async write(path, output, parent, expected) {
     let staging;
     const signal = this.context.signal;
+    const capabilities = await this.work.fs(path, async () => await this.fs.capabilitiesFor?.(path, { signal }) ?? this.fs.capabilities);
+    if (capabilities.retainedStagingWrite !== true || capabilities.retainedStagingCleanup !== true || capabilities.atomicStagedFileMutation !== true) {
+      const bytes = await collectBytes(output.range(0, output.size), { signal, maxBytes: this.work.limits.maxFileBytes });
+      await this.work.fs(path, () => this.fs.writeFileConditional(path, bytes, {
+        parent,
+        expected: expected ?? null,
+        signal,
+        ...expected ? { mode: expected.mode & 4095 } : {}
+      }));
+      return;
+    }
     try {
       await this.work.fs(path, async () => {
         staging = await this.fs.createStagedFile(

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/{command-engine-GHE6QUHU.js → command-engine-2QXVRRH3.js}

@@ -12,6 +12,7 @@ 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";
 
@@ -12113,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 === "properties.list" || args.operation === "properties.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()) {
@@ -12126,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 === "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: {
+        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 } },

package/dist/safe-bash/command-chunks/{engine-RG6HQCCB-FXYZS264.js → engine-T4GP6QOK-ECFKMR5V.js}

@@ -1,7 +1,7 @@
 import {
   Si,
   gi
-} from "./chunk-K7VDCBXW.js";
+} from "./chunk-ABL2DPJI.js";
 import "./chunk-Z7ESJVFP.js";
 import "./chunk-WHWIZ2B7.js";
 import "./chunk-65DS4IOB.js";