@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,399 @@
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  measurePackageResourceSerialization
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  LocationIndex,
+  pathContains
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  admitEquationFragment,
+  assertOutsideRevisionRanges,
+  inspectEquationFragment,
+  mathNamespace
+} from "./chunk-YPVBU7QF.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  MarkupCompatibility,
+  compatibilityProfileForPart
+} from "./chunk-GZ2N24A2.js";
+import {
+  SelectionError,
+  closedRecord,
+  decodeLocation,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  isXmlContentType,
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError,
+  InvalidValueError,
+  ResourceLimitError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/equation-properties.ts
+var wrappers = ["accPr", "barPr", "boxPr", "borderBoxPr", "dPr", "eqArrPr", "fPr", "funcPr", "groupChrPr", "limLowPr", "limUppPr", "mPr", "naryPr", "phantPr", "radPr", "sPrePr", "sSubPr", "sSubSupPr", "sSupPr", "rPr", "argPr", "ctrlPr", "oMathParaPr"];
+var native = ["lit", "nor", "scr", "sty", "brk", "aln", "argSz", "type", "jc", "mathFont", "brkBin", "brkBinSub", "smallFrac", "dispDef", "lMargin", "rMargin", "defJc", "preSp", "postSp", "interSp", "intraSp", "wrapIndent", "wrapRight", "intLim", "naryLim", "chr", "pos", "begChr", "endChr", "sepChr", "grow", "shp", "baseJc", "maxDist", "objDist", "rSp", "rSpRule", "cSp", "cGp", "cGpRule", "mcs", "mc", "mcPr", "count", "hideTop", "hideBot", "hideLeft", "hideRight", "strikeH", "strikeV", "strikeBLTR", "strikeTLBR", "opEmu", "noBreak", "diff", "alnScr", "limLoc", "subHide", "supHide", "transp", "zeroAsc", "zeroDesc", "zeroWid", "show", "degHide", "vertJc"];
+var propertyChildren = {
+  accPr: ["chr", "ctrlPr"],
+  barPr: ["pos", "ctrlPr"],
+  boxPr: ["opEmu", "noBreak", "diff", "brk", "aln", "ctrlPr"],
+  borderBoxPr: ["hideTop", "hideBot", "hideLeft", "hideRight", "strikeH", "strikeV", "strikeBLTR", "strikeTLBR", "ctrlPr"],
+  dPr: ["begChr", "sepChr", "endChr", "grow", "shp", "ctrlPr"],
+  eqArrPr: ["baseJc", "maxDist", "objDist", "rSpRule", "rSp", "ctrlPr"],
+  fPr: ["type", "ctrlPr"],
+  funcPr: ["ctrlPr"],
+  groupChrPr: ["chr", "pos", "vertJc", "ctrlPr"],
+  limLowPr: ["ctrlPr"],
+  limUppPr: ["ctrlPr"],
+  mPr: ["baseJc", "rSpRule", "cGpRule", "rSp", "cSp", "cGp", "mcs", "ctrlPr"],
+  mcs: ["mc"],
+  mc: ["mcPr"],
+  mcPr: ["count"],
+  naryPr: ["chr", "limLoc", "grow", "subHide", "supHide", "ctrlPr"],
+  phantPr: ["show", "zeroWid", "zeroAsc", "zeroDesc", "transp", "ctrlPr"],
+  radPr: ["degHide", "ctrlPr"],
+  sPrePr: ["ctrlPr"],
+  sSubPr: ["ctrlPr"],
+  sSubSupPr: ["alnScr", "ctrlPr"],
+  sSupPr: ["ctrlPr"],
+  rPr: ["lit", "nor", "scr", "sty", "brk", "aln"],
+  argPr: ["argSz"],
+  oMathParaPr: ["jc"],
+  mathPr: ["mathFont", "brkBin", "brkBinSub", "smallFrac", "dispDef", "lMargin", "rMargin", "defJc", "preSp", "postSp", "interSp", "intraSp", "wrapIndent", "wrapRight", "intLim", "naryLim"]
+};
+var mathContext = /* @__PURE__ */ new Set([...wrappers, ...native, "mathPr", "oMath", "oMathPara", "r", "num", "den", "e", "sub", "sup", "deg", "lim", "fn", "mr", ...wrappers.map((n) => n.slice(0, -2))]);
+var wordProperties = new Set("rPr rPrChange rStyle rFonts b bCs i iCs caps smallCaps strike dstrike outline shadow emboss imprint noProof snapToGrid vanish webHidden color spacing w kern position sz szCs highlight u effect bdr shd fitText vertAlign rtl cs em lang eastAsianLayout specVanish oMath ins del moveFrom moveTo".split(" "));
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function collectEquationProperties(root, namespace, part, base, budget, global = false) {
+  const result = [];
+  const w = namespace.includes("purl.oclc") ? "http://purl.oclc.org/ooxml/wordprocessingml/main" : "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const visit = (node, path, scope, inert = false, context = true, parent = "") => {
+    budget.charge("work", 1 + node.attributes.length);
+    context &&= node.namespace === namespace && mathContext.has(node.localName) || inert && node.namespace === w || node.namespace === w && node.localName === "rPr" && (scope !== void 0 || parent === "r");
+    if (node.namespace === namespace && wrappers.includes(node.localName)) {
+      const supported = node.localName === "rPr" ? parent === "r" : node.localName === "argPr" ? ["num", "den", "e", "sub", "sup", "deg", "lim", "fn"].includes(parent) : node.localName === "ctrlPr" ? wrappers.includes(parent) : parent === node.localName.slice(0, -2);
+      context &&= supported;
+    }
+    if (node.namespace === namespace && native.includes(node.localName)) context &&= propertyChildren[parent]?.includes(node.localName) === true;
+    let selected = scope;
+    if (node.namespace === w && node.localName === "rPr" && parent === "r") selected = "run";
+    if (global) selected = "global";
+    else if (node.namespace === namespace && wrappers.includes(node.localName)) selected = node.localName === "oMathParaPr" ? "display" : node.localName === "rPr" ? "run" : node.localName === "argPr" ? "argument" : "equation";
+    if (selected) {
+      const attributes = node.attributes.filter((a) => a.namespace !== "http://www.w3.org/2000/xmlns/").map((a) => ({ namespace: a.namespace, localName: a.localName, value: a.value })).sort((a, b) => compare(a.namespace, b.namespace) || compare(a.localName, b.localName));
+      const associated = inert || node.namespace === w && ["rPr", "rPrChange"].includes(node.localName);
+      const stored = context && (associated && node.namespace === w && wordProperties.has(node.localName) && attributes.every((a) => a.namespace === w) || node.namespace === namespace && (wrappers.includes(node.localName) || native.includes(node.localName) || global && node.localName === "mathPr") && attributes.every((a) => a.namespace === namespace && a.localName === (node.localName === "brk" ? "alnAt" : "val")) && (!wrappers.includes(node.localName) && node.localName !== "mathPr" || attributes.length === 0));
+      const issues = stored ? [] : [{ code: "opaque-equation-property", part, path: [...path], message: "Stored property metadata is outside recognized native names or attributes." }];
+      budget.charge("retainedBytes", 256 + attributes.reduce((n, a) => n + (a.namespace.length + a.localName.length + a.value.length) * 2, 0) + path.length * 8);
+      if (issues.length) budget.charge("diagnosticBytes", 160 + part.length);
+      result.push({ scope: selected, part, path: [...path], namespace: node.namespace, localName: node.localName, attributes, status: stored ? "stored" : "opaque", issues });
+      inert = associated;
+    }
+    node.children.forEach((child, i) => visit(child, [...path, i], selected, inert, context && !(node.namespace === w && !wordProperties.has(node.localName)), node.localName));
+  };
+  visit(root, base);
+  return result;
+}
+
+// packages/safe-bash-docx-engine/src/equations.ts
+var UnsupportedEquationMutationError = class extends UnsupportedEditError {
+  constructor(location2) {
+    super("Equation mutation cannot establish bounded faithful preservation.");
+    this.location = location2;
+    this.locations = [location2];
+  }
+  location;
+  locations;
+};
+var compare2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+async function digest(bytes, budget) {
+  budget.charge("work", bytes.length);
+  budget.charge("retainedBytes", bytes.length + 128);
+  const hash = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+  budget.check("work", 0);
+  return [...new Uint8Array(hash)].map((n) => n.toString(16).padStart(2, "0")).join("");
+}
+function location(sourceSha256, part, story, path, generation = 0) {
+  const value = { version: 1, sourceSha256, generation, part, story, path: [...path], range: null };
+  return { kind: "part", value, token: encodeGeneratedLocation(value), positions: {} };
+}
+async function equationDiagnosticLocation(input, part, path, budget) {
+  return location(await digest(input, budget), part, part, path);
+}
+function collectEquationUnits(root, namespace, budget) {
+  const result = [], pending = [{ node: root, path: [] }];
+  while (pending.length) {
+    const { node, path } = pending.pop();
+    budget.charge("work", 1);
+    if (node.namespace === namespace && ["oMath", "oMathPara"].includes(node.localName)) {
+      budget.charge("retainedBytes", 64 + path.length * 8);
+      result.push({ node, path });
+      continue;
+    }
+    for (let i = node.children.length - 1; i >= 0; i--) pending.push({ node: node.children[i], path: [...path, i] });
+  }
+  return result;
+}
+function exposed(view, budget) {
+  const result = /* @__PURE__ */ new Set();
+  const visit = (content) => {
+    for (const node of content) {
+      budget.charge("work", 1);
+      if ("source" in node) {
+        result.add(node.source);
+        budget.charge("retainedBytes", 32);
+        if (node.disposition === "understood") visit(node.content);
+      }
+    }
+  };
+  visit(view.content);
+  return result;
+}
+function at(root, path) {
+  let node = root;
+  for (const i of path) node = node?.children[i];
+  return node;
+}
+function ancestors(root, path) {
+  const result = [root];
+  let node = root;
+  for (const i of path) {
+    node = node.children[i];
+    result.push(node);
+  }
+  return result;
+}
+function hostReasons(root, paragraphPath, namespace, view, budget) {
+  const reasons = [], w = namespace === mathNamespace(true) ? documentDialects.strict.w : documentDialects.transitional.w, chain = ancestors(root, paragraphPath), paragraph = chain.at(-1);
+  const native2 = ["document", "body", "hdr", "ftr", "footnotes", "footnote", "endnotes", "endnote", "comments", "comment", "tbl", "tr", "tc", "p"];
+  if (paragraph.namespace !== w || paragraph.localName !== "p" || chain.some((n) => n.namespace === w ? !native2.includes(n.localName) : n.namespace !== "http://schemas.openxmlformats.org/markup-compatibility/2006" || !["AlternateContent", "Choice", "Fallback"].includes(n.localName))) reasons.push("unsupported-equation-host");
+  const transparentHost = chain.some((n) => n.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" && n.localName === "AlternateContent");
+  if (!view.canEdit(paragraph) && !(transparentHost && exposed(view, budget).has(paragraph))) reasons.push("opaque-equation-host");
+  const active = exposed(view, budget);
+  const visit = (node, transparent = false) => {
+    budget.charge("work", 1 + node.attributes.length);
+    if (node.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" && node.localName === "AlternateContent") {
+      const selected = view.branches.find((b) => b.alternateContent === node)?.selected;
+      selected?.children.forEach((child) => visit(child, true));
+      return;
+    }
+    if (!active.has(node)) return;
+    if (![w, namespace].includes(node.namespace) || node.attributes.some((a) => ![w, namespace, "http://schemas.openxmlformats.org/markup-compatibility/2006", "", "http://www.w3.org/XML/1998/namespace", "http://www.w3.org/2000/xmlns/"].includes(a.namespace))) reasons.push("opaque-equation-host");
+    if (node.namespace === w && ["sdt", "fldSimple", "fldChar", "instrText", "ins", "del", "moveFrom", "moveTo", "pPrChange", "rPrChange", "moveFromRangeStart", "moveFromRangeEnd", "moveToRangeStart", "moveToRangeEnd"].includes(node.localName)) reasons.push("compound-equation-host");
+    if (node.namespace !== namespace && !view.canEdit(node) && !(transparent && node.namespace === w) && node.namespace !== "http://schemas.openxmlformats.org/markup-compatibility/2006") reasons.push("opaque-equation-host");
+    node.children.forEach((child) => visit(child, transparent));
+  };
+  visit(paragraph, transparentHost);
+  try {
+    assertOutsideRevisionRanges(root, paragraph, budget, view.branches);
+  } catch (error) {
+    if (!(error instanceof UnsupportedEditError)) throw error;
+    reasons.push("review-equation-host");
+  }
+  return [...new Set(reasons)];
+}
+async function inventory(owned, archive, budget, context) {
+  let protectedDocument = false;
+  try {
+    assertDocumentEditable(archive, archiveSettings({ ...context, budget }));
+  } catch (error) {
+    if (!(error instanceof UnsupportedEditError)) throw error;
+    protectedDocument = true;
+  }
+  const namespace = mathNamespace(archive.dialect === "strict"), index = new LocationIndex(archive, archiveSettings(context).limits, archive.mainPart, archive.dialect, budget), sha = await digest(owned, budget), items = [], globalProperties = [];
+  const edges = [];
+  for (const owner of ["/", ...archive.package.parts.filter((p) => p.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml").map((p) => p.partname)]) for (const edge of archive.package.relationships(owner)) {
+    budget.charge("work", 1);
+    budget.charge("retainedBytes", 128);
+    edges.push({ owner, reference: { owner, id: edge.rId, type: edge.reltype, target: edge.target_ref, external: edge.is_external }, target: edge.is_external ? null : edge.target_part.partname });
+  }
+  for (const part of [...archive.package.parts].sort((a, b) => compare2(a.partname, b.partname))) {
+    await budget.checkpoint(1);
+    if (!isXmlContentType(part.content_type)) continue;
+    const root = parseDocumentXml(part.bytes, {}, budget).root, view = new MarkupCompatibility(root, compatibilityProfileForPart(part.partname), budget), active = exposed(view, budget);
+    const paragraphs = index.entries.filter((e) => e.kind === "paragraph" && e.part === part.partname), stories = index.entries.filter((e) => e.kind === "story" && e.part === part.partname);
+    if (parseMediaType(part.content_type) === "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml" && root.namespace === documentDialects[archive.dialect].w && root.localName === "settings") root.children.forEach((child, i) => {
+      if (child.namespace === namespace && child.localName === "mathPr") globalProperties.push(...collectEquationProperties(child, namespace, part.partname, [i], budget, true));
+    });
+    for (const unit of collectEquationUnits(root, namespace, budget)) {
+      const host = paragraphs.filter((p) => pathContains(p.path, unit.path)).sort((a, b) => b.path.length - a.path.length)[0], story = stories.filter((s) => pathContains(s.path, unit.path)).sort((a, b) => b.path.length - a.path.length)[0]?.story ?? part.partname, properties = collectEquationProperties(unit.node, namespace, part.partname, unit.path, budget), issues = inspectEquationFragment(unit.node, namespace, budget, part.partname, unit.path), bounded = issues.length === 0, reasons = [];
+      if (!active.has(unit.node)) reasons.push("inactive-equation");
+      if (!host || ancestors(root, unit.path).slice(host.path.length + 1, -1).some((n) => n.namespace !== "http://schemas.openxmlformats.org/markup-compatibility/2006" || !["AlternateContent", "Choice", "Fallback"].includes(n.localName))) reasons.push("unsupported-equation-host");
+      else reasons.push(...hostReasons(root, host.path, namespace, view, budget));
+      if (index.references.filter((ref) => ref.story === story).length > 1) reasons.push("shared-equation-host");
+      if (protectedDocument) reasons.push("protected-equation-document");
+      for (const code of [...new Set(reasons)]) {
+        budget.charge("diagnosticBytes", 160 + part.partname.length);
+        issues.push({ code, part: part.partname, path: [...unit.path], message: "The stored equation has no admitted unambiguous editable paragraph host." });
+      }
+      const mathPaths = unit.node.localName === "oMath" ? [unit.path] : unit.node.children.flatMap((child, i) => child.namespace === namespace && child.localName === "oMath" ? [[...unit.path, i]] : []), references = edges.filter((e) => e.owner === part.partname || e.target === part.partname).map((e) => e.reference).sort((a, b) => compare2(a.owner, b.owner) || compare2(a.id, b.id) || compare2(a.type, b.type) || compare2(a.target, b.target)), loc = location(sha, part.partname, story, unit.path);
+      budget.charge("matches", 1);
+      budget.charge("retainedBytes", 512 + loc.token.length * 2);
+      items.push({ kind: "equations", location: loc, name: part.partname, properties: [], references, support: bounded && !reasons.length ? "edit" : "preserve", details: { kind: "equations", mode: unit.node.localName === "oMath" ? "inline" : "display", ownerPart: part.partname, root: { namespace: unit.node.namespace, localName: unit.node.localName }, path: unit.path, mathPaths, active: active.has(unit.node), properties, status: bounded ? "bounded" : "opaque", issues } });
+    }
+  }
+  const warnings = items.some((i) => i.support === "preserve") ? [{ code: "preserve-only-equations", message: "Some stored equations require faithful preservation and cannot be edited by this bounded profile." }] : [];
+  return { items, globalProperties, warnings };
+}
+async function inspectDocumentEquations(input, options, context) {
+  const settings = archiveSettings(context), invocation = validateDocxInvocation({ operation: "equations.list", inputs: ["document"], options }, settings.budget), opts = invocation.options, budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((l) => [l.name, l.value])));
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected archive bytes.");
+  budget.check("compressedInput", input.length);
+  budget.charge("retainedBytes", input.length);
+  const owned = new Uint8Array(input), archive = await readDocumentArchive(owned, { ...settings, budget }), data = await inventory(owned, archive, budget, { ...settings, budget });
+  budget.charge("retainedBytes", measurePackageResourceSerialization({ version: 1, operation: "equations.list", ok: true, data, warnings: data.warnings, errors: [], affected: 0, locations: data.items.map((i) => i.location) }, budget));
+  return data;
+}
+async function fragmentBytes(input, context, budget) {
+  const settings = archiveSettings({ ...context, budget }), maxBytes = Math.min(settings.limits.maxEntryBytes, budget.limits.xmlPartBytes);
+  closedRecord(input, ["kind", "base64", "path", "capability"]);
+  if (input.kind === "bytes") {
+    closedRecord(input, ["kind", "base64"]);
+    const s = input.base64;
+    if (typeof s !== "string" || s.length % 4 !== 0) throw new InvalidValueError("Expected canonical equation bytes.");
+    const size2 = s.length / 4 * 3 - (s.endsWith("==") ? 2 : s.endsWith("=") ? 1 : 0);
+    if (size2 > maxBytes) throw new ResourceLimitError("Equation fragment exceeds XML limit.");
+    budget.charge("work", s.length);
+    budget.charge("retainedBytes", size2 * 3);
+    let decoded;
+    try {
+      decoded = atob(s);
+      if (btoa(decoded) !== s) throw new Error();
+    } catch {
+      throw new InvalidValueError("Expected canonical equation bytes.");
+    }
+    return Uint8Array.from(decoded, (c) => c.charCodeAt(0));
+  }
+  if (input.kind !== "vfs") throw new InvalidValueError("Expected explicit equation binary input.");
+  closedRecord(input, ["kind", "path", "capability"]);
+  if (typeof input.path !== "string" || !input.path || typeof input.capability !== "string" || !input.capability) throw new InvalidValueError("Expected explicit equation path capability.");
+  const resolver = context.binaryResolver;
+  if (!resolver || resolver.capability !== input.capability) throw new UnsupportedEditError("Equation fragment requires a matching explicit VFS capability.");
+  settings.signal.throwIfAborted();
+  const source = await resolver.open(input.path, { signal: settings.signal, maxBytes }), chunks = [];
+  let size = 0;
+  for await (const chunk of source) {
+    budget.check("work", 0);
+    if (!(chunk instanceof Uint8Array)) throw new InputTypeError("Expected equation byte fragments.");
+    if (chunk.length > maxBytes - size) throw new ResourceLimitError("Equation fragment exceeds XML limit.");
+    size += chunk.length;
+    budget.charge("retainedBytes", chunk.length + 64);
+    budget.charge("work", chunk.length + 1);
+    chunks.push(new Uint8Array(chunk));
+  }
+  budget.check("work", 0);
+  budget.charge("retainedBytes", size);
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+async function mutate(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["equations.add", "equations.replace"].includes(request.operation)) throw new InvalidValueError("Expected equation mutation.");
+  if (request.input !== void 0) {
+    closedRecord(request.input, ["path", "stat"]);
+    closedRecord(request.input.stat, ["type", "filesystemType", "size", "allocatedBytes", "ioBlockSize", "preferredIoBlockSize", "mode", "mtimeMs", "atimeMs", "ctimeMs", "birthtimeMs", "revision", "identityScope", "ino", "dev", "rdevMajor", "rdevMinor", "nlink", "uid", "gid"]);
+  }
+  const identity = request.input ? { path: request.input.path, stat: { ...request.input.stat } } : void 0, settings = archiveSettings(context), invocation = validateDocxInvocation({ operation: request.operation, inputs: [identity?.path ?? "document"], options: request.options }, settings.budget), opts = invocation.options, budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((l) => [l.name, l.value]))), scoped = { ...context, ...settings, budget };
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected archive bytes.");
+  budget.charge("retainedBytes", input.length);
+  const owned = new Uint8Array(input), archive = await readDocumentArchive(owned, scoped), index = new LocationIndex(archive, settings.limits, archive.mainPart, archive.dialect, budget), sha = await digest(owned, budget), value = decodeLocation(opts.select);
+  if (value.sourceSha256 !== sha || value.generation !== 0 || value.range !== null) throw new SelectionError("stale-selection");
+  const data = await inventory(owned, archive, budget, { ...settings, budget }), record = request.operation === "equations.replace" ? data.items.find((i) => i.location.token === opts.select) : void 0;
+  const paragraph = request.operation === "equations.add" ? index.entries.find((e) => e.kind === "paragraph" && e.part === value.part && e.story === value.story && e.path.length === value.path.length && e.path.every((n, i) => n === value.path[i])) : record ? index.entries.filter((e) => e.kind === "paragraph" && e.part === value.part && e.story === value.story && pathContains(e.path, value.path)).sort((a, b) => b.path.length - a.path.length)[0] : void 0;
+  if (!paragraph || request.operation === "equations.replace" && !record) throw new SelectionError("stale-selection");
+  const before = request.operation === "equations.add" ? { kind: "paragraph", value, token: opts.select, positions: paragraph.positions } : record.location;
+  const member = archive.members.find((m) => "/" + m.name === value.part), editor = new DocumentArchiveEditor(archive, {}, void 0, budget), xml = editor.xml(member.name), namespace = mathNamespace(archive.dialect === "strict");
+  try {
+    assertDocumentEditable(archive, scoped);
+  } catch (error) {
+    if (!(error instanceof UnsupportedEditError)) throw error;
+    throw new UnsupportedEquationMutationError(before);
+  }
+  if (hostReasons(xml.root, paragraph.path, namespace, xml.compatibility, budget).length || index.references.filter((ref) => ref.story === paragraph.story).length > 1 || record?.support === "preserve") throw new UnsupportedEquationMutationError(before);
+  const bytes = await fragmentBytes(opts.file, scoped, budget), fragment = admitEquationFragment(bytes, namespace, budget), node = at(xml.root, value.path);
+  if (record && (fragment.root.namespace !== record.details.root.namespace || fragment.root.localName !== record.details.root.localName)) throw new UnsupportedEquationMutationError(before);
+  const changed = request.operation === "equations.add" || xml.sourceXml(node) !== fragment.xml, path = request.operation === "equations.add" ? [...value.path, node.children.length] : value.path;
+  if (changed) {
+    if (request.operation === "equations.add") xml.appendEquationElement(node, fragment.xml);
+    else xml.replaceEquationElement(node, fragment.xml);
+  }
+  const after = location(sha, value.part, value.story, path, 1), changes = changed ? [{ kind: request.operation === "equations.add" ? "add" : "replace", before, after }] : [], planned = { changed, changes, dryRun: opts.dryRun ?? false, output: opts.dryRun ? null : { path: opts.inPlace ? identity?.path ?? null : opts.output === "-" ? null : opts.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  if (opts.json) budget.charge("retainedBytes", measurePackageResourceSerialization({ version: 1, operation: request.operation, ok: true, data: planned, affected: changes.length, locations: changes.map((c) => c.after), warnings: [], errors: [] }, budget));
+  if (context.admitPublication) {
+    const result2 = context.admitPublication(planned);
+    if (result2 !== void 0) {
+      if (result2 && typeof result2.then === "function") void Promise.resolve(result2).catch(() => {
+      });
+      throw new InputTypeError("Equation publication admission must be synchronous.");
+    }
+  }
+  const result = await publishDocumentArchive(editor.snapshot(), { ...identity ? { input: identity } : {}, ...opts.output === void 0 ? {} : { output: opts.output }, ...opts.inPlace === void 0 ? {} : { inPlace: opts.inPlace }, ...opts.force === void 0 ? {} : { force: opts.force }, ...opts.dryRun === void 0 ? {} : { dryRun: opts.dryRun }, ...opts.json === void 0 ? {} : { json: opts.json } }, scoped);
+  return { ...planned, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+async function addDocumentEquation(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (request.operation !== "equations.add") throw new InvalidValueError("Expected equation addition.");
+  return mutate(input, request, context);
+}
+async function replaceDocumentEquation(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (request.operation !== "equations.replace") throw new InvalidValueError("Expected equation replacement.");
+  return mutate(input, request, context);
+}
+async function assertEquationXmlReplacement(archive, original, replacement, input, part, budget, replacementBytes) {
+  const metadata = archive.package.parts.find((p) => p.partname === part), namespace = mathNamespace(archive.dialect === "strict"), global = metadata !== void 0 && parseMediaType(metadata.content_type) === "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml", observations = (root) => [...collectEquationUnits(root, namespace, budget), ...global && root.namespace === documentDialects[archive.dialect].w && root.localName === "settings" ? root.children.flatMap((node, i) => node.namespace === namespace && node.localName === "mathPr" ? [{ node, path: [i] }] : []) : []];
+  const before = observations(original), after = observations(replacement);
+  if (!before.length && !after.length) return;
+  const encodingChanged = parseDocumentXml(archive.members.find((m) => "/" + m.name === part).bytes, {}, budget).encoding !== parseDocumentXml(replacementBytes, {}, budget).encoding;
+  const originalEditor = new DocumentXmlEditor(archive.members.find((m) => "/" + m.name === part).bytes, {}, void 0, budget), replacementEditor = new DocumentXmlEditor(replacementBytes, {}, void 0, budget);
+  const context = (node) => {
+    budget.charge("work", node.namespaces.size);
+    const text = JSON.stringify([...node.namespaces]) + node.children.map(context).join("");
+    budget.charge("retainedBytes", text.length * 2);
+    return text;
+  };
+  const payload = (editor, path) => {
+    const node = at(editor.root, path);
+    return editor.sourceXml(node) + context(node);
+  };
+  for (let i = 0; i < Math.max(before.length, after.length); i++) {
+    const a = before[i], b = after[i];
+    if (!a || !b || a.path.length !== b.path.length || a.path.some((n, j) => n !== b.path[j]) || encodingChanged || payload(originalEditor, a.path) !== payload(replacementEditor, b.path)) throw new UnsupportedEquationMutationError(await equationDiagnosticLocation(input, part, a?.path ?? [], budget));
+  }
+}
+
+export {
+  UnsupportedEquationMutationError,
+  equationDiagnosticLocation,
+  collectEquationUnits,
+  inspectDocumentEquations,
+  addDocumentEquation,
+  replaceDocumentEquation,
+  assertEquationXmlReplacement
+};

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

@@ -0,0 +1,90 @@
+import {
+  inspectionOperationMetadata
+} from "./chunk-5LKNP4IF.js";
+import {
+  docxValueSchema
+} from "./chunk-WVB6ONZS.js";
+import {
+  structureModelBatchActions
+} from "./chunk-DKNNYPOI.js";
+import {
+  styleModelBatchOperations
+} from "./chunk-JQE256UO.js";
+import {
+  docxOperationSchemas,
+  splitDocxType
+} from "./chunk-R4TYL2G6.js";
+
+// packages/safe-bash-docx-engine/src/style-model-result-schema.ts
+var styleModelBatchOperations2 = [...styleModelBatchOperations, ...structureModelBatchActions.keys()];
+var object = (properties) => ({ type: "object", properties, required: Object.keys(properties), additionalProperties: false });
+var string = { type: "string" };
+var integer = { type: "integer", minimum: 0 };
+function value(type) {
+  if (type.startsWith("Promise<") && type.endsWith(">")) return value(type.slice(8, -1));
+  if (type === "readonly [Length, Length]") return { type: "array", items: docxValueSchema("Length"), minItems: 2, maxItems: 2 };
+  if (type === "Uint8Array") return object({ kind: { const: "bytes" }, base64: string });
+  if (type === "PackURI") return string;
+  if (type === "ExpandedName") return docxValueSchema(type);
+  if (type === "Date") return docxValueSchema(type);
+  if (type === "readonly [string, RelationshipView]") return { type: "array", items: { anyOf: [string, value("RelationshipView")] }, minItems: 2, maxItems: 2 };
+  if (type === "Image") return object({ id: string, type: { const: "Image" }, owner: { const: "batch" }, revision: { const: 0 } });
+  const variants = splitDocxType(type);
+  if (variants.length > 1) return { anyOf: variants.map(value) };
+  if (type.startsWith("ReadonlyMap<string, ") && type.endsWith(">")) return { type: "array", items: object({ key: string, value: value(type.slice("ReadonlyMap<string, ".length, -1)) }) };
+  if (type === "ReadonlyMap<ExpandedName, string>") return { type: "array", items: object({ key: docxValueSchema("ExpandedName"), value: string }) };
+  if (["Length", "Emu", "Inches", "Cm", "Mm", "Pt", "Twips"].includes(type)) return docxValueSchema("Length");
+  if (type === "void") return { type: "null" };
+  if (["string", "number", "boolean", "null", "Length"].includes(type) || type.startsWith("WD_") || type.startsWith("MSO_")) return docxValueSchema(type);
+  if ((type.startsWith("IterableIterator<") || type.startsWith("ReadonlyArray<")) && type.endsWith(">")) return { type: "array", items: value(type.slice(type.indexOf("<") + 1, -1)) };
+  const styleTypes = ["BaseStyle", "CharacterStyle", "ParagraphStyle", "_TableStyle", "_NumberingStyle"];
+  const partTypes = ["PartView", "XmlPartView", "StylesPart", "DocumentPart", "CorePropertiesPart", "ImagePart"];
+  return object({ id: string, type: styleTypes.includes(type) ? { enum: styleTypes } : partTypes.includes(type) ? { enum: [...partTypes, "NumberingPart"] } : { const: type }, owner: { const: "document" }, revision: { const: 0 } });
+}
+function styleModelOperationResultSchema(id) {
+  if (id === "paragraphs.get" || id === "runs.get") return inspectionOperationMetadata[id].result.oneOf[0];
+  const empty = { type: "array", maxItems: 0 };
+  return object({
+    version: { const: 1 },
+    operation: { const: id },
+    ok: { const: true },
+    data: value(docxOperationSchemas[id].valueType),
+    warnings: { type: "array", items: object({ code: string, message: string }) },
+    errors: empty,
+    affected: integer,
+    locations: { type: "array", items: inspectionOperationMetadata["text.replace"].result.oneOf[0].properties.locations.items }
+  });
+}
+function batchPublicationSchema() {
+  const mutation = inspectionOperationMetadata["text.replace"].result.oneOf[0].properties.data;
+  const change = mutation.properties.changes.items.properties;
+  return { ...mutation, properties: { ...mutation.properties, changes: { type: "array", items: object({ kind: { enum: ["add", "set", "remove", "replace"] }, before: { anyOf: [change.before, { type: "null" }] }, after: { anyOf: [change.after, { type: "null" }] } }) } } };
+}
+function styleModelBatchResultSchema() {
+  const empty = { type: "array", maxItems: 0 };
+  return { oneOf: [object({
+    version: { const: 1 },
+    operation: { const: "batch" },
+    ok: { const: true },
+    data: object({ results: { type: "array", items: { oneOf: [...styleModelBatchOperations2.filter((id) => docxOperationSchemas[id]), "paragraphs.get", "runs.get"].map(styleModelOperationResultSchema) } }, publication: { anyOf: [batchPublicationSchema(), { type: "null" }] } }),
+    warnings: { type: "array", items: object({ code: string, message: string }) },
+    errors: empty,
+    affected: integer,
+    locations: empty
+  }), object({
+    version: { const: 1 },
+    operation: { const: "batch" },
+    ok: { const: false },
+    data: { type: "null" },
+    warnings: empty,
+    errors: { type: "array", minItems: 1, items: object({ code: string, message: string }) },
+    affected: { const: 0 },
+    locations: empty
+  })] };
+}
+
+export {
+  styleModelOperationResultSchema,
+  batchPublicationSchema,
+  styleModelBatchResultSchema
+};