@poe-platform/safe-bash 0.1.814 → 0.1.816

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

@@ -1,13 +1,116 @@
 import {
   StoredXmlDocument
-} from "./chunk-PIVH35EQ.js";
+} from "./chunk-RINR7XPR.js";
 import {
   escape
-} from "./chunk-CSE4VQKG.js";
+} from "./chunk-IJE65P52.js";
 import {
   XmlQueryError
 } from "./chunk-3I5WTVWZ.js";
 
+// packages/safe-bash-xml-engine/src/stored-attributes.ts
+var StoredAttributes = class {
+  constructor(storage, budget) {
+    this.storage = storage;
+    this.budget = budget;
+  }
+  storage;
+  budget;
+  head = 0;
+  tail = 0;
+  async append(value) {
+    const source = JSON.stringify(value), encoder = new TextEncoder();
+    const header = new Uint8Array(16);
+    const reference = await this.storage.append(header);
+    let size = 0;
+    for (let offset = 0; offset < source.length; ) {
+      let end = Math.min(source.length, offset + 4096);
+      const last = source.charCodeAt(end - 1);
+      if (end < source.length && last >= 55296 && last <= 56319) end--;
+      const bytes = encoder.encode(source.slice(offset, end));
+      const checkpoint = this.budget.tick(bytes.length);
+      if (checkpoint) await checkpoint;
+      await this.storage.append(bytes);
+      size += bytes.length;
+      offset = end;
+    }
+    new DataView(header.buffer).setFloat64(8, size, true);
+    await this.storage.write(reference, header);
+    if (this.tail) await this.link(this.tail, reference);
+    else this.head = reference;
+    this.tail = reference;
+  }
+  async link(reference, next) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, next, true);
+    await this.storage.write(reference, bytes);
+  }
+  async next(reference) {
+    const bytes = await this.storage.read(reference, 8);
+    return new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, true);
+  }
+  async value(reference) {
+    const bytes = await this.storage.read(reference + 8, 8);
+    const size = new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, true);
+    const checkpoint = this.budget.tick(size);
+    if (checkpoint) await checkpoint;
+    const decoder = new TextDecoder(), parts = [];
+    for (let offset = 0; offset < size; offset += 16384)
+      parts.push(decoder.decode(await this.storage.read(reference + 16 + offset, Math.min(16384, size - offset)), { stream: true }));
+    parts.push(decoder.decode());
+    return JSON.parse(parts.join(""));
+  }
+  async sort(compare2) {
+    for (let width = 1; this.head; width *= 2) {
+      let left = this.head, head = 0, tail = 0, merges = 0;
+      while (left) {
+        merges++;
+        let right = left, leftCount = 0, rightCount = width;
+        for (; leftCount < width && right; leftCount++) right = await this.next(right);
+        let leftValue, rightValue;
+        while (leftCount || rightCount && right) {
+          const checkpoint = this.budget.tick();
+          if (checkpoint) await checkpoint;
+          let takeLeft = false;
+          if (leftCount) {
+            if (!rightCount || !right) takeLeft = true;
+            else {
+              leftValue ??= await this.value(left);
+              rightValue ??= await this.value(right);
+              const work = this.budget.tick(leftValue.namespace.length + leftValue.localName.length + rightValue.namespace.length + rightValue.localName.length + 1);
+              if (work) await work;
+              takeLeft = compare2(leftValue, rightValue) <= 0;
+            }
+          }
+          let selected;
+          if (takeLeft) {
+            selected = left;
+            left = await this.next(left);
+            leftCount--;
+            leftValue = void 0;
+          } else {
+            selected = right;
+            right = await this.next(right);
+            rightCount--;
+            rightValue = void 0;
+          }
+          if (tail) await this.link(tail, selected);
+          else head = selected;
+          tail = selected;
+        }
+        left = right;
+      }
+      await this.link(tail, 0);
+      this.head = head;
+      this.tail = tail;
+      if (merges <= 1) break;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for (let reference = this.head; reference; reference = await this.next(reference)) yield await this.value(reference);
+  }
+};
+
 // packages/safe-bash-xml-engine/src/document.ts
 var xmlns = "http://www.w3.org/2000/xmlns/";
 var xml = "http://www.w3.org/XML/1998/namespace";
@@ -36,14 +139,17 @@ function declaration(source) {
   }
   return result + "?>\n";
 }
