@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,679 @@
+import {
+  admitControlPng,
+  inspectControlSnapshot,
+  openControlInventory,
+  prepareControlPlaceholder,
+  prepareControlValue
+} from "./chunk-2B6XWO6A.js";
+import {
+  assertOutsideFields,
+  parseFields
+} from "./chunk-6EHVFKM7.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  characterizeRasterHeader
+} from "./chunk-FZSQMMYV.js";
+import {
+  pathContains
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  tableRows
+} from "./chunk-BERVTMQB.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  assertOutsideRevisionRanges,
+  containsRevision,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  storedIntegerIdentity,
+  trimXmlWhitespace
+} from "./chunk-VEUQWV2V.js";
+import {
+  commentExtensionParts
+} from "./chunk-MG7AJD5E.js";
+import {
+  SelectionError,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  archiveSettings,
+  documentXmlCache
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/control-clone.ts
+var word = ["http://schemas.openxmlformats.org/wordprocessingml/2006/main", "http://purl.oclc.org/ooxml/wordprocessingml/main"];
+var relationships = ["http://schemas.openxmlformats.org/officeDocument/2006/relationships", "http://purl.oclc.org/ooxml/officeDocument/relationships"];
+var drawingMain = ["http://schemas.openxmlformats.org/drawingml/2006/main", "http://purl.oclc.org/ooxml/drawingml/main"];
+var pictures = ["http://schemas.openxmlformats.org/drawingml/2006/picture", "http://purl.oclc.org/ooxml/drawingml/picture"];
+var drawings = ["http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing", "http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing"];
+function nodes(root, budget) {
+  budget.charge("work", 1);
+  const result = [];
+  budget.charge("retainedBytes", 8);
+  const pending = [root];
+  while (pending.length) {
+    const node = pending.pop();
+    budget.charge("work", node.children.length + node.attributes.length + 1);
+    budget.charge("retainedBytes", 8 + node.children.length * 8);
+    result.push(node);
+    for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+  }
+  return result;
+}
+function parents(root, budget) {
+  budget.charge("work", 1);
+  const result = /* @__PURE__ */ new Map();
+  for (const node of nodes(root, budget)) for (const child2 of node.children) {
+    budget.charge("work", 1);
+    budget.charge("retainedBytes", 16);
+    result.set(child2, node);
+  }
+  return result;
+}
+function attribute(node, name, namespace = node.namespace) {
+  return node.attributes.find((attribute2) => attribute2.namespace === namespace && attribute2.localName === name)?.value;
+}
+function number(value, signed = false, maximum = 4294967295) {
+  if (value === void 0) throw new UnsupportedEditError("A template identity is malformed.");
+  const raw = trimXmlWhitespace(value), digits = raw[0] === "+" || raw[0] === "-" ? raw.slice(1) : raw;
+  if (!digits || [...digits].some((char) => !"0123456789".includes(char))) throw new UnsupportedEditError("A template identity is malformed.");
+  const result = Number(raw);
+  if (!Number.isSafeInteger(result) || result < (signed ? -2147483648 : 0) || result > maximum) throw new UnsupportedEditError("A template identity is out of range.");
+  return result === 0 ? 0 : result;
+}
+function controlIdentity(value, budget) {
+  budget.charge("work", value?.length ?? 1);
+  const identity = storedIntegerIdentity(value);
+  if (identity === void 0) throw new UnsupportedEditError("A template identity is malformed.");
+  budget.charge("retainedBytes", identity.length * 2);
+  return identity;
+}
+function opening(node, changes = /* @__PURE__ */ new Map()) {
+  return `<${node.name}${[...node.namespaces].filter(([prefix]) => prefix !== "xml").map(([prefix, uri]) => ` ${prefix ? "xmlns:" + prefix : "xmlns"}="${xmlValue(uri)}"`).join("")}${node.attributes.filter((attribute2) => attribute2.namespace !== "http://www.w3.org/2000/xmlns/").map((attribute2) => ` ${attribute2.name}="${xmlValue(changes.get(attribute2.name) ?? attribute2.value)}"`).join("")}>`;
+}
+var ControlClonePlanner = class {
+  #context;
+  #package;
+  #identities = /* @__PURE__ */ new Map();
+  #nextIdentity;
+  #names = /* @__PURE__ */ new Set();
+  #relationships = /* @__PURE__ */ new Map();
+  #admittedMedia = /* @__PURE__ */ new Set();
+  #comments = [];
+  #source = /* @__PURE__ */ new Map();
+  constructor(archive, context) {
+    this.#context = archiveSettings(context);
+    this.#package = new DocumentPackage(archive, this.#context.limits, this.#context.budget);
+    this.#context.budget.charge("retainedBytes", 96);
+    this.#nextIdentity = /* @__PURE__ */ new Map();
+    const storyParts = new Map(Object.entries({ "document.main": "document", "template.main": "document", header: "hdr", footer: "ftr", footnotes: "footnotes", endnotes: "endnotes", comments: "comments" }).map(([kind, root]) => [`application/vnd.openxmlformats-officedocument.wordprocessingml.${kind}+xml`, root]));
+    for (const part of this.#package.parts) {
+      const root = storyParts.get(parseMediaType(part.content_type));
+      if (root === void 0) continue;
+      const xml = new DocumentXmlEditor(part.bytes, {}, void 0, this.#context.budget);
+      if (!word.includes(xml.root.namespace) || xml.root.localName !== root) throw new UnsupportedEditError("A declared story part requires its matching WordprocessingML root.");
+      this.#source.set(part.partname, xml);
+      const owners = parents(xml.root, this.#context.budget);
+      const children = activeXmlChildren(xml, this.#context.budget);
+      for (const node of nodes(xml.root, this.#context.budget)) {
+        if (node.localName === "sdt" && word.includes(node.namespace)) for (const properties of children(node).filter((child2) => child2.namespace === node.namespace && child2.localName === "sdtPr")) {
+          for (const id of children(properties).filter((child2) => child2.namespace === node.namespace && child2.localName === "id" && attribute(child2, "val") !== void 0)) this.#reserve("control", controlIdentity(attribute(id, "val"), this.#context.budget));
+        }
+        if (node.localName === "id" && word.includes(node.namespace) && owners.get(node)?.localName === "sdtPr" && owners.get(node)?.namespace === node.namespace && owners.get(owners.get(node))?.localName === "sdt" && owners.get(owners.get(node))?.namespace === node.namespace && attribute(node, "val") !== void 0) this.#reserve("control", controlIdentity(attribute(node, "val"), this.#context.budget));
+        if (word.includes(node.namespace) && node.localName === "bookmarkStart") {
+          this.#reserve("bookmark", String(number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER)));
+          this.#names.add(attribute(node, "name") ?? "");
+        }
+        if (word.includes(node.namespace) && node.localName === "comment" && owners.get(node)?.localName === "comments" && owners.get(node)?.namespace === node.namespace) this.#reserve("comment", String(number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER)));
+        if (drawings.includes(node.namespace) && node.localName === "docPr" || pictures.includes(node.namespace) && node.localName === "cNvPr") this.#reserve("drawing", String(number(attribute(node, "id", ""))));
+      }
+    }
+  }
+  #taken(kind) {
+    let values = this.#identities.get(kind);
+    if (!values) {
+      this.#context.budget.charge("retainedBytes", 64 + kind.length * 2);
+      values = /* @__PURE__ */ new Set();
+      this.#identities.set(kind, values);
+    }
+    return values;
+  }
+  #reserve(kind, identity) {
+    const values = this.#taken(kind);
+    if (!values.has(identity)) {
+      this.#context.budget.charge("retainedBytes", 32 + identity.length * 2);
+      values.add(identity);
+    }
+  }
+  #allocate(kind) {
+    const values = this.#taken(kind), next = this.#nextIdentity.get(kind);
+    let value = next ?? 1;
+    while (values.has(String(value))) {
+      this.#context.budget.charge("work", 1);
+      value++;
+    }
+    if (value > 2147483647) throw new UnsupportedEditError("Template identities are exhausted.");
+    if (next === void 0) this.#context.budget.charge("retainedBytes", 64 + kind.length * 2);
+    const identity = String(value);
+    this.#reserve(kind, identity);
+    this.#nextIdentity.set(kind, value + 1);
+    return identity;
+  }
+  admit(xml, item) {
+    const all = nodes(item, this.#context.budget), budget = this.#context.budget;
+    const supported = new Set("comment sdt sdtPr sdtEndPr sdtContent id tag alias lock text richText picture date dateFormat lid calendar storeMappedDataAs dropDownList comboBox listItem showingPlcHdr placeholder docPart temporary color appearance p pPr r rPr t tab br cr tbl tblPr tblGrid gridCol tr trPr tc tcPr tblStyle tblW tblInd tblBorders top left bottom right insideH insideV tblLayout tblCellMar tcW vAlign cantSplit tblHeader jc spacing ind keepNext keepLines pageBreakBefore widowControl numPr ilvl numId pStyle rStyle b bCs i iCs u strike dstrike caps smallCaps sz szCs rFonts lang highlight shd vertAlign noProof position kern w fitText rtl cs vanish webHidden textDirection drawing hyperlink bookmarkStart bookmarkEnd commentRangeStart commentRangeEnd commentReference".split(" "));
+    const attributeNames = {
+      comment: ["id", "author", "date", "initials"],
+      p: ["rsidR", "rsidRDefault", "rsidP", "rsidDel"],
+      r: ["rsidR", "rsidRPr", "rsidDel"],
+      tr: ["rsidR", "rsidTr", "rsidDel"],
+      tbl: ["rsidR"],
+      sdt: [],
+      sdtPr: [],
+      sdtEndPr: [],
+      sdtContent: [],
+      pPr: [],
+      rPr: [],
+      tblPr: [],
+      tblGrid: [],
+      trPr: [],
+      tc: [],
+      tcPr: [],
+      t: [],
+      drawing: [],
+      bookmarkStart: ["id", "name", "colFirst", "colLast", "displacedByCustomXml"],
+      bookmarkEnd: ["id", "displacedByCustomXml"],
+      commentRangeStart: ["id", "displacedByCustomXml"],
+      commentRangeEnd: ["id", "displacedByCustomXml"],
+      commentReference: ["id"],
+      hyperlink: ["anchor", "history", "docLocation", "tgtFrame", "tooltip"],
+      date: ["fullDate"],
+      dropDownList: ["lastValue"],
+      comboBox: ["lastValue"],
+      listItem: ["value", "displayText"],
+      text: ["multiLine"],
+      richText: [],
+      picture: [],
+      placeholder: [],
+      temporary: [],
+      showingPlcHdr: ["val"],
+      gridCol: ["w"],
+      rFonts: ["ascii", "hAnsi", "eastAsia", "cs", "hint", "asciiTheme", "hAnsiTheme", "eastAsiaTheme", "cstheme"],
+      lang: ["val", "eastAsia", "bidi"],
+      spacing: ["before", "after", "beforeLines", "afterLines", "beforeAutospacing", "afterAutospacing", "line", "lineRule"],
+      ind: ["left", "right", "start", "end", "firstLine", "hanging", "leftChars", "rightChars", "firstLineChars", "hangingChars"],
+      shd: ["val", "color", "fill", "themeColor", "themeFill", "themeTint", "themeShade", "themeFillTint", "themeFillShade"],
+      color: ["val", "themeColor", "themeTint", "themeShade"],
+      u: ["val", "color", "themeColor", "themeTint", "themeShade"],
+      br: ["type", "clear"],
+      tab: []
+    };
+    const sized = new Set("tblW tblInd tcW".split(" "));
+    const borders = new Set("top left bottom right insideH insideV".split(" "));
+    for (const node of all) for (const attr2 of node.attributes.filter((attribute2) => word.includes(attribute2.namespace))) {
+      const admitted = attributeNames[node.localName] ?? (sized.has(node.localName) ? ["w", "type"] : borders.has(node.localName) ? ["val", "sz", "space", "color", "themeColor", "themeTint", "themeShade", "shadow", "frame"] : ["val"]);
+      if (!admitted.includes(attr2.localName)) throw new UnsupportedEditError("The template has an unverified attribute.");
+    }
+    budget.charge("work", all.length * 8);
+    if (containsRevision(item)) throw new UnsupportedEditError("Reviewed templates cannot be cloned.");
+    for (const node of all) {
+      if (word.includes(node.namespace) && !supported.has(node.localName) || !xml.compatibility.canEdit(node) || node.attributes.some((attribute2) => attribute2.namespace !== "http://www.w3.org/2000/xmlns/" && !xml.compatibility.canEdit(attribute2)) || ["fldChar", "fldSimple", "permStart", "permEnd", "footnoteReference", "endnoteReference", "sectPr", "object", "pict"].includes(node.localName) || node.content.some((content) => !["element", "comment", "processing-instruction"].includes(content.kind) && (content.kind !== "text" || content.text.trim() && !["t", "instrText"].includes(node.localName)))) throw new UnsupportedEditError("The template contains unsupported boundaries or opaque data.");
+    }
+    return all;
+  }
+  preflight(xml, item, owner) {
+    const all = this.admit(xml, item), owned = new Set(all), stack = [];
+    for (const node of all.filter((node2) => node2.namespace === item.namespace)) {
+      if (node.localName === "bookmarkStart") {
+        const id = number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER), name = attribute(node, "name");
+        if (!name || all.filter((candidate) => candidate.namespace === item.namespace && candidate.localName === "bookmarkStart" && number(attribute(candidate, "id"), false, Number.MAX_SAFE_INTEGER) === id).length !== 1) throw new UnsupportedEditError("Bookmark declarations must be unique.");
+        if ([...this.#source].some(([part, source]) => nodes(part === owner ? xml.root : source.root, this.#context.budget).some((candidate) => !owned.has(candidate) && word.includes(candidate.namespace) && candidate.localName === "hyperlink" && attribute(candidate, "anchor") === name))) throw new UnsupportedEditError("Bookmark references cannot cross the template boundary.");
+        stack.push(id);
+      } else if (node.localName === "bookmarkEnd" && stack.pop() !== number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER)) throw new UnsupportedEditError("Bookmark ranges cannot cross template boundaries.");
+      if (["commentRangeStart", "commentRangeEnd", "commentReference"].includes(node.localName)) {
+        const id = number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER);
+        const markers2 = all.filter((candidate) => candidate.namespace === item.namespace && ["commentRangeStart", "commentRangeEnd", "commentReference"].includes(candidate.localName) && number(attribute(candidate, "id"), false, Number.MAX_SAFE_INTEGER) === id);
+        if (["commentRangeStart", "commentRangeEnd", "commentReference"].some((name) => markers2.filter((marker) => marker.localName === name).length !== 1) || all.indexOf(markers2.find((marker) => marker.localName === "commentRangeStart")) >= all.indexOf(markers2.find((marker) => marker.localName === "commentRangeEnd")) || [...this.#source].some(([part, source]) => nodes(part === owner ? xml.root : source.root, this.#context.budget).some((candidate) => !owned.has(candidate) && candidate.namespace === item.namespace && ["commentRangeStart", "commentRangeEnd", "commentReference"].includes(candidate.localName) && number(attribute(candidate, "id"), false, Number.MAX_SAFE_INTEGER) === id))) throw new UnsupportedEditError("Comments must have ordered complete owned ranges.");
+      }
+    }
+    if (stack.length) throw new UnsupportedEditError("Bookmarks cross the template boundary.");
+    const markers = all.filter((node) => node.namespace === item.namespace && ["commentRangeStart", "commentRangeEnd", "commentReference"].includes(node.localName));
+    if (markers.length) {
+      if (this.#package.parts.some((part) => commentExtensionParts.some((role) => parseMediaType(part.content_type) === role.contentType.toLowerCase()))) throw new UnsupportedEditError("Modern comments cannot be cloned.");
+      const edges = this.#package.relationships(owner).filter((edge) => relationships.some((namespace) => edge.reltype === `${namespace}/comments`));
+      if (edges.length !== 1 || edges[0].is_external) throw new UnsupportedEditError("A classic comment part is required.");
+      const comments = this.#source.get(edges[0].target_part.partname);
+      for (const id of new Set(markers.map((node) => number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER)))) {
+        const bodies = comments.root.children.filter((node) => node.namespace === item.namespace && node.localName === "comment" && number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER) === id);
+        if (bodies.length !== 1 || nodes(bodies[0], this.#context.budget).some((node) => !comments.compatibility.canEdit(node) || node.attributes.some((attribute2) => attribute2.namespace !== "http://www.w3.org/2000/xmlns/" && !comments.compatibility.canEdit(attribute2)) || !["comment", "p", "pPr", "r", "rPr", "t", "tab", "br", "cr", "b", "i", "rFonts"].includes(node.localName))) throw new UnsupportedEditError("A comment requires one supported stored body.");
+        this.admit(comments, bodies[0]);
+      }
+    }
+    for (const node of all) for (const attr2 of node.attributes.filter((attribute2) => relationships.includes(attribute2.namespace))) {
+      if (!(["embed", "link"].includes(attr2.localName) && node.localName === "blip" || attr2.localName === "id" && node.localName === "hyperlink")) throw new UnsupportedEditError("The template relationship occurrence is unsupported.");
+      const edge = this.#package.relationships(owner).find((edge2) => edge2.rId === attr2.value);
+      if (!edge || !(edge.reltype.endsWith("/image") || edge.reltype.endsWith("/hyperlink")) || edge.is_external && !edge.reltype.endsWith("/hyperlink")) throw new UnsupportedEditError("The template relationship is unsupported.");
+    }
+  }
+  async admitMedia(xml, item, owner) {
+    const all = nodes(item, this.#context.budget), owners = parents(item, this.#context.budget);
+    for (const drawing of all.filter((node) => word.includes(node.namespace) && node.localName === "drawing")) {
+      const one = (node, name, namespaces) => {
+        const found = node.children.filter((child2) => namespaces.includes(child2.namespace) && child2.localName === name);
+        if (found.length !== 1) throw new UnsupportedEditError("The cloned picture grammar is unsupported.");
+        return found[0];
+      };
+      const inline = one(drawing, "inline", drawings), extent = one(inline, "extent", drawings);
+      one(inline, "docPr", drawings);
+      for (const field of ["cx", "cy"]) if (number(attribute(extent, field, "")) < 1) throw new UnsupportedEditError("Picture extents must be positive.");
+      const graphic = one(inline, "graphic", drawingMain), data = one(graphic, "graphicData", drawingMain), picture = one(data, "pic", pictures);
+      if (attribute(data, "uri", "") !== picture.namespace) throw new UnsupportedEditError("The picture dialect is inconsistent.");
+      const properties = one(picture, "nvPicPr", pictures);
+      one(properties, "cNvPr", pictures);
+      one(properties, "cNvPicPr", pictures);
+      const fill = one(picture, "blipFill", pictures), blip = one(fill, "blip", drawingMain), stretch = one(fill, "stretch", drawingMain);
+      one(stretch, "fillRect", drawingMain);
+      const shape2 = one(picture, "spPr", pictures), transform = one(shape2, "xfrm", drawingMain);
+      one(transform, "off", drawingMain);
+      one(transform, "ext", drawingMain);
+      const geometry = one(shape2, "prstGeom", drawingMain);
+      if (attribute(geometry, "prst", "") !== "rect") throw new UnsupportedEditError("Only rectangular pictures are admitted.");
+      one(geometry, "avLst", drawingMain);
+      const embed = blip.attributes.filter((attr2) => relationships.includes(attr2.namespace) && attr2.localName === "embed");
+      if (embed.length !== 1 || blip.attributes.some((attr2) => relationships.includes(attr2.namespace) && attr2.localName === "link")) throw new UnsupportedEditError("Only internal picture embeds are admitted.");
+      const edge = this.#package.relationships(owner).find((edge2) => edge2.rId === embed[0].value);
+      if (!edge || edge.is_external || !edge.reltype.endsWith("/image")) throw new UnsupportedEditError("Only admitted internal raster pictures are cloned.");
+      if (!this.#admittedMedia.has(edge.target_part.partname)) {
+        this.#context.budget.charge("embeddedMediaBytes", edge.target_part.bytes.length);
+        const header = characterizeRasterHeader(edge.target_part.bytes, this.#context);
+        if (parseMediaType(edge.target_part.content_type) !== header.mime) throw new UnsupportedEditError("The cloned raster declaration does not match its bytes.");
+        if (header.mime === "image/png") await admitControlPng(edge.target_part.bytes, this.#context, "retained-image");
+        this.#admittedMedia.add(edge.target_part.partname);
+      }
+      for (const node of nodes(drawing, this.#context.budget)) if (!(word.includes(node.namespace) && node.localName === "drawing" || drawings.includes(node.namespace) && ["inline", "extent", "docPr"].includes(node.localName) || pictures.includes(node.namespace) && ["pic", "nvPicPr", "cNvPr", "cNvPicPr", "blipFill", "spPr"].includes(node.localName) || drawingMain.includes(node.namespace) && ["graphic", "graphicData", "blip", "stretch", "fillRect", "xfrm", "off", "ext", "prstGeom", "avLst"].includes(node.localName))) throw new UnsupportedEditError("The picture contains unverified drawing markup.");
+      const profile = {
+        drawing: { children: ["inline"], attributes: [] },
+        inline: { children: ["extent", "docPr", "graphic"], attributes: ["distT", "distB", "distL", "distR"] },
+        extent: { children: [], attributes: ["cx", "cy"] },
+        docPr: { children: [], attributes: ["id", "name", "descr", "hidden"] },
+        graphic: { children: ["graphicData"], attributes: [] },
+        graphicData: { children: ["pic"], attributes: ["uri"] },
+        pic: { children: ["nvPicPr", "blipFill", "spPr"], attributes: [] },
+        nvPicPr: { children: ["cNvPr", "cNvPicPr"], attributes: [] },
+        cNvPr: { children: [], attributes: ["id", "name", "descr", "hidden"] },
+        cNvPicPr: { children: [], attributes: [] },
+        blipFill: { children: ["blip", "stretch"], attributes: [] },
+        blip: { children: [], attributes: [] },
+        stretch: { children: ["fillRect"], attributes: [] },
+        fillRect: { children: [], attributes: [] },
+        spPr: { children: ["xfrm", "prstGeom"], attributes: [] },
+        xfrm: { children: ["off", "ext"], attributes: [] },
+        off: { children: [], attributes: ["x", "y"] },
+        ext: { children: [], attributes: ["cx", "cy"] },
+        prstGeom: { children: ["avLst"], attributes: ["prst"] },
+        avLst: { children: [], attributes: [] }
+      };
+      for (const node of nodes(drawing, this.#context.budget)) {
+        const declaration = profile[node.localName];
+        if (!declaration || node.children.some((child2) => !declaration.children.includes(child2.localName)) || node.children.length !== declaration.children.length || new Set(node.children.map((child2) => child2.localName)).size !== node.children.length || node.attributes.some((attr2) => attr2.namespace !== "http://www.w3.org/2000/xmlns/" && !(attr2.namespace === "" && declaration.attributes.includes(attr2.localName) || node === blip && relationships.includes(attr2.namespace) && attr2.localName === "embed"))) throw new UnsupportedEditError("The picture has unverified structural or attribute semantics.");
+      }
+      if (owners.get(drawing)?.localName !== "r") throw new UnsupportedEditError("Pictures require an ordinary run owner.");
+    }
+  }
+  clone(xml, item, owner) {
+    const budget = this.#context.budget;
+    const owners = parents(item, this.#context.budget);
+    this.preflight(xml, item, owner);
+    const all = this.admit(xml, item);
+    const owned = new Set(all);
+    const attributeChanges = /* @__PURE__ */ new Map();
+    budget.charge("insertedNodes", all.length);
+    budget.charge("retainedBytes", all.length * 256);
+    const change = (node, field, value, namespace = node.namespace) => {
+      const attr2 = node.attributes.find((attribute2) => attribute2.namespace === namespace && attribute2.localName === field);
+      if (!attr2) throw new UnsupportedEditError("The template identity attribute is missing.");
+      const changes = attributeChanges.get(node) ?? /* @__PURE__ */ new Map();
+      changes.set(attr2.name, value);
+      attributeChanges.set(node, changes);
+    };
+    const starts = all.filter((node) => node.localName === "bookmarkStart" && node.namespace === item.namespace);
+    const ends = all.filter((node) => node.localName === "bookmarkEnd" && node.namespace === item.namespace);
+    for (const start of starts) {
+      const id = number(attribute(start, "id"), false, Number.MAX_SAFE_INTEGER), name = attribute(start, "name");
+      const paired = ends.filter((end) => number(attribute(end, "id"), false, Number.MAX_SAFE_INTEGER) === id);
+      if (!name || starts.filter((node) => number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER) === id).length !== 1 || paired.length !== 1 || all.indexOf(paired[0]) < all.indexOf(start)) throw new UnsupportedEditError("Bookmarks must have complete owned pairs.");
+      if ([...this.#source].some(([part, source]) => nodes(part === owner ? xml.root : source.root, this.#context.budget).some((node) => !owned.has(node) && word.includes(node.namespace) && node.localName === "hyperlink" && attribute(node, "anchor") === name))) throw new UnsupportedEditError("Bookmark references cannot cross the template boundary.");
+      const fresh = this.#allocate("bookmark");
+      let suffix = 1, newName;
+      do {
+        newName = name.slice(0, 30) + "_" + suffix++;
+      } while (this.#names.has(newName));
+      this.#names.add(newName);
+      change(start, "id", fresh);
+      change(paired[0], "id", fresh);
+      change(start, "name", newName);
+      for (const link of all.filter((node) => node.namespace === item.namespace && node.localName === "hyperlink" && attribute(node, "anchor") === name)) change(link, "anchor", newName);
+    }
+    if (ends.length !== starts.length || ends.some((end) => !starts.some((start) => number(attribute(start, "id"), false, Number.MAX_SAFE_INTEGER) === number(attribute(end, "id"), false, Number.MAX_SAFE_INTEGER)))) throw new UnsupportedEditError("Bookmarks cross the template boundary.");
+    const commentMarkers = all.filter((node) => node.namespace === item.namespace && ["commentRangeStart", "commentRangeEnd", "commentReference"].includes(node.localName));
+    if (commentMarkers.length) {
+      if (this.#package.parts.some((part2) => commentExtensionParts.some((role) => parseMediaType(part2.content_type) === role.contentType.toLowerCase()))) throw new UnsupportedEditError("Modern comments cannot be cloned.");
+      const edges = this.#package.relationships(owner).filter((edge) => relationships.some((namespace) => edge.reltype === `${namespace}/comments`));
+      if (edges.length !== 1 || edges[0].is_external) throw new UnsupportedEditError("A classic comment part is required.");
+      const part = edges[0].target_part.partname, comments = this.#source.get(part);
+      for (const id of new Set(commentMarkers.map((node) => number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER)))) {
+        const markers = commentMarkers.filter((node) => number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER) === id);
+        if (["commentRangeStart", "commentRangeEnd", "commentReference"].some((name) => markers.filter((node) => node.localName === name).length !== 1) || [...this.#source].some(([name, source]) => nodes(name === owner ? xml.root : source.root, this.#context.budget).some((node) => !owned.has(node) && node.namespace === item.namespace && ["commentRangeStart", "commentRangeEnd", "commentReference"].includes(node.localName) && number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER) === id))) throw new UnsupportedEditError("Comments must be entirely owned by one item.");
+        const body = comments.root.children.filter((node) => node.namespace === item.namespace && node.localName === "comment" && number(attribute(node, "id"), false, Number.MAX_SAFE_INTEGER) === id);
+        if (body.length !== 1) throw new UnsupportedEditError("A comment requires one stored body.");
+        if (nodes(body[0], this.#context.budget).some((node) => !comments.compatibility.canEdit(node) || node.attributes.some((attribute2) => attribute2.namespace !== "http://www.w3.org/2000/xmlns/" && !comments.compatibility.canEdit(attribute2)) || !["comment", "p", "pPr", "r", "rPr", "t", "tab", "br", "cr", "b", "i", "rFonts"].includes(node.localName))) throw new UnsupportedEditError("The comment body has unsupported cloning semantics.");
+        const fresh = this.#allocate("comment");
+        const attr2 = body[0].attributes.find((attribute2) => attribute2.namespace === item.namespace && attribute2.localName === "id");
+        this.#comments.push({ part, xml: opening(body[0], /* @__PURE__ */ new Map([[attr2.name, fresh]])) + comments.sourceXml(body[0], /* @__PURE__ */ new Map(), true) + `</${body[0].name}>` });
+        for (const marker of markers) change(marker, "id", fresh);
+      }
+    }
+    for (const node of all) {
+      if (node.namespace === item.namespace && node.localName === "id" && owners.get(node)?.localName === "sdtPr" && owners.get(node)?.namespace === node.namespace && attribute(node, "val") !== void 0) change(node, "val", this.#allocate("control"));
+      if (drawings.includes(node.namespace) && node.localName === "docPr" || pictures.includes(node.namespace) && node.localName === "cNvPr") change(node, "id", this.#allocate("drawing"), "");
+      for (const attr2 of node.attributes.filter((attribute2) => relationships.includes(attribute2.namespace))) {
+        if (!(["embed", "link"].includes(attr2.localName) && node.localName === "blip" || attr2.localName === "id" && node.localName === "hyperlink")) throw new UnsupportedEditError("The template relationship occurrence is unsupported.");
+        const edge = this.#package.relationships(owner).find((edge2) => edge2.rId === attr2.value);
+        if (!edge || !(edge.reltype.endsWith("/image") || edge.reltype.endsWith("/hyperlink")) || edge.is_external && !edge.reltype.endsWith("/hyperlink")) throw new UnsupportedEditError("The template relationship is unsupported.");
+        const additions = this.#relationships.get(owner) ?? [];
+        const taken = /* @__PURE__ */ new Set([...this.#package.relationships(owner).map((edge2) => edge2.rId), ...additions.map((item2) => item2.id)]);
+        let ordinal = 1;
+        while (taken.has(`rId${ordinal}`)) ordinal++;
+        const id = `rId${ordinal}`;
+        additions.push({ id, edge });
+        this.#relationships.set(owner, additions);
+        change(node, attr2.localName, id, attr2.namespace);
+      }
+    }
+    budget.charge("retainedBytes", 96 + all.length * 64);
+    const containers = /* @__PURE__ */ new Map([[item, []]]), nearest = /* @__PURE__ */ new Map([[item, item]]);
+    for (const node of all) {
+      budget.charge("work", 1);
+      if (node === item) continue;
+      const owner2 = nearest.get(owners.get(node));
+      if (attributeChanges.has(node)) {
+        containers.get(owner2).push(node);
+        containers.set(node, []);
+        nearest.set(node, node);
+      } else nearest.set(node, owner2);
+    }
+    budget.charge("retainedBytes", containers.size * 64);
+    const rendered = /* @__PURE__ */ new Map();
+    for (const [node, children] of [...containers].reverse()) {
+      const nested = new Map(children.map((child2) => [child2, rendered.get(child2)]));
+      const value = opening(node, attributeChanges.get(node)) + xml.sourceXml(node, nested, true) + `</${node.name}>`;
+      budget.charge("retainedBytes", value.length * 2);
+      rendered.set(node, value);
+    }
+    const result = rendered.get(item);
+    budget.charge("retainedBytes", result.length * 8);
+    budget.charge("work", result.length);
+    return { xml: result };
+  }
+  finish(editor) {
+    for (const [owner, additions] of this.#relationships) {
+      const slash = owner.lastIndexOf("/"), name = owner.slice(1, slash + 1) + "_rels/" + owner.slice(slash + 1) + ".rels";
+      const xml = editor.xml(name);
+      const prefix = xml.root.name.includes(":") ? xml.root.name.slice(0, xml.root.name.indexOf(":") + 1) : "";
+      xml.insertChildren(xml.root, additions.map((item) => `<${prefix}Relationship Id="${item.id}" Type="${xmlValue(item.edge.reltype)}" Target="${xmlValue(item.edge.target_ref)}"${item.edge.is_external ? ' TargetMode="External"' : ""}/>`).join(""));
+    }
+    const comments = /* @__PURE__ */ new Map();
+    for (const item of this.#comments) {
+      const items = comments.get(item.part) ?? [];
+      items.push(item.xml);
+      comments.set(item.part, items);
+    }
+    for (const [part, items] of comments) {
+      const xml = editor.xml(part.slice(1));
+      xml.insertChildren(xml.root, items.join(""));
+    }
+    return editor.snapshot();
+  }
+};
+
+// packages/safe-bash-docx-engine/src/control-repeat.ts
+var templateRepeatAdmission = /* @__PURE__ */ Symbol("template-repeat-admission");
+var w15 = "http://schemas.microsoft.com/office/word/2012/wordml";
+function elements(root, budget) {
+  budget.charge("retainedBytes", 8);
+  const pending = [root], result = [];
+  while (pending.length) {
+    const node = pending.pop();
+    budget.charge("work", node.children.length + 1);
+    budget.charge("retainedBytes", 8 + node.children.length * 8);
+    result.push(node);
+    for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+  }
+  return result;
+}
+function child(node, name, namespace = node.namespace) {
+  const result = node.children.filter((child2) => child2.namespace === namespace && child2.localName === name);
+  if (result.length > 1) throw new UnsupportedEditError("Repeated template declarations are unsupported.");
+  return result[0];
+}
+function attr(node, name) {
+  return node?.attributes.find((attribute2) => attribute2.namespace === node.namespace && attribute2.localName === name)?.value;
+}
+function open(node) {
+  return `<${node.name}${node.attributes.map((attribute2) => ` ${attribute2.name}="${xmlValue(attribute2.value)}"`).join("")}>`;
+}
+function fields(item, budget) {
+  budget.charge("retainedBytes", 8);
+  const pending = [item], result = [];
+  while (pending.length) {
+    const node = pending.pop();
+    budget.charge("work", node.children.length + 1);
+    if (node !== item && node.namespace === item.namespace && node.localName === "sdt") {
+      const properties = child(node, "sdtPr");
+      if (properties && child(properties, "repeatingSection", w15)) continue;
+      if (properties && attr(child(properties, "tag"), "val") !== void 0) {
+        budget.charge("retainedBytes", 8);
+        result.push(node);
+      }
+    }
+    budget.charge("retainedBytes", node.children.length * 8);
+    for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+  }
+  return result;
+}
+function shape(item, budget) {
+  const tagged = new Set(fields(item, budget));
+  const pending = [{ node: item, item, tagged }], chunks = [];
+  budget.charge("retainedBytes", 32);
+  while (pending.length) {
+    const task = pending.pop();
+    if (typeof task === "string") {
+      chunks.push(task);
+      continue;
+    }
+    const { node, item: item2, tagged: tagged2 } = task;
+    budget.charge("work", node.attributes.length + node.children.length + 1);
+    budget.charge("retainedBytes", 64 + node.children.length * 40);
+    if (node.namespace === item2.namespace && ["id", "showingPlcHdr"].includes(node.localName)) {
+      chunks.push("null");
+      continue;
+    }
+    const names = node.attributes.filter((attribute2) => attribute2.namespace !== "http://www.w3.org/2000/xmlns/" && !(["id", "embed"].includes(attribute2.localName) && ["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "commentReference", "docPr", "blip"].includes(node.localName) || node.localName === "bookmarkStart" && attribute2.localName === "name" || node.localName === "hyperlink" && ["anchor", "id"].includes(attribute2.localName) || ["date", "dropDownList", "comboBox"].includes(node.localName) && ["fullDate", "lastValue"].includes(attribute2.localName) || node.namespace !== item2.namespace && node.localName === "checked" && attribute2.localName === "val")).map((attribute2) => [attribute2.namespace, attribute2.localName, attribute2.value]);
+    const head = JSON.stringify([node.namespace, node.localName, names]);
+    chunks.push(head.slice(0, -1) + ",");
+    if (node.localName === "sdt" && node.namespace === item2.namespace && child(node, "sdtPr") && child(child(node, "sdtPr"), "repeatingSection", w15)) {
+      const first = child(node, "sdtContent").children[0];
+      pending.push("]", first ? { node: first, item: first, tagged: new Set(fields(first, budget)) } : "null", ",", { node: child(node, "sdtPr"), item: item2, tagged: tagged2 });
+    } else if (tagged2.has(node)) {
+      const content = child(node, "sdtContent"), run = elements(content, budget).find((node2) => node2.namespace === item2.namespace && node2.localName === "r"), properties = run && child(run, "rPr");
+      pending.push("]", properties ? { node: properties, item: item2, tagged: tagged2 } : "null", "," + JSON.stringify(content.children[0]?.localName === "p" ? "paragraph" : "inline") + ",", { node: child(node, "sdtPr"), item: item2, tagged: tagged2 });
+    } else {
+      chunks.push("[");
+      pending.push("]," + JSON.stringify(node.children.length ? "" : node.text) + "]");
+      const children = node.children.filter((node2) => node2.namespace !== item2.namespace || !["id", "showingPlcHdr"].includes(node2.localName));
+      for (let index = children.length - 1; index >= 0; index--) {
+        pending.push({ node: children[index], item: item2, tagged: tagged2 });
+        if (index > 0) pending.push(",");
+      }
+    }
+  }
+  const length = chunks.reduce((total, chunk) => total + chunk.length, 0);
+  budget.charge("retainedBytes", length * 4);
+  return chunks.join("");
+}
+function scalar(item, value) {
+  if (["plain-text", "rich-text"].includes(item.kind) && typeof value === "string") return { text: value };
+  if (item.kind === "checkbox" && typeof value === "boolean") return { checked: value };
+  if (["dropdown", "combo-box"].includes(item.kind) && typeof value === "string") return { choice: value };
+  if (item.kind === "date" && typeof value === "string") return { date: value };
+  throw new DocxUsageError("The record value has a conflicting declared scalar type.");
+}
+async function editDocumentControlRepeats(input, options, context) {
+  const settings = archiveSettings(context);
+  const { input: identity, ...args } = options;
+  const invocation = validateDocxInvocation({ operation: "controls.repeat", 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 { data, output, inPlace, force, dryRun, json, all, allowEmpty, ...selection } = opts;
+  delete selection.limit;
+  if (!Array.isArray(data)) throw new DocxUsageError("Repeating controls require a typed record array.");
+  budget.check("matches", Math.max(1, data.length));
+  const { document, archive, editor, items: inventory } = await openControlInventory(input, selection, { ...settings, budget });
+  const regions = inventory.filter((item) => item.kind === "repeating-section" && (!context[templateRepeatAdmission] || !selection.select || item.location.token === selection.select));
+  if (regions.length !== 1) throw new SelectionError(regions.length ? "ambiguous-selection" : "missing-selection", regions.map((item) => item.location.token));
+  if (regions[0].support !== "supported" || regions[0].lock !== "unlocked" || regions[0].binding !== null) throw new UnsupportedEditError("The repeating region requires an admitted, unlocked and unbound owner.");
+  const location = regions[0].location;
+  document.select([location], { ...all === void 0 ? {} : { all }, ...allowEmpty === void 0 ? {} : { allowEmpty } }, "mutation");
+  if (document.references(location.token).length > 1) throw new UnsupportedEditError("Shared repeat owners are ambiguous.");
+  const xml = editor.xml(location.value.part.slice(1));
+  let region = xml.root;
+  const ancestors = [region];
+  for (const index of location.value.path) {
+    region = region.children[index];
+    ancestors.push(region);
+  }
+  const parent = ancestors.at(-2), content = activeXmlChildren(xml, budget)(region).find((node) => node.namespace === region.namespace && node.localName === "sdtContent");
+  if (!content || containsRevision(region)) throw new UnsupportedEditError("The repeating region is bound, locked or reviewed.");
+  const row = parent.namespace === region.namespace && parent.localName === "tbl";
+  if (!row && !(parent.namespace === region.namespace && (["body", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent", "tc"].includes(parent.localName) || context[templateRepeatAdmission] && parent.localName === "sdtContent"))) throw new UnsupportedEditError("A repeating region requires a direct admitted row or block owner.");
+  if (ancestors.slice(0, -1).some((owner) => owner.namespace === region.namespace && (!context[templateRepeatAdmission] && owner.localName === "sdt" || ["ins", "del", "moveFrom", "moveTo", "fldSimple", "hyperlink", "customXml"].includes(owner.localName)))) throw new UnsupportedEditError("Repeating boundaries cannot cross controlled owners.");
+  if (context[templateRepeatAdmission]) for (const ancestor of ancestors.slice(0, -1).filter((node) => node.namespace === region.namespace && node.localName === "sdt")) {
+    const snapshot = inspectControlSnapshot(ancestor, location, archive, { ...settings, budget }, xml);
+    if (snapshot.support !== "supported" || !["repeating-section", "repeating-item"].includes(snapshot.kind) || snapshot.binding !== null || snapshot.lock !== "unlocked") throw new UnsupportedEditError("Nested templates require admitted unlocked native repeat ancestors.");
+  }
+  const story = document.list("story", { scope: "all-stories" }).filter((owner) => owner.value.story === location.value.story && pathContains(owner.value.path, location.value.path)).sort((a, b) => b.value.path.length - a.value.path.length)[0];
+  if (!story) throw new UnsupportedEditError("A repeat requires an admitted story.");
+  assertOutsideFields(parseFields(ancestors[story.value.path.length], story.value.path, budget, xml.compatibility.content), location.value.path);
+  assertOutsideRevisionRanges(xml.root, region, budget, xml.compatibility.branches);
+  if (!content.children.length || content.content.some((node) => node.kind !== "element" && (node.kind !== "text" || node.text.trim()))) throw new UnsupportedEditError("A region requires reusable native items.");
+  const items = content.children;
+  assertDocumentEditable(archive, { ...settings, budget }, archive);
+  const planner = new ControlClonePlanner(archive, { ...settings, budget });
+  let prototypeShape;
+  for (const item of items) {
+    const properties = child(item, "sdtPr"), body = child(item, "sdtContent");
+    if (item.namespace !== region.namespace || item.localName !== "sdt" || !properties || !body || !child(properties, "repeatingSectionItem", w15) || child(properties, "dataBinding") || attr(child(properties, "lock"), "val") && attr(child(properties, "lock"), "val") !== "unlocked") throw new UnsupportedEditError("Every item requires an unlocked, unbound native declaration.");
+    if (row ? body.children.length !== 1 || body.children[0].namespace !== region.namespace || body.children[0].localName !== "tr" : !body.children.length || body.children.some((node) => node.namespace !== region.namespace || !(["p", "tbl"].includes(node.localName) || context[templateRepeatAdmission] && node.localName === "sdt" && child(node, "sdtPr") && child(child(node, "sdtPr"), "repeatingSection", w15)))) throw new UnsupportedEditError("The native item has an unsupported row/block shape.");
+    planner.preflight(xml, item, location.value.part);
+    if (elements(body, budget).some((node) => ["vMerge", "hMerge", "gridSpan", "sectPr"].includes(node.localName) || !context[templateRepeatAdmission] && node.namespace === w15 && ["repeatingSection", "repeatingSectionItem"].includes(node.localName))) throw new UnsupportedEditError("Merged, section-changing or nested repeated templates are unsupported.");
+    if (row) {
+      const cells = body.children[0].children.filter((node) => node.namespace === region.namespace && node.localName === "tc");
+      const grid = child(parent, "tblGrid")?.children.filter((node) => node.namespace === region.namespace && node.localName === "gridCol") ?? [];
+      if (!grid.length || cells.length !== grid.length || cells.some((cell) => !child(cell, "p") && !cell.children.some((node) => node.namespace === region.namespace && node.localName === "p"))) throw new UnsupportedEditError("A repeated row requires a complete unmerged grid.");
+      budget.table(Math.max(1, data.length), cells.length);
+    }
+    for (const node of elements(item, budget).filter((node2) => node2.namespace === region.namespace && node2.localName === "sdt")) {
+      const properties2 = child(node, "sdtPr");
+      if (!properties2 || child(properties2, "dataBinding") || attr(child(properties2, "lock"), "val") && attr(child(properties2, "lock"), "val") !== "unlocked") throw new UnsupportedEditError("All repeated controls must be unlocked and unbound.");
+    }
+    const beforeShape = budget.usage;
+    const itemShape = shape(item, budget);
+    if (!prototypeShape) {
+      budget.charge("retainedBytes", 128);
+      const afterShape = budget.usage;
+      prototypeShape = {
+        value: itemShape,
+        work: afterShape.work - beforeShape.work,
+        retainedBytes: afterShape.retainedBytes - beforeShape.retainedBytes
+      };
+    }
+    budget.charge("work", prototypeShape.work);
+    budget.charge("retainedBytes", prototypeShape.retainedBytes);
+    if (itemShape !== prototypeShape.value) throw new UnsupportedEditError("Prior items have conflicting declaration schemas or layouts.");
+  }
+  const prototype = items[0], keys = new Set(fields(prototype, budget).map((node) => attr(child(child(node, "sdtPr"), "tag"), "val")));
+  for (const record of data) {
+    const bindings = record.values.map((value2) => value2.binding);
+    if (bindings.length !== keys.size || new Set(bindings).size !== bindings.length || bindings.some((key) => !keys.has(key))) throw new DocxUsageError("Every record must exactly match the declared scalar keys.");
+  }
+  if (!row) for (const table of elements(prototype, budget).filter((node) => node.namespace === region.namespace && node.localName === "tbl")) {
+    const rows = tableRows(table, (node) => node, (node) => node.children, budget);
+    const columns = child(table, "tblGrid")?.children.filter((node) => node.namespace === region.namespace && node.localName === "gridCol").length ?? 0;
+    budget.table(rows.length * Math.max(1, data.length), columns);
+  }
+  const rendered = [];
+  for (const item of items) {
+    await planner.admitMedia(xml, item, location.value.part);
+    for (const node of fields(item, budget)) {
+      const snapshot = inspectControlSnapshot(node, location, archive, { ...settings, budget }, xml);
+      for (const record of data.length ? data : [null]) {
+        const value2 = record?.values.find((entry) => entry.binding === snapshot.tag)?.value;
+        if (record) prepareControlValue(xml, node, snapshot, scalar(snapshot, value2), { ...settings, budget });
+        else prepareControlPlaceholder(xml, node, snapshot, { ...settings, budget });
+      }
+    }
+  }
+  for (const record of data.length ? data : [null]) {
+    budget.check("work", 0);
+    const clone = planner.clone(xml, prototype, location.value.part);
+    const fragmentBytes = new TextEncoder().encode(`<root>${clone.xml}</root>`);
+    (budget[documentXmlCache].staged ??= /* @__PURE__ */ new WeakSet()).add(fragmentBytes);
+    const fragment = new DocumentXmlEditor(fragmentBytes, {}, void 0, budget);
+    const item = fragment.root.children[0];
+    const stages = [];
+    for (const node of fields(item, budget)) {
+      const snapshot = inspectControlSnapshot(node, location, archive, { ...settings, budget }, fragment);
+      if (!keys.has(snapshot.tag)) throw new UnsupportedEditError("A clone introduced an undeclared key.");
+      const value2 = record?.values.find((entry) => entry.binding === snapshot.tag)?.value;
+      stages.push(record ? prepareControlValue(fragment, node, snapshot, scalar(snapshot, value2), { ...settings, budget }) : prepareControlPlaceholder(fragment, node, snapshot, { ...settings, budget }));
+    }
+    for (const stage of stages) stage();
+    const bytes = fragment.serialize();
+    const owned = new DocumentXmlEditor(bytes, {}, void 0, budget);
+    rendered.push(owned.sourceXml(owned.root.children[0]));
+  }
+  const replacement = open(content) + rendered.join("") + `</${content.name}>`;
+  const value = { ...location.value, generation: 1 };
+  const after = { ...location, value, token: encodeGeneratedLocation(value) };
+  const changes = [{ kind: "replace", before: location, after }];
+  const prospective = { changed: true, 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: "controls.repeat", ok: true, data: prospective, affected: 1, locations: [after], warnings: [], errors: [] }) + "\n").length);
+  xml.replaceElement(content, replacement);
+  const staged = planner.finish(editor);
+  const published = await publishDocumentArchive(staged, { ...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 }, archive);
+  return { ...prospective, output: published.published.length ? { path: published.published[0].path, bytes: published.published[0].bytes, sha256: published.archiveSha256 } : null };
+}
+
+export {
+  ControlClonePlanner,
+  templateRepeatAdmission,
+  editDocumentControlRepeats
+};