@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,205 @@
+import {
+  sanitizeProperties
+} from "./chunk-W5YFDYHO.js";
+import {
+  attr,
+  invalid,
+  loadShared,
+  relPart
+} from "./chunk-RAXJVM4U.js";
+import {
+  readPackage
+} from "./chunk-FRZ5P5AB.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/sanitize.ts
+var namespaces = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships"
+];
+var modern = "http://schemas.microsoft.com/office/2018/10/relationships";
+function category(edge) {
+  for (const ns of namespaces) {
+    if ([`${ns}/notesSlide`, `${ns}/notesMaster`].includes(edge.type)) return "notes";
+    if ([`${ns}/comments`, `${ns}/commentAuthors`].includes(edge.type)) return "comments";
+    if ([`${ns}/extended-properties`, `${ns}/custom-properties`].includes(edge.type)) return "properties";
+    if ([`${ns}/oleObject`, `${ns}/package`].includes(edge.type)) return "objects";
+    if (edge.type === `${ns}/hyperlink` && edge.external) return "links";
+  }
+  if ([`${modern}/comments`, `${modern}/authors`].includes(edge.type)) return "comments";
+  if (edge.type === "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties") return "properties";
+  return void 0;
+}
+function walk(root) {
+  const result = [];
+  const pending = [{ node: root, ancestors: [] }];
+  while (pending.length) {
+    const entry = pending.pop();
+    result.push({ ...entry, ...entry.ancestors.length ? { parent: entry.ancestors.at(-1) } : {} });
+    for (const node of [...entry.node.children].reverse()) pending.push({ node, ancestors: [...entry.ancestors, entry.node] });
+  }
+  return result;
+}
+function references(node, id) {
+  return node.attributes.some((a) => namespaces.includes(a.name.namespace) && a.value === id);
+}
+function isDrawing(node, names) {
+  return ["http://schemas.openxmlformats.org/drawingml/2006/main", "http://purl.oclc.org/ooxml/drawingml/main"].includes(node.name.namespace) && names.includes(node.name.localName);
+}
+function isPresentation(node, names) {
+  return ["http://schemas.openxmlformats.org/presentationml/2006/main", "http://purl.oclc.org/ooxml/presentationml/main"].includes(node.name.namespace) && names.includes(node.name.localName);
+}
+async function sanitize(input, options, context) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((k) => !["remove", "allowEmpty"].includes(k)) || !Array.isArray(options.remove) || !options.remove.length || options.remove.some((k) => !["notes", "comments", "properties", "links", "objects"].includes(k)) || new Set(options.remove).size !== options.remove.length || options.allowEmpty !== void 0 && typeof options.allowEmpty !== "boolean") invalid("An explicit nonempty sanitization policy is required.");
+  const s = await loadShared(input, context);
+  const edges = s.index.inventory.relationships;
+  const removed = [], retained = [];
+  const cut = /* @__PURE__ */ new Set();
+  const candidates = /* @__PURE__ */ new Map();
+  const types = parseContentTypes(s.reader.get("/[Content_Types].xml"), { ...context.xmlLimits, maxEntries: context.archiveLimits.maxMembers });
+  const isXml = (part) => {
+    const type = types.get(part).split(";", 1)[0].trim();
+    return type.endsWith("+xml") || type === "application/xml" || type === "text/xml";
+  };
+  if (options.remove.includes("properties")) {
+    const cleaned = await readPackage((await sanitizeProperties(s.source, context)).bytes, context);
+    for (const edge of edges.filter((e) => category(e) === "properties" && e.targetPart)) {
+      const part = edge.targetPart;
+      const before = s.doc(part), after = parseXmlPart(cleaned.get(part), context.xmlLimits);
+      if (before.markup(before.root, true) === after.markup(after.root, true)) continue;
+      const remaining = after.root.children.map((node) => after.markup(node, true));
+      for (const node of before.root.children) {
+        const markup = before.markup(node, true), at = remaining.indexOf(markup);
+        if (at >= 0) remaining.splice(at, 1);
+        else removed.push({ category: "properties", kind: "element", part, reason: `Supported scalar property removed: {${node.name.namespace}}${node.name.localName}.` });
+      }
+      s.save(part, after);
+    }
+  }
+  const retainedNotes = edges.some((edge) => edge.type === `${s.r}/notesSlide` && edge.targetPart && (edges.some((incoming) => incoming.targetPart === edge.targetPart && incoming.type !== `${s.r}/notesSlide`) || edge.owner !== "/" && isXml(edge.owner) && walk(s.doc(edge.owner).root).some(({ node }) => references(node, edge.id))));
+  for (const edge of edges) {
+    context.signal?.throwIfAborted();
+    const selected = category(edge);
+    if (!selected || selected === "properties" || !options.remove.includes(selected)) continue;
+    if (retainedNotes && edge.type === `${s.r}/notesMaster`) continue;
+    if (edge.type === `${s.r}/notesSlide` && edge.targetPart && edges.some((incoming) => incoming.targetPart === edge.targetPart && incoming.type !== `${s.r}/notesSlide`)) {
+      retained.push({ category: "notes", kind: "relationship", part: edge.owner, relationshipId: edge.id, target: edge.target, reason: "Shared notes retain their reciprocal slide and master associations." });
+      continue;
+    }
+    let doc;
+    if (edge.owner !== "/" && isXml(edge.owner)) doc = s.doc(edge.owner);
+    const refs = doc ? walk(doc.root).filter(({ node }) => references(node, edge.id)) : [];
+    if (selected === "objects" && (!doc || !isPresentation(doc.root, ["sld", "sldLayout", "sldMaster", "notes", "notesMaster"]) || !refs.length)) {
+      retained.push({ category: selected, kind: "relationship", part: edge.owner, relationshipId: edge.id, target: edge.target, reason: "Embedded resource belongs to retained content or an unsupported consumer." });
+      continue;
+    }
+    const targets = [];
+    let safe = true;
+    for (const entry of refs) {
+      if (selected === "links" && isDrawing(entry.node, ["hlinkClick", "hlinkHover", "hlinkMouseOver"])) targets.push(entry.node);
+      else if (selected === "notes" && isPresentation(entry.node, ["notesMasterId"])) targets.push(entry.parent && isPresentation(entry.parent, ["notesMasterIdLst"]) && entry.parent.children.length === 1 ? entry.parent : entry.node);
+      else if (selected === "objects" && isPresentation(entry.node, ["oleObj"])) {
+        const frame = [...entry.ancestors].reverse().find((node) => isPresentation(node, ["graphicFrame"]));
+        if (frame) targets.push(frame);
+        else safe = false;
+      } else safe = false;
+    }
+    if (!safe) {
+      retained.push({ category: selected, kind: "relationship", part: edge.owner, relationshipId: edge.id, target: edge.target, reason: "Unsupported relationship consumer retained with its target." });
+      continue;
+    }
+    if (doc) {
+      const original = doc;
+      const paths = walk(original.root).filter(({ node, ancestors }) => targets.includes(node) && !ancestors.some((a) => targets.includes(a))).map(({ node, ancestors }) => {
+        let current = original.root;
+        return [...ancestors.slice(1), node].map((next) => {
+          const at = current.children.indexOf(next);
+          current = next;
+          return at;
+        });
+      });
+      for (const path of paths.reverse()) {
+        let parent = doc.root;
+        for (const at of path.slice(0, -1)) parent = parent.children[at];
+        doc = doc.spliceChildren(parent, path.at(-1), 1, []);
+        removed.push({ category: selected, kind: "element", part: edge.owner, relationshipId: edge.id, reason: "Selected relationship consumer removed; adjacent content retained." });
+      }
+      if (doc !== original) s.save(edge.owner, doc);
+    }
+    cut.add(edge);
+    if (edge.targetPart) candidates.set(edge.targetPart, selected);
+  }
+  const protectedParts = /* @__PURE__ */ new Set([s.main, ...s.index.inventory.slides.map((x) => x.part), ...s.index.inventory.masters, ...s.index.inventory.layouts, ...s.index.inventory.themes]);
+  const pending = [...candidates.keys()];
+  while (pending.length) {
+    const owner = pending.pop();
+    for (const edge of edges.filter((e) => e.owner === owner && !e.external)) {
+      if (edge.targetPart && (category(edge) === "notes" || namespaces.some((ns) => [`${ns}/image`, `${ns}/audio`, `${ns}/video`].includes(edge.type))) && !protectedParts.has(edge.targetPart) && !candidates.has(edge.targetPart)) {
+        candidates.set(edge.targetPart, "resources");
+        pending.push(edge.targetPart);
+      }
+    }
+  }
+  const deletable = new Set([...candidates.keys()].filter((part) => !protectedParts.has(part)));
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const part of deletable) if (edges.some((e) => e.targetPart === part && !cut.has(e) && !deletable.has(e.owner))) {
+      deletable.delete(part);
+      changed = true;
+    }
+  }
+  const retainedComments = edges.some((e) => category(e) === "comments" && e.type.endsWith("/comments") && e.targetPart && !deletable.has(e.targetPart));
+  if (retainedComments) {
+    for (const edge of [...cut]) if (edge.type.endsWith("/authors") || edge.type.endsWith("/commentAuthors")) {
+      cut.delete(edge);
+      if (edge.targetPart) deletable.delete(edge.targetPart);
+    }
+    changed = true;
+    while (changed) {
+      changed = false;
+      for (const part of deletable) if (edges.some((e) => e.targetPart === part && !cut.has(e) && !deletable.has(e.owner))) {
+        deletable.delete(part);
+        changed = true;
+      }
+    }
+  }
+  for (const edge of cut) {
+    const ownerRel = edge.owner === "/" ? "/_rels/.rels" : relPart(edge.owner);
+    const doc = s.doc(ownerRel);
+    const at = doc.root.children.findIndex((n) => attr(n, "Id") === edge.id);
+    if (at >= 0) s.save(ownerRel, doc.spliceChildren(doc.root, at, 1, []));
+    removed.push({ category: category(edge), kind: "relationship", part: edge.owner, relationshipId: edge.id, target: edge.target, reason: "Selected relationship removed." });
+  }
+  for (const part of deletable) {
+    s.deleted.add(part);
+    if (s.reader.has(relPart(part))) s.deleted.add(relPart(part));
+    removed.push({ category: candidates.get(part), kind: "part", part, reason: "Selected part or exclusively owned dependency removed." });
+  }
+  if (deletable.size) {
+    let doc = s.doc("/[Content_Types].xml");
+    for (let at = doc.root.children.length - 1; at >= 0; at--) if (deletable.has(attr(doc.root.children[at], "PartName") ?? "")) doc = doc.spliceChildren(doc.root, at, 1, []);
+    s.save("/[Content_Types].xml", doc);
+  }
+  for (const part of s.reader.names.filter((n) => !s.deleted.has(n))) {
+    retained.push({ category: candidates.get(part) ?? "unknown", kind: "part", part, reason: candidates.has(part) ? "Retained because shared or structurally required; may still contain selected data." : "Retained package content; hidden or unsupported data is not certified absent." });
+    if (part !== "/[Content_Types].xml" && isXml(part)) for (const { node } of walk(s.doc(part).root)) {
+      if (isDrawing(node, ["hlinkClick", "hlinkHover", "hlinkMouseOver"])) retained.push({ category: "links", kind: "element", part, reason: "Internal navigation or unsupported action retained inert; no activation performed." });
+    }
+  }
+  for (const edge of edges.filter((e) => e.external && !cut.has(e) && !s.deleted.has(e.owner))) retained.push({ category: category(edge) ?? "unknown", kind: "relationship", part: edge.owner, relationshipId: edge.id, target: edge.target, reason: "External relationship retained; unsupported consumers and non-hyperlink resources are preserve-only." });
+  if (!removed.length && !options.allowEmpty) throw new OfficeError("missing-selection", "No removable content matched the explicit policy.", "select");
+  return { bytes: removed.length ? (await s.finish(s.main, [])).bytes : s.source, affected: removed.filter((entry) => entry.category === "properties" && entry.kind === "element").length + [...cut].filter((edge) => !edge.type.endsWith("/notesMaster") && !edge.type.endsWith("/authors") && !edge.type.endsWith("/commentAuthors")).length, removed, retained, warnings: ["Only explicitly selected supported content was removed. Retained content may contain hidden data; no clean-file claim is made."] };
+}
+
+export {
+  sanitize
+};

