@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,174 @@
+import {
+  openDocumentLocations
+} from "./chunk-LHDB4QO5.js";
+import {
+  measurePackageResourceSerialization
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  embeddedFontContentTypes,
+  fontResourceRole
+} from "./chunk-WOZCIRJ5.js";
+import {
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  revisionInfo
+} from "./chunk-YPVBU7QF.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compareInventoryNames
+} from "./chunk-2EUH5B6A.js";
+import {
+  SelectionError,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError,
+  archiveSettings,
+  documentSession
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/font-inventory.ts
+async function inspectDocumentFonts(input, options, context) {
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: "fonts.list", inputs: ["document"], options }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((limit) => [limit.name, limit.value])));
+  const bounded = { ...settings, budget };
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected archive bytes.");
+  budget.check("compressedInput", input.length);
+  budget.charge("retainedBytes", input.length);
+  budget.charge("work", input.length);
+  const owned = new Uint8Array(input);
+  const archive = await readDocumentArchive(owned, bounded), graph = archive.package;
+  const namespaces = Object.values(documentDialects).map((dialect) => dialect.r);
+  const fontRelationship = (type) => namespaces.some((namespace) => type === namespace + "/font" || type === namespace + "/fontTable");
+  const parts = new Map(graph.parts.filter((part) => parseMediaType(part.content_type) !== "application/vnd.openxmlformats-package.relationships+xml").map((part) => [part.partname, part]));
+  const incomingReferences = /* @__PURE__ */ new Map();
+  const outgoingReferences = /* @__PURE__ */ new Map();
+  const targets = /* @__PURE__ */ new Map();
+  for (const owner of ["/", ...parts.keys()]) for (const edge of graph.relationships(owner)) {
+    budget.charge("work", 1);
+    budget.charge("retainedBytes", 192 + (owner.length + edge.rId.length + edge.reltype.length + edge.target_ref.length) * 2);
+    const reference = { owner, id: edge.rId, type: edge.reltype, target: edge.target_ref, external: edge.is_external };
+    const outgoing = outgoingReferences.get(owner) ?? [];
+    outgoing.push(reference);
+    outgoingReferences.set(owner, outgoing);
+    if (!edge.is_external) {
+      const incoming = incomingReferences.get(edge.target_part.partname) ?? [];
+      incoming.push(reference);
+      incomingReferences.set(edge.target_part.partname, incoming);
+    }
+    if (fontRelationship(edge.reltype) && !edge.is_external) {
+      const names = targets.get(owner) ?? [];
+      names.push(edge.target_part.partname);
+      targets.set(owner, names);
+    }
+  }
+  const candidates = new Set([...parts.values()].filter((part) => {
+    const type = parseMediaType(part.content_type);
+    return type === "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml" || embeddedFontContentTypes.includes(type);
+  }).map((part) => part.partname));
+  for (const names of targets.values()) for (const name of names) candidates.add(name);
+  const closure = (initial) => {
+    const pending = [...initial], result = /* @__PURE__ */ new Set();
+    budget.charge("retainedBytes", pending.length * 8);
+    while (pending.length) {
+      budget.charge("work", 1);
+      const name = pending.pop();
+      if (result.has(name)) continue;
+      result.add(name);
+      budget.charge("retainedBytes", 32);
+      for (const target of targets.get(name) ?? []) {
+        budget.charge("retainedBytes", 8);
+        pending.push(target);
+      }
+    }
+    return result;
+  };
+  const selectorNames = Object.keys(opts).filter((name) => !["json", "limit"].includes(name));
+  let admitted = candidates;
+  if (selectorNames.length) {
+    const document = await openDocumentLocations(owned, bounded, "inventory");
+    let selected;
+    if (opts.select !== void 0) selected = document.resolve(opts.select);
+    else {
+      const section = opts.section === void 0 ? void 0 : document.at("section", opts.section);
+      for (const name of ["comment", "note"]) if (opts[name] !== void 0) {
+        const stories = document.list("story", { scope: "all-stories" }).filter((story) => story.positions[name] === opts[name]);
+        if (!stories.length) throw new SelectionError("missing-selection");
+        if (stories.length !== 1) throw new SelectionError("ambiguous-selection", stories.map((story) => story.token));
+        selected = stories[0];
+      }
+      for (const name of ["table", "cell", "paragraph", "run", "image", "link", "control", "revision", "shape", "field", "bookmark"]) if (opts[name] !== void 0) {
+        if (name === "cell") selected = document.cell(selected.token, opts.cell);
+        else if (name === "revision") {
+          const root = parseDocumentXml(graph.getPart(selected?.value.part ?? "/" + archive.mainPart).bytes, {}, budget).root;
+          const revisions = document.list("annotation", selected ? { owner: selected.token } : opts.section === void 0 ? {} : { section: opts.section }).filter((location) => {
+            budget.charge("work", location.value.path.length + 1);
+            let node = root;
+            for (const index of location.value.path) node = node.children[index];
+            return revisionInfo(node) !== void 0;
+          });
+          selected = revisions[opts.revision - 1];
+          if (!selected) throw new SelectionError("missing-selection");
+        } else selected = document.at(name, opts[name], selected ? { owner: selected.token } : opts.section === void 0 ? {} : { section: opts.section });
+      }
+      selected ??= section;
+    }
+    if (!selected) throw new SelectionError("missing-selection");
+    admitted = closure(candidates.has(selected.value.part) ? [selected.value.part] : targets.get(graph.getPart("/" + archive.mainPart).partname) ?? []);
+  }
+  budget.charge("work", owned.length);
+  budget.charge("retainedBytes", owned.length + 96);
+  const sourceSha256 = [...new Uint8Array(await crypto.subtle.digest("SHA-256", owned))].map((value) => value.toString(16).padStart(2, "0")).join("");
+  const metadata = /* @__PURE__ */ new Map();
+  const items = [];
+  for (const name of [...candidates].filter((name2) => admitted.has(name2)).sort(compareInventoryNames)) {
+    budget.charge("matches", 1);
+    budget.charge("retainedBytes", 256);
+    const inventory = [];
+    for (const target of [...closure([name])].sort(compareInventoryNames)) {
+      let record = metadata.get(target);
+      if (!record) {
+        const part2 = parts.get(target);
+        budget.charge("work", part2.bytes.length);
+        budget.charge("retainedBytes", part2.bytes.length + 192);
+        const hash = [...new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(part2.bytes)))].map((value2) => value2.toString(16).padStart(2, "0")).join("");
+        record = { name: target, contentType: part2.content_type, bytes: part2.bytes.length, sha256: hash };
+        metadata.set(target, record);
+      }
+      inventory.push(record);
+    }
+    const part = parts.get(name);
+    const native = parseMediaType(part.content_type) === "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml" && fontResourceRole(part.content_type, parseDocumentXml(part.bytes, {}, budget).root) === "fontTable";
+    const references = /* @__PURE__ */ new Map();
+    for (const reference of incomingReferences.get(name) ?? []) references.set(reference.owner + "#" + reference.id, reference);
+    for (const part2 of inventory) for (const reference of outgoingReferences.get(part2.name) ?? []) references.set(reference.owner + "#" + reference.id, reference);
+    budget.charge("work", references.size);
+    budget.charge("retainedBytes", references.size * 64);
+    const sortedReferences = [...new Set([...references.values()].map((reference) => reference.owner))].sort(compareInventoryNames).flatMap((owner) => (outgoingReferences.get(owner) ?? []).filter((reference) => references.has(owner + "#" + reference.id)));
+    const value = { version: 1, sourceSha256, generation: settings[documentSession]?.generation ?? 0, part: name, story: name, path: [], range: null };
+    const token = encodeGeneratedLocation(value);
+    budget.charge("retainedBytes", token.length * 4);
+    budget.charge("work", token.length);
+    const location = { kind: "part", token, value, positions: {} };
+    items.push({ kind: "fonts", name, location, properties: [], references: sortedReferences, support: native ? "read" : "preserve", details: { kind: "fonts", parts: inventory } });
+  }
+  const data = { items };
+  measurePackageResourceSerialization({ version: 1, operation: "fonts.list", ok: true, data, warnings: [], errors: [], affected: 0, locations: items.map((item) => item.location) }, budget);
+  return data;
+}
+
+export {
+  inspectDocumentFonts
+};

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

