@poe-platform/safe-bash 0.1.811 → 0.1.813

package/dist/safe-bash/command-chunks/{chunk-EHSM5ZQS.js → chunk-2DGJOOXM.js}

@@ -1,30 +1,30 @@
 import {
   drawingColorSchema,
   drawingUpdateSchema
-} from "./chunk-2CORNDGF.js";
+} from "./chunk-DBLHCJJU.js";
 import {
   MSO_LANGUAGE_ID
-} from "./chunk-COKYZUBW.js";
+} from "./chunk-AJI55RS7.js";
 import {
   MSO_TEXT_UNDERLINE_TYPE,
   validateTextRunOptions
-} from "./chunk-XZ2FWFNV.js";
+} from "./chunk-7QZ2HP2F.js";
 import {
   validateDrawingUpdate
-} from "./chunk-QYMEASQ6.js";
+} from "./chunk-BEHUSUOY.js";
 import {
   defineEnum,
   defineXmlEnum
-} from "./chunk-5HPU7D36.js";
+} from "./chunk-NMPED6L5.js";
 import {
   Length
-} from "./chunk-6QBMND4A.js";
+} from "./chunk-6SRHWVEB.js";
 import {
   PropertyAccessError
-} from "./chunk-S6R3IB36.js";
+} from "./chunk-D55REQA3.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/chart-font-operations.ts
 var owners = [

package/dist/safe-bash/command-chunks/{chunk-Q6S57NOQ.js → chunk-2E2H7MBH.js}

@@ -2,30 +2,30 @@ import {
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-TW73OXPR.js";
+} from "./chunk-EJTNVXWF.js";
 import {
   applyShapeUpdate,
   readShape
-} from "./chunk-IT7TAC3F.js";
+} from "./chunk-HVW53ARH.js";
 import {
   Length
-} from "./chunk-6QBMND4A.js";
+} from "./chunk-6SRHWVEB.js";
 import {
   attr,
   child,
   loadShared,
   required
-} from "./chunk-56NYSX65.js";
+} from "./chunk-2Z3WRRFT.js";
 import {
   SelectionError,
   readSelectionIndex
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-O675URF4.js";
 import {
   parseXmlPart
-} from "./chunk-554Z6IKP.js";
+} from "./chunk-7PRL6RJ6.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/shape-selection.ts
 var kinds = ["sp", "pic", "cxnSp", "graphicFrame", "grpSp"];

package/dist/safe-bash/command-chunks/{chunk-MMBZTYXO.js → chunk-2PQRZDNR.js}

@@ -1209,6 +1209,221 @@ var Pattern = class {
     const groups = captured ? [full, text.slice(groupStart, groupEnd)] : [full];
     return { start: found, end: matchEnd, groups };
   }