package/dist/safe-bash/command-chunks/{chunk-W5OR7COJ.js → chunk-PVLPWVRH.js}

@@ -1,37 +1,37 @@
-import {
-  nodeSourceLocation
-} from "./chunk-5FMXQUDY.js";
-import {
-  nodeReadFile
-} from "./chunk-GDAS4LY7.js";
 import {
   createSafeJsCommands
-} from "./chunk-CB3HTIDK.js";
+} from "./chunk-XNJ67APB.js";
 import {
   onlyKeys,
   record
-} from "./chunk-YJ3TFZB2.js";
-import {
-  DEFAULT_NODE_VERSION,
-  createDefaultSafeJsRuntime
-} from "./chunk-22JWEBPL.js";
-import {
-  createNodePathModule
-} from "./chunk-D4K44JKA.js";
+} from "./chunk-LRDME6WV.js";
 import {
   timerBindings,
   timerSource
-} from "./chunk-AITNVBXO.js";
-import {
-  SafeJsCommandLimitError
-} from "./chunk-G3YO3JIN.js";
+} from "./chunk-2ANW3FXH.js";
 import {
   bufferBindings,
   bufferSource
-} from "./chunk-B5F2KQYA.js";
+} from "./chunk-SWUVHT7G.js";
+import {
+  nodeSourceLocation
+} from "./chunk-UZOGSYJP.js";
+import {
+  nodeReadFile
+} from "./chunk-OEKLEUUW.js";
 import {
   commandLimits
-} from "./chunk-MRFW2E6B.js";
+} from "./chunk-457CU3IC.js";
+import {
+  SafeJsCommandLimitError
+} from "./chunk-JJK3CU7Z.js";
+import {
+  DEFAULT_NODE_VERSION,
+  createDefaultSafeJsRuntime
+} from "./chunk-22JWEBPL.js";
+import {
+  createNodePathModule
+} from "./chunk-D4K44JKA.js";
 
 // packages/safe-bash-command-node/src/commands/node/safejs.ts
 import { hmac as nobleHmac } from "@noble/hashes/hmac.js";

