@compact-design/core 0.2.0 → 0.3.0

package/dist/index.js

@@ -7254,6 +7254,371 @@ function validationIssues(errors) {
   });
 }
 
+// src/patch-keys.ts
+var PATCH_SET_EXCLUDED_NODE_KEYS = ["id", "type", "children", "coordinateMode"];
+var PATCH_SET_KEYS = [
+  "name",
+  "x",
+  "y",
+  "w",
+  "h",
+  "rotation",
+  "fill",
+  "fills",
+  "stroke",
+  "strokes",
+  "strokeWeight",
+  "strokeTopWeight",
+  "strokeRightWeight",
+  "strokeBottomWeight",
+  "strokeLeftWeight",
+  "strokeAlign",
+  "strokeCap",
+  "strokeJoin",
+  "dashPattern",
+  "cornerRadius",
+  "cornerRadii",
+  "opacity",
+  "blendMode",
+  "visible",
+  "locked",
+  "isMask",
+  "clipsContent",
+  "effects",
+  "elevation",
+  "shadow",
+  "layout",
+  "constraints",
+  "layoutSizingHorizontal",
+  "layoutSizingVertical",
+  "layoutAlign",
+  "layoutGrow",
+  "layoutPositioning",
+  "minWidth",
+  "maxWidth",
+  "minHeight",
+  "maxHeight",
+  "layoutGrids",
+  "text",
+  "font",
+  "lineHeight",
+  "letterSpacing",
+  "align",
+  "verticalAlignment",
+  "textDecoration",
+  "textCase",
+  "paragraphSpacing",
+  "paragraphIndent",
+  "listSpacing",
+  "hangingPunctuation",
+  "hangingList",
+  "textAutoResize",
+  "textTruncation",
+  "maxLines",
+  "runs",
+  "pointCount",
+  "innerRadius",
+  "startingAngle",
+  "endingAngle",
+  "innerRadiusRatio",
+  "svg",
+  "vectorPaths",
+  "componentId",
+  "componentProperties",
+  "instanceProperties",
+  "componentPropertyReferences",
+  "variantAxes",
+  "variant",
+  "operation",
+  "prototype",
+  "overflowDirection",
+  "numberOfFixedChildren",
+  "styleRefs",
+  "bindings",
+  "variableModes"
+];
+var PATCH_SET_SEMANTICS = {
+  name: "scalar",
+  x: "scalar",
+  y: "scalar",
+  w: "scalar",
+  h: "scalar",
+  rotation: "scalar",
+  fill: "replace",
+  fills: "replace",
+  stroke: "replace",
+  strokes: "replace",
+  strokeWeight: "scalar",
+  strokeTopWeight: "scalar",
+  strokeRightWeight: "scalar",
+  strokeBottomWeight: "scalar",
+  strokeLeftWeight: "scalar",
+  strokeAlign: "scalar",
+  strokeCap: "scalar",
+  strokeJoin: "scalar",
+  dashPattern: "replace",
+  cornerRadius: "scalar",
+  cornerRadii: "replace",
+  opacity: "scalar",
+  blendMode: "scalar",
+  visible: "scalar",
+  locked: "scalar",
+  isMask: "scalar",
+  clipsContent: "scalar",
+  effects: "replace",
+  elevation: "replace",
+  shadow: "replace",
+  layout: "merge",
+  constraints: "merge",
+  layoutSizingHorizontal: "scalar",
+  layoutSizingVertical: "scalar",
+  layoutAlign: "scalar",
+  layoutGrow: "scalar",
+  layoutPositioning: "scalar",
+  minWidth: "scalar",
+  maxWidth: "scalar",
+  minHeight: "scalar",
+  maxHeight: "scalar",
+  layoutGrids: "replace",
+  text: "scalar",
+  font: "merge",
+  lineHeight: "scalar",
+  letterSpacing: "scalar",
+  align: "scalar",
+  verticalAlignment: "scalar",
+  textDecoration: "scalar",
+  textCase: "scalar",
+  paragraphSpacing: "scalar",
+  paragraphIndent: "scalar",
+  listSpacing: "scalar",
+  hangingPunctuation: "scalar",
+  hangingList: "scalar",
+  textAutoResize: "scalar",
+  textTruncation: "scalar",
+  maxLines: "scalar",
+  runs: "replace",
+  pointCount: "scalar",
+  innerRadius: "scalar",
+  startingAngle: "scalar",
+  endingAngle: "scalar",
+  innerRadiusRatio: "scalar",
+  svg: "immutable",
+  vectorPaths: "replace",
+  componentId: "deferred",
+  componentProperties: "merge",
+  instanceProperties: "merge",
+  componentPropertyReferences: "merge",
+  variantAxes: "merge",
+  variant: "merge",
+  operation: "scalar",
+  prototype: "replace",
+  overflowDirection: "scalar",
+  numberOfFixedChildren: "scalar",
+  styleRefs: "merge",
+  bindings: "merge",
+  variableModes: "merge"
+};
+var PATCH_SET_DEFERRED_KEYS = PATCH_SET_KEYS.filter((key) => PATCH_SET_SEMANTICS[key] === "deferred");
+var ALL = null;
+var FRAME_LIKE = ["FRAME", "COMPONENT", "COMPONENT_SET", "INSTANCE"];
+var AUTO_LAYOUT_CAPABLE = ["FRAME", "COMPONENT"];
+var STROKABLE = ["FRAME", "COMPONENT", "COMPONENT_SET", "INSTANCE", "RECTANGLE", "ELLIPSE", "ARC", "LINE", "POLYGON", "STAR", "VECTOR", "TEXT", "BOOLEAN_OPERATION"];
+var FILLABLE = [...STROKABLE, "SECTION"];
+var BLENDABLE = [...STROKABLE, "GROUP"];
+var LAYOUT_CHILD = [...STROKABLE, "GROUP"];
+var TEXT_ONLY = ["TEXT"];
+var PATCH_SET_APPLIES_TO = {
+  name: ALL,
+  x: ALL,
+  y: ALL,
+  rotation: [...BLENDABLE],
+  w: [...STROKABLE, "SECTION", "SLICE"],
+  h: [...STROKABLE, "SECTION", "SLICE"],
+  fill: FILLABLE,
+  fills: FILLABLE,
+  stroke: STROKABLE,
+  strokes: STROKABLE,
+  strokeWeight: STROKABLE,
+  strokeTopWeight: FRAME_LIKE.concat("RECTANGLE"),
+  strokeRightWeight: FRAME_LIKE.concat("RECTANGLE"),
+  strokeBottomWeight: FRAME_LIKE.concat("RECTANGLE"),
+  strokeLeftWeight: FRAME_LIKE.concat("RECTANGLE"),
+  strokeAlign: STROKABLE,
+  strokeCap: ["LINE", "VECTOR", "ELLIPSE", "ARC"],
+  strokeJoin: STROKABLE,
+  dashPattern: STROKABLE,
+  cornerRadius: [...FRAME_LIKE, "RECTANGLE", "POLYGON", "STAR", "VECTOR"],
+  cornerRadii: [...FRAME_LIKE, "RECTANGLE"],
+  opacity: BLENDABLE,
+  blendMode: BLENDABLE,
+  visible: ALL,
+  locked: ALL,
+  isMask: BLENDABLE,
+  clipsContent: FRAME_LIKE,
+  effects: BLENDABLE,
+  elevation: BLENDABLE,
+  shadow: BLENDABLE,
+  layout: AUTO_LAYOUT_CAPABLE,
+  constraints: STROKABLE,
+  layoutSizingHorizontal: LAYOUT_CHILD,
+  layoutSizingVertical: LAYOUT_CHILD,
+  layoutAlign: LAYOUT_CHILD,
+  layoutGrow: LAYOUT_CHILD,
+  layoutPositioning: LAYOUT_CHILD,
+  minWidth: LAYOUT_CHILD,
+  maxWidth: LAYOUT_CHILD,
+  minHeight: LAYOUT_CHILD,
+  maxHeight: LAYOUT_CHILD,
+  layoutGrids: AUTO_LAYOUT_CAPABLE,
+  text: TEXT_ONLY,
+  font: TEXT_ONLY,
+  lineHeight: TEXT_ONLY,
+  letterSpacing: TEXT_ONLY,
+  align: TEXT_ONLY,
+  verticalAlignment: TEXT_ONLY,
+  textDecoration: TEXT_ONLY,
+  textCase: TEXT_ONLY,
+  paragraphSpacing: TEXT_ONLY,
+  paragraphIndent: TEXT_ONLY,
+  listSpacing: TEXT_ONLY,
+  hangingPunctuation: TEXT_ONLY,
+  hangingList: TEXT_ONLY,
+  textAutoResize: TEXT_ONLY,
+  textTruncation: TEXT_ONLY,
+  maxLines: TEXT_ONLY,
+  runs: TEXT_ONLY,
+  pointCount: ["POLYGON", "STAR"],
+  innerRadius: ["STAR"],
+  startingAngle: ["ELLIPSE", "ARC"],
+  endingAngle: ["ELLIPSE", "ARC"],
+  innerRadiusRatio: ["ELLIPSE", "ARC"],
+  svg: ALL,
+  vectorPaths: ["VECTOR"],
+  componentId: ALL,
+  componentProperties: ["COMPONENT"],
+  instanceProperties: ["INSTANCE"],
+  componentPropertyReferences: ALL,
+  variantAxes: ["COMPONENT_SET"],
+  variant: ["COMPONENT"],
+  operation: ["BOOLEAN_OPERATION"],
+  prototype: ALL,
+  overflowDirection: AUTO_LAYOUT_CAPABLE,
+  numberOfFixedChildren: AUTO_LAYOUT_CAPABLE,
+  styleRefs: ALL,
+  bindings: ALL,
+  variableModes: ALL
+};
+var PATCH_TEXT_STYLE_KEYS = ["font", "lineHeight", "letterSpacing", "paragraphSpacing", "paragraphIndent", "listSpacing", "textCase", "textDecoration", "hangingPunctuation", "hangingList"];
+var PATCH_SET_KEY_SET = new Set(PATCH_SET_KEYS);
+function isPatchSetKey(key) {
+  return PATCH_SET_KEY_SET.has(key);
+}
+var isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var GROUP_TYPES = /* @__PURE__ */ new Set(["GROUP", "BOOLEAN_OPERATION"]);
+var PADDING_FIELDS = { left: "paddingLeft", top: "paddingTop", right: "paddingRight", bottom: "paddingBottom" };
+function patchSetBindingFields(set) {
+  const fields = [];
+  const direct = {
+    w: ["width"],
+    h: ["height"],
+    opacity: ["opacity"],
+    visible: ["visible"],
+    text: ["characters"],
+    cornerRadius: ["cornerRadius", "topLeftRadius", "topRightRadius", "bottomLeftRadius", "bottomRightRadius"],
+    cornerRadii: ["topLeftRadius", "topRightRadius", "bottomLeftRadius", "bottomRightRadius"],
+    strokeWeight: ["strokeWeight"],
+    strokeTopWeight: ["strokeTopWeight"],
+    strokeRightWeight: ["strokeRightWeight"],
+    strokeBottomWeight: ["strokeBottomWeight"],
+    strokeLeftWeight: ["strokeLeftWeight"],
+    minWidth: ["minWidth"],
+    maxWidth: ["maxWidth"],
+    minHeight: ["minHeight"],
+    maxHeight: ["maxHeight"],
+    paragraphSpacing: ["paragraphSpacing"],
+    paragraphIndent: ["paragraphIndent"],
+    letterSpacing: ["letterSpacing"],
+    lineHeight: ["lineHeight"]
+  };
+  for (const [key, mapped] of Object.entries(direct)) if (key in set) fields.push(...mapped);
+  if (isObject(set.layout)) {
+    if ("itemSpacing" in set.layout) fields.push("itemSpacing");
+    if ("counterAxisSpacing" in set.layout) fields.push("counterAxisSpacing");
+    if (isObject(set.layout.padding)) {
+      for (const side of Object.keys(set.layout.padding)) if (PADDING_FIELDS[side]) fields.push(PADDING_FIELDS[side]);
+    }
+  }
+  if (isObject(set.font)) {
+    if ("size" in set.font) fields.push("fontSize");
+    if ("family" in set.font) fields.push("fontFamily");
+    if ("style" in set.font) fields.push("fontStyle");
+  }
+  return fields;
+}
+function patchSetShapeIssues(set) {
+  const issues = [];
+  for (const key of Object.keys(set)) {
+    if (!isPatchSetKey(key)) {
+      issues.push(`${key}: unknown set key '${key}'. Settable keys: ${PATCH_SET_KEYS.join(", ")}.`);
+      continue;
+    }
+    const semantics = PATCH_SET_SEMANTICS[key];
+    if (semantics === "deferred") issues.push(`${key}: '${key}' cannot be patched yet (planned follow-up). Re-import the node, or remove and insert it.`);
+    if (semantics === "immutable") issues.push(`${key}: '${key}' cannot be patched in place. Remove the node and insert a new one.`);
+  }
+  for (const key of ["font", "layout", "constraints"]) {
+    if (key in set && (!isObject(set[key]) || !Object.keys(set[key]).length)) issues.push(`${key}: '${key}' must be a non-empty object.`);
+  }
+  if (isObject(set.layout) && "padding" in set.layout && (!isObject(set.layout.padding) || !Object.keys(set.layout.padding).length)) issues.push("layout.padding: padding must be a non-empty object.");
+  if ("fill" in set && "fills" in set) issues.push("fills: set either fill or fills, not both.");
+  if ("stroke" in set && "strokes" in set) issues.push("strokes: set either stroke or strokes, not both.");
+  if (isObject(set.layout) && set.layout.counterAxisAlignItems === "STRETCH") issues.push("layout.counterAxisAlignItems: STRETCH cannot be patched yet (Figma applies it per child at import). Set layoutAlign: STRETCH on the children instead.");
+  if (Array.isArray(set.runs) && set.text === void 0 && set.runs.some((run) => !isObject(run) || typeof run.text !== "string")) issues.push("runs: without text, every run must carry its own text so the content is defined.");
+  return issues;
+}
+function patchSetTargetIssues(set, context) {
+  const issues = patchSetShapeIssues(set);
+  for (const key of Object.keys(set)) {
+    if (!isPatchSetKey(key)) continue;
+    const types = PATCH_SET_APPLIES_TO[key];
+    if (types && !types.includes(context.type)) issues.push(`${key}: '${key}' does not apply to ${context.type} nodes.`);
+  }
+  const layout = isObject(set.layout) ? set.layout : null;
+  const autoLayoutAfter = context.autoLayout || Boolean(layout && typeof layout.direction === "string");
+  const positioningAfter = typeof set.layoutPositioning === "string" ? set.layoutPositioning : context.layoutPositioning;
+  if (("x" in set || "y" in set) && context.parentType && GROUP_TYPES.has(context.parentType)) {
+    issues.push(`${"x" in set ? "x" : "y"}: children of a ${context.parentType} cannot be positioned by patch (the group derives its bounds from its children). Set x/y on the ${context.parentType} instead, or move the node out first.`);
+  }
+  if (("x" in set || "y" in set) && context.parentAutoLayout && positioningAfter !== "ABSOLUTE") {
+    issues.push(`${"x" in set ? "x" : "y"}: the parent uses Auto Layout, which positions this node. Also set layoutPositioning: "ABSOLUTE" to place it by x/y.`);
+  }
+  if (layout && !context.autoLayout && typeof layout.direction !== "string" && PATCH_SET_APPLIES_TO.layout?.includes(context.type)) {
+    issues.push("layout.direction: the target has no Auto Layout yet; a partial layout must include direction to enable it.");
+  }
+  for (const key of ["layoutAlign", "layoutGrow", "layoutPositioning"]) {
+    if (key in set && !context.parentAutoLayout) issues.push(`${key}: '${key}' only applies to children of an Auto Layout parent.`);
+  }
+  for (const key of ["layoutSizingHorizontal", "layoutSizingVertical"]) {
+    if (set[key] === "FILL" && !context.parentAutoLayout) issues.push(`${key}: FILL requires an Auto Layout parent.`);
+    if (set[key] === "HUG" && context.type !== "TEXT" && !autoLayoutAfter) issues.push(`${key}: HUG requires a TEXT node or an Auto Layout frame.`);
+  }
+  for (const key of ["minWidth", "maxWidth", "minHeight", "maxHeight"]) {
+    if (key in set && !autoLayoutAfter && !context.parentAutoLayout) issues.push(`${key}: '${key}' only applies to Auto Layout frames or their children.`);
+  }
+  if (typeof set.numberOfFixedChildren === "number" && set.numberOfFixedChildren > context.childCount) {
+    issues.push(`numberOfFixedChildren: ${set.numberOfFixedChildren} exceeds the node's ${context.childCount} children.`);
+  }
+  if (context.type === "TEXT") {
+    if (("text" in set || "runs" in set) && context.mixedText) {
+      issues.push(`${"runs" in set ? "runs" : "text"}: the node has per-range text styling; replacing its content by patch is not supported yet. Remove and insert the TEXT node instead.`);
+    }
+    if (isObject(set.font) && context.mixedFontName && "family" in set.font !== "style" in set.font) {
+      issues.push("font: the node mixes fonts across ranges; set font.family and font.style together (font.size alone is fine).");
+    }
+  }
+  return issues;
+}
+
 // src/normalize.ts
 function hexColor(value) {
   if (typeof value !== "string" || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(value)) return null;
@@ -7374,6 +7739,18 @@ function effect(value) {
     visible
   };
 }