-async function attributes(element, inherited, budget, exclusive) {
-  const selected = [];
-  for (const attribute of element.attributes) {
+async function attributes(element, source, inherited, budget, exclusive, stored) {
+  const selected = stored ? new StoredAttributes(stored.storage, budget) : [];
+  for await (const attribute of source()) {
     {
       const _p = budget.tick();
       if (_p) await _p;
     }
-    if (attribute.namespace !== xmlns) selected.push(attribute);
+    if (attribute.namespace !== xmlns) {
+      if (Array.isArray(selected)) selected.push(attribute);
+      else await selected.append(attribute);
+    }
   }
   for (const [prefix, uri] of element.namespaces) {
     {
@@ -54,33 +160,38 @@ async function attributes(element, inherited, budget, exclusive) {
     if (exclusive) {
       const colon = element.name.indexOf(":");
       let used = prefix === (colon < 0 ? "" : element.name.slice(0, colon));
-      for (const attribute of element.attributes) {
-        const p = budget.tick(attribute.name.length + 1);
+      for await (const attribute2 of source()) {
+        const p = budget.tick(attribute2.name.length + 1);
         if (p) await p;
-        if (attribute.namespace === xmlns) continue;
-        const at = attribute.name.indexOf(":");
-        if (at > 0 && attribute.name.slice(0, at) === prefix) used = true;
+        if (attribute2.namespace === xmlns) continue;
+        const at = attribute2.name.indexOf(":");
+        if (at > 0 && attribute2.name.slice(0, at) === prefix) used = true;
       }
       if (!used) continue;
     }
     if (uri === (inherited.get(prefix) ?? "")) continue;
-    selected.push({
+    const attribute = {
       name: prefix ? `xmlns:${prefix}` : "xmlns",
       namespace: xmlns,
       localName: prefix,
       value: uri
-    });
+    };
+    if (Array.isArray(selected)) selected.push(attribute);
+    else await selected.append(attribute);
   }
-  const comparisons = Math.ceil(Math.log2(selected.length + 1));
-  for (const attribute of selected)
-    await budget.tick((attribute.namespace.length + attribute.localName.length + 1) * comparisons);
-  selected.sort((left, right) => {
+  const ordering = (left, right) => {
     if (left.namespace === xmlns || right.namespace === xmlns) {
       if (left.namespace !== right.namespace) return left.namespace === xmlns ? -1 : 1;
       return compare(left.localName, right.localName);
     }
     return compare(left.namespace, right.namespace) || compare(left.localName, right.localName);
-  });
+  };
+  if (Array.isArray(selected)) {
+    const comparisons = Math.ceil(Math.log2(selected.length + 1));
+    for (const attribute of selected)
+      await budget.tick((attribute.namespace.length + attribute.localName.length + 1) * comparisons);
+    selected.sort(ordering);
+  } else await selected.sort(ordering);
   return selected;
 }
 var StoredFrames = class {
@@ -149,7 +260,7 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
   const stored = source instanceof StoredXmlDocument ? source : void 0;
   const rootReference = stored ? stored.root : source;
   const load = async (reference) => {
-    const node = typeof reference === "number" ? await stored.node(reference) : reference;
+    const node = typeof reference === "number" ? await stored.metadata(reference) : reference;
     if (node.kind === "attribute") throw new TypeError("Attribute used as XML content");
     return node;
   };
@@ -157,6 +268,10 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
     if (typeof reference === "number") yield* stored.children(reference);
     else if (reference.kind === "element") yield* reference.content;
   }
+  async function* elementAttributes(reference) {
+    if (typeof reference === "number") yield* stored.attributes(reference);
+    else if (reference.kind === "element") yield* reference.attributes;
+  }
   const root = await load(rootReference);
   const canonical = mode !== "format";
   const documentDeclaration = options.declaration ?? root.declaration;
@@ -299,7 +414,7 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
     if (current.kind === "element") {
       let preserveSpace = frame.preserveSpace;
       let preserveBlanks = frame.preserveBlanks;
-      for (const attribute of current.attributes) {
+      for await (const attribute of elementAttributes(reference)) {
         {
           const p = budget.tick();
           if (p) await p;
@@ -315,18 +430,24 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
         count++;
         mixed = child.mixed;
       }
-      const ordered = canonical ? await attributes(current, frame.namespaces, budget, mode === "exc-c14n") : [];
-      if (!canonical) {
-        for (const namespace of [true, false]) for (const attribute of current.attributes) {
-          {
-            const p = budget.tick();
-            if (p) await p;
-          }
-          if (attribute.namespace === xmlns === namespace) ordered.push(attribute);
+      const ordered = canonical ? await attributes(current, () => elementAttributes(reference), 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)) {
+          const p = budget.tick();
+          if (p) await p;
+          if (attribute.namespace === xmlns === namespace) yield attribute;
         }
       }
+      let childNamespaces = frame.namespaces;
+      let changed;
       yield `<${current.name}`;
-      for (const attribute of ordered) {
+      for await (const attribute of outputAttributes()) {
+        if (canonical && attribute.namespace === xmlns) {
+          changed ??= new Map(frame.namespaces);
+          changed.set(attribute.localName, attribute.value);
+          childNamespaces = changed;
+        }
         {
           const p = budget.tick();
           if (p) await p;
@@ -341,12 +462,6 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
       }
       yield ">";
       const indent = !canonical && format && !frame.inline && !mixed && count > 0;
-      let childNamespaces = frame.namespaces;
-      if (canonical && ordered.some((attribute) => attribute.namespace === xmlns)) {
-        const changed = new Map(frame.namespaces);
-        for (const attribute of ordered) if (attribute.namespace === xmlns) changed.set(attribute.localName, attribute.value);
-        childNamespaces = changed;
-      }
       const childFrame = { depth: frame.depth + 1, namespaces: childNamespaces, preserveSpace, preserveBlanks, inline: frame.inline || mixed };
       const parentFrame = frame;
       await push((async function* () {

package/dist/safe-bash/command-chunks/{chunk-6ZGCKUAM.js → chunk-DIRK47GT.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-77NXQZGK.js";
 import {
   Interpreter
-} from "./chunk-LNLACEAN.js";
+} from "./chunk-Y3ZRIZL7.js";
 import {
   Budget,
   JqLimitError,

package/dist/safe-bash/command-chunks/{chunk-WYZG3DRR.js → chunk-DM5WURQL.js}

@@ -3,11 +3,11 @@ import {
   paragraphUnits,
   runElementOpen,
   xmlValue
-} from "./chunk-Y7AXMCFV.js";
+} from "./chunk-LZY46GYY.js";
 import {
   storedBooleanValue,
   trimXmlWhitespace
-} from "./chunk-ET5SFGRH.js";
+} from "./chunk-QDV2NIFR.js";
 import {
   DocxUsageError
 } from "./chunk-WXMYTNWS.js";

package/dist/safe-bash/command-chunks/{chunk-EBHOZIBS.js → chunk-DOVWHVHI.js}

@@ -4,26 +4,26 @@ import {
   readConnector,
   removeDrawingObjects,
   validateConnectorUpdate
-} from "./chunk-NEMUPUUB.js";
+} from "./chunk-ICJH6A73.js";
 import {
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-MVLVIMJ6.js";
+} from "./chunk-LMLBQSAM.js";
 import {
   ShapeIdAllocator
-} from "./chunk-XMTR7QGL.js";
+} from "./chunk-X42MJT2J.js";
 import {
   child,
   loadShared,
   required
-} from "./chunk-ADHFF2IM.js";
+} from "./chunk-A5SPMSKD.js";
 import {
   SelectionError
-} from "./chunk-W3ZSWK76.js";
+} from "./chunk-NCNHJRIY.js";
 import {
   OfficeError
-} from "./chunk-CXME4YHU.js";
+} from "./chunk-KM2SMMXZ.js";
 
 // packages/safe-bash-presentation-engine/src/connector-operations.ts
 function optionsFor(options, action) {

package/dist/safe-bash/command-chunks/{chunk-GQGMQMIM.js → chunk-DXOXUKQB.js}

@@ -1,3 +1,8 @@
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-FB2WPI3M.js";
 import {
   attr,
   child,
@@ -7,22 +12,257 @@ import {
   nextRel,
   relPart,
   required
-} from "./chunk-ADHFF2IM.js";
+} from "./chunk-A5SPMSKD.js";
 import {
   SelectionError
-} from "./chunk-W3ZSWK76.js";
+} from "./chunk-NCNHJRIY.js";
+import {
+  openRetainedPresentationValidation
+} from "./chunk-6W4RMBFH.js";
+import {
+  dialects
+} from "./chunk-6KJDTKE4.js";
 import {
   parseXmlPart
-} from "./chunk-DBLQUZGN.js";
+} from "./chunk-7PYDVQPB.js";
 import {
   relativePartReference
-} from "./chunk-WTVJLHMG.js";
+} from "./chunk-MOUCMZZP.js";
 import {
-  OfficeError
-} from "./chunk-CXME4YHU.js";
+  OfficeError,
+  RetainedValues,
+  equal,
+  folded,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-KM2SMMXZ.js";
 
 // packages/safe-bash-presentation-engine/src/notes.ts
 import { SaxesParser } from "saxes";
+
+// packages/safe-bash-presentation-engine/src/retained-notes.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function openRetainedNotes(archive, fingerprint, options, settings, selectBeforeValidation = false) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((key) => key !== "selection"))
+    throw new OfficeError("invalid-value", "Invalid notes query.", "usage");
+  if (options.selection !== void 0 && (!options.selection || typeof options.selection !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options.selection))))
+    throw new SelectionError("invalid-selection");
+  const selection = options.selection === void 0 ? void 0 : { ...options.selection, kind: options.selection.kind ?? "slide", ...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, first = 0, last = 0, count = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Notes are closed.", "select");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "select");
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Notes storage operation failed.", "select");
+  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, field) => ({ start: row2[field], length: row2[field + 1] });
+  async function row(pointer) {
+    check();
+    const bytes = await pages.read(pointer, 11 /* Count */ * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: 11 /* 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 metadata(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();
+  }
+  try {
+    if (selectBeforeValidation && selection) for await (const record of index.records.select(selection)) {
+      void record;
+      check();
+    }
+    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], mainFailed = false;
+    try {
+      for (const candidate of dialects) if (await equal(main.namespace(main.root), literal(candidate.p))) dialect = candidate;
+    } catch (error) {
+      mainFailed = true;
+      throw error;
+    } finally {
+      try {
+        await main.close();
+      } catch (error) {
+        if (!mainFailed) await Promise.reject(error);
+      }
+    }
+    async function target(owner, kind, internal) {
+      for await (const edge of index.graph.outgoing(owner)) if ((!internal || !edge.external) && await equal(edge.type(), literal(`${dialect.r}/${kind}`))) {
+        if (!edge.targetPart) return void 0;
+        const original = await values.find("parts", () => folded(edge.targetPart()));
+        if (!original) throw new OfficeError("missing-binding", "Package member is absent.", "index");
+        return { name: await metadata(original), reference: await values.store(edge.targetPart()) };
+      }
+      return void 0;
+    }
+    if (selection) {
+      for await (const slide of index.records.select(selection)) if (slide.kind !== "slide") throw new SelectionError("invalid-selection");
+    }
+    for await (const slide of selection ? index.records.select(selection) : index.records.records("slide")) {
+      const part = await target(slide.part, "notesSlide", true);
+      if (!part) continue;
+      const document = await openRetainedXmlDocument(archive.read(part.name), { ...context, workingStorage: working });
+      let failed = false;
+      try {
+        async function is(node, local, namespace) {
+          return node.kind === "element" && await equal(document.raw(node.localName), literal(local)) && await equal(document.namespace(node), namespace);
+        }
+        async function child2(node, local) {
+          if (!node) return void 0;
+          let found;
+          for await (const candidate of document.children(node)) if (await is(candidate, local, document.namespace(node))) {
+            if (found) throw new OfficeError("invalid-value", "Ambiguous shared structure.", "usage");
+            found = candidate;
+          }
+          return found;
+        }
+        async function required2(node, local) {
+          const found = await child2(node, local);
+          if (!found) throw new OfficeError("unsupported-edit", "Unsupported shared structure.", "validate-intent");
+          return found;
+        }
+        async function attribute(node, local) {
+          if (node) {
+            for await (const candidate of document.attributes(node)) if (await equal(document.raw(candidate.localName), literal(local)) && await equal(document.namespace(candidate), literal(""))) return candidate;
+          }
+          return void 0;
+        }
+        const tree = await required2(await required2(document.root, "cSld"), "spTree");
+        let body2;
+        for await (const node of document.children(tree)) if (await is(node, "sp", document.namespace(document.root))) {
+          const placeholder2 = await child2(await child2(await child2(node, "nvSpPr"), "nvPr"), "ph"), type = await attribute(placeholder2, "type");
+          if (type && await equal(document.text(type), literal("body"))) {
+            if (body2) throw new OfficeError("ambiguous-selection", "Notes have multiple speaker bodies.", "select");
+            body2 = node;
+          }
+        }
+        const id = await attribute(await child2(await child2(body2, "nvSpPr"), "cNvPr"), "id"), textBody = await child2(body2, "txBody");
+        const idRange = id ? await values.store(document.text(id)) : { start: -1, length: 0 };
+        let drawing = dialects[0].a;
+        for (const candidate of dialects) if (await equal(document.namespace(document.root), literal(candidate.p))) drawing = candidate.a;
+        async function* speakerText2() {
+          let separator = false;
+          if (textBody) {
+            for await (const paragraph of document.children(textBody)) if (await is(paragraph, "p", literal(drawing))) {
+              if (separator) yield* literal("\n");
+              separator = true;
+              for await (const inline of document.children(paragraph)) {
+                if (await is(inline, "br", literal(drawing))) yield* literal("\v");
+                else if (await is(inline, "r", literal(drawing)) || await is(inline, "fld", literal(drawing))) {
+                  for await (const text2 of document.children(inline)) if (await is(text2, "t", literal(drawing))) yield* document.text(text2);
+                }
+              }
+            }
+          }
+        }
+        const text = textBody ? await values.store(speakerText2()) : { start: -1, length: 0 }, master = await target(part.name, "notesMaster", false);
+        if (!master) throw new OfficeError("invalid-opc", "Missing notes master.", "index");
+        const descriptor = await values.store(literal(JSON.stringify({ selector: slide.token, location: slide.location, slide: slide.position })));
+        const pointer = pages.allocate(11 /* Count */ * 8);
+        await write(pointer, [0, descriptor.start, descriptor.length, part.reference.start, part.reference.length, master.reference.start, master.reference.length, text.start, text.length, idRange.start, idRange.length]);
+        if (last) await write(last, [pointer]);
+        else first = pointer;
+        last = pointer;
+        count++;
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        try {
+          await document.close();
+        } catch (error) {
+          if (!failed) await Promise.reject(error);
+        }
+      }
+    }
+    await index.close();
+    check();
+    async function* records() {
+      try {
+        for (let pointer = first; pointer; ) {
+          const entry = await row(pointer), descriptor = JSON.parse(await metadata(range(entry, 1 /* Metadata */)));
+          yield {
+            ...descriptor,
+            part: () => values.read(range(entry, 3 /* Part */)),
+            master: () => values.read(range(entry, 5 /* Master */)),
+            text: entry[7 /* Text */] === -1 ? null : () => values.read(range(entry, 7 /* Text */)),
+            bodyShapeId: entry[9 /* Id */] === -1 ? null : () => values.read(range(entry, 9 /* Id */))
+          };
+          pointer = entry[0 /* Next */];
+        }
+        check();
+      } catch (error) {
+        throw failure(error);
+      }
+    }
+    return Object.freeze({ records, close, count });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+async function stageRetainedNotes(archive, fingerprint, options, settings, output) {
+  const format = { ...output }, notes = await openRetainedNotes(archive, fingerprint, options, settings, format.operation === "notes.get");
+  let staged;
+  async function* locations() {
+    for await (const note of notes.records()) yield note.location;
+  }
+  async function* render() {
+    if (format.json) {
+      yield* streamJson({ version: 1, operation: format.operation, ok: true, data: format.operation === "notes.get" && !notes.count ? null : { notes: notes.records() }, affected: 0, warnings: [], errors: [], locations: locations() });
+      yield* literal("\n");
+    } else for await (const note of notes.records()) {
+      yield* literal(`${note.slide}: `);
+      if (note.text) yield* note.text();
+      yield* literal("\n");
+    }
+  }
+  try {
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await notes.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([notes.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/notes.ts
 var relns = "http://schemas.openxmlformats.org/package/2006/relationships";
 function notesPart(s, slide) {
   return s.index.inventory.relationships.find(
@@ -366,6 +606,8 @@ async function mutateNotes(input, action, options, context) {
 }
 
 export {
+  openRetainedNotes,
+  stageRetainedNotes,
   readNotes,
   validateNotesOptions,
   mutateNotes

package/dist/safe-bash/command-chunks/{chunk-JR3Q6QNL.js → chunk-DZOKH5BL.js}

@@ -1,9 +1,9 @@
 import {
   admitImage
-} from "./chunk-7KZ5LWV2.js";
+} from "./chunk-4IDV763L.js";
 import {
   ShapeIdAllocator
-} from "./chunk-XMTR7QGL.js";
+} from "./chunk-X42MJT2J.js";
 import {
   child,
   escape,
@@ -11,19 +11,19 @@ import {
   nextRel,
   relPart,
   required
-} from "./chunk-ADHFF2IM.js";
+} from "./chunk-A5SPMSKD.js";
 import {
   SelectionError
-} from "./chunk-W3ZSWK76.js";
+} from "./chunk-NCNHJRIY.js";
 import {
   parseXmlPart
-} from "./chunk-DBLQUZGN.js";
+} from "./chunk-7PYDVQPB.js";
 import {
   relativePartReference
-} from "./chunk-WTVJLHMG.js";
+} from "./chunk-MOUCMZZP.js";
 import {
   OfficeError
-} from "./chunk-CXME4YHU.js";
+} from "./chunk-KM2SMMXZ.js";
 
 // packages/safe-bash-presentation-engine/src/image-insertion.ts
 function invalid(message) {