package/dist/safe-bash/command-chunks/{chunk-BNG4ZMZ3.js → chunk-PXL4NBYP.js}

@@ -1,7 +1,3 @@
-import {
-  validateAttachmentUrl
-} from "./chunk-OTEHQQU7.js";
-
 // packages/safe-bash-command-llm/src/json-value.ts
 function jsonValue(value, signal) {
   const ancestors = /* @__PURE__ */ new Set();
@@ -133,81 +129,8 @@ async function* sourceBytes(source, signal) {
   }
 }
 
-// packages/safe-bash-command-llm/src/base64-stream.ts
-async function* base64Stream(source, signal) {
-  let remainder = new Uint8Array(0);
-  for await (const input of sourceBytes(source, signal)) {
-    signal.throwIfAborted();
-    for (let position = 0; position < input.length; position += 8190) {
-      signal.throwIfAborted();
-      const next = input.subarray(position, position + 8190);
-      const bytes = new Uint8Array(remainder.length + next.length);
-      bytes.set(remainder);
-      bytes.set(next, remainder.length);
-      const length = bytes.length - bytes.length % 3;
-      if (length) yield btoa(String.fromCharCode(...bytes.subarray(0, length)));
-      remainder = bytes.slice(length);
-    }
-  }
-  signal.throwIfAborted();
-  if (remainder.length) yield btoa(String.fromCharCode(...remainder));
-}
-
-// packages/safe-bash-command-llm/src/attachment-id.ts
-import { sha256 } from "../../safe-bash-checksum-engine/sha256.js";
-import { yieldTurn } from "../../safe-bash-contracts/yield.js";
-function attachmentDigestHex(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-async function getLlmAttachmentUrlId(url, signal) {
-  signal.throwIfAborted();
-  if (url !== null) validateAttachmentUrl(url);
-  const hash = sha256.create(), encoder = new TextEncoder();
-  try {
-    hash.update(encoder.encode('{"url": '));
-    if (url === null) hash.update(encoder.encode("null"));
-    else {
-      hash.update(Uint8Array.of(34));
-      for (let offset = 0; offset < url.length; offset += 2048) {
-        signal.throwIfAborted();
-        if (offset && offset % 16384 === 0) await yieldTurn(signal);
-        const json = JSON.stringify(url.slice(offset, offset + 2048)).slice(1, -1);
-        let ascii = "";
-        for (let index = 0; index < json.length; index++) {
-          const code = json.charCodeAt(index);
-          ascii += code >= 127 ? "\\u" + code.toString(16).padStart(4, "0") : json[index];
-        }
-        hash.update(encoder.encode(ascii));
-      }
-      hash.update(Uint8Array.of(34));
-    }
-    hash.update(Uint8Array.of(125));
-    return attachmentDigestHex(hash.digest());
-  } finally {
-    hash.destroy();
-  }
-}
-async function attachmentBytesId(bytes, signal) {
-  const hash = sha256.create();
-  try {
-    for (let offset = 0; offset < bytes.length; offset += 16384) {
-      signal.throwIfAborted();
-      if (offset && offset % 1048576 === 0) await yieldTurn(signal);
-      hash.update(bytes.subarray(offset, offset + 16384));
-    }
-    signal.throwIfAborted();
-    return attachmentDigestHex(hash.digest());
-  } finally {
-    hash.destroy();
-  }
-}
-
 export {
   jsonValue,
   waitForSource,
-  sourceBytes,
-  base64Stream,
-  attachmentDigestHex,
-  getLlmAttachmentUrlId,
-  attachmentBytesId
+  sourceBytes
 };

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

@@ -0,0 +1,41 @@
+import {
+  resolveDocumentModelContext
+} from "./chunk-KB3CY3QO.js";
+import {
+  Image,
+  acquireImageModelInput
+} from "./chunk-A7EMM3SB.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+
+// packages/safe-bash-docx-engine/src/image-batch-operations.ts
+var imageBatchActions = /* @__PURE__ */ new Map();
+var prefix = "model.image.image.Image";
+imageBatchActions.set(`${prefix}.from_blob.call`, async (_receiver, args, context) => {
+  if (!(args.blob instanceof Uint8Array) && (!args.blob || typeof args.blob !== "object" || args.blob.kind !== "bytes")) throw new DocxUsageError("Image.from_blob requires owned bytes.");
+  const selected = await resolveDocumentModelContext(args.context, context);
+  const acquired = await acquireImageModelInput(args.blob, selected);
+  return Image.from_blob(acquired.bytes, acquired.context);
+});
+imageBatchActions.set(`${prefix}.from_file.call`, async (_receiver, args, context) => {
+  const selected = await resolveDocumentModelContext(args.context, context);
+  const descriptor = args.imageDescriptor;
+  if (!(descriptor instanceof Uint8Array) && "path" in descriptor) return Image.from_file({ path: descriptor.path, capability: descriptor.capability }, selected);
+  const acquired = await acquireImageModelInput(descriptor, selected);
+  return Image.from_blob(acquired.bytes, acquired.context);
+});
+for (const name of ["blob", "content_type", "ext", "filename", "px_width", "px_height", "horz_dpi", "vert_dpi", "width", "height", "sha1"]) {
+  imageBatchActions.set(`${prefix}.${name}.get`, (receiver) => {
+    if (!(receiver instanceof Image)) throw new DocxUsageError("The receiver is not an admitted Image.");
+    return receiver[name];
+  });
+}
+imageBatchActions.set(`${prefix}.scaled_dimensions.call`, (receiver, args) => {
+  if (!(receiver instanceof Image)) throw new DocxUsageError("The receiver is not an admitted Image.");
+  return receiver.scaled_dimensions(args.width, args.height);
+});
+
+export {
+  imageBatchActions
+};

package/dist/safe-bash/command-chunks/{chunk-KLCHCSIV.js → chunk-QGD64UHJ.js}

@@ -1,6 +1,6 @@
 import {
   withSignal
-} from "./chunk-OOB7YCFQ.js";
+} from "./chunk-FMJKCVSQ.js";
 import {
   CurlError
 } from "./chunk-QYXWTNUN.js";

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

