ooxml-core 0.9.0 → 0.11.0

package/dist/visio/index.cjs

@@ -4356,6 +4356,8 @@ function isSafeHyperlinkHref(href) {
   const scheme = /^([a-z][a-z0-9+.-]*:)/i.exec(href.trim())?.[1];
   return scheme !== void 0 && SAFE_SCHEMES.has(scheme.toLowerCase());
 }
+var OPEN_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto"]);
+/* @__PURE__ */ new Set([...OPEN_SCHEMES, "ftp", "file"]);
 
 // src/visio/shape-metadata.ts
 function createMetadataBudget(options = {}) {
@@ -4971,16 +4973,16 @@ async function parseVsdx(input, options = {}) {
       const id = metadata(attribute2(master, "ID") ?? "", 256, "Master ID");
       if (!id || masters.has(id))
         throw new VisioPackageError("INVALID_MASTER_ID", "Master IDs must be present and unique.");
-      const masterShapes = readShapes(await visioXml(pkg, part, "MasterContents"));
+      const masterShapes2 = readShapes(await visioXml(pkg, part, "MasterContents"));
       await prepareImages(
-        masterShapes,
+        masterShapes2,
         pkg,
         part,
         report,
         options.images,
         options.metafileConverter
       );
-      masters.set(id, masterShapes);
+      masters.set(id, masterShapes2);
     }
   }
   let geometryCount = 0, textCount = 0, expansionCount = 0, textRuns = 0, paragraphCount = 0;
@@ -5496,6 +5498,105 @@ var themeInputs = [
   "QuickStyleVariation"
 ];
 
