@poe-platform/safe-bash 0.1.811 → 0.1.813

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

@@ -0,0 +1,737 @@
+import {
+  openPackageArchive
+} from "./chunk-KCE5D4Z4.js";
+import {
+  boundedOutput,
+  openRetainedPresentationIndex,
+  rawJson,
+  streamJson
+} from "./chunk-X64XGIXZ.js";
+import {
+  RetainedOrder
+} from "./chunk-ZYLGNIGA.js";
+import {
+  loadShared
+} from "./chunk-2Z3WRRFT.js";
+import {
+  writePackageArchive
+} from "./chunk-HKOMXGJS.js";
+import {
+  readBinary
+} from "./chunk-LD7BONZY.js";
+import {
+  openRetainedPresentationValidation
+} from "./chunk-GVWVRPG6.js";
+import {
+  openRetainedContentTypes
+} from "./chunk-G3RUXKVY.js";
+import {
+  parseContentTypes
+} from "./chunk-VQOINPVF.js";
+import {
+  asciiKey,
+  partName
+} from "./chunk-U5TWQFZY.js";
+import {
+  PackageNotFoundError
+} from "./chunk-D55REQA3.js";
+import {
+  OfficeError,
+  RetainedValues,
+  characters,
+  digest,
+  equal,
+  folded,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-X6RHJ6YN.js";
+import {
+  createZipCodec
+} from "./chunk-IOEUZ4EA.js";
+
+// packages/safe-bash-presentation-engine/src/package-tools.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+
+// packages/safe-bash-presentation-engine/src/retained-package-extraction.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+var extensions = { "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/tiff": "tif", "image/bmp": "bmp", "audio/mpeg": "mp3", "video/mp4": "mp4" };
+async function openRetainedPackageExtraction(input, settings, options = {}) {
+  const context = resolveOfficeResources(settings), signal = context.signal ?? new AbortController().signal;
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some((key) => key !== "parts" || !("value" in Object.getOwnPropertyDescriptor(options, key))))
+    throw new OfficeError("invalid-value", "Expected a plain package record.", "usage");
+  const selected = options.parts;
+  if (selected !== void 0) {
+    if (!Array.isArray(selected) || !selected.length || Object.getPrototypeOf(selected) !== Array.prototype)
+      throw new OfficeError("invalid-value", "Invalid package extraction options.", "usage");
+    if (selected.length > context.archiveLimits.maxMembers) throw new OfficeError("resource-limit", "Package member limit exceeded.", "usage");
+    if (Reflect.ownKeys(selected).length !== selected.length + 1) throw new OfficeError("invalid-value", "Expected a dense package array.", "usage");
+    for (let n = 0; n < selected.length; n++) if (!Object.getOwnPropertyDescriptor(selected, String(n)) || !("value" in Object.getOwnPropertyDescriptor(selected, String(n))))
+      throw new OfficeError("invalid-value", "Expected a dense package array.", "usage");
+  }
+  const working = { ...settings.workingStorage }, cacheBytes = working.cacheBytes ?? 1024 * 1024;
+  if (!working.fs || typeof working.directory !== "string" || !working.directory.startsWith("/") || !Number.isSafeInteger(cacheBytes) || cacheBytes < 16384 || cacheBytes % 16384)
+    throw new OfficeError("invalid-value", "Explicit extraction storage and a valid cache budget are required.", "usage");
+  if (!input || typeof input.read !== "function" || typeof input.stream !== "function") throw new OfficeError("invalid-type", "An immutable retained input is required.", "usage");
+  const pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, cacheBytes / 16384);
+  let archive, index;
+  let validation, types;
+  let closed = false, closing, count = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Extraction is 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", "Extraction storage operation failed.", "select");
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([types?.close(), validation?.close(), index?.close(), archive?.close(), pages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal), order = new RetainedOrder(pages, values, check), requests = new RetainedOrder(pages, values, check);
+  async function text(range) {
+    const decoder = new TextDecoder();
+    let value = "";
+    for await (const bytes of values.read(range)) value += decoder.decode(bytes, { stream: true });
+    return value + decoder.decode();
+  }
+  try {
+    if (selected) for (let n = 0; n < selected.length; n++) {
+      check();
+      const name = selected[n], canonical = partName(name, false);
+      if (canonical !== name) throw new OfficeError("unsafe-path", "A canonical package part is required.", "usage");
+      const key = await values.store(folded(literal(name))), value = await values.store(literal(name));
+      if (!await values.insert("selected", key, value)) throw new OfficeError("invalid-value", "Duplicate extracted part.", "usage");
+      await requests.add(literal(String(n).padStart(16, "0")), value);
+    }
+    await requests.seal();
+    archive = await openPackageArchive(input, { ...context, workingStorage: working });
+    async function* original() {
+      check();
+      let iterator, exhausted = false, size = 0;
+      try {
+        iterator = input.stream()[Symbol.asyncIterator]();
+      } catch {
+        check();
+        throw new OfficeError("io-failure", "Byte input failed.", "admit");
+      }
+      try {
+        for (let reads = 0; reads < context.limits.maxReads; reads++) {
+          check();
+          let item;
+          try {
+            item = await iterator.next();
+          } catch (error) {
+            check();
+            if (error && typeof error === "object" && "code" in error) {
+              if (error.code === "ENOENT") throw new PackageNotFoundError();
+              if (error.code === "EFBIG") throw new OfficeError("resource-limit", "Byte input exceeds its limit.", "admit");
+            }
+            throw new OfficeError("io-failure", "Byte input failed.", "admit");
+          }
+          check();
+          if (item.done) {
+            exhausted = true;
+            if (size !== input.size) throw new OfficeError("io-failure", "Retained input size changed.", "admit");
+            return;
+          }
+          if (!(item.value instanceof Uint8Array)) throw new OfficeError("invalid-type", "Byte source returned an invalid chunk.", "admit");
+          if (item.value.length > input.size - size) throw new OfficeError("resource-limit", "Byte input exceeds its limit.", "admit");
+          size += item.value.length;
+          yield item.value;
+        }
+        throw new OfficeError("resource-limit", "Byte source exceeded its read limit.", "admit");
+      } finally {
+        if (!exhausted) try {
+          await iterator.return?.();
+        } catch {
+        }
+      }
+    }
+    const fingerprint = await digest(original());
+    index = await openRetainedPresentationIndex(archive, fingerprint, { ...context, workingStorage: working });
+    const limits = { ...context.xmlLimits, ...context.relationshipLimits, maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes), maxEntries: context.archiveLimits.maxMembers };
+    validation = await openRetainedPresentationValidation(archive, { ...context, workingStorage: working }, limits);
+    if (!validation.valid) throw new OfficeError("invalid-opc", "Invalid presentation graph.", "validate-intent");
+    types = await openRetainedContentTypes(archive.read("/[Content_Types].xml"), { ...context, workingStorage: working }, { maxBytes: context.xmlLimits.maxBytes, maxEntries: context.archiveLimits.maxMembers });
+    async function* names() {
+      if (selected) {
+        for await (const name of requests.entries()) yield await text(name);
+      } else {
+        const names2 = new RetainedOrder(pages, values, check);
+        for await (const name of archive.parts()) {
+          const value = await values.store(literal(name));
+          await names2.add(literal(name), value);
+        }
+        await names2.seal();
+        for await (const name of names2.entries()) yield await text(name);
+      }
+    }
+    for await (const part of names()) {
+      check();
+      const size = await archive.byteLength(part), hash = await digest(archive.read(part));
+      const type = await values.store(part === "/[Content_Types].xml" ? literal("application/xml") : await types.get(part));
+      let essence = "", suffix = "", pendingWhitespace = 0, overflow = false;
+      for await (const character of characters(values.read(type))) {
+        if (character === ";") break;
+        if (character.trim() === "") {
+          if (essence || overflow) pendingWhitespace++;
+          continue;
+        }
+        if (pendingWhitespace) {
+          if (essence.length + pendingWhitespace > 32) overflow = true;
+          else essence += " ".repeat(pendingWhitespace);
+          suffix = "";
+          pendingWhitespace = 0;
+        }
+        const lower = character.toLowerCase();
+        if (essence.length + lower.length > 32) overflow = true;
+        else if (!overflow) essence += lower;
+        suffix = (suffix + lower).slice(-4);
+      }
+      const extension = !overflow && (essence === "application/xml" || essence === "text/xml") || suffix === "+xml" ? "xml" : !overflow ? extensions[essence] ?? "bin" : "bin";
+      const name = `part-${String(++count).padStart(6, "0")}.${extension}`;
+      const partRange = await values.store(literal(part)), nameRange = await values.store(literal(name)), hashRange = await values.store(literal(hash));
+      const data = [partRange.start, partRange.length, nameRange.start, nameRange.length, hashRange.start, hashRange.length, type.start, type.length, size];
+      const bytes = new Uint8Array(data.length * 8), view = new DataView(bytes.buffer);
+      data.forEach((value, n) => view.setFloat64(n * 8, value, true));
+      const row = await values.store((async function* () {
+        yield bytes;
+      })());
+      await order.add(literal(String(count).padStart(16, "0")), row);
+    }
+    await order.seal();
+    await types.close();
+    types = void 0;
+    await validation.close();
+    validation = void 0;
+    await index.close();
+    index = void 0;
+    async function* members() {
+      try {
+        check();
+        for await (const stored of order.entries()) {
+          check();
+          const bytes = await pages.read(stored.start, stored.length), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+          const range = (n) => ({ start: view.getFloat64(n * 8, true), length: view.getFloat64((n + 1) * 8, true) });
+          const part = await text(range(0)), type = range(6);
+          yield Object.freeze({
+            part,
+            name: await text(range(2)),
+            sha256: await text(range(4)),
+            size: view.getFloat64(64, true),
+            async *contentType() {
+              try {
+                check();
+                yield* values.read(type);
+                check();
+              } catch (error) {
+                throw failure(error);
+              }
+            },
+            async *bytes() {
+              check();
+              for await (const bytes2 of archive.read(part)) {
+                check();
+                yield bytes2;
+              }
+              check();
+            }
+          });
+        }
+        check();
+      } catch (error) {
+        throw failure(error);
+      }
+    }
+    return Object.freeze({ count, members, close });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/retained-extraction-output.ts
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+async function stageRetainedExtractionOutput(extraction, settings, output) {
+  output = { ...output };
+  const working = { ...settings.workingStorage }, cacheBytes = working.cacheBytes ?? 1024 * 1024;
+  if (!working.fs || typeof working.directory !== "string" || !working.directory.startsWith("/") || !Number.isSafeInteger(cacheBytes) || cacheBytes < 16384 || cacheBytes % 16384 || typeof output.directory !== "string" || !output.directory || typeof output.json !== "boolean" || typeof output.allowPartialOutput !== "boolean" || !(output.maxOutputBytes > 0 && (output.maxOutputBytes === Infinity || Number.isSafeInteger(output.maxOutputBytes)))) throw new OfficeError("invalid-value", "Invalid extraction output storage or options.", "usage");
+  const signal = settings.signal ?? new AbortController().signal, controller = new AbortController();
+  const abort = () => controller.abort(signal.reason);
+  signal.addEventListener("abort", abort, { once: true });
+  if (signal.aborted) abort();
+  const context = { fs: working.fs, cwd: working.directory, env: {}, signal: controller.signal };
+  const pages = new PagedStorage2(context, cacheBytes / 16384), offsets = new PagedStorage2(context, cacheBytes / 16384);
+  let closed = false, closing;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Extraction output is closed.", "publish");
+    controller.signal.throwIfAborted();
+  };
+  const values = new RetainedValues(pages, check, controller.signal);
+  const close = () => {
+    closed = true;
+    signal.removeEventListener("abort", abort);
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([pages.close(), offsets.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  try {
+    let data2 = function(count2) {
+      return { outputs: { [rawJson]: () => manifest(count2) }, dryRun: false };
+    }, envelope2 = function(code, published = 0, reserve2 = false) {
+      return {
+        version: 1,
+        operation: "extract",
+        ok: !code,
+        warnings: [],
+        errors: code ? [{ code, message: "Output could not be published.", context: { phase: "publish" } }] : [],
+        locations: [],
+        affected: code && output.allowPartialOutput ? published : 0,
+        data: !code || reserve2 ? data2(count) : output.allowPartialOutput && published > 0 ? data2(published) : null
+      };
+    };
+    var data = data2, envelope = envelope2;
+    const start = pages.allocate(0), offsetStart = offsets.allocate(0);
+    let length = 0, count = 0;
+    const path = (name) => `${output.directory}${output.directory.endsWith("/") ? "" : "/"}${name}`;
+    for await (const member of extraction.members()) {
+      check();
+      if (count++) {
+        await pages.append(new Uint8Array([44]));
+        length++;
+      }
+      const item = await values.store(boundedOutput(streamJson({ part: member.part, name: member.name, contentType: member.contentType, sha256: member.sha256, path: path(member.name), bytes: member.size }), controller.signal, output.maxOutputBytes));
+      length += item.length;
+      if (!Number.isSafeInteger(length) || length > output.maxOutputBytes) throw new OfficeError("resource-limit", "Output limit exceeded.", "publish");
+      const end = new Uint8Array(8);
+      new DataView(end.buffer).setFloat64(0, length, true);
+      await offsets.append(end);
+    }
+    async function* manifest(count2) {
+      check();
+      yield* literal("[");
+      if (count2) {
+        const bytes = await offsets.read(offsetStart + (count2 - 1) * 8, 8), end = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getFloat64(0, true);
+        yield* values.read({ start, length: end });
+      }
+      yield* literal("]");
+      check();
+    }
+    async function* render(code, published = 0) {
+      if (output.json) {
+        yield* streamJson(envelope2(code, published));
+        yield* literal("\n");
+      } else if (!code) yield* literal(`Extracted ${count} package part(s)
+`);
+      else {
+        yield* literal(`pptx: ${code}: Output could not be published.
+`);
+        yield* streamJson(output.allowPartialOutput && published > 0 ? data2(published) : null);
+        yield* literal("\n");
+      }
+    }
+    for await (const chunk of boundedOutput(render(), signal, output.maxOutputBytes)) void chunk;
+    async function* reserve() {
+      yield* streamJson(envelope2("publication-unsupported", count, true));
+      yield* literal("\n");
+    }
+    for await (const chunk of boundedOutput(reserve(), signal, output.maxOutputBytes)) void chunk;
+    signal.throwIfAborted();
+    signal.removeEventListener("abort", abort);
+    return Object.freeze({ close, path, async write(sink, failure) {
+      check();
+      if (failure && (!["cancelled", "resource-limit", "stale-input", "publication-unsupported", "io-failure"].includes(failure.code) || !Number.isSafeInteger(failure.published) || failure.published < 0 || failure.published > count)) throw new OfficeError("invalid-value", "Invalid extraction outcome.", "usage");
+      for await (const chunk of boundedOutput(render(failure?.code, failure?.published), failure ? controller.signal : signal, output.maxOutputBytes)) await sink.write(chunk);
+    } });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/retained-package-packing.ts
+import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+import { sha256 } from "@noble/hashes/sha2.js";
+
+// packages/safe-bash-presentation-engine/src/retained-package-edit-admission.ts
+function unsupported() {
+  throw new OfficeError("unsupported-edit", "Signed, macro-enabled, labeled or protected packages cannot be edited.", "validate-intent");
+}
+async function mime(source) {
+  let text = "", window = "", pending = "", started = false, overflow = false;
+  for await (const value of characters(source)) {
+    if (value === ";") break;
+    if (!value.trim()) {
+      if (started) pending = " ";
+      continue;
+    }
+    started = true;
+    for (const character of pending + value.toLowerCase()) {
+      window = (window + character).slice(-17);
+      if (["digital-signature", "macroenabled", "vbaproject"].some((needle) => window.endsWith(needle))) unsupported();
+      if (text.length < 100) text += character;
+      else overflow = true;
+    }
+    pending = "";
+  }
+  return overflow ? "" : text;
+}
+async function admitRetainedPackageEdit(archive, main, types, graph, settings) {
+  const context = resolveOfficeResources(settings);
+  let metadataBytes = 0, metadataNodes = 0;
+  for await (const part of archive.parts()) {
+    if (part === "/[Content_Types].xml") continue;
+    const name = part.toLowerCase(), type = await mime(await types.get(part));
+    if (name.startsWith("/_xmlsignatures/") || name.endsWith("/vbaproject.bin") || name === "/docmetadata/labelinfo.xml" || type === "application/vnd.ms-office.classificationlabels+xml") unsupported();
+    if (type === "application/vnd.openxmlformats-officedocument.custom-properties+xml") {
+      metadataBytes += await archive.byteLength(part);
+      if (metadataBytes > context.xmlLimits.maxBytes || metadataNodes >= context.xmlLimits.maxNodes) throw new OfficeError("resource-limit", "Security metadata inspection limit exceeded.", "validate-intent");
+      const document2 = await openRetainedXmlDocument(archive.read(part), { ...settings, xmlLimits: { ...context.xmlLimits, maxNodes: context.xmlLimits.maxNodes - metadataNodes } });
+      let failed2 = false;
+      try {
+        metadataNodes += document2.nodeCount;
+        for await (const node of document2.children(document2.root)) {
+          if (node.kind !== "element" || !await equal(document2.raw(node.localName), literal("property"))) continue;
+          if (!await equal(document2.namespace(node), literal("http://schemas.openxmlformats.org/officeDocument/2006/custom-properties")) && !await equal(document2.namespace(node), literal("http://purl.oclc.org/ooxml/officeDocument/customProperties"))) continue;
+          for await (const attribute of document2.attributes(node)) if (await equal(document2.namespace(attribute), literal("")) && await equal(document2.raw(attribute.localName), literal("name"))) {
+            let prefix = "";
+            for await (const character of characters(document2.text(attribute))) {
+              prefix += character;
+              if (prefix.length >= 11) break;
+            }
+            if (prefix === "MSIP_Label_") unsupported();
+          }
+        }
+      } catch (error) {
+        failed2 = true;
+        throw error;
+      } finally {
+        try {
+          await document2.close();
+        } catch (error) {
+          if (!failed2) await Promise.reject(error);
+        }
+      }
+    }
+  }
+  async function* owners() {
+    yield "/";
+    yield* graph.parts();
+  }
+  for await (const owner of owners()) for await (const edge of graph.outgoing(owner)) {
+    let window = "";
+    for await (const character of characters(edge.type())) {
+      window = (window + character).slice(-19);
+      if (window.includes("/digital-signature/")) unsupported();
+    }
+    if (window.endsWith("/vbaProject")) unsupported();
+  }
+  const document = await openRetainedXmlDocument(archive.read(main), settings);
+  let failed = false;
+  try {
+    for await (const node of document.elements(document.root)) if (await equal(document.raw(node.localName), literal("modifyVerifier")) && await equal(document.namespace(node), document.namespace(document.root))) unsupported();
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    try {
+      await document.close();
+    } catch (error) {
+      if (!failed) await Promise.reject(error);
+    }
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/retained-package-packing.ts
+async function stageRetainedPackage(members, openMember, settings, options = {}) {
+  const context = resolveOfficeResources(settings), signal = context.signal ?? new AbortController().signal;
+  const working = { ...settings.workingStorage }, cacheBytes = working?.cacheBytes ?? 1024 * 1024;
+  if (!working?.fs || typeof working.directory !== "string" || !working.directory.startsWith("/") || !Number.isSafeInteger(cacheBytes) || cacheBytes < 16384 || cacheBytes % 16384)
+    throw new OfficeError("invalid-value", "Explicit packing storage and a valid cache budget are required.", "usage");
+  function record2(value, keys) {
+    if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some((key) => typeof key !== "string" || !keys.includes(key) || !("value" in Object.getOwnPropertyDescriptor(value, key))))
+      throw new OfficeError("invalid-value", "Expected a plain package record.", "usage");
+  }
+  record2(options, ["kind"]);
+  if (options.kind !== void 0 && !["pptx", "potx", "ppsx"].includes(options.kind)) throw new OfficeError("invalid-value", "Invalid presentation kind.", "usage");
+  const kind = options.kind, admittedSettings = { ...context, signal, workingStorage: working };
+  if (!members || typeof members[Symbol.asyncIterator] !== "function" || typeof openMember !== "function") throw new OfficeError("invalid-type", "Explicit package member streams are required.", "usage");
+  const makePages = () => new PagedStorage3({ fs: working.fs, cwd: working.directory, env: {}, signal }, cacheBytes / 16384);
+  const descriptors = makePages(), zipPages = makePages(), output = makePages();
+  let closed = false, closing;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Packed output is closed.", "serialize");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "serialize");
+  };
+  const failure = (error) => {
+    if (signal.aborted) return new OfficeError("cancelled", "Operation cancelled.", "serialize");
+    if (error instanceof OfficeError) return error;
+    const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+    return new OfficeError(code === "resource-limit" || code === "EFBIG" ? "resource-limit" : "io-failure", "Package packing failed.", "serialize");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([descriptors.close(), zipPages.close(), output.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const values = new RetainedValues(descriptors, check, signal), order = new RetainedOrder(descriptors, values, check);
+  const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const bounds = (size, maximum) => {
+    if (!Number.isSafeInteger(size) || size > maximum) throw new OfficeError("resource-limit", "Package byte limit exceeded.", "admit");
+  };
+  try {
+    check();
+    let count = 0;
+    for await (const member of members) {
+      check();
+      bounds(++count, Math.min(context.archiveLimits.maxMembers, 65534));
+      record2(member, ["part", "sha256"]);
+      const part = partName(member.part, false), expectedDigest = member.sha256;
+      if (part !== member.part || part.includes(":")) throw new OfficeError("unsafe-path", "A canonical package part is required.", "usage");
+      if (typeof expectedDigest !== "string" || expectedDigest.length !== 64 || [...expectedDigest].some((character) => !"0123456789abcdef".includes(character))) throw new OfficeError("invalid-value", "A lowercase SHA-256 digest is required.", "usage");
+      const name = [...part.slice(1)].map((character) => character.codePointAt(0) > 127 ? encodeURIComponent(character) : character).join("");
+      bounds(new TextEncoder().encode(name).length, Math.min(context.archiveLimits.maxPathBytes, 65535));
+      bounds(name.split("/").length, context.archiveLimits.maxDepth);
+      const key = asciiKey(part);
+      if (await values.find("names", () => literal(key)) || await values.find("parents", () => literal(key))) throw new OfficeError("invalid-opc", "Colliding package members.", "admit");
+      let parent = key.slice(0, key.lastIndexOf("/"));
+      while (parent) {
+        if (await values.find("names", () => literal(parent))) throw new OfficeError("invalid-opc", "Colliding package members.", "admit");
+        const value2 = await values.store(literal(parent));
+        await values.insert("parents", value2, value2);
+        parent = parent.slice(0, parent.lastIndexOf("/"));
+      }
+      const value = await values.store(literal(key));
+      await values.insert("names", value, value);
+      await order.add(literal(name), await values.store(literal(JSON.stringify({ part, name, sha256: expectedDigest }))));
+    }
+    if (!count) throw new OfficeError("invalid-value", "Explicit package members are required.", "usage");
+    await order.seal();
+    const storage = { allocate: (length) => zipPages.allocate(length), read: (position, length) => zipPages.read(position, length), write: (position, bytes2) => zipPages.write(position, bytes2) };
+    const writer = createZipCodec(void 0, { zip64: true, rejectDuplicateNames: true, utcDates: true }).createStagedWriter(
+      storage,
+      { ...context.archiveLimits, maxArchiveBytes: Math.min(context.archiveLimits.maxArchiveBytes, context.limits.maxBytes) },
+      signal
+    );
+    let total = 0;
+    for await (const row of order.entries()) {
+      check();
+      let text = "";
+      const decoder = new TextDecoder();
+      for await (const bytes2 of values.read(row)) text += decoder.decode(bytes2, { stream: true });
+      text += decoder.decode();
+      const member = JSON.parse(text);
+      async function* source() {
+        let iterator, exhausted = false, size2 = 0;
+        const hash2 = sha256.create();
+        try {
+          try {
+            iterator = openMember(member.part)[Symbol.asyncIterator]();
+          } catch {
+            throw new OfficeError("io-failure", "Byte input failed.", "admit");
+          }
+          for (let reads = 0; reads < context.limits.maxReads; reads++) {
+            check();
+            let item;
+            try {
+              item = await iterator.next();
+            } catch (error) {
+              if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") throw new PackageNotFoundError();
+              throw failure(error);
+            }
+            check();
+            if (item.done) {
+              exhausted = true;
+              if (hex(hash2.digest()) !== member.sha256) throw new OfficeError("invalid-value", "Package member digest does not match.", "admit");
+              return;
+            }
+            if (!(item.value instanceof Uint8Array)) throw new OfficeError("invalid-type", "Byte source returned an invalid chunk.", "admit");
+            size2 += item.value.length;
+            total += item.value.length;
+            bounds(size2, Math.min(context.limits.maxBytes, context.archiveLimits.maxEntryBytes));
+            bounds(total, context.archiveLimits.maxTotalBytes);
+            for (let offset = 0; offset < item.value.length; offset += 16384) {
+              check();
+              const owned = new Uint8Array(item.value.subarray(offset, offset + 16384));
+              hash2.update(owned);
+              yield owned;
+            }
+          }
+          throw new OfficeError("resource-limit", "Byte source exceeded its read limit.", "admit");
+        } finally {
+          if (!exhausted) try {
+            await iterator?.return?.();
+          } catch {
+          }
+        }
+      }
+      await writer.addSource(member.name, source(), { modified: new Date(Date.UTC(1980, 0, 1)), mode: 33188, directory: false, symlink: false, compression: "store" });
+    }
+    const start = output.allocate(0);
+    let size = 0;
+    const hash = sha256.create();
+    for await (const bytes2 of writer.finish()) {
+      check();
+      await output.append(bytes2);
+      hash.update(bytes2);
+      size += bytes2.length;
+    }
+    const fingerprint = hex(hash.digest());
+    await descriptors.close();
+    await zipPages.close();
+    async function* bytes() {
+      try {
+        check();
+        for (let offset = 0; offset < size; offset += 16384) {
+          check();
+          yield await output.read(start + offset, Math.min(16384, size - offset));
+        }
+        check();
+      } catch (error) {
+        throw failure(error);
+      }
+    }
+    const archive = await openPackageArchive({ size, read: (position, maximum) => output.read(start + position, Math.min(maximum, size - position)) }, admittedSettings);
+    let index, validation, types, failed = false;
+    try {
+      index = await openRetainedPresentationIndex(archive, fingerprint, admittedSettings);
+      validation = await openRetainedPresentationValidation(archive, admittedSettings, { ...context.xmlLimits, ...context.relationshipLimits, maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes), maxEntries: context.archiveLimits.maxMembers });
+      if (!validation.valid) throw new OfficeError("invalid-opc", "Invalid presentation graph.", "validate-intent");
+      types = await openRetainedContentTypes(archive.read("/[Content_Types].xml"), admittedSettings, { maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes), maxEntries: context.archiveLimits.maxMembers });
+      await admitRetainedPackageEdit(archive, index.records.main, types, index.graph, admittedSettings);
+      if (kind !== void 0) await types.presentationKind(index.records.main, kind);
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      const results = await Promise.allSettled([types?.close(), validation?.close(), index?.close(), archive.close()]);
+      if (!failed) {
+        for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+      }
+    }
+    check();
+    return Object.freeze({ count, size, fingerprint, bytes, close });
+  } catch (error) {
+    const primary = failure(error);
+    await close().catch(() => {
+    });
+    throw primary;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/package-tools.ts
+function record(value, allowed) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some((key) => typeof key !== "string" || !allowed.includes(key) || !("value" in Object.getOwnPropertyDescriptor(value, key))))
+    throw new OfficeError("invalid-value", "Expected a plain package record.", "usage");
+}
+function list(value, maximum) {
+  if (!Array.isArray(value)) throw new OfficeError("invalid-value", "Expected package members.", "usage");
+  if (value.length > maximum) throw new OfficeError("resource-limit", "Package member limit exceeded.", "usage");
+  if (Object.getPrototypeOf(value) !== Array.prototype || Reflect.ownKeys(value).length !== value.length + 1 || Array.from({ length: value.length }, (_, index) => Object.getOwnPropertyDescriptor(value, String(index))).some((item) => !item || !("value" in item)))
+    throw new OfficeError("invalid-value", "Expected a dense package array.", "usage");
+}
+function digest2(bytes) {
+  return Array.from(sha2562(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function extractPackage(input, context, options = {}) {
+  record(options, ["parts"]);
+  if (!context?.archiveLimits) throw new OfficeError("invalid-value", "Explicit limits are required.", "usage");
+  if (options.parts !== void 0) list(options.parts, context.archiveLimits.maxMembers);
+  if (!options || Object.keys(options).some((key) => key !== "parts") || options.parts !== void 0 && (!Array.isArray(options.parts) || !options.parts.length))
+    throw new OfficeError("invalid-value", "Invalid package extraction options.", "usage");
+  const selected = options.parts?.map((part) => {
+    const canonical = partName(part, false);
+    if (canonical !== part) throw new OfficeError("unsafe-path", "A canonical package part is required.", "usage");
+    return canonical;
+  });
+  if (selected && new Set(selected.map(asciiKey)).size !== selected.length)
+    throw new OfficeError("invalid-value", "Duplicate extracted part.", "usage");
+  const { reader } = await loadShared(input, context, false);
+  const types = parseContentTypes(reader.get("/[Content_Types].xml"), {
+    maxBytes: context.xmlLimits.maxBytes,
+    maxEntries: context.archiveLimits.maxMembers
+  });
+  const names = selected ?? [...reader.names].sort();
+  return Object.freeze(names.map((part, index) => {
+    const bytes = reader.get(part);
+    const contentType = part === "/[Content_Types].xml" ? "application/xml" : types.get(part);
+    const essence = contentType.split(";", 1)[0].trim().toLowerCase();
+    const extension = essence === "application/xml" || essence === "text/xml" || essence.endsWith("+xml") ? "xml" : { "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/tiff": "tif", "image/bmp": "bmp", "audio/mpeg": "mp3", "video/mp4": "mp4" }[essence] ?? "bin";
+    return Object.freeze({ part, name: `part-${String(index + 1).padStart(6, "0")}.${extension}`, contentType, sha256: digest2(bytes), bytes });
+  }));
+}
+async function packPackage(members, context, options = {}) {
+  record(options, ["kind"]);
+  if (!context?.limits || !context.archiveLimits || !Array.isArray(members) || !members.length || !options || Object.keys(options).some((key) => key !== "kind") || options.kind !== void 0 && !["pptx", "potx", "ppsx"].includes(options.kind))
+    throw new OfficeError("invalid-value", "Explicit package members and limits are required.", "usage");
+  if (context.signal?.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "admit");
+  if (members.length > context.archiveLimits.maxMembers)
+    throw new OfficeError("resource-limit", "Package member limit exceeded.", "admit");
+  list(members, context.archiveLimits.maxMembers);
+  const names = /* @__PURE__ */ new Set();
+  const parents = /* @__PURE__ */ new Set();
+  let ownedTotal = 0;
+  const admitted = members.map((member) => {
+    record(member, ["part", "sha256", "bytes", "name", "contentType"]);
+    if (!member || typeof member.sha256 !== "string" || member.sha256.length !== 64 || [...member.sha256].some((character) => !"0123456789abcdef".includes(character)))
+      throw new OfficeError("invalid-value", "A lowercase SHA-256 digest is required.", "usage");
+    const part = partName(member.part, false);
+    if (part !== member.part || part.includes(":"))
+      throw new OfficeError("unsafe-path", "A canonical package part is required.", "usage");
+    const key = asciiKey(part);
+    if (names.has(key) || parents.has(key))
+      throw new OfficeError("invalid-opc", "Colliding package members.", "admit");
+    let parent = key.slice(0, key.lastIndexOf("/"));
+    while (parent) {
+      if (names.has(parent)) throw new OfficeError("invalid-opc", "Colliding package members.", "admit");
+      parents.add(parent);
+      parent = parent.slice(0, parent.lastIndexOf("/"));
+    }
+    names.add(key);
+    let input = member.bytes;
+    if (input instanceof Uint8Array) {
+      ownedTotal += input.length;
+      if (input.length > context.archiveLimits.maxEntryBytes || input.length > context.limits.maxBytes || ownedTotal > context.archiveLimits.maxTotalBytes)
+        throw new OfficeError("resource-limit", "Package byte limit exceeded.", "admit");
+      input = new Uint8Array(input);
+    }
+    return { part, sha256: member.sha256, input };
+  });
+  let total = 0;
+  const output = [];
+  for (const member of admitted) {
+    const remaining = context.archiveLimits.maxTotalBytes - total;
+    const bytes2 = await readBinary(member.input, context, { maxBytes: Math.min(context.limits.maxBytes, context.archiveLimits.maxEntryBytes, Math.max(1, remaining)) });
+    if (bytes2.length > remaining) throw new OfficeError("resource-limit", "Package byte limit exceeded.", "admit");
+    total += bytes2.length;
+    if (digest2(bytes2) !== member.sha256)
+      throw new OfficeError("invalid-value", "Package member digest does not match.", "admit");
+    const name = [...member.part.slice(1)].map((character) => character.codePointAt(0) > 127 ? encodeURIComponent(character) : character).join("");
+    output.push({ name, bytes: bytes2 });
+  }
+  const bytes = await writePackageArchive(output, context, { compression: "store" });
+  const loaded = await loadShared(bytes, context);
+  if (options.kind !== void 0) {
+    const types = parseContentTypes(loaded.reader.get("/[Content_Types].xml"), {
+      maxBytes: context.xmlLimits.maxBytes,
+      maxEntries: context.archiveLimits.maxMembers
+    });
+    types.presentationKind(loaded.main, options.kind);
+  }
+  return bytes;
+}
+
+export {
+  openRetainedPackageExtraction,
+  stageRetainedExtractionOutput,
+  stageRetainedPackage,
+  extractPackage,
+  packPackage
+};