@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,321 @@
+import {
+  chartDefinitionParts,
+  decodeChartContent
+} from "./chunk-JQZ3BXWY.js";
+import {
+  collectDiagramObservations,
+  diagramPartRoles
+} from "./chunk-OGWJD5QP.js";
+import {
+  DocumentLocations,
+  docxLocationBudgets
+} from "./chunk-LHDB4QO5.js";
+import {
+  embeddedFontContentTypes,
+  fontResourceRole,
+  readFontResources
+} from "./chunk-WOZCIRJ5.js";
+import {
+  LocationIndex
+} from "./chunk-IR6ZKAUH.js";
+import {
+  activeControlLocks,
+  activeSettingsProtection
+} from "./chunk-TBAH4XGI.js";
+import {
+  validateDocumentArchive
+} from "./chunk-3SEQG5JH.js";
+import {
+  documentPartRole,
+  signatureContentTypes,
+  signatureRelationshipTypes
+} from "./chunk-DXX2Z2QA.js";
+import {
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  revisionInfo
+} from "./chunk-YPVBU7QF.js";
+import {
+  readPropertyParts,
+  storedBooleanValue
+} from "./chunk-VEUQWV2V.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compareInventoryNames
+} from "./chunk-2EUH5B6A.js";
+import {
+  MarkupCompatibility,
+  compatibilityProfileForPart,
+  documentCompatibilityProfile
+} from "./chunk-GZ2N24A2.js";
+import {
+  SelectionError,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  UnsupportedProfileError,
+  isXmlContentType,
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError,
+  InvalidValueError,
+  archiveSettings,
+  documentSession,
+  readArchive
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/inspection.ts
+var inspectionLocationView = /* @__PURE__ */ Symbol("inspection-location-view");
+function selectInspectionLocations(document, roots, options) {
+  if (options.select !== void 0) return [document.resolve(options.select)];
+  const section = options.section === void 0 ? void 0 : document.at("section", options.section);
+  const query = { scope: options.scope ?? "body", ...options.section === void 0 ? {} : { section: options.section } };
+  let owner;
+  if (options.comment !== void 0 || options.note !== void 0)
+    owner = document.at("story", options.comment ?? options.note, { scope: options.comment === void 0 ? query.scope ?? "body" : "comments" });
+  for (const kind of ["table", "cell", "paragraph", "run", "image", "link", "control", "revision", "shape", "field", "bookmark"]) {
+    if (options[kind] === void 0) continue;
+    if (kind === "cell") owner = document.cell(owner.token, options.cell);
+    else if (kind === "revision") {
+      const budget = docxLocationBudgets.get(document);
+      const revisions = document.list("annotation", owner ? { owner: owner.token } : query).filter((location) => {
+        budget.charge("work", location.value.path.length + 1);
+        let node = roots.get(location.value.part);
+        for (const index of location.value.path) node = node?.children[index];
+        return node !== void 0 && revisionInfo(node) !== void 0;
+      });
+      owner = revisions[options.revision - 1];
+      if (!owner) throw new SelectionError("missing-selection");
+    } else owner = document.at(kind, options[kind], owner ? { owner: owner.token } : query);
+  }
+  return owner ? [owner] : section && (options.scope === void 0 || options.scope === "body") ? [section] : document.list("story", query);
+}
+function attribute(node, name, namespace = "") {
+  return node.attributes.find((a) => a.localName === name && a.namespace === namespace)?.value;
+}
+async function inspectDocument(input, context) {
+  const { limits, signal, budget } = archiveSettings(context);
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected archive bytes.");
+  budget.check("compressedInput", input.length);
+  budget.charge("retainedBytes", input.length);
+  const owned = new Uint8Array(input);
+  const archive = await readDocumentArchive(owned, { ...context, limits, signal, budget });
+  const hash = async (bytes) => {
+    budget.charge("work", bytes.length);
+    const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+    budget.check("work", 0);
+    return [...new Uint8Array(digest)].map((n) => n.toString(16).padStart(2, "0")).join("");
+  };
+  const sourceSha256 = await hash(owned);
+  const graph = archive.package;
+  const parts = [];
+  for (const member of [...archive.members].filter((m2) => !m2.directory).sort((a2, b) => compareInventoryNames(a2.name, b.name))) {
+    const name = member.name.toLowerCase() === "[content_types].xml" ? "/[Content_Types].xml" : graph.getPart("/" + member.name).partname;
+    parts.push({ name, contentType: name === "/[Content_Types].xml" ? "application/xml" : graph.getPart(name).content_type, bytes: member.bytes.length, sha256: await hash(member.bytes) });
+  }
+  parts.sort((a2, b) => compareInventoryNames(a2.name, b.name));
+  const relationships = [];
+  for (const owner of ["/", ...graph.parts.filter((p) => p.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml").map((p) => p.partname)].sort(compareInventoryNames)) {
+    for (const edge of graph.relationships(owner))
+      relationships.push({ owner, id: edge.rId, type: edge.reltype, target: edge.target_ref, external: edge.is_external });
+  }
+  const counts = { paragraphs: 0, runs: 0, tables: 0, rows: 0, cells: 0, images: 0, sections: 0, comments: 0, footnotes: 0, endnotes: 0, fields: 0, controls: 0, equations: 0, cachedPages: null };
+  const countNames = /* @__PURE__ */ new Map([["p", "paragraphs"], ["r", "runs"], ["tbl", "tables"], ["tr", "rows"], ["tc", "cells"], ["sectPr", "sections"], ["comment", "comments"], ["sdt", "controls"]]);
+  const { w, a, m } = documentDialects[archive.dialect];
+  const properties = [];
+  const annotations = [];
+  const protection = [];
+  const fontNames = /* @__PURE__ */ new Set();
+  const themeNames = /* @__PURE__ */ new Set();
+  const unknownNamespaces = /* @__PURE__ */ new Set();
+  const roots = /* @__PURE__ */ new Map();
+  const compatibilityViews = /* @__PURE__ */ new Map();
+  let cachedBreaks = 0;
+  let compatibility = false;
+  const annotationNames = /* @__PURE__ */ new Set(["comment", "ins", "del", "moveFrom", "moveTo", "rPrChange", "pPrChange", "tblPrChange", "tcPrChange", "sectPrChange", "numberingChange"]);
+  for (const part of [...graph.parts].sort((a2, b) => compareInventoryNames(a2.partname, b.partname))) {
+    const type = part.content_type.toLowerCase();
+    if (!isXmlContentType(type)) continue;
+    const root = parseDocumentXml(part.bytes, {}, budget).root;
+    roots.set(part.partname, root);
+    const role = documentPartRole(type, root);
+    const fontRole = fontResourceRole(type, root);
+    const raw = [root];
+    while (raw.length) {
+      budget.charge("work", 1);
+      const node = raw.pop();
+      for (const child of node.children) {
+        budget.charge("retainedBytes", 16);
+        raw.push(child);
+      }
+      if (node.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" || node.attributes.some((attr) => attr.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006")) compatibility = true;
+      if (!documentCompatibilityProfile.understoodNamespaces.includes(node.namespace) && node.namespace !== "http://schemas.openxmlformats.org/markup-compatibility/2006") unknownNamespaces.add(node.namespace);
+      for (const attr of node.attributes) if (attr.namespace && attr.namespace !== "http://www.w3.org/2000/xmlns/" && attr.namespace !== "http://schemas.openxmlformats.org/markup-compatibility/2006" && !documentCompatibilityProfile.understoodNamespaces.includes(attr.namespace)) unknownNamespaces.add(attr.namespace);
+    }
+    const view2 = new MarkupCompatibility(root, compatibilityProfileForPart(part.partname), budget);
+    budget.charge("retainedBytes", 64);
+    compatibilityViews.set(part.partname, view2);
+    const settingsProtection = role === "settings" ? activeSettingsProtection(root, view2, budget) : /* @__PURE__ */ new Set();
+    const controlLocks = role === "story" || role === "glossary" ? activeControlLocks(root, view2, budget) : /* @__PURE__ */ new Map();
+    compatibility ||= view2.branches.length > 0;
+    const stack = [...view2.content].reverse();
+    while (stack.length) {
+      budget.charge("work", 1);
+      const current = stack.pop();
+      if (!("source" in current)) continue;
+      const node = current.source;
+      if (current.disposition !== "understood") {
+        unknownNamespaces.add(node.namespace);
+        continue;
+      }
+      for (let index2 = current.content.length - 1; index2 >= 0; index2--) stack.push(current.content[index2]);
+      if (node.namespace === w && (role === "story" || role === "glossary" || role === "settings")) {
+        const name = node.localName;
+        const count = countNames.get(name);
+        if (count && count !== "cachedPages") counts[count]++;
+        if (["footnote", "endnote"].includes(name) && !["separator", "continuationSeparator", "continuationNotice"].includes(attribute(node, "type", w) ?? "normal")) counts[name === "footnote" ? "footnotes" : "endnotes"]++;
+        if (name === "fldSimple" || name === "fldChar" && attribute(node, "fldCharType", w) === "begin") counts.fields++;
+        if (name === "lastRenderedPageBreak") cachedBreaks++;
+        if (annotationNames.has(name)) annotations.push({ part: part.partname, kind: name, id: attribute(node, "id", w) ?? null, author: attribute(node, "author", w) ?? null, date: attribute(node, "date", w) ?? null });
+        if (settingsProtection.has(node) || controlLocks.has(node)) {
+          const enforcement = attribute(node, "enforcement", w);
+          const edit = attribute(node, name === "lock" ? "val" : "edit", w) ?? null;
+          const enforced = name === "lock" ? edit !== "unlocked" : name === "writeProtection" ? true : enforcement === void 0 ? false : storedBooleanValue(enforcement);
+          protection.push({ part: part.partname, kind: name, enforced, edit });
+        }
+      }
+      if (node.namespace === w && (role === "story" || role === "glossary" || role === "settings" || fontRole === "styles")) {
+        if (node.localName === "rFonts") for (const attr of node.attributes) {
+          if (attr.namespace !== w) continue;
+          if (["ascii", "hAnsi", "eastAsia", "cs"].includes(attr.localName)) fontNames.add(attr.value);
+          if (["asciiTheme", "hAnsiTheme", "eastAsiaTheme", "cstheme"].includes(attr.localName)) themeNames.add(attr.value);
+        }
+      }
+      if (node.namespace === a && (fontRole === "theme" || role === "story" || role === "glossary" || ["application/vnd.openxmlformats-officedocument.drawingml.chart+xml", "application/vnd.ms-office.chartex+xml"].includes(parseMediaType(type))) && ["latin", "ea", "cs", "font"].includes(node.localName)) {
+        const value = attribute(node, "typeface");
+        if (value) fontNames.add(value);
+      }
+      if (node.namespace === m && node.localName === "oMath") counts.equations++;
+    }
+  }
+  const propertyParts = readPropertyParts(archive, budget, roots);
+  for (const part of propertyParts) for (const property of part.properties) if (property.value) properties.push({ ...property.value, writable: property.value.writable && part.owned && !part.ambiguous && part.safeCustom, part: part.name, group: part.group });
+  properties.sort((a2, b) => compareInventoryNames(a2.part, b.part) || compareInventoryNames(a2.name, b.name));
+  const pages = properties.filter((p) => p.group === "extended" && p.name === "pages");
+  counts.cachedPages = pages.length === 1 && typeof pages[0].value === "number" && pages[0].value >= 0 ? pages[0].value : null;
+  const index = new LocationIndex(archive, limits, archive.mainPart, archive.dialect, budget, graph, roots);
+  const view = context[inspectionLocationView];
+  if (view) {
+    view.document = new DocumentLocations(archive, sourceSha256, { ...context, limits, signal, budget }, "inventory", index);
+    view.roots = roots;
+  }
+  counts.images = index.entries.filter((entry) => entry.kind === "image").length;
+  const stories = index.entries.filter((entry) => entry.kind === "story").map((entry) => {
+    const value = { version: 1, sourceSha256, generation: context[documentSession]?.generation ?? 0, part: entry.part, story: entry.story, path: entry.path, range: null };
+    const token = encodeGeneratedLocation(value);
+    budget.charge("retainedBytes", token.length * 4);
+    return { kind: entry.scope ?? "story", location: { kind: "story", token, value, positions: { ...entry.positions } }, properties: [], references: relationships.filter((r) => r.owner === entry.part), support: "read" };
+  });
+  const signatureReferences = relationships.filter((reference) => signatureRelationshipTypes.includes(reference.type));
+  const signatureTargets = /* @__PURE__ */ new Set();
+  for (const owner of ["/", ...graph.parts.filter((part) => part.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml").map((part) => part.partname)]) for (const edge of graph.relationships(owner)) if (!edge.is_external && signatureRelationshipTypes.includes(edge.reltype)) signatureTargets.add(edge.target_part.partname);
+  const signatureParts = parts.filter((part) => signatureContentTypes.includes(part.contentType.toLowerCase()) || signatureTargets.has(part.name));
+  const signed = signatureParts.length > 0 || signatureReferences.length > 0;
+  const media = parts.filter((p) => ["image/", "audio/", "video/"].some((prefix) => p.contentType.toLowerCase().startsWith(prefix)));
+  const embedded = parts.filter((p) => embeddedFontContentTypes.includes(parseMediaType(p.contentType))).map((p) => p.name);
+  const warnings = [
+    { code: "partial-validation", message: "Inspection is an inventory; core-v1 validation is partial and does not certify schema conformance." },
+    { code: "cached-layout", message: "Page metadata and stored page breaks are cached; rendered pages are not measured." },
+    { code: "font-availability", message: "Font names are document references; installed fonts are not queried." }
+  ];
+  if (propertyParts.some((p) => !p.owned || p.ambiguous || !p.safeCustom || p.properties.some((property) => !property.value || property.value.value === null))) warnings.push({ code: "invalid-property", message: "One or more stored property values are invalid or unsupported; opaque values remain preserved outside scalar snapshots." });
+  if (signatureParts.length) warnings.push({ code: "unverified-signatures", message: "Signature parts are present; cryptographic signatures are not verified." });
+  if (protection.length) warnings.push({ code: "unvalidated-protection", message: "Protection metadata is present; passwords and enforcement are not verified." });
+  if (unknownNamespaces.size) warnings.push({ code: "unvalidated-extensions", message: "Opaque extension content is inventoried without semantic validation." });
+  const chartParts = chartDefinitionParts(graph, budget);
+  const decodedCharts = chartParts.some((part) => parseMediaType(part.content_type) === "application/vnd.openxmlformats-officedocument.drawingml.chart+xml" && roots.has(part.partname) && decodeChartContent(roots.get(part.partname), part.partname, budget).status === "decoded");
+  const diagramRoles = diagramPartRoles(graph, archive.dialect, budget);
+  const diagramObservations = [...roots].flatMap(([part, root]) => collectDiagramObservations(root, archive.dialect, part, budget, compatibilityViews.get(part)));
+  const knownDiagrams = diagramRoles.size > 0 || diagramObservations.some((observation) => observation.kind === "relIds");
+  const detections = [
+    ["F01", true, "read"],
+    ["F02", true, "read"],
+    ["F03", archive.kind === "dotx", "read"],
+    ["F05", compatibility, "read"],
+    ["F06", true, "read"],
+    ["F19", counts.tables > 0, "read"],
+    ["F21", relationships.some((r) => Object.values(documentDialects).some((dialect) => r.type === `${dialect.r}/hyperlink`)), "read"],
+    ["F22", counts.fields > 0, "read"],
+    ["F24", counts.footnotes + counts.endnotes > 0, "read"],
+    ["F25", counts.comments > 0, "read"],
+    ["F26", annotations.some((a2) => a2.kind !== "comment"), "read"],
+    ["F27", annotations.some((a2) => ["moveFrom", "moveTo", "tblPrChange", "tcPrChange", "sectPrChange"].includes(a2.kind)), "read"],
+    ["F37", chartParts.length > 0, decodedCharts ? "read" : "preserve"],
+    ["F38", knownDiagrams, "preserve"],
+    ["F28", counts.controls > 0, "read"],
+    ["F30", propertyParts.length > 0, properties.length > 0 ? "read" : "preserve"],
+    ["F31", media.length > 0, "read"],
+    ["F39", counts.equations > 0, "preserve"],
+    ["F41", relationships.some((r) => ["http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml", "http://purl.oclc.org/ooxml/officeDocument/relationships/customXml", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/glossaryDocument", "http://purl.oclc.org/ooxml/officeDocument/relationships/glossaryDocument"].includes(r.type)) || parts.some((p) => parseMediaType(p.contentType) === "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml" || parseMediaType(p.contentType) === "application/vnd.openxmlformats-officedocument.customxmlproperties+xml"), "preserve"],
+    ["F42", fontNames.size + embedded.length + protection.length > 0 || parts.some((p) => ["application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml"].includes(parseMediaType(p.contentType))), "read"],
+    ["F43", signed, "preserve"]
+  ];
+  const fontResources = readFontResources(archive, roots, budget, compatibilityViews);
+  for (const table of fontResources.fontTables) for (const font of table.fonts) if (font.name) fontNames.add(font.name);
+  if (fontResources.diagnostics.length) warnings.push({ code: "unresolved-font-resources", message: "Theme or embedded font references have unresolved package resources; see fontResources.diagnostics." });
+  const result = {
+    fontResources,
+    kind: archive.kind,
+    dialect: archive.dialect,
+    sizes: { archiveBytes: owned.length, expandedBytes: parts.reduce((sum, p) => sum + p.bytes, 0), mediaBytes: media.reduce((sum, p) => sum + p.bytes, 0) },
+    parts,
+    relationships,
+    contentTypes: { defaults: graph.defaults.map((d) => ({ extension: d.extension, contentType: d.content_type })).sort((a2, b) => compareInventoryNames(a2.extension, b.extension)), overrides: graph.overrides.map((d) => ({ name: d.partname, contentType: d.content_type })).sort((a2, b) => compareInventoryNames(a2.name, b.name)) },
+    unsupportedNamespaces: [...unknownNamespaces].sort(compareInventoryNames),
+    stories,
+    properties,
+    counts,
+    features: detections.map(([id, detected, level]) => ({ id, detected, level, subsets: id === "F39" ? [{ name: "inventory", level, reason: "Physical stored math inventory preserves opaque units and does not evaluate equations." }, { name: "bounded-fragment-edit", level: "read", reason: "Explicit equation utilities admit bounded fragments only at current editable paragraph or whole-unit tokens; inventory counts remain exposed expressions." }] : id === "F38" ? [{ name: "inventory", level, reason: "Diagram resource inventory and preservation only; no layout generation." }, ...diagramObservations.some((observation) => observation.kind !== "relIds") ? [{ name: "opaque-graphics", level: "preserve", reason: "Opaque physical graphics observations do not establish known diagram semantics." }] : []] : [{ name: "inventory", level, reason: "Package inventory only; no editing or rendering claim." }] })),
+    signed,
+    protected: protection.some((p) => p.enforced !== false),
+    pages: { rendered: null, cachedBreaks },
+    fonts: { references: [...fontNames].sort(compareInventoryNames), themeReferences: [...themeNames].sort(compareInventoryNames), embedded, installed: null },
+    signatures: { parts: signatureParts.map((p) => p.name), verified: null },
+    media,
+    annotations,
+    protection,
+    warnings
+  };
+  const size = new TextEncoder().encode(JSON.stringify(result)).length;
+  budget.check("serializedOutput", size);
+  budget.charge("retainedBytes", size);
+  return result;
+}
+async function validateDocument(input, context, options = {}) {
+  const { limits, signal, budget } = archiveSettings(context);
+  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.");
+  if (input instanceof Uint8Array && input.length >= 8 && [208, 207, 17, 224, 161, 177, 26, 225].every((b, i) => input[i] === b)) {
+    budget.check("compressedInput", input.length);
+    throw new UnsupportedProfileError("Compound binary Word or encrypted Office containers are unsupported.");
+  }
+  const archive = await readArchive(input, { limits, signal, budget });
+  const report = validateDocumentArchive(archive, options, budget);
+  return {
+    ...report,
+    checks: report.checks.map((c) => c.id === "container" ? { id: c.id, status: "passed" } : c),
+    warnings: ["Partial schema and semantic validation only; no full conformance certification.", "Protection, signature cryptography, extension semantics and rendered layout are unvalidated."]
+  };
+}
+
+export {
+  inspectionLocationView,
+  selectInspectionLocations,
+  inspectDocument,
+  validateDocument
+};

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

@@ -0,0 +1,309 @@
+import {
+  UnsupportedEquationMutationError,
+  collectEquationUnits
+} from "./chunk-L4XEXXVQ.js";
+import {
+  UnsupportedDiagramMutationError,
+  collectDiagramObservations
+} from "./chunk-OGWJD5QP.js";
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  sectionAttribute,
+  sectionChild
+} from "./chunk-VU3YUC3U.js";
+import {
+  addDocumentStylesPart,
+  styleAllocationIds
+} from "./chunk-MQFXMBGD.js";
+import {
+  paragraphTextRun,
+  replaceParagraphContent,
+  splitParagraphContent
+} from "./chunk-GGOZXIGH.js";
+import {
+  LocationIndex,
+  addressKey
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  UnsupportedEditError,
+  activeXmlChildren,
+  appendBodyBlocks,
+  assertFormattingHistoryEditable,
+  assertOutsideRevisionRanges,
+  copiedSplitParagraphProperties,
+  mathNamespace,
+  newTabStopXml,
+  pageGeometry,
+  paragraphProperties,
+  paragraphUnits,
+  renderContent,
+  replaceNativeTabCollectionXml,
+  replaceSplitParagraphXml,
+  runElementOpen,
+  selectNamedStyles,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InvalidValueError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/table-insertion.ts
+function renderInsertedTable(options, location, root, mainRoot, styles, budget, reservedStyleIds = /* @__PURE__ */ new Set()) {
+  const supplied = options.content;
+  if (supplied && (supplied.page || supplied.theme || supplied.styles || supplied.blocks.length !== 1 || supplied.blocks[0]?.kind !== "table"))
+    throw new InvalidValueError("Table content requires exactly one table and no document settings.");
+  const block = supplied?.blocks[0];
+  if (block && (block.rows.length !== options.rows || block.rows[0].length !== options.cols))
+    throw new InvalidValueError("Typed table content must match explicit rows and columns.");
+  const formatKeys = ["width", "style", "columnWidths", "autofit", "repeatHeader", "headerRows", "allowRowSplit", "rowHeight", "heightRule", "borders", "shading", "cellMargin", "rowOptions"];
+  const formatting = Object.fromEntries(formatKeys.filter((key) => options[key] !== void 0).map((key) => {
+    if (block?.[key] !== void 0) throw new InvalidValueError("Table formatting cannot be supplied twice.");
+    return [key, options[key]];
+  }));
+  budget.table(options.rows, options.cols);
+  const table = { kind: "table", rows: block?.rows ?? Array.from({ length: options.rows }, () => Array.from({ length: options.cols }, () => ({ blocks: [] }))), ...block, ...formatting };
+  const width = tableContainerWidth(location, root, mainRoot, budget, options.before);
+  return renderContent({ version: 1, blocks: [table] }, mainRoot.namespace, budget, styles, width, reservedStyleIds);
+}
+function tableContainerWidth(location, root, mainRoot, budget, before) {
+  const mainChildren = activeXmlChildren(mainRoot, budget);
+  const children = root === mainRoot ? mainChildren : activeXmlChildren(root, budget);
+  const body = sectionChild(mainRoot, "body", mainChildren);
+  const sections = mainChildren(body).flatMap((n) => n.namespace !== mainRoot.namespace ? [] : n.localName === "p" ? sectionChild(sectionChild(n, "pPr", mainChildren), "sectPr", mainChildren) ?? [] : n.localName === "sectPr" ? [n] : []);
+  let section = sections.at(-1);
+  if (location?.positions.section) section = sections[location.positions.section - 1];
+  if (location?.kind === "paragraph" && !location.value.range && !before) {
+    let node2 = root;
+    for (const i of location.value.path) node2 = node2.children[i];
+    if (sectionChild(sectionChild(node2, "pPr", children), "sectPr", children)) section = sections[location.positions.section ?? 1];
+  }
+  let width = pageGeometry(void 0, section, mainRoot.namespace, mainChildren).width;
+  const columns = sectionChild(section, "cols", mainChildren);
+  const count = Number(sectionAttribute(columns, "num") ?? 1);
+  if (!Number.isSafeInteger(count) || count < 1) throw new UnsupportedEditError("Invalid section column geometry.");
+  if (count > 1) {
+    const entries = columns ? mainChildren(columns).filter((n) => n.namespace === mainRoot.namespace && n.localName === "col") : [];
+    if (entries.length) {
+      if (entries.length !== count) throw new UnsupportedEditError("Incomplete section column geometry.");
+      width = Math.min(...entries.map((n) => Number(sectionAttribute(n, "w"))));
+    } else width = Math.floor((width - (count - 1) * Number(sectionAttribute(columns, "space") ?? 720)) / count);
+  }
+  let node = root;
+  let tableMargins;
+  for (const index of location?.value.path ?? []) {
+    node = node.children[index];
+    if (node.namespace !== root.namespace) continue;
+    if (node.localName === "tbl") tableMargins = sectionChild(sectionChild(node, "tblPr", children), "tblCellMar", children);
+    if (node.localName !== "tc") continue;
+    const props = sectionChild(node, "tcPr", children), cellWidth = sectionChild(props, "tcW", children);
+    if (sectionAttribute(cellWidth, "type") !== "dxa") throw new UnsupportedEditError("Nested insertion requires an explicit cell width in twips.");
+    width = Number(sectionAttribute(cellWidth, "w"));
+    const margins = sectionChild(props, "tcMar", children);
+    for (const edge of ["left", "right"]) {
+      const alternate = edge === "left" ? "start" : "end";
+      const margin = sectionChild(margins, edge, children) ?? sectionChild(margins, alternate, children) ?? sectionChild(tableMargins, edge, children) ?? sectionChild(tableMargins, alternate, children);
+      if (margin && sectionAttribute(margin, "type") !== "dxa") throw new UnsupportedEditError("Nested insertion requires explicit cell margins in twips.");
+      width -= Number(sectionAttribute(margin, "w") ?? 0);
+    }
+  }
+  if (!Number.isSafeInteger(width) || width < 1) throw new UnsupportedEditError("No positive stored container width is available.");
+  return width;
+}
+
+// packages/safe-bash-docx-engine/src/paragraph-edit.ts
+async function editDocumentParagraphs(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["paragraphs.set", "paragraphs.add", "runs.add", "tables.add"].includes(request.operation)) throw new DocxUsageError("Expected a block or inline 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;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const selected = resolveDocxSelection(document, invocation);
+  let archive = document.snapshot();
+  assertDocumentEditable(archive, { ...settings, budget });
+  const body = document.list("story", { scope: "body" })[0];
+  const graph = new DocumentPackage(archive, settings.limits, budget);
+  const mainPart = graph.getPart(body.value.part), main = mainPart.name;
+  const dialect = dialectForNamespace(parseDocumentXml(mainPart.bytes, {}, budget).root.namespace);
+  const w = documentDialects[dialect].w;
+  const stylesEdge = graph.relationships("/" + main).find((edge) => edge.reltype === documentDialects[dialect].r + "/styles");
+  const styles = stylesEdge && !stylesEdge.is_external ? parseDocumentXml(stylesEdge.target_part.bytes, {}, budget).root : void 0;
+  const styleChildren = styles ? activeXmlChildren(styles, budget) : (node) => node.children;
+  let styleId;
+  if (opts.style !== void 0 && request.operation !== "tables.add") {
+    const candidates = styles ? styleChildren(styles).filter((node) => node.namespace === w && node.localName === "style" && (node.attributes.find((a) => a.namespace === w && a.localName === "type")?.value ?? "paragraph") === (request.operation === "runs.add" ? "character" : "paragraph")) : [];
+    const found = selectNamedStyles(candidates, opts.style, styleChildren, budget);
+    if (found.length !== 1) throw new InvalidValueError("Expected one existing style of the selected kind.");
+    styleId = found[0].attributes.find((a) => a.namespace === w && a.localName === "styleId")?.value;
+    if (!styleId) throw new InvalidValueError("Selected style has no identifier.");
+  }
+  let headingStyles = "";
+  if (opts.level !== void 0) {
+    if (opts.style !== void 0) throw new DocxUsageError("Heading level and style cannot be combined.");
+    const rendered = renderContent({ version: 1, blocks: [{ kind: "paragraph", level: opts.level }] }, w, budget, styles, void 0, styleAllocationIds(graph.parts, budget));
+    const paragraph = parseDocumentXml(new TextEncoder().encode(rendered.body), {}, budget).root;
+    styleId = paragraph.children[0].children[0].attributes.find((a) => a.namespace === w && a.localName === "val").value;
+    headingStyles = rendered.styles;
+    if (headingStyles && !stylesEdge) {
+      archive = addDocumentStylesPart(archive, { package: graph, mainPart: main, dialect }, headingStyles, budget).archive;
+      headingStyles = "";
+    }
+  }
+  let tableMarkup;
+  if (request.operation === "tables.add") {
+    const anchor = selected[0];
+    const mainRoot = parseDocumentXml(archive.members.find((m) => m.name === main).bytes, {}, budget).root;
+    const owner = anchor ? graph.getPart(anchor.value.part) : mainPart;
+    const root = owner.name !== main ? parseDocumentXml(owner.bytes, {}, budget).root : mainRoot;
+    const rendered = renderInsertedTable(opts, anchor, root, mainRoot, styles, budget, styleAllocationIds(graph.parts, budget));
+    tableMarkup = rendered.body;
+    headingStyles = selected.length ? rendered.styles : "";
+    if (headingStyles && !stylesEdge) {
+      archive = addDocumentStylesPart(archive, { package: graph, mainPart: main, dialect }, headingStyles, budget).archive;
+      headingStyles = "";
+    }
+  }
+  const editor = new DocumentArchiveEditor(archive, {}, void 0, budget);
+  if (headingStyles) {
+    const xml = editor.xml(stylesEdge.target_part.name);
+    xml.insertChildren(xml.root, headingStyles);
+  }
+  const updates = [];
+  for (const before of selected) {
+    budget.charge("work", 1);
+    const xml = editor.xml(before.value.part.slice(1));
+    let node = xml.root, parent = node;
+    const ancestors = [node];
+    for (const index2 of before.value.path) {
+      parent = node;
+      node = node.children[index2];
+      ancestors.push(node);
+    }
+    if (ancestors.some((n) => n.namespace === w && ["ins", "del", "moveFrom", "moveTo"].includes(n.localName)))
+      throw new UnsupportedEditError("Tracked paragraph edits require explicit revision operations.");
+    xml.assertShapeEditAllowed(node);
+    const children = activeXmlChildren(xml, budget);
+    assertFormattingHistoryEditable(xml.root, node, children, budget);
+    const props = children(node).find((c) => c.namespace === w && c.localName === "pPr");
+    const originalProps = props ? xml.sourceXml(props) : "";
+    if (request.operation === "paragraphs.set") {
+      if (opts.text !== void 0) {
+        const observations = collectDiagramObservations(xml.root, dialect, before.value.part, budget);
+        const equations = collectEquationUnits(node, mathNamespace(dialect === "strict"), budget);
+        if (equations.length) throw new UnsupportedEquationMutationError(before);
+        if (observations.some((observation) => before.value.path.every((index2, i) => observation.path[i] === index2))) throw new UnsupportedDiagramMutationError(before);
+        assertOutsideRevisionRanges(xml.root, node, budget, xml.compatibility.branches, children);
+      }
+      const properties = paragraphProperties(xml, node, opts, styleId, children);
+      const original = xml.sourceXml(node);
+      const replacement = opts.text !== void 0 ? replaceParagraphContent(xml, node, properties, opts.text ?? "", budget, { graph: () => graph, owner: before.value.part, context: { ...settings, budget } }) : props ? xml.sourceXml(node, /* @__PURE__ */ new Map([[props, properties]])) : runElementOpen(node) + properties + xml.sourceXml(node, /* @__PURE__ */ new Map(), true) + `</${node.name}>`;
+      if (properties === originalProps && opts.text === void 0 || replacement === original) continue;
+      const tabs = props && children(props).find((c) => c.namespace === w && c.localName === "tabs");
+      if (opts.tabStopAdd && tabs) xml[replaceNativeTabCollectionXml](node, replacement, tabs, newTabStopXml(w, opts.tabStopAdd), paragraphUnits(opts.tabStopAdd.position));
+      else xml.replaceElement(node, replacement);
+      updates.push({ before, path: before.value.path, kind: opts.text === void 0 ? "format" : "replace" });
+      continue;
+    }
+    const range = before.value.range;
+    if (range && (range.start !== range.end || before.kind !== "paragraph")) throw new DocxUsageError("Insertion requires a collapsed paragraph range.");
+    if (opts.before !== void 0 && (before.kind !== "paragraph" || range)) throw new DocxUsageError("Before requires a whole paragraph anchor.");
+    const run = paragraphTextRun(w, opts.text ?? "", request.operation === "runs.add" ? styleId : void 0, opts.break);
+    if (request.operation === "runs.add") {
+      if (before.kind !== "paragraph") throw new DocxUsageError("Inline insertion requires a paragraph.");
+      if (range) {
+        const [prefix, suffix] = splitParagraphContent(xml, node, range.start, budget, [originalProps, ""]);
+        xml[replaceSplitParagraphXml](node, runElementOpen(node) + prefix + run + suffix + `</${node.name}>`);
+      } else xml.insertChildren(node, run);
+      updates.push({ before, path: before.value.path, kind: "insert" });
+      continue;
+    }
+    const markup = tableMarkup ?? `<pi:p xmlns:pi="${w}">${styleId === void 0 ? "" : `<pi:pPr><pi:pStyle pi:val="${xmlValue(styleId)}"/></pi:pPr>`}${opts.text === void 0 ? "" : run}</pi:p>`;
+    if (before.kind === "paragraph") {
+      const position = before.value.path.at(-1);
+      if (!["body", "tc", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent", "sdtContent"].includes(parent.localName) || parent.namespace !== w)
+        throw new UnsupportedEditError("Paragraph insertion requires a supported block container.");
+      if (range) {
+        if (node.attributes.some((attribute) => ![w, "http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace", "http://schemas.openxmlformats.org/markup-compatibility/2006"].includes(attribute.namespace))) throw new UnsupportedEditError("Caret insertion cannot duplicate opaque paragraph attributes.");
+        const sections = props ? children(props).filter((c) => c.namespace === w && c.localName === "sectPr") : [];
+        if (sections.length > 1) throw new UnsupportedEditError("Caret insertion requires one section-property owner.");
+        const section = sections[0];
+        const prefixProps = props && section ? xml.sourceXml(props, /* @__PURE__ */ new Map([[section, ""]])) : originalProps;
+        const suffixProps = props ? xml[copiedSplitParagraphProperties](node, props) : "";
+        const [prefix, suffix] = splitParagraphContent(xml, node, range.start, budget, [prefixProps, suffixProps]);
+        xml[replaceSplitParagraphXml](node, runElementOpen(node) + prefix + `</${node.name}>` + markup + runElementOpen(node) + suffix + `</${node.name}>`);
+        updates.push({ before, path: [...before.value.path.slice(0, -1), position + 1], kind: "insert" });
+      } else {
+        const original = xml.sourceXml(node);
+        const terminal = tableMarkup && parent.localName === "tc" && parent.children.at(-1) === node && !opts.before ? `<w:p xmlns:w="${w}"/>` : "";
+        xml.replaceElement(node, opts.before ? markup + original : original + markup + terminal);
+        updates.push({ before, path: [...before.value.path.slice(0, -1), position + (opts.before ? 0 : 1)], kind: "insert" });
+      }
+    } else {
+      if (!["body", "tc", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent"].includes(node.localName) || node.namespace !== w)
+        throw new UnsupportedEditError("Block insertion requires a story or cell container.");
+      if (node.localName === "body") {
+        const path = xml[appendBodyBlocks](node, markup);
+        updates.push({ before, path, kind: "insert" });
+        continue;
+      }
+      const section = node.children.find((c) => c.namespace === w && c.localName === "sectPr");
+      xml.insertChildren(node, markup + (tableMarkup && node.localName === "tc" ? `<w:p xmlns:w="${w}"/>` : ""), section);
+      updates.push({ before, path: [...before.value.path, section ? node.children.indexOf(section) : node.children.length], kind: "insert" });
+    }
+  }
+  budget.check("matches", updates.length);
+  const candidate = editor.snapshot();
+  const index = new LocationIndex(candidate, settings.limits, main, dialect, budget);
+  const changes = updates.map(({ before, path, kind }) => {
+    const kindOfResult = tableMarkup ? "table" : "paragraph";
+    const entry = index.byAddress.get(addressKey({ ...before.value, path }))?.find((e) => e.kind === kindOfResult);
+    if (!entry) throw new UnsupportedEditError("Paragraph edit could not resolve its resulting location.");
+    const value = { ...before.value, generation: 1, path, range: null };
+    const after = { kind: kindOfResult, value, token: encodeGeneratedLocation(value), positions: entry.positions };
+    return { kind, before, after };
+  });
+  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: opts.dryRun ? null : { path: opts.inPlace ? request.input?.path ?? null : opts.output === "-" ? null : opts.output ?? 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(candidate, 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 };
+}
+var editDocumentTables = editDocumentParagraphs;
+
+export {
+  tableContainerWidth,
+  editDocumentParagraphs,
+  editDocumentTables
+};