+  async supportsStoredTest(budget) {
+    await this.prepare(budget);
+    return (this.dialect === "sed" || this.dialect === "awk") && this.code.every((instruction) => instruction.kind === "character" || instruction.kind === "boundary" || instruction.kind === "match" || instruction.kind === "save" || instruction.kind === "jump" || instruction.kind === "split" || instruction.kind === "backreference" || (instruction.kind === "begin" || instruction.kind === "end") && !instruction.multiline && !instruction.trailingNewlines);
+  }
+  /** Replay captures as bounded spans; input-dependent search state belongs to the caller. */
+  async testStored(source, budget) {
+    if (!await this.supportsStoredTest(budget)) throw new ProgramError("pattern requires unsupported stored matching");
+    if (await this.supportsStreamTest(budget)) return this.testStream({ async *[Symbol.asyncIterator]() {
+      for (let position = 0; position < source.length; position += 4096) yield await source.read(position, Math.min(4096, source.length - position));
+    } }, budget);
+    const fields = 2 + (this.groupCount + 1) * 2;
+    if (fields * 16 > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    const checkpoint = async () => {
+      const pause = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+      if (pause) await pause;
+    };
+    await checkpoint();
+    for (let start = 0; start <= source.length; ) {
+      const initial = new Array(fields).fill(NaN);
+      initial[0] = 0;
+      initial[1] = start;
+      await source.enqueue(initial);
+      for (; ; ) {
+        budget.step();
+        await checkpoint();
+        const state = await source.dequeue();
+        if (!state) break;
+        const pc = state[0], position = state[1], instruction = this.code[pc];
+        const enqueue = async (next, at = position) => {
+          state[0] = next;
+          state[1] = at;
+          await source.enqueue(state);
+        };
+        if (instruction.kind === "match") {
+          await checkpoint();
+          return true;
+        }
+        if (instruction.kind === "character") {
+          const text2 = await source.read(position, Math.min(2, source.length - position));
+          if (text2) {
+            const character = String.fromCodePoint(text2.codePointAt(0));
+            if (instruction.accepts(character)) await enqueue(pc + 1, position + character.length);
+          }
+        } else if (instruction.kind === "backreference") {
+          const begin = state[2 + instruction.index * 2], end = state[3 + instruction.index * 2];
+          if (!Number.isFinite(begin) || !Number.isFinite(end) || position + end - begin > source.length) continue;
+          let matches = true;
+          for (let offset = 0; offset < end - begin && matches; ) {
+            const count = Math.min(4096, end - begin - offset);
+            const expected = await source.read(begin + offset, count), actual = await source.read(position + offset, count);
+            for (let index = 0; index < count; index++) {
+              if (instruction.ignoreCase ? expected[index].toLowerCase() !== actual[index].toLowerCase() : expected[index] !== actual[index]) {
+                matches = false;
+                break;
+              }
+            }
+            budget.step(count);
+            await checkpoint();
+            offset += count;
+          }
+          if (matches) await enqueue(pc + 1, position + end - begin);
+        } else if (instruction.kind === "split") {
+          await enqueue(instruction.first);
+          await enqueue(instruction.second);
+        } else if (instruction.kind === "jump") await enqueue(instruction.target);
+        else if (instruction.kind === "save") {
+          for (let slot = instruction.slot + 2; slot < Math.min(instruction.clearUntil ?? 0, fields - 2); slot++) state[slot + 2] = NaN;
+          state[instruction.slot + 2] = position;
+          await enqueue(pc + 1);
+        } else if (instruction.kind === "boundary") {
+          const before = position > 0 && instruction.accepts(await source.read(position - 1, 1));
+          const after = position < source.length && instruction.accepts(await source.read(position, 1));
+          const boundary = instruction.edge === "start" ? !before && after : instruction.edge === "end" ? before && !after : before !== after;
+          if (boundary === instruction.positive) await enqueue(pc + 1);
+        } else if (instruction.kind === "begin" ? position === 0 : position === source.length) await enqueue(pc + 1);
+      }
+      if (this.anchored || start === source.length) break;
+      const text = await source.read(start, Math.min(2, source.length - start));
+      start += text.codePointAt(0) > 65535 ? 2 : 1;
+    }
+    await checkpoint();
+    return false;
+  }
+  /** Existence-only streaming does not retain captures or the input text. */
+  async supportsStreamTest(budget) {
+    await this.prepare(budget);
+    return (this.dialect === "sed" || this.dialect === "awk") && this.code.every((instruction) => instruction.kind === "character" || instruction.kind === "boundary" || instruction.kind === "match" || instruction.kind === "save" || instruction.kind === "jump" || instruction.kind === "split" || (instruction.kind === "begin" || instruction.kind === "end") && !instruction.multiline && !instruction.trailingNewlines);
+  }
+  /** Working state is proportional to the compiled pattern, independent of input size. */
+  async testStream(source, budget) {
+    if (!await this.supportsStreamTest(budget)) throw new ProgramError("pattern requires non-streaming matching");
+    const initial = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (initial) await initial;
+    if (this.literalMatch) {
+      const { value, anchoredStart, anchoredEnd } = this.literalMatch;
+      if (value.length * 4 > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+      const prefix = new Uint32Array(value.length);
+      let units2 = 0;
+      const work = () => {
+        budget.step();
+        if (++units2 < 64) return;
+        units2 = 0;
+        return budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+      };
+      for (let index = 1, length = 0; index < value.length; index++) {
+        while (length && value[index] !== value[length]) {
+          length = prefix[length - 1];
+          const pause2 = work();
+          if (pause2) await pause2;
+        }
+        if (value[index] === value[length]) length++;
+        prefix[index] = length;
+        const pause = work();
+        if (pause) await pause;
+      }
+      let matched = 0, position = 0, lastEnd = value.length ? -1 : 0;
+      for await (const chunk of source) {
+        const pause = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+        if (pause) await pause;
+        if (!value.length && !anchoredEnd) return true;
+        for (let index = 0; index < chunk.length; index++) {
+          while (matched && chunk[index] !== value[matched]) {
+            matched = prefix[matched - 1];
+            const pause3 = work();
+            if (pause3) await pause3;
+          }
+          if (chunk[index] === value[matched]) matched++;
+          position++;
+          const pause2 = work();
+          if (pause2) await pause2;
+          if (matched === value.length) {
+            if (!anchoredStart || position === value.length) {
+              lastEnd = position;
+              if (!anchoredEnd) return true;
+            }
+            matched = matched ? prefix[matched - 1] : 0;
+          }
+        }
+      }
+      const final2 = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+      if (final2) await final2;
+      return anchoredEnd ? lastEnd === position : lastEnd >= 0;
+    }
+    if (this.code.length * 7 > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    let current = new Uint8Array(this.code.length), next = new Uint8Array(this.code.length);
+    const visited = new Uint8Array(this.code.length), pending = new Uint32Array(this.code.length);
+    let previous, beginning = true, units = 0;
+    const advance = async (character) => {
+      visited.fill(0);
+      next.fill(0);
+      let count = 0;
+      const push = (pc) => {
+        if (!visited[pc]) {
+          visited[pc] = 1;
+          pending[count++] = pc;
+        }
+      };
+      push(0);
+      budget.step(current.length);
+      for (let pc = 0; pc < current.length; pc++) if (current[pc]) push(pc);
+      while (count) {
+        budget.step();
+        if (++units === 64) {
+          units = 0;
+          const pause = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+          if (pause) await pause;
+        }
+        const pc = pending[--count], instruction = this.code[pc];
+        if (instruction.kind === "match") return true;
+        if (instruction.kind === "character") {
+          if (character !== void 0 && instruction.accepts(character)) next[pc + 1] = 1;
+        } else if (instruction.kind === "split") {
+          push(instruction.first);
+          push(instruction.second);
+        } else if (instruction.kind === "jump") push(instruction.target);
+        else if (instruction.kind === "save") push(pc + 1);
+        else if (instruction.kind === "begin") {
+          if (beginning) push(pc + 1);
+        } else if (instruction.kind === "end") {
+          if (character === void 0) push(pc + 1);
+        } else if (instruction.kind === "boundary") {
+          const before = previous !== void 0 && instruction.accepts(previous);
+          const after = character !== void 0 && instruction.accepts(character[0]);
+          const boundary = instruction.edge === "start" ? !before && after : instruction.edge === "end" ? before && !after : before !== after;
+          if (boundary === instruction.positive) push(pc + 1);
+        }
+      }
+      [current, next] = [next, current];
+      previous = character?.slice(-1);
+      beginning = false;
+      return false;
+    };
+    let high = "";
+    for await (const chunk of source) {
+      const pause = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+      if (pause) await pause;
+      let offset = 0;
+      if (high && chunk.length) {
+        const low = chunk.charCodeAt(0);
+        const character = low >= 56320 && low <= 57343 ? high + chunk[offset++] : high;
+        high = "";
+        if (await advance(character)) return true;
+      }
+      while (offset < chunk.length) {
+        const character = String.fromCodePoint(chunk.codePointAt(offset));
+        offset += character.length;
+        if (offset === chunk.length && character.length === 1 && character.charCodeAt(0) >= 55296 && character.charCodeAt(0) <= 56319) high = character;
+        else if (await advance(character)) return true;
+      }
+    }
+    const final = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (final) await final;
+    if (high && await advance(high)) return true;
+    return advance(void 0);
+  }
   async find(text, budget, from = 0, continuation = from) {
     this.assertInstructionLimit(budget);
     if (!this.code.length) await this.prepare(budget);
@@ -2225,6 +2440,12 @@ var BytePattern = class extends Pattern {
     if (this.usesUnicode(budget)) await this.unicode.prepare(budget);
     else await super.prepare(budget);
   }
+  async supportsStreamTest(budget) {
+    return !this.usesUnicode(budget) && await super.supportsStreamTest(budget);
+  }
+  async supportsStoredTest(budget) {
+    return !this.usesUnicode(budget) && await super.supportsStoredTest(budget);
+  }
   canFindSync() {
     return super.canFindSync() && this.unicode.canFindSync();
   }

package/dist/safe-bash/command-chunks/{chunk-5OO2P27R.js → chunk-2V6FOLXV.js}

@@ -1,41 +1,49 @@
 import {
-  openRetainedPresentationIndex
-} from "./chunk-L5MCW6CM.js";
+  stageRetainedArchive
+} from "./chunk-3D24WDND.js";
+import {
+  openPackageArchive
+} from "./chunk-KCE5D4Z4.js";
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-X64XGIXZ.js";
 import {
   writePackageArchive
-} from "./chunk-DM2CPMB4.js";
+} from "./chunk-HKOMXGJS.js";
 import {
   SelectionError,
   readSelectionIndex
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-O675URF4.js";
 import {
   readPackage
-} from "./chunk-XPD636C4.js";
+} from "./chunk-PVGZMLC6.js";
 import {
   readBinary
-} from "./chunk-PNGDJA6M.js";
+} from "./chunk-LD7BONZY.js";
 import {
   openRetainedPresentationValidation,
   validatePresentation
-} from "./chunk-RNSKXOG3.js";
+} from "./chunk-GVWVRPG6.js";
 import {
   openRetainedContentTypes,
   openRetainedRelationshipGraph
-} from "./chunk-QC5RMGSA.js";
+} from "./chunk-G3RUXKVY.js";
 import {
   parseXmlPart
-} from "./chunk-554Z6IKP.js";
+} from "./chunk-7PRL6RJ6.js";
 import {
   parseContentTypes
-} from "./chunk-WJCN2IXI.js";
+} from "./chunk-VQOINPVF.js";
 import {
   readRelationshipGraph
-} from "./chunk-ZMHEGDU2.js";
+} from "./chunk-TODWFDYB.js";
 import {
   asciiKey,
   partName,
   relativePartReference
-} from "./chunk-36XGIPOG.js";
+} from "./chunk-U5TWQFZY.js";
 import {
   OfficeError,
   RetainedValues,
@@ -45,7 +53,7 @@ import {
   openRetainedXmlDocument,
   resolveOfficeResources,
   stageRetainedXmlEdits
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/retained-slide-settings.ts
 import { PagedStorage } from "@poe-platform/safe-fs/storage";
@@ -188,20 +196,9 @@ async function openRetainedSlideSettings(archive, fingerprint, options, settings
     const presentation = await openRetainedXmlDocument(archive.read(index.records.main), resources);
     let failed = false;
     try {
-      let stack = pages.allocate(16);
-      await write(stack, [0, presentation.reference(presentation.root)]);
-      while (stack) {
-        const frame = await row(stack, 2);
-        stack = frame[0];
-        const node = await presentation.node(frame[1]);
-        if (node.kind !== "element") continue;
+      for await (const node of presentation.elements(presentation.root)) {
         if (await equal(presentation.namespace(node), literal("http://schemas.openxmlformats.org/markup-compatibility/2006"))) unsupported("Conditional presentation structure cannot be changed.");
         if (await equal(presentation.raw(node.localName), literal("modifyVerifier")) && await equal(presentation.namespace(node), presentation.namespace(presentation.root))) unsupported("Protected presentations cannot be changed.");
-        for await (const child2 of presentation.children(node)) {
-          const pointer = pages.allocate(16);
-          await write(pointer, [stack, presentation.reference(child2)]);
-          stack = pointer;
-        }
       }
     } catch (error) {
       failed = true;
@@ -325,6 +322,61 @@ async function openRetainedSlideSettings(archive, fingerprint, options, settings
   }
 }
 
+// packages/safe-bash-presentation-engine/src/retained-slide-publication.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+async function stageRetainedSlideSettings(input, options, settings, output) {
+  const signal = settings.signal ?? new AbortController().signal;
+  const hash = sha256.create();
+  for await (const bytes of input.stream()) {
+    signal.throwIfAborted();
+    hash.update(bytes);
+  }
+  const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const before = hex(hash.digest());
+  const archive = await openPackageArchive(input, settings);
+  let mutation, staged, response;
+  let closing;
+  const close = () => {
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([response?.close(), mutation?.close(), staged?.close(), archive.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  try {
+    mutation = await openRetainedSlideSettings(archive, before, options, settings);
+    staged = await stageRetainedArchive(input, before, archive, mutation, settings);
+    const { bytes, size, fingerprint } = staged;
+    async function* locations() {
+      for await (const location of mutation.targets()) yield { ...location, fingerprint };
+    }
+    async function* effects() {
+      if (fingerprint !== before) for await (const location of locations()) yield { location, action: "update", feature: "F07" };
+    }
+    const dryRun = output.dryRun;
+    async function* content() {
+      if (output.destination === "-" && !dryRun) {
+        yield* bytes();
+        return;
+      }
+      if (output.json) {
+        yield* streamJson({ version: 1, operation: "slides.set", ok: true, data: {
+          effects: effects(),
+          outputs: dryRun ? [] : [{ path: output.destination, sha256: fingerprint, bytes: size }],
+          fingerprint: dryRun ? null : fingerprint
+        }, warnings: [], errors: [], affected: mutation.affected, locations: locations() });
+        yield new TextEncoder().encode("\n");
+      } else yield new TextEncoder().encode(`${dryRun ? "Validated" : "Updated"} ${mutation.affected} slide(s)
+`);
+    }
+    response = await stageRetainedOutput(content(), settings, output.maxOutputBytes);
+    return Object.freeze({ bytes, size, fingerprint, output: response, close });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+
 // packages/safe-bash-presentation-engine/src/slides.ts
 var contentNamespace = "http://schemas.openxmlformats.org/package/2006/content-types";
 var packageRelationships = "http://schemas.openxmlformats.org/package/2006/relationships";
@@ -865,6 +917,7 @@ async function mutateSlides(input, options, context) {
 
 export {
   openRetainedSlideSettings,
+  stageRetainedSlideSettings,
   addSlide,
   prepareSlideInsertion,
   prepareSlideMutationOptions,

package/dist/safe-bash/command-chunks/{chunk-56NYSX65.js → chunk-2Z3WRRFT.js}

@@ -1,30 +1,30 @@
 import {
   writePackageArchive
-} from "./chunk-DM2CPMB4.js";
+} from "./chunk-HKOMXGJS.js";
 import {
   readSelectionIndex
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-O675URF4.js";
 import {
   readPackage
-} from "./chunk-XPD636C4.js";
+} from "./chunk-PVGZMLC6.js";
 import {
   readBinary
-} from "./chunk-PNGDJA6M.js";
+} from "./chunk-LD7BONZY.js";
 import {
   validatePresentation
-} from "./chunk-RNSKXOG3.js";
+} from "./chunk-GVWVRPG6.js";
 import {
   parseXmlPart
-} from "./chunk-554Z6IKP.js";
+} from "./chunk-7PRL6RJ6.js";
 import {
   parseContentTypes
-} from "./chunk-WJCN2IXI.js";
+} from "./chunk-VQOINPVF.js";
 import {
   relativePartReference
-} from "./chunk-36XGIPOG.js";
+} from "./chunk-U5TWQFZY.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/masters.ts
 var relns = "http://schemas.openxmlformats.org/package/2006/relationships";

package/dist/safe-bash/command-chunks/chunk-3D24WDND.js

@@ -0,0 +1,63 @@
+import {
+  OfficeError
+} from "./chunk-X6RHJ6YN.js";
+
+// packages/safe-bash-presentation-engine/src/retained-archive-staging.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+import { sha256 } from "@noble/hashes/sha2.js";
+async function stageRetainedArchive(input, originalFingerprint, archive, mutation, settings) {
+  const signal = settings.signal ?? new AbortController().signal;
+  let pages, closed = false, closing;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Archive output is closed.", "publish");
+    signal.throwIfAborted();
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= pages?.close() ?? Promise.resolve();
+  };
+  const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  try {
+    let size = input.size, fingerprint = originalFingerprint, start = 0;
+    if (mutation.changed) {
+      const working = settings.workingStorage;
+      pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+      start = pages.allocate(0);
+      size = 0;
+      const digest = sha256.create();
+      await archive.rewrite({ async write(bytes2) {
+        check();
+        for (let offset = 0; offset < bytes2.length; offset += 16384) {
+          check();
+          const owned = new Uint8Array(bytes2.subarray(offset, offset + 16384));
+          await pages.append(owned);
+          digest.update(owned);
+          size += owned.length;
+        }
+      } }, { replace: mutation.replacement, sourceOrder: "name" });
+      fingerprint = hex(digest.digest());
+    }
+    async function* bytes() {
+      check();
+      if (!pages) {
+        yield* input.stream();
+        check();
+        return;
+      }
+      for (let offset = 0; offset < size; offset += 16384) {
+        check();
+        yield await pages.read(start + offset, Math.min(16384, size - offset));
+      }
+      check();
+    }
+    return Object.freeze({ bytes, size, fingerprint, close });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+
+export {
+  stageRetainedArchive
+};