@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,168 @@
+import {
+  validateArchiveNamespace
+} from "./chunk-BDYKJTBQ.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  PublicationError
+} from "./chunk-JGGRMERW.js";
+import {
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  displayXml
+} from "./chunk-YPVBU7QF.js";
+import {
+  compareInventoryNames
+} from "./chunk-2EUH5B6A.js";
+import {
+  asciiKey
+} from "./chunk-WAKYUXVQ.js";
+import {
+  isXmlContentType,
+  parseDocumentXmlAsync
+} from "./chunk-MWAAMNAM.js";
+import {
+  CancellationError,
+  InvalidContainerError,
+  ResourceLimitError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/extract.ts
+import { resolvePath } from "@poe-platform/safe-fs/core";
+var ArchiveExtractionError = class extends Error {
+  constructor(cause, data, cancelled = false) {
+    super(data.possiblePartialOutput ? "Archive extraction failed; partial new output may remain." : "Archive extraction destination refused.", { cause });
+    this.data = data;
+    this.code = cancelled ? "cancelled" : cause instanceof ResourceLimitError ? "limit-exceeded" : cause instanceof PublicationError && cause.code === "conflict" ? "conflict" : "unsupported-publication";
+  }
+  data;
+  code;
+};
+async function extractDocumentArchive(input, options, context) {
+  const host = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: "extract", inputs: ["-"], options }, host.budget);
+  const admitted = invocation.options;
+  const settings = archiveSettings({ ...context, budget: host.budget.lower(Object.fromEntries((admitted.limit ?? []).map((limit) => [limit.name, limit.value]))) });
+  const { budget, signal } = settings;
+  if (!admitted.outputDir?.startsWith("/")) throw new InvalidContainerError("Extraction requires an absolute VFS destination.");
+  const outputDir = resolvePath("/", admitted.outputDir), fs = context.filesystem;
+  const archive = await readDocumentArchive(input, settings);
+  validateArchiveNamespace(archive.members, budget);
+  const files = [];
+  for (const member of archive.members) {
+    if (member.directory || admitted.selection === "media-only" && !asciiKey(member.name).startsWith("word/media/")) continue;
+    let bytes = member.bytes;
+    if (admitted.pretty && (asciiKey(member.name) === "[content_types].xml" || isXmlContentType(archive.package.getPart("/" + member.name).content_type))) {
+      const parsed = await parseDocumentXmlAsync(bytes, {}, budget);
+      bytes = new TextEncoder().encode(displayXml(parsed.root, budget, true));
+      budget.charge("retainedBytes", bytes.length);
+    }
+    budget.charge("work", bytes.length);
+    budget.charge("retainedBytes", bytes.length + 128);
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes)));
+    files.push({ path: member.name, bytes, sha256: [...digest].map((b) => b.toString(16).padStart(2, "0")).join(""), published: false });
+  }
+  const directories = archive.members.filter((m) => m.directory && (admitted.selection !== "media-only" || asciiKey(m.name).startsWith("word/media/"))).map((m) => m.name.slice(0, -1));
+  const manifest = {
+    version: 1,
+    kind: archive.kind,
+    dialect: archive.dialect,
+    selection: admitted.selection ?? "all",
+    pretty: admitted.pretty ?? false,
+    directories,
+    entries: files.map((f) => ({ part: f.path === "[Content_Types].xml" ? f.path : "/" + f.path, path: f.path, contentType: f.path === "[Content_Types].xml" ? "application/xml" : archive.package.getPart("/" + f.path).content_type, bytes: f.bytes.length, sha256: f.sha256 })).sort((a, b) => compareInventoryNames(a.part, b.part))
+  };
+  const manifestText = JSON.stringify(manifest);
+  budget.check("serializedOutput", new TextEncoder().encode(manifestText).length);
+  budget.charge("retainedBytes", manifestText.length * 4);
+  const manifestBytes = new TextEncoder().encode(manifestText);
+  let possiblePartialOutput = false, manifestPublished = false;
+  const data = (complete) => ({
+    outputDir,
+    complete,
+    possiblePartialOutput: !complete && possiblePartialOutput,
+    entries: files.map((f) => ({ path: f.path, bytes: f.bytes.length, sha256: f.sha256, published: f.published })),
+    manifestPublished
+  });
+  const failureMessage = "Archive extraction failed; partial new output may remain.";
+  const receipt = JSON.stringify({
+    version: 1,
+    operation: "extract",
+    ok: false,
+    data: data(false),
+    affected: 0,
+    locations: [],
+    warnings: [],
+    errors: [{ code: "unsupported-publication", message: failureMessage }]
+  });
+  const receiptSize = new TextEncoder().encode(receipt).length + 1;
+  budget.check("serializedOutput", receiptSize);
+  budget.check("diagnosticBytes", new TextEncoder().encode(`docx: unsupported-publication: ${failureMessage}
+`).length);
+  budget.charge("retainedBytes", receiptSize * 12);
+  budget.charge("work", receiptSize * 12);
+  const parents = /* @__PURE__ */ new Map();
+  const capabilities = async (path) => {
+    const caps = fs.capabilitiesFor ? await fs.capabilitiesFor(path, { create: true, signal }) : fs.capabilities;
+    if (caps.readOnly || !caps.write || !caps.mkdir || !caps.explicitDirectories || !caps.atomicFileMutation || !caps.atomicDirectoryMetadata || !fs.prepareDirectory || !fs.writeFileConditional)
+      throw new Error("Destination lacks safe exclusive publication capabilities.");
+  };
+  const verifyDirectory = async (path) => {
+    const stat = await fs.lstat(path, { signal });
+    if (stat.type !== "directory" || await fs.realpath(path, { signal }) !== path) throw new Error("Destination directory aliases are not supported.");
+    await fs.access(path, 3, { signal });
+    return stat;
+  };
+  try {
+    await capabilities(outputDir);
+    const outer = outputDir.slice(0, outputDir.lastIndexOf("/")) || "/";
+    const outerStat = await verifyDirectory(outer);
+    try {
+      await fs.lstat(outputDir, { signal });
+      throw new PublicationError("conflict", "Destination already exists.");
+    } catch (error) {
+      if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") throw error;
+    }
+    possiblePartialOutput = true;
+    parents.set(outputDir, await fs.prepareDirectory(outputDir, { parent: outerStat, expected: null, mode: 448, signal }));
+    await verifyDirectory(outputDir);
+    const prepareParents = async (segments) => {
+      let parentPath = outputDir;
+      for (const segment of segments) {
+        const ancestor = parentPath;
+        parentPath += "/" + segment;
+        if (!parents.has(parentPath)) {
+          await capabilities(parentPath);
+          parents.set(parentPath, await fs.prepareDirectory(parentPath, { parent: parents.get(ancestor), expected: null, mode: 448, signal }));
+          await verifyDirectory(parentPath);
+        }
+      }
+      return parentPath;
+    };
+    for (const directory of directories) {
+      await budget.checkpoint(1);
+      await prepareParents(directory.split("/"));
+    }
+    for (const file of [...files, { path: "manifest.json", bytes: manifestBytes, published: false }]) {
+      await budget.checkpoint(file.bytes.length + 1);
+      const parentPath = await prepareParents(file.path.split("/").slice(0, -1));
+      const path = outputDir + "/" + file.path;
+      await capabilities(path);
+      await fs.writeFileConditional(path, file.bytes, { parent: parents.get(parentPath), expected: null, signal });
+      file.published = true;
+      if (file.path === "manifest.json") manifestPublished = true;
+    }
+    signal.throwIfAborted();
+    return data(true);
+  } catch (error) {
+    throw new ArchiveExtractionError(error, data(false), signal.aborted || error instanceof CancellationError);
+  }
+}
+
+export {
+  ArchiveExtractionError,
+  extractDocumentArchive
+};

