@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-3SEQG5JH.js

@@ -0,0 +1,521 @@
+import {
+  tableRows
+} from "./chunk-BERVTMQB.js";
+import {
+  DocumentPackage,
+  macroTypes
+} from "./chunk-GLPIFP7N.js";
+import {
+  UnsupportedEditError
+} from "./chunk-YPVBU7QF.js";
+import {
+  storedBooleanValue,
+  storedIntegerIdentity,
+  trimXmlWhitespace
+} from "./chunk-VEUQWV2V.js";
+import {
+  documentDialects,
+  validatePackageDialect
+} from "./chunk-MG7AJD5E.js";
+import {
+  MarkupCompatibility,
+  documentCompatibilityProfile
+} from "./chunk-GZ2N24A2.js";
+import {
+  InvalidPackageError,
+  InvalidXmlError,
+  UnsupportedProfileError,
+  isXmlContentType,
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocumentBudget,
+  InputTypeError,
+  InvalidValueError,
+  ResourceLimitError
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/validation.ts
+var SemanticValidationError = class extends InvalidPackageError {
+  constructor(diagnostics) {
+    super("Staged document validation failed.");
+    this.diagnostics = diagnostics;
+  }
+  diagnostics;
+};
+var documentValidationProfile = Object.freeze({
+  profile: "core-v1",
+  understoodNamespaces: Object.freeze([...documentCompatibilityProfile.understoodNamespaces.filter(Boolean), "http://schemas.openxmlformats.org/markup-compatibility/2006"]),
+  schema: "Selected roots and attributes; no full XSD conformance.",
+  checks: Object.freeze(["container", "part-names", "content-types", "relationships", "xml", "mce", "structure", "references", "protection", "signatures", "extension-coverage"])
+});
+var wordType = "application/vnd.openxmlformats-officedocument.wordprocessingml.";
+function integer(value, min = 0, max = 2147483647) {
+  if (value === void 0) return void 0;
+  value = trimXmlWhitespace(value);
+  if (!value.length) return void 0;
+  const digits = value[0] === "-" || value[0] === "+" ? value.slice(1) : value;
+  if (!digits.length || [...digits].some((c) => c < "0" || c > "9")) return void 0;
+  const n = Number(value);
+  return Number.isSafeInteger(n) && n >= min && n <= max ? String(n) : void 0;
+}
+function validateDocumentArchive(archive, options = {}, budget = new DocumentBudget()) {
+  if (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some((k) => !["profile", "maxParts", "maxBytes", "maxNodes", "maxDiagnostics"].includes(k)) || options.profile !== void 0 && options.profile !== "core-v1") throw new InvalidValueError("Unknown validation profile or option.");
+  const limits = { maxParts: budget.limits.zipEntries, maxBytes: budget.limits.expandedPackage, maxNodes: budget.limits.xmlNodes, maxDiagnostics: Infinity };
+  for (const key of Object.keys(limits)) {
+    const value = options[key] ?? limits[key];
+    if (value !== Infinity && !Number.isSafeInteger(value) || value < 1) throw new InvalidValueError("Validation limits must be positive safe integers or unlimited.");
+    limits[key] = value;
+  }
+  if (!archive || !Array.isArray(archive.members)) throw new InputTypeError("Expected decoded archive members.");
+  if (archive.members.length > limits.maxParts) throw new ResourceLimitError("Validation part limit exceeded.");
+  let total = 0;
+  for (const member of archive.members) {
+    if (!member || !(member.bytes instanceof Uint8Array) || typeof member.name !== "string") throw new InputTypeError("Expected typed archive members.");
+    total += member.bytes.length;
+    if (total > limits.maxBytes) throw new ResourceLimitError("Validation byte limit exceeded.");
+  }
+  budget.charge("work", total * 8);
+  const diagnostics = [];
+  const failed = /* @__PURE__ */ new Set();
+  let styleFallback = false;
+  const add = (code, part, location, message, check = "references") => {
+    if (diagnostics.length >= limits.maxDiagnostics) throw new ResourceLimitError("Validation diagnostic limit exceeded.");
+    budget.charge("diagnosticBytes", new TextEncoder().encode(code + part + location + message).length);
+    failed.add(check);
+    diagnostics.push({ code, part, location, message });
+  };
+  const result = () => ({
+    valid: diagnostics.length === 0,
+    profile: "core-v1",
+    diagnostics,
+    checks: documentValidationProfile.checks.map((id) => ({ id, status: failed.has(id) ? "failed" : ["container", "protection", "signatures", "extension-coverage"].includes(id) ? "unvalidated" : diagnostics.length ? "unvalidated" : "passed" })),
+    warnings: [
+      "Partial schema and semantic validation only; no full conformance certification.",
+      "Container integrity requires byte admission; protection, signatures and extension semantics are unvalidated.",
+      ...styleFallback ? ["Unresolved style references use document defaults or inherited formatting."] : []
+    ]
+  });
+  for (const name of ["[Content_Types].xml", "_rels/.rels"]) {
+    if (!archive.members.some((m) => !m.directory && m.name.toLowerCase() === name.toLowerCase()))
+      add("required-part", "/" + name, "/", "Required package metadata is missing.", "structure");
+  }
+  if (diagnostics.length) return result();
+  const roots = /* @__PURE__ */ new Map();
+  let remaining = limits.maxNodes;
+  const parse = (part, bytes) => {
+    const root2 = parseDocumentXml(bytes, { maxBytes: Math.min(limits.maxBytes, budget.limits.xmlPartBytes), maxNodes: Math.max(1, remaining) }, budget).root;
+    const stack = [root2];
+    while (stack.length) {
+      if (--remaining < 0) throw new ResourceLimitError("Validation node limit exceeded.");
+      const node = stack.pop();
+      for (const child of node.children) stack.push(child);
+    }
+    roots.set(part, root2);
+  };
+  for (const member of archive.members) {
+    if (member.name.toLowerCase() === "[content_types].xml" || member.name.toLowerCase().endsWith(".rels")) {
+      try {
+        parse("/" + member.name, member.bytes);
+      } catch (e) {
+        if (!(e instanceof InvalidXmlError)) throw e;
+        add("invalid-xml", "/" + member.name, "/", e.message, "xml");
+      }
+    }
+  }
+  if (diagnostics.length) return result();
+  let graph;
+  try {
+    graph = new DocumentPackage(archive, {
+      maxMembers: limits.maxParts,
+      maxArchiveBytes: limits.maxBytes,
+      maxEntryBytes: limits.maxBytes,
+      maxTotalBytes: limits.maxBytes,
+      maxPathBytes: Infinity,
+      maxDepth: Infinity,
+      maxExtraBytes: Infinity,
+      maxCommentBytes: Infinity,
+      maxRetainedBytes: budget.limits.retainedBytes,
+      chunkSize: 4096
+    }, budget);
+  } catch (e) {
+    if (!(e instanceof InvalidPackageError || e instanceof InvalidXmlError)) throw e;
+    add(e instanceof InvalidPackageError ? e.diagnosticCode : "invalid-xml", e instanceof InvalidPackageError ? e.part ?? "/" : "/", e instanceof InvalidPackageError ? e.location : "/", e.message, "relationships");
+    return result();
+  }
+  if ([...graph.defaults, ...graph.overrides].some((declaration) => macroTypes.has(parseMediaType(declaration.content_type))))
+    throw new UnsupportedProfileError("Macro-enabled document containers are unsupported.");
+  for (const part of graph.parts) {
+    if (!roots.has(part.partname) && isXmlContentType(part.content_type)) {
+      try {
+        parse(part.partname, part.bytes);
+      } catch (e) {
+        if (!(e instanceof InvalidXmlError)) throw e;
+        add("invalid-xml", part.partname, "/", e.message, "xml");
+      }
+    }
+  }
+  if (diagnostics.length) return result();
+  const mains = graph.relationships("/").filter((e) => Object.values(documentDialects).some((d) => e.reltype === d.r + "/officeDocument"));
+  if (mains.length !== 1 || mains[0].is_external || mains[0].fragment !== null) {
+    add("main-part", "/_rels/.rels", "/", "Exactly one internal main relationship without a fragment is required.", "structure");
+    return result();
+  }
+  const main = mains[0].target_part;
+  if (![wordType + "document.main+xml", wordType + "template.main+xml"].includes(parseMediaType(main.content_type)))
+    throw new UnsupportedProfileError("Only non-macro Word documents and templates are supported.");
+  const root = roots.get(main.partname);
+  if (!root) {
+    add("part-root", main.partname, "/", "Missing document XML root.", "structure");
+    return result();
+  }
+  let dialect;
+  try {
+    dialect = validatePackageDialect(graph, mains[0], root, budget);
+  } catch (e) {
+    if (!(e instanceof InvalidPackageError)) throw e;
+    add(e.diagnosticCode, e.part ?? main.partname, e.location, e.message, "structure");
+    return result();
+  }
+  const { w, r, wp } = documentDialects[dialect];
+  const attr = (node, name, namespace = w) => {
+    budget.charge("work", node.element.attributes.length);
+    return node.element.attributes.find((a) => a.namespace === namespace && a.localName === name)?.value;
+  };
+  const children = (node, name) => {
+    budget.charge("work", node.element.content.length);
+    return node.element.content.flatMap((child, i) => "source" in child && child.source.namespace === w && child.source.localName === name ? [{ ...node, element: child, location: `${node.location}/${name}[${i + 1}]` }] : []);
+  };
+  const terminalCellBlock = (content) => {
+    for (let index = content.length - 1; index >= 0; index--) {
+      budget.charge("work", 1);
+      const item = content[index];
+      if (!("source" in item) || item.source.namespace !== w) continue;
+      const name = item.source.localName;
+      if (name === "p" || name === "tbl") return name;
+      if (["sdt", "sdtContent", "customXml", "ins", "del", "moveFrom", "moveTo"].includes(name) && "content" in item) {
+        const last = terminalCellBlock(item.content);
+        if (last) return last;
+      }
+    }
+    return void 0;
+  };
+  const issue = (node, code, message) => add(code, node.part, node.location, message);
+  const semanticParts = /* @__PURE__ */ new Set([main.partname]);
+  for (const edge of graph.relationships(main.partname)) {
+    if (!edge.is_external && ["styles", "numbering", "header", "footer", "footnotes", "endnotes", "comments"].some((name) => edge.reltype === `${r}/${name}`))
+      semanticParts.add(edge.target_part.partname);
+  }
+  const nodes = [];
+  for (const part of graph.parts) {
+    const partRoot = roots.get(part.partname);
+    if (!partRoot || !semanticParts.has(part.partname) || !part.content_type.toLowerCase().startsWith(wordType)) continue;
+    const view = new MarkupCompatibility(partRoot, documentCompatibilityProfile, budget);
+    const pending = [{ content: view.content, index: 0, location: "", story: "/", fieldStory: "/" }];
+    while (pending.length) {
+      const frame = pending.at(-1);
+      if (frame.index >= frame.content.length) {
+        pending.pop();
+        continue;
+      }
+      const index = frame.index++, element = frame.content[index];
+      if (!("source" in element) || element.disposition !== "understood") continue;
+      const path = `${frame.location}/${element.source.localName}[${index + 1}]`;
+      const local = element.source.localName;
+      const scope = element.source.namespace === w && ["footnote", "endnote", "comment", "txbxContent"].includes(local) ? path : frame.story;
+      const fieldScope = scope !== frame.story || element.source.namespace === w && local === "fldSimple" ? path : frame.fieldStory;
+      nodes.push({ element, part: part.partname, location: path, story: part.partname + scope, fieldStory: part.partname + fieldScope });
+      pending.push({ content: element.content, index: 0, location: path, story: scope, fieldStory: fieldScope });
+    }
+  }
+  const definitions = /* @__PURE__ */ new Map();
+  const styleDefinitions = /* @__PURE__ */ new Map();
+  const definitionNames = { style: "styleId", num: "numId", abstractNum: "abstractNumId", footnote: "id", endnote: "id", comment: "id" };
+  for (const node of nodes) {
+    if (node.element.source.namespace !== w) continue;
+    const name = node.element.source.localName;
+    if (name === "lsdException" && attr(node, "name") === void 0)
+      issue(node, "latent-name", "A latent style exception requires its native name attribute.");
+    if (!Object.hasOwn(definitionNames, name)) continue;
+    const raw = attr(node, definitionNames[name]);
+    const specialNote = (name === "footnote" || name === "endnote") && ["separator", "continuationSeparator", "continuationNotice"].includes(attr(node, "type") ?? "normal");
+    const id = name === "style" ? raw : integer(raw, specialNote ? -Number.MAX_SAFE_INTEGER : 0, Number.MAX_SAFE_INTEGER);
+    const key = `${node.part}:${name}`;
+    const entries = definitions.get(key) ?? /* @__PURE__ */ new Map();
+    if (name === "style") {
+      const styles = styleDefinitions.get(key) ?? [];
+      styles.push(node);
+      styleDefinitions.set(key, styles);
+    }
+    if (name === "style" && raw === void 0) {
+      definitions.set(key, entries);
+      continue;
+    }
+    if (id === void 0 || id === "" || entries.has(id)) issue(node, name + "-id", "Missing, invalid or duplicate definition ID.");
+    else entries.set(id, node);
+    definitions.set(key, entries);
+  }
+  const relatedParts = new Map(graph.relationships(main.partname).filter((e) => !e.is_external).map((e) => [e.reltype, e.target_part.partname]));
+  const related = (name) => relatedParts.get(`${r}/${name}`);
+  const relationships = new Map(graph.parts.filter((p) => parseMediaType(p.content_type) !== "application/vnd.openxmlformats-package.relationships+xml").map((p) => [p.partname, new Map(graph.relationships(p.partname).map((e) => [e.rId, e]))]));
+  const lookup = (name, id, part = related(name === "style" ? "styles" : name === "num" || name === "abstractNum" ? "numbering" : name === "comment" ? "comments" : name + "s")) => id === void 0 || !part ? void 0 : definitions.get(`${part}:${name}`)?.get(id);
+  const completedStyles = /* @__PURE__ */ new Set();
+  for (const [key, entries] of definitions) {
+    if (!key.endsWith(":style")) continue;
+    const styles = styleDefinitions.get(key);
+    const defaults = /* @__PURE__ */ new Set();
+    for (const style of styles) {
+      const type = attr(style, "type") ?? "paragraph";
+      if (storedBooleanValue(attr(style, "default") ?? "0") === true) {
+        if (defaults.has(type)) issue(style, "style-default", "A style type has multiple defaults.");
+        defaults.add(type);
+      }
+      for (const [tag, code] of [["basedOn", "style-base-type"], ["next", "style-next-type"], ["link", "style-link-type"]]) {
+        const reference = children(style, tag)[0];
+        const target = reference && entries.get(attr(reference, "val") ?? "");
+        if (!target) continue;
+        const targetType = attr(target, "type") ?? "paragraph";
+        const compatible = tag === "link" ? type === "paragraph" && targetType === "character" || type === "character" && targetType === "paragraph" : tag === "next" ? type === "paragraph" && targetType === "paragraph" : type === targetType;
+        if (!compatible) issue(reference, code, "Style relationship has incompatible types.");
+      }
+    }
+    const completedLinks = /* @__PURE__ */ new Set();
+    for (const start of styles) {
+      const path = /* @__PURE__ */ new Map();
+      let current = start;
+      while (current && !completedLinks.has(current)) {
+        budget.charge("work", 1);
+        const previous = path.get(current);
+        if (previous !== void 0) {
+          if (path.size - previous !== 2) issue(current, "style-link-cycle", "Linked styles contain a cycle beyond a reciprocal pair.");
+          break;
+        }
+        path.set(current, path.size);
+        const link = children(current, "link")[0];
+        current = link ? entries.get(attr(link, "val") ?? "") : void 0;
+      }
+      for (const node of path.keys()) completedLinks.add(node);
+    }
+    for (const start of styles) {
+      const chain = /* @__PURE__ */ new Set();
+      let current = start;
+      while (current && !completedStyles.has(current)) {
+        if (chain.has(current)) {
+          issue(current, "style-cycle", "Style inheritance contains a cycle.");
+          break;
+        }
+        chain.add(current);
+        const base = children(current, "basedOn")[0];
+        current = base ? entries.get(attr(base, "val") ?? "") : void 0;
+      }
+      for (const node of chain) completedStyles.add(node);
+    }
+  }
+  const numberingNext = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.element.source.namespace !== w) continue;
+    const name = node.element.source.localName;
+    let target;
+    if (name === "num") {
+      const id = children(node, "abstractNumId")[0];
+      target = id && lookup("abstractNum", integer(attr(id, "val"), 0, Number.MAX_SAFE_INTEGER), node.part);
+    } else if (name === "abstractNum") {
+      const link = children(node, "numStyleLink")[0];
+      target = link && lookup("style", attr(link, "val"));
+    } else if (name === "style") {
+      const pPr = children(node, "pPr")[0];
+      const numPr = pPr && children(pPr, "numPr")[0];
+      const id = numPr && children(numPr, "numId")[0];
+      target = id && lookup("num", integer(attr(id, "val"), 0, Number.MAX_SAFE_INTEGER));
+    }
+    if (target) numberingNext.set(node, target);
+  }
+  const resolvedNumbering = /* @__PURE__ */ new Map();
+  for (const start of numberingNext.keys()) {
+    const chain = /* @__PURE__ */ new Set();
+    let current = start;
+    while (current && !resolvedNumbering.has(current)) {
+      if (chain.has(current)) {
+        issue(current, "numbering-cycle", "Numbering style dependencies contain a cycle.");
+        current = void 0;
+        break;
+      }
+      chain.add(current);
+      const next = numberingNext.get(current);
+      if (!next) break;
+      current = next;
+    }
+    const terminal = current && (resolvedNumbering.has(current) ? resolvedNumbering.get(current) : current);
+    for (const node of chain) resolvedNumbering.set(node, terminal);
+  }
+  const unique = /* @__PURE__ */ new Map();
+  const claim = (key, id) => {
+    const set = unique.get(key) ?? /* @__PURE__ */ new Set();
+    if (id === void 0 || set.has(id)) return false;
+    set.add(id);
+    unique.set(key, set);
+    return true;
+  };
+  const bookmarks = /* @__PURE__ */ new Map();
+  const fields = /* @__PURE__ */ new Map();
+  const commentRanges = /* @__PURE__ */ new Map();
+  const revisionRanges = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const name = node.element.source.localName;
+    const namespace = node.element.source.namespace;
+    for (const a of node.element.attributes) {
+      if (a.namespace !== r || !["id", "embed", "link"].includes(a.localName)) continue;
+      const edge = relationships.get(node.part)?.get(a.value);
+      if (!edge) issue(node, "relationship-reference", "Relationship ID is not defined by the owning part.");
+      const expected = namespace === w ? { hyperlink: "hyperlink", headerReference: "header", footerReference: "footer" }[name] : namespace === documentDialects[dialect].a && name === "blip" ? "image" : void 0;
+      if (edge && expected && edge.reltype !== `${r}/${expected}`) issue(node, "relationship-type", "Relationship type disagrees with the referring element.");
+      if (edge && expected === "image" && !edge.is_external && !edge.target_part.content_type.toLowerCase().startsWith("image/"))
+        issue(node, "relationship-content-type", "Image relationship target has a non-image content type.");
+    }
+    if (namespace === wp && name === "docPr" && !claim("drawing", integer(attr(node, "id", ""), 0, 4294967295))) issue(node, "drawing-id", "Invalid or duplicate document drawing ID.");
+    if (namespace !== w) continue;
+    if (name === "tc") {
+      if (terminalCellBlock(node.element.content) !== "p")
+        add("cell-terminal-paragraph", node.part, node.location, "A table cell requires a terminal paragraph.", "structure");
+    }
+    if (["pStyle", "rStyle", "tblStyle", "basedOn", "next", "link", "numStyleLink", "styleLink"].includes(name) && !lookup("style", attr(node, "val"))) {
+      if (attr(node, "val") !== void 0 && !["numStyleLink", "styleLink"].includes(name)) styleFallback = true;
+      else issue(node, "style-reference", "Style reference has no definition.");
+    }
+    const expectedStyleType = { pStyle: "paragraph", rStyle: "character", tblStyle: "table" };
+    if (Object.hasOwn(expectedStyleType, name)) {
+      const style = lookup("style", attr(node, "val"));
+      if (style && (attr(style, "type") ?? "paragraph") !== expectedStyleType[name]) issue(node, "style-type", "Style type disagrees with its usage.");
+    }
+    if (name === "num" && children(node, "abstractNumId").length !== 1) issue(node, "numbering-reference", "Numbering instances require exactly one abstract reference.");
+    if (name === "abstractNum" || name === "num") {
+      const levels = children(node, name === "num" ? "lvlOverride" : "lvl");
+      const ids = /* @__PURE__ */ new Set();
+      for (const level of levels) {
+        const id = integer(attr(level, "ilvl"), 0, 8);
+        if (id === void 0 || ids.has(id)) issue(level, "numbering-level", "Invalid or duplicate numbering level.");
+        else ids.add(id);
+      }
+    }
+    if (name === "lvlOverride") {
+      const levels = children(node, "lvl");
+      if (levels.length > 1 || children(node, "startOverride").length > 1)
+        issue(node, "numbering-override", "Numbering overrides allow at most one level and one start value.");
+      const id = integer(attr(node, "ilvl"), 0, 8);
+      for (const level of levels) {
+        const nestedId = integer(attr(level, "ilvl"), 0, 8);
+        if (nestedId === void 0 || nestedId !== id)
+          issue(level, "numbering-level", "Override level must match its owning numbering level.");
+      }
+    }
+    if (name === "numPr") {
+      const numId = children(node, "numId")[0];
+      const level = children(node, "ilvl")[0];
+      const id = numId && integer(attr(numId, "val"), 0, Number.MAX_SAFE_INTEGER);
+      const ilvl = level ? integer(attr(level, "val"), 0, 8) : "0";
+      const num = lookup("num", id);
+      const abstractId = num && children(num, "abstractNumId")[0];
+      const direct = abstractId && lookup("abstractNum", integer(attr(abstractId, "val"), 0, Number.MAX_SAFE_INTEGER), abstractId.part);
+      const abstract = direct && (resolvedNumbering.has(direct) ? resolvedNumbering.get(direct) : direct);
+      const override = num && children(num, "lvlOverride").find((l) => integer(attr(l, "ilvl")) === ilvl && children(l, "lvl").length === 1);
+      if (ilvl === void 0 || id !== void 0 && id !== "0" && num && !override && (!abstract || !children(abstract, "lvl").some((l) => integer(attr(l, "ilvl")) === ilvl))) issue(node, "numbering-level", "Numbering level has no matching definition.");
+    }
+    if (name === "numId" && integer(attr(node, "val"), 0, Number.MAX_SAFE_INTEGER) !== "0" && !lookup("num", integer(attr(node, "val"), 0, Number.MAX_SAFE_INTEGER))) issue(node, "numbering-reference", "Numbering reference has no instance.");
+    if (name === "abstractNumId" && !lookup("abstractNum", integer(attr(node, "val"), 0, Number.MAX_SAFE_INTEGER), node.part)) issue(node, "numbering-reference", "Abstract numbering reference has no definition.");
+    if (["footnoteReference", "endnoteReference", "commentReference", "commentRangeStart", "commentRangeEnd"].includes(name)) {
+      const type = name.startsWith("footnote") ? "footnote" : name.startsWith("endnote") ? "endnote" : "comment";
+      if (!lookup(type, integer(attr(node, "id"), 0, Number.MAX_SAFE_INTEGER))) issue(node, type === "comment" ? "comment-reference" : "note-reference", "Annotation reference has no definition.");
+    }
+    if (name === "bookmarkStart" || name === "bookmarkEnd") {
+      const id = integer(attr(node, "id"), 0, Number.MAX_SAFE_INTEGER);
+      const key = node.story + ":" + id;
+      if (name === "bookmarkStart") {
+        if (!claim(node.story + ":bookmark", id) || !claim("bookmark-name", attr(node, "name"))) issue(node, "bookmark-range", "Invalid or duplicate bookmark start.");
+        bookmarks.set(key, node);
+      } else if (id === void 0 || !bookmarks.delete(key)) issue(node, "bookmark-range", "Bookmark end has no preceding start in this story.");
+    }
+    if (name === "commentRangeStart" || name === "commentRangeEnd") {
+      const key = node.story + ":" + integer(attr(node, "id"), 0, Number.MAX_SAFE_INTEGER);
+      if (name === "commentRangeStart") {
+        if (commentRanges.has(key)) issue(node, "comment-range", "Duplicate open comment range.");
+        commentRanges.set(key, node);
+      } else if (!commentRanges.delete(key)) issue(node, "comment-range", "Comment end has no preceding start.");
+    }
+    if (["ins", "del", "moveFrom", "moveTo", "rPrChange", "pPrChange", "sectPrChange", "tblPrChange", "trPrChange", "tcPrChange", "tblGridChange", "numberingChange", "cellIns", "cellDel", "cellMerge", "tblPrExChange"].includes(name) && !claim("revision", storedIntegerIdentity(attr(node, "id"))))
+      issue(node, "revision-id", "Invalid or duplicate tracked revision ID.");
+    for (const kind of ["moveFrom", "moveTo", "customXmlIns", "customXmlDel", "customXmlMoveFrom", "customXmlMoveTo"]) {
+      if (name !== kind + "RangeStart" && name !== kind + "RangeEnd") continue;
+      const id = storedIntegerIdentity(attr(node, "id"));
+      const key = node.story + ":" + kind + ":" + id;
+      if (name.endsWith("Start")) {
+        if (!claim(node.story + ":" + kind, id)) issue(node, "revision-id", "Invalid or duplicate tracked range ID.");
+        revisionRanges.set(key, node);
+      } else if (id === void 0 || !revisionRanges.delete(key)) issue(node, "revision-id", "Tracked range end has no matching preceding start.");
+    }
+    if (name === "fldSimple" && attr(node, "instr") === void 0)
+      issue(node, "field-instruction", "Simple fields require a native instruction attribute.");
+    if (name === "instrText") {
+      const field = fields.get(node.fieldStory)?.at(-1);
+      if (!field || field.separated || node.element.source.children.length)
+        issue(node, "field-instruction", "Instruction text requires an open instruction region without child elements.");
+    }
+    if (name === "fldChar") {
+      const stack = fields.get(node.fieldStory) ?? [];
+      const kind = attr(node, "fldCharType");
+      if (kind === "begin") stack.push({ node, separated: false });
+      else if (kind === "end" && stack.length) stack.pop();
+      else if (kind === "separate" && stack.length && !stack.at(-1).separated) stack.at(-1).separated = true;
+      else issue(node, "field-balance", "Unmatched or repeated field delimiter.");
+      fields.set(node.fieldStory, stack);
+    }
+    if (name === "tbl") {
+      const grids = children(node, "tblGrid");
+      const width = grids.length === 1 ? children(grids[0], "gridCol").length : 0;
+      let rows = [];
+      try {
+        rows = tableRows(node, (node2) => node2.element.source, (node2) => node2.element.content.flatMap((child, index) => "source" in child ? [{ ...node2, element: child, location: `${node2.location}/${child.source.localName}[${index + 1}]` }] : []), budget);
+      } catch (error) {
+        if (!(error instanceof UnsupportedEditError)) throw error;
+        issue(node, "table-grid", error.message);
+      }
+      if (width && rows.length) budget.table(rows.length, width);
+      if (!width) issue(node, "table-grid", "A table needs one nonempty grid.");
+      let previous = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const properties = children(row, "trPr")[0];
+        const count = (parent, key, fallback) => {
+          const value = parent && children(parent, key)[0];
+          return value ? Number(integer(attr(value, "val")) ?? NaN) : fallback;
+        };
+        let column = count(properties, "gridBefore", 0);
+        const next = /* @__PURE__ */ new Map();
+        for (const cell of children(row, "tc")) {
+          const props = children(cell, "tcPr")[0];
+          const span = count(props, "gridSpan", 1);
+          const merge = props && children(props, "vMerge")[0];
+          if (!Number.isSafeInteger(span) || span < 1) issue(cell, "table-grid", "Invalid cell span.");
+          if (merge) {
+            const value = attr(merge, "val") ?? "continue";
+            if (value !== "restart" && (value !== "continue" || previous.get(column) !== span)) issue(cell, "table-grid", "Vertical continuation does not match the preceding row span.");
+            next.set(column, span);
+          }
+          column += span;
+        }
+        if (column + count(properties, "gridAfter", 0) !== width) issue(row, "table-grid", "Row cells and omitted slots disagree with the table grid.");
+        previous = next;
+      }
+    }
+  }
+  for (const node of revisionRanges.values()) issue(node, "revision-id", "Tracked range start has no matching end.");
+  for (const node of bookmarks.values()) issue(node, "bookmark-range", "Bookmark start has no end in this story.");
+  for (const node of commentRanges.values()) issue(node, "comment-range", "Comment range start has no end.");
+  for (const stack of fields.values()) for (const { node } of stack) issue(node, "field-balance", "Field begin has no end in this story.");
+  return result();
+}
+
+export {
+  SemanticValidationError,
+  documentValidationProfile,
+  validateDocumentArchive
+};

