@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-4DJICIFV.js

@@ -0,0 +1,227 @@
+import {
+  applyConnectorUpdate,
+  createConnectorXml,
+  readConnector,
+  removeDrawingObjects,
+  validateConnectorUpdate
+} from "./chunk-UJTJFMIN.js";
+import {
+  nodeFor,
+  selected,
+  validateSelection
+} from "./chunk-QHS7PDG3.js";
+import {
+  ShapeIdAllocator
+} from "./chunk-RZC7QHL6.js";
+import {
+  child,
+  loadShared,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/connector-operations.ts
+function optionsFor(options, action) {
+  if (!options || typeof options !== "object" || Reflect.ownKeys(options).some(
+    (k) => typeof k !== "string" || !("value" in Object.getOwnPropertyDescriptor(options, k))
+  ))
+    throw new SelectionError("invalid-selection");
+  validateSelection(options, action);
+  if (options.scope !== void 0 && options.scope !== "slides")
+    throw new SelectionError("invalid-selection");
+}
+function validateConnectorOptions(update, adding = false) {
+  validateConnectorUpdate(update, adding);
+  if (!adding && !Object.keys(update).some((k) => update[k] !== void 0))
+    throw new OfficeError("invalid-value", "A connector edit is required.", "usage");
+  let attached = false;
+  for (const key of ["beginTarget", "endTarget"]) {
+    const loc = update[key];
+    if (loc === void 0 || loc === null) continue;
+    attached = true;
+    if (typeof loc !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(loc)) || Reflect.ownKeys(loc).some(
+      (k) => typeof k !== "string" || !["fingerprint", "scope", "owner", "objectId", "coordinateSystem"].includes(k) || !("value" in Object.getOwnPropertyDescriptor(loc, k))
+    ) || loc.scope !== "slides" || loc.coordinateSystem !== "identity" || [loc.fingerprint, loc.owner, loc.objectId].some((v) => typeof v !== "string" || !v.length))
+      throw new SelectionError("invalid-selection");
+  }
+  if (attached !== (update.site !== void 0))
+    throw new OfficeError(
+      "invalid-value",
+      "An explicit site is required with an attached target.",
+      "usage"
+    );
+  if (update.detachPolicy === "remove" && Object.keys(update).some(
+    (k) => k !== "detachPolicy" && update[k] !== void 0
+  ))
+    throw new OfficeError(
+      "invalid-value",
+      "Remove policy cannot be combined with connector edits.",
+      "usage"
+    );
+}
+function targetsFor(s, part, update, root) {
+  const targets = {};
+  for (const end of ["begin", "end"]) {
+    const location = update[`${end}Target`];
+    if (!location) continue;
+    if (location.fingerprint !== s.index.fingerprint) throw new SelectionError("stale-selection");
+    const matches = s.index.objects.filter(
+      (r) => r.part === part && r.location.scope === location.scope && r.location.owner === location.owner && r.location.objectId === location.objectId
+    );
+    if (matches.length !== 1)
+      throw new SelectionError(matches.length ? "ambiguous-selection" : "missing-selection");
+    targets[end] = nodeFor(root, matches[0].id);
+  }
+  return targets;
+}
+async function readConnectors(input, options, context) {
+  optionsFor(options, "read");
+  const s = await loadShared(input, context, false);
+  return selected(s, options).filter((r) => nodeFor(s.doc(r.part).root, r.id).name.localName === "cxnSp").map((r) => ({
+    ...readConnector(nodeFor(s.doc(r.part).root, r.id)),
+    location: r.location,
+    token: r.token,
+    part: r.part
+  }));
+}
+async function addConnector(input, options, context) {
+  optionsFor(options, "add");
+  validateConnectorOptions(options.update, true);
+  if (options.shape !== void 0) throw new SelectionError("invalid-selection");
+  const s = await loadShared(input, context), records = selected(s, options, true);
+  if (records.length !== 1)
+    throw new SelectionError(records.length ? "ambiguous-selection" : "missing-selection");
+  const record = records[0], doc = s.doc(record.part), tree = required(required(doc.root, "cSld"), "spTree");
+  const id = new ShapeIdAllocator(() => doc).next();
+  const extension = child(tree, "extLst");
+  let next = doc.spliceChildren(
+    tree,
+    extension ? tree.children.indexOf(extension) : tree.children.length,
+    0,
+    [
+      createConnectorXml(
+        id,
+        Object.fromEntries(
+          Object.entries(options.update).filter(
+            ([key]) => !["beginTarget", "endTarget", "site"].includes(key)
+          )
+        ),
+        doc.root.name.namespace
+      )
+    ]
+  );
+  s.save(record.part, next);
+  const targets = targetsFor(s, record.part, options.update, next.root);
+  next = applyConnectorUpdate(next, nodeFor(next.root, String(id)), options.update, targets);
+  s.save(record.part, next);
+  return {
+    ...await s.finish(
+      record.part,
+      s.index.inventory.slides.filter((x) => x.part === record.part).map((x) => x.position)
+    ),
+    affected: 1,
+    records: [{ ...record, id: String(id) }]
+  };
+}
+async function mutateConnectors(input, options, context) {
+  optionsFor(options, "set");
+  validateConnectorOptions(options.update);
+  if (options.update.detachPolicy === "remove")
+    return removeConnectors(
+      input,
+      Object.fromEntries(Object.entries(options).filter(([k]) => k !== "update")),
+      context
+    );
+  const s = await loadShared(input, context), records = selected(s, options).filter(
+    (r) => nodeFor(s.doc(r.part).root, r.id).name.localName === "cxnSp"
+  );
+  checkCount(records, options);
+  for (const r of records) {
+    const doc = s.doc(r.part);
+    s.save(
+      r.part,
+      applyConnectorUpdate(
+        doc,
+        nodeFor(doc.root, r.id),
+        options.update,
+        targetsFor(s, r.part, options.update, doc.root)
+      )
+    );
+  }
+  return {
+    ...await s.finish(
+      records[0]?.part ?? s.main,
+      s.index.inventory.slides.filter((x) => records.some((r) => r.part === x.part)).map((x) => x.position)
+    ),
+    affected: records.length,
+    records
+  };
+}
+function checkCount(records, options) {
+  if (!options.select && options.shape === void 0 && options.slide === void 0 && !options.part && !options.all)
+    throw new SelectionError("invalid-selection");
+  if (!records.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (records.length > 1 && !options.all)
+    throw new SelectionError(
+      "ambiguous-selection",
+      records.map((r) => r.location)
+    );
+}
+async function removeConnectors(input, options, context) {
+  optionsFor(options, "set");
+  if (Object.hasOwn(options, "update"))
+    throw new OfficeError("invalid-value", "Deletion does not accept updates.", "usage");
+  return removeObjects(input, options, context, true);
+}
+async function removeShapes(input, options, context) {
+  if (!options || typeof options !== "object" || Reflect.ownKeys(options).some(
+    (k) => typeof k !== "string" || !("value" in Object.getOwnPropertyDescriptor(options, k))
+  ))
+    throw new SelectionError("invalid-selection");
+  const { detachPolicy, ...selection } = options;
+  optionsFor(selection, "set");
+  if (Object.hasOwn(selection, "update"))
+    throw new OfficeError("invalid-value", "Deletion does not accept updates.", "usage");
+  if (detachPolicy !== void 0 && !["detach", "remove"].includes(detachPolicy))
+    throw new OfficeError("invalid-value", "Invalid detach policy.", "usage");
+  return removeObjects(input, options, context, false);
+}
+async function removeObjects(input, options, context, connectorsOnly) {
+  const { detachPolicy, ...selection } = options;
+  optionsFor(selection, "set");
+  const s = await loadShared(input, context), records = selected(s, selection).filter(
+    (r) => !connectorsOnly || nodeFor(s.doc(r.part).root, r.id).name.localName === "cxnSp"
+  );
+  checkCount(records, selection);
+  for (const part of new Set(records.map((r) => r.part)))
+    s.save(
+      part,
+      removeDrawingObjects(
+        s.doc(part),
+        records.filter((r) => r.part === part).map((r) => r.id),
+        detachPolicy
+      )
+    );
+  return {
+    ...await s.finish(
+      records[0]?.part ?? s.main,
+      s.index.inventory.slides.filter((x) => records.some((r) => r.part === x.part)).map((x) => x.position)
+    ),
+    affected: records.length,
+    records
+  };
+}
+
+export {
+  validateConnectorOptions,
+  readConnectors,
+  addConnector,
+  mutateConnectors,
+  removeConnectors,
+  removeShapes
+};

package/dist/safe-bash/command-chunks/chunk-4FNQPK7C.js

@@ -0,0 +1,385 @@
+import {
+  editDocumentParagraphs,
+  tableContainerWidth
+} from "./chunk-AQ6RTM2M.js";
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  editMergedTable,
+  mergedTableGrid,
+  replaceCellContent
+} from "./chunk-47MFDPH4.js";
+import {
+  LocationIndex,
+  addressKey
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  UnsupportedEditError,
+  activeXmlChildren,
+  insertTableRowXml,
+  removeTableRowXml,
+  runElementOpen,
+  twips,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  storedBooleanValue
+} from "./chunk-VEUQWV2V.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  SelectionError,
+  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-edit.ts
+var orders = {
+  tblPr: "tblStyle tblpPr tblOverlap bidiVisual tblStyleRowBandSize tblStyleColBandSize tblW jc tblCellSpacing tblInd tblBorders shd tblLayout tblCellMar tblLook tblCaption tblDescription tblPrChange".split(" "),
+  trPr: "cnfStyle divId gridBefore gridAfter wBefore wAfter cantSplit trHeight tblHeader tblCellSpacing jc hidden ins del trPrChange".split(" "),
+  tcPr: "cnfStyle tcW gridSpan hMerge vMerge tcBorders shd noWrap tcMar textDirection tcFitText vAlign hideMark cellIns cellDel cellMerge tcPrChange".split(" "),
+  tblCellMar: ["top", "left", "start", "bottom", "right", "end"],
+  tcMar: ["top", "left", "start", "bottom", "right", "end"]
+};
+function one(node, name, projected = (node2) => node2.children) {
+  const found = projected(node).filter((child) => child.namespace === node.namespace && child.localName === name);
+  if (found.length > 1) throw new UnsupportedEditError("Duplicate table properties cannot be edited.");
+  return found[0];
+}
+function attr(node, name) {
+  return node?.attributes.find((a) => a.namespace === node.namespace && a.localName === name)?.value;
+}
+function element(w, name, attrs, source, inner = "") {
+  const keep = source?.attributes.filter((a) => a.namespace !== "http://www.w3.org/2000/xmlns/" && !(a.namespace === w && Object.hasOwn(attrs, a.localName))) ?? [];
+  const namespaces = new Map(source?.namespaces);
+  let prefix = "te";
+  while (namespaces.has(prefix) && namespaces.get(prefix) !== w) prefix += "e";
+  namespaces.set(prefix, w);
+  return `<${prefix}:${name}${[...namespaces].filter(([p]) => p !== "xml").map(([p, uri]) => ` ${p ? "xmlns:" + p : "xmlns"}="${xmlValue(uri)}"`).join("")}${keep.map((a) => ` ${a.name}="${xmlValue(a.value)}"`).join("")}${Object.entries(attrs).map(([k, v]) => ` ${prefix}:${k}="${xmlValue(v)}"`).join("")}>${inner}</${prefix}:${name}>`;
+}
+function properties(xml, owner, name, values, nested, projected = (node) => node.children) {
+  const field = (node, key) => {
+    const found = projected(node).filter((child) => child.namespace === node.namespace && child.localName === key);
+    if (found.length > 1) throw new UnsupportedEditError("Duplicate table properties cannot be edited.");
+    return found[0];
+  };
+  const props = field(owner, name), changes = /* @__PURE__ */ new Map(), additions = /* @__PURE__ */ new Map();
+  const set = (key, markup, old) => {
+    if (old) changes.set(old, markup);
+    else additions.set(key, markup);
+  };
+  for (const [key, value] of values) {
+    const old = props ? field(props, key) : void 0;
+    if (value === null) {
+      if (old) changes.set(old, "");
+      continue;
+    }
+    if (old && Object.entries(value).every(([k, v]) => attr(old, k) === v)) continue;
+    set(key, element(owner.namespace, key, value, old, old ? xml.sourceXml(old, /* @__PURE__ */ new Map(), true) : ""), old);
+  }
+  if (nested) {
+    const containerOwner = props ?? { ...owner, children: [] };
+    const markup = properties(xml, containerOwner, nested.name, nested.values, void 0, projected);
+    const old = props ? field(props, nested.name) : void 0;
+    if (markup !== (old ? xml.sourceXml(old) : "")) set(nested.name, markup, old);
+  }
+  if (!changes.size && !additions.size) return props ? xml.sourceXml(props) : "";
+  const order = orders[name] ?? [], prefixes = /* @__PURE__ */ new Map();
+  let tail = "";
+  for (const [key, markup] of additions) {
+    const next = (props ? projected(props) : []).find((c) => c.namespace === owner.namespace && order.indexOf(c.localName) > order.indexOf(key));
+    if (next) prefixes.set(next, (prefixes.get(next) ?? "") + markup);
+    else tail += markup;
+  }
+  for (const [node, prefix] of prefixes) changes.set(node, prefix + (changes.get(node) ?? xml.sourceXml(node)));
+  const inner = (props ? xml.sourceXml(props, changes, true) : "") + tail;
+  return props ? runElementOpen(props) + inner + `</${props.name}>` : element(owner.namespace, name, {}, void 0, inner);
+}
+function withProperties(xml, node, name, markup, patches = /* @__PURE__ */ new Map(), projected = (node2) => node2.children) {
+  const found = projected(node).filter((child) => child.namespace === node.namespace && child.localName === name);
+  if (found.length > 1) throw new UnsupportedEditError("Duplicate table properties cannot be edited.");
+  const old = found[0];
+  if (old) {
+    patches.set(old, markup);
+    return xml.sourceXml(node, patches);
+  }
+  if (!markup) return xml.sourceXml(node, patches);
+  return runElementOpen(node) + (old ? "" : markup) + xml.sourceXml(node, patches, true) + `</${node.name}>`;
+}
+function descendants(node, children = (node2) => node2.children) {
+  const result = [], pending = [node];
+  while (pending.length) {
+    const current = pending.pop();
+    result.push(current);
+    const active = children(current);
+    for (let index = active.length - 1; index >= 0; index--) pending.push(active[index]);
+  }
+  return result;
+}
+function header(row, projected = (node) => node.children) {
+  const props = one(row, "trPr", projected), flag = props && one(props, "tblHeader", projected);
+  if (!flag) return false;
+  const value = storedBooleanValue(attr(flag, "val") ?? "1");
+  if (value === null) throw new UnsupportedEditError("Invalid repeated table header policy value.");
+  return value;
+}
+function validateHeaders(flags) {
+  let ended = false;
+  for (const value of flags) {
+    if (value && ended) throw new InvalidValueError("Repeated headers must be consecutive leading rows.");
+    if (!value) ended = true;
+  }
+}
+async function editDocumentTables(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (request.operation === "tables.add") return editDocumentParagraphs(input, request, context);
+  if (!["tables.set", "tables.rows.add", "tables.rows.remove", "tables.columns.add", "tables.columns.remove", "tables.merge", "tables.split"].includes(request.operation)) throw new DocxUsageError("Expected a table 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);
+  const archive = document.snapshot();
+  assertDocumentEditable(archive, { ...settings, budget });
+  const graph = new DocumentPackage(archive, settings.limits, budget);
+  const mainPart = graph.getPart(document.list("story", { scope: "body" })[0].value.part), main = mainPart.name;
+  const dialect = dialectForNamespace(parseDocumentXml(mainPart.bytes, {}, budget).root.namespace);
+  const w = documentDialects[dialect].w;
+  let styleId;
+  if (opts.style !== void 0) {
+    const edge = graph.relationships("/" + main).find((e) => e.reltype === documentDialects[dialect].r + "/styles");
+    const styles = edge && !edge.is_external ? parseDocumentXml(edge.target_part.bytes, {}, budget).root : void 0;
+    const found = styles?.children.filter((n) => n.namespace === w && n.localName === "style" && attr(n, "type") === "table" && attr(one(n, "name"), "val") === opts.style) ?? [];
+    if (found.length !== 1 || !(styleId = attr(found[0], "styleId"))) throw new InvalidValueError("Expected one existing table style.");
+  }
+  const editor = new DocumentArchiveEditor(archive, {}, void 0, budget);
+  const updates = [];
+  const edited = /* @__PURE__ */ new Set();
+  for (const before of selected) {
+    budget.charge("work", 1);
+    const xml = editor.xml(before.value.part.slice(1));
+    let node = xml.root;
+    const ancestors = [node];
+    for (const i of before.value.path) {
+      node = node.children[i];
+      ancestors.push(node);
+    }
+    if (!["table", "cell"].includes(before.kind) || before.value.range) throw new InvalidValueError("Table editing requires a whole table or cell anchor.");
+    const table = [...ancestors].reverse().find((n) => n.namespace === w && n.localName === "tbl");
+    if (!table) throw new InvalidValueError("Expected a table anchor.");
+    const projected = activeXmlChildren(xml, budget);
+    if (ancestors.some((n) => n.namespace === w && ["ins", "del", "moveFrom", "moveTo"].includes(n.localName)) || descendants(table, projected).some((n) => n.namespace === w && ["tblPrChange", "trPrChange", "tcPrChange", "cellIns", "cellDel", "cellMerge"].includes(n.localName))) throw new UnsupportedEditError("Tracked table changes require explicit revision operations.");
+    budget.charge("work", descendants(table).length);
+    const tablePath = before.value.path.slice(0, ancestors.indexOf(table));
+    const key = before.value.part + ":" + tablePath.join(",");
+    if (edited.has(key)) throw new InvalidValueError("Overlapping table edits require separate transactions.");
+    edited.add(key);
+    const rows = projected(table).filter((n) => n.namespace === w && n.localName === "tr"), selectedRow = before.kind === "cell" ? [...ancestors].reverse().find((n) => n.namespace === w && n.localName === "tr") : void 0;
+    const patches = /* @__PURE__ */ new Map();
+    let replacement;
+    let rowInsertion;
+    const logical = mergedTableGrid(table, budget, projected);
+    if (request.operation === "tables.set" && opts.cell !== void 0 && opts.cell !== before.positions.cell && opts.covered !== "owner") throw new SelectionError("ambiguous-selection", [before.token]);
+    if (request.operation === "tables.set") {
+      if (opts.text !== void 0 && before.kind !== "cell") throw new InvalidValueError("Scalar table text requires a logical cell selection.");
+      if (before.kind === "cell" && [opts.style, opts.autofit, opts.alignment, opts.direction].some((v) => v !== void 0)) throw new InvalidValueError("Table style, layout, alignment and direction require a table selection.");
+      const values = /* @__PURE__ */ new Map();
+      if (styleId !== void 0) values.set("tblStyle", { val: styleId });
+      if (opts.width !== void 0) values.set(before.kind === "cell" ? "tcW" : "tblW", { w: String(twips(opts.width)), type: "dxa" });
+      if (opts.autofit !== void 0) values.set("tblLayout", { type: opts.autofit ? "autofit" : "fixed" });
+      if (opts.alignment !== void 0) values.set("jc", opts.alignment === null ? null : { val: { LEFT: dialect === "strict" ? "start" : "left", CENTER: "center", RIGHT: dialect === "strict" ? "end" : "right" }[opts.alignment.name] });
+      if (opts.direction !== void 0) values.set("bidiVisual", opts.direction === null ? null : { val: opts.direction.name === "RTL" ? "1" : "0" });
+      const margin = opts.cellMargin === void 0 ? void 0 : String(twips(opts.cellMargin, false));
+      const nested = margin === void 0 ? void 0 : { name: before.kind === "cell" ? "tcMar" : "tblCellMar", values: new Map((dialect === "strict" ? ["top", "start", "bottom", "end"] : ["top", "left", "bottom", "right"]).map((edge) => [edge, { w: margin, type: "dxa" }])) };
+      const target = before.kind === "cell" ? node : table, propertyName = before.kind === "cell" ? "tcPr" : "tblPr";
+      const targetPatches = /* @__PURE__ */ new Map();
+      const propertyMarkup = properties(xml, target, propertyName, values, nested, projected);
+      const formatted = opts.text === void 0 ? withProperties(xml, target, propertyName, propertyMarkup, targetPatches, projected) : replaceCellContent(xml, target, opts.text, budget, { graph: () => graph, owner: before.value.part, context: { ...settings, budget } }, propertyMarkup);
+      if (target === table) patches.set(table, formatted);
+      else patches.set(selectedRow, xml.sourceXml(selectedRow, /* @__PURE__ */ new Map([[target, formatted]])));
+      if (opts.repeatHeader !== void 0 || opts.allowRowSplit !== void 0) {
+        const activeRows = projected(table).filter((child) => child.namespace === w && child.localName === "tr");
+        const affected = selectedRow ? [selectedRow] : activeRows;
+        validateHeaders(activeRows.map((row) => affected.includes(row) && opts.repeatHeader !== void 0 ? opts.repeatHeader : header(row, projected)));
+        for (const row of affected) {
+          const rowValues = /* @__PURE__ */ new Map();
+          if (opts.repeatHeader !== void 0) rowValues.set("tblHeader", { val: String(Number(opts.repeatHeader)) });
+          if (opts.allowRowSplit !== void 0) rowValues.set("cantSplit", { val: String(Number(!opts.allowRowSplit)) });
+          patches.set(row, withProperties(xml, row, "trPr", properties(xml, row, "trPr", rowValues, void 0, projected), target === node && before.kind === "cell" ? /* @__PURE__ */ new Map([[node, formatted]]) : /* @__PURE__ */ new Map(), projected));
+        }
+      }
+      if (target === table) {
+        const rowPatches = new Map([...patches].filter(([n]) => n !== table));
+        replacement = withProperties(xml, table, "tblPr", properties(xml, table, "tblPr", values, nested, projected), rowPatches, projected);
+      } else replacement = xml.sourceXml(table, patches);
+    } else if (request.operation === "tables.merge" || request.operation === "tables.split" || request.operation === "tables.rows.remove" && logical.owners.some((o) => o.rowSpan > 1 || o.columnSpan > 1)) {
+      if (request.operation !== "tables.rows.remove" && descendants(table).some((c) => c.namespace === w && ["fldChar", "bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "permStart", "permEnd"].includes(c.localName))) throw new UnsupportedEditError("Merge and split cannot move range markers or complex fields.");
+      if (request.operation === "tables.rows.remove" && before.kind !== "table") throw new InvalidValueError("Row removal requires a table anchor.");
+      if (request.operation === "tables.rows.remove" && descendants(rows[(opts.index ?? 0) - 1] ?? table).some((c) => c.namespace === w && ["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "permStart", "permEnd", "fldChar"].includes(c.localName))) throw new UnsupportedEditError("Structural deletion cannot remove range markers or complex fields.");
+      replacement = editMergedTable(xml, table, node, request.operation, opts, budget, projected);
+    } else {
+      if (before.kind !== "table") throw new InvalidValueError("Row and column operations require a table anchor.");
+      const grid = one(table, "tblGrid", projected), columns = logical.columns;
+      if (!grid || !columns.length || !rows.length) throw new UnsupportedEditError("Structural edits require a nonempty table grid.");
+      if (projected(table).some((c) => c.namespace !== w || !["tblPr", "tblGrid", "tr"].includes(c.localName)) || projected(grid).some((c) => c.namespace !== w || c.localName !== "gridCol")) throw new UnsupportedEditError("Structural edits require a rectangular table without controlled rows or columns.");
+      for (const row of rows) {
+        if (projected(row).some((c) => c.namespace !== w || !["trPr", "tc"].includes(c.localName))) throw new UnsupportedEditError("Structural edits require rectangular rows without controlled cells.");
+      }
+      if (logical.slots.some((slots) => Array.from({ length: columns.length }, (_, i) => slots[i]).some((owner) => !owner))) throw new UnsupportedEditError("Structural edits require a rectangular table without omitted cells.");
+      const rowOperation = request.operation.startsWith("tables.rows."), adding = request.operation.endsWith(".add"), count = rowOperation ? rows.length : columns.length;
+      const position = opts.index ?? count + 1;
+      if (!Number.isSafeInteger(position) || position < 1) throw new InvalidValueError("Table index must be a positive one-based integer.");
+      if (position > count + (adding ? 1 : 0)) throw new SelectionError("missing-selection");
+      if (!adding && count === 1) throw new InvalidValueError("Structural removal must retain at least one row and column.");
+      budget.table(rows.length + (rowOperation ? adding ? 1 : -1 : 0), columns.length + (rowOperation ? 0 : adding ? 1 : -1));
+      const widths = columns.map((column) => Number(attr(column, "w")));
+      if (adding && widths.some((value) => !Number.isSafeInteger(value) || value <= 0)) throw new UnsupportedEditError("Insertion requires stored positive grid widths.");
+      const emptyCell = (width, span = 1, continuation = false) => element(w, "tc", {}, void 0, element(w, "tcPr", {}, void 0, element(w, "tcW", { w: String(width), type: "dxa" }) + (span > 1 ? element(w, "gridSpan", { val: String(span) }) : "") + (continuation ? element(w, "vMerge", { val: "continue" }) : "")) + element(w, "p", {}));
+      const insert = (parent, values, markup) => {
+        const next = values[position - 1];
+        if (next) patches.set(next, markup + xml.sourceXml(next));
+        else {
+          const last = values.at(-1);
+          patches.set(last, xml.sourceXml(last) + markup);
+        }
+        return xml.sourceXml(parent, patches);
+      };
+      if (rowOperation) {
+        if (opts.width !== void 0 && twips(opts.width) !== widths.reduce((a, b) => a + b, 0)) throw new InvalidValueError("New row width must equal the table grid width.");
+        if (adding) {
+          const flags = rows.map((row) => header(row, projected)), repeated = position <= flags.filter(Boolean).length;
+          flags.splice(position - 1, 0, repeated);
+          validateHeaders(flags);
+          let cells = "";
+          for (let c = 0; c < columns.length; ) {
+            const owner = logical.slots[position - 1]?.[c];
+            const continuation = owner !== void 0 && owner.row < position - 1 && owner.row + owner.rowSpan > position - 1;
+            const span = continuation ? owner.columnSpan : 1;
+            cells += emptyCell(widths.slice(c, c + span).reduce((a, b) => a + b, 0), span, continuation);
+            c += span;
+          }
+          const markup = element(w, "tr", {}, void 0, (repeated ? element(w, "trPr", {}, void 0, element(w, "tblHeader", { val: "1" })) : "") + cells);
+          rowInsertion = { anchor: rows[position - 1] ?? rows.at(-1), markup, before: position <= rows.length };
+          replacement = insert(table, rows, markup);
+        } else {
+          patches.set(rows[position - 1], "");
+          replacement = xml.sourceXml(table, patches);
+        }
+      } else {
+        const width = adding ? opts.width ? twips(opts.width) : Math.floor(tableContainerWidth(before, xml.root, editor.xml(main).root, budget) / (columns.length + 1)) : widths[position - 1];
+        if (adding && (!Number.isSafeInteger(width) || width < 1)) throw new InvalidValueError("Column insertion requires a positive width.");
+        const gridMarkup = adding ? insert(grid, columns, element(w, "gridCol", { w: String(width) })) : xml.sourceXml(grid, /* @__PURE__ */ new Map([[columns[position - 1], ""]]));
+        patches.clear();
+        patches.set(grid, gridMarkup);
+        for (const row of rows) {
+          const physical = logical.physical[rows.indexOf(row)], local = /* @__PURE__ */ new Map();
+          const crossing = physical.find((cell) => cell.column < position - 1 && cell.column + cell.span > position - 1);
+          const affected = adding ? crossing : physical.find((cell) => cell.column <= position - 1 && cell.column + cell.span > position - 1);
+          if (affected && (adding || affected.span > 1)) {
+            const span = affected.span + (adding ? 1 : -1), props2 = one(affected.node, "tcPr", projected), preferred2 = props2 && one(props2, "tcW", projected);
+            const values = /* @__PURE__ */ new Map([["gridSpan", span === 1 ? null : { val: String(span) }]]);
+            const oldWidth2 = Number(attr(preferred2, "w"));
+            if (attr(preferred2, "type") === "dxa" && Number.isSafeInteger(oldWidth2) && Number.isSafeInteger(width)) {
+              const newWidth = oldWidth2 + (adding ? width : -width);
+              if (newWidth <= 0) throw new InvalidValueError("Column removal leaves an invalid preferred cell width.");
+              values.set("tcW", { w: String(newWidth), type: "dxa" });
+            }
+            local.set(affected.node, withProperties(xml, affected.node, "tcPr", properties(xml, affected.node, "tcPr", values, void 0, projected), /* @__PURE__ */ new Map(), projected));
+          } else if (adding) {
+            const next = physical.find((cell) => cell.column >= position - 1)?.node, anchor = next ?? physical.at(-1).node;
+            local.set(anchor, next ? emptyCell(width) + xml.sourceXml(anchor) : xml.sourceXml(anchor) + emptyCell(width));
+          } else local.set(affected.node, "");
+          patches.set(row, xml.sourceXml(row, local));
+        }
+        const props = one(table, "tblPr", projected), preferred = props && one(props, "tblW", projected);
+        const oldWidth = Number(attr(preferred, "w"));
+        if (attr(preferred, "type") === "dxa" && Number.isSafeInteger(oldWidth) && Number.isSafeInteger(width)) {
+          const newWidth = oldWidth + (adding ? width : -width);
+          if (newWidth <= 0) throw new InvalidValueError("Column removal leaves an invalid preferred table width.");
+          replacement = withProperties(xml, table, "tblPr", properties(xml, table, "tblPr", /* @__PURE__ */ new Map([["tblW", { w: String(newWidth), type: "dxa" }]]), void 0, projected), patches, projected);
+        } else replacement = xml.sourceXml(table, patches);
+      }
+      if (!adding) {
+        const removed = rowOperation ? [rows[position - 1]] : logical.physical.flat().filter((cell) => cell.column === position - 1 && cell.span === 1).map((cell) => cell.node);
+        if (removed.some((n) => descendants(n).some((c) => c.namespace === w && ["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "permStart", "permEnd", "fldChar"].includes(c.localName)))) throw new UnsupportedEditError("Structural deletion cannot remove range markers or complex fields.");
+      }
+    }
+    if (replacement === xml.sourceXml(table)) continue;
+    const candidateRoot = parseDocumentXml(new TextEncoder().encode(xml.sourceXml(xml.root, /* @__PURE__ */ new Map([[table, replacement]]))), {}, budget).root;
+    let resultingTable = candidateRoot;
+    for (const index2 of tablePath) resultingTable = resultingTable.children[index2];
+    const resultingGrid = mergedTableGrid(resultingTable, budget, activeXmlChildren(candidateRoot, budget));
+    if (rowInsertion) xml[insertTableRowXml](rowInsertion.anchor, rowInsertion.markup, rowInsertion.before);
+    else if (request.operation === "tables.rows.remove") xml[removeTableRowXml](table, rows[opts.index - 1], replacement);
+    else xml.replaceElement(table, replacement);
+    let resultPath = tablePath;
+    if (request.operation === "tables.set" && before.kind === "cell") {
+      const owner = logical.owners.find((owner2) => owner2.node === node);
+      const cell = owner && resultingGrid.slots[owner.row]?.[owner.column]?.node;
+      if (!cell) throw new UnsupportedEditError("Table edit could not retain its logical cell owner.");
+      const pending = [{ node: resultingTable, path: tablePath }];
+      let found = false;
+      while (pending.length) {
+        const current = pending.pop();
+        budget.charge("work", 1);
+        if (current.node === cell) {
+          resultPath = current.path;
+          found = true;
+          break;
+        }
+        for (let index2 = current.node.children.length - 1; index2 >= 0; index2--) {
+          budget.charge("work", current.path.length + 1);
+          budget.charge("retainedBytes", 64 + (current.path.length + 1) * 8);
+          pending.push({ node: current.node.children[index2], path: [...current.path, index2] });
+        }
+      }
+      if (!found) throw new UnsupportedEditError("Table edit could not resolve its resulting cell path.");
+    }
+    updates.push({ before, path: resultPath, kind: request.operation === "tables.set" ? opts.text === void 0 ? "format" : "replace" : ["tables.merge", "tables.split"].includes(request.operation) ? "replace" : request.operation.endsWith(".add") ? "insert" : "delete", resultKind: request.operation === "tables.set" && before.kind === "cell" ? "cell" : "table" });
+  }
+  const candidate = editor.snapshot(), index = new LocationIndex(candidate, settings.limits, main, dialect, budget);
+  budget.check("matches", updates.length);
+  const changes = updates.map(({ before, path, kind, resultKind }) => {
+    const entry = index.byAddress.get(addressKey({ ...before.value, path }))?.find((e) => e.kind === resultKind);
+    if (!entry) throw new UnsupportedEditError("Table edit could not resolve its resulting location.");
+    const value = { ...before.value, generation: 1, path, range: null };
+    return { kind, before, after: { kind: resultKind, value, token: encodeGeneratedLocation(value), positions: resultKind === "cell" && before.positions.cell !== void 0 ? { ...entry.positions, cell: before.positions.cell } : entry.positions } };
+  });
+  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 };
+}
+
+export {
+  editDocumentTables
+};