@@ -0,0 +1,153 @@
+import {
+  admitImage
+} from "./chunk-45BW6MGM.js";
+import {
+  ShapeIdAllocator
+} from "./chunk-RZC7QHL6.js";
+import {
+  child,
+  escape,
+  loadShared,
+  nextRel,
+  relPart,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/image-insertion.ts
+function invalid(message) {
+  throw new OfficeError("invalid-value", message, "usage");
+}
+async function addImage(input, options, context) {
+  context.signal?.throwIfAborted();
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some(
+    (key) => typeof key !== "string" || ![
+      "slide",
+      "bytes",
+      "contentType",
+      "left",
+      "top",
+      "width",
+      "height",
+      "fit",
+      "altText"
+    ].includes(key) || !("value" in Object.getOwnPropertyDescriptor(options, key))
+  ))
+    invalid("Invalid image options.");
+  if (!Number.isSafeInteger(options.slide) || options.slide < 1)
+    invalid("Select a positive slide position.");
+  for (const key of ["left", "top", "width", "height"]) {
+    const value = options[key];
+    if (value !== void 0 && (!Number.isSafeInteger(value) || Math.abs(value) > 27273042316900 || (key === "width" || key === "height") && value <= 0))
+      invalid("Image geometry requires bounded integer EMUs.");
+  }
+  if (options.altText !== void 0 && typeof options.altText !== "string")
+    invalid("Image alt text requires text.");
+  if (options.fit !== void 0 && !["contain", "cover", "stretch"].includes(options.fit))
+    invalid("Unknown image fit.");
+  if (options.fit !== void 0 && (options.width === void 0 || options.height === void 0))
+    invalid("Image fit requires both dimensions.");
+  const metadata = admitImage(options.bytes, options.contentType);
+  if (options.bytes.byteLength > Math.min(context.limits.maxBytes, context.archiveLimits.maxEntryBytes))
+    throw new OfficeError("resource-limit", "Image exceeds the admitted byte budget.", "admit");
+  const bytes = new Uint8Array(options.bytes);
+  options = { ...options, bytes };
+  let width = options.width, height = options.height;
+  let left = options.left ?? 0, top = options.top ?? 0;
+  let cropX = 0, cropY = 0;
+  if (metadata.pixelWidth === null || metadata.pixelHeight === null) {
+    if (width === void 0 || height === void 0 || (options.fit ?? "stretch") !== "stretch")
+      invalid("Unavailable image dimensions require explicit width and height with stretch fit.");
+  } else {
+    const naturalWidth = metadata.pixelWidth * 914400 / metadata.dpiX;
+    const naturalHeight = metadata.pixelHeight * 914400 / metadata.dpiY;
+    const ratio = naturalWidth / naturalHeight;
+    if (width === void 0 && height === void 0) {
+      width = naturalWidth;
+      height = naturalHeight;
+    } else if (width === void 0) width = height * ratio;
+    else if (height === void 0) height = width / ratio;
+    else if (options.fit === "contain") {
+      const scale = Math.min(width / naturalWidth, height / naturalHeight);
+      const fittedWidth = naturalWidth * scale, fittedHeight = naturalHeight * scale;
+      left += (width - fittedWidth) / 2;
+      top += (height - fittedHeight) / 2;
+      width = fittedWidth;
+      height = fittedHeight;
+    } else if (options.fit === "cover") {
+      const boxRatio = width / height;
+      if (ratio > boxRatio) cropX = (1 - boxRatio / ratio) * 5e4;
+      else cropY = (1 - ratio / boxRatio) * 5e4;
+    }
+  }
+  const round = (value) => Math.sign(value) * Math.round(Math.abs(value));
+  width = round(width);
+  height = round(height);
+  left = round(left);
+  top = round(top);
+  if ([left, top, width, height].some(
+    (value) => !Number.isSafeInteger(value) || Math.abs(value) > 27273042316900
+  ) || width < 1 || height < 1)
+    invalid("Computed image geometry is outside the supported range.");
+  if (Math.round(cropX) >= 5e4 || Math.round(cropY) >= 5e4)
+    invalid("Image crop cannot leave an empty source rectangle.");
+  const s = await loadShared(input, context);
+  const target = s.index.inventory.slides.find((slide) => slide.position === options.slide);
+  if (!target) throw new SelectionError("missing-selection");
+  const doc = s.doc(target.part), tree = required(required(doc.root, "cSld"), "spTree");
+  const id = new ShapeIdAllocator(() => doc).next();
+  let mediaIndex = 1;
+  while (s.reader.names.some(
+    (name) => name.toLowerCase() === `/ppt/media/image${mediaIndex}.${metadata.extension}`
+  ))
+    mediaIndex++;
+  const media = `/ppt/media/image${mediaIndex}.${metadata.extension}`;
+  const relationsPart = relPart(target.part);
+  const relns = "http://schemas.openxmlformats.org/package/2006/relationships";
+  const rels = s.reader.names.includes(relationsPart) ? s.doc(relationsPart) : parseXmlPart(
+    new TextEncoder().encode(`<Relationships xmlns="${relns}"/>`),
+    context.xmlLimits
+  );
+  const rid = nextRel(rels);
+  s.save(
+    relationsPart,
+    rels.spliceChildren(rels.root, rels.root.children.length, 0, [
+      `<Relationship xmlns="${relns}" Id="${rid}" Type="${s.r}/image" Target="${escape(relativePartReference(media, target.part.slice(0, target.part.lastIndexOf("/"))))}"/>`
+    ])
+  );
+  const types = s.doc("/[Content_Types].xml");
+  s.save(
+    "/[Content_Types].xml",
+    types.spliceChildren(types.root, types.root.children.length, 0, [
+      `<Override xmlns="${types.root.name.namespace}" PartName="${media}" ContentType="${options.contentType}"/>`
+    ])
+  );
+  s.changes.set(media, bytes);
+  const picture = `<p:pic xmlns:p="${s.p}" xmlns:a="${s.a}" xmlns:r="${s.r}"><p:nvPicPr><p:cNvPr id="${id}" name="Picture ${id}" descr="${escape(options.altText ?? "")}"/><p:cNvPicPr><a:picLocks noChangeAspect="1"/></p:cNvPicPr><p:nvPr/></p:nvPicPr><p:blipFill><a:blip r:embed="${rid}"/><a:srcRect l="${Math.round(cropX)}" t="${Math.round(cropY)}" r="${Math.round(cropX)}" b="${Math.round(cropY)}"/><a:stretch><a:fillRect/></a:stretch></p:blipFill><p:spPr><a:xfrm><a:off x="${left}" y="${top}"/><a:ext cx="${width}" cy="${height}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr></p:pic>`;
+  const extension = child(tree, "extLst");
+  s.save(
+    target.part,
+    doc.spliceChildren(
+      tree,
+      extension ? tree.children.indexOf(extension) : tree.children.length,
+      0,
+      [picture]
+    )
+  );
+  return (await s.finish(target.part, [options.slide])).bytes;
+}
+
+export {
+  addImage
+};