+// src/visio/formula-arithmetic.ts
+function finiteFormulaValue(value) {
+  if (!Number.isFinite(value.value)) return formulaFailure("value", "Formula result is not finite");
+  if (!["scalar", "length", "area", "angle", "time"].includes(value.unit))
+    return formulaFailure("unit", "Unknown resolved unit");
+  return value;
+}
+function compatibleFormulaUnits(a, b) {
+  if (a.unit === b.unit) return a.unit;
+  if (a.unit === "scalar" && a.value === 0) return b.unit;
+  if (b.unit === "scalar" && b.value === 0) return a.unit;
+  return formulaFailure("unit", `Incompatible units ${a.unit} and ${b.unit}`);
+}
+var lengthPower = (unit) => unit === "scalar" ? 0 : unit === "length" ? 1 : unit === "area" ? 2 : void 0;
+function fromPower(power) {
+  if (power === 0) return "scalar";
+  if (power === 1) return "length";
+  if (power === 2) return "area";
+  return formulaFailure("unit", "Unsupported dimensional power");
+}
+function formulaProductUnit(a, b) {
+  if (a === "scalar") return b;
+  if (b === "scalar") return a;
+  const left = lengthPower(a), right = lengthPower(b);
+  if (left === void 0 || right === void 0)
+    return formulaFailure("unit", "Mixed dimensions are unsupported");
+  return fromPower(left + right);
+}
+function formulaQuotientUnit(a, b) {
+  if (b === "scalar") return a;
+  if (a === b) return "scalar";
+  const left = lengthPower(a), right = lengthPower(b);
+  if (left === void 0 || right === void 0)
+    return formulaFailure("unit", "Mixed dimensions are unsupported");
+  return fromPower(left - right);
+}
+function formulaExponentUnit(a, exponent) {
+  if (exponent.unit !== "scalar") return formulaFailure("unit", "Exponents must be scalar");
+  if (a === "scalar") return "scalar";
+  if (exponent.value === 0) return "scalar";
+  if (exponent.value === 1) return a;
+  const power = lengthPower(a);
+  if (power === void 0) return formulaFailure("unit", "Unsupported dimensional power");
+  return fromPower(power * exponent.value);
+}
+function formulaSquareRootUnit(unit) {
+  if (unit === "scalar") return "scalar";
+  if (unit === "area") return "length";
+  return formulaFailure("unit", "Square root requires scalar or square inches");
+}
+
+// src/visio/formula-numeric-functions.ts
+var numericFormulaFunctions = /* @__PURE__ */ new Set([
+  "AND",
+  "OR",
+  "NOT",
+  "BITAND",
+  "BITOR",
+  "BITXOR",
+  "MODULUS"
+]);
+function evaluateNumericFormulaFunction(name, args) {
+  const arity = (min, max = min) => {
+    if (args.length < min || args.length > max)
+      return formulaFailure("arity", `Invalid ${name} argument count`);
+  };
+  const scalar2 = (value) => ({ value, unit: "scalar" });
+  if (name === "AND" || name === "OR" || name === "NOT") {
+    arity(1, name === "NOT" ? 1 : 1024);
+    const values = args.map((arg) => finiteFormulaValue(arg).value !== 0);
+    return scalar2(
+      Number(
+        name === "AND" ? values.every(Boolean) : name === "OR" ? values.some(Boolean) : !values[0]
+      )
+    );
+  }
+  if (["BITAND", "BITOR", "BITXOR"].includes(name)) {
+    arity(2);
+    const values = args.map((arg) => {
+      if (arg.unit !== "scalar") return formulaFailure("unit", `${name} requires scalar bitmasks`);
+      if (!Number.isInteger(arg.value) || arg.value < 0 || arg.value > 65535)
+        return formulaFailure("value", `${name} requires an integer from 0 to 65535`);
+      return arg.value;
+    });
+    return scalar2(
+      name === "BITAND" ? values[0] & values[1] : name === "BITOR" ? values[0] | values[1] : values[0] ^ values[1]
+    );
+  }
+  if (name === "MODULUS") {
+    arity(2);
+    const dividend = finiteFormulaValue(args[0]), divisor = finiteFormulaValue(args[1]);
+    const unit = compatibleFormulaUnits(dividend, divisor);
+    if (divisor.value === 0) return formulaFailure("value", "MODULUS division by zero");
+    const remainder = dividend.value - Math.floor(dividend.value / divisor.value) * divisor.value;
+    return finiteFormulaValue({ value: remainder === 0 ? 0 : remainder, unit });
+  }
+  return formulaFailure("unsupported", `Unsupported numeric function ${name}`);
+}
+
 // src/visio/formula-evaluate.ts
 var supported = /* @__PURE__ */ new Set([
   "GUARD",
@@ -5509,7 +5610,8 @@ var supported = /* @__PURE__ */ new Set([
   "TAN",
   "ATAN2",
   "SIGN",
-  "PI"
+  "PI",
+  ...numericFormulaFunctions
 ]);
 var staticUnsupported = /* @__PURE__ */ new Set([
   "ROUND",
@@ -5541,7 +5643,9 @@ var staticUnsupported = /* @__PURE__ */ new Set([
   "BITXOR",
   "TINT",
   "MSOTINT",
-  "SHADE"
+  "SHADE",
+  "LUMDIFF",
+  "MODULUS"
 ]);
 var dynamic = /* @__PURE__ */ new Set([
   "INDIRECT",
@@ -5600,41 +5704,23 @@ function analyzeVisioFormula(source, limits = {}) {
     guarded
   };
 }
-function finite2(value) {
-  if (!Number.isFinite(value.value)) return formulaFailure("value", "Formula result is not finite");
-  if (!["scalar", "length", "angle", "time"].includes(value.unit))
-    return formulaFailure("unit", "Unknown resolved unit");
-  return value;
-}
-function compatible(a, b) {
-  if (a.unit === b.unit) return a.unit;
-  if (a.unit === "scalar" && a.value === 0) return b.unit;
-  if (b.unit === "scalar" && b.value === 0) return a.unit;
-  return formulaFailure("unit", `Incompatible units ${a.unit} and ${b.unit}`);
-}
 function binary(operator, a, b) {
   let unit;
   if (operator === "+" || operator === "-") {
-    unit = compatible(a, b);
-    return finite2({ value: operator === "+" ? a.value + b.value : a.value - b.value, unit });
+    unit = compatibleFormulaUnits(a, b);
+    return finiteFormulaValue({ value: operator === "+" ? a.value + b.value : a.value - b.value, unit });
   }
   if (operator === "*") {
-    if (a.unit !== "scalar" && b.unit !== "scalar")
-      return formulaFailure("unit", "Compound dimensions are unsupported");
-    return finite2({ value: a.value * b.value, unit: a.unit === "scalar" ? b.unit : a.unit });
+    return finiteFormulaValue({ value: a.value * b.value, unit: formulaProductUnit(a.unit, b.unit) });
   }
   if (operator === "/") {
     if (b.value === 0) return formulaFailure("value", "Division by zero");
-    if (b.unit !== "scalar" && a.unit !== b.unit)
-      return formulaFailure("unit", "Inverse dimensions are unsupported");
-    return finite2({ value: a.value / b.value, unit: a.unit === b.unit ? "scalar" : a.unit });
+    return finiteFormulaValue({ value: a.value / b.value, unit: formulaQuotientUnit(a.unit, b.unit) });
   }
   if (operator === "^") {
-    if (b.unit !== "scalar" || a.unit !== "scalar" && b.value !== 1 && b.value !== 0)
-      return formulaFailure("unit", "Dimensional powers are unsupported");
-    return finite2({ value: a.value ** b.value, unit: b.value === 0 ? "scalar" : a.unit });
+    return finiteFormulaValue({ value: a.value ** b.value, unit: formulaExponentUnit(a.unit, b) });
   }
-  compatible(a, b);
+  compatibleFormulaUnits(a, b);
   const comparisons = {
     "=": a.value === b.value,
     "<>": a.value !== b.value,
@@ -5658,13 +5744,13 @@ function evaluateVisioFormula(source, resolve, limits = {}) {
     if (++steps > maxSteps || depth > maxDepth)
       return formulaFailure("limit", "Formula evaluation limit");
     limits.onStep?.();
-    if (node.kind === "number") return finite2({ value: node.value, unit: node.unit });
+    if (node.kind === "number") return finiteFormulaValue({ value: node.value, unit: node.unit });
     if (node.kind === "string")
       return formulaFailure("value", "String results are outside the numeric formula subset");
-    if (node.kind === "reference") return finite2(resolve(node.reference));
+    if (node.kind === "reference") return finiteFormulaValue(resolve(node.reference));
     if (node.kind === "unary") {
       const result = evaluate(node.operand, depth + 1);
-      return finite2({
+      return finiteFormulaValue({
         value: node.operator === "-" ? -result.value : result.value,
         unit: result.unit
       });
@@ -5678,6 +5764,11 @@ function evaluateVisioFormula(source, resolve, limits = {}) {
         return formulaFailure("arity", `Invalid ${name} argument count`);
     };
     const arg = (index) => evaluate(node.args[index], depth + 1);
+    if (numericFormulaFunctions.has(name))
+      return evaluateNumericFormulaFunction(
+        name,
+        node.args.map((_, index) => arg(index))
+      );
     if (name === "PI") {
       arity(0);
       return { value: Math.PI, unit: "scalar" };
@@ -5697,18 +5788,18 @@ function evaluateVisioFormula(source, resolve, limits = {}) {
       const args = node.args.map((_, i) => arg(i));
       let result = args[0];
       for (const item of args.slice(1)) {
-        const unit = compatible(result, item);
+        const unit = compatibleFormulaUnits(result, item);
         result = {
           value: name === "MIN" ? Math.min(result.value, item.value) : Math.max(result.value, item.value),
           unit
         };
       }
-      return finite2(result);
+      return finiteFormulaValue(result);
     }
     if (name === "ATAN2") {
       arity(2);
       const y = arg(0), x = arg(1);
-      compatible(y, x);
+      compatibleFormulaUnits(y, x);
       return { value: Math.atan2(y.value, x.value), unit: "angle" };
     }
     if (name === "SIGN") {
@@ -5726,12 +5817,11 @@ function evaluateVisioFormula(source, resolve, limits = {}) {
     const value = arg(0);
     if (name === "ABS") return { value: Math.abs(value.value), unit: value.unit };
     if (name === "SQRT") {
-      if (value.unit !== "scalar") return formulaFailure("unit", "Dimensional SQRT unsupported");
-      return finite2({ value: Math.sqrt(value.value), unit: "scalar" });
+      return finiteFormulaValue({ value: Math.sqrt(value.value), unit: formulaSquareRootUnit(value.unit) });
     }
     if (value.unit !== "angle" && value.unit !== "scalar")
       return formulaFailure("unit", `${name} requires radians`);
-    return finite2({
+    return finiteFormulaValue({
       value: name === "SIN" ? Math.sin(value.value) : name === "COS" ? Math.cos(value.value) : Math.tan(value.value),
       unit: "scalar"
     });
@@ -6093,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."
@@ -6246,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()) {
   const containers = children(root, "Shapes");
   if (containers.length !== 1)
     fail("UNSUPPORTED_GEOMETRY_EDIT", "One local Shapes container is required.");
@@ -6256,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."
@@ -6463,7 +6556,7 @@ function createRectangle(root, edit) {
   container.appendChild(shape);
   return shape;
 }
-function applyGeometryEdit(roots, document, edit, check) {
+function applyGeometryEdit(roots, document, edit, check, masterMovePins = /* @__PURE__ */ new Set()) {
   check();
   const root = roots.get(edit.pageId);
   if (!root) fail("EDIT_TARGET_NOT_FOUND", "Page does not exist.");
@@ -6475,7 +6568,11 @@ 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);
+    const shape = admitted(
+      root,
+      edit.shapeId,
+      edit.type === "move-shape" ? masterMovePins : /* @__PURE__ */ new Set()
+    );
     protectedShape(shape, document);
     if (edit.type !== "delete-shape") {
       for (const connections2 of children(root, "Connects"))
@@ -6553,8 +6650,10 @@ function applyGeometryEdit(roots, document, edit, check) {
     }
   }
   if (!changed.length) return [];
-  const affectedPages = recalculateVisioCells(roots, changed, { check });
-  const result = cells(admitted(root, edit.shapeId));
+  const affectedPages = recalculateVisioCells(roots, changed, { check, masterMovePins });
+  const result = cells(
+    admitted(root, edit.shapeId, edit.type === "move-shape" ? masterMovePins : /* @__PURE__ */ new Set())
+  );
   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))
     fail(
       "EDIT_UNSUPPORTED_DEPENDENCY",
@@ -6563,6 +6662,525 @@ function applyGeometryEdit(roots, document, edit, check) {
   return [.../* @__PURE__ */ new Set([edit.pageId, ...affectedPages])];
 }
 
+// src/visio/formula-master.ts
+function analyzeVisioMasterFormula(source, options) {
+  const ast = parseVisioFormula(source);
+  const analysis = analyzeVisioFormula(ast);
+  const references = /* @__PURE__ */ new Map();
+  for (const ref of analysis.references)
+    references.set(`${ref.shapeId ?? ""}!${ref.cell.toLowerCase()}`, ref);
+  let dynamic2 = false, readsText = false, readsTheme = false;
+  const queue = [ast];
+  while (queue.length) {
+    const node = queue.pop();
+    if (node.kind === "unary") queue.push(node.operand);
+    if (node.kind === "binary") queue.push(node.left, node.right);
+    if (node.kind !== "call") continue;
+    queue.push(...node.args);
+    if (["THEME", "THEMEVAL", "ISTHEMED"].includes(node.name)) readsTheme = true;
+    let local = !analyzeVisioFormula({ kind: "call", name: node.name, args: [] }).dynamic;
+    if (node.name === "SETATREF")
+      local = node.args.length === 1 && node.args[0].kind === "reference";
+    if (["TEXTWIDTH", "TEXTHEIGHT", "SHAPETEXT"].includes(node.name)) {
+      const text = node.args[0];
+      const count = node.name === "TEXTHEIGHT" ? node.args.length === 2 : node.args.length === 1;
+      local = options.textFieldFree && count && text?.kind === "reference" && text.reference.shapeId === void 0 && text.reference.cell.toLowerCase() === "thetext";
+      readsText = true;
+    }
+    if (["LUM", "HUE", "SAT"].includes(node.name)) {
+      local = node.args.length === 1;
+      const arg = node.args[0];
+      if (arg?.kind === "string") {
+        local = /^[A-Za-z_][A-Za-z0-9_.]*$/.test(arg.value);
+        if (local) references.set(`!${arg.value.toLowerCase()}`, { cell: arg.value });
+      }
+    }
+    if (node.name === "STRSAME") local = node.args.length === 2;
+    if (!local) dynamic2 = true;
+  }
+  return { ...analysis, references: [...references.values()], dynamic: dynamic2, readsText, readsTheme };
+}
+
+// src/visio/edit-master-move.ts
+var protection = [
+  "LockMoveX",
+  "LockMoveY",
+  "LockWidth",
+  "LockHeight",
+  "LockAspect",
+  "LockDelete"
+];
+var dimensions2 = ["PinX", "PinY", "Width", "Height", "LocPinX", "LocPinY"];
+function prepareMasterMovePins(roots, commands, bindings, check) {
+  const result = /* @__PURE__ */ new Set();
+  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) {
+      charge();
+      const node = local.get(name);
+      numeric3(node);
+      if (visioFormulaCachedValue("0", attribute2(node, "U") ?? "DL").unit !== "length")
+        fail("EDIT_FORMULA_UNIT", "Master transform caches require length units.");
+    }
+    if (numeric3(local.get("Width")) <= 0 || numeric3(local.get("Height")) <= 0)
+      fail("UNSUPPORTED_GEOMETRY_EDIT", "Positive explicit local dimensions are required.");
+    for (const name of protection) {
+      charge();
+      const node = binding.cells.get(name.toLowerCase())?.node;
+      if (!node || visioFormulaCachedValue(attribute2(node, "V") ?? "", attribute2(node, "U")).unit !== "scalar" || numeric3(node) !== 0)
+        fail(
+          "EDIT_PROTECTED_CELL",
+          "Effective master protection must be explicitly proven inactive."
+        );
+      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 !== 0)
+          fail("EDIT_PROTECTED_CELL", "Effective master protection is active or stale.");
+      }
+    }
+    for (const name of ["PinX", "PinY"]) {
+      charge();
+      const node = local.get(name);
+      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 result;
+}
+
+// src/visio/edit-master-index.ts
+function masterCells(sheet, charge = () => {
+}) {
+  const result = /* @__PURE__ */ new Map();
+  if (!sheet) return result;
+  const add = (name, node) => {
+    charge();
+    const id = name.toLowerCase();
+    if (result.has(id) && result.get(id) !== node)
+      fail("EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY", "Ambiguous effective master cells.");
+    result.set(id, node);
+  };
+  for (const node of children(sheet, "Cell")) add(attribute2(node, "N") ?? "", node);
+  for (const section of children(sheet, "Section")) {
+    const name = attribute2(section, "N") ?? "";
+    const prefix = name === "Geometry" ? `Geometry${Number(attribute2(section, "IX") ?? "0") + 1}` : name === "Control" ? "Controls" : name;
+    for (const node of children(section, "Cell"))
+      add(`${prefix}.${attribute2(node, "N") ?? ""}`, node);
+    for (const row of children(section, "Row"))
+      for (const node of children(row, "Cell")) {
+        const n = attribute2(node, "N") ?? "";
+        const rowName = attribute2(row, "N");
+        const index = attribute2(row, "IX") ?? (prefix === "Controls" && /^Row_\d+$/.test(rowName ?? "") ? String(Number(rowName.slice(4)) - 1) : void 0);
+        const ix = index ?? "0", r = rowName ?? (prefix === "Controls" ? `Row_${Number(ix) + 1}` : ix);
+        add(
+          name === "Geometry" || ["Controls", "Scratch", "Connection"].includes(prefix) ? `${prefix}.${n}${ix}` : n === "Value" && ["User", "Prop"].includes(name) ? `${prefix}.${r}` : `${prefix}.${r}.${n}`,
+          node
+        );
+        if (name !== "Geometry") add(`${prefix}.${r}.${n}`, node);
+        if (prefix === "Controls" && n === "X") add(`${prefix}.${r}`, node);
+        if (name !== "Geometry" && index !== void 0) add(`${prefix}.$row${ix}.${n}`, node);
+      }
+  }
+  return result;
+}
+function masterShapes(root) {
+  const result = [], pending = [root];
+  while (pending.length) {
+    const parent = pending.pop();
+    for (const container of children(parent, "Shapes"))
+      for (const shape of children(container, "Shape")) {
+        result.push(shape);
+        pending.push(shape);
+      }
+  }
+  return result;
+}
+function assertMasterMarkup(root, known, check) {
+  for (const node of [root, ...Array.from(root.getElementsByTagName("*"))]) {
+    check();
+    if (node.namespaceURI === root.namespaceURI && node.hasAttribute("F") && !known.has(node))
+      fail(
+        "EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY",
+        "Master formula outside admitted sheet cells has unknown scope."
+      );
+  }
+}
+function masterStyleCells(document, template, instance, check, charge = () => {
+}) {
+  const styles = /* @__PURE__ */ new Map();
+  for (const container of children(document, "StyleSheets"))
+    for (const style of children(container, "StyleSheet")) {
+      charge();
+      const id = attribute2(style, "ID");
+      if (!id || styles.has(id))
+        fail("EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY", "Ambiguous master style IDs.");
+      styles.set(id, style);
+    }
+  const defaults = children(document, "DocumentSheet")[0];
+  const collect = (id, category, seen = /* @__PURE__ */ new Set()) => {
+    check();
+    if (seen.has(id) || seen.size >= 64)
+      fail("EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY", "Invalid inherited master style ancestry.");
+    seen.add(id);
+    const style = styles.get(id);
+    if (!style) fail("EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY", "Missing inherited master style.");
+    const own = masterCells(style, charge);
+    assertMasterMarkup(style, new Set(own.values()), check);
+    const parent = attribute2(style, category);
+    const result2 = parent !== void 0 && parent !== id ? collect(parent, category, seen) : /* @__PURE__ */ new Map();
+    for (const [name, node] of own) {
+      charge();
+      if (attribute2(node, "F") !== "Inh") result2.set(name, node);
+    }
+    return result2;
+  };
+  const result = /* @__PURE__ */ new Map();
+  for (const category of ["LineStyle", "FillStyle", "TextStyle"]) {
+    const id = attribute2(instance, category) ?? attribute2(template, category) ?? attribute2(defaults, category) ?? (styles.has("0") ? "0" : void 0);
+    if (id !== void 0)
+      for (const [name, node] of collect(id, category)) {
+        charge();
+        if (result.has(name) && result.get(name) !== node)
+          fail(
+            "EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY",
+            "Master style categories have ambiguous overlapping inputs."
+          );
+        result.set(name, node);
+      }
+  }
+  return result;
+}
+function overlay(cells3, additions, kind, charge) {
+  const aliases = /* @__PURE__ */ new Map(), inherited = /* @__PURE__ */ new Map();
+  for (const [name, source] of cells3) {
+    charge();
+    const names = aliases.get(source.node) ?? /* @__PURE__ */ new Set();
+    names.add(name);
+    aliases.set(source.node, names);
+  }
+  for (const [name, node] of additions) {
+    charge();
+    const source = cells3.get(name);
+    if (source) inherited.set(node, source);
+  }
+  for (const [name, node] of additions) {
+    charge();
+    if (attribute2(node, "F") === "Inh") {
+      const source = cells3.get(name) ?? inherited.get(node);
+      if (!source)
+        fail(
+          "EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY",
+          "Inherited master cell has no effective source."
+        );
+      cells3.set(name, source);
+      const names2 = aliases.get(source.node) ?? /* @__PURE__ */ new Set();
+      names2.add(name);
+      aliases.set(source.node, names2);
+      continue;
+    }
+    const previous = cells3.get(name), names = aliases.get(node) ?? /* @__PURE__ */ new Set();
+    if (previous && previous.node !== node) {
+      for (const alias of aliases.get(previous.node) ?? []) {
+        charge();
+        cells3.set(alias, { node, kind });
+        names.add(alias);
+      }
+      aliases.delete(previous.node);
+    }
+    cells3.set(name, { node, kind });
+    names.add(name);
+    aliases.set(node, names);
+  }
+}
+
+// src/visio/edit-master-scope.ts
+function problem(message) {
+  return fail("EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY", message);
+}
+var themeCell = /^(ColorSchemeIndex|EffectSchemeIndex|FontSchemeIndex|ThemeIndex|QuickStyle.*)$/i;
+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 /* @__PURE__ */ new Set();
+  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.");
+  const definitions = /* @__PURE__ */ new Map();
+  for (const node of children(await visioXml(pkg, mastersPart, "Masters"), "Master")) {
+    const id = attribute2(node, "ID");
+    if (!id || definitions.has(id)) problem("Master IDs are ambiguous.");
+    definitions.set(id, node);
+  }
+  const loaded = /* @__PURE__ */ new Map();
+  const bindings = [];
+  let buildWork = 1e5;
+  const charge = () => {
+    check();
+    if (--buildWork < 0) problem("Master effective-cell construction budget exceeded.");
+  };
+  const pageBindings = /* @__PURE__ */ new Map();
+  const pageShapes = /* @__PURE__ */ new Map();
+  for (const [pageId, root] of roots)
+    for (const shape of masterShapes(root)) {
+      const id = attribute2(shape, "ID");
+      if (!id) problem("Page shape ID is missing.");
+      const key2 = JSON.stringify([pageId, id]);
+      if (pageShapes.has(key2)) problem("Page sheet IDs have ambiguous group scopes.");
+      pageShapes.set(key2, shape);
+    }
+  for (const { pageId, instance } of instances) {
+    check();
+    const masterId = attribute2(instance, "Master"), definition = definitions.get(masterId);
+    if (!definition) problem("Active master ID cannot be resolved.");
+    let root = loaded.get(masterId);
+    if (!root) {
+      root = await visioXml(
+        pkg,
+        await indexedPart(pkg, mastersPart, definition, "master"),
+        "MasterContents"
+      );
+      loaded.set(masterId, root);
+    }
+    const tops = children(children(root, "Shapes")[0], "Shape");
+    if (tops.length !== 1) problem("Only a uniquely rooted master can prove independence.");
+    const templates = masterShapes(root), context = /* @__PURE__ */ new Map();
+    assertMasterMarkup(
+      root,
+      new Set(
+        templates.flatMap((shape) => {
+          charge();
+          return [...masterCells(shape, charge).values()];
+        })
+      ),
+      check
+    );
+    const locals = [instance, ...masterShapes(instance)];
+    const byTemplate = /* @__PURE__ */ new Map();
+    const rootId = attribute2(tops[0], "ID");
+    if (!rootId) problem("Master root shape ID is missing.");
+    const explicitRoot = attribute2(instance, "MasterShape");
+    if (explicitRoot !== void 0 && explicitRoot !== rootId)
+      problem("Master root mapping is ambiguous.");
+    byTemplate.set(rootId, instance);
+    for (const local of locals.slice(1)) {
+      if (local.hasAttribute("Master")) problem("Nested master inheritance is unsupported.");
+      const id = attribute2(local, "MasterShape");
+      if (id === void 0) continue;
+      if (byTemplate.has(id)) problem("MasterShape mappings are ambiguous.");
+      byTemplate.set(id, local);
+    }
+    for (const template of templates) {
+      charge();
+      if (bindings.length >= 1e4) problem("Master effective binding limit exceeded.");
+      check();
+      if (template.hasAttribute("Master") || template.hasAttribute("MasterShape"))
+        problem("Chained master definitions are unsupported.");
+      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))
+        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 } : {}
+      };
+      context.set(templateId, binding);
+      bindings.push(binding);
+      if (local) pageBindings.set(JSON.stringify([pageId, attribute2(local, "ID")]), binding);
+    }
+    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 }))
+  );
+  const query = createVisioDependencyQuery(roots, { check });
+  const directAffected = (pageId, shapeId, cell) => commands.some(
+    (command2) => command2.pageId === pageId && command2.shapeId === shapeId && (command2.type === "delete-shape" || changed.some(
+      (target) => target.pageId === pageId && target.shapeId === shapeId && target.cell.toLowerCase() === cell.toLowerCase()
+    ))
+  );
+  const active = /* @__PURE__ */ new Set(), done = /* @__PURE__ */ new Set();
+  const pageInputs = /* @__PURE__ */ new Map();
+  const pageInput = (pageId, shapeId) => {
+    const id = JSON.stringify([pageId, shapeId]);
+    const bound2 = pageBindings.get(id) ?? pageInputs.get(id);
+    if (bound2) return bound2;
+    const shape = pageShapes.get(id);
+    if (!shape) problem("Local master override has a missing page reference.");
+    const cells3 = /* @__PURE__ */ new Map();
+    for (const [name, node] of masterStyleCells(document, shape, shape, check, charge))
+      cells3.set(name, { node, kind: "style" });
+    overlay(cells3, masterCells(shape, charge), "instance", charge);
+    const result = {
+      id: `page:${id}`,
+      pageId,
+      template: shape,
+      instance: shape,
+      cells: cells3,
+      inheritedCells: /* @__PURE__ */ new Map(),
+      context: /* @__PURE__ */ new Map()
+    };
+    pageInputs.set(id, result);
+    return result;
+  };
+  let steps = 1e5;
+  const inspect2 = (binding, name) => {
+    check();
+    if (--steps < 0) problem("Master dependency proof exceeded its cell budget.");
+    name = name.toLowerCase();
+    const pageShapeId = attribute2(binding.instance, "ID");
+    if (pageShapeId !== void 0 && directAffected(binding.pageId, pageShapeId, name))
+      problem("Effective master cache depends on an edited page cell.");
+    const id = JSON.stringify([binding.id, name]);
+    if (done.has(id)) return;
+    if (active.has(id) || active.size >= 64)
+      problem("Master dependency proof is cyclic or too deep.");
+    active.add(id);
+    const source = binding.cells.get(name);
+    if (!source) {
+      const defaults = {
+        locpinx: "width",
+        locpiny: "height",
+        txtwidth: "width",
+        txtheight: "height",
+        txtpinx: "width",
+        txtpiny: "height",
+        txtlocpinx: "txtwidth",
+        txtlocpiny: "txtheight"
+      };
+      const dimension = defaults[name];
+      if (dimension) inspect2(binding, dimension);
+      else if (!themeCell.test(name)) problem(`Missing effective master reference ${name}.`);
+    } else {
+      const formula = executableCellFormula(attribute2(source.node, "F"));
+      if (formula && !inertDoubleClickFormula(attribute2(source.node, "N") ?? "", formula)) {
+        const text = children(binding.instance, "Text")[0] ?? children(binding.template, "Text")[0];
+        const textFieldFree = ![...binding.cells.keys()].some((key2) => /^fields?\./i.test(key2)) && (!text || !Array.from(text.getElementsByTagName("*")).some(
+          (node) => node.localName.toLowerCase() === "fld"
+        ));
+        let analysis;
+        try {
+          analysis = analyzeVisioMasterFormula(formula, { textFieldFree });
+        } catch (error) {
+          problem(
+            `Cannot analyze effective master formula: ${error instanceof Error ? error.message : "invalid formula"}`
+          );
+        }
+        if (analysis.dynamic) problem("Effective master formula has unknown dynamic dependencies.");
+        for (const ref of analysis.references) {
+          if (analysis.readsText && ref.shapeId === void 0 && ref.cell.toLowerCase() === "thetext")
+            continue;
+          if (ref.shapeId === void 0) inspect2(binding, ref.cell);
+          else if (source.kind === "template") {
+            const target = binding.context.get(ref.shapeId);
+            if (!target) problem("Missing master-local Sheet reference.");
+            inspect2(target, ref.cell);
+          } else {
+            if (source.kind === "style")
+              problem("Explicit sheet references in inherited master styles are ambiguous.");
+            if (directAffected(binding.pageId, ref.shapeId, ref.cell) || query({ pageId: binding.pageId, shapeId: ref.shapeId, cell: ref.cell }, changed))
+              problem("Effective master cache depends on an edited page shape.");
+            inspect2(pageInput(binding.pageId, ref.shapeId), ref.cell);
+          }
+        }
+        if (analysis.readsText) {
+          for (const cell of binding.cells.keys())
+            if (/^(character\.|paragraph\.|tabs\.|leftmargin$|rightmargin$|topmargin$|bottommargin$)/i.test(
+              cell
+            ))
+              inspect2(binding, cell);
+        }
+      }
+    }
+    active.delete(id);
+    done.add(id);
+  };
+  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.has(source.node))
+        continue;
+      inspect2(binding, name);
+    }
+  return movePins;
+}
+
 // src/visio/edit-scope.ts
 var admitted2 = (node) => node.namespaceURI === VISIO_NS || node.namespaceURI === VISIO_LEGACY_NS;
 function cells2(sheet) {
@@ -6645,31 +7263,10 @@ async function assertGeometryPackageScope(pkg, pagePaths, commands, check, roots
   let documentRoot;
   for (const path of pkg.paths()) {
     if (!/^visio\/.*\.xml$/i.test(path) || pagePaths.has(path)) continue;
-    if (/^visio\/masters\//i.test(path) && !hasMasterInstances) continue;
+    if (/^visio\/masters\//i.test(path)) continue;
     const root = await pkg.readXml(path);
     const masterScope = /^visio\/masters\//i.test(path) || admitted2(root) && ["MasterContents", "Masters"].includes(root.localName);
-    if (masterScope) {
-      if (hasMasterInstances)
-        for (const node of [root, ...Array.from(root.getElementsByTagName("*"))]) {
-          check();
-          if (!admitted2(node)) continue;
-          const source = executableCellFormula(attribute2(node, "F"));
-          if (!source || inertDoubleClickFormula(attribute2(node, "N") ?? "", source)) continue;
-          try {
-            if (analyzeVisioFormula(source).dynamic)
-              fail(
-                "EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY",
-                "Used master formulas have unknown dynamic dependencies."
-              );
-          } catch (error) {
-            fail(
-              "EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY",
-              `Cannot prove used master formula independence: ${error instanceof Error ? error.message : "invalid formula"}`
-            );
-          }
-        }
-      continue;
-    }
+    if (masterScope) continue;
     if (admitted2(root) && root.localName === "VisioDocument") {
       if (documentRoot)
         fail("EDIT_UNSUPPORTED_PACKAGE_DEPENDENCY", "Multiple document scopes are ambiguous.");
@@ -6701,7 +7298,24 @@ async function assertGeometryPackageScope(pkg, pagePaths, commands, check, roots
           });
     }
   }
-  if (!documentRoot) return;
+  let movePins = /* @__PURE__ */ new Set();
+  if (hasMasterInstances) {
+    for (const command2 of commands) {
+      const root = roots.get(command2.pageId);
+      if (!root) continue;
+      const target = Array.from(root.getElementsByTagNameNS(root.namespaceURI, "Shape")).find(
+        (shape) => attribute2(shape, "ID") === command2.shapeId
+      );
+      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", "Width", "Height", "LocPinX", "LocPinY"].every(
+        (name) => children(target, "Cell").some((node) => attribute2(node, "N") === name)
+      )))
+        fail("UNSUPPORTED_GEOMETRY_EDIT", "Master moves require complete local transform caches.");
+    }
+    movePins = await assertVisioMasterIndependence(pkg, roots, commands, check);
+  }
+  if (!documentRoot) return movePins;
   const styles = /* @__PURE__ */ new Map();
   for (const container of children(documentRoot, "StyleSheets"))
     for (const style of children(container, "StyleSheet")) {
@@ -6766,6 +7380,7 @@ async function assertGeometryPackageScope(pkg, pagePaths, commands, check, roots
       }
     }
   }
+  return movePins;
 }
 
 // src/visio/edit.ts
@@ -6793,12 +7408,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 = /* @__PURE__ */ new Set();
   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"),
@@ -6825,7 +7441,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));
     }
   }