package/dist/safe-bash/command-chunks/chunk-3SWT2KYH.js

@@ -0,0 +1,78 @@
+import {
+  stageTrackedText
+} from "./chunk-IB2Q5CL3.js";
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  UnsupportedEditError
+} from "./chunk-YPVBU7QF.js";
+import {
+  SelectionError,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/revision-edit.ts
+async function editDocumentRevisions(input, options, context) {
+  const settings = archiveSettings(context);
+  const { input: identity, ...args } = options;
+  const invocation = validateDocxInvocation({ operation: "revisions.add", inputs: [identity?.path ?? "document"], options: args }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const { kind, text, author, timestamp, all, allowEmpty, output, inPlace, force, dryRun, json, ...selection } = opts;
+  delete selection.limit;
+  const selected = resolveDocxSelection(document, { operation: "text.get", inputs: ["document"], options: selection });
+  const targets = [];
+  for (const target of selected) if (["paragraph", "run"].includes(target.kind)) targets.push(target);
+  else targets.push(...document.list("paragraph", { owner: target.token }));
+  const chosen = document.select(targets, { ...all === void 0 ? {} : { all }, ...allowEmpty === void 0 ? {} : { allowEmpty } }, "mutation");
+  if (!chosen.length && !allowEmpty) throw new SelectionError("missing-selection");
+  const archive = document.snapshot();
+  assertDocumentEditable(archive, { ...settings, budget });
+  const editor = new DocumentArchiveEditor(archive, {}, void 0, budget);
+  const edits = [];
+  for (const target of chosen) {
+    if (!["paragraph", "run"].includes(target.kind)) throw new UnsupportedEditError("Tracked creation requires a paragraph or run text selection.");
+    if (document.references(target.token).length > 1) throw new SelectionError("ambiguous-selection");
+    const paragraph = target.kind === "paragraph" ? target : document.list("paragraph", { scope: "all-stories" }).find((location) => location.value.story === target.value.story && location.value.path.every((i, n) => target.value.path[n] === i));
+    const wholeToken = encodeGeneratedLocation({ ...target.value, range: null });
+    const length = [...document.text({ select: wholeToken }).text].length;
+    const range = target.value.range ?? { start: kind === "insert" ? length : 0, end: length };
+    if (kind === "insert" && range.start !== range.end || kind === "delete" && range.start === range.end) throw new UnsupportedEditError("Tracked creation requires a caret or a nonempty deletion range.");
+    let offset = 0;
+    if (target.kind === "run") for (const run of document.list("run", { owner: paragraph.token })) {
+      if (run.token === target.token || run.value.path.every((i, n) => target.value.path[n] === i)) break;
+      offset += [...document.text({ select: run.token }).text].length;
+    }
+    if (kind === "insert" && text === "" && allowEmpty) continue;
+    edits.push({ paragraph, start: offset + range.start, end: offset + range.end, text: kind === "insert" ? text : "" });
+  }
+  stageTrackedText(editor, edits, { author, timestamp }, budget, settings.limits);
+  const changes = edits.map((edit) => {
+    const value = { ...edit.paragraph.value, generation: 1 };
+    return { kind: kind === "insert" ? "insert" : "remove", before: edit.paragraph, after: { ...edit.paragraph, value, token: encodeGeneratedLocation(value) } };
+  });
+  const prospective = { changed: edits.length > 0, changes, output: dryRun ? null : { path: inPlace ? identity?.path ?? null : output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) }, dryRun: dryRun ?? false };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: "revisions.add", ok: true, data: prospective, affected: changes.length, locations: changes.map((change) => change.after), warnings: [], errors: [] }) + "\n").length);
+  const published = await publishDocumentArchive(editor.snapshot(), { ...identity ? { input: identity } : {}, ...output === void 0 ? {} : { output }, ...inPlace === void 0 ? {} : { inPlace }, ...force === void 0 ? {} : { force }, ...dryRun === void 0 ? {} : { dryRun }, ...json === void 0 ? {} : { json } }, { ...context, budget });
+  return { ...prospective, output: published.published.length ? { path: published.published[0].path, bytes: published.published[0].bytes, sha256: published.archiveSha256 } : null };
+}
+
+export {
+  editDocumentRevisions
+};