ooxml-core 0.10.0 → 0.12.0

package/dist/visio/index.cjs

@@ -6183,7 +6183,7 @@ function recalculateVisioCells(roots, changed, options = {}) {
     if (active.size >= maxDepth)
       fail("LIMIT_FORMULA_DEPTH", "ShapeSheet dependency depth limit exceeded.");
     const item = cells3.get(id);
-    if (!item || item.unsafe)
+    if (!item || item.unsafe && (!item.node || !options.masterMovePins?.has(item.node)))
       fail(
         "EDIT_UNSUPPORTED_DEPENDENCY",
         "Affected formula references missing, inherited or grouped cells."
@@ -6336,7 +6336,7 @@ function setCell(shape, name, value, formula) {
   if (formula) node.setAttribute("F", formula);
   else if (attribute2(node, "F") !== "No Formula") node.removeAttribute("F");
 }
-function admitted(root, shapeId) {
+function admitted(root, shapeId, masterMovePins = /* @__PURE__ */ new Set(), masterDimensions = /* @__PURE__ */ new Map()) {
   const containers = children(root, "Shapes");
   if (containers.length !== 1)
     fail("UNSUPPORTED_GEOMETRY_EDIT", "One local Shapes container is required.");
@@ -6346,7 +6346,10 @@ function admitted(root, shapeId) {
   if (candidates.length !== 1)
     fail("EDIT_TARGET_NOT_FOUND", "A unique top-level local shape is required.");
   const shape = candidates[0];
-  if (shape.hasAttribute("Master") || shape.hasAttribute("MasterShape") || ["1", "true"].includes(attribute2(shape, "Del") ?? "") || children(shape, "Shapes").length || children(shape, "ForeignData").length || children(shape, "Rel").length || attribute2(shape, "Type") && attribute2(shape, "Type") !== "Shape")
+  if ((shape.hasAttribute("Master") || shape.hasAttribute("MasterShape")) && !["PinX", "PinY"].every((name) => {
+    const cell = cells(shape).get(name);
+    return cell && masterMovePins.has(cell);
+  }) || ["1", "true"].includes(attribute2(shape, "Del") ?? "") || children(shape, "Shapes").length || children(shape, "ForeignData").length || children(shape, "Rel").length || attribute2(shape, "Type") && attribute2(shape, "Type") !== "Shape")
     fail(
       "UNSUPPORTED_GEOMETRY_EDIT",
       "Master, group, foreign, deleted and non-shape operations are unsupported."
@@ -6362,12 +6365,17 @@ function admitted(root, shapeId) {
       "UNSUPPORTED_GEOMETRY_EDIT",
       "Only local 2D shapes are admitted; line routing and glue are unsupported."
     );
-  if (!(numeric3(local.get("Width")) > 0) || !(numeric3(local.get("Height")) > 0))
-    fail("UNSUPPORTED_GEOMETRY_EDIT", "Positive local Width and Height caches are required.");
+  const proven = masterDimensions.get(shape);
+  if (!(numeric3(local.get("Width"), proven?.width) > 0) || !(numeric3(local.get("Height"), proven?.height) > 0))
+    fail("UNSUPPORTED_GEOMETRY_EDIT", "Positive proven Width and Height caches are required.");
   return shape;
 }
-function protectedShape(shape, document) {
+function protectedShape(shape, document, masterMovePins = /* @__PURE__ */ new Set()) {
   const local = cells(shape);
+  const certifiedMove = shape.hasAttribute("Master") && ["PinX", "PinY"].every((name) => {
+    const node = local.get(name);
+    return node !== void 0 && masterMovePins.has(node);
+  });
   const styles = /* @__PURE__ */ new Map();
   for (const container of children(document, "StyleSheets"))
     for (const node of children(container, "StyleSheet")) {
@@ -6375,9 +6383,13 @@ function protectedShape(shape, document) {
       if (!id || styles.has(id)) fail("EDIT_PROTECTED_CELL", "Ambiguous protection style IDs.");
       styles.set(id, node);
     }
-  const inactive = (cell) => {
+  const validateProtection = (cell) => {
     try {
-      if (cell.hasAttribute("E") || visioFormulaCachedValue(attribute2(cell, "V") ?? "", attribute2(cell, "U")).unit !== "scalar" || numeric3(cell) !== 0)
+      const cached2 = numeric3(cell);
+      const operationIndependent = certifiedMove && ["LockWidth", "LockHeight", "LockAspect", "LockDelete"].includes(
+        attribute2(cell, "N") ?? ""
+      );
+      if (cell.hasAttribute("E") || visioFormulaCachedValue(attribute2(cell, "V") ?? "", attribute2(cell, "U")).unit !== "scalar" || !(cached2 === 0 || operationIndependent && cached2 === 1))
         fail("EDIT_PROTECTED_CELL", "Inherited protection is active or invalid.");
       const source = executableCellFormula(attribute2(cell, "F"));
       if (!source) return;
@@ -6388,12 +6400,12 @@ function protectedShape(shape, document) {
         source,
         () => fail("EDIT_PROTECTED_CELL", "Inherited protection has dependencies.")
       );
-      if (result.unit !== "scalar" || result.value !== 0)
-        fail("EDIT_PROTECTED_CELL", "Inherited protection formula is active or stale.");
+      if (result.unit !== "scalar" || result.value !== cached2)
+        fail("EDIT_PROTECTED_CELL", "Inherited protection formula cache is stale.");
     } catch (error) {
       fail(
         "EDIT_PROTECTED_CELL",
-        `Inherited protection cannot be proven inactive: ${error instanceof Error ? error.message : "invalid cache"}`
+        `Inherited protection cannot be proven safe for this operation: ${error instanceof Error ? error.message : "invalid cache"}`
       );
     }
   };
@@ -6405,16 +6417,18 @@ function protectedShape(shape, document) {
     if (!style) fail("EDIT_PROTECTED_CELL", "Protection style ancestry cannot be resolved.");
     const cell = cells(style).get(lock), parent = attribute2(style, category);
     if (cell && attribute2(cell, "F") !== "Inh") {
-      inactive(cell);
+      validateProtection(cell);
       return cell;
     }
     if (cell) {
-      inactive(cell);
+      validateProtection(cell);
       if (parent === void 0 || parent === id)
         fail("EDIT_PROTECTED_CELL", "Inherited protection has no provable parent.");
       const inherited = resolve(parent, category, lock, seen);
       if (!inherited)
-        fail("EDIT_PROTECTED_CELL", "Inherited protection has no explicit inactive ancestor.");
+        fail("EDIT_PROTECTED_CELL", "Inherited protection has no explicit provable ancestor.");
+      if (numeric3(cell) !== numeric3(inherited))
+        fail("EDIT_PROTECTED_CELL", "Delegated protection cache disagrees with its ancestor.");
       return inherited;
     }
     return parent !== void 0 && parent !== id ? resolve(parent, category, lock, seen) : void 0;
@@ -6491,6 +6505,130 @@ function resizeGeometry(shape, roots, edit, check) {
   }
 }
 
+// src/visio/edit-master-move.ts
+var protection = [
+  "LockMoveX",
+  "LockMoveY",
+  "LockWidth",
+  "LockHeight",
+  "LockAspect",
+  "LockDelete"
+];
+var dimensions2 = ["PinX", "PinY", "Width", "Height", "LocPinX", "LocPinY"];
+var emptyMasterMoveProof = () => ({
+  pins: /* @__PURE__ */ new Set(),
+  dimensions: /* @__PURE__ */ new Map()
+});
+function prepareMasterMovePins(roots, commands, bindings, check) {
+  const result = /* @__PURE__ */ new Set();
+  const provenDimensions = /* @__PURE__ */ new Map();
+  let work = 1e5;
+  const charge = (amount = 1) => {
+    check();
+    work -= amount;
+    if (work < 0)
+      fail("EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY", "Master move preparation budget exceeded.");
+  };
+  const analyze = (formula) => {
+    charge(formula.length);
+    return analyzeVisioFormula(formula);
+  };
+  for (const command2 of commands) {
+    charge();
+    const root = roots.get(command2.pageId);
+    const instance = children(children(root, "Shapes")[0], "Shape").find(
+      (shape) => attribute2(shape, "ID") === command2.shapeId
+    );
+    if (!instance?.hasAttribute("Master")) continue;
+    if (command2.type !== "move-shape")
+      fail("UNSUPPORTED_GEOMETRY_EDIT", "Master-linked resizing and deletion remain unsupported.");
+    const binding = bindings.find((candidate) => candidate.instance === instance);
+    if (!binding) fail("UNSUPPORTED_GEOMETRY_EDIT", "A unique effective master root is required.");
+    for (const node of [instance, binding.template]) {
+      charge();
+      if (attribute2(node, "Type") !== "Shape" || children(node, "Shapes").length || children(node, "ForeignData").length || children(node, "Rel").length || ["1", "true"].includes(attribute2(node, "Del") ?? ""))
+        fail("UNSUPPORTED_GEOMETRY_EDIT", "Master moves require top-level local 2D shape roots.");
+    }
+    for (const name of ["BeginX", "BeginY", "EndX", "EndY"])
+      if (binding.cells.has(name.toLowerCase()))
+        fail("UNSUPPORTED_GEOMETRY_EDIT", "Master lines and endpoint routing remain unsupported.");
+    const oneD = binding.cells.get("oned")?.node;
+    charge();
+    if (oneD && (numeric3(oneD) !== 0 || visioFormulaCachedValue(attribute2(oneD, "V") ?? "", attribute2(oneD, "U")).unit !== "scalar" || executableCellFormula(attribute2(oneD, "F"))))
+      fail("UNSUPPORTED_GEOMETRY_EDIT", "A static effective 2D master is required.");
+    const local = cells(instance);
+    for (const name of dimensions2) {
+      const effective = binding.cells.get(name.toLowerCase())?.node;
+      for (const node of /* @__PURE__ */ new Set([effective, ...local.has(name) ? [local.get(name)] : []])) {
+        charge();
+        numeric3(node);
+        if (visioFormulaCachedValue("0", attribute2(node, "U") ?? "DL").unit !== "length")
+          fail("EDIT_FORMULA_UNIT", "Master transform caches require length units.");
+      }
+    }
+    const dimension = (name) => numeric3(local.get(name) ?? binding.cells.get(name.toLowerCase())?.node);
+    const width = dimension("Width"), height = dimension("Height");
+    if (width <= 0 || height <= 0)
+      fail("UNSUPPORTED_GEOMETRY_EDIT", "Positive proven effective dimensions are required.");
+    provenDimensions.set(instance, { width, height });
+    for (const name of protection) {
+      charge();
+      const node = binding.cells.get(name.toLowerCase())?.node;
+      const cached2 = node ? numeric3(node) : NaN;
+      const moving = name === "LockMoveX" || name === "LockMoveY";
+      if (!node || visioFormulaCachedValue(attribute2(node, "V") ?? "", attribute2(node, "U")).unit !== "scalar" || ![0, 1].includes(cached2) || moving && cached2 !== 0)
+        fail(
+          "EDIT_PROTECTED_CELL",
+          "Effective master protection must be proven boolean with inactive movement locks."
+        );
+      const formula = executableCellFormula(attribute2(node, "F"));
+      if (formula) {
+        const analysis = analyze(formula);
+        if (analysis.dynamic || analysis.references.length || analysis.unsupportedFunctions.length)
+          fail("EDIT_PROTECTED_CELL", "Effective master protection dependencies are unsupported.");
+        const value = evaluateVisioFormula(
+          formula,
+          () => fail("EDIT_PROTECTED_CELL", "Unexpected protection dependency."),
+          { onStep: () => charge() }
+        );
+        if (value.unit !== "scalar" || value.value !== cached2)
+          fail("EDIT_PROTECTED_CELL", "Effective master protection cache is stale.");
+      }
+    }
+    for (const name of ["PinX", "PinY"]) {
+      charge();
+      const node = local.get(name);
+      if (!node)
+        fail("EDIT_PROTECTED_CELL", "The rotation pin must be an explicit local override.");
+      if (binding.cells.get(name.toLowerCase())?.node !== node)
+        fail("EDIT_PROTECTED_CELL", "The rotation pin must be an explicit local override.");
+      charge(executableCellFormula(attribute2(node, "F"))?.length ?? 0);
+      editableCell(node);
+      const inherited = binding.inheritedCells.get(name.toLowerCase())?.node;
+      numeric3(inherited);
+      if (visioFormulaCachedValue("0", attribute2(inherited, "U") ?? "DL").unit !== "length")
+        fail("EDIT_FORMULA_UNIT", "Inherited rotation pins require length units.");
+      const formula = executableCellFormula(attribute2(inherited, "F"));
+      if (formula) {
+        const analysis = analyze(formula);
+        if (analysis.guarded || analysis.dynamic || analysis.unsupportedFunctions.length)
+          fail("EDIT_PROTECTED_CELL", "Protected or redirected master pins cannot be overridden.");
+      }
+      result.add(node);
+    }
+  }
+  if (result.size) {
+    const indexed = indexCells(roots, { check });
+    const pins = new Set(
+      [...indexed.values()].filter((cell) => cell.node && result.has(cell.node)).map(key)
+    );
+    for (const cell of indexed.values())
+      if (charge(), cell.dependencies.some((dependency) => pins.has(dependency)))
+        fail("EDIT_UNSUPPORTED_DEPENDENCY", "A page cache depends on a master rotation pin.");
+  }
+  return { pins: result, dimensions: provenDimensions };
+}
+
 // src/visio/edit-geometry.ts
 function createRectangle(root, edit) {
   const doc = root.ownerDocument;
@@ -6553,7 +6691,8 @@ function createRectangle(root, edit) {
   container.appendChild(shape);
   return shape;
 }
-function applyGeometryEdit(roots, document, edit, check) {
+function applyGeometryEdit(roots, document, edit, check, masterMoveProof = emptyMasterMoveProof()) {
+  const masterMovePins = masterMoveProof.pins, masterDimensions = masterMoveProof.dimensions;
   check();
   const root = roots.get(edit.pageId);
   if (!root) fail("EDIT_TARGET_NOT_FOUND", "Page does not exist.");
@@ -6565,8 +6704,13 @@ function applyGeometryEdit(roots, document, edit, check) {
     expected = { width: edit.width, height: edit.height, x: edit.x, y: edit.y };
     for (const name of ["Width", "Height", "PinX", "PinY"]) add(name);
   } else {
-    const shape = admitted(root, edit.shapeId);
-    protectedShape(shape, document);
+    const shape = admitted(
+      root,
+      edit.shapeId,
+      edit.type === "move-shape" ? masterMovePins : /* @__PURE__ */ new Set(),
+      edit.type === "move-shape" ? masterDimensions : /* @__PURE__ */ new Map()
+    );
+    protectedShape(shape, document, edit.type === "move-shape" ? masterMovePins : /* @__PURE__ */ new Set());
     if (edit.type !== "delete-shape") {
       for (const connections2 of children(root, "Connects"))
         for (const connection of children(connections2, "Connect"))
@@ -6588,9 +6732,10 @@ function applyGeometryEdit(roots, document, edit, check) {
       return [edit.pageId];
     }
     if (edit.type === "move-shape") {
+      const proven = masterDimensions.get(shape);
       expected = {
-        width: numeric3(local.get("Width")),
-        height: numeric3(local.get("Height")),
+        width: numeric3(local.get("Width"), proven?.width),
+        height: numeric3(local.get("Height"), proven?.height),
         x: edit.x,
         y: edit.y
       };
@@ -6598,10 +6743,7 @@ function applyGeometryEdit(roots, document, edit, check) {
         ["PinX", edit.x, "LockMoveX"],
         ["PinY", edit.y, "LockMoveY"]
       ]) {
-        if (numeric3(
-          local.get(name),
-          name === "PinX" ? numeric3(local.get("Width")) / 2 : numeric3(local.get("Height")) / 2
-        ) === value)
+        if (numeric3(local.get(name), name === "PinX" ? expected.width / 2 : expected.height / 2) === value)
           continue;
         unlocked(lock);
         editableCell(local.get(name));
@@ -6643,9 +6785,15 @@ function applyGeometryEdit(roots, document, edit, check) {
     }
   }
   if (!changed.length) return [];
-  const affectedPages = recalculateVisioCells(roots, changed, { check });
-  const result = cells(admitted(root, edit.shapeId));
-  if (expected && (numeric3(result.get("Width")) !== expected.width || numeric3(result.get("Height")) !== expected.height || numeric3(result.get("PinX"), expected.width / 2) !== expected.x || numeric3(result.get("PinY"), expected.height / 2) !== expected.y))
+  const affectedPages = recalculateVisioCells(roots, changed, { check, masterMovePins });
+  const resultShape = admitted(
+    root,
+    edit.shapeId,
+    edit.type === "move-shape" ? masterMovePins : /* @__PURE__ */ new Set(),
+    edit.type === "move-shape" ? masterDimensions : /* @__PURE__ */ new Map()
+  );
+  const result = cells(resultShape), provenResult = masterDimensions.get(resultShape);
+  if (expected && (numeric3(result.get("Width"), provenResult?.width) !== expected.width || numeric3(result.get("Height"), provenResult?.height) !== expected.height || numeric3(result.get("PinX"), expected.width / 2) !== expected.x || numeric3(result.get("PinY"), expected.height / 2) !== expected.y))
     fail(
       "EDIT_UNSUPPORTED_DEPENDENCY",
       "Dependent formulas would violate the requested geometry or fixed rotation pin."
@@ -6693,6 +6841,28 @@ function analyzeVisioMasterFormula(source, options) {
 }
 
 // src/visio/edit-master-index.ts
+function inheritedProtection(node, ancestor) {
+  try {
+    const boolean2 = (cell) => {
+      if (!cell || cell.hasAttribute("E"))
+        fail("EDIT_PROTECTED_CELL", "Inherited protection has an unresolved or error cache.");
+      const value = visioFormulaCachedValue(attribute2(cell, "V") ?? "", attribute2(cell, "U"));
+      if (value.unit !== "scalar" || ![0, 1].includes(value.value))
+        fail("EDIT_PROTECTED_CELL", "Inherited protection requires scalar boolean caches.");
+      return value.value;
+    };
+    if (boolean2(node) !== boolean2(ancestor))
+      fail(
+        "EDIT_PROTECTED_CELL",
+        "Delegated master style protection cache disagrees with its ancestor."
+      );
+  } catch (error) {
+    fail(
+      "EDIT_PROTECTED_CELL",
+      `Inherited master style protection cannot be proven: ${error instanceof Error ? error.message : "invalid cache"}`
+    );
+  }
+}
 function masterCells(sheet, charge = () => {
 }) {
   const result = /* @__PURE__ */ new Map();
@@ -6750,7 +6920,7 @@ function assertMasterMarkup(root, known, check) {
   }
 }
 function masterStyleCells(document, template, instance, check, charge = () => {
-}) {
+}, verifyMovementProtection = false) {
   const styles = /* @__PURE__ */ new Map();
   for (const container of children(document, "StyleSheets"))
     for (const style of children(container, "StyleSheet")) {
@@ -6775,6 +6945,10 @@ function masterStyleCells(document, template, instance, check, charge = () => {
     for (const [name, node] of own) {
       charge();
       if (attribute2(node, "F") !== "Inh") result2.set(name, node);
+      else if (verifyMovementProtection && /^lock(move[xy]|width|height|aspect|delete)$/.test(name)) {
+        charge();
+        inheritedProtection(node, result2.get(name));
+      }
     }
     return result2;
   };
@@ -6846,12 +7020,20 @@ async function assertVisioMasterIndependence(pkg, roots, commands, check) {
   const instances = [...roots].flatMap(
     ([pageId, root]) => masterShapes(root).filter((shape) => shape.hasAttribute("Master")).map((instance) => ({ pageId, instance }))
   );
-  if (!instances.length) return;
+  if (!instances.length) return emptyMasterMoveProof();
   const documentPart = await related(pkg, "", "document");
   if (!documentPart) problem("Missing master document relationship.");
   const document = await visioXml(pkg, documentPart, "VisioDocument");
   const mastersPart = await related(pkg, documentPart, "masters", false);
-  if (!mastersPart) problem("Active master definitions are missing.");
+  if (!mastersPart) {
+    if (commands.some(
+      (command2) => instances.some(
+        (item) => item.pageId === command2.pageId && attribute2(item.instance, "ID") === command2.shapeId
+      )
+    ))
+      fail("UNSUPPORTED_GEOMETRY_EDIT", "Active master definitions are missing.");
+    problem("Active master definitions are missing.");
+  }
   const definitions = /* @__PURE__ */ new Map();
   for (const node of children(await visioXml(pkg, mastersPart, "Masters"), "Master")) {
     const id = attribute2(node, "ID");
@@ -6866,6 +7048,12 @@ async function assertVisioMasterIndependence(pkg, roots, commands, check) {
     if (--buildWork < 0) problem("Master effective-cell construction budget exceeded.");
   };
   const pageBindings = /* @__PURE__ */ new Map();
+  const movingTargets = /* @__PURE__ */ new Set();
+  for (const command2 of commands) {
+    charge();
+    if (command2.type === "move-shape")
+      movingTargets.add(JSON.stringify([command2.pageId, command2.shapeId]));
+  }
   const pageShapes = /* @__PURE__ */ new Map();
   for (const [pageId, root] of roots)
     for (const shape of masterShapes(root)) {
@@ -6925,15 +7113,25 @@ async function assertVisioMasterIndependence(pkg, roots, commands, check) {
       const templateId = attribute2(template, "ID");
       if (!templateId || context.has(templateId)) problem("Master-local sheet IDs are ambiguous.");
       const local = byTemplate.get(templateId), cells3 = /* @__PURE__ */ new Map();
-      for (const [name, node] of masterStyleCells(document, template, local, check, charge))
+      const movedInstance = local === instance && movingTargets.has(JSON.stringify([pageId, attribute2(local, "ID")]));
+      for (const [name, node] of masterStyleCells(
+        document,
+        template,
+        local,
+        check,
+        charge,
+        movedInstance
+      ))
         cells3.set(name, { node, kind: "style" });
       overlay(cells3, masterCells(template, charge), "template", charge);
+      const inheritedCells = new Map(cells3);
       overlay(cells3, masterCells(local, charge), "instance", charge);
       const binding = {
         id: `${pageId}:${attribute2(instance, "ID")}:${templateId}`,
         pageId,
         template,
         cells: cells3,
+        inheritedCells,
         context,
         ...local ? { instance: local } : {}
       };
@@ -6944,6 +7142,7 @@ async function assertVisioMasterIndependence(pkg, roots, commands, check) {
     for (const id of byTemplate.keys())
       if (!context.has(id)) problem("MasterShape refers to a missing template.");
   }
+  const movePins = prepareMasterMovePins(roots, commands, bindings, check);
   const changed = commands.flatMap(
     (command2) => command2.type === "delete-shape" ? [] : (command2.type === "move-shape" ? ["PinX", "PinY"] : command2.type === "resize-shape" ? ["Width", "Height"] : ["Width", "Height", "PinX", "PinY"]).map((cell) => ({ pageId: command2.pageId, shapeId: command2.shapeId, cell }))
   );
@@ -6971,6 +7170,7 @@ async function assertVisioMasterIndependence(pkg, roots, commands, check) {
       template: shape,
       instance: shape,
       cells: cells3,
+      inheritedCells: /* @__PURE__ */ new Map(),
       context: /* @__PURE__ */ new Map()
     };
     pageInputs.set(id, result);
@@ -7048,7 +7248,14 @@ async function assertVisioMasterIndependence(pkg, roots, commands, check) {
     active.delete(id);
     done.add(id);
   };
-  for (const binding of bindings) for (const name of binding.cells.keys()) inspect2(binding, name);
+  for (const binding of bindings)
+    for (const name of binding.cells.keys()) {
+      const source = binding.cells.get(name);
+      if (["pinx", "piny"].includes(name) && source?.kind === "instance" && movePins.pins.has(source.node))
+        continue;
+      inspect2(binding, name);
+    }
+  return movePins;
 }
 
 // src/visio/edit-scope.ts
@@ -7168,6 +7375,7 @@ async function assertGeometryPackageScope(pkg, pagePaths, commands, check, roots
           });
     }
   }
+  let movePins = emptyMasterMoveProof();
   if (hasMasterInstances) {
     for (const command2 of commands) {
       const root = roots.get(command2.pageId);
@@ -7175,12 +7383,16 @@ async function assertGeometryPackageScope(pkg, pagePaths, commands, check, roots
       const target = Array.from(root.getElementsByTagNameNS(root.namespaceURI, "Shape")).find(
         (shape) => attribute2(shape, "ID") === command2.shapeId
       );
-      if (target?.hasAttribute("Master") || target?.hasAttribute("MasterShape"))
+      if (target?.hasAttribute("MasterShape") && !target.hasAttribute("Master"))
         fail("UNSUPPORTED_GEOMETRY_EDIT", "Editing master-linked shapes is unsupported.");
+      if (target?.hasAttribute("Master") && (command2.type !== "move-shape" || !["PinX", "PinY"].every(
+        (name) => children(target, "Cell").some((node) => attribute2(node, "N") === name)
+      )))
+        fail("UNSUPPORTED_GEOMETRY_EDIT", "Master moves require explicit local rotation pins.");
     }
-    await assertVisioMasterIndependence(pkg, roots, commands, check);
+    movePins = await assertVisioMasterIndependence(pkg, roots, commands, check);
   }
-  if (!documentRoot) return;
+  if (!documentRoot) return movePins;
   const styles = /* @__PURE__ */ new Map();
   for (const container of children(documentRoot, "StyleSheets"))
     for (const style of children(container, "StyleSheet")) {
@@ -7245,6 +7457,7 @@ async function assertGeometryPackageScope(pkg, pagePaths, commands, check, roots
       }
     }
   }
+  return movePins;
 }
 
 // src/visio/edit.ts
@@ -7272,12 +7485,13 @@ async function editVsdx(input, edits, options = {}) {
   const roots = /* @__PURE__ */ new Map();
   const geometry = commands.some((command2) => command2.type !== "replace-plain-text");
   let document;
+  let masterMovePins = emptyMasterMoveProof();
   if (geometry) {
     for (const [pageId, path2] of pages) {
       const sourceRoot = await visioXml(pkg, path2, "PageContents");
       roots.set(pageId, sourceRoot.ownerDocument.cloneNode(true).documentElement);
     }
-    await assertGeometryPackageScope(
+    masterMovePins = await assertGeometryPackageScope(
       pkg,
       new Set(pages.values()),
       commands.filter((command2) => command2.type !== "replace-plain-text"),
@@ -7304,7 +7518,7 @@ async function editVsdx(input, edits, options = {}) {
         textChanged = true;
       }
     } else {
-      for (const pageId of applyGeometryEdit(roots, document, command2, check))
+      for (const pageId of applyGeometryEdit(roots, document, command2, check, masterMovePins))
         dirty.set(pages.get(pageId), roots.get(pageId));
     }
   }