@poe-platform/safe-bash 0.1.818 → 0.1.819

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

@@ -0,0 +1,1016 @@
+import {
+  openRetainedPresentationIndex
+} from "./chunk-LZHFVNEV.js";
+import {
+  rawJson,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-R36PDP3L.js";
+import {
+  RetainedOrder
+} from "./chunk-7JTJQKIV.js";
+import {
+  attr
+} from "./chunk-UDRJKA3P.js";
+import {
+  SelectionError,
+  readSelectionIndex
+} from "./chunk-SKF6PGA5.js";
+import {
+  readPackage
+} from "./chunk-KVTZJBLM.js";
+import {
+  dialects,
+  openRetainedCompatibility
+} from "./chunk-P3LHQOX7.js";
+import {
+  equationOpaqueElements,
+  interpretCompatibility
+} from "./chunk-PNOXBL2B.js";
+import {
+  parseXmlPart
+} from "./chunk-YWP62BAZ.js";
+import {
+  readBinary
+} from "./chunk-S5MBHFLB.js";
+import {
+  OfficeError,
+  RetainedValues,
+  equal,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-VJQ5OWS5.js";
+
+// packages/safe-bash-presentation-engine/src/media.ts
+import { sha1 as sha12 } from "@noble/hashes/legacy.js";
+
+// packages/safe-bash-presentation-engine/src/retained-media.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+import { sha1 } from "@noble/hashes/legacy.js";
+var mediaNamespace = "http://schemas.microsoft.com/office/powerpoint/2010/main";
+var mediaRelationship = "http://schemas.microsoft.com/office/2007/relationships/media";
+var tracksNamespace = "http://schemas.microsoft.com/office/powerpoint/2017/3/main";
+async function* joined(...sources) {
+  for (const source of sources) yield* source;
+}
+async function relationshipKind(edge) {
+  for (const kind of ["audio", "video"])
+    for (const d of dialects) if (await equal(edge.type(), literal(d.r + "/" + kind))) return kind;
+  return await equal(edge.type(), literal(mediaRelationship)) ? "unknown" : null;
+}
+var RetainedMediaSelectionError = class extends OfficeError {
+  constructor(code, candidates, close) {
+    super(code, new SelectionError(code).message, "select");
+    this.candidates = candidates;
+    this.close = close;
+  }
+  candidates;
+  close;
+};
+async function openRetainedMedia(archive, fingerprint, input, settings) {
+  validateMediaOptions(input);
+  const options = { ...input };
+  const context = { ...resolveOfficeResources(settings), workingStorage: { ...settings.workingStorage } }, signal = context.signal ?? new AbortController().signal;
+  const index = await openRetainedPresentationIndex(archive, fingerprint, context);
+  const storage = () => new PagedStorage(
+    { fs: context.workingStorage.fs, cwd: context.workingStorage.directory, env: {}, signal },
+    (context.workingStorage.cacheBytes ?? 1024 * 1024) / 16384
+  );
+  const pages = storage(), outputPages = storage();
+  let closed = false, closing, head = 0, tail = 0, resourceHead = 0, resourceTail = 0, mediaHead = 0, mediaTail = 0, count = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Media inventory is closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([index.close(), pages.close(), outputPages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(
+    signal.aborted ? "cancelled" : "io-failure",
+    "Media storage operation failed.",
+    "index"
+  );
+  const values = new RetainedValues(pages, check, signal), output = new RetainedValues(outputPages, check, signal);
+  const owners = new RetainedOrder(pages, values, check), mediaParts = new RetainedOrder(pages, values, check);
+  async function text(range) {
+    let value = "";
+    const decoder = new TextDecoder();
+    for await (const bytes of values.read(range)) value += decoder.decode(bytes, { stream: true });
+    return value + decoder.decode();
+  }
+  async function write(pointer, row2) {
+    const bytes = new Uint8Array(row2.length * 8), view = new DataView(bytes.buffer);
+    row2.forEach((n, i) => view.setFloat64(i * 8, n, true));
+    await pages.write(pointer, bytes);
+  }
+  async function row(pointer, length) {
+    check();
+    const bytes = await pages.read(pointer, length * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length }, (_, i) => view.getFloat64(i * 8, true));
+  }
+  async function mark(scope, key) {
+    const stored = await values.store(key);
+    return values.insert(scope, stored, stored);
+  }
+  async function part(source) {
+    const stored = await values.find("parts", source);
+    return stored ? JSON.parse(await text(stored)) : void 0;
+  }
+  const content = (info) => info.contentType ? () => values.read(info.contentType) : null;
+  let selectedObjects = false;
+  try {
+    for await (const info of index.inventory.parts) {
+      const type = info.contentType ? await values.store(info.contentType()) : null;
+      const key = await values.store(literal(info.part)), value = await values.store(literal(JSON.stringify({ ...info, contentType: type })));
+      await values.insert("parts", key, value);
+    }
+    if (options.select)
+      for await (const record of index.records.select({ token: options.select })) {
+        await mark("selectedPart", literal(record.part));
+        await mark(
+          record.kind === "object" ? "selectedObject" : "selectedWhole",
+          literal(record.kind === "object" ? record.part + "\0" + record.id : record.part)
+        );
+        selectedObjects ||= record.kind === "object";
+      }
+    async function related(owner, type, visit) {
+      for await (const edge of index.graph.outgoing(owner))
+        if (!edge.external && edge.targetPart) {
+          let match = false;
+          for (const d of dialects)
+            if (await equal(edge.type(), literal(d.r + "/" + type))) match = true;
+          if (match) {
+            const info = await part(edge.targetPart);
+            if (info) await visit(info.part);
+          }
+        }
+    }
+    for await (const slide of index.inventory.slides) {
+      const key = await values.store(literal(slide.part));
+      await values.insert("slideOrder", key, { start: slide.position, length: 0 });
+      if (options.slide === slide.position) {
+        for (const name of [slide.part, slide.layout, slide.master])
+          if (name) await mark("allowedPart", literal(name));
+        await related(slide.part, "notesSlide", async (notes) => {
+          await mark("allowedPart", literal(notes));
+          await related(notes, "notesMaster", async (master) => {
+            await mark("allowedPart", literal(master));
+          });
+        });
+      }
+    }
+    for await (const owner of index.records.records("part")) {
+      if (owner.scope === "shared") continue;
+      if (options.select ? !await values.find("selectedPart", () => literal(owner.part)) : options.scope !== "shared" && owner.scope !== (options.scope ?? "slides"))
+        continue;
+      if (options.slide !== void 0 && !await values.find("allowedPart", () => literal(owner.part)))
+        continue;
+      await mark("owners", literal(owner.part));
+      const order = (await values.find("slideOrder", () => literal(owner.part)))?.start ?? Number.MAX_SAFE_INTEGER;
+      const stored = await values.store(literal(JSON.stringify({ ...owner, name: void 0 })));
+      await owners.add(literal(String(order).padStart(16, "0") + owner.part), stored);
+    }
+    await owners.seal();
+    if (options.shape !== void 0) {
+      let matches = 0;
+      for await (const record of index.records.records("object"))
+        if (await values.find("owners", () => literal(record.part)) && await equal(record.name(), literal(options.shape))) {
+          matches++;
+        }
+      if (matches !== 1)
+        throw new RetainedMediaSelectionError(
+          matches ? "ambiguous-selection" : "missing-selection",
+          async function* () {
+            for await (const record of index.records.records("object"))
+              if (await values.find("owners", () => literal(record.part)) && await equal(record.name(), literal(options.shape)))
+                yield record.location;
+          },
+          close
+        );
+    }
+    async function addOccurrence(id, location, sourcePart, shapeId, shapeName, kind, relationships2, posters, playback, captions, timing) {
+      const storedId = await values.store(id());
+      let embedded = 0, linked = 0;
+      for await (const ref of relationships2()) {
+        const resource = ref.mediaPart ? await part(ref.mediaPart) : void 0;
+        const metadata = await values.store(
+          literal(
+            JSON.stringify({
+              external: ref.external,
+              part: resource?.part ?? null,
+              contentType: resource?.contentType ?? null,
+              bytes: ref.bytes,
+              sha256: ref.sha256
+            })
+          )
+        );
+        const resourcePointer = pages.allocate(48);
+        await write(resourcePointer, [
+          0,
+          count + 1,
+          storedId.start,
+          storedId.length,
+          metadata.start,
+          metadata.length
+        ]);
+        if (resourceTail) await write(resourceTail, [resourcePointer]);
+        else resourceHead = resourcePointer;
+        resourceTail = resourcePointer;
+        if (ref.external) linked++;
+        else embedded++;
+        if (ref.mediaPart) {
+          const info = await part(ref.mediaPart);
+          if (!info) continue;
+          const key = await values.store(literal(info.part));
+          if (await values.insert("media", key, key)) await mediaParts.add(literal(info.part), key);
+          if (await values.insert("occurrence:" + info.part, storedId, storedId)) {
+            const prior = await values.find("ids:" + info.part, () => literal("list"));
+            const pointer2 = pages.allocate(24);
+            await write(pointer2, [0, storedId.start, storedId.length]);
+            if (prior) {
+              const links = await row(prior.start, 2);
+              await write(links[1], [pointer2]);
+              await write(prior.start + 8, [pointer2]);
+            } else {
+              const links = pages.allocate(16);
+              await write(links, [pointer2, pointer2]);
+              const listKey = await values.store(literal("list"));
+              await values.insert("ids:" + info.part, listKey, { start: links, length: 16 });
+            }
+          }
+        }
+      }
+      const name = shapeName ? await values.store(shapeName()) : void 0;
+      const json = await output.store(
+        streamJson({
+          id: () => values.read(storedId),
+          location,
+          sourcePart,
+          shapeId,
+          shapeName: name ? () => values.read(name) : null,
+          kind,
+          relationships: relationships2(),
+          posters,
+          playback,
+          captions,
+          timing
+        })
+      );
+      const summary = await values.store(
+        literal(JSON.stringify({ location, sourcePart, shapeId, kind, name, embedded, linked }))
+      );
+      const pointer = pages.allocate(40);
+      await write(pointer, [0, json.start, json.length, summary.start, summary.length]);
+      if (tail) await write(tail, [pointer]);
+      else head = pointer;
+      tail = pointer;
+      count++;
+    }
+    async function reference(owner, id) {
+      const edge = await index.graph.get(owner, id);
+      if (!edge) throw new OfficeError("missing-binding", "Media relationship is absent.", "index");
+      const info = edge.targetPart ? await part(edge.targetPart) : void 0;
+      if (!edge.external && !info)
+        throw new OfficeError("missing-binding", "Media part is absent.", "index");
+      return {
+        relationshipId: edge.id,
+        relationshipType: edge.type,
+        target: edge.target,
+        external: edge.external,
+        mediaPart: edge.targetPart,
+        contentType: info ? content(info) : null,
+        bytes: info?.bytes ?? null,
+        sha256: info?.sha256 ?? null
+      };
+    }
+    for await (const stored of owners.entries()) {
+      const owner = JSON.parse(await text(stored));
+      const doc = await openRetainedXmlDocument(archive.read(owner.part), context);
+      let view;
+      try {
+        view = await openRetainedCompatibility(
+          doc,
+          dialects.flatMap((d) => [d.p, d.a, d.r]),
+          context,
+          [
+            ...equationOpaqueElements,
+            ...dialects.flatMap((d) => [
+              { namespace: d.p, localName: "ext" },
+              { namespace: d.a, localName: "ext" },
+              { namespace: d.a, localName: "graphicData" }
+            ])
+          ]
+        );
+        const local = (node, name) => equal(doc.raw(node.localName), literal(name));
+        async function named(node, names, kind) {
+          let namespace = false;
+          for (const uri of kind === "p" || kind === "a" || kind === "r" ? dialects.map((d) => d[kind]) : [kind])
+            if (await equal(doc.namespace(node), literal(uri))) namespace = true;
+          if (!namespace) return false;
+          for (const name of names) if (await local(node, name)) return true;
+          return false;
+        }
+        async function attr2(node, name) {
+          for await (const value of doc.attributes(node))
+            if (await local(value, name) && await equal(doc.namespace(value), literal("")))
+              return value;
+        }
+        async function* bindings(node) {
+          for await (const value of doc.attributes(node))
+            if (await named(value, ["embed", "link", "id"], "r")) yield value;
+        }
+        const active = new RetainedOrder(pages, values, check);
+        let serial = 0, top = pages.allocate(16);
+        await write(top, [0, doc.reference(doc.root)]);
+        async function admit(node) {
+          const key = await values.store(literal(String(doc.reference(node))));
+          await values.insert("active:" + owner.part, key, key);
+          await active.add(literal(String(serial++).padStart(16, "0")), key);
+        }
+        while (top) {
+          const task = await row(top, 2);
+          top = task[0];
+          const node = await doc.node(task[1]);
+          await admit(node);
+          if (await named(node, ["ext"], "p") || await named(node, ["ext"], "a")) {
+            for await (const nested of doc.elements(node))
+              if (doc.reference(nested) !== doc.reference(node)) await admit(nested);
+            continue;
+          }
+          let first = 0, last = 0;
+          for await (const child of view.children(node)) {
+            const task2 = pages.allocate(16);
+            await write(task2, [0, doc.reference(child)]);
+            if (last) await write(last, [task2]);
+            else first = task2;
+            last = task2;
+          }
+          if (last) {
+            await write(last, [top]);
+            top = first;
+          }
+        }
+        await active.seal();
+        async function* nodes(root) {
+          if (root) {
+            for await (const node of doc.elements(root))
+              if (await values.find(
+                "active:" + owner.part,
+                () => literal(String(doc.reference(node)))
+              ))
+                yield node;
+          } else
+            for await (const key of active.entries()) yield await doc.node(Number(await text(key)));
+        }
+        let metadataId = 0;
+        async function metadata(node) {
+          const scope = "metadata:" + owner.part + ":" + ++metadataId;
+          async function* refs() {
+            for await (const nested of doc.elements(node))
+              for await (const binding of bindings(nested))
+                if (await mark(scope, doc.text(binding)))
+                  yield await reference(owner.part, () => doc.text(binding));
+          }
+          return {
+            namespace: () => doc.namespace(node),
+            name: () => doc.raw(node.localName),
+            xml: () => doc.markup(node, true),
+            relationships: refs()
+          };
+        }
+        for await (const record of index.records.records("object")) {
+          if (record.part !== owner.part || options.shape !== void 0 && !await equal(record.name(), literal(options.shape)))
+            continue;
+          if (options.select && !await values.find("selectedWhole", () => literal(owner.part)) && !await values.find("selectedObject", () => literal(owner.part + "\0" + record.id)))
+            continue;
+          let shape;
+          for await (const node of nodes()) {
+            if (!await named(node, ["pic", "sp", "graphicFrame"], "p")) continue;
+            let match = false;
+            for await (const nv of doc.children(node))
+              for await (const identity of doc.children(nv))
+                if (identity.kind === "element" && await named(identity, ["cNvPr"], "p")) {
+                  const id = await attr2(identity, "id");
+                  if (id && await equal(doc.text(id), literal(record.id))) match = true;
+                }
+            if (match) {
+              shape = node;
+              break;
+            }
+          }
+          if (!shape) continue;
+          const refs = new RetainedOrder(pages, values, check);
+          let refsCount = 0, hasNodes = false, audio = false, video = false;
+          for await (const node of nodes(shape)) {
+            const isDrawing = await named(node, ["videoFile", "audioFile", "wavAudioFile"], "a"), isMedia = await named(node, ["media"], mediaNamespace);
+            if (!isDrawing && !isMedia) continue;
+            hasNodes = true;
+            let bound = false;
+            for await (const binding of bindings(node)) {
+              bound = true;
+              const ref = await reference(owner.part, () => doc.text(binding)), edge = await index.graph.get(owner.part, () => doc.text(binding));
+              const expected = await local(node, "videoFile") ? "video" : await local(node, "media") ? "unknown" : "audio";
+              const kind = await relationshipKind(edge);
+              if (kind !== expected)
+                throw new OfficeError(
+                  "missing-binding",
+                  "Media relationship has the wrong type.",
+                  "index"
+                );
+              await mark("consumed:" + owner.part, edge.id());
+              const id = await values.store(edge.id());
+              if (await values.insert("refs:" + owner.part + ":" + record.id, id, id))
+                await refs.add(literal(String(refsCount++).padStart(16, "0")), id);
+              audio ||= kind === "audio";
+              video ||= kind === "video";
+              if (kind === "unknown" && ref.contentType) {
+                let prefix = "";
+                for await (const bytes of ref.contentType()) {
+                  prefix += new TextDecoder().decode(bytes.subarray(0, 6 - prefix.length));
+                  if (prefix.length >= 6) break;
+                }
+                audio ||= prefix.startsWith("audio/");
+                video ||= prefix.startsWith("video/");
+              }
+            }
+            if (!bound)
+              throw new OfficeError(
+                "missing-binding",
+                "Media reference has no relationship binding.",
+                "index"
+              );
+          }
+          if (!hasNodes) continue;
+          await refs.seal();
+          async function* references() {
+            for await (const id of refs.entries())
+              yield await reference(owner.part, () => values.read(id));
+          }
+          async function* posters() {
+            for await (const node of nodes(shape))
+              if (await named(node, ["blip"], "a"))
+                for await (const binding of bindings(node)) {
+                  const ref = await reference(owner.part, () => doc.text(binding));
+                  let image = false;
+                  for (const d of dialects)
+                    if (await equal(ref.relationshipType(), literal(d.r + "/image"))) image = true;
+                  if (!image)
+                    throw new OfficeError(
+                      "missing-binding",
+                      "Poster relationship has the wrong type.",
+                      "index"
+                    );
+                  yield ref;
+                }
+          }
+          async function* metadataNodes(kind) {
+            for await (const node of nodes(kind === "timing" ? void 0 : shape)) {
+              if (kind === "playback" && await named(node, ["media"], mediaNamespace) || kind === "captions" && await named(node, ["tracksInfo"], tracksNamespace))
+                yield await metadata(node);
+              else if (kind === "timing" && await named(
+                node,
+                [
+                  "audio",
+                  "video",
+                  "anim",
+                  "animEffect",
+                  "animMotion",
+                  "animRot",
+                  "animScale",
+                  "cmd",
+                  "set"
+                ],
+                "p"
+              )) {
+                let match = false;
+                for await (const target of doc.elements(node))
+                  if (await named(target, ["spTgt"], "p")) {
+                    const id = await attr2(target, "spid");
+                    if (id && await equal(doc.text(id), literal(record.id))) match = true;
+                  }
+                if (match) yield await metadata(node);
+              }
+            }
+          }
+          await addOccurrence(
+            () => literal(owner.part + "#media-" + record.id),
+            record.location,
+            owner.part,
+            record.id,
+            record.name,
+            audio === video ? "unknown" : audio ? "audio" : "video",
+            references,
+            posters(),
+            metadataNodes("playback"),
+            metadataNodes("captions"),
+            metadataNodes("timing")
+          );
+        }
+        const unconsumed = new RetainedOrder(pages, values, check);
+        if (options.shape === void 0 && !selectedObjects)
+          for await (const edge of index.graph.outgoing(owner.part)) {
+            const id = await values.store(edge.id());
+            await unconsumed.add(values.read(id), id);
+          }
+        await unconsumed.seal();
+        for await (const id of unconsumed.entries()) {
+          const edge = await index.graph.get(owner.part, () => values.read(id));
+          const kind = await relationshipKind(edge);
+          if (!kind || await values.find("consumed:" + owner.part, edge.id)) continue;
+          async function* references() {
+            yield await reference(owner.part, edge.id);
+          }
+          async function* empty() {
+          }
+          await addOccurrence(
+            () => joined(literal(owner.part + "#media-relationship-"), edge.id()),
+            owner.location,
+            owner.part,
+            null,
+            null,
+            kind,
+            references,
+            empty(),
+            empty(),
+            empty(),
+            empty()
+          );
+        }
+      } finally {
+        await Promise.all([view?.close(), doc.close()]);
+      }
+    }
+    await mediaParts.seal();
+    for await (const name of mediaParts.entries()) {
+      const info = await part(() => values.read(name)), hash = sha1.create();
+      for await (const bytes of archive.read(info.part)) {
+        check();
+        hash.update(bytes);
+      }
+      async function* ids() {
+        const list = await values.find("ids:" + info.part, () => literal("list"));
+        for (let pointer2 = (await row(list.start, 2))[0]; pointer2; ) {
+          const data = await row(pointer2, 3);
+          pointer2 = data[0];
+          const value = { start: data[1], length: data[2] };
+          yield () => values.read(value);
+        }
+      }
+      const json = await output.store(
+        streamJson({
+          part: info.part,
+          contentType: content(info),
+          bytes: info.bytes,
+          sha256: info.sha256,
+          sha1: Array.from(hash.digest(), (b) => b.toString(16).padStart(2, "0")).join(""),
+          occurrenceIds: ids()
+        })
+      );
+      const pointer = pages.allocate(24);
+      await write(pointer, [0, json.start, json.length]);
+      if (mediaTail) await write(mediaTail, [pointer]);
+      else mediaHead = pointer;
+      mediaTail = pointer;
+    }
+    await index.close();
+    check();
+    return Object.freeze({
+      close,
+      count,
+      async *occurrences() {
+        try {
+          check();
+          for (let pointer = head; pointer; ) {
+            const item = await row(pointer, 5);
+            pointer = item[0];
+            yield { [rawJson]: () => output.read({ start: item[1], length: item[2] }) };
+          }
+        } catch (error) {
+          throw failure(error);
+        }
+      },
+      async *media() {
+        try {
+          check();
+          for (let pointer = mediaHead; pointer; ) {
+            const item = await row(pointer, 3);
+            pointer = item[0];
+            yield { [rawJson]: () => output.read({ start: item[1], length: item[2] }) };
+          }
+        } catch (error) {
+          throw failure(error);
+        }
+      },
+      async *resources() {
+        try {
+          check();
+          for (let pointer = resourceHead; pointer; ) {
+            const item = await row(pointer, 6);
+            pointer = item[0];
+            const metadata = JSON.parse(await text({ start: item[4], length: item[5] }));
+            yield {
+              ...metadata,
+              occurrence: item[1],
+              occurrenceId: () => values.read({ start: item[2], length: item[3] }),
+              contentType: metadata.contentType ? () => values.read(metadata.contentType) : null
+            };
+          }
+          check();
+        } catch (error) {
+          throw failure(error);
+        }
+      },
+      async *summaries() {
+        try {
+          check();
+          for (let pointer = head; pointer; ) {
+            const item = await row(pointer, 5);
+            pointer = item[0];
+            const summary = JSON.parse(await text({ start: item[3], length: item[4] }));
+            yield { ...summary, name: summary.name ? () => values.read(summary.name) : null };
+          }
+        } catch (error) {
+          throw failure(error);
+        }
+      }
+    });
+  } catch (error) {
+    if (!(error instanceof RetainedMediaSelectionError)) await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+async function stageRetainedMedia(archive, fingerprint, options, settings, format) {
+  const output = { ...format };
+  let reader, staged;
+  try {
+    reader = await openRetainedMedia(archive, fingerprint, options, settings);
+    const inventory = reader;
+    async function* locations() {
+      for await (const item of inventory.summaries()) yield item.location;
+    }
+    if (output.operation === "media.get" && reader.count !== 1)
+      throw new RetainedMediaSelectionError(
+        reader.count ? "ambiguous-selection" : "missing-selection",
+        locations,
+        reader.close
+      );
+    async function* render() {
+      if (output.json) {
+        yield* streamJson({
+          version: 1,
+          operation: output.operation,
+          ok: true,
+          data: {
+            occurrences: inventory.occurrences(),
+            media: inventory.media(),
+            playbackVerified: false
+          },
+          warnings: [],
+          errors: [],
+          affected: 0,
+          locations: locations()
+        });
+        yield* literal("\n");
+      } else {
+        yield* literal("Media occurrences: " + inventory.count + "\n");
+        for await (const item of inventory.summaries()) {
+          yield* literal(item.kind + " ");
+          yield* streamJson(item.name ?? (() => literal(item.sourcePart)));
+          yield* literal(": " + item.embedded + " embedded, " + item.linked + " linked\n");
+        }
+        yield* literal(
+          "External targets remain inert. Metadata parsing does not prove playback.\n"
+        );
+      }
+    }
+    staged = await stageRetainedOutput(render(), settings, output.maxOutputBytes);
+    await reader.close();
+    return { output: staged, ok: true };
+  } catch (error) {
+    if (error instanceof RetainedMediaSelectionError) {
+      return { output: await stageRetainedMediaSelectionError(error, settings, output), ok: false };
+    }
+    await Promise.allSettled([reader?.close(), staged?.close()]);
+    throw error;
+  }
+}
+async function stageRetainedMediaSelectionError(selection, settings, format) {
+  const output = { ...format };
+  let staged;
+  async function* render() {
+    if (output.json) {
+      yield* streamJson({
+        version: 1,
+        operation: output.operation,
+        ok: false,
+        data: null,
+        warnings: [],
+        errors: [
+          {
+            code: selection.code,
+            message: selection.message,
+            context: { phase: "select", candidates: selection.candidates() }
+          }
+        ],
+        affected: 0,
+        locations: []
+      });
+      yield* literal("\n");
+    } else yield* literal("pptx: " + selection.code + ": " + selection.message + "\n");
+  }
+  try {
+    staged = await stageRetainedOutput(render(), settings, output.maxOutputBytes);
+    await selection.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([selection.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/media.ts
+var presentation = [
+  "http://schemas.openxmlformats.org/presentationml/2006/main",
+  "http://purl.oclc.org/ooxml/presentationml/main"
+];
+var drawing = [
+  "http://schemas.openxmlformats.org/drawingml/2006/main",
+  "http://purl.oclc.org/ooxml/drawingml/main"
+];
+var relationships = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships"
+];
+var mediaNamespace2 = "http://schemas.microsoft.com/office/powerpoint/2010/main";
+var mediaRelationship2 = "http://schemas.microsoft.com/office/2007/relationships/media";
+function walk(node) {
+  return [node, ...node.children.flatMap(walk)];
+}
+function relationshipKind2(type) {
+  if (relationships.some((ns) => type === `${ns}/video`)) return "video";
+  if (relationships.some((ns) => type === `${ns}/audio`)) return "audio";
+  return type === mediaRelationship2 ? "unknown" : null;
+}
+function validateMediaOptions(options) {
+  const scopes = [
+    "slides",
+    "layouts",
+    "masters",
+    "notes",
+    "notes-master",
+    "handout-master",
+    "shared"
+  ];
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some(
+    (key) => typeof key !== "string" || !["scope", "slide", "shape", "select"].includes(key) || !("value" in Object.getOwnPropertyDescriptor(options, key))
+  ) || options.scope !== void 0 && !scopes.includes(options.scope) || options.select !== void 0 && (typeof options.select !== "string" || !options.select.length))
+    throw new OfficeError("invalid-value", "Invalid media selection options.", "usage");
+  for (const key of ["slide"])
+    if (options[key] !== void 0 && (!Number.isSafeInteger(options[key]) || options[key] < 1))
+      throw new OfficeError(
+        "invalid-value",
+        "Media positions require positive safe integers.",
+        "usage"
+      );
+  if (options.shape !== void 0 && (typeof options.shape !== "string" || !options.shape.length || options.slide === void 0))
+    throw new SelectionError("invalid-selection");
+  if (options.select !== void 0 && [options.scope, options.slide, options.shape].some((value) => value !== void 0))
+    throw new SelectionError("invalid-selection");
+}
+async function readMedia(input, options, context) {
+  validateMediaOptions(options);
+  const source = await readBinary(input, context);
+  const reader = await readPackage(source, context);
+  const index = await readSelectionIndex(source, context);
+  const selected = options.select ? index.select({ token: options.select }) : void 0;
+  const occurrences = [];
+  const related = (owner, type) => index.inventory.relationships.filter(
+    (edge) => edge.owner === owner && !edge.external && relationships.some((ns) => edge.type === `${ns}/${type}`)
+  ).flatMap((edge) => edge.targetPart ? [edge.targetPart] : []);
+  const owners = index.parts.filter(
+    (owner) => owner.scope !== "shared" && (selected ? selected.some((record) => record.part === owner.part) : options.scope === "shared" || owner.scope === (options.scope ?? "slides")) && (options.slide === void 0 || index.inventory.slides.some(
+      (slide) => slide.position === options.slide && ([slide.part, slide.layout, slide.master].includes(owner.part) || related(slide.part, "notesSlide").some(
+        (notes) => notes === owner.part || related(notes, "notesMaster").includes(owner.part)
+      ))
+    ))
+  );
+  if (options.shape !== void 0) {
+    const matches = index.objects.filter(
+      (record) => owners.some((owner) => owner.part === record.part) && record.name === options.shape
+    );
+    if (matches.length !== 1)
+      throw new SelectionError(
+        matches.length ? "ambiguous-selection" : "missing-selection",
+        matches.map((record) => record.location)
+      );
+  }
+  owners.sort((left, right) => {
+    const a = index.slides.findIndex((slide) => slide.part === left.part);
+    const b = index.slides.findIndex((slide) => slide.part === right.part);
+    return (a < 0 ? Number.MAX_SAFE_INTEGER : a) - (b < 0 ? Number.MAX_SAFE_INTEGER : b) || (left.part < right.part ? -1 : left.part > right.part ? 1 : 0);
+  });
+  for (const owner of owners) {
+    context.signal?.throwIfAborted();
+    const document = parseXmlPart(reader.get(owner.part), context.xmlLimits);
+    const view = interpretCompatibility(
+      document,
+      [...presentation, ...drawing, ...relationships],
+      [
+        ...equationOpaqueElements,
+        ...presentation.map((namespace) => ({ namespace, localName: "ext" })),
+        ...drawing.flatMap(
+          (namespace) => ["ext", "graphicData"].map((localName) => ({ namespace, localName }))
+        )
+      ]
+    );
+    const activeWalk = (node) => [
+      node,
+      ...node.name.localName === "ext" && [...presentation, ...drawing].includes(node.name.namespace) ? node.children.flatMap(walk) : view.children(node).flatMap(activeWalk)
+    ];
+    const nodes = activeWalk(document.root);
+    const edges = index.inventory.relationships.filter((edge) => edge.owner === owner.part);
+    const consumed = /* @__PURE__ */ new Set();
+    const reference = (id) => {
+      const edge = edges.find((edge2) => edge2.id === id);
+      if (!edge) throw new OfficeError("missing-binding", "Media relationship is absent.", "index");
+      const part = edge.targetPart === null ? void 0 : index.inventory.parts.find((part2) => part2.part === edge.targetPart);
+      if (!edge.external && !part)
+        throw new OfficeError("missing-binding", "Media part is absent.", "index");
+      return {
+        relationshipId: edge.id,
+        relationshipType: edge.type,
+        target: edge.target,
+        external: edge.external,
+        mediaPart: edge.targetPart,
+        contentType: part?.contentType ?? null,
+        bytes: part?.bytes ?? null,
+        sha256: part?.sha256 ?? null
+      };
+    };
+    const bindings = (node) => node.attributes.filter(
+      (attribute) => relationships.includes(attribute.name.namespace) && ["embed", "link", "id"].includes(attribute.name.localName)
+    );
+    const metadata = (node) => ({
+      namespace: node.name.namespace,
+      name: node.name.localName,
+      xml: document.markup(node, true),
+      relationships: [
+        ...new Set(
+          walk(node).flatMap((element) => bindings(element).map((binding) => binding.value))
+        )
+      ].map(reference)
+    });
+    for (const record of index.objects.filter((record2) => record2.part === owner.part)) {
+      if (options.shape !== void 0 && options.shape !== record.name) continue;
+      if (selected && !selected.some(
+        (item) => item.part === owner.part && (item.kind !== "object" || item.id === record.id)
+      ))
+        continue;
+      const shape = nodes.find(
+        (node) => presentation.includes(node.name.namespace) && ["pic", "sp", "graphicFrame"].includes(node.name.localName) && node.children.some(
+          (nv) => nv.children.some(
+            (identity) => presentation.includes(identity.name.namespace) && identity.name.localName === "cNvPr" && attr(identity, "id") === record.id
+          )
+        )
+      );
+      if (!shape) continue;
+      const children = activeWalk(shape);
+      const mediaNodes = children.filter(
+        (node) => drawing.includes(node.name.namespace) && ["videoFile", "audioFile", "wavAudioFile"].includes(node.name.localName) || node.name.namespace === mediaNamespace2 && node.name.localName === "media"
+      );
+      if (!mediaNodes.length) continue;
+      const refs = [];
+      for (const node of mediaNodes) {
+        const nodeBindings = bindings(node);
+        if (!nodeBindings.length)
+          throw new OfficeError(
+            "missing-binding",
+            "Media reference has no relationship binding.",
+            "index"
+          );
+        for (const binding of nodeBindings) {
+          const ref = reference(binding.value);
+          const expected = node.name.localName === "videoFile" ? "video" : node.name.localName === "media" ? "unknown" : "audio";
+          if (relationshipKind2(ref.relationshipType) !== expected)
+            throw new OfficeError(
+              "missing-binding",
+              "Media relationship has the wrong type.",
+              "index"
+            );
+          consumed.add(ref.relationshipId);
+          if (!refs.some((existing) => existing.relationshipId === ref.relationshipId))
+            refs.push(ref);
+        }
+      }
+      const posters = children.filter((node) => drawing.includes(node.name.namespace) && node.name.localName === "blip").flatMap(
+        (node) => bindings(node).map((binding) => {
+          const ref = reference(binding.value);
+          if (!relationships.some((ns) => ref.relationshipType === `${ns}/image`))
+            throw new OfficeError(
+              "missing-binding",
+              "Poster relationship has the wrong type.",
+              "index"
+            );
+          return ref;
+        })
+      );
+      const extensionNodes = children.filter(
+        (node) => node.name.namespace === mediaNamespace2 && node.name.localName === "media"
+      );
+      const captions = children.filter(
+        (node) => node.name.namespace === "http://schemas.microsoft.com/office/powerpoint/2017/3/main" && node.name.localName === "tracksInfo"
+      ).map(metadata);
+      const timing = nodes.filter(
+        (node) => presentation.includes(node.name.namespace) && [
+          "audio",
+          "video",
+          "anim",
+          "animEffect",
+          "animMotion",
+          "animRot",
+          "animScale",
+          "cmd",
+          "set"
+        ].includes(node.name.localName) && walk(node).some(
+          (target) => presentation.includes(target.name.namespace) && target.name.localName === "spTgt" && attr(target, "spid") === record.id
+        )
+      ).map(metadata);
+      const kinds = [
+        ...new Set(
+          refs.map((ref) => {
+            const kind = relationshipKind2(ref.relationshipType);
+            return kind === "unknown" ? ref.contentType?.startsWith("video/") ? "video" : ref.contentType?.startsWith("audio/") ? "audio" : "unknown" : kind;
+          }).filter((kind) => kind === "audio" || kind === "video")
+        )
+      ];
+      occurrences.push({
+        id: `${owner.part}#media-${record.id}`,
+        location: record.location,
+        sourcePart: owner.part,
+        shapeId: record.id,
+        shapeName: record.name,
+        kind: kinds.length === 1 ? kinds[0] : "unknown",
+        relationships: refs,
+        posters,
+        playback: extensionNodes.map(metadata),
+        captions,
+        timing
+      });
+    }
+    if (options.shape === void 0 && !selected?.some((record) => record.kind === "object")) {
+      for (const edge of edges.filter(
+        (edge2) => relationshipKind2(edge2.type) !== null && !consumed.has(edge2.id)
+      )) {
+        occurrences.push({
+          id: `${owner.part}#media-relationship-${edge.id}`,
+          location: owner.location,
+          sourcePart: owner.part,
+          shapeId: null,
+          shapeName: null,
+          kind: relationshipKind2(edge.type),
+          relationships: [reference(edge.id)],
+          posters: [],
+          playback: [],
+          captions: [],
+          timing: []
+        });
+      }
+    }
+  }
+  const media = [];
+  for (const part of [
+    ...new Set(
+      occurrences.flatMap(
+        (occurrence) => occurrence.relationships.flatMap((ref) => ref.mediaPart ? [ref.mediaPart] : [])
+      )
+    )
+  ].sort()) {
+    const info = index.inventory.parts.find((info2) => info2.part === part);
+    media.push({
+      part,
+      contentType: info.contentType,
+      bytes: info.bytes,
+      sha256: info.sha256,
+      sha1: Array.from(sha12(reader.get(part)), (byte) => byte.toString(16).padStart(2, "0")).join(
+        ""
+      ),
+      occurrenceIds: occurrences.filter((occurrence) => occurrence.relationships.some((ref) => ref.mediaPart === part)).map((occurrence) => occurrence.id)
+    });
+  }
+  return { occurrences, media, playbackVerified: false };
+}
+
+export {
+  RetainedMediaSelectionError,
+  openRetainedMedia,
+  stageRetainedMedia,
+  stageRetainedMediaSelectionError,
+  validateMediaOptions,
+  readMedia
+};