package/dist/safe-bash/command-chunks/{chunk-XFHUSZBM.js → chunk-KUGV3SSL.js}

@@ -1,11 +1,11 @@
-import {
-  record
-} from "./chunk-YJ3TFZB2.js";
 import {
   SafeJsCommandLimitError
-} from "./chunk-G3YO3JIN.js";
+} from "./chunk-ABH5FMMA.js";
+import {
+  record
+} from "./chunk-PQOAM5SC.js";
 
-// packages/safe-bash-command-node/src/commands/safejs/render.ts
+// packages/safe-bash-command-safejs/src/render.ts
 import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
 var Text = class {
   constructor(limit, fail) {

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

@@ -0,0 +1,249 @@
+import {
+  openDocumentLocations
+} from "./chunk-LHDB4QO5.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  formatSectionProperties,
+  readSectionProperties,
+  sectionAttribute,
+  sectionBoolean,
+  sectionChild
+} from "./chunk-VU3YUC3U.js";
+import {
+  findRelationshipPart
+} from "./chunk-4LXDJES2.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  appendBodyBlocks,
+  runElementOpen,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  SelectionError,
+  closedRecord,
+  decodeLocation,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/sections.ts
+function sectionOwners(body, bodyPath, budget, children) {
+  const result = [];
+  const w = body.namespace;
+  const paths = /* @__PURE__ */ new Map();
+  const locate = (node, path) => {
+    budget.charge("work", 1);
+    budget.charge("retainedBytes", 64 + path.length * 8);
+    paths.set(node, path);
+    node.children.forEach((child, index) => locate(child, [...path, index]));
+  };
+  locate(body, bodyPath);
+  const blocks = children(body);
+  let final;
+  blocks.forEach((child, i) => {
+    if (child.namespace !== w) return;
+    if (child.localName === "sectPr") {
+      if (final || i !== blocks.length - 1) throw new UnsupportedEditError("Final section properties must remain last in the body.");
+      final = child;
+    }
+    if (child.localName === "p") {
+      const props = sectionChild(child, "pPr", children), section = sectionChild(props, "sectPr", children);
+      if (section) result.push({ node: section, path: paths.get(section), owner: "paragraph" });
+    }
+  });
+  result.push({ node: final, path: final ? paths.get(final) : bodyPath, owner: "body" });
+  const admitted = new Set(result.map((o) => o.node));
+  const visit = (node) => {
+    budget.charge("work", 1);
+    if (node.namespace === w && node.localName === "sectPr" && !admitted.has(node)) throw new UnsupportedEditError("Section properties inside revisions or unsupported containers cannot be edited.");
+    for (const child of children(node)) visit(child);
+  };
+  visit(body);
+  return result;
+}
+function sectionState(document, archive, settings) {
+  const bodyLocation = document.list("story", { scope: "body" })[0];
+  const graph = new DocumentPackage(archive, settings.limits, settings.budget);
+  const main = graph.getPart(bodyLocation.value.part).name;
+  const editor = new DocumentArchiveEditor(archive, {}, void 0, settings.budget);
+  const xml = editor.xml(main);
+  const active = /* @__PURE__ */ new Map();
+  const collect = (content) => {
+    for (const item of content) if ("source" in item) {
+      settings.budget.charge("retainedBytes", 96 + item.content.length * 8);
+      active.set(item.source, item.content.filter((child) => "source" in child).map((child) => child.source));
+      collect(item.content);
+    }
+  };
+  collect(xml.compatibility.content);
+  const children = (node) => {
+    settings.budget.charge("work", 1);
+    return active.get(node) ?? [];
+  };
+  const body = sectionChild(xml.root, "body", children);
+  const owners = sectionOwners(body, bodyLocation.value.path, settings.budget, children);
+  const dialect = dialectForNamespace(xml.root.namespace);
+  const r = documentDialects[dialect].r;
+  const edges = graph.relationships("/" + main);
+  const edgesById = new Map(edges.map((edge) => [edge.rId, edge]));
+  const settingEdges = edges.filter((e) => e.reltype === r + "/settings");
+  if (settingEdges.length > 1 || settingEdges[0]?.is_external) throw new UnsupportedEditError("Settings require one internal relationship.");
+  const settingEdge = settingEdges[0];
+  const settingXml = settingEdge ? editor.xml(settingEdge.target_part.name) : void 0;
+  if (settingXml) collect(settingXml.compatibility.content);
+  const evenAndOddHeaders = sectionBoolean(sectionChild(settingXml?.root, "evenAndOddHeaders", children));
+  const inherited = { headers: /* @__PURE__ */ new Map(), footers: /* @__PURE__ */ new Map() };
+  const items = owners.map((owner, i) => {
+    settings.budget.charge("work", 1);
+    settings.budget.check("matches", i + 1);
+    const value = { ...bodyLocation.value, story: bodyLocation.value.story + "#sections", path: owner.path };
+    const location = { kind: "section", value, token: encodeGeneratedLocation(value), positions: { section: i + 1 } };
+    settings.budget.charge("retainedBytes", location.token.length * 4);
+    const bindings = (kind) => Object.fromEntries(["default", "first", "even"].map((variant) => {
+      const name = kind === "headers" ? "header" : "footer";
+      const refs = owner.node ? children(owner.node).filter((n) => n.namespace === xml.root.namespace && n.localName === name + "Reference" && sectionAttribute(n, "type") === variant) : [];
+      if (refs.length > 1) throw new UnsupportedEditError("Duplicate section story bindings cannot be interpreted.");
+      let binding = inherited[kind].get(variant);
+      if (refs[0]) {
+        const id = refs[0].attributes.find((a) => a.namespace === r && a.localName === "id")?.value;
+        const edge = id === void 0 ? void 0 : edgesById.get(id);
+        if (!edge || edge.reltype !== r + "/" + name || edge.is_external) throw new UnsupportedEditError("Section story binding cannot be resolved.");
+        binding = { linkedToPrevious: false, sourceSection: i + 1, part: edge.target_part.partname };
+        inherited[kind].set(variant, binding);
+      }
+      return [variant, { linkedToPrevious: !refs.length, sourceSection: binding?.sourceSection ?? null, part: binding?.part ?? null }];
+    }));
+    return { position: i + 1, owner: owner.owner, location, direct: readSectionProperties(owner.node, children), headers: bindings("headers"), footers: bindings("footers") };
+  });
+  return { editor, xml, body, main, owners, items, evenAndOddHeaders, graph, dialect, settingXml, settingEdge, children };
+}
+function select(items, options, mutable = false) {
+  if (options.select !== void 0) {
+    const value = decodeLocation(options.select);
+    if (value.sourceSha256 !== items[0]?.location.value.sourceSha256 || value.generation !== 0) throw new SelectionError("stale-selection");
+    const found = items.find((item) => item.location.token === options.select);
+    if (!found) throw new SelectionError("missing-selection");
+    return [found];
+  }
+  const selected = options.section === void 0 ? items : items.filter((item) => item.position === options.section);
+  if (!selected.length && mutable && !options.allowEmpty) throw new SelectionError("missing-selection");
+  return selected;
+}
+async function inspectDocumentSections(input, options, context) {
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: "sections.list", inputs: ["document"], options }, 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 current = sectionState(document, document.snapshot(), { ...settings, budget });
+  const data = { items: select(current.items, opts), evenAndOddHeaders: current.evenAndOddHeaders, units: "twip" };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify(data)).length);
+  return data;
+}
+async function editDocumentSections(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["sections.set", "sections.add"].includes(request.operation)) throw new DocxUsageError("Expected a section editing operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: [request.input?.path ?? "document"], options: request.options }, settings.budget);
+  const opts = invocation.options;
+  if (opts.evenAndOddHeaders !== void 0 && (opts.all !== true || opts.section !== void 0 || opts.select !== void 0)) throw new DocxUsageError("Even/odd headers are document-wide; use explicit all-section selection.");
+  if (request.operation === "sections.add" && ["select", "section", "all"].some((k) => invocation.options[k] !== void 0)) throw new DocxUsageError("Section addition appends to the body and rejects selection.");
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  let archive = document.snapshot();
+  assertDocumentEditable(archive, { ...settings, budget });
+  const current = sectionState(document, archive, { ...settings, budget });
+  const { owners, items, main, body } = current;
+  let { xml, editor } = current;
+  const selected = request.operation === "sections.add" ? [items.at(-1)] : select(items, opts, true);
+  const changes = [];
+  const geometryFields = ["orientation", "pageWidth", "pageHeight", "topMargin", "bottomMargin", "leftMargin", "rightMargin", "gutter", "headerDistance", "footerDistance", "columns", "columnGap", "startType"];
+  if (geometryFields.some((k) => invocation.options[k] !== void 0) && items.some((item) => item.direct.startType === "continuous" && [item.direct.pageWidth, item.direct.pageHeight, item.direct.leftMargin, item.direct.rightMargin, item.direct.topMargin, item.direct.bottomMargin].some((n) => n === null)))
+    throw new UnsupportedEditError("Unresolved continuous-section page dependencies prevent isolated geometry edits.");
+  const policyChanged = opts.evenAndOddHeaders !== void 0 && opts.evenAndOddHeaders !== current.evenAndOddHeaders;
+  for (const item of selected) {
+    budget.charge("work", 1);
+    const owner = owners[item.position - 1];
+    const adding = request.operation === "sections.add";
+    const properties = formatSectionProperties(xml, owner.node, adding ? { startType: opts.startType ?? { enum: "WD_SECTION_START", name: "NEW_PAGE" } } : opts, adding, sectionBoolean(sectionChild(current.settingXml?.root, "gutterAtTop", current.children)), current.children);
+    if (adding) {
+      const original = owner.node ? runElementOpen(owner.node) + xml.sourceXml(owner.node, /* @__PURE__ */ new Map(), true) + `</${owner.node.name}>` : `<sp:sectPr xmlns:sp="${xml.root.namespace}"/>`;
+      const boundary = `<sp:p xmlns:sp="${xml.root.namespace}"><sp:pPr>${original}</sp:pPr></sp:p>`;
+      if (owner.node) {
+        xml.replaceElement(owner.node, properties);
+        const staged = sectionState(document, editor.snapshot(), { ...settings, budget });
+        editor = staged.editor;
+        xml = staged.xml;
+        xml[appendBodyBlocks](staged.body, boundary);
+      } else xml[appendBodyBlocks](body, boundary + properties);
+    } else if (properties !== (owner.node ? xml.sourceXml(owner.node) : "")) {
+      if (owner.node) xml.replaceElement(owner.node, properties);
+      else xml.insertChildren(body, properties);
+    } else if (!policyChanged) continue;
+    const bodyPath = document.list("story", { scope: "body" })[0].value.path;
+    const path = adding ? owner.node ? [...owner.path.slice(0, -1), owner.path.at(-1) + 1] : [...bodyPath, body.children.length + 1] : !owner.node && properties ? [...bodyPath, body.children.length] : owner.path;
+    const value = { ...item.location.value, generation: 1, path };
+    const after = { ...item.location, value, token: encodeGeneratedLocation(value), positions: { section: adding ? items.length + 1 : item.position } };
+    changes.push({ kind: adding ? "insert" : "format", before: item.location, after });
+  }
+  archive = editor.snapshot();
+  if (policyChanged) {
+    const w = xml.root.namespace, r = documentDialects[current.dialect].r;
+    const markup = `<sp:evenAndOddHeaders xmlns:sp="${w}" sp:val="${Number(opts.evenAndOddHeaders)}"/>`;
+    if (current.settingXml) {
+      const old = sectionChild(current.settingXml.root, "evenAndOddHeaders");
+      if (old) current.settingXml.replaceElement(old, markup);
+      else current.settingXml.insertChildren(current.settingXml.root, markup, current.settingXml.root.children.find((c) => c.namespace === w && !["writeProtection", "view", "zoom", "removePersonalInformation", "removeDateAndTime", "doNotDisplayPageBoundaries", "displayBackgroundShape", "printPostScriptOverText", "printFractionalCharacterWidth", "printFormsData", "embedTrueTypeFonts", "embedSystemFonts", "saveSubsetFonts", "saveFormsData", "mirrorMargins", "alignBordersAndEdges", "bordersDoNotSurroundHeader", "bordersDoNotSurroundFooter", "gutterAtTop", "hideSpellingErrors", "hideGrammaticalErrors", "activeWritingStyle", "proofState", "formsDesign", "attachedTemplate", "linkStyles", "stylePaneFormatFilter", "stylePaneSortMethod", "documentType", "mailMerge", "revisionView", "trackRevisions", "doNotTrackMoves", "doNotTrackFormatting", "documentProtection", "autoFormatOverride", "styleLockTheme", "styleLockQFSet", "defaultTabStop", "autoHyphenation", "consecutiveHyphenLimit", "hyphenationZone", "doNotHyphenateCaps", "showEnvelope", "summaryLength", "clickAndTypeStyle", "defaultTableStyle"].includes(c.localName)));
+      archive = editor.snapshot();
+    } else {
+      const name = current.graph.allocatePartName("/word/settings", ".xml");
+      const types = new DocumentXmlEditor(archive.members.find((m) => m.name === "[Content_Types].xml").bytes, {}, void 0, budget);
+      types.insertChildren(types.root, `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(name)}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"/>`);
+      const split = main.lastIndexOf("/"), relName = findRelationshipPart(current.graph, "/" + main, budget)?.name ?? main.slice(0, split + 1) + "_rels/" + main.slice(split + 1) + ".rels";
+      const rel = archive.members.find((m) => m.name === relName);
+      const ns = "http://schemas.openxmlformats.org/package/2006/relationships";
+      const relXml = new DocumentXmlEditor(rel?.bytes ?? new TextEncoder().encode(`<Relationships xmlns="${ns}"/>`), {}, void 0, budget);
+      relXml.insertChildren(relXml.root, `<Relationship xmlns="${ns}" Id="${current.graph.allocateRelationshipId("/" + main)}" Type="${r}/settings" Target="${xmlValue(relativePartTarget("/" + main, name))}"/>`);
+      const members = archive.members.map((m) => m.name === "[Content_Types].xml" ? { ...m, bytes: types.serialize() } : m === rel ? { ...m, bytes: relXml.serialize() } : m);
+      if (!rel) members.push({ name: relName, bytes: relXml.serialize(), directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+      members.push({ name: name.slice(1), bytes: new TextEncoder().encode(`<sp:settings xmlns:sp="${w}">${markup}</sp:settings>`), directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+      archive = { ...archive, members };
+    }
+  }
+  const publication = { ...request.input ? { input: request.input } : {}, ...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 } };
+  const prospective = { changed: changes.length > 0, changes, dryRun: opts.dryRun ?? false, output: { path: opts.output ?? request.input?.path ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: request.operation, ok: true, data: prospective, affected: changes.length, locations: changes.map((c) => c.after), warnings: [], errors: [] }) + "\n").length);
+  const result = await publishDocumentArchive(archive, publication, { ...context, budget });
+  return { changed: changes.length > 0, changes, dryRun: opts.dryRun ?? false, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  sectionState,
+  inspectDocumentSections,
+  editDocumentSections
+};