+var OVERFLOW_DIRECTIONS = {
+  NONE: "NONE",
+  HORIZONTAL: "HORIZONTAL",
+  VERTICAL: "VERTICAL",
+  BOTH: "BOTH",
+  HORIZONTAL_SCROLLING: "HORIZONTAL",
+  VERTICAL_SCROLLING: "VERTICAL",
+  HORIZONTAL_AND_VERTICAL_SCROLLING: "BOTH"
+};
+function lineHeightValue(value) {
+  return typeof value === "number" ? { unit: "PERCENT", value: value <= 3 ? value * 100 : value } : value;
+}
 var passthrough = [
   "cornerRadius",
   "cornerRadii",
@@ -7417,6 +7794,7 @@ var passthrough = [
   "innerRadiusRatio",
   "componentProperties",
   "instanceProperties",
+  "componentPropertyReferences",
   "prototype",
   "variantAxes",
   "variant",
@@ -7445,23 +7823,12 @@ function normalizeNode(node, parent, path) {
   if (type === "TEXT" && raw.alignment !== void 0) throw new Error(`${path}.alignment is not part of the current text API; use align.`);
   if (type === "TEXT" && raw.fontSize !== void 0) throw new Error(`${path}.fontSize is not part of the current text API; use font.size.`);
   Object.assign(props, Object.fromEntries(passthrough.filter((key) => raw[key] !== void 0).map((key) => [key, raw[key]])));
-  if (typeof raw.overflowDirection === "string") {
-    const overflowDirections = {
-      NONE: "NONE",
-      HORIZONTAL: "HORIZONTAL",
-      VERTICAL: "VERTICAL",
-      BOTH: "BOTH",
-      HORIZONTAL_SCROLLING: "HORIZONTAL",
-      VERTICAL_SCROLLING: "VERTICAL",
-      HORIZONTAL_AND_VERTICAL_SCROLLING: "BOTH"
-    };
-    props.overflowDirection = overflowDirections[raw.overflowDirection];
-  }
+  if (typeof raw.overflowDirection === "string") props.overflowDirection = OVERFLOW_DIRECTIONS[raw.overflowDirection];
   if (type === "TEXT") {
     const font = raw.font || {};
     props.text = raw.text !== void 0 ? raw.text : (raw.runs || []).map((run) => run.text || "").join("");
     props.font = { family: font.family || "Arial", style: font.style || "Regular", size: font.size || 16 };
-    props.lineHeight = typeof raw.lineHeight === "number" ? { unit: "PERCENT", value: raw.lineHeight <= 3 ? raw.lineHeight * 100 : raw.lineHeight } : raw.lineHeight || { unit: "AUTO" };
+    props.lineHeight = raw.lineHeight !== void 0 ? lineHeightValue(raw.lineHeight) : { unit: "AUTO" };
     props.alignment = raw.align || "LEFT";
     for (const key of ["letterSpacing", "textDecoration", "paragraphSpacing", "paragraphIndent", "listSpacing", "hangingPunctuation", "hangingList", "textCase", "verticalAlignment", "textAutoResize", "textTruncation", "maxLines", "runs"]) {
       if (raw[key] !== void 0) Object.assign(props, { [key]: raw[key] });
@@ -7590,6 +7957,37 @@ function normalizeDocument(value) {
   applyStructuredVariants(result.nodes);
   return result;
 }
+var SET_VALUE_RENAMES = { align: "alignment" };
+var SET_STRUCTURED_KEYS = /* @__PURE__ */ new Set(["name", "x", "y", "w", "h", "fill", "fills", "stroke", "strokes", "effects", "shadow", "elevation", "lineHeight", "overflowDirection", "font", "constraints", "layout"]);
+function normalizePatchSet(set, path = "set") {
+  const issues = patchSetShapeIssues(set);
+  if (issues.length) throw new Error(`${path}.${issues[0]}`);
+  const raw = set;
+  const values = {};
+  if (typeof raw.name === "string") values.name = raw.name;
+  if ("x" in raw || "y" in raw) values.position = { ..."x" in raw ? { x: raw.x } : {}, ..."y" in raw ? { y: raw.y } : {} };
+  if ("w" in raw || "h" in raw) values.size = { ..."w" in raw ? { width: raw.w } : {}, ..."h" in raw ? { height: raw.h } : {} };
+  const styles = {};
+  if (raw.fills !== void 0) styles.fills = raw.fills.map(paint);
+  else if (raw.fill !== void 0) styles.fills = [paint(raw.fill)];
+  if (raw.strokes !== void 0) styles.strokes = raw.strokes.map(paint);
+  else if (raw.stroke !== void 0) styles.strokes = [paint(raw.stroke)];
+  if (raw.effects !== void 0 || raw.shadow !== void 0 || raw.elevation !== void 0) styles.effects = effects(raw);
+  if (Object.keys(styles).length) values.styles = styles;
+  if (raw.lineHeight !== void 0) values.lineHeight = lineHeightValue(raw.lineHeight);
+  if (typeof raw.overflowDirection === "string") values.overflowDirection = OVERFLOW_DIRECTIONS[raw.overflowDirection];
+  if (raw.font !== void 0) values.font = { ...raw.font };
+  if (raw.constraints !== void 0) values.constraints = { ...raw.constraints };
+  if (raw.layout !== void 0) {
+    const layout = raw.layout;
+    values.layout = { ...layout, ...layout.padding && typeof layout.padding === "object" ? { padding: { ...layout.padding } } : {} };
+  }
+  for (const key of PATCH_SET_KEYS) {
+    if (SET_STRUCTURED_KEYS.has(key) || raw[key] === void 0) continue;
+    Object.assign(values, { [SET_VALUE_RENAMES[key] || key]: raw[key] });
+  }
+  return values;
+}
 function isPatchDocument(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value) && "patch" in value);
 }
@@ -7599,194 +7997,1544 @@ function normalizePatchDocument(value) {
   if (!Array.isArray(source.patch?.operations) || !source.patch.operations.length) throw new Error("patch.operations must be a non-empty array.");
   const operations = source.patch.operations.map((operation, index) => {
     const op = String(operation.op || "").toUpperCase();
-    if (!["SET", "REMOVE", "APPEND"].includes(op)) throw new Error(`patch.operations[${index}].op must be set, remove, or append.`);
-    if ((op === "SET" || op === "REMOVE") && typeof operation.id !== "string") throw new Error(`patch.operations[${index}].id is required.`);
+    if (!["SET", "REMOVE", "APPEND", "INSERT", "MOVE", "DUPLICATE"].includes(op)) throw new Error(`patch.operations[${index}].op must be set, remove, append, insert, move, or duplicate.`);
+    if ((op === "SET" || op === "REMOVE" || op === "MOVE" || op === "DUPLICATE") && typeof operation.id !== "string") throw new Error(`patch.operations[${index}].id is required.`);
     if (op === "SET" && (!operation.set || typeof operation.set !== "object" || Array.isArray(operation.set))) throw new Error(`patch.operations[${index}].set is required.`);
     if (op === "APPEND" && (typeof operation.parent !== "string" || !operation.node)) throw new Error(`patch.operations[${index}] requires parent and node.`);
-    const result = { op, id: typeof operation.id === "string" ? operation.id : void 0, parent: typeof operation.parent === "string" ? operation.parent : void 0, set: operation.set };
+    if (op === "INSERT" && (typeof operation.parent !== "string" || !operation.node)) throw new Error(`patch.operations[${index}] requires parent and node.`);
+    if (op === "MOVE" && typeof operation.parent !== "string") throw new Error(`patch.operations[${index}].parent is required.`);
+    if ((op === "INSERT" || op === "MOVE") && (typeof operation.index !== "number" || !Number.isInteger(operation.index) || operation.index < 0)) {
+      throw new Error(`patch.operations[${index}].index must be a non-negative integer.`);
+    }
+    if (op === "DUPLICATE") {
+      if (typeof operation.idSuffix !== "string" || !operation.idSuffix) {
+        throw new Error(`patch.operations[${index}].idSuffix must be a non-empty string.`);
+      }
+      if (operation.index !== void 0 && (typeof operation.index !== "number" || !Number.isInteger(operation.index) || operation.index < 0)) {
+        throw new Error(`patch.operations[${index}].index must be a non-negative integer.`);
+      }
+      if (operation.ids !== void 0) {
+        if (typeof operation.ids !== "object" || operation.ids === null || Array.isArray(operation.ids)) {
+          throw new Error(`patch.operations[${index}].ids must be an object.`);
+        }
+        for (const [key, value2] of Object.entries(operation.ids)) {
+          if (typeof value2 !== "string" || !value2) {
+            throw new Error(`patch.operations[${index}].ids.${key} must be a non-empty string.`);
+          }
+        }
+      }
+    }
+    const result = {
+      op,
+      id: typeof operation.id === "string" ? operation.id : void 0,
+      parent: typeof operation.parent === "string" ? operation.parent : void 0,
+      index: typeof operation.index === "number" ? operation.index : void 0,
+      set: operation.set,
+      idSuffix: typeof operation.idSuffix === "string" ? operation.idSuffix : void 0,
+      ids: operation.ids && typeof operation.ids === "object" && !Array.isArray(operation.ids) ? { ...operation.ids } : void 0
+    };
     if (op === "SET") {
-      const textKeys = ["text", "font", "lineHeight", "letterSpacing", "align", "runs", "textDecoration", "paragraphSpacing", "textAutoResize"];
       const set = operation.set;
-      const syntheticType = textKeys.some((key) => key in set) ? "TEXT" : "FRAME";
-      result.normalized = normalizeNode({ ...set, type: syntheticType, w: typeof set.w === "number" ? set.w : 1, h: typeof set.h === "number" ? set.h : 1 }, { x: 0, y: 0 }, `patch-${index}`).properties;
+      if (!Object.keys(set).length) throw new Error(`patch.operations[${index}].set must contain at least one key.`);
+      result.normalized = normalizePatchSet(set, `patch.operations[${index}].set`);
     }
     if (op === "APPEND") result.node = normalizeNode(operation.node, { x: 0, y: 0 }, `patch-${index}-append`);
+    if (op === "INSERT") result.node = normalizeNode(operation.node, { x: 0, y: 0 }, `patch-${index}-insert`);
     return result;
   });
   return { patch: { operations } };
 }
 
-// src/patch.ts
-function cloneValue(value) {
-  if (value instanceof Uint8Array) return new Uint8Array(value);
-  if (Array.isArray(value)) return value.map(cloneValue);
-  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneValue(item)]));
-  return value;
-}
-function cloneNode(node) {
-  return { ...node, properties: cloneValue(node.properties), children: node.children.map(cloneNode) };
+// src/patch-definitions.ts
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function mergeSet(node, operation) {
-  const set = operation.set || {};
-  const normalized = operation.normalized;
-  if (!normalized) throw new Error(`Patch SET '${operation.id}' was not normalized.`);
-  if (typeof set.name === "string") node.name = set.name;
-  const propertyKeys = Object.keys(set).filter((key) => !["id", "name", "type", "children"].includes(key));
-  for (const key of propertyKeys) {
-    if (key === "x") node.properties.position.x = normalized.position.x;
-    else if (key === "y") node.properties.position.y = normalized.position.y;
-    else if (key === "w") node.properties.size.width = normalized.size.width;
-    else if (key === "h") node.properties.size.height = normalized.size.height;
-    else if (key === "fill" || key === "fills") node.properties.styles.fills = cloneValue(normalized.styles.fills);
-    else if (key === "stroke" || key === "strokes") node.properties.styles.strokes = cloneValue(normalized.styles.strokes);
-    else if (key === "effects" || key === "shadow" || key === "elevation") node.properties.styles.effects = cloneValue(normalized.styles.effects);
-    else Object.assign(node.properties, { [key === "align" ? "alignment" : key]: cloneValue(normalized[key]) });
+function uniqueStrings(path, options, errors) {
+  if (!options.length || options.some((option) => typeof option !== "string" || !option)) {
+    errors.push(`${path}: must be a non-empty string array`);
+    return null;
+  }
+  if (new Set(options).size !== options.length) {
+    errors.push(`${path}: options must be unique`);
+    return null;
   }
+  return options;
 }
-function applyDocumentPatch(document, patch) {
-  const result = { ...document, nodes: document.nodes.map(cloneNode), styles: cloneValue(document.styles), variables: cloneValue(document.variables) };
-  const affectedIds = [];
-  const index = /* @__PURE__ */ new Map();
-  const visit = (nodes, parent) => nodes.forEach((node) => {
-    index.set(node.id, { node, parent, siblings: nodes });
-    visit(node.children, node);
-  });
-  visit(result.nodes, null);
-  for (const [operationIndex, operation] of patch.patch.operations.entries()) {
-    if (operation.op === "APPEND") {
-      const target2 = operation.parent ? index.get(operation.parent) : void 0;
-      if (!target2 || !operation.node) throw new Error(`patch.operations[${operationIndex}]: parent '${operation.parent || ""}' was not found.`);
-      if (index.has(operation.node.id)) throw new Error(`patch.operations[${operationIndex}]: ID '${operation.node.id}' already exists.`);
-      const appended = cloneNode(operation.node);
-      target2.node.children.push(appended);
-      visit([appended], target2.node);
-      affectedIds.push(appended.id);
+function detectVariantRenames(current, patch) {
+  const errors = [];
+  const axes = { ...current };
+  const axisRenames = [];
+  const optionRenames = [];
+  for (const [axis, entry] of Object.entries(patch)) {
+    const path = `variantAxes.${axis}`;
+    if (entry === null) {
+      errors.push(`${path}: deleting a variant axis is not supported (Figma cannot delete VARIANT properties)`);
       continue;
     }
-    const target = operation.id ? index.get(operation.id) : void 0;
-    if (!target) throw new Error(`patch.operations[${operationIndex}]: node '${operation.id || ""}' was not found.`);
-    if (operation.op === "REMOVE") {
-      target.siblings.splice(target.siblings.indexOf(target.node), 1);
-      index.delete(target.node.id);
-      affectedIds.push(target.node.id);
-    } else {
-      mergeSet(target.node, operation);
-      affectedIds.push(target.node.id);
+    if (Array.isArray(entry)) {
+      const options = uniqueStrings(path, entry, errors);
+      if (!options) continue;
+      if (!(axis in current) && !(axis in axes)) {
+      } else if (!(axis in axes) && axisRenames.some((rename) => rename.to === axis)) {
+      }
+      axes[axis] = options;
+      continue;
+    }
+    if (!isPlainObject(entry)) {
+      errors.push(`${path}: must be a string array, null, or { rename?, options?, renameOptions? }`);
+      continue;
+    }
+    const renameTo = entry.rename;
+    const renameOptionsRaw = entry.renameOptions;
+    const optionsRaw = entry.options;
+    if (renameTo !== void 0 && (typeof renameTo !== "string" || !renameTo)) {
+      errors.push(`${path}.rename: must be a non-empty string`);
+      continue;
+    }
+    if (renameTo !== void 0 && renameTo !== axis) {
+      if (!(axis in current) && !(axis in axes)) {
+        errors.push(`${path}: cannot rename unknown axis '${axis}'`);
+      } else if (renameTo in axes && renameTo !== axis) {
+        errors.push(`${path}.rename: axis '${renameTo}' already exists`);
+      } else {
+        axisRenames.push({ from: axis, to: renameTo });
+        const prior = axes[axis] || current[axis] || [];
+        delete axes[axis];
+        axes[renameTo] = [...prior];
+      }
+    }
+    const axisKey = typeof renameTo === "string" && renameTo ? renameTo : axis;
+    const baseOptions = axes[axisKey] || current[axis] || [];
+    const explicitOptionRenames = [];
+    if (renameOptionsRaw !== void 0) {
+      if (!isPlainObject(renameOptionsRaw)) {
+        errors.push(`${path}.renameOptions: must be an object of old\u2192new option names`);
+      } else {
+        for (const [from, to] of Object.entries(renameOptionsRaw)) {
+          if (typeof to !== "string" || !to) {
+            errors.push(`${path}.renameOptions.${from}: must be a non-empty string`);
+            continue;
+          }
+          if (!baseOptions.includes(from)) {
+            errors.push(`${path}.renameOptions.${from}: option '${from}' is not on axis '${axisKey}'`);
+            continue;
+          }
+          explicitOptionRenames.push({ axis: axisKey, from, to });
+        }
+      }
+    }
+    let nextOptions = [...baseOptions];
+    for (const { from, to } of explicitOptionRenames) {
+      nextOptions = nextOptions.map((option) => option === from ? to : option);
+    }
+    if (optionsRaw !== void 0) {
+      if (!Array.isArray(optionsRaw)) {
+        errors.push(`${path}.options: must be a string array`);
+      } else {
+        const options = uniqueStrings(`${path}.options`, optionsRaw, errors);
+        if (options) nextOptions = options;
+      }
+    } else if (explicitOptionRenames.length) {
+      nextOptions = [...new Set(nextOptions)];
+    }
+    if (!nextOptions.length) {
+      errors.push(`${path}: options must be a non-empty string array`);
+      continue;
+    }
+    if (new Set(nextOptions).size !== nextOptions.length) {
+      errors.push(`${path}: options must be unique`);
+      continue;
     }
+    axes[axisKey] = nextOptions;
+    optionRenames.push(...explicitOptionRenames);
   }
-  return { document: result, affectedIds };
+  return { axes, axisRenames, optionRenames, errors };
 }
-
-// src/parser.ts
-function parseDocument(source) {
-  if (!source.trim()) throw new Error("Paste a Compact Design JSON document first.");
-  try {
-    return JSON.parse(source);
-  } catch (error) {
-    throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+function variantAxesChildConflicts(set, previousAxes, nextAxes, optionRenames, axisRenames) {
+  const errors = [];
+  const renamedAway = new Set(optionRenames.map((rename) => `${rename.axis}\0${rename.from}`));
+  const axisFrom = new Map(axisRenames.map((rename) => [rename.from, rename.to]));
+  for (const child of set.children) {
+    if (child.type !== "COMPONENT") continue;
+    const variant = { ...child.properties.variant || {} };
+    for (const [from, to] of axisFrom) {
+      if (from in variant) {
+        variant[to] = variant[from];
+        delete variant[from];
+      }
+    }
+    for (const { axis, from, to } of optionRenames) {
+      if (variant[axis] === from) variant[axis] = to;
+    }
+    for (const [axis, value] of Object.entries(variant)) {
+      const options = nextAxes[axis];
+      if (!options) {
+        errors.push(`variantAxes: child '${child.id}' still uses axis '${axis}' which is not declared`);
+        continue;
+      }
+      if (!options.includes(value)) {
+        const priorAxis = [...axisFrom.entries()].find(([, to]) => to === axis)?.[0] || axis;
+        const priorOptions = previousAxes[priorAxis] || previousAxes[axis] || [];
+        if (priorOptions.includes(value) || renamedAway.has(`${axis}\0${value}`)) {
+          errors.push(
+            `variantAxes.${axis}: option '${value}' is used by variant child '${child.id}' but was removed without renameOptions (use renameOptions: { "${value}": "NewName" } or update the child's variant first)`
+          );
+        } else {
+          errors.push(`variantAxes.${axis}: child '${child.id}' has value '${value}' which is not declared`);
+        }
+      }
+    }
   }
+  return errors;
 }
-
-// src/generated-schema.ts
-var generated_schema_default = {
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://compact-design-json.dev/schema.json",
-  "title": "Compact Design JSON",
-  "description": "The current public input language for the Compact Design JSON to Figma plugin.",
-  "type": "object",
-  "additionalProperties": false,
-  "properties": {
-    "$schema": { "type": "string" },
-    "canvas": { "$ref": "#/$defs/canvas" },
-    "canvases": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/responsiveCanvas" } },
-    "nodes": { "$ref": "#/$defs/nodes" },
-    "variables": { "type": "array", "items": { "$ref": "#/$defs/variableCollection" } },
-    "styles": { "type": "array", "items": { "$ref": "#/$defs/style" } },
-    "patch": { "$ref": "#/$defs/patchRoot" }
-  },
-  "oneOf": [
-    {
-      "required": ["canvas"],
-      "not": { "anyOf": [{ "required": ["canvases"] }, { "required": ["patch"] }] }
-    },
-    {
-      "required": ["canvases"],
-      "not": { "anyOf": [{ "required": ["canvas"] }, { "required": ["patch"] }] }
-    },
-    {
-      "required": ["patch"],
-      "not": { "anyOf": [{ "required": ["canvas"] }, { "required": ["canvases"] }] }
+function variantAxesUncarriedOptions(set, axes) {
+  const errors = [];
+  const carried = {};
+  for (const axis of Object.keys(axes)) carried[axis] = /* @__PURE__ */ new Set();
+  for (const child of set.children) {
+    if (child.type !== "COMPONENT") continue;
+    for (const [axis, value] of Object.entries(child.properties.variant || {})) {
+      if (carried[axis]) carried[axis].add(value);
     }
-  ],
-  "$defs": {
-    "positiveNumber": { "type": "number", "exclusiveMinimum": 0 },
-    "nonNegativeNumber": { "type": "number", "minimum": 0 },
-    "nullablePositiveNumber": { "type": ["number", "null"], "exclusiveMinimum": 0 },
-    "hexColor": { "type": "string", "pattern": "^#[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$" },
-    "color": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["r", "g", "b"],
-      "properties": {
-        "r": { "type": "number", "minimum": 0, "maximum": 255 },
-        "g": { "type": "number", "minimum": 0, "maximum": 255 },
-        "b": { "type": "number", "minimum": 0, "maximum": 255 },
-        "a": { "type": "number", "minimum": 0, "maximum": 1 }
+  }
+  for (const [axis, options] of Object.entries(axes)) {
+    for (const option of options) {
+      if (!carried[axis]?.has(option)) {
+        errors.push(
+          `variantAxes.${axis}: option '${option}' is not carried by any variant child (add or set a COMPONENT child's variant to '${option}', or use renameOptions)`
+        );
       }
-    },
-    "vector": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["x", "y"],
-      "properties": { "x": { "type": "number" }, "y": { "type": "number" } }
-    },
-    "transform": {
-      "type": "array",
-      "minItems": 2,
-      "maxItems": 2,
-      "items": { "type": "array", "minItems": 3, "maxItems": 3, "items": { "type": "number" } }
-    },
-    "gradientStop": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["at", "color"],
-      "properties": {
-        "at": { "type": "number", "minimum": 0, "maximum": 1 },
-        "color": { "oneOf": [{ "$ref": "#/$defs/hexColor" }, { "$ref": "#/$defs/color" }] }
+    }
+  }
+  return errors;
+}
+function applyVariantRenamesInForest(roots, setId, axisRenames, optionRenames, axes, index) {
+  const childIds = /* @__PURE__ */ new Set();
+  const collectChildren = (node, inside) => {
+    const inSet = inside || node.type === "COMPONENT_SET" && node.id === setId;
+    if (node.type === "COMPONENT" && inSet && node.id !== setId) childIds.add(node.id);
+    const childInside = node.type === "COMPONENT_SET" ? node.id === setId : inSet;
+    for (const child of node.children) collectChildren(child, childInside);
+  };
+  for (const root of roots) collectChildren(root, false);
+  const visit = (node, insideTargetSet) => {
+    const inSet = insideTargetSet || node.type === "COMPONENT_SET" && node.id === setId;
+    if (node.type === "COMPONENT" && inSet && node.id !== setId) {
+      const variant = { ...node.properties.variant || {} };
+      for (const { from, to } of axisRenames) {
+        if (from in variant) {
+          variant[to] = variant[from];
+          delete variant[from];
+        }
       }
-    },
-    "imagePaint": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["image"],
-      "properties": {
-        "image": {
-          "type": "string",
-          "anyOf": [
-            { "pattern": "^https://" },
-            { "pattern": "^file:[^/].+" },
-            { "pattern": "^data:image/(png|jpeg|gif|webp);base64," }
-          ]
-        },
-        "fit": { "enum": ["COVER", "CONTAIN", "CROP", "TILE", "FILL", "FIT"] },
-        "opacity": { "type": "number", "minimum": 0, "maximum": 1 },
-        "transform": { "$ref": "#/$defs/transform" }
+      for (const { axis, from, to } of optionRenames) {
+        if (variant[axis] === from) variant[axis] = to;
       }
-    },
-    "gradientPaint": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["gradient", "stops"],
-      "properties": {
-        "gradient": { "enum": ["LINEAR", "RADIAL", "ANGULAR", "DIAMOND"] },
-        "angle": { "type": "number" },
-        "transform": { "$ref": "#/$defs/transform" },
-        "stops": { "type": "array", "minItems": 2, "items": { "$ref": "#/$defs/gradientStop" } },
-        "opacity": { "type": "number", "minimum": 0, "maximum": 1 }
+      node.properties.variant = Object.keys(variant).length ? variant : void 0;
+      if (Object.keys(axes).length) {
+        node.name = Object.keys(axes).map((axis) => `${axis}=${variant[axis] ?? axes[axis][0]}`).join(", ");
       }
-    },
-    "solidPaint": {
-      "type": "object",
+    }
+    if (node.type === "INSTANCE" && node.properties.instanceProperties) {
+      const mainId = node.properties.componentId;
+      if (!mainId || !childIds.has(mainId)) {
+      } else {
+        const next = {};
+        for (const [key, value] of Object.entries(node.properties.instanceProperties)) {
+          let newKey = key;
+          for (const { from, to } of axisRenames) if (key === from) newKey = to;
+          let newValue = value;
+          if (typeof value === "string") {
+            for (const { axis, from, to } of optionRenames) {
+              if (newKey === axis && value === from) newValue = to;
+            }
+          }
+          next[newKey] = newValue;
+        }
+        node.properties.instanceProperties = next;
+      }
+    }
+    const childInside = node.type === "COMPONENT_SET" ? node.id === setId : inSet;
+    for (const child of node.children) visit(child, childInside);
+  };
+  for (const root of roots) visit(root, false);
+  void index;
+}
+function applyComponentPropertiesPatch(props, patch, path) {
+  const errors = [];
+  if (patch === null) {
+    delete props.componentProperties;
+    return errors;
+  }
+  const list = [...props.componentProperties || []];
+  const indexByName = () => {
+    const map = /* @__PURE__ */ new Map();
+    list.forEach((property, index) => map.set(property.name, index));
+    return map;
+  };
+  let byName = indexByName();
+  for (const [name, entry] of Object.entries(patch)) {
+    if (entry === null) {
+      const index = byName.get(name);
+      if (index === void 0) continue;
+      list.splice(index, 1);
+      byName = indexByName();
+      continue;
+    }
+    const existingIndex = byName.get(name);
+    if (existingIndex === void 0) {
+      if (!entry.type) {
+        errors.push(`${path}.componentProperties.${name}: type is required when creating a property`);
+        continue;
+      }
+      if (entry.defaultValue === void 0) {
+        errors.push(`${path}.componentProperties.${name}: defaultValue is required when creating a property`);
+        continue;
+      }
+      list.push({
+        name,
+        type: entry.type,
+        defaultValue: entry.defaultValue,
+        ...entry.options ? { options: entry.options } : {}
+      });
+      byName = indexByName();
+      continue;
+    }
+    const existing = list[existingIndex];
+    if (entry.type !== void 0 && entry.type !== existing.type) {
+      errors.push(`${path}.componentProperties.${name}: type is immutable after create (was ${existing.type}, got ${entry.type})`);
+      continue;
+    }
+    list[existingIndex] = {
+      ...existing,
+      ...entry.defaultValue !== void 0 ? { defaultValue: entry.defaultValue } : {},
+      ...entry.options !== void 0 ? { options: entry.options } : {}
+    };
+  }
+  if (list.length) props.componentProperties = list;
+  else delete props.componentProperties;
+  return errors;
+}
+function applyVariantPatchOnComponent(node, parent, patch, path) {
+  const errors = [];
+  if (!parent || parent.type !== "COMPONENT_SET") {
+    errors.push(`${path}.variant: only applies to COMPONENT children of a COMPONENT_SET`);
+    return errors;
+  }
+  if (patch === null) {
+    errors.push(`${path}.variant: clearing variant on a COMPONENT inside a COMPONENT_SET is not supported (variant components require a selection)`);
+    return errors;
+  }
+  const axes = parent.properties.variantAxes || {};
+  const variant = { ...node.properties.variant || {} };
+  for (const [axis, value] of Object.entries(patch)) {
+    if (value === null) {
+      errors.push(`${path}.variant.${axis}: clearing an axis on a variant COMPONENT is not supported`);
+      continue;
+    }
+    if (!axes[axis]) {
+      errors.push(`${path}.variant.${axis}: axis '${axis}' is not declared on the parent COMPONENT_SET`);
+      continue;
+    }
+    if (!axes[axis].includes(value)) {
+      errors.push(`${path}.variant.${axis}: value '${value}' is not declared in variantAxes`);
+      continue;
+    }
+    variant[axis] = value;
+  }
+  node.properties.variant = Object.keys(variant).length ? variant : void 0;
+  if (Object.keys(axes).length) {
+    node.name = Object.keys(axes).map((axis) => `${axis}=${variant[axis] ?? axes[axis][0]}`).join(", ");
+  }
+  return errors;
+}
+function rewriteVariantChildNames(set) {
+  const axes = set.properties.variantAxes || {};
+  for (const child of set.children) {
+    if (child.type !== "COMPONENT") continue;
+    const selected = child.properties.variant || {};
+    child.name = Object.keys(axes).map((axis) => `${axis}=${selected[axis] ?? axes[axis][0]}`).join(", ");
+  }
+}
+
+// src/patch-duplicate.ts
+function collectSubtreeIds(node) {
+  const ids = [node.id];
+  for (const child of node.children) ids.push(...collectSubtreeIds(child));
+  return ids;
+}
+function subtreeContainsType(node, types) {
+  if (types.has(node.type)) return true;
+  return node.children.some((child) => subtreeContainsType(child, types));
+}
+function buildDuplicateIdMap(source, idSuffix, ids, path) {
+  return buildDuplicateIdMapFromIds(collectSubtreeIds(source), idSuffix, ids, path);
+}
+function buildDuplicateIdMapFromIds(subtreeIds, idSuffix, ids, path) {
+  const errors = [];
+  if (typeof idSuffix !== "string" || !idSuffix) {
+    errors.push(`${path}.idSuffix: must be a non-empty string`);
+    return { map: /* @__PURE__ */ new Map(), errors };
+  }
+  const subtree = new Set(subtreeIds);
+  const map = /* @__PURE__ */ new Map();
+  for (const id of subtree) map.set(id, `${id}${idSuffix}`);
+  if (ids !== void 0) {
+    if (!ids || typeof ids !== "object" || Array.isArray(ids)) {
+      errors.push(`${path}.ids: must be an object of sourceId\u2192newId`);
+    } else {
+      for (const [from, to] of Object.entries(ids)) {
+        if (!subtree.has(from)) {
+          errors.push(`${path}.ids.${from}: is not an id in the source subtree`);
+          continue;
+        }
+        if (typeof to !== "string" || !to) {
+          errors.push(`${path}.ids.${from}: new id must be a non-empty string`);
+          continue;
+        }
+        map.set(from, to);
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const [from, to] of map) {
+    const prior = seen.get(to);
+    if (prior !== void 0) {
+      errors.push(`${path}: duplicate maps both '${prior}' and '${from}' to '${to}'`);
+    } else {
+      seen.set(to, from);
+    }
+  }
+  return { map, errors };
+}
+function cloneSubtreeWithIds(node, idMap) {
+  const mappedId = idMap.get(node.id) || node.id;
+  const properties = cloneValue(node.properties);
+  rewritePrototypeDestinations(properties, idMap);
+  return {
+    ...node,
+    id: mappedId,
+    properties,
+    children: node.children.map((child) => cloneSubtreeWithIds(child, idMap))
+  };
+}
+function cloneValue(value) {
+  if (Array.isArray(value)) return value.map(cloneValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneValue(item)]));
+  }
+  return value;
+}
+function rewritePrototypeDestinations(properties, idMap) {
+  const prototype = properties.prototype;
+  if (!Array.isArray(prototype)) return;
+  for (const reaction of prototype) {
+    if (!reaction || typeof reaction !== "object" || Array.isArray(reaction)) continue;
+    const actions = reaction.actions;
+    if (!Array.isArray(actions)) continue;
+    for (const action of actions) {
+      if (!action || typeof action !== "object" || Array.isArray(action)) continue;
+      const dest = action.destination;
+      if (typeof dest === "string" && idMap.has(dest)) {
+        action.destination = idMap.get(dest);
+      }
+    }
+  }
+}
+function remapDelimitedIds(text, idMap) {
+  if (!text || idMap.size === 0) return text;
+  const entries = [...idMap.entries()].sort((a, b) => b[0].length - a[0].length);
+  let result = text;
+  for (const [from, to] of entries) {
+    result = result.split(`'${from}'`).join(`'${to}'`);
+    result = result.split(`"${from}"`).join(`"${to}"`);
+  }
+  return result;
+}
+function remapIssueKeyThroughDuplicate(key, idMap) {
+  const parts = key.split("|");
+  if (parts.length < 4) return null;
+  const [code, owner, rest, ...messageParts] = parts;
+  const message = messageParts.join("|");
+  let nextOwner = owner;
+  let changed = false;
+  if (owner.startsWith("node:")) {
+    const id = owner.slice("node:".length);
+    const mapped = idMap.get(id);
+    if (mapped) {
+      nextOwner = `node:${mapped}`;
+      changed = true;
+    }
+  }
+  const nextRest = remapDelimitedIds(rest, idMap);
+  const nextMessage = remapDelimitedIds(message, idMap);
+  if (nextRest !== rest || nextMessage !== message) changed = true;
+  return changed ? `${code}|${nextOwner}|${nextRest}|${nextMessage}` : null;
+}
+
+// src/patch-prototype.ts
+var DESTINATION_ACTIONS = /* @__PURE__ */ new Set(["NAVIGATE", "SWAP", "OVERLAY", "SCROLL_TO", "CHANGE_TO"]);
+var TOP_LEVEL_NAV_ACTIONS = /* @__PURE__ */ new Set(["NAVIGATE", "SWAP", "OVERLAY"]);
+function triggerType(reaction) {
+  const trigger = reaction.trigger;
+  if (typeof trigger === "string") return trigger;
+  if (trigger && typeof trigger === "object" && !Array.isArray(trigger) && typeof trigger.type === "string") {
+    return String(trigger.type);
+  }
+  return "";
+}
+function reactionActions(reaction) {
+  if (Array.isArray(reaction.actions)) {
+    return reaction.actions.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item));
+  }
+  if (reaction.action) return [{ ...reaction, type: reaction.action }];
+  return [];
+}
+function forEachPrototypeDestination(prototype, visit, basePath = "prototype") {
+  if (!Array.isArray(prototype)) return;
+  prototype.forEach((reaction, index) => {
+    if (!reaction || typeof reaction !== "object" || Array.isArray(reaction)) return;
+    reactionActions(reaction).forEach((action, actionIndex) => {
+      const type = String(action.type || "").toUpperCase();
+      if (!DESTINATION_ACTIONS.has(type)) return;
+      const destination = action.destination;
+      if (typeof destination !== "string") return;
+      visit(action, type, destination, `${basePath}[${index}].actions[${actionIndex}]`);
+    });
+  });
+}
+function isAfterTimeoutReaction(reaction) {
+  return triggerType(reaction) === "AFTER_TIMEOUT";
+}
+function isTopLevelNodeId(roots, nodeId) {
+  return roots.some((root) => root.id === nodeId);
+}
+function assertPrototypeSetDestinations(prototype, lookup, path, sourceId) {
+  const errors = [];
+  if (!Array.isArray(prototype)) {
+    errors.push(`${path}: prototype must be an array`);
+    return errors;
+  }
+  forEachPrototypeDestination(prototype, (_action, type, destination, actionPath) => {
+    if (!lookup.has(destination)) {
+      errors.push(`${actionPath}.destination: Prototype destination '${destination}' was not found`);
+      return;
+    }
+    if (type === "CHANGE_TO") {
+      const destType = lookup.typeOf?.(destination);
+      if (destType && destType !== "COMPONENT") {
+        errors.push(`${actionPath}.destination: CHANGE_TO destination '${destination}' must be a component variant, received ${destType}`);
+      }
+    }
+    if (type === "SCROLL_TO" && sourceId && lookup.canvasOf) {
+      const sourceCanvas = lookup.canvasOf(sourceId);
+      const destCanvas = lookup.canvasOf(destination);
+      if (sourceCanvas && destCanvas && sourceCanvas !== destCanvas) {
+        errors.push(`${actionPath}.destination: SCROLL_TO destination '${destination}' must be inside the same top-level canvas as its source`);
+      }
+    }
+  }, path);
+  return errors;
+}
+function assertPrototypePatchRules(prototype, lookup, path, sourceId, sourceIsTopLevel) {
+  const errors = assertPrototypeSetDestinations(prototype, lookup, path, sourceId);
+  if (!Array.isArray(prototype)) return errors;
+  if (!sourceIsTopLevel) {
+    prototype.forEach((reaction, index) => {
+      if (!reaction || typeof reaction !== "object" || Array.isArray(reaction)) return;
+      if (isAfterTimeoutReaction(reaction)) {
+        errors.push(`${path}[${index}].trigger: AFTER_TIMEOUT in set.prototype requires a top-level target node`);
+      }
+    });
+  }
+  forEachPrototypeDestination(prototype, (_action, type, destination, actionPath) => {
+    if (!TOP_LEVEL_NAV_ACTIONS.has(type)) return;
+    if (!lookup.has(destination)) return;
+    if (lookup.isTopLevel && !lookup.isTopLevel(destination)) {
+      errors.push(`${actionPath}.destination: ${type} destination must be a top-level frame; use '${lookup.canvasOf?.(destination) || destination}'`);
+    }
+  }, path);
+  return errors;
+}
+function canvasRootId(roots, nodeId) {
+  const find = (nodes, rootId) => {
+    for (const node of nodes) {
+      if (node.id === nodeId) return rootId;
+      const nested = find(node.children, rootId);
+      if (nested) return nested;
+    }
+    return void 0;
+  };
+  for (const root of roots) {
+    const hit = find([root], root.id);
+    if (hit) return hit;
+  }
+  return void 0;
+}
+function documentLookup(document) {
+  const types = /* @__PURE__ */ new Map();
+  const collect = (node) => {
+    types.set(node.id, node.type);
+    node.children.forEach(collect);
+  };
+  document.nodes.forEach(collect);
+  return {
+    has: (id) => types.has(id),
+    typeOf: (id) => types.get(id),
+    canvasOf: (id) => canvasRootId(document.nodes, id),
+    isTopLevel: (id) => isTopLevelNodeId(document.nodes, id)
+  };
+}
+function prototypeDestinationErrors(document) {
+  const lookup = documentLookup(document);
+  const errors = [];
+  const walk = (node, path) => {
+    if (node.properties.prototype) {
+      errors.push(...assertPrototypeSetDestinations(node.properties.prototype, lookup, `${path}.prototype`, node.id));
+    }
+    node.children.forEach((child, index) => walk(child, `${path}.children[${index}]`));
+  };
+  document.nodes.forEach((node, index) => walk(node, `nodes[${index}]`));
+  return errors;
+}
+function prototypePatchStrictErrors(document) {
+  const lookup = documentLookup(document);
+  const errors = [];
+  const walk = (node, path) => {
+    if (node.properties.prototype) {
+      errors.push(...assertPrototypePatchRules(
+        node.properties.prototype,
+        lookup,
+        `${path}.prototype`,
+        node.id,
+        isTopLevelNodeId(document.nodes, node.id)
+      ));
+    }
+    node.children.forEach((child, index) => walk(child, `${path}.children[${index}]`));
+  };
+  document.nodes.forEach((node, index) => walk(node, `nodes[${index}]`));
+  return errors;
+}
+
+// src/constants.ts
+var SUPPORTED_NODE_TYPES = /* @__PURE__ */ new Set([
+  "FRAME",
+  "GROUP",
+  "RECTANGLE",
+  "ELLIPSE",
+  "LINE",
+  "TEXT",
+  "VECTOR",
+  "SVG",
+  "COMPONENT",
+  "COMPONENT_SET",
+  "INSTANCE",
+  "BOOLEAN_OPERATION",
+  "POLYGON",
+  "STAR",
+  "SECTION",
+  "SLICE",
+  "ARC"
+]);
+var SUPPORTED_PAINT_TYPES = /* @__PURE__ */ new Set([
+  "SOLID",
+  "GRADIENT_LINEAR",
+  "GRADIENT_RADIAL",
+  "GRADIENT_ANGULAR",
+  "GRADIENT_DIAMOND",
+  "IMAGE"
+]);
+
+// src/validate.ts
+function validateDocument(document, limit = 30) {
+  const errors = [];
+  const ids = /* @__PURE__ */ new Set();
+  const components = /* @__PURE__ */ new Set();
+  const nodeTypes = /* @__PURE__ */ new Map();
+  const add = (path, message) => {
+    if (errors.length < limit) errors.push(`${path}: ${message}`);
+  };
+  const finite = (value) => typeof value === "number" && Number.isFinite(value);
+  const triggers = /* @__PURE__ */ new Set(["ON_CLICK", "ON_HOVER", "ON_PRESS", "ON_DRAG", "AFTER_TIMEOUT", "MOUSE_UP", "MOUSE_DOWN", "MOUSE_ENTER", "MOUSE_LEAVE", "ON_KEY_DOWN", "ON_MEDIA_HIT", "ON_MEDIA_END"]);
+  const actions = /* @__PURE__ */ new Set(["NAVIGATE", "SWAP", "OVERLAY", "SCROLL_TO", "CHANGE_TO", "BACK", "CLOSE", "URL", "UPDATE_MEDIA_RUNTIME", "SET_VARIABLE", "SET_VARIABLE_MODE", "CONDITIONAL"]);
+  function validateAction(value, path) {
+    if (!value || typeof value !== "object") return add(path, "action must be an object");
+    const action = value;
+    const type = String(action.type || "");
+    if (!actions.has(type)) add(`${path}.type`, `unsupported prototype action '${type}'`);
+    if (["NAVIGATE", "SWAP", "OVERLAY", "SCROLL_TO", "CHANGE_TO"].includes(type) && typeof action.destination !== "string") add(`${path}.destination`, `${type} requires a destination ID`);
+    if (type === "URL" && typeof action.url !== "string") add(`${path}.url`, "URL action requires url");
+    if (type === "SET_VARIABLE" && typeof (action.variable || action.variableId) !== "string") add(`${path}.variable`, "SET_VARIABLE requires a variable reference");
+    if (type === "SET_VARIABLE_MODE" && (typeof (action.collection || action.variableCollectionId) !== "string" || typeof (action.mode || action.variableModeId) !== "string")) add(path, "SET_VARIABLE_MODE requires collection and mode references");
+    if (type === "UPDATE_MEDIA_RUNTIME" && typeof action.mediaAction !== "string") add(`${path}.mediaAction`, "UPDATE_MEDIA_RUNTIME requires mediaAction");
+    if (type === "CONDITIONAL") {
+      const blocks = action.blocks || action.conditionalBlocks;
+      if (!Array.isArray(blocks) || !blocks.length) add(`${path}.blocks`, "CONDITIONAL requires at least one block");
+      else blocks.forEach((block, index) => {
+        if (block && typeof block === "object" && !Array.isArray(block)) {
+          const nested = block.actions;
+          if (Array.isArray(nested)) nested.forEach((item, actionIndex) => validateAction(item, `${path}.blocks[${index}].actions[${actionIndex}]`));
+        }
+      });
+    }
+  }
+  function validatePrototype(values, path) {
+    values.forEach((reaction, index) => {
+      const reactionPath = `${path}[${index}]`;
+      const triggerValue = reaction.trigger;
+      const trigger = typeof triggerValue === "string" ? triggerValue : triggerValue && typeof triggerValue === "object" && !Array.isArray(triggerValue) && typeof triggerValue.type === "string" ? triggerValue.type : "";
+      if (!triggers.has(trigger)) add(`${reactionPath}.trigger`, `unsupported trigger '${trigger}'`);
+      const reactionActions2 = Array.isArray(reaction.actions) ? reaction.actions : reaction.action ? [{ ...reaction, type: reaction.action }] : [];
+      if (!reactionActions2.length) add(`${reactionPath}.actions`, "reaction requires at least one action");
+      reactionActions2.forEach((action, actionIndex) => validateAction(action, `${reactionPath}.actions[${actionIndex}]`));
+    });
+  }
+  function validatePaint(value, path) {
+    if (!value || typeof value !== "object") return add(path, "paint must be an object or valid hex color");
+    if (!SUPPORTED_PAINT_TYPES.has(value.type)) add(`${path}.type`, `unsupported paint type '${value.type}'`);
+    if (value.type === "IMAGE") {
+      if (typeof value.src !== "string" || !/^https:\/\//i.test(value.src) && !/^file:[^/].+/i.test(value.src) && !/^data:image\/(png|jpeg|gif|webp);base64,/i.test(value.src)) add(`${path}.src`, "IMAGE requires HTTPS, file:filename, or an embedded image data URL");
+      if (!value.scaleMode || !["FILL", "FIT", "CROP", "TILE"].includes(value.scaleMode)) add(`${path}.scaleMode`, "must be COVER/FILL, CONTAIN/FIT, CROP, or TILE");
+      if (value.imageTransform !== void 0 && (!Array.isArray(value.imageTransform) || value.imageTransform.length !== 2)) add(`${path}.imageTransform`, "must be a 2\xD73 transform matrix");
+    }
+    if (value.type?.startsWith("GRADIENT_") && (!Array.isArray(value.gradientStops) || value.gradientStops.length < 2)) add(`${path}.gradientStops`, "gradient requires at least two stops");
+    if (value.opacity !== void 0 && (!finite(value.opacity) || value.opacity < 0 || value.opacity > 1)) add(`${path}.opacity`, "must be 0\u20131");
+  }
+  const componentPropsById = /* @__PURE__ */ new Map();
+  function owningComponentProperties(ancestors) {
+    for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+      const ancestor = ancestors[index];
+      if (ancestor.type === "INSTANCE") return null;
+      if (ancestor.type === "COMPONENT") return ancestor.componentProperties || [];
+    }
+    return null;
+  }
+  function validateComponentPropertyReferences(node, path, ancestors) {
+    const refs = node.properties.componentPropertyReferences;
+    if (refs === void 0) return;
+    if (!refs || typeof refs !== "object" || Array.isArray(refs)) return add(`${path}.componentPropertyReferences`, "must be an object");
+    const owning = owningComponentProperties(ancestors);
+    if (owning === null) return add(`${path}.componentPropertyReferences`, "must be on a descendant of a COMPONENT and must not cross a nested INSTANCE");
+    const byName = new Map(owning.map((property) => [property.name, property]));
+    const entries = refs;
+    for (const field of Object.keys(entries)) {
+      if (!["characters", "visible", "mainComponent"].includes(field)) add(`${path}.componentPropertyReferences.${field}`, "supported fields are characters, visible, and mainComponent");
+    }
+    const characters = entries.characters;
+    if (characters !== void 0) {
+      if (typeof characters !== "string" || !characters) add(`${path}.componentPropertyReferences.characters`, "must be a non-empty property name");
+      else if (node.type !== "TEXT") add(`${path}.componentPropertyReferences.characters`, "characters may only be set on TEXT nodes");
+      else {
+        const property = byName.get(characters);
+        if (!property) add(`${path}.componentPropertyReferences.characters`, `property '${characters}' is not defined on the owning COMPONENT`);
+        else if (property.type !== "TEXT") add(`${path}.componentPropertyReferences.characters`, `property '${characters}' has type ${property.type} but characters requires TEXT`);
+      }
+    }
+    const visible = entries.visible;
+    if (visible !== void 0) {
+      if (typeof visible !== "string" || !visible) add(`${path}.componentPropertyReferences.visible`, "must be a non-empty property name");
+      else {
+        const property = byName.get(visible);
+        if (!property) add(`${path}.componentPropertyReferences.visible`, `property '${visible}' is not defined on the owning COMPONENT`);
+        else if (property.type !== "BOOLEAN") add(`${path}.componentPropertyReferences.visible`, `property '${visible}' has type ${property.type} but visible requires BOOLEAN`);
+      }
+    }
+    const mainComponent = entries.mainComponent;
+    if (mainComponent !== void 0) {
+      if (typeof mainComponent !== "string" || !mainComponent) add(`${path}.componentPropertyReferences.mainComponent`, "must be a non-empty property name");
+      else if (node.type !== "INSTANCE") add(`${path}.componentPropertyReferences.mainComponent`, "mainComponent may only be set on INSTANCE nodes");
+      else {
+        const property = byName.get(mainComponent);
+        if (!property) add(`${path}.componentPropertyReferences.mainComponent`, `property '${mainComponent}' is not defined on the owning COMPONENT`);
+        else if (property.type !== "INSTANCE_SWAP") add(`${path}.componentPropertyReferences.mainComponent`, `property '${mainComponent}' has type ${property.type} but mainComponent requires INSTANCE_SWAP`);
+      }
+    }
+  }
+  function walk(node, path, ancestors = []) {
+    if (ids.has(node.id)) add(`${path}.id`, `duplicate ID '${node.id}'`);
+    else ids.add(node.id);
+    if (!SUPPORTED_NODE_TYPES.has(node.type)) add(`${path}.type`, `unsupported node type '${node.type}'`);
+    nodeTypes.set(node.id, node.type);
+    if (node.type === "COMPONENT") {
+      components.add(node.id);
+      if (node.properties.componentProperties) componentPropsById.set(node.id, node.properties.componentProperties);
+    }
+    const props = node.properties;
+    if (!finite(props.position?.x) || !finite(props.position?.y)) add(`${path}.position`, "x and y must be finite numbers");
+    if (!finite(props.size?.width) || props.size.width <= 0 || !finite(props.size?.height) || props.size.height <= 0) add(`${path}.size`, "w and h must be positive finite numbers");
+    if (props.cornerRadius !== void 0 && (!finite(props.cornerRadius) || props.cornerRadius < 0)) add(`${path}.cornerRadius`, "must be non-negative");
+    if (props.cornerRadii !== void 0 && (!Array.isArray(props.cornerRadii) || props.cornerRadii.length !== 4 || props.cornerRadii.some((n) => !finite(n) || n < 0))) add(`${path}.cornerRadii`, "must contain four non-negative numbers");
+    if (props.layout) {
+      if (!props.layout.direction || !["HORIZONTAL", "VERTICAL", "GRID"].includes(props.layout.direction)) add(`${path}.layout.direction`, "must be HORIZONTAL, VERTICAL, or GRID");
+      for (const key of ["primaryAxisSizingMode", "counterAxisSizingMode"]) {
+        const value = props.layout[key];
+        if (value !== void 0 && !["FIXED", "HUG", "AUTO"].includes(value)) add(`${path}.layout.${key}`, "must be FIXED or HUG");
+      }
+      if (props.layout.primaryAxisAlignItems !== void 0 && !["MIN", "MAX", "CENTER", "SPACE_BETWEEN"].includes(props.layout.primaryAxisAlignItems)) add(`${path}.layout.primaryAxisAlignItems`, "must be MIN, MAX, CENTER, or SPACE_BETWEEN");
+      if (props.layout.counterAxisAlignItems !== void 0 && !["MIN", "MAX", "CENTER", "BASELINE", "STRETCH"].includes(props.layout.counterAxisAlignItems)) add(`${path}.layout.counterAxisAlignItems`, "must be MIN, MAX, CENTER, BASELINE, or STRETCH");
+    }
+    for (const key of ["fills", "strokes"]) props.styles[key].forEach((item, index) => validatePaint(item, `${path}.${key}[${index}]`));
+    if (node.type === "TEXT" && typeof props.text !== "string") add(`${path}.text`, "TEXT requires text or runs");
+    if (node.type === "SVG" && typeof props.svg !== "string") add(`${path}.svg`, "SVG requires markup");
+    if (node.type === "VECTOR" && !Array.isArray(props.vectorPaths)) add(`${path}.vectorPaths`, "VECTOR requires vectorPaths");
+    if (node.type === "INSTANCE" && typeof props.componentId !== "string") add(`${path}.componentId`, "INSTANCE requires componentId");
+    if (node.type === "BOOLEAN_OPERATION" && (typeof props.operation !== "string" || !["UNION", "SUBTRACT", "INTERSECT", "EXCLUDE"].includes(props.operation))) add(`${path}.operation`, "BOOLEAN_OPERATION requires operation UNION, SUBTRACT, INTERSECT, or EXCLUDE");
+    if (node.type === "COMPONENT_SET" && (!node.children.length || node.children.some((child) => child.type !== "COMPONENT"))) add(`${path}.children`, "COMPONENT_SET requires COMPONENT children");
+    if (node.type === "COMPONENT_SET" && props.variantAxes) {
+      for (const [axis, options] of Object.entries(props.variantAxes)) if (!axis || !Array.isArray(options) || !options.length || options.some((option) => typeof option !== "string")) add(`${path}.variantAxes.${axis}`, "must be a non-empty string array");
+      const variantAxes = props.variantAxes;
+      node.children.forEach((child, index) => Object.entries(child.properties.variant || {}).forEach(([axis, value]) => {
+        if (!variantAxes[axis]?.includes(value)) add(`${path}.children[${index}].variant.${axis}`, `value '${value}' is not declared in variantAxes`);
+      }));
+      for (const message of variantAxesUncarriedOptions(node, variantAxes)) {
+        const match = /^variantAxes\.([^:]+):\s*(.*)$/.exec(message);
+        if (match) add(`${path}.variantAxes.${match[1]}`, match[2]);
+        else add(path, message);
+      }
+    }
+    if (props.prototype !== void 0) Array.isArray(props.prototype) ? validatePrototype(props.prototype, `${path}.prototype`) : add(`${path}.prototype`, "must be an array of reactions");
+    if (["GROUP", "BOOLEAN_OPERATION"].includes(node.type) && !node.children.length) add(`${path}.children`, `${node.type} requires children`);
+    validateComponentPropertyReferences(node, path, ancestors);
+    const nextAncestors = [...ancestors, { type: node.type, id: node.id, componentProperties: props.componentProperties }];
+    node.children.forEach((child, index) => walk(child, `${path}.children[${index}]`, nextAncestors));
+  }
+  document.nodes.forEach((node, index) => walk(node, `nodes[${index}]`));
+  function requireComponentId(targetId, issuePath) {
+    const targetType = nodeTypes.get(targetId);
+    if (!targetType) add(issuePath, `component '${targetId}' is not defined in this import`);
+    else if (targetType !== "COMPONENT") add(issuePath, `'${targetId}' is a ${targetType} but INSTANCE_SWAP requires a COMPONENT`);
+  }
+  function references(node, path) {
+    if (node.type === "INSTANCE" && (!node.properties.componentId || !components.has(node.properties.componentId))) add(`${path}.componentId`, `component '${node.properties.componentId || ""}' is not defined in this import`);
+    if (node.type === "COMPONENT" && node.properties.componentProperties) {
+      node.properties.componentProperties.forEach((property, index) => {
+        if (property.type !== "INSTANCE_SWAP") return;
+        if (typeof property.defaultValue !== "string" || !property.defaultValue) {
+          add(`${path}.componentProperties[${index}].defaultValue`, "INSTANCE_SWAP requires a component id string");
+          return;
+        }
+        requireComponentId(property.defaultValue, `${path}.componentProperties[${index}].defaultValue`);
+      });
+    }
+    const overrides = node.properties.instanceProperties;
+    if (node.type === "INSTANCE" && overrides && typeof node.properties.componentId === "string") {
+      const declared = componentPropsById.get(node.properties.componentId);
+      if (declared) {
+        const byName = new Map(declared.map((property) => [property.name, property]));
+        for (const [key, value] of Object.entries(overrides)) {
+          const property = byName.get(key);
+          if (!property) {
+            add(`${path}.instanceProperties.${key}`, `property '${key}' is not defined on component '${node.properties.componentId}'`);
+            continue;
+          }
+          if (property.type === "BOOLEAN" && typeof value !== "boolean") add(`${path}.instanceProperties.${key}`, `property '${key}' expects a boolean`);
+          else if ((property.type === "TEXT" || property.type === "INSTANCE_SWAP") && typeof value !== "string" && !(value && typeof value === "object" && value.type === "VARIABLE_ALIAS")) add(`${path}.instanceProperties.${key}`, `property '${key}' expects a string`);
+          else if (property.type === "INSTANCE_SWAP" && typeof value === "string") requireComponentId(value, `${path}.instanceProperties.${key}`);
+        }
+      }
+    }
+    node.children.forEach((child, index) => references(child, `${path}.children[${index}]`));
+  }
+  document.nodes.forEach((node, index) => references(node, `nodes[${index}]`));
+  const styleKeys = /* @__PURE__ */ new Map();
+  for (const style of document.styles || []) {
+    if (typeof style.id === "string" && style.id) styleKeys.set(style.id, style.type);
+    if (typeof style.name === "string" && style.name) styleKeys.set(style.name, style.type);
+  }
+  const variableKeys = /* @__PURE__ */ new Set();
+  const collectionNames = /* @__PURE__ */ new Set();
+  const modesByCollection = /* @__PURE__ */ new Map();
+  for (const [collectionIndex, collection] of (document.variables || []).entries()) {
+    const modes = Array.isArray(collection.modes) && collection.modes.length ? collection.modes : [];
+    if (collection.modes !== void 0 && (!modes.length || modes.some((mode) => typeof mode !== "string"))) add(`variables[${collectionIndex}].modes`, "must be a non-empty array of mode names");
+    if (typeof collection.name === "string" && collection.name) {
+      collectionNames.add(collection.name);
+      if (collection.modes !== void 0 && modes.length && modes.every((mode) => typeof mode === "string")) {
+        modesByCollection.set(collection.name, modes);
+      }
+    }
+    for (const [variableIndex, variable] of (collection.items || []).entries()) {
+      const path = `variables[${collectionIndex}].items[${variableIndex}]`;
+      if (!variable.name || typeof variable.name !== "string") add(`${path}.name`, "must be a non-empty string");
+      if (!["COLOR", "FLOAT", "STRING", "BOOLEAN"].includes(variable.type)) add(`${path}.type`, "must be COLOR, FLOAT, STRING, or BOOLEAN");
+      if (typeof variable.id === "string" && variable.id) variableKeys.add(variable.id);
+      if (typeof variable.name === "string" && variable.name) variableKeys.add(variable.name);
+      const values = variable.values || (variable.value !== void 0 ? { default: variable.value } : {});
+      if (!Object.keys(values).length) add(`${path}`, "requires value or values");
+      if (variable.values && modes.length) {
+        for (const mode of modes) if (!(mode in variable.values)) add(`${path}.values.${mode}`, "missing value for declared mode");
+      }
+      for (const [mode, value] of Object.entries(values)) {
+        if (variable.type === "FLOAT" && !finite(value)) add(`${path}.${mode}`, "FLOAT value must be a finite number");
+        if (variable.type === "STRING" && typeof value !== "string") add(`${path}.${mode}`, "STRING value must be a string");
+        if (variable.type === "BOOLEAN" && typeof value !== "boolean") add(`${path}.${mode}`, "BOOLEAN value must be true or false");
+        const color = value && typeof value === "object" && !Array.isArray(value) ? value : null;
+        if (variable.type === "COLOR" && (!color || !finite(color.r) || !finite(color.g) || !finite(color.b))) add(`${path}.${mode}`, "COLOR value requires numeric r, g, and b channels");
+      }
+    }
+  }
+  function tokenReferences(node, path) {
+    const bindings = node.properties.bindings;
+    if (bindings) {
+      for (const [field, key] of Object.entries(bindings)) {
+        if (typeof key !== "string" || !key) {
+          add(`${path}.bindings.${field}`, "must be a non-empty variable id or name");
+          continue;
+        }
+        if (!variableKeys.has(key)) add(`${path}.bindings.${field}`, `variable '${key}' is not defined in this document`);
+      }
+    }
+    const variableModes = node.properties.variableModes;
+    if (variableModes) {
+      for (const [collectionName, modeName] of Object.entries(variableModes)) {
+        if (!collectionNames.has(collectionName)) {
+          add(`${path}.variableModes.${collectionName}`, `variable collection '${collectionName}' is not defined in this document`);
+          continue;
+        }
+        if (typeof modeName !== "string" || !modeName) {
+          add(`${path}.variableModes.${collectionName}`, "must be a non-empty mode name");
+          continue;
+        }
+        const declared = modesByCollection.get(collectionName);
+        if (declared && !declared.includes(modeName)) add(`${path}.variableModes.${collectionName}`, `mode '${modeName}' is not declared on collection '${collectionName}'`);
+      }
+    }
+    const styleRefs = node.properties.styleRefs;
+    if (styleRefs) {
+      for (const [field, key] of Object.entries(styleRefs)) {
+        if (typeof key !== "string" || !key) {
+          add(`${path}.styleRefs.${field}`, "must be a non-empty style id or name");
+          continue;
+        }
+        const styleType = styleKeys.get(key);
+        if (!styleType) {
+          add(`${path}.styleRefs.${field}`, `style '${key}' is not defined in this document`);
+          continue;
+        }
+        if ((field === "fill" || field === "stroke") && styleType !== "PAINT") {
+          add(`${path}.styleRefs.${field}`, `style '${key}' has type ${styleType} but ${field} requires PAINT`);
+        } else if (field === "text" && styleType !== "TEXT") {
+          add(`${path}.styleRefs.${field}`, `style '${key}' has type ${styleType} but text requires TEXT`);
+        }
+      }
+    }
+    node.children.forEach((child, index) => tokenReferences(child, `${path}.children[${index}]`));
+  }
+  document.nodes.forEach((node, index) => tokenReferences(node, `nodes[${index}]`));
+  for (const message of prototypeDestinationErrors(document)) {
+    const split = message.indexOf(": ");
+    add(split > 0 ? message.slice(0, split) : "$", split > 0 ? message.slice(split + 2) : message);
+  }
+  return errors;
+}
+function documentIssueOwners(document) {
+  const nodePaths = /* @__PURE__ */ new Map();
+  const visit = (node, path) => {
+    nodePaths.set(path, node.id);
+    node.children.forEach((child, index) => visit(child, `${path}.children[${index}]`));
+  };
+  document.nodes.forEach((node, index) => visit(node, `nodes[${index}]`));
+  const variablePaths = /* @__PURE__ */ new Map();
+  (document.variables || []).forEach((collection, collectionIndex) => {
+    const collectionKey = typeof collection.name === "string" && collection.name ? collection.name : `#${collectionIndex}`;
+    variablePaths.set(`variables[${collectionIndex}]`, `collection:${collectionKey}`);
+    (collection.items || []).forEach((variable, variableIndex) => {
+      const variableKey = typeof variable.id === "string" && variable.id ? variable.id : typeof variable.name === "string" && variable.name ? variable.name : `#${variableIndex}`;
+      variablePaths.set(`variables[${collectionIndex}].items[${variableIndex}]`, `variable:${collectionKey}/${variableKey}`);
+    });
+  });
+  const longest = (paths, path) => {
+    let best;
+    for (const [prefix, owner] of paths) if ((path === prefix || path.startsWith(`${prefix}.`)) && (!best || prefix.length > best[0].length)) best = [prefix, owner];
+    return best;
+  };
+  return (path) => {
+    const node = longest(nodePaths, path);
+    if (node) return { owner: `node:${node[1]}`, nodeId: node[1], rest: path.slice(node[0].length) };
+    const variable = longest(variablePaths, path);
+    if (variable) return { owner: variable[1], rest: path.slice(variable[0].length) };
+    return { owner: "document", rest: path };
+  };
+}
+
+// src/patch.ts
+var PatchError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(issues.map((issue2) => `${issue2.path}: ${issue2.message}`).join("\n"));
+    this.name = "PatchError";
+    this.issues = issues;
+  }
+};
+var CONTAINER_TYPES = /* @__PURE__ */ new Set(["FRAME", "GROUP", "COMPONENT", "COMPONENT_SET", "SECTION", "BOOLEAN_OPERATION"]);
+var RUN_STYLE_KEYS = ["font", "fill", "letterSpacing", "textDecoration", "link"];
+function cloneValue2(value) {
+  if (value instanceof Uint8Array) return new Uint8Array(value);
+  if (Array.isArray(value)) return value.map(cloneValue2);
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneValue2(item)]));
+  return value;
+}
+function cloneNode(node) {
+  return { ...node, properties: cloneValue2(node.properties), children: node.children.map(cloneNode) };
+}
+function translate(node, dx, dy) {
+  if (!dx && !dy) return;
+  node.properties.position = { x: node.properties.position.x + dx, y: node.properties.position.y + dy };
+  for (const child of node.children) translate(child, dx, dy);
+}
+function origin(parent) {
+  return parent ? { x: parent.properties.position.x, y: parent.properties.position.y } : { x: 0, y: 0 };
+}
+var isObject2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function corePatchContext(node, parent) {
+  const props = node.properties;
+  const runs = Array.isArray(props.runs) ? props.runs : [];
+  return {
+    type: node.type,
+    parentType: parent ? parent.type : null,
+    parentAutoLayout: Boolean(parent?.properties.layout?.direction),
+    autoLayout: Boolean(props.layout?.direction),
+    layoutPositioning: props.layoutPositioning,
+    mixedText: node.type === "TEXT" && runs.some((run) => RUN_STYLE_KEYS.some((key) => run[key] !== void 0)),
+    mixedFontName: node.type === "TEXT" && runs.some((run) => isObject2(run.font) && (run.font.family !== void 0 || run.font.style !== void 0)),
+    textStyle: Boolean(props.styleRefs?.text),
+    boundFields: Object.keys(props.bindings || {}),
+    childCount: node.children.length
+  };
+}
+function detachField(props, mapKey, field) {
+  const map = props[mapKey];
+  if (!map || map[field] === void 0) return false;
+  const next = { ...map };
+  delete next[field];
+  if (Object.keys(next).length) props[mapKey] = next;
+  else delete props[mapKey];
+  return true;
+}
+function detach(props, field) {
+  const warnings = [];
+  if (detachField(props, "bindings", field)) warnings.push(`detached bindings.${field}`);
+  if (detachField(props, "styleRefs", field)) warnings.push(`detached styleRefs.${field}`);
+  return warnings;
+}
+function mergeObjectMap(current, patch, assign) {
+  if (patch === void 0) return;
+  if (patch === null) {
+    assign(void 0);
+    return;
+  }
+  const next = { ...current || {} };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === null) delete next[key];
+    else next[key] = value;
+  }
+  assign(Object.keys(next).length ? next : void 0);
+}
+function stripRuns(props, keys) {
+  if (!Array.isArray(props.runs)) return;
+  props.runs = props.runs.map((run) => {
+    const next = { ...run };
+    for (const key of keys) {
+      if (key.startsWith("font.")) {
+        if (isObject2(next.font)) {
+          const font = { ...next.font };
+          delete font[key.slice(5)];
+          if (Object.keys(font).length) next.font = font;
+          else delete next.font;
+        }
+      } else delete next[key];
+    }
+    return next;
+  });
+}
+function mergeSet(ref, values, set, warnings) {
+  const { node, parent } = ref;
+  const props = node.properties;
+  const path = `node '${node.id}'`;
+  if (values.name !== void 0) node.name = values.name;
+  if (values.position) {
+    const base = origin(parent);
+    const x = values.position.x !== void 0 ? base.x + values.position.x : props.position.x;
+    const y = values.position.y !== void 0 ? base.y + values.position.y : props.position.y;
+    translate(node, x - props.position.x, y - props.position.y);
+  }
+  if (values.size) props.size = { width: values.size.width ?? props.size.width, height: values.size.height ?? props.size.height };
+  const styleKeys = [];
+  if (values.styles?.fills) {
+    props.styles.fills = cloneValue2(values.styles.fills);
+    for (const message of detach(props, "fill")) warnings.push(`${path}: ${message} because fill was set`);
+    styleKeys.push("fill");
+  }
+  if (values.styles?.strokes) {
+    props.styles.strokes = cloneValue2(values.styles.strokes);
+    for (const message of detach(props, "stroke")) warnings.push(`${path}: ${message} because stroke was set`);
+  }
+  if (values.styles?.effects) props.styles.effects = cloneValue2(values.styles.effects);
+  if (values.layout) {
+    const current = props.layout || {};
+    const padding = values.layout.padding ? { ...current.padding || {}, ...values.layout.padding } : current.padding;
+    props.layout = { ...current, ...cloneValue2(values.layout), ...padding ? { padding } : {} };
+  }
+  if (values.constraints) props.constraints = { horizontal: "MIN", vertical: "MIN", ...props.constraints || {}, ...values.constraints };
+  if (node.type === "TEXT") {
+    if (values.font || setTouchesTextStyle(set)) {
+      if (props.styleRefs?.text) {
+        detachField(props, "styleRefs", "text");
+        warnings.push(`${path}: detached styleRefs.text because typography was set`);
+      }
+    }
+    if (values.font) {
+      stripRuns(props, Object.keys(values.font).map((key) => `font.${key}`));
+      props.font = { ...props.font || {}, ...values.font };
+    }
+    if (values.letterSpacing !== void 0) styleKeys.push("letterSpacing");
+    if (values.textDecoration !== void 0) styleKeys.push("textDecoration");
+    stripRuns(props, styleKeys);
+    if (values.runs !== void 0) {
+      props.runs = cloneValue2(values.runs);
+      props.text = values.text !== void 0 ? values.text : values.runs.map((run) => typeof run.text === "string" ? run.text : "").join("");
+    } else if (values.text !== void 0) {
+      props.text = values.text;
+      delete props.runs;
+    }
+  }
+  const overwritten = patchSetBindingFields(set).filter((field) => props.bindings && props.bindings[field] !== void 0);
+  for (const field of [...new Set(overwritten)]) {
+    detachField(props, "bindings", field);
+    warnings.push(`${path}: detached bindings.${field} because the set overwrites it`);
+  }
+  mergeObjectMap(props.bindings, values.bindings, (next) => {
+    if (next) props.bindings = next;
+    else delete props.bindings;
+  });
+  mergeObjectMap(props.styleRefs, values.styleRefs, (next) => {
+    if (next) props.styleRefs = next;
+    else delete props.styleRefs;
+  });
+  mergeObjectMap(props.variableModes, values.variableModes, (next) => {
+    if (next) props.variableModes = next;
+    else delete props.variableModes;
+  });
+  mergeObjectMap(props.instanceProperties, values.instanceProperties, (next) => {
+    if (next) props.instanceProperties = next;
+    else delete props.instanceProperties;
+  });
+  mergeObjectMap(props.componentPropertyReferences, values.componentPropertyReferences, (next) => {
+    if (next) props.componentPropertyReferences = next;
+    else delete props.componentPropertyReferences;
+  });
+  const handled = /* @__PURE__ */ new Set(["name", "position", "size", "styles", "layout", "constraints", "font", "runs", "text", "bindings", "styleRefs", "variableModes", "instanceProperties", "componentPropertyReferences", "componentProperties", "variantAxes", "variant"]);
+  for (const [key, value] of Object.entries(values)) {
+    if (handled.has(key)) continue;
+    Object.assign(props, { [key]: cloneValue2(value) });
+  }
+}
+function setTouchesTextStyle(set) {
+  return ["lineHeight", "letterSpacing", "paragraphSpacing", "paragraphIndent", "listSpacing", "textCase", "textDecoration", "hangingPunctuation", "hangingList"].some((key) => key in set);
+}
+function clampIndex(index, length) {
+  return Math.max(0, Math.min(index, length));
+}
+function isDescendantOf(ancestor, candidate) {
+  for (const child of ancestor.children) {
+    if (child === candidate || isDescendantOf(child, candidate)) return true;
+  }
+  return false;
+}
+function hasInstanceAncestor(node, index) {
+  let current = node;
+  while (current) {
+    if (current.type === "INSTANCE") return true;
+    const ref = index.get(current.id);
+    current = ref?.parent ?? null;
+  }
+  return false;
+}
+function assertContainerParent(parent, operationIndex, parentId, index) {
+  if (parent.type === "INSTANCE" || hasInstanceAncestor(parent, index)) {
+    throw new Error(`patch.operations[${operationIndex}]: parent '${parentId}' is an INSTANCE (or inside one) and cannot accept structural edits.`);
+  }
+  if (!CONTAINER_TYPES.has(parent.type)) {
+    throw new Error(`patch.operations[${operationIndex}]: parent '${parentId}' cannot contain children.`);
+  }
+}
+function assertNotInsideInstance(parent, operationIndex, id, index) {
+  if (parent && hasInstanceAncestor(parent, index)) {
+    throw new Error(`patch.operations[${operationIndex}]: node '${id}' is inside an INSTANCE and cannot be moved.`);
+  }
+}
+function patchIssue(code, path, message, suggestion) {
+  return { severity: "ERROR", code, path, message, suggestion };
+}
+function applyOperation(operation, operationIndex, index, visit, affectedIds, warnings, roots, duplicateMaps) {
+  if (operation.op === "APPEND" || operation.op === "INSERT") {
+    const target2 = operation.parent ? index.get(operation.parent) : void 0;
+    if (!target2 || !operation.node) throw new Error(`patch.operations[${operationIndex}]: parent '${operation.parent || ""}' was not found.`);
+    assertContainerParent(target2.node, operationIndex, operation.parent || "", index);
+    if (index.has(operation.node.id)) throw new Error(`patch.operations[${operationIndex}]: ID '${operation.node.id}' already exists.`);
+    const child = cloneNode(operation.node);
+    const base = origin(target2.node);
+    translate(child, base.x, base.y);
+    if (target2.node.type === "COMPONENT_SET" && child.type === "COMPONENT") {
+      const axes = target2.node.properties.variantAxes || {};
+      const selected = child.properties.variant || {};
+      if (Object.keys(axes).length) {
+        child.name = Object.keys(axes).map((axis) => `${axis}=${selected[axis] ?? axes[axis][0]}`).join(", ");
+      } else if (Object.keys(selected).length) {
+        child.name = Object.entries(selected).map(([axis, value]) => `${axis}=${value}`).join(", ");
+      }
+    }
+    if (operation.op === "APPEND") {
+      target2.node.children.push(child);
+    } else {
+      const at = clampIndex(operation.index ?? 0, target2.node.children.length);
+      target2.node.children.splice(at, 0, child);
+    }
+    visit([child], target2.node);
+    affectedIds.push(child.id);
+    return;
+  }
+  if (operation.op === "DUPLICATE") {
+    const sourceRef = operation.id ? index.get(operation.id) : void 0;
+    if (!sourceRef) throw new Error(`patch.operations[${operationIndex}]: node '${operation.id || ""}' was not found.`);
+    assertNotInsideInstance(sourceRef.parent, operationIndex, operation.id || "", index);
+    if (subtreeContainsType(sourceRef.node, /* @__PURE__ */ new Set(["COMPONENT", "COMPONENT_SET"]))) {
+      throw new Error(`patch.operations[${operationIndex}]: cannot duplicate a COMPONENT or COMPONENT_SET (or a subtree that contains one)`);
+    }
+    const path = `patch.operations[${operationIndex}]`;
+    const { map, errors } = buildDuplicateIdMap(sourceRef.node, operation.idSuffix || "", operation.ids, path);
+    if (errors.length) throw new Error(errors[0]);
+    for (const [, newId] of map) {
+      if (index.has(newId)) throw new Error(`${path}: new id '${newId}' already exists`);
+    }
+    let destParent;
+    let destSiblings;
+    if (operation.parent !== void 0) {
+      const dest = index.get(operation.parent);
+      if (!dest) throw new Error(`${path}: parent '${operation.parent}' was not found.`);
+      assertContainerParent(dest.node, operationIndex, operation.parent, index);
+      destParent = dest.node;
+      destSiblings = dest.node.children;
+    } else if (sourceRef.parent) {
+      destParent = sourceRef.parent;
+      destSiblings = sourceRef.siblings;
+    } else {
+      destParent = null;
+      destSiblings = roots;
+    }
+    if (destParent) assertContainerParent(destParent, operationIndex, destParent.id, index);
+    const copy = cloneSubtreeWithIds(sourceRef.node, map);
+    const fromOrigin = origin(sourceRef.parent);
+    const toOrigin = origin(destParent);
+    translate(copy, toOrigin.x - fromOrigin.x, toOrigin.y - fromOrigin.y);
+    let at;
+    if (operation.index !== void 0) {
+      at = clampIndex(operation.index, destSiblings.length);
+    } else if (destParent === sourceRef.parent || destParent === null && sourceRef.parent === null) {
+      const sourceIndex = sourceRef.siblings.indexOf(sourceRef.node);
+      at = clampIndex(sourceIndex + 1, destSiblings.length);
+    } else {
+      at = destSiblings.length;
+    }
+    destSiblings.splice(at, 0, copy);
+    visit([copy], destParent);
+    duplicateMaps.push(map);
+    affectedIds.push(copy.id);
+    return;
+  }
+  if (operation.op === "MOVE") {
+    const moving = operation.id ? index.get(operation.id) : void 0;
+    if (!moving) throw new Error(`patch.operations[${operationIndex}]: node '${operation.id || ""}' was not found.`);
+    if (!moving.parent) throw new Error(`patch.operations[${operationIndex}]: cannot move the document root.`);
+    assertNotInsideInstance(moving.parent, operationIndex, operation.id || "", index);
+    const destination = operation.parent ? index.get(operation.parent) : void 0;
+    if (!destination) throw new Error(`patch.operations[${operationIndex}]: parent '${operation.parent || ""}' was not found.`);
+    assertContainerParent(destination.node, operationIndex, operation.parent || "", index);
+    if (destination.node === moving.node || isDescendantOf(moving.node, destination.node)) {
+      throw new Error(`patch.operations[${operationIndex}]: cannot move a node under itself or its descendants.`);
+    }
+    const from = origin(moving.parent);
+    const to = origin(destination.node);
+    translate(moving.node, to.x - from.x, to.y - from.y);
+    const fromIndex = moving.siblings.indexOf(moving.node);
+    moving.siblings.splice(fromIndex, 1);
+    const at = clampIndex(operation.index ?? 0, destination.node.children.length);
+    destination.node.children.splice(at, 0, moving.node);
+    index.set(moving.node.id, { node: moving.node, parent: destination.node, siblings: destination.node.children });
+    visit(moving.node.children, moving.node);
+    affectedIds.push(moving.node.id);
+    return;
+  }
+  const target = operation.id ? index.get(operation.id) : void 0;
+  if (!target) throw new Error(`patch.operations[${operationIndex}]: node '${operation.id || ""}' was not found.`);
+  if (operation.op === "REMOVE") {
+    const removeAll = (node) => {
+      index.delete(node.id);
+      node.children.forEach(removeAll);
+    };
+    target.siblings.splice(target.siblings.indexOf(target.node), 1);
+    removeAll(target.node);
+    affectedIds.push(target.node.id);
+    return;
+  }
+  const set = operation.set || {};
+  const values = operation.normalized;
+  if (!values) throw new Error(`patch.operations[${operationIndex}]: SET '${operation.id}' was not normalized.`);
+  const issues = patchSetTargetIssues(set, corePatchContext(target.node, target.parent));
+  if (issues.length) {
+    throw new PatchError(issues.map((message) => {
+      const split = message.indexOf(":");
+      return patchIssue("PATCH_SET_INVALID", `patch.operations[${operationIndex}].set.${message.slice(0, split)}`, message.slice(split + 1).trim(), "Use a key that applies to this node, or see the patch rules in DESIGN-LANGUAGE.md.");
+    }));
+  }
+  if (values.prototype !== void 0) {
+    const protoErrors = assertPrototypePatchRules(
+      values.prototype,
+      {
+        has: (id) => index.has(id),
+        typeOf: (id) => index.get(id)?.node.type,
+        canvasOf: (id) => canvasRootId(roots, id),
+        isTopLevel: (id) => isTopLevelNodeId(roots, id)
+      },
+      `patch.operations[${operationIndex}].set.prototype`,
+      target.node.id,
+      isTopLevelNodeId(roots, target.node.id)
+    );
+    if (protoErrors.length) {
+      throw new PatchError(protoErrors.map((message) => {
+        const split = message.indexOf(": ");
+        return patchIssue("PATCH_OPERATION", split > 0 ? message.slice(0, split) : `patch.operations[${operationIndex}].set.prototype`, split > 0 ? message.slice(split + 2) : message, "Use a top-level frame destination; AFTER_TIMEOUT only on a top-level node.");
+      }));
+    }
+  }
+  mergeSet(target, values, set, warnings);
+  const defErrors = [];
+  if (values.componentProperties !== void 0) {
+    defErrors.push(...applyComponentPropertiesPatch(target.node.properties, values.componentProperties, `patch.operations[${operationIndex}].set`));
+  }
+  if (values.variant !== void 0) {
+    defErrors.push(...applyVariantPatchOnComponent(target.node, target.parent, values.variant, `patch.operations[${operationIndex}].set`));
+  }
+  if (values.variantAxes !== void 0) {
+    if (target.node.type !== "COMPONENT_SET") {
+      defErrors.push(`patch.operations[${operationIndex}].set.variantAxes: only applies to COMPONENT_SET`);
+    } else if (values.variantAxes === null) {
+      defErrors.push(`patch.operations[${operationIndex}].set.variantAxes: clearing all axes is not supported (Figma cannot delete VARIANT properties)`);
+    } else {
+      const current = target.node.properties.variantAxes || {};
+      const detected = detectVariantRenames(current, values.variantAxes);
+      const axisErrors = [
+        ...detected.errors,
+        ...!detected.errors.length ? variantAxesChildConflicts(target.node, current, detected.axes, detected.optionRenames, detected.axisRenames) : []
+      ].map((message) => `patch.operations[${operationIndex}].set.${message}`);
+      defErrors.push(...axisErrors);
+      if (!axisErrors.length) {
+        target.node.properties.variantAxes = detected.axes;
+        applyVariantRenamesInForest(roots, target.node.id, detected.axisRenames, detected.optionRenames, detected.axes);
+        rewriteVariantChildNames(target.node);
+      }
+    }
+  }
+  if (defErrors.length) {
+    throw new PatchError(defErrors.map((message) => {
+      const split = message.indexOf(": ");
+      return patchIssue("PATCH_SET_INVALID", split > 0 ? message.slice(0, split) : `patch.operations[${operationIndex}].set`, split > 0 ? message.slice(split + 2) : message, "See component/variant patch rules in DESIGN-LANGUAGE.md.");
+    }));
+  }
+  affectedIds.push(target.node.id);
+}
+function applyDocumentPatch(document, patch) {
+  const result = { ...document, nodes: document.nodes.map(cloneNode), styles: cloneValue2(document.styles), variables: cloneValue2(document.variables) };
+  const affectedIds = [];
+  const warnings = [];
+  const duplicateMaps = [];
+  const index = /* @__PURE__ */ new Map();
+  const visit = (nodes, parent) => nodes.forEach((node) => {
+    index.set(node.id, { node, parent, siblings: nodes });
+    visit(node.children, node);
+  });
+  visit(result.nodes, null);
+  for (const [operationIndex, operation] of patch.patch.operations.entries()) {
+    try {
+      applyOperation(operation, operationIndex, index, visit, affectedIds, warnings, result.nodes, duplicateMaps);
+    } catch (error) {
+      if (error instanceof PatchError) throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      const split = message.indexOf(": ");
+      throw new PatchError([patchIssue("PATCH_OPERATION", split > 0 ? message.slice(0, split) : `patch.operations[${operationIndex}]`, split > 0 ? message.slice(split + 2) : message, "Target nodes that exist and containers that can accept children.")]);
+    }
+  }
+  const introduced = newDocumentIssues(document, result, duplicateMaps);
+  const strictKeyed = (doc) => {
+    const owners = documentIssueOwners(doc);
+    return prototypePatchStrictErrors(doc).map((message) => {
+      const split = message.indexOf(": ");
+      const path = split > 0 ? message.slice(0, split) : "$";
+      const body = split > 0 ? message.slice(split + 2) : message;
+      const owner = owners(path);
+      return { path, body, key: `STRICT|${owner.owner}|${owner.rest}|${body}` };
+    });
+  };
+  const strictExisting = /* @__PURE__ */ new Map();
+  const beforeStrict = strictKeyed(document);
+  for (const { key } of beforeStrict) strictExisting.set(key, (strictExisting.get(key) || 0) + 1);
+  for (const idMap of duplicateMaps) {
+    for (const { key } of beforeStrict) {
+      const remapped = remapIssueKeyThroughDuplicate(key, idMap);
+      if (remapped) strictExisting.set(remapped, (strictExisting.get(remapped) || 0) + 1);
+    }
+  }
+  for (const { path, body, key } of strictKeyed(result)) {
+    const count = strictExisting.get(key) || 0;
+    if (count > 0) {
+      strictExisting.set(key, count - 1);
+      continue;
+    }
+    introduced.push(patchIssue("PATCH_RESULT_INVALID", path, `after patch: ${body}`, "NAVIGATE/SWAP/OVERLAY destinations must be top-level frames; AFTER_TIMEOUT only on top-level nodes."));
+  }
+  if (introduced.length) throw new PatchError(introduced);
+  return { document: result, affectedIds, warnings };
+}
+function newDocumentIssues(before, after, duplicateMaps = []) {
+  const keyed = (document) => {
+    const owners = documentIssueOwners(document);
+    return validationIssues(validateDocument(document, Infinity)).map((issue2) => {
+      const owner = owners(issue2.path);
+      return { issue: issue2, owner, key: `${issue2.code}|${owner.owner}|${owner.rest}|${issue2.message}` };
+    });
+  };
+  const existing = /* @__PURE__ */ new Map();
+  const beforeKeyed = keyed(before);
+  for (const { key } of beforeKeyed) existing.set(key, (existing.get(key) || 0) + 1);
+  for (const idMap of duplicateMaps) {
+    for (const { key } of beforeKeyed) {
+      const remapped = remapIssueKeyThroughDuplicate(key, idMap);
+      if (remapped) existing.set(remapped, (existing.get(remapped) || 0) + 1);
+    }
+  }
+  const introduced = [];
+  for (const { issue: issue2, owner, key } of keyed(after)) {
+    const count = existing.get(key) || 0;
+    if (count > 0) {
+      existing.set(key, count - 1);
+      continue;
+    }
+    const where = owner.nodeId !== void 0 ? ` (node '${owner.nodeId}')` : "";
+    introduced.push({ ...issue2, code: "PATCH_RESULT_INVALID", message: `after patch${where}: ${issue2.message}`, suggestion: "This issue is introduced by the patch; issues already in the input document are not reported." });
+  }
+  return introduced;
+}
+
+// src/parser.ts
+function parseDocument(source) {
+  if (!source.trim()) throw new Error("Paste a Compact Design JSON document first.");
+  try {
+    return JSON.parse(source);
+  } catch (error) {
+    throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/generated-schema.ts
+var generated_schema_default = {
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://compact-design-json.dev/schema.json",
+  "title": "Compact Design JSON",
+  "description": "The current public input language for the Compact Design JSON to Figma plugin.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "$schema": { "type": "string" },
+    "canvas": { "$ref": "#/$defs/canvas" },
+    "canvases": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/responsiveCanvas" } },
+    "nodes": { "$ref": "#/$defs/nodes" },
+    "variables": { "type": "array", "items": { "$ref": "#/$defs/variableCollection" } },
+    "styles": { "type": "array", "items": { "$ref": "#/$defs/style" } },
+    "patch": { "$ref": "#/$defs/patchRoot" }
+  },
+  "oneOf": [
+    {
+      "required": ["canvas"],
+      "not": { "anyOf": [{ "required": ["canvases"] }, { "required": ["patch"] }] }
+    },
+    {
+      "required": ["canvases"],
+      "not": { "anyOf": [{ "required": ["canvas"] }, { "required": ["patch"] }] }
+    },
+    {
+      "required": ["patch"],
+      "not": { "anyOf": [{ "required": ["canvas"] }, { "required": ["canvases"] }] }
+    }
+  ],
+  "$defs": {
+    "positiveNumber": { "type": "number", "exclusiveMinimum": 0 },
+    "nonNegativeNumber": { "type": "number", "minimum": 0 },
+    "nullablePositiveNumber": { "type": ["number", "null"], "exclusiveMinimum": 0 },
+    "hexColor": { "type": "string", "pattern": "^#[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$" },
+    "color": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["r", "g", "b"],
+      "properties": {
+        "r": { "type": "number", "minimum": 0, "maximum": 255 },
+        "g": { "type": "number", "minimum": 0, "maximum": 255 },
+        "b": { "type": "number", "minimum": 0, "maximum": 255 },
+        "a": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    },
+    "vector": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["x", "y"],
+      "properties": { "x": { "type": "number" }, "y": { "type": "number" } }
+    },
+    "transform": {
+      "type": "array",
+      "minItems": 2,
+      "maxItems": 2,
+      "items": { "type": "array", "minItems": 3, "maxItems": 3, "items": { "type": "number" } }
+    },
+    "gradientStop": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["at", "color"],
+      "properties": {
+        "at": { "type": "number", "minimum": 0, "maximum": 1 },
+        "color": { "oneOf": [{ "$ref": "#/$defs/hexColor" }, { "$ref": "#/$defs/color" }] }
+      }
+    },
+    "imagePaint": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["image"],
+      "properties": {
+        "image": {
+          "type": "string",
+          "anyOf": [
+            { "pattern": "^https://" },
+            { "pattern": "^file:[^/].+" },
+            { "pattern": "^data:image/(png|jpeg|gif|webp);base64," }
+          ]
+        },
+        "fit": { "enum": ["COVER", "CONTAIN", "CROP", "TILE", "FILL", "FIT"] },
+        "opacity": { "type": "number", "minimum": 0, "maximum": 1 },
+        "transform": { "$ref": "#/$defs/transform" }
+      }
+    },
+    "gradientPaint": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["gradient", "stops"],
+      "properties": {
+        "gradient": { "enum": ["LINEAR", "RADIAL", "ANGULAR", "DIAMOND"] },
+        "angle": { "type": "number" },
+        "transform": { "$ref": "#/$defs/transform" },
+        "stops": { "type": "array", "minItems": 2, "items": { "$ref": "#/$defs/gradientStop" } },
+        "opacity": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    },
+    "solidPaint": {
+      "type": "object",
       "additionalProperties": false,
       "required": ["type", "color"],
       "properties": {
@@ -8257,6 +10005,26 @@ var generated_schema_default = {
         "options": { "type": "object" }
       }
     },
+    "componentPropertyReferences": {
+      "type": "object",
+      "description": "Links this child layer to component properties on its nearest ancestor COMPONENT (Figma componentPropertyReferences). Values are the authored property names from that COMPONENT's componentProperties. characters \u2192 TEXT (TEXT nodes only); visible \u2192 BOOLEAN (any node); mainComponent \u2192 INSTANCE_SWAP (INSTANCE nodes only).",
+      "additionalProperties": false,
+      "properties": {
+        "characters": { "type": "string", "minLength": 1 },
+        "visible": { "type": "string", "minLength": 1 },
+        "mainComponent": { "type": "string", "minLength": 1 }
+      }
+    },
+    "componentPropertyReferencesPatch": {
+      "type": "object",
+      "description": "Patch form of componentPropertyReferences: null field clears that link.",
+      "additionalProperties": false,
+      "properties": {
+        "characters": { "type": ["string", "null"], "minLength": 1 },
+        "visible": { "type": ["string", "null"], "minLength": 1 },
+        "mainComponent": { "type": ["string", "null"], "minLength": 1 }
+      }
+    },
     "vectorPath": {
       "type": "object",
       "additionalProperties": false,
@@ -8405,6 +10173,7 @@ var generated_schema_default = {
           "items": { "$ref": "#/$defs/componentProperty" }
         },
         "instanceProperties": { "type": "object" },
+        "componentPropertyReferences": { "$ref": "#/$defs/componentPropertyReferences" },
         "variantAxes": {
           "type": "object",
           "additionalProperties": {
@@ -8601,15 +10370,191 @@ var generated_schema_default = {
         "font": { "$ref": "#/$defs/font" },
         "lineHeight": {
           "oneOf": [
-            { "type": "number", "exclusiveMinimum": 0 },
-            { "$ref": "#/$defs/lineHeightObject" }
+            { "type": "number", "exclusiveMinimum": 0 },
+            { "$ref": "#/$defs/lineHeightObject" }
+          ]
+        },
+        "letterSpacing": { "$ref": "#/$defs/letterSpacing" },
+        "paragraphSpacing": { "$ref": "#/$defs/nonNegativeNumber" }
+      }
+    },
+    "style": { "oneOf": [{ "$ref": "#/$defs/paintStyle" }, { "$ref": "#/$defs/textStyle" }] },
+    "fontPatch": {
+      "description": "Partial font for patch set. Merges into the target's font: unmentioned family/style/size are kept.",
+      "allOf": [{ "$ref": "#/$defs/font" }],
+      "minProperties": 1
+    },
+    "paddingPatch": {
+      "description": "Partial padding for patch set. Merges per side into the target's padding.",
+      "allOf": [{ "$ref": "#/$defs/padding" }],
+      "minProperties": 1
+    },
+    "layoutPatch": {
+      "type": "object",
+      "description": "Partial Auto Layout for patch set. Deep-merges into the target's layout (padding merges per side). direction is required only when the target has no Auto Layout yet.",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "properties": {
+        "direction": { "enum": ["HORIZONTAL", "VERTICAL", "GRID"] },
+        "itemSpacing": { "type": "number" },
+        "counterAxisSpacing": { "type": "number" },
+        "padding": { "$ref": "#/$defs/paddingPatch" },
+        "primaryAxisAlignItems": { "enum": ["MIN", "MAX", "CENTER", "SPACE_BETWEEN"] },
+        "counterAxisAlignItems": { "enum": ["MIN", "MAX", "CENTER", "BASELINE"], "description": "STRETCH is not patchable yet; set layoutAlign: STRETCH on children." },
+        "primaryAxisSizingMode": { "enum": ["FIXED", "HUG", "AUTO"] },
+        "counterAxisSizingMode": { "enum": ["FIXED", "HUG", "AUTO"] },
+        "wrap": { "type": "boolean" }
+      }
+    },
+    "constraintsPatch": {
+      "type": "object",
+      "description": "Partial constraints for patch set. Merges into the target's constraints (missing axes default to MIN, Figma's default).",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "properties": {
+        "horizontal": { "enum": ["MIN", "CENTER", "MAX", "STRETCH", "SCALE"] },
+        "vertical": { "enum": ["MIN", "CENTER", "MAX", "STRETCH", "SCALE"] }
+      }
+    },
+    "patchSet": {
+      "type": "object",
+      "description": "Properties for a patch set operation. Derived from node properties minus id, type, children and coordinateMode. Unknown keys are rejected. x/y are parent-relative. Objects (layout, layout.padding, font, constraints) deep-merge; arrays (fills, strokes, effects, runs, layoutGrids, vectorPaths, dashPattern, cornerRadii) replace. font is partial (its fields merge).",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "properties": {
+        "name": { "type": "string" },
+        "x": { "type": "number" },
+        "y": { "type": "number" },
+        "w": { "$ref": "#/$defs/positiveNumber" },
+        "h": { "$ref": "#/$defs/positiveNumber" },
+        "rotation": { "type": "number" },
+        "fill": { "$ref": "#/$defs/paint" },
+        "fills": { "type": "array", "items": { "$ref": "#/$defs/paint" } },
+        "stroke": { "$ref": "#/$defs/paint" },
+        "strokes": { "type": "array", "items": { "$ref": "#/$defs/paint" } },
+        "strokeWeight": { "$ref": "#/$defs/nonNegativeNumber" },
+        "strokeTopWeight": { "$ref": "#/$defs/nonNegativeNumber" },
+        "strokeRightWeight": { "$ref": "#/$defs/nonNegativeNumber" },
+        "strokeBottomWeight": { "$ref": "#/$defs/nonNegativeNumber" },
+        "strokeLeftWeight": { "$ref": "#/$defs/nonNegativeNumber" },
+        "strokeAlign": { "enum": ["CENTER", "INSIDE", "OUTSIDE"] },
+        "strokeCap": { "enum": ["NONE", "ROUND", "SQUARE", "LINE_ARROW", "TRIANGLE_ARROW", "DIAMOND_FILLED", "CIRCLE_FILLED", "TRIANGLE_FILLED", "WASHI_TAPE_1", "WASHI_TAPE_2", "WASHI_TAPE_3", "WASHI_TAPE_4", "WASHI_TAPE_5", "WASHI_TAPE_6"] },
+        "strokeJoin": { "enum": ["MITER", "BEVEL", "ROUND"] },
+        "dashPattern": { "type": "array", "items": { "$ref": "#/$defs/nonNegativeNumber" } },
+        "cornerRadius": { "$ref": "#/$defs/nonNegativeNumber" },
+        "cornerRadii": { "type": "array", "minItems": 4, "maxItems": 4, "items": { "$ref": "#/$defs/nonNegativeNumber" } },
+        "opacity": { "type": "number", "minimum": 0, "maximum": 1 },
+        "blendMode": { "type": "string" },
+        "visible": { "type": "boolean" },
+        "locked": { "type": "boolean" },
+        "isMask": { "type": "boolean" },
+        "clipsContent": { "type": "boolean" },
+        "effects": { "type": "array", "items": { "$ref": "#/$defs/effect" } },
+        "elevation": { "enum": ["NONE", "LOW", "MEDIUM", "HIGH", "FLOATING"] },
+        "shadow": { "oneOf": [{ "$ref": "#/$defs/shadow" }, { "type": "array", "items": { "$ref": "#/$defs/shadow" } }] },
+        "layout": { "$ref": "#/$defs/layoutPatch" },
+        "constraints": { "$ref": "#/$defs/constraintsPatch" },
+        "layoutSizingHorizontal": { "enum": ["FIXED", "HUG", "FILL"] },
+        "layoutSizingVertical": { "enum": ["FIXED", "HUG", "FILL"] },
+        "layoutAlign": { "enum": ["INHERIT", "STRETCH"] },
+        "layoutGrow": { "type": "number", "minimum": 0 },
+        "layoutPositioning": { "enum": ["AUTO", "ABSOLUTE"] },
+        "minWidth": { "$ref": "#/$defs/nullablePositiveNumber" },
+        "maxWidth": { "$ref": "#/$defs/nullablePositiveNumber" },
+        "minHeight": { "$ref": "#/$defs/nullablePositiveNumber" },
+        "maxHeight": { "$ref": "#/$defs/nullablePositiveNumber" },
+        "layoutGrids": { "type": "array", "items": { "$ref": "#/$defs/grid" } },
+        "text": { "type": "string" },
+        "font": { "$ref": "#/$defs/fontPatch" },
+        "lineHeight": { "oneOf": [{ "type": "number", "exclusiveMinimum": 0 }, { "$ref": "#/$defs/lineHeightObject" }] },
+        "letterSpacing": { "$ref": "#/$defs/letterSpacing" },
+        "align": { "enum": ["LEFT", "CENTER", "RIGHT", "JUSTIFIED"] },
+        "verticalAlignment": { "enum": ["TOP", "CENTER", "BOTTOM"] },
+        "textDecoration": { "enum": ["NONE", "UNDERLINE", "STRIKETHROUGH"] },
+        "textCase": { "enum": ["ORIGINAL", "UPPER", "LOWER", "TITLE", "SMALL_CAPS", "SMALL_CAPS_FORCED"] },
+        "paragraphSpacing": { "$ref": "#/$defs/nonNegativeNumber" },
+        "paragraphIndent": { "$ref": "#/$defs/nonNegativeNumber" },
+        "listSpacing": { "$ref": "#/$defs/nonNegativeNumber" },
+        "hangingPunctuation": { "type": "boolean" },
+        "hangingList": { "type": "boolean" },
+        "textAutoResize": { "enum": ["NONE", "WIDTH_AND_HEIGHT", "HEIGHT", "TRUNCATE"] },
+        "textTruncation": { "enum": ["DISABLED", "ENDING"] },
+        "maxLines": { "type": ["integer", "null"], "minimum": 1 },
+        "runs": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/textRun" } },
+        "pointCount": { "type": "integer", "minimum": 3 },
+        "innerRadius": { "type": "number", "minimum": 0, "maximum": 1 },
+        "startingAngle": { "type": "number" },
+        "endingAngle": { "type": "number" },
+        "innerRadiusRatio": { "type": "number", "minimum": 0, "maximum": 1 },
+        "svg": { "type": "string", "minLength": 1, "description": "SVG markup cannot be patched in place: core and the Figma plugin reject it. Remove and insert a new SVG node." },
+        "vectorPaths": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/vectorPath" } },
+        "componentId": { "type": "string", "minLength": 1, "description": "Recognised but not patchable yet: core and the Figma plugin reject it with PATCH_SET_UNSUPPORTED. Re-import, or remove and insert the node." },
+        "componentProperties": {
+          "description": "Name-keyed upsert of COMPONENT property definitions (not a full wipe). Field null deletes a TEXT/BOOLEAN/INSTANCE_SWAP property. type is immutable after create. INSTANCE_SWAP defaultValue must be a COMPONENT id.",
+          "oneOf": [
+            { "type": "null" },
+            {
+              "type": "object",
+              "additionalProperties": {
+                "oneOf": [
+                  { "type": "null" },
+                  {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "type": { "enum": ["TEXT", "BOOLEAN", "INSTANCE_SWAP"] },
+                      "defaultValue": {},
+                      "options": { "type": "object" }
+                    }
+                  }
+                ]
+              }
+            }
+          ]
+        },
+        "instanceProperties": { "description": "Shallow-merge instance overrides (authored names). Field null clears that override. Whole-key null clears all. INSTANCE_SWAP values must be COMPONENT ids.", "oneOf": [{ "type": "null" }, { "type": "object" }] },
+        "componentPropertyReferences": { "description": "Shallow-merge onto the node. Field null clears that link. Whole-key null clears all refs. Values are authored property names on the owning COMPONENT.", "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/componentPropertyReferencesPatch" }] },
+        "variantAxes": {
+          "description": "Shallow-merge on COMPONENT_SET. A string array replaces that axis's options and NEVER renames. Object form { rename?, options?, renameOptions? } renames explicitly. Axis null is an error (Figma cannot delete VARIANT properties). Every declared option must be carried by a COMPONENT child after the patch (Figma derives options from child names).",
+          "type": "object",
+          "additionalProperties": {
+            "oneOf": [
+              { "type": "null" },
+              { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
+              {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "rename": { "type": "string", "minLength": 1, "description": "Rename this axis to the given name." },
+                  "options": { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 }, "uniqueItems": true, "description": "Final option list after renameOptions are applied." },
+                  "renameOptions": { "type": "object", "additionalProperties": { "type": "string", "minLength": 1 }, "description": "Explicit old\u2192new option renames on this axis (after axis rename, if any)." }
+                }
+              }
+            ]
+          }
+        },
+        "variant": {
+          "description": "Merge variant selection on a COMPONENT inside a COMPONENT_SET. Every axis/value must be declared on the parent variantAxes. Rewrites the component name. Whole-key null and per-axis null are rejected (variant components require a selection).",
+          "oneOf": [
+            { "type": "null" },
+            { "type": "object", "additionalProperties": { "type": ["string", "null"], "minLength": 1 } }
           ]
         },
-        "letterSpacing": { "$ref": "#/$defs/letterSpacing" },
-        "paragraphSpacing": { "$ref": "#/$defs/nonNegativeNumber" }
+        "operation": { "enum": ["UNION", "SUBTRACT", "INTERSECT", "EXCLUDE"] },
+        "prototype": { "type": "array", "items": { "$ref": "#/$defs/prototype" }, "description": "Replace the full reaction list (like runs/effects). [] clears. Destinations must exist (including ids created earlier in the same patch). NAVIGATE/SWAP/OVERLAY destinations must be top-level frames; AFTER_TIMEOUT only on a top-level target. No whole-key null." },
+        "overflowDirection": { "enum": ["NONE", "HORIZONTAL", "VERTICAL", "BOTH", "HORIZONTAL_SCROLLING", "VERTICAL_SCROLLING", "HORIZONTAL_AND_VERTICAL_SCROLLING"] },
+        "numberOfFixedChildren": { "type": "integer", "minimum": 0 },
+        "styleRefs": { "description": "Shallow-merge style refs. Field null clears that ref. Whole-key null clears all styleRefs.", "oneOf": [{ "type": "null" }, { "type": "object", "additionalProperties": { "type": ["string", "null"] } }] },
+        "bindings": { "description": "Shallow-merge variable bindings. Field null clears that binding. Whole-key null clears all bindings.", "oneOf": [{ "type": "null" }, { "type": "object", "additionalProperties": { "type": ["string", "null"] } }] },
+        "variableModes": { "description": "Shallow-merge collection\u2192mode. Field null clears that collection mode. Whole-key null clears all.", "oneOf": [{ "type": "null" }, { "type": "object", "additionalProperties": { "type": ["string", "null"] } }] }
+      },
+      "not": {
+        "anyOf": [
+          { "required": ["fill", "fills"] },
+          { "required": ["stroke", "strokes"] }
+        ]
       }
     },
-    "style": { "oneOf": [{ "$ref": "#/$defs/paintStyle" }, { "$ref": "#/$defs/textStyle" }] },
     "patchOperation": {
       "oneOf": [
         {
@@ -8619,7 +10564,7 @@ var generated_schema_default = {
           "properties": {
             "op": { "const": "set" },
             "id": { "type": "string" },
-            "set": { "type": "object", "minProperties": 1 }
+            "set": { "$ref": "#/$defs/patchSet" }
           }
         },
         {
@@ -8637,6 +10582,41 @@ var generated_schema_default = {
             "parent": { "type": "string" },
             "node": { "$ref": "#/$defs/node" }
           }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["op", "parent", "index", "node"],
+          "properties": {
+            "op": { "const": "insert" },
+            "parent": { "type": "string" },
+            "index": { "type": "integer", "minimum": 0 },
+            "node": { "$ref": "#/$defs/node" }
+          }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["op", "id", "parent", "index"],
+          "properties": {
+            "op": { "const": "move" },
+            "id": { "type": "string" },
+            "parent": { "type": "string" },
+            "index": { "type": "integer", "minimum": 0 }
+          }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["op", "id", "idSuffix"],
+          "properties": {
+            "op": { "const": "duplicate" },
+            "id": { "type": "string", "minLength": 1, "description": "Source node to duplicate." },
+            "idSuffix": { "type": "string", "minLength": 1, "description": "Appended to every subtree id unless overridden in ids." },
+            "parent": { "type": "string", "minLength": 1, "description": "Optional new parent; omit to keep the source parent (or page-level for a top-level screen)." },
+            "index": { "type": "integer", "minimum": 0, "description": "Optional insert index; default is right after the source when same parent, else end." },
+            "ids": { "type": "object", "additionalProperties": { "type": "string", "minLength": 1 }, "description": "Optional sourceId\u2192newId overrides. Keys must be ids within the source subtree." }
+          }
         }
       ]
     },
@@ -8680,220 +10660,6 @@ function validateSchema(value) {
   return validate2(value) ? [] : (validate2.errors || []).map(issue);
 }
 
-// src/constants.ts
-var SUPPORTED_NODE_TYPES = /* @__PURE__ */ new Set([
-  "FRAME",
-  "GROUP",
-  "RECTANGLE",
-  "ELLIPSE",
-  "LINE",
-  "TEXT",
-  "VECTOR",
-  "SVG",
-  "COMPONENT",
-  "COMPONENT_SET",
-  "INSTANCE",
-  "BOOLEAN_OPERATION",
-  "POLYGON",
-  "STAR",
-  "SECTION",
-  "SLICE",
-  "ARC"
-]);
-var SUPPORTED_PAINT_TYPES = /* @__PURE__ */ new Set([
-  "SOLID",
-  "GRADIENT_LINEAR",
-  "GRADIENT_RADIAL",
-  "GRADIENT_ANGULAR",
-  "GRADIENT_DIAMOND",
-  "IMAGE"
-]);
-
-// src/validate.ts
-function validateDocument(document) {
-  const errors = [];
-  const ids = /* @__PURE__ */ new Set();
-  const components = /* @__PURE__ */ new Set();
-  const add = (path, message) => {
-    if (errors.length < 30) errors.push(`${path}: ${message}`);
-  };
-  const finite = (value) => typeof value === "number" && Number.isFinite(value);
-  const triggers = /* @__PURE__ */ new Set(["ON_CLICK", "ON_HOVER", "ON_PRESS", "ON_DRAG", "AFTER_TIMEOUT", "MOUSE_UP", "MOUSE_DOWN", "MOUSE_ENTER", "MOUSE_LEAVE", "ON_KEY_DOWN", "ON_MEDIA_HIT", "ON_MEDIA_END"]);
-  const actions = /* @__PURE__ */ new Set(["NAVIGATE", "SWAP", "OVERLAY", "SCROLL_TO", "CHANGE_TO", "BACK", "CLOSE", "URL", "UPDATE_MEDIA_RUNTIME", "SET_VARIABLE", "SET_VARIABLE_MODE", "CONDITIONAL"]);
-  function validateAction(value, path) {
-    if (!value || typeof value !== "object") return add(path, "action must be an object");
-    const action = value;
-    const type = String(action.type || "");
-    if (!actions.has(type)) add(`${path}.type`, `unsupported prototype action '${type}'`);
-    if (["NAVIGATE", "SWAP", "OVERLAY", "SCROLL_TO", "CHANGE_TO"].includes(type) && typeof action.destination !== "string") add(`${path}.destination`, `${type} requires a destination ID`);
-    if (type === "URL" && typeof action.url !== "string") add(`${path}.url`, "URL action requires url");
-    if (type === "SET_VARIABLE" && typeof (action.variable || action.variableId) !== "string") add(`${path}.variable`, "SET_VARIABLE requires a variable reference");
-    if (type === "SET_VARIABLE_MODE" && (typeof (action.collection || action.variableCollectionId) !== "string" || typeof (action.mode || action.variableModeId) !== "string")) add(path, "SET_VARIABLE_MODE requires collection and mode references");
-    if (type === "UPDATE_MEDIA_RUNTIME" && typeof action.mediaAction !== "string") add(`${path}.mediaAction`, "UPDATE_MEDIA_RUNTIME requires mediaAction");
-    if (type === "CONDITIONAL") {
-      const blocks = action.blocks || action.conditionalBlocks;
-      if (!Array.isArray(blocks) || !blocks.length) add(`${path}.blocks`, "CONDITIONAL requires at least one block");
-      else blocks.forEach((block, index) => {
-        if (block && typeof block === "object" && !Array.isArray(block)) {
-          const nested = block.actions;
-          if (Array.isArray(nested)) nested.forEach((item, actionIndex) => validateAction(item, `${path}.blocks[${index}].actions[${actionIndex}]`));
-        }
-      });
-    }
-  }
-  function validatePrototype(values, path) {
-    values.forEach((reaction, index) => {
-      const reactionPath = `${path}[${index}]`;
-      const triggerValue = reaction.trigger;
-      const trigger = typeof triggerValue === "string" ? triggerValue : triggerValue && typeof triggerValue === "object" && !Array.isArray(triggerValue) && typeof triggerValue.type === "string" ? triggerValue.type : "";
-      if (!triggers.has(trigger)) add(`${reactionPath}.trigger`, `unsupported trigger '${trigger}'`);
-      const reactionActions = Array.isArray(reaction.actions) ? reaction.actions : reaction.action ? [{ ...reaction, type: reaction.action }] : [];
-      if (!reactionActions.length) add(`${reactionPath}.actions`, "reaction requires at least one action");
-      reactionActions.forEach((action, actionIndex) => validateAction(action, `${reactionPath}.actions[${actionIndex}]`));
-    });
-  }
-  function validatePaint(value, path) {
-    if (!value || typeof value !== "object") return add(path, "paint must be an object or valid hex color");
-    if (!SUPPORTED_PAINT_TYPES.has(value.type)) add(`${path}.type`, `unsupported paint type '${value.type}'`);
-    if (value.type === "IMAGE") {
-      if (typeof value.src !== "string" || !/^https:\/\//i.test(value.src) && !/^file:[^/].+/i.test(value.src) && !/^data:image\/(png|jpeg|gif|webp);base64,/i.test(value.src)) add(`${path}.src`, "IMAGE requires HTTPS, file:filename, or an embedded image data URL");
-      if (!value.scaleMode || !["FILL", "FIT", "CROP", "TILE"].includes(value.scaleMode)) add(`${path}.scaleMode`, "must be COVER/FILL, CONTAIN/FIT, CROP, or TILE");
-      if (value.imageTransform !== void 0 && (!Array.isArray(value.imageTransform) || value.imageTransform.length !== 2)) add(`${path}.imageTransform`, "must be a 2\xD73 transform matrix");
-    }
-    if (value.type?.startsWith("GRADIENT_") && (!Array.isArray(value.gradientStops) || value.gradientStops.length < 2)) add(`${path}.gradientStops`, "gradient requires at least two stops");
-    if (value.opacity !== void 0 && (!finite(value.opacity) || value.opacity < 0 || value.opacity > 1)) add(`${path}.opacity`, "must be 0\u20131");
-  }
-  function walk(node, path) {
-    if (ids.has(node.id)) add(`${path}.id`, `duplicate ID '${node.id}'`);
-    else ids.add(node.id);
-    if (!SUPPORTED_NODE_TYPES.has(node.type)) add(`${path}.type`, `unsupported node type '${node.type}'`);
-    if (node.type === "COMPONENT") components.add(node.id);
-    const props = node.properties;
-    if (!finite(props.position?.x) || !finite(props.position?.y)) add(`${path}.position`, "x and y must be finite numbers");
-    if (!finite(props.size?.width) || props.size.width <= 0 || !finite(props.size?.height) || props.size.height <= 0) add(`${path}.size`, "w and h must be positive finite numbers");
-    if (props.cornerRadius !== void 0 && (!finite(props.cornerRadius) || props.cornerRadius < 0)) add(`${path}.cornerRadius`, "must be non-negative");
-    if (props.cornerRadii !== void 0 && (!Array.isArray(props.cornerRadii) || props.cornerRadii.length !== 4 || props.cornerRadii.some((n) => !finite(n) || n < 0))) add(`${path}.cornerRadii`, "must contain four non-negative numbers");
-    if (props.layout) {
-      if (!props.layout.direction || !["HORIZONTAL", "VERTICAL", "GRID"].includes(props.layout.direction)) add(`${path}.layout.direction`, "must be HORIZONTAL, VERTICAL, or GRID");
-      for (const key of ["primaryAxisSizingMode", "counterAxisSizingMode"]) {
-        const value = props.layout[key];
-        if (value !== void 0 && !["FIXED", "HUG", "AUTO"].includes(value)) add(`${path}.layout.${key}`, "must be FIXED or HUG");
-      }
-      if (props.layout.primaryAxisAlignItems !== void 0 && !["MIN", "MAX", "CENTER", "SPACE_BETWEEN"].includes(props.layout.primaryAxisAlignItems)) add(`${path}.layout.primaryAxisAlignItems`, "must be MIN, MAX, CENTER, or SPACE_BETWEEN");
-      if (props.layout.counterAxisAlignItems !== void 0 && !["MIN", "MAX", "CENTER", "BASELINE", "STRETCH"].includes(props.layout.counterAxisAlignItems)) add(`${path}.layout.counterAxisAlignItems`, "must be MIN, MAX, CENTER, BASELINE, or STRETCH");
-    }
-    for (const key of ["fills", "strokes"]) props.styles[key].forEach((item, index) => validatePaint(item, `${path}.${key}[${index}]`));
-    if (node.type === "TEXT" && typeof props.text !== "string") add(`${path}.text`, "TEXT requires text or runs");
-    if (node.type === "SVG" && typeof props.svg !== "string") add(`${path}.svg`, "SVG requires markup");
-    if (node.type === "VECTOR" && !Array.isArray(props.vectorPaths)) add(`${path}.vectorPaths`, "VECTOR requires vectorPaths");
-    if (node.type === "INSTANCE" && typeof props.componentId !== "string") add(`${path}.componentId`, "INSTANCE requires componentId");
-    if (node.type === "BOOLEAN_OPERATION" && (typeof props.operation !== "string" || !["UNION", "SUBTRACT", "INTERSECT", "EXCLUDE"].includes(props.operation))) add(`${path}.operation`, "BOOLEAN_OPERATION requires operation UNION, SUBTRACT, INTERSECT, or EXCLUDE");
-    if (node.type === "COMPONENT_SET" && (!node.children.length || node.children.some((child) => child.type !== "COMPONENT"))) add(`${path}.children`, "COMPONENT_SET requires COMPONENT children");
-    if (node.type === "COMPONENT_SET" && props.variantAxes) {
-      for (const [axis, options] of Object.entries(props.variantAxes)) if (!axis || !Array.isArray(options) || !options.length || options.some((option) => typeof option !== "string")) add(`${path}.variantAxes.${axis}`, "must be a non-empty string array");
-      const variantAxes = props.variantAxes;
-      node.children.forEach((child, index) => Object.entries(child.properties.variant || {}).forEach(([axis, value]) => {
-        if (!variantAxes[axis]?.includes(value)) add(`${path}.children[${index}].variant.${axis}`, `value '${value}' is not declared in variantAxes`);
-      }));
-    }
-    if (props.prototype !== void 0) Array.isArray(props.prototype) ? validatePrototype(props.prototype, `${path}.prototype`) : add(`${path}.prototype`, "must be an array of reactions");
-    if (["GROUP", "BOOLEAN_OPERATION"].includes(node.type) && !node.children.length) add(`${path}.children`, `${node.type} requires children`);
-    node.children.forEach((child, index) => walk(child, `${path}.children[${index}]`));
-  }
-  document.nodes.forEach((node, index) => walk(node, `nodes[${index}]`));
-  function references(node, path) {
-    if (node.type === "INSTANCE" && (!node.properties.componentId || !components.has(node.properties.componentId))) add(`${path}.componentId`, `component '${node.properties.componentId || ""}' is not defined in this import`);
-    node.children.forEach((child, index) => references(child, `${path}.children[${index}]`));
-  }
-  document.nodes.forEach((node, index) => references(node, `nodes[${index}]`));
-  const styleKeys = /* @__PURE__ */ new Map();
-  for (const style of document.styles || []) {
-    if (typeof style.id === "string" && style.id) styleKeys.set(style.id, style.type);
-    if (typeof style.name === "string" && style.name) styleKeys.set(style.name, style.type);
-  }
-  const variableKeys = /* @__PURE__ */ new Set();
-  const collectionNames = /* @__PURE__ */ new Set();
-  const modesByCollection = /* @__PURE__ */ new Map();
-  for (const [collectionIndex, collection] of (document.variables || []).entries()) {
-    const modes = Array.isArray(collection.modes) && collection.modes.length ? collection.modes : [];
-    if (collection.modes !== void 0 && (!modes.length || modes.some((mode) => typeof mode !== "string"))) add(`variables[${collectionIndex}].modes`, "must be a non-empty array of mode names");
-    if (typeof collection.name === "string" && collection.name) {
-      collectionNames.add(collection.name);
-      if (collection.modes !== void 0 && modes.length && modes.every((mode) => typeof mode === "string")) {
-        modesByCollection.set(collection.name, modes);
-      }
-    }
-    for (const [variableIndex, variable] of (collection.items || []).entries()) {
-      const path = `variables[${collectionIndex}].items[${variableIndex}]`;
-      if (!variable.name || typeof variable.name !== "string") add(`${path}.name`, "must be a non-empty string");
-      if (!["COLOR", "FLOAT", "STRING", "BOOLEAN"].includes(variable.type)) add(`${path}.type`, "must be COLOR, FLOAT, STRING, or BOOLEAN");
-      if (typeof variable.id === "string" && variable.id) variableKeys.add(variable.id);
-      if (typeof variable.name === "string" && variable.name) variableKeys.add(variable.name);
-      const values = variable.values || (variable.value !== void 0 ? { default: variable.value } : {});
-      if (!Object.keys(values).length) add(`${path}`, "requires value or values");
-      if (variable.values && modes.length) {
-        for (const mode of modes) if (!(mode in variable.values)) add(`${path}.values.${mode}`, "missing value for declared mode");
-      }
-      for (const [mode, value] of Object.entries(values)) {
-        if (variable.type === "FLOAT" && !finite(value)) add(`${path}.${mode}`, "FLOAT value must be a finite number");
-        if (variable.type === "STRING" && typeof value !== "string") add(`${path}.${mode}`, "STRING value must be a string");
-        if (variable.type === "BOOLEAN" && typeof value !== "boolean") add(`${path}.${mode}`, "BOOLEAN value must be true or false");
-        const color = value && typeof value === "object" && !Array.isArray(value) ? value : null;
-        if (variable.type === "COLOR" && (!color || !finite(color.r) || !finite(color.g) || !finite(color.b))) add(`${path}.${mode}`, "COLOR value requires numeric r, g, and b channels");
-      }
-    }
-  }
-  function tokenReferences(node, path) {
-    const bindings = node.properties.bindings;
-    if (bindings) {
-      for (const [field, key] of Object.entries(bindings)) {
-        if (typeof key !== "string" || !key) {
-          add(`${path}.bindings.${field}`, "must be a non-empty variable id or name");
-          continue;
-        }
-        if (!variableKeys.has(key)) add(`${path}.bindings.${field}`, `variable '${key}' is not defined in this document`);
-      }
-    }
-    const variableModes = node.properties.variableModes;
-    if (variableModes) {
-      for (const [collectionName, modeName] of Object.entries(variableModes)) {
-        if (!collectionNames.has(collectionName)) {
-          add(`${path}.variableModes.${collectionName}`, `variable collection '${collectionName}' is not defined in this document`);
-          continue;
-        }
-        if (typeof modeName !== "string" || !modeName) {
-          add(`${path}.variableModes.${collectionName}`, "must be a non-empty mode name");
-          continue;
-        }
-        const declared = modesByCollection.get(collectionName);
-        if (declared && !declared.includes(modeName)) add(`${path}.variableModes.${collectionName}`, `mode '${modeName}' is not declared on collection '${collectionName}'`);
-      }
-    }
-    const styleRefs = node.properties.styleRefs;
-    if (styleRefs) {
-      for (const [field, key] of Object.entries(styleRefs)) {
-        if (typeof key !== "string" || !key) {
-          add(`${path}.styleRefs.${field}`, "must be a non-empty style id or name");
-          continue;
-        }
-        const styleType = styleKeys.get(key);
-        if (!styleType) {
-          add(`${path}.styleRefs.${field}`, `style '${key}' is not defined in this document`);
-          continue;
-        }
-        if ((field === "fill" || field === "stroke") && styleType !== "PAINT") {
-          add(`${path}.styleRefs.${field}`, `style '${key}' has type ${styleType} but ${field} requires PAINT`);
-        } else if (field === "text" && styleType !== "TEXT") {
-          add(`${path}.styleRefs.${field}`, `style '${key}' has type ${styleType} but text requires TEXT`);
-        }
-      }
-    }
-    node.children.forEach((child, index) => tokenReferences(child, `${path}.children[${index}]`));
-  }
-  document.nodes.forEach((node, index) => tokenReferences(node, `nodes[${index}]`));
-  return errors;
-}
-
 // src/references.ts
 function indexDocument(document) {
   const nodes = /* @__PURE__ */ new Map();
@@ -8909,6 +10675,11 @@ function indexDocument(document) {
 }
 
 // src/index.ts
+function parseIssue(error, code = "PARSE_OR_NORMALIZE") {
+  const message = error instanceof Error ? error.message : String(error);
+  const match = /^(patch\.operations\[\d+\](?:\.[^:\s]+)?): (.*)$/s.exec(message);
+  return { severity: "ERROR", code, path: match ? match[1] : "$", message: match ? match[2] : message, suggestion: "Correct the document using the Compact Design schema." };
+}
 function parse(source) {
   return parseDocument(source);
 }
@@ -8921,13 +10692,46 @@ function normalizePatch(value) {
 function validate(value) {
   try {
     const schemaIssues = validateSchema(value);
-    if (schemaIssues.length) return { valid: false, issues: schemaIssues };
-    if (isPatchDocument(value)) return { valid: true, issues: [], patch: normalizePatchDocument(value) };
+    if (schemaIssues.length) return { valid: false, issues: isPatchDocument(value) ? [...patchKeyIssues(value), ...schemaIssues] : schemaIssues };
+    if (isPatchDocument(value)) {
+      try {
+        return { valid: true, issues: [], patch: normalizePatchDocument(value) };
+      } catch (error) {
+        return { valid: false, issues: [parseIssue(error, "PATCH_SET_UNSUPPORTED")] };
+      }
+    }
     const document = normalizeDocument(value);
     const issues = validationIssues(validateDocument(document));
     return { valid: issues.length === 0, issues, document };
   } catch (error) {
-    return { valid: false, issues: [{ severity: "ERROR", code: "PARSE_OR_NORMALIZE", path: "$", message: error instanceof Error ? error.message : String(error), suggestion: "Correct the document using the Compact Design schema." }] };
+    return { valid: false, issues: [parseIssue(error)] };
+  }
+}
+function patchKeyIssues(value) {
+  const operations = value.patch?.operations;
+  if (!Array.isArray(operations)) return [];
+  const issues = [];
+  operations.forEach((operation, index) => {
+    if (!operation || typeof operation !== "object") return;
+    const { op, set } = operation;
+    if (op !== "set" || !set || typeof set !== "object" || Array.isArray(set)) return;
+    for (const issue2 of patchSetShapeIssues(set)) {
+      const split = issue2.indexOf(": ");
+      const key = split > 0 ? issue2.slice(0, split) : "";
+      issues.push({ severity: "ERROR", code: "PATCH_SET_UNSUPPORTED", path: `patch.operations[${index}].set${key ? `.${key}` : ""}`, message: split > 0 ? issue2.slice(split + 2) : issue2, suggestion: "Use only the settable keys listed in PATCH_SET_KEYS / DESIGN-LANGUAGE.md (Patch set semantics)." });
+    }
+  });
+  return issues;
+}
+function validatePatch(document, patch) {
+  const checked = validate(patch);
+  if (!checked.valid) return { valid: false, issues: checked.issues };
+  if (!checked.patch) return { valid: false, issues: [{ severity: "ERROR", code: "PATCH_EXPECTED", path: "$", message: "Expected a patch document with a top-level patch.operations array.", suggestion: 'Wrap operations in { "patch": { "operations": [...] } }.' }] };
+  try {
+    const result = applyDocumentPatch(document, checked.patch);
+    return { valid: true, issues: [], patch: checked.patch, document: result.document, affectedIds: result.affectedIds, warnings: result.warnings };
+  } catch (error) {
+    return { valid: false, issues: error instanceof PatchError ? error.issues : [parseIssue(error, "PATCH_OPERATION")], patch: checked.patch };
   }
 }
 function lint(value) {
@@ -8937,13 +10741,44 @@ function applyPatch(document, patch) {
   return applyDocumentPatch(document, patch);
 }
 export {
+  PATCH_SET_APPLIES_TO,
+  PATCH_SET_DEFERRED_KEYS,
+  PATCH_SET_EXCLUDED_NODE_KEYS,
+  PATCH_SET_KEYS,
+  PATCH_SET_SEMANTICS,
+  PATCH_TEXT_STYLE_KEYS,
+  PatchError,
   applyPatch,
+  assertPrototypePatchRules,
+  assertPrototypeSetDestinations,
+  buildDuplicateIdMap,
+  buildDuplicateIdMapFromIds,
+  cloneSubtreeWithIds,
+  collectSubtreeIds,
+  corePatchContext,
+  detectVariantRenames,
+  forEachPrototypeDestination,
   indexDocument,
+  isAfterTimeoutReaction,
   isPatchDocument,
+  isPatchSetKey,
+  isTopLevelNodeId,
   lint,
+  newDocumentIssues,
   normalize,
   normalizePatch,
+  normalizePatchSet,
   parse,
+  patchSetBindingFields,
+  patchSetShapeIssues,
+  patchSetTargetIssues,
+  prototypeDestinationErrors,
+  prototypePatchStrictErrors,
+  remapDelimitedIds,
+  remapIssueKeyThroughDuplicate,
   schema,
-  validate
+  subtreeContainsType,
+  validate,
+  validatePatch,
+  variantAxesUncarriedOptions
 };