@@ -0,0 +1,188 @@
+import {
+  applyShapeUpdate,
+  createShapeXml,
+  readShape,
+  validateShapeOptions
+} from "./chunk-HHLVI2CB.js";
+import {
+  ShapeIdAllocator
+} from "./chunk-RZC7QHL6.js";
+import {
+  readShapeGeometry
+} from "./chunk-TGHQGJNR.js";
+import {
+  attr,
+  child,
+  loadShared,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/shape-operations.ts
+function validateSelection(options, action) {
+  const allowed = [
+    "scope",
+    "slide",
+    "part",
+    "shape",
+    "select",
+    ...action === "read" ? [] : ["update"],
+    ...action === "set" ? ["all", "allowEmpty"] : []
+  ];
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((key) => !allowed.includes(key)))
+    throw new OfficeError("invalid-value", "Invalid shape selection options.", "usage");
+  for (const key of ["part", "shape", "select"])
+    if (options[key] !== void 0 && (typeof options[key] !== "string" || !options[key].length))
+      throw new OfficeError("invalid-value", "Shape selectors require nonempty strings.", "usage");
+  for (const key of ["all", "allowEmpty"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean")
+      throw new OfficeError("invalid-value", "Selection controls require booleans.", "usage");
+  if (options.slide !== void 0 && (!Number.isSafeInteger(options.slide) || options.slide < 1))
+    throw new OfficeError(
+      "invalid-value",
+      "Slide position requires a positive safe integer.",
+      "usage"
+    );
+  if (options.scope !== void 0 && !["slides", "layouts", "masters", "shared"].includes(options.scope))
+    throw new OfficeError("invalid-value", "Unsupported shape scope.", "usage");
+  if (options.part && options.slide !== void 0 || options.select && (options.slide !== void 0 || options.part !== void 0 || options.shape !== void 0 || options.all))
+    throw new SelectionError("invalid-selection");
+}
+function selected(s, options, adding = false) {
+  if (options.select && (options.slide !== void 0 || options.part !== void 0 || options.shape !== void 0 || options.all))
+    throw new SelectionError("invalid-selection");
+  if (options.part && options.slide !== void 0) throw new SelectionError("invalid-selection");
+  if (options.slide !== void 0 && (!Number.isSafeInteger(options.slide) || options.slide < 1))
+    throw new SelectionError("invalid-selection");
+  const scope = options.scope ?? "slides";
+  if (!["slides", "layouts", "masters", "shared"].includes(scope))
+    throw new SelectionError("invalid-selection");
+  let records = adding ? s.index.parts : s.index.objects;
+  if (options.select) {
+    const targets = s.index.select({ token: options.select });
+    if (options.scope !== void 0 && options.scope !== "shared" && targets.some((x) => x.scope !== options.scope))
+      throw new SelectionError("invalid-selection");
+    if (targets.some((x) => !["slides", "layouts", "masters"].includes(x.scope)))
+      throw new SelectionError("invalid-selection");
+    records = records.filter(
+      (x) => targets.some(
+        (t) => adding ? t.part === x.part && t.kind !== "object" : t.part === x.part && (t.kind !== "object" || t.id === x.id)
+      )
+    );
+  } else {
+    if (scope === "shared" && !options.part) throw new SelectionError("invalid-selection");
+    records = records.filter(
+      (x) => scope === "shared" ? ["slides", "layouts", "masters"].includes(x.scope) : x.scope === scope
+    );
+    if (options.part) records = records.filter((x) => x.part === options.part);
+    if (options.slide !== void 0) {
+      const slide = s.index.inventory.slides.find((x) => x.position === options.slide);
+      const part = scope === "masters" ? slide?.master : scope === "layouts" ? slide?.layout : slide?.part;
+      records = records.filter((x) => x.part === part);
+    }
+    if (options.shape !== void 0) records = records.filter((x) => x.name === options.shape);
+  }
+  return records;
+}
+function nodeFor(root, id) {
+  const pending = [root];
+  while (pending.length) {
+    const node = pending.shift();
+    const nv = node.name.namespace === root.name.namespace && ["sp", "pic", "graphicFrame", "cxnSp", "grpSp"].includes(node.name.localName) ? node.children.find(
+      (x) => x.name.namespace === root.name.namespace && ["nvSpPr", "nvPicPr", "nvGraphicFramePr", "nvCxnSpPr", "nvGrpSpPr"].includes(
+        x.name.localName
+      )
+    ) : void 0;
+    if (nv && Number.isInteger(Number(id)) && Number(id) >= 0 && Number(attr(required(nv, "cNvPr"), "id")) === Number(id))
+      return node;
+    pending.unshift(...node.children);
+  }
+  throw new SelectionError("missing-selection");
+}
+async function readShapes(input, options, context) {
+  validateSelection(options, "read");
+  const s = await loadShared(input, context, false);
+  return selected(s, options).map((record) => {
+    const root = s.doc(record.part).root;
+    const node = nodeFor(root, record.id);
+    return {
+      ...readShape(node),
+      geometry: readShapeGeometry(root, node),
+      location: record.location,
+      token: record.token,
+      part: record.part
+    };
+  });
+}
+async function mutateShapes(input, options, context) {
+  validateSelection(options, "set");
+  validateShapeOptions(options.update);
+  const s = await loadShared(input, context);
+  if (!options.select && options.shape === void 0 && options.slide === void 0 && !options.part && !options.all)
+    throw new SelectionError("invalid-selection");
+  const records = selected(s, options);
+  if (!records.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (records.length > 1 && !options.all)
+    throw new SelectionError(
+      "ambiguous-selection",
+      records.map((x) => x.location)
+    );
+  for (const record of records) {
+    const doc = s.doc(record.part);
+    s.save(record.part, applyShapeUpdate(doc, nodeFor(doc.root, record.id), options.update));
+  }
+  const result = await s.finish(
+    records[0]?.part ?? s.main,
+    s.index.inventory.slides.filter((x) => records.some((r) => [x.part, x.master, x.layout].includes(r.part))).map((x) => x.position)
+  );
+  return { ...result, affected: records.length, records };
+}
+async function addShape(input, options, context) {
+  validateSelection(options, "add");
+  validateShapeOptions(options.update, true);
+  if (options.shape !== void 0 || options.all || options.allowEmpty)
+    throw new SelectionError("invalid-selection");
+  const s = await loadShared(input, context);
+  const targets = selected(s, options, true);
+  if (targets.length !== 1)
+    throw new SelectionError(
+      targets.length ? "ambiguous-selection" : "missing-selection",
+      targets.map((x) => x.location)
+    );
+  const target = targets[0];
+  const doc = s.doc(target.part);
+  const tree = required(required(doc.root, "cSld"), "spTree");
+  const id = new ShapeIdAllocator(() => doc).next();
+  const extension = child(tree, "extLst");
+  s.save(
+    target.part,
+    doc.spliceChildren(
+      tree,
+      extension ? tree.children.indexOf(extension) : tree.children.length,
+      0,
+      [createShapeXml(options.update.kind, id, options.update, doc.root.name.namespace)]
+    )
+  );
+  return {
+    ...await s.finish(
+      target.part,
+      s.index.inventory.slides.filter((x) => [x.part, x.master, x.layout].includes(target.part)).map((x) => x.position)
+    ),
+    affected: 1,
+    records: [{ ...target, id: String(id) }]
+  };
+}
+
+export {
+  validateSelection,
+  selected,
+  nodeFor,
+  readShapes,
+  mutateShapes,
+  addShape
+};