package/dist/safe-bash/command-chunks/{chunk-SUYSZJI3.js → chunk-K5COUQAQ.js}

@@ -1,13 +1,13 @@
 import {
   playwrightStandardAbilities
-} from "./chunk-5RLK2QSY.js";
+} from "./chunk-7JEIWA3A.js";
+import {
+  playwrightCommandCatalog
+} from "./chunk-ZFNYL7XB.js";
 import {
   limitedForms,
   playwrightBuiltinCommands
 } from "./chunk-BLNP5WRP.js";
-import {
-  playwrightCommandCatalog
-} from "./chunk-ZFNYL7XB.js";
 
 // packages/safe-bash-command-playwright-cli/src/playwright/abilities.ts
 var builtinOptions = {

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

@@ -0,0 +1,489 @@
+import {
+  nodeFor,
+  selected,
+  validateSelection
+} from "./chunk-QHS7PDG3.js";
+import {
+  Length
+} from "./chunk-I6AMDG2T.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-groups.ts
+var shapeKinds = ["sp", "pic", "cxnSp", "graphicFrame", "grpSp"];
+function unsupported(message) {
+  throw new OfficeError("unsupported-edit", message, "validate-intent");
+}
+function descendants(root) {
+  const result = [], pending = [root];
+  while (pending.length) {
+    const next = pending.pop();
+    result.push(next);
+    pending.push(...next.children);
+  }
+  return result;
+}
+var parentIndexes = /* @__PURE__ */ new WeakMap();
+function parentOf(root, node) {
+  let index = parentIndexes.get(root);
+  if (!index) {
+    const owners = /* @__PURE__ */ new Map();
+    for (const parent2 of descendants(root))
+      for (const child2 of parent2.children) owners.set(child2, parent2);
+    index = owners;
+    parentIndexes.set(root, index);
+  }
+  const parent = index.get(node);
+  if (!parent) throw new SelectionError("invalid-selection");
+  return parent;
+}
+function geometry(node) {
+  const p = node.name.namespace;
+  const a = p === "http://purl.oclc.org/ooxml/presentationml/main" ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+  const owner = node.name.localName === "graphicFrame" ? node : required(node, node.name.localName === "grpSp" ? "grpSpPr" : "spPr");
+  const xfrm = child(owner, "xfrm", node.name.localName === "graphicFrame" ? p : a);
+  if (!xfrm) unsupported("Explicit geometry is required for grouping.");
+  const integer = (value, fallback) => {
+    if (value === void 0 && fallback !== void 0) return fallback;
+    const digits = value?.startsWith("-") || value?.startsWith("+") ? value.slice(1) : value;
+    if (!digits?.length || [...digits].some((c2) => c2 < "0" || c2 > "9") || !Number.isSafeInteger(Number(value)) || Math.abs(Number(value)) > 27273042316900)
+      unsupported("Geometry requires bounded integer coordinates.");
+    return Number(value);
+  };
+  const pair = (name, key) => integer(attr(child(xfrm, name, a) ?? unsupported("Missing transform coordinate."), key));
+  const x = pair("off", "x"), y = pair("off", "y"), w = pair("ext", "cx"), h = pair("ext", "cy");
+  if (w < 0 || h < 0 || node.name.localName !== "cxnSp" && (w === 0 || h === 0))
+    unsupported("Geometry requires positive extents except for connector axes.");
+  const angle = (integer(attr(xfrm, "rot"), 0) % 216e5 + 216e5) % 216e5;
+  const q = angle / 54e5;
+  const c = Number.isInteger(q) ? [1, 0, -1, 0][q] : Math.cos(angle * Math.PI / 108e5);
+  const s = Number.isInteger(q) ? [0, 1, 0, -1][q] : Math.sin(angle * Math.PI / 108e5);
+  const flip = (key) => {
+    const value = attr(xfrm, key);
+    if (value !== void 0 && !["0", "1", "true", "false"].includes(value))
+      unsupported("Invalid geometry reflection.");
+    return value === "1" || value === "true" ? -1 : 1;
+  };
+  const fx = flip("flipH"), fy = flip("flipV");
+  const map = (point) => {
+    if (angle === 0 && fx === 1 && fy === 1) return point;
+    const dx = (point.x - x - w / 2) * fx, dy = (point.y - y - h / 2) * fy;
+    return { x: x + w / 2 + dx * c - dy * s, y: y + h / 2 + dx * s + dy * c };
+  };
+  let cx = 0, cy = 0, cw = 1, ch = 1;
+  if (node.name.localName === "grpSp") {
+    cx = pair("chOff", "x");
+    cy = pair("chOff", "y");
+    cw = pair("chExt", "cx");
+    ch = pair("chExt", "cy");
+    if (cw <= 0 || ch <= 0) unsupported("Group child extents must be nonsingular.");
+  }
+  const identityMapping = x === cx && y === cy && w === cw && h === ch && angle === 0 && fx === 1 && fy === 1;
+  return {
+    x,
+    y,
+    w,
+    h,
+    xfrm,
+    a,
+    map,
+    identityMapping,
+    angle,
+    fx,
+    fy,
+    cx,
+    cy,
+    cw,
+    ch,
+    childMap: (point) => identityMapping ? point : map({ x: x + (point.x - cx) * w / cw, y: y + (point.y - cy) * h / ch })
+  };
+}
+function corners(root, node) {
+  const g = geometry(node);
+  let points = [
+    { x: g.x, y: g.y },
+    { x: g.x + g.w, y: g.y },
+    { x: g.x + g.w, y: g.y + g.h },
+    { x: g.x, y: g.y + g.h }
+  ].map(g.map);
+  let current = node;
+  while (current !== root) {
+    current = parentOf(root, current);
+    if (current.name.localName === "grpSp" && current.name.namespace === node.name.namespace)
+      points = points.map(geometry(current).childMap);
+  }
+  if (points.some(
+    (point) => !Number.isFinite(point.x) || !Number.isFinite(point.y) || Math.abs(point.x) > 27273042316900 || Math.abs(point.y) > 27273042316900
+  ))
+    unsupported("World geometry exceeds coordinate bounds.");
+  return points;
+}
+function identity(node) {
+  const nv = node.children.find(
+    (n) => n.name.namespace === node.name.namespace && ["nvSpPr", "nvGrpSpPr", "nvPicPr", "nvCxnSpPr", "nvGraphicFramePr"].includes(n.name.localName)
+  );
+  const value = nv && attr(required(nv, "cNvPr"), "id");
+  if (!value) unsupported("Shape identity is required.");
+  return value;
+}
+function validateTolerance(tolerance) {
+  if (!Number.isSafeInteger(tolerance) || tolerance < 0)
+    throw new OfficeError(
+      "invalid-value",
+      "Explicit nonnegative integer EMU tolerance is required.",
+      "usage"
+    );
+}
+function drawingShapes(root) {
+  return descendants(root).filter(
+    (n) => n.name.namespace === root.name.namespace && shapeKinds.includes(n.name.localName)
+  );
+}
+function fraction(n, d = 1n) {
+  let a = n < 0n ? -n : n, b = d;
+  while (b) {
+    const rest = a % b;
+    a = b;
+    b = rest;
+  }
+  return { n: n / a, d: d / a };
+}
+function add(a, b) {
+  return fraction(a.n * b.d + b.n * a.d, a.d * b.d);
+}
+function negate(a) {
+  return { n: -a.n, d: a.d };
+}
+function multiply(a, n, d = 1) {
+  return fraction(a.n * BigInt(n), a.d * BigInt(d));
+}
+function exactCorners(root, node) {
+  const own = geometry(node), f = (n) => fraction(BigInt(n));
+  let points = [
+    { x: f(own.x), y: f(own.y) },
+    { x: f(own.x + own.w), y: f(own.y) },
+    { x: f(own.x + own.w), y: f(own.y + own.h) },
+    { x: f(own.x), y: f(own.y + own.h) }
+  ];
+  const apply = (target, childSpace) => {
+    const g = geometry(target), q = g.angle / 54e5;
+    if (!Number.isInteger(q))
+      unsupported(
+        "Nonidentity ungroup requires quarter-turn geometry for an exact tolerance proof."
+      );
+    const centerX = add(f(g.x), multiply(f(g.w), 1, 2)), centerY = add(f(g.y), multiply(f(g.h), 1, 2));
+    points = points.map((point) => {
+      const px = childSpace ? add(f(g.x), multiply(add(point.x, negate(f(g.cx))), g.w, g.cw)) : point.x;
+      const py = childSpace ? add(f(g.y), multiply(add(point.y, negate(f(g.cy))), g.h, g.ch)) : point.y;
+      const dx = multiply(add(px, negate(centerX)), g.fx), dy = multiply(add(py, negate(centerY)), g.fy);
+      const rx = [dx, negate(dy), negate(dx), dy][q], ry = [dy, dx, negate(dy), negate(dx)][q];
+      return { x: add(centerX, rx), y: add(centerY, ry) };
+    });
+  };
+  apply(node, false);
+  let current = node;
+  while (current !== root) {
+    current = parentOf(root, current);
+    if (current.name.namespace === node.name.namespace && current.name.localName === "grpSp")
+      apply(current, true);
+  }
+  for (const point of points)
+    for (const value of [point.x, point.y])
+      if ((value.n < 0n ? -value.n : value.n) > 27273042316900n * value.d)
+        unsupported("World geometry exceeds coordinate bounds.");
+  return points;
+}
+function certify(before, after, nodes, tolerance) {
+  for (const node of nodes) {
+    const original = exactCorners(before.root, node), changed = exactCorners(after.root, nodeFor(after.root, identity(node)));
+    for (let i = 0; i < 4; i++)
+      for (const axis of ["x", "y"]) {
+        const difference = add(original[i][axis], negate(changed[i][axis]));
+        if ((difference.n < 0n ? -difference.n : difference.n) > BigInt(tolerance) * difference.d)
+          unsupported("Serialized geometry exceeds the explicit tolerance.");
+      }
+  }
+}
+function bounded(node) {
+  const transform = geometry(node);
+  const xfrm = transform.xfrm;
+  if (xfrm.attributes.some(
+    (a) => a.name.namespace !== "" || !["rot", "flipH", "flipV"].includes(a.name.localName)
+  ) || xfrm.children.some(
+    (n) => n.name.namespace !== transform.a || !["off", "ext", "chOff", "chExt"].includes(n.name.localName) || n.children.length || n.attributes.length !== 2 || n.attributes.some(
+      (a) => a.name.namespace !== "" || !(n.name.localName.endsWith("Off") || n.name.localName === "off" ? ["x", "y"] : ["cx", "cy"]).includes(a.name.localName)
+    )
+  ))
+    unsupported("Unknown transform metadata cannot be bounded.");
+  if (node.name.localName === "grpSp") {
+    const nv = required(node, "nvGrpSpPr");
+    if (node.attributes.length || nv.attributes.length || nv.children.length !== 3 || nv.children.some(
+      (n) => n.name.namespace !== node.name.namespace || !["cNvPr", "cNvGrpSpPr", "nvPr"].includes(n.name.localName) || n.children.length || n.attributes.some(
+        (a) => n.name.localName !== "cNvPr" || a.name.namespace !== "" || !["id", "name"].includes(a.name.localName)
+      )
+    ))
+      unsupported("Group actions or metadata cannot be removed.");
+    const props2 = required(node, "grpSpPr");
+    if (props2.attributes.length || props2.children.some((n) => n.name.localName !== "xfrm" || n.name.namespace !== transform.a))
+      unsupported("Group effects or inherited formatting cannot be removed.");
+    return;
+  }
+  if (node.name.localName !== "sp")
+    unsupported("Ungroup currently requires plain rectangular shapes or nested groups.");
+  const props = required(node, "spPr"), preset = child(props, "prstGeom", geometry(node).a);
+  if (!preset || attr(preset, "prst") !== "rect" || preset.children.some(
+    (n) => n.name.namespace !== transform.a || n.name.localName !== "avLst" || n.children.length || n.attributes.length
+  ))
+    unsupported("Unsupported vertex geometry for ungroup.");
+  if (node.attributes.length || props.attributes.length || node.children.some(
+    (n) => n.name.namespace !== node.name.namespace || !["nvSpPr", "spPr"].includes(n.name.localName)
+  ) || props.children.some(
+    (n) => n.name.namespace !== transform.a || !["xfrm", "prstGeom", "solidFill", "noFill", "ln"].includes(n.name.localName)
+  ))
+    unsupported("Text, styles, or effects cannot be bounded for ungroup.");
+  const line = child(props, "ln", geometry(node).a);
+  if (!line || line.children.length !== 1 || line.children[0].name.localName !== "noFill" || line.children[0].name.namespace !== transform.a || line.children[0].attributes.length || line.children[0].children.length || line.attributes.length)
+    unsupported("Ungroup requires an explicit absent stroke.");
+}
+function applyShapeGroup(doc, ids, tolerance) {
+  validateTolerance(tolerance);
+  if (ids.length < 2 || new Set(ids).size !== ids.length)
+    throw new SelectionError("invalid-selection");
+  const nodes = ids.map((id2) => nodeFor(doc.root, id2)), parent = parentOf(doc.root, nodes[0]);
+  if (!["spTree", "grpSp"].includes(parent.name.localName) || nodes.some((n) => parentOf(doc.root, n) !== parent))
+    throw new SelectionError("invalid-selection");
+  const positions = nodes.map((n) => parent.children.indexOf(n)).sort((a2, b) => a2 - b);
+  if (positions.at(-1) - positions[0] + 1 !== nodes.length)
+    unsupported("Grouping requires contiguous siblings to preserve z-order.");
+  const ordered = parent.children.slice(positions[0], positions.at(-1) + 1);
+  const affected = ordered.flatMap(drawingShapes);
+  for (const node of affected) corners(doc.root, node);
+  const transforms = ordered.map(geometry);
+  const x = transforms.reduce((n, g) => Math.min(n, g.x), Infinity), y = transforms.reduce((n, g) => Math.min(n, g.y), Infinity);
+  const w = transforms.reduce((n, g) => Math.max(n, g.x + g.w), -Infinity) - x, h = transforms.reduce((n, g) => Math.max(n, g.y + g.h), -Infinity) - y;
+  if (w <= 0 || h <= 0) unsupported("Group union requires positive nonsingular extents.");
+  if (w > 27273042316900 || h > 27273042316900)
+    unsupported("Group union exceeds coordinate bounds.");
+  const used = new Set(
+    descendants(doc.root).filter((n) => n.name.localName === "cNvPr" && n.name.namespace === doc.root.name.namespace).map((n) => Number(attr(n, "id")))
+  );
+  let id = 1;
+  for (const usedId of used) id = Math.max(id, usedId + 1);
+  if (id > 4294967295) {
+    id = 1;
+    while (used.has(id)) id++;
+  }
+  if (!Number.isSafeInteger(id) || id > 4294967295) unsupported("No available group identity.");
+  const p = doc.root.name.namespace, a = transforms[0].a;
+  const xml = `<p:grpSp xmlns:p="${p}" xmlns:a="${a}"><p:nvGrpSpPr><p:cNvPr id="${id}" name="Group ${id}"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x="${x}" y="${y}"/><a:ext cx="${w}" cy="${h}"/><a:chOff x="${x}" y="${y}"/><a:chExt cx="${w}" cy="${h}"/></a:xfrm></p:grpSpPr>${ordered.map((n) => doc.markup(n, true)).join("")}</p:grpSp>`;
+  const result = doc.spliceChildren(parent, positions[0], nodes.length, [xml]);
+  return result;
+}
+function applyShapeUngroup(doc, id, tolerance) {
+  validateTolerance(tolerance);
+  const group = nodeFor(doc.root, id);
+  if (group.name.localName !== "grpSp") throw new SelectionError("invalid-selection");
+  const affected = drawingShapes(group).filter((n) => n !== group);
+  const nodes = group.children.filter(
+    (n) => n.name.namespace === group.name.namespace && shapeKinds.includes(n.name.localName)
+  );
+  if (!nodes.length) unsupported("Ungroup requires explicit child geometry.");
+  const outer = geometry(group);
+  bounded(group);
+  for (const node of affected) {
+    if (outer.identityMapping) corners(doc.root, node);
+    else bounded(node);
+  }
+  if (group.children.some(
+    (n) => n.name.namespace !== group.name.namespace || !["nvGrpSpPr", "grpSpPr", ...shapeKinds].includes(n.name.localName)
+  ))
+    unsupported("Unknown group metadata cannot be removed.");
+  const affectedIds = new Set(affected.map(identity));
+  for (const node of descendants(doc.root)) {
+    if (["timing", "extLst"].includes(node.name.localName) && node.children.length)
+      unsupported("Opaque timing or extension references cannot be remapped safely.");
+    if (!outer.identityMapping && node.attributes.some(
+      (a) => ["spid", "spId", "shapeId"].includes(a.name.localName) && affectedIds.has(a.value)
+    ))
+      unsupported("Affected timing references cannot be remapped safely.");
+    if (["stCxn", "endCxn"].includes(node.name.localName) && attr(node, "id") === id || node.attributes.some(
+      (a) => ["spid", "spId", "shapeId"].includes(a.name.localName) && a.value === id
+    ))
+      unsupported("Removed group has connector or timing references.");
+  }
+  let changed = doc;
+  for (const original of outer.identityMapping ? [] : nodes) {
+    const childNode = nodeFor(changed.root, identity(original)), g = geometry(childNode);
+    const local = [
+      { x: g.x, y: g.y },
+      { x: g.x + g.w, y: g.y },
+      { x: g.x, y: g.y + g.h }
+    ].map(g.map).map(outer.childMap);
+    const u = { x: local[1].x - local[0].x, y: local[1].y - local[0].y }, v = { x: local[2].x - local[0].x, y: local[2].y - local[0].y };
+    const width = Math.hypot(u.x, u.y), height = Math.hypot(v.x, v.y);
+    if (Math.abs(u.x * v.x + u.y * v.y) > Number.EPSILON * width * height * 8)
+      unsupported("Ungroup would require unsupported shear.");
+    const angle = Math.atan2(u.y, u.x) * 108e5 / Math.PI;
+    const rotation = (new Length(angle).emu % 216e5 + 216e5) % 216e5;
+    const roundedWidth = new Length(width).emu, roundedHeight = new Length(height).emu;
+    const x = new Length(local[0].x + (u.x + v.x) / 2 - roundedWidth / 2).emu, y = new Length(local[0].y + (u.y + v.y) / 2 - roundedHeight / 2).emu;
+    if (roundedWidth <= 0 || roundedHeight <= 0)
+      unsupported("Rounding produces zero visible extents.");
+    changed = changed.merge(g.xfrm, {
+      attributes: [
+        { namespace: "", localName: "rot", value: String(rotation) },
+        { namespace: "", localName: "flipH", value: "0" },
+        { namespace: "", localName: "flipV", value: u.x * v.y - u.y * v.x < 0 ? "1" : "0" }
+      ],
+      children: {
+        sequence: ["off", "ext", "chOff", "chExt"].map((localName) => ({
+          namespace: g.a,
+          localName
+        })),
+        upsert: [
+          {
+            name: { namespace: g.a, localName: "off" },
+            merge: {
+              attributes: [
+                { namespace: "", localName: "x", value: String(x) },
+                { namespace: "", localName: "y", value: String(y) }
+              ]
+            }
+          },
+          {
+            name: { namespace: g.a, localName: "ext" },
+            merge: {
+              attributes: [
+                { namespace: "", localName: "cx", value: String(roundedWidth) },
+                { namespace: "", localName: "cy", value: String(roundedHeight) }
+              ]
+            }
+          }
+        ]
+      }
+    });
+  }
+  const current = nodeFor(changed.root, id), parent = parentOf(changed.root, current);
+  const result = changed.spliceChildren(
+    parent,
+    parent.children.indexOf(current),
+    1,
+    nodes.map((n) => changed.markup(nodeFor(changed.root, identity(n)), true))
+  );
+  if (!outer.identityMapping) certify(doc, result, affected, tolerance);
+  return result;
+}
+function validateGroupOptions(options, grouping) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some(
+    (key) => typeof key !== "string" || !("value" in Object.getOwnPropertyDescriptor(options, key))
+  ))
+    throw new OfficeError("invalid-value", "Invalid group options.", "usage");
+  if (!(options.tolerance instanceof Length))
+    throw new OfficeError("invalid-value", "Explicit tolerance Length is required.", "usage");
+  if (!("value" in (Object.getOwnPropertyDescriptor(options.tolerance, "emu") ?? {})))
+    throw new OfficeError("invalid-value", "Tolerance requires a stored EMU value.", "usage");
+  validateTolerance(options.tolerance.emu);
+  if (["update", "all", "allowEmpty"].some((key) => Object.hasOwn(options, key)))
+    throw new OfficeError("invalid-value", "Unexpected group option.", "usage");
+  if (grouping) {
+    const shapes = options.shapes;
+    if (!Array.isArray(shapes) || shapes.length < 2) throw new SelectionError("invalid-selection");
+    for (const location of shapes) {
+      const keys = ["fingerprint", "scope", "owner", "objectId", "coordinateSystem"];
+      if (!location || typeof location !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(location)) || Reflect.ownKeys(location).some(
+        (key) => typeof key !== "string" || !keys.includes(key) || !("value" in Object.getOwnPropertyDescriptor(location, key))
+      ) || keys.some(
+        (key) => !Object.hasOwn(location, key) || typeof location[key] !== "string" || !location[key].length
+      ) || location.coordinateSystem !== "identity")
+        throw new OfficeError(
+          "invalid-value",
+          "Locations require exact identity data fields.",
+          "usage"
+        );
+    }
+  }
+  const { tolerance: ignoredTolerance, ...rest } = options;
+  const { shapes: ignoredShapes, ...selection } = rest;
+  if (!grouping && Object.hasOwn(options, "shapes"))
+    throw new OfficeError("invalid-value", "Unexpected shapes option.", "usage");
+  validateSelection(selection, "set");
+  if (!grouping && !selection.select && selection.shape === void 0 && selection.slide === void 0 && !selection.part)
+    throw new SelectionError("invalid-selection");
+  return selection;
+}
+async function groupShapes(input, options, context) {
+  const selection = validateGroupOptions(options, true), s = await loadShared(input, context);
+  if (!Array.isArray(options.shapes) || options.shapes.length < 2)
+    throw new SelectionError("invalid-selection");
+  const allowed = selected(s, selection);
+  const records = options.shapes.map((location) => {
+    if (!location || location.fingerprint !== s.index.fingerprint)
+      throw new SelectionError("stale-selection");
+    const record = allowed.find(
+      (r) => r.location.owner === location.owner && r.location.objectId === location.objectId && r.location.scope === location.scope && location.coordinateSystem === "identity"
+    );
+    if (!record) throw new SelectionError("invalid-selection");
+    return record;
+  });
+  const part = records[0].part;
+  if (records.some((r) => r.part !== part)) throw new SelectionError("invalid-selection");
+  s.save(
+    part,
+    applyShapeGroup(
+      s.doc(part),
+      records.map((r) => r.id),
+      options.tolerance.emu
+    )
+  );
+  return {
+    ...await s.finish(
+      part,
+      s.index.inventory.slides.filter((x) => [x.part, x.master, x.layout].includes(part)).map((x) => x.position)
+    ),
+    affected: records.length,
+    records
+  };
+}
+async function ungroupShape(input, options, context) {
+  const selection = validateGroupOptions(options, false), s = await loadShared(input, context), records = selected(s, selection);
+  if (records.length !== 1)
+    throw new SelectionError(
+      records.length ? "ambiguous-selection" : "missing-selection",
+      records.map((r) => r.location)
+    );
+  const record = records[0];
+  const source = s.doc(record.part);
+  const childIds = new Set(
+    nodeFor(source.root, record.id).children.filter(
+      (n) => n.name.namespace === source.root.name.namespace && shapeKinds.includes(n.name.localName)
+    ).map(identity)
+  );
+  const retained = s.index.objects.filter((r) => r.part === record.part && childIds.has(r.id));
+  s.save(record.part, applyShapeUngroup(source, record.id, options.tolerance.emu));
+  return {
+    ...await s.finish(
+      record.part,
+      s.index.inventory.slides.filter((x) => [x.part, x.master, x.layout].includes(record.part)).map((x) => x.position)
+    ),
+    affected: 1,
+    records: retained
+  };
+}
+
+export {
+  applyShapeGroup,
+  applyShapeUngroup,
+  validateGroupOptions,
+  groupShapes,
+  ungroupShape
+};