@popcraft/kit 0.29.0 → 0.31.0

package/dist/chunks/chunk-MQ66HDKC.js

@@ -0,0 +1,2662 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  init_palettes,
+  presetPalette
+} from "./chunk-N7XUSTLZ.js";
+import {
+  init_page_presets,
+  kindForCategory,
+  presetById,
+  presetPx
+} from "./chunk-XBVMM6ZD.js";
+import {
+  encodeCels,
+  init_cells
+} from "./chunk-2LYY4KTS.js";
+import {
+  init_instance_layout,
+  instanceChildBox,
+  setSceneApi
+} from "./chunk-SMR77HUB.js";
+import {
+  effectiveComponentProperties,
+  init_instances,
+  withPropertyPaths
+} from "./chunk-2YBOCBPA.js";
+import {
+  init_variables,
+  resolveNodeVariables
+} from "./chunk-FREAHUVP.js";
+import {
+  blursOf,
+  init_effects,
+  shadowsOf
+} from "./chunk-4VICNBUI.js";
+import {
+  init_layout_access,
+  readCachedTextLayout
+} from "./chunk-IPETYEVH.js";
+import {
+  init_scene3d,
+  scene3dOf,
+  sceneLayers,
+  setVirtualResolver
+} from "./chunk-NMFXCSU4.js";
+import {
+  fromAffine,
+  init_transform3d,
+  mul4,
+  projectRect,
+  sceneFrame
+} from "./chunk-CK43FENV.js";
+import {
+  IDENTITY,
+  aabbOf,
+  apply,
+  decompose,
+  determinant,
+  init_transform,
+  invert,
+  lengthScale,
+  localCentre,
+  localMatrix,
+  multiply,
+  nearestAngle,
+  nodeFlips,
+  restValue,
+  withoutFlips
+} from "./chunk-X53QDCNX.js";
+import {
+  init_dist_node,
+  v4_default
+} from "./chunk-VBAS5IB5.js";
+import {
+  createColor,
+  createDefaultSceneNodeProps,
+  createSolidPaint,
+  init_types
+} from "./chunk-CZXJDKOJ.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-FFS4SO7R.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-LJSVREWM.js";
+
+// lib/engine/routing.ts
+function calculateOrthogonalPath(options) {
+  const { startPos, endPos, startDir, endDir, minSegmentLength = 20, obstacles, obstaclePadding = 14 } = options;
+  if (obstacles && obstacles.length > 0) {
+    const routed = routeAroundObstacles(startPos, endPos, startDir, endDir, obstacles, obstaclePadding, minSegmentLength);
+    if (routed) return routed;
+  }
+  const p1 = getPointAtDistance(startPos, startDir, minSegmentLength);
+  const p2 = getPointAtDistance(endPos, endDir, minSegmentLength);
+  const pts = [startPos, p1];
+  const isHoriz = (dir) => dir === "LEFT" || dir === "RIGHT" || dir === "CENTER";
+  if (isHoriz(startDir) && isHoriz(endDir)) {
+    const midX = (p1.x + p2.x) / 2;
+    pts.push({ x: midX, y: p1.y });
+    pts.push({ x: midX, y: p2.y });
+  } else if (!isHoriz(startDir) && !isHoriz(endDir)) {
+    const midY = (p1.y + p2.y) / 2;
+    pts.push({ x: p1.x, y: midY });
+    pts.push({ x: p2.x, y: midY });
+  } else if (isHoriz(startDir) && !isHoriz(endDir)) {
+    pts.push({ x: p2.x, y: p1.y });
+  } else {
+    pts.push({ x: p1.x, y: p2.y });
+  }
+  pts.push(p2);
+  pts.push(endPos);
+  return dedupe(pts);
+}
+function getPointAtDistance(pos, dir, dist) {
+  switch (dir) {
+    case "TOP":
+      return { x: pos.x, y: pos.y - dist };
+    case "BOTTOM":
+      return { x: pos.x, y: pos.y + dist };
+    case "LEFT":
+      return { x: pos.x - dist, y: pos.y };
+    case "RIGHT":
+      return { x: pos.x + dist, y: pos.y };
+    case "CENTER":
+      return { ...pos };
+  }
+}
+function dedupe(pts) {
+  const out = [];
+  for (let i = 0; i < pts.length; i++) {
+    if (i === 0 || Math.abs(pts[i].x - pts[i - 1].x) > 0.1 || Math.abs(pts[i].y - pts[i - 1].y) > 0.1) {
+      out.push(pts[i]);
+    }
+  }
+  return out;
+}
+function inflate(r, p) {
+  return { x: r.x - p, y: r.y - p, w: r.w + 2 * p, h: r.h + 2 * p };
+}
+function segmentBlocked(ax, ay, bx, by, rects) {
+  const EPS = 0.01;
+  if (Math.abs(ay - by) < EPS) {
+    const y = ay;
+    const lo = Math.min(ax, bx), hi = Math.max(ax, bx);
+    for (const r of rects) {
+      const top = r.y, bot = r.y + r.h, left = r.x, right = r.x + r.w;
+      if (y > top + EPS && y < bot - EPS && hi > left + EPS && lo < right - EPS) return true;
+    }
+  } else {
+    const x = ax;
+    const lo = Math.min(ay, by), hi = Math.max(ay, by);
+    for (const r of rects) {
+      const top = r.y, bot = r.y + r.h, left = r.x, right = r.x + r.w;
+      if (x > left + EPS && x < right - EPS && hi > top + EPS && lo < bot - EPS) return true;
+    }
+  }
+  return false;
+}
+function pointInsideAny(x, y, rects) {
+  const EPS = 0.01;
+  for (const r of rects) {
+    if (x > r.x + EPS && x < r.x + r.w - EPS && y > r.y + EPS && y < r.y + r.h - EPS) return true;
+  }
+  return false;
+}
+function uniqSorted(vals) {
+  const s = vals.slice().sort((a, b) => a - b);
+  const out = [];
+  for (const v of s) if (out.length === 0 || Math.abs(v - out[out.length - 1]) > 0.5) out.push(v);
+  return out;
+}
+function routeAroundObstacles(start, end, startDir, endDir, obstacles, padding, stub) {
+  const infl = obstacles.map((o) => inflate(o, padding));
+  const s1 = getPointAtDistance(start, startDir, stub);
+  const e1 = getPointAtDistance(end, endDir, stub);
+  let minX = Math.min(s1.x, e1.x), maxX = Math.max(s1.x, e1.x);
+  let minY = Math.min(s1.y, e1.y), maxY = Math.max(s1.y, e1.y);
+  for (const r of infl) {
+    minX = Math.min(minX, r.x);
+    maxX = Math.max(maxX, r.x + r.w);
+    minY = Math.min(minY, r.y);
+    maxY = Math.max(maxY, r.y + r.h);
+  }
+  const ring = padding + stub;
+  const xsRaw = [s1.x, e1.x, minX - ring, maxX + ring];
+  const ysRaw = [s1.y, e1.y, minY - ring, maxY + ring];
+  for (const r of infl) {
+    xsRaw.push(r.x, r.x + r.w);
+    ysRaw.push(r.y, r.y + r.h);
+  }
+  const X = uniqSorted(xsRaw);
+  const Y = uniqSorted(ysRaw);
+  if (X.length * Y.length > 4e3) return null;
+  const ix = (v) => X.findIndex((x) => Math.abs(x - v) < 0.5);
+  const iy = (v) => Y.findIndex((y) => Math.abs(y - v) < 0.5);
+  const si = ix(s1.x), sj = iy(s1.y), ti = ix(e1.x), tj = iy(e1.y);
+  if (si < 0 || sj < 0 || ti < 0 || tj < 0) return null;
+  if (pointInsideAny(s1.x, s1.y, infl) || pointInsideAny(e1.x, e1.y, infl)) return null;
+  const W = X.length, H = Y.length;
+  const cell = (i, j) => j * W + i;
+  const N = W * H;
+  const TURN = stub * 1.5;
+  const startAxis = startDir === "CENTER" ? 0 : HORIZ(startDir) ? 1 : 2;
+  const g = new Float64Array(N * 3).fill(Infinity);
+  const cameFrom = new Int32Array(N * 3).fill(-1);
+  const heurTarget = { x: X[ti], y: Y[tj] };
+  const h = (i, j) => Math.abs(X[i] - heurTarget.x) + Math.abs(Y[j] - heurTarget.y);
+  const heap = [];
+  const fscore = [];
+  const push = (id, f) => {
+    heap.push(id);
+    fscore.push(f);
+    let c = heap.length - 1;
+    while (c > 0) {
+      const p = c - 1 >> 1;
+      if (fscore[p] <= fscore[c]) break;
+      [heap[p], heap[c]] = [heap[c], heap[p]];
+      [fscore[p], fscore[c]] = [fscore[c], fscore[p]];
+      c = p;
+    }
+  };
+  const pop = () => {
+    const top = heap[0];
+    const lastId = heap.pop();
+    const lastF = fscore.pop();
+    if (heap.length > 0) {
+      heap[0] = lastId;
+      fscore[0] = lastF;
+      let c = 0;
+      for (; ; ) {
+        const l = 2 * c + 1, r = 2 * c + 2;
+        let m = c;
+        if (l < heap.length && fscore[l] < fscore[m]) m = l;
+        if (r < heap.length && fscore[r] < fscore[m]) m = r;
+        if (m === c) break;
+        [heap[m], heap[c]] = [heap[c], heap[m]];
+        [fscore[m], fscore[c]] = [fscore[c], fscore[m]];
+        c = m;
+      }
+    }
+    return top;
+  };
+  const startState = cell(si, sj) * 3 + startAxis;
+  g[startState] = 0;
+  push(startState, h(si, sj));
+  const targetCell = cell(ti, tj);
+  let endState = -1;
+  while (heap.length > 0) {
+    const state = pop();
+    const c = Math.floor(state / 3);
+    const axis = state % 3;
+    if (c === targetCell) {
+      endState = state;
+      break;
+    }
+    const i = c % W, j = Math.floor(c / W);
+    const gc = g[state];
+    const moves = [
+      { ni: i - 1, nj: j, ax: 1 },
+      { ni: i + 1, nj: j, ax: 1 },
+      { ni: i, nj: j - 1, ax: 2 },
+      { ni: i, nj: j + 1, ax: 2 }
+    ];
+    for (const mv of moves) {
+      if (mv.ni < 0 || mv.ni >= W || mv.nj < 0 || mv.nj >= H) continue;
+      if (segmentBlocked(X[i], Y[j], X[mv.ni], Y[mv.nj], infl)) continue;
+      const len = Math.abs(X[mv.ni] - X[i]) + Math.abs(Y[mv.nj] - Y[j]);
+      const turn = axis !== 0 && axis !== mv.ax ? TURN : 0;
+      const ns = cell(mv.ni, mv.nj) * 3 + mv.ax;
+      const ng = gc + len + turn;
+      if (ng < g[ns]) {
+        g[ns] = ng;
+        cameFrom[ns] = state;
+        push(ns, ng + h(mv.ni, mv.nj));
+      }
+    }
+  }
+  if (endState < 0) return null;
+  const way = [];
+  let s = endState;
+  while (s >= 0) {
+    const c = Math.floor(s / 3);
+    way.push({ x: X[c % W], y: Y[Math.floor(c / W)] });
+    s = cameFrom[s];
+  }
+  way.reverse();
+  return dedupe([start, ...way, end]);
+}
+function trimPolyline(pts, startTrim, endTrim) {
+  if (pts.length < 2) return null;
+  if (startTrim <= 0 && endTrim <= 0) return pts;
+  const n = pts.length;
+  const cum = new Array(n);
+  cum[0] = 0;
+  for (let i = 1; i < n; i++) {
+    cum[i] = cum[i - 1] + Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y);
+  }
+  const total = cum[n - 1];
+  const s0 = Math.max(0, startTrim);
+  const s1 = total - Math.max(0, endTrim);
+  const EPS = 1e-3;
+  if (s1 - s0 < EPS) return null;
+  const pointAt = (s) => {
+    let i = 1;
+    while (i < n - 1 && cum[i] <= s) i++;
+    const segLen = cum[i] - cum[i - 1];
+    const t = segLen > 1e-6 ? (s - cum[i - 1]) / segLen : 0;
+    return {
+      x: pts[i - 1].x + (pts[i].x - pts[i - 1].x) * t,
+      y: pts[i - 1].y + (pts[i].y - pts[i - 1].y) * t
+    };
+  };
+  const out = [pointAt(s0)];
+  for (let i = 1; i < n - 1; i++) {
+    if (cum[i] > s0 + EPS && cum[i] < s1 - EPS) out.push(pts[i]);
+  }
+  out.push(pointAt(s1));
+  return out;
+}
+function calculateBezierPath(options, steps = 30) {
+  const { startPos, endPos, startDir, endDir } = options;
+  const dx = endPos.x - startPos.x;
+  const dy = endPos.y - startPos.y;
+  const dist = Math.max(Math.hypot(dx, dy) * 0.4, 40);
+  const actualDist = Math.hypot(dx, dy);
+  const numSteps = Math.max(30, Math.min(150, Math.floor(actualDist / 3)));
+  let cp1 = getPointAtDistance(startPos, startDir, dist);
+  let cp2 = getPointAtDistance(endPos, endDir, dist);
+  if (startDir === "CENTER") cp1 = { x: startPos.x + dx * 0.25, y: startPos.y + dy * 0.25 };
+  if (endDir === "CENTER") cp2 = { x: endPos.x - dx * 0.25, y: endPos.y - dy * 0.25 };
+  const pts = [];
+  for (let i = 0; i <= numSteps; i++) {
+    const t = i / numSteps;
+    const u = 1 - t;
+    const tt = t * t;
+    const uu = u * u;
+    const uuu = uu * u;
+    const ttt = tt * t;
+    const pX = uuu * startPos.x + 3 * uu * t * cp1.x + 3 * u * tt * cp2.x + ttt * endPos.x;
+    const pY = uuu * startPos.y + 3 * uu * t * cp1.y + 3 * u * tt * cp2.y + ttt * endPos.y;
+    pts.push({ x: pX, y: pY });
+  }
+  return dedupe(pts);
+}
+var HORIZ;
+var init_routing = __esm({
+  "lib/engine/routing.ts"() {
+    "use strict";
+    init_define_POPCRAFT_COMPONENT_IDS();
+    HORIZ = (d) => d === "LEFT" || d === "RIGHT" || d === "CENTER";
+  }
+});
+
+// lib/engine/geometry/flatten.ts
+function flattenQuadratic(x1, y1, cx, cy, x2, y2, points, tolerance) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const d = Math.abs(dy * cx - dx * cy + x2 * y1 - y2 * x1);
+  const len = Math.sqrt(dx * dx + dy * dy);
+  if (len > 0 && d / len <= tolerance) {
+    points.push(x2, y2);
+    return;
+  }
+  const x12 = (x1 + cx) / 2;
+  const y12 = (y1 + cy) / 2;
+  const x23 = (cx + x2) / 2;
+  const y23 = (cy + y2) / 2;
+  const x123 = (x12 + x23) / 2;
+  const y123 = (y12 + y23) / 2;
+  flattenQuadratic(x1, y1, x12, y12, x123, y123, points, tolerance);
+  flattenQuadratic(x123, y123, x23, y23, x2, y2, points, tolerance);
+}
+function flattenCubic(x1, y1, c1x, c1y, c2x, c2y, x2, y2, points, tolerance) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const d1 = Math.abs(dy * c1x - dx * c1y + x2 * y1 - y2 * x1);
+  const d2 = Math.abs(dy * c2x - dx * c2y + x2 * y1 - y2 * x1);
+  const len = Math.sqrt(dx * dx + dy * dy);
+  if (len > 0 && (d1 + d2) / len <= tolerance) {
+    points.push(x2, y2);
+    return;
+  }
+  const x12 = (x1 + c1x) / 2;
+  const y12 = (y1 + c1y) / 2;
+  const x23 = (c1x + c2x) / 2;
+  const y23 = (c1y + c2y) / 2;
+  const x34 = (c2x + x2) / 2;
+  const y34 = (c2y + y2) / 2;
+  const x123 = (x12 + x23) / 2;
+  const y123 = (y12 + y23) / 2;
+  const x234 = (x23 + x34) / 2;
+  const y234 = (y23 + y34) / 2;
+  const x1234 = (x123 + x234) / 2;
+  const y1234 = (y123 + y234) / 2;
+  flattenCubic(x1, y1, x12, y12, x123, y123, x1234, y1234, points, tolerance);
+  flattenCubic(x1234, y1234, x234, y234, x34, y34, x2, y2, points, tolerance);
+}
+function flattenPaths(paths, tolerance = DEFAULT_TOLERANCE) {
+  const result = [];
+  for (const path of paths) {
+    if (!path.points || path.points.length === 0) continue;
+    const flatPoints = [];
+    flatPoints.push(path.points[0].x, path.points[0].y);
+    for (let i = 1; i < path.points.length; i++) {
+      const prev = path.points[i - 1];
+      const curr = path.points[i];
+      if (prev.handleOut && curr.handleIn) {
+        flattenCubic(
+          prev.x,
+          prev.y,
+          prev.handleOut.x,
+          prev.handleOut.y,
+          curr.handleIn.x,
+          curr.handleIn.y,
+          curr.x,
+          curr.y,
+          flatPoints,
+          tolerance
+        );
+      } else if (prev.handleOut) {
+        flattenQuadratic(
+          prev.x,
+          prev.y,
+          prev.handleOut.x,
+          prev.handleOut.y,
+          curr.x,
+          curr.y,
+          flatPoints,
+          tolerance
+        );
+      } else if (curr.handleIn) {
+        flattenQuadratic(
+          prev.x,
+          prev.y,
+          curr.handleIn.x,
+          curr.handleIn.y,
+          curr.x,
+          curr.y,
+          flatPoints,
+          tolerance
+        );
+      } else {
+        flatPoints.push(curr.x, curr.y);
+      }
+    }
+    if (path.closed && path.points.length > 1) {
+      const curr = path.points[0];
+      const prev = path.points[path.points.length - 1];
+      if (prev.handleOut && curr.handleIn) {
+        flattenCubic(
+          prev.x,
+          prev.y,
+          prev.handleOut.x,
+          prev.handleOut.y,
+          curr.handleIn.x,
+          curr.handleIn.y,
+          curr.x,
+          curr.y,
+          flatPoints,
+          tolerance
+        );
+      } else if (prev.handleOut) {
+        flattenQuadratic(
+          prev.x,
+          prev.y,
+          prev.handleOut.x,
+          prev.handleOut.y,
+          curr.x,
+          curr.y,
+          flatPoints,
+          tolerance
+        );
+      } else if (curr.handleIn) {
+        flattenQuadratic(
+          prev.x,
+          prev.y,
+          curr.handleIn.x,
+          curr.handleIn.y,
+          curr.x,
+          curr.y,
+          flatPoints,
+          tolerance
+        );
+      } else {
+        flatPoints.push(curr.x, curr.y);
+      }
+    }
+    result.push(flatPoints);
+  }
+  return result;
+}
+var DEFAULT_TOLERANCE;
+var init_flatten = __esm({
+  "lib/engine/geometry/flatten.ts"() {
+    "use strict";
+    init_define_POPCRAFT_COMPONENT_IDS();
+    DEFAULT_TOLERANCE = 0.25;
+  }
+});
+
+// lib/engine/text/glyph-linear.ts
+function glyphLinear(g) {
+  if (g.xform) return g.xform;
+  if (!g.angle) return null;
+  const c = Math.cos(g.angle), s = Math.sin(g.angle);
+  return [c, s, -s, c];
+}
+var init_glyph_linear = __esm({
+  "lib/engine/text/glyph-linear.ts"() {
+    "use strict";
+    init_define_POPCRAFT_COMPONENT_IDS();
+  }
+});
+
+// lib/engine/text/outline-sdf.ts
+function flattenPath(commands, t, line, tolerance = FLATTEN_TOLERANCE) {
+  const X = (x) => t.sx * x + t.tx;
+  const Y = (y) => t.sy * y + t.ty;
+  let sx = 0, sy = 0, cx = 0, cy = 0, open = false;
+  const close = () => {
+    if (open && (cx !== sx || cy !== sy)) line(cx, cy, sx, sy);
+    cx = sx;
+    cy = sy;
+    open = false;
+  };
+  for (const c of commands) {
+    const a = c.args;
+    switch (c.command) {
+      case "moveTo":
+        close();
+        sx = cx = X(a[0]);
+        sy = cy = Y(a[1]);
+        break;
+      case "lineTo": {
+        const x = X(a[0]), y = Y(a[1]);
+        line(cx, cy, x, y);
+        cx = x;
+        cy = y;
+        open = true;
+        break;
+      }
+      case "quadraticCurveTo": {
+        const x1 = X(a[0]), y1 = Y(a[1]), x2 = X(a[2]), y2 = Y(a[3]);
+        const dd = Math.hypot(cx - 2 * x1 + x2, cy - 2 * y1 + y2);
+        const n = Math.min(256, Math.max(1, Math.ceil(Math.sqrt(dd / (4 * tolerance)))));
+        let px = cx, py = cy;
+        for (let i = 1; i <= n; i++) {
+          const u = i / n, v = 1 - u;
+          const x = v * v * cx + 2 * u * v * x1 + u * u * x2;
+          const y = v * v * cy + 2 * u * v * y1 + u * u * y2;
+          line(px, py, x, y);
+          px = x;
+          py = y;
+        }
+        cx = x2;
+        cy = y2;
+        open = true;
+        break;
+      }
+      case "bezierCurveTo": {
+        const x1 = X(a[0]), y1 = Y(a[1]), x2 = X(a[2]), y2 = Y(a[3]), x3 = X(a[4]), y3 = Y(a[5]);
+        const dd = Math.max(Math.hypot(cx - 2 * x1 + x2, cy - 2 * y1 + y2), Math.hypot(x1 - 2 * x2 + x3, y1 - 2 * y2 + y3));
+        const n = Math.min(256, Math.max(1, Math.ceil(Math.sqrt(0.75 * dd / tolerance))));
+        let px = cx, py = cy;
+        for (let i = 1; i <= n; i++) {
+          const u = i / n, v = 1 - u;
+          const b0 = v * v * v, b1 = 3 * u * v * v, b2 = 3 * u * u * v, b3 = u * u * u;
+          const x = b0 * cx + b1 * x1 + b2 * x2 + b3 * x3;
+          const y = b0 * cy + b1 * y1 + b2 * y2 + b3 * y3;
+          line(px, py, x, y);
+          px = x;
+          py = y;
+        }
+        cx = x3;
+        cy = y3;
+        open = true;
+        break;
+      }
+      case "closePath":
+        close();
+        break;
+    }
+  }
+  close();
+}
+var FLATTEN_TOLERANCE;
+var init_outline_sdf = __esm({
+  "lib/engine/text/outline-sdf.ts"() {
+    "use strict";
+    init_define_POPCRAFT_COMPONENT_IDS();
+    FLATTEN_TOLERANCE = 5e-3;
+  }
+});
+
+// lib/engine/text/text-rings.ts
+function glyphTransform(g) {
+  const s = g.unitScale ?? 0;
+  return { sx: s, sy: -s, tx: g.penX ?? g.x, ty: g.baseline ?? g.y };
+}
+function glyphOutline(g) {
+  if (g.gid === void 0 || !g.font || !g.unitScale) return null;
+  let glyph;
+  try {
+    glyph = g.font.getGlyph(g.gid);
+  } catch {
+    return null;
+  }
+  const commands = glyph?.path?.commands;
+  if (!commands?.length) return null;
+  const t = glyphTransform(g);
+  const turn = glyphTurn(g);
+  return { commands, place: (x, y) => turn(t.sx * x + t.tx, t.sy * y + t.ty) };
+}
+function glyphTurn(g) {
+  const t = glyphTransform(g);
+  const m = glyphLinear(g);
+  return (x, y) => m ? [t.tx + (x - t.tx) * m[0] + (y - t.ty) * m[2], t.ty + (x - t.tx) * m[1] + (y - t.ty) * m[3]] : [x, y];
+}
+function glyphInstancesToRings(instances) {
+  const rings = [];
+  for (const g of instances) {
+    if (g.gid === void 0 || !g.font || !g.unitScale) continue;
+    let glyph;
+    try {
+      glyph = g.font.getGlyph(g.gid);
+    } catch {
+      continue;
+    }
+    const commands = glyph?.path?.commands;
+    if (!commands?.length) continue;
+    let current = [];
+    const push = () => {
+      if (current.length >= 3) rings.push(closeRing(current));
+      current = [];
+    };
+    const t = glyphTransform(g);
+    const turn = glyphTurn(g);
+    flattenPath(commands, t, (x0, y0, x1, y1) => {
+      const [ax, ay] = turn(x0, y0), [bx, by] = turn(x1, y1);
+      const last = current[current.length - 1];
+      if (!last || last[0] !== ax || last[1] !== ay) {
+        push();
+        current.push([ax, ay]);
+      }
+      current.push([bx, by]);
+    });
+    push();
+  }
+  return rings;
+}
+function closeRing(r) {
+  const a = r[0];
+  const b = r[r.length - 1];
+  return a[0] === b[0] && a[1] === b[1] ? r : [...r, [a[0], a[1]]];
+}
+var init_text_rings = __esm({
+  "lib/engine/text/text-rings.ts"() {
+    "use strict";
+    init_define_POPCRAFT_COMPONENT_IDS();
+    init_glyph_linear();
+    init_outline_sdf();
+  }
+});
+
+// lib/engine/geometry/shape-outline.ts
+function shapeToRings(node, ox, oy) {
+  const w = node.width;
+  const h = node.height;
+  const cx = ox + w / 2;
+  const cy = oy + h / 2;
+  const rot = (node.rotation || 0) * Math.PI / 180;
+  const cosR = Math.cos(rot);
+  const sinR = Math.sin(rot);
+  const place2 = (lx, ly) => {
+    const dx = ox + lx - cx;
+    const dy = oy + ly - cy;
+    return [cx + dx * cosR - dy * sinR, cy + dx * sinR + dy * cosR];
+  };
+  const closeRing2 = (r) => {
+    if (r.length && (r[0][0] !== r[r.length - 1][0] || r[0][1] !== r[r.length - 1][1])) r.push([r[0][0], r[0][1]]);
+    return r;
+  };
+  switch (node.type) {
+    case "ELLIPSE": {
+      const rx = w / 2, ry = h / 2;
+      const ring = [];
+      for (let i = 0; i < ELLIPSE_SEGMENTS; i++) {
+        const a = i / ELLIPSE_SEGMENTS * Math.PI * 2;
+        ring.push(place2(w / 2 + rx * Math.cos(a), h / 2 + ry * Math.sin(a)));
+      }
+      return [closeRing2(ring)];
+    }
+    case "POLYGON": {
+      const n = Math.max(3, node.pointCount || 3);
+      const rx = w / 2, ry = h / 2;
+      const ring = [];
+      for (let i = 0; i < n; i++) {
+        const a = -Math.PI / 2 + i / n * Math.PI * 2;
+        ring.push(place2(w / 2 + rx * Math.cos(a), h / 2 + ry * Math.sin(a)));
+      }
+      return [closeRing2(ring)];
+    }
+    case "STAR": {
+      const n = Math.max(3, node.pointCount || 5);
+      const inner = node.innerRadius ?? 0.4;
+      const rx = w / 2, ry = h / 2;
+      const ring = [];
+      for (let i = 0; i < n * 2; i++) {
+        const a = -Math.PI / 2 + i / (n * 2) * Math.PI * 2;
+        const f = i % 2 === 0 ? 1 : inner;
+        ring.push(place2(w / 2 + rx * f * Math.cos(a), h / 2 + ry * f * Math.sin(a)));
+      }
+      return [closeRing2(ring)];
+    }
+    case "VECTOR": {
+      const paths = node.paths;
+      if (!paths || paths.length === 0) return [];
+      const flat = flattenPaths(paths);
+      return flat.filter((p) => p.length >= 6).map((p) => {
+        const ring = [];
+        for (let i = 0; i < p.length; i += 2) ring.push(place2(p[i], p[i + 1]));
+        return closeRing2(ring);
+      });
+    }
+    case "TEXT": {
+      const layout = readCachedTextLayout(node.id);
+      if (!layout) return [];
+      return glyphInstancesToRings(layout.instances).map((ring) => ring.map(([lx, ly]) => place2(lx, ly)));
+    }
+    case "LINE":
+    case "ARROW":
+      return [];
+    // no fillable area
+    default: {
+      return [closeRing2([place2(0, 0), place2(w, 0), place2(w, h), place2(0, h)])];
+    }
+  }
+}
+function tableCellGeom(table) {
+  const colCount = table.colCount || 5, rowCount = table.rowCount || 5;
+  const colWidths = table.colWidths && table.colWidths.length ? table.colWidths : Array(colCount).fill(140);
+  const rowHeights = table.rowHeights && table.rowHeights.length ? table.rowHeights : Array(rowCount).fill(32);
+  return { colWidths, rowHeights };
+}
+function tableCellRect(table, r, c) {
+  const { colWidths, rowHeights } = tableCellGeom(table);
+  let x = 0;
+  for (let i = 0; i < c; i++) x += colWidths[i] || 140;
+  let y = 0;
+  for (let i = 0; i < r; i++) y += rowHeights[i] || 32;
+  return { x, y, w: colWidths[c] || 140, h: rowHeights[r] || 32 };
+}
+function tableCellAnchor(table, r, c, edge) {
+  const rc = tableCellRect(table, r, c);
+  switch (edge) {
+    case "TOP":
+      return { x: rc.x + rc.w / 2, y: rc.y };
+    case "BOTTOM":
+      return { x: rc.x + rc.w / 2, y: rc.y + rc.h };
+    case "LEFT":
+      return { x: rc.x, y: rc.y + rc.h / 2 };
+    case "RIGHT":
+      return { x: rc.x + rc.w, y: rc.y + rc.h / 2 };
+    default:
+      return { x: rc.x + rc.w / 2, y: rc.y + rc.h / 2 };
+  }
+}
+function getConnectorAnchorLocal(node, position) {
+  const w = node.width || 1;
+  const h = node.height || 1;
+  if (node.type === "TABLE") {
+    const m = /^(\d+),(\d+):(TOP|BOTTOM|LEFT|RIGHT)$/.exec(position);
+    if (m) return tableCellAnchor(node, +m[1], +m[2], m[3]);
+  }
+  const bbox = {
+    TOP: { x: w / 2, y: 0 },
+    BOTTOM: { x: w / 2, y: h },
+    LEFT: { x: 0, y: h / 2 },
+    RIGHT: { x: w, y: h / 2 },
+    CENTER: { x: w / 2, y: h / 2 }
+  };
+  const pos = position in bbox ? position : "CENTER";
+  if (pos === "CENTER") return bbox.CENTER;
+  const boxy = /* @__PURE__ */ new Set([
+    "RECTANGLE",
+    "FRAME",
+    "IMAGE",
+    "TEXT",
+    "STICKY",
+    "GROUP",
+    "SECTION",
+    "COMPONENT",
+    "COMPONENT_SET",
+    "INSTANCE",
+    "TABLE",
+    "SLICE"
+  ]);
+  if (boxy.has(node.type)) return bbox[pos];
+  const key = `${node.id}:${Math.round(w)}x${Math.round(h)}:${node.type}`;
+  let anchors = _anchorCache.get(key);
+  if (!anchors) {
+    anchors = { ...bbox };
+    let rings = [];
+    try {
+      rings = shapeToRings({ ...node, rotation: 0 }, 0, 0);
+    } catch {
+      rings = [];
+    }
+    if (rings.length) {
+      const yc = h / 2;
+      let minX = Infinity, maxX = -Infinity;
+      const xc = w / 2;
+      let minY = Infinity, maxY = -Infinity;
+      for (const ring of rings) {
+        for (let i = 1; i < ring.length; i++) {
+          const [x1, y1] = ring[i - 1], [x2, y2] = ring[i];
+          if (y1 <= yc && y2 >= yc || y2 <= yc && y1 >= yc) {
+            if (y1 !== y2) {
+              const t = (yc - y1) / (y2 - y1);
+              const x = x1 + t * (x2 - x1);
+              if (x < minX) minX = x;
+              if (x > maxX) maxX = x;
+            }
+          }
+          if (x1 <= xc && x2 >= xc || x2 <= xc && x1 >= xc) {
+            if (x1 !== x2) {
+              const t = (xc - x1) / (x2 - x1);
+              const y = y1 + t * (y2 - y1);
+              if (y < minY) minY = y;
+              if (y > maxY) maxY = y;
+            }
+          }
+        }
+      }
+      if (minX !== Infinity) {
+        anchors.LEFT = { x: minX, y: yc };
+        anchors.RIGHT = { x: maxX, y: yc };
+      }
+      if (minY !== Infinity) {
+        anchors.TOP = { x: xc, y: minY };
+        anchors.BOTTOM = { x: xc, y: maxY };
+      }
+    }
+    if (_anchorCache.size > 512) _anchorCache.clear();
+    _anchorCache.set(key, anchors);
+  }
+  return anchors[pos];
+}
+function connectorPositionDir(position) {
+  const m = /(TOP|BOTTOM|LEFT|RIGHT|CENTER)$/.exec(position || "");
+  return m ? m[1] : "CENTER";
+}
+var ELLIPSE_SEGMENTS, _anchorCache;
+var init_shape_outline = __esm({
+  "lib/engine/geometry/shape-outline.ts"() {
+    "use strict";
+    init_define_POPCRAFT_COMPONENT_IDS();
+    init_flatten();
+    init_layout_access();
+    init_text_rings();
+    ELLIPSE_SEGMENTS = 64;
+    _anchorCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// lib/document/scene-graph.ts
+function virtualRootOf(host, doc) {
+  if (!host) return void 0;
+  if (host.type === "INSTANCE") return host.mainComponentId || void 0;
+  if (host.type === "FRAME") {
+    const frame = host;
+    if (doc) {
+      const { effectiveMasterId: effectiveMasterId2 } = (init_print_pages(), __toCommonJS(print_pages_exports));
+      return effectiveMasterId2(doc, frame);
+    }
+    return frame.print?.masterId;
+  }
+  return void 0;
+}
+function virtualChildId(parent, childId) {
+  if (parent.type === "INSTANCE" || parent.type === "FRAME" && parent.print?.masterId && !parent.id.includes("::")) return `${parent.id}::${childId}`;
+  if (parent.id.includes("::")) return `${parent.id.split("::").slice(0, -1).join("::")}::${childId}`;
+  return childId;
+}
+function chainOverrides(nodes, parts) {
+  let merged = {};
+  for (let k = 0; k < parts.length - 1; k++) {
+    const raw = nodes[parts[k]];
+    if (!raw) break;
+    const node = k === 0 ? raw : { ...raw, ...merged[raw.id] };
+    if (node.type === "INSTANCE") merged = { ...node.overrides || {}, ...merged };
+  }
+  return merged;
+}
+function resolveVirtualNode(nodes, id, opts) {
+  if (!id) return null;
+  if (!id.includes("::")) return nodes[id] || null;
+  const posed = nodes[id];
+  if (posed) return posed;
+  const parts = id.split("::");
+  const instanceId = parts[0];
+  const targetId = parts[parts.length - 1];
+  const instance = nodes[instanceId];
+  const target = nodes[targetId];
+  const rootId = virtualRootOf(instance);
+  if (!instance || !rootId || !target) return null;
+  const overrides = instance.type === "INSTANCE" ? chainOverrides(nodes, parts)[targetId] || {} : {};
+  let parentId;
+  if (parts.length === 2) {
+    parentId = target.parentId === rootId ? instanceId : `${instanceId}::${target.parentId}`;
+  } else {
+    const ownerId = parts.slice(0, -1).join("::");
+    const owner = resolveVirtualNode(nodes, ownerId, opts);
+    const ownerRoot = virtualRootOf(owner ?? void 0);
+    parentId = target.parentId === ownerRoot ? ownerId : `${ownerId}::${target.parentId}`;
+  }
+  const resolved = { ...target, ...overrides, id, parentId };
+  const refs = resolved.componentPropertyReferences;
+  let props = null;
+  if (refs?.characters || refs?.visible) {
+    props = effectiveComponentProperties(nodes, parts);
+    if (refs.characters && typeof props[refs.characters] === "string") resolved.characters = props[refs.characters];
+    if (refs.visible && typeof props[refs.visible] === "boolean") resolved.visible = props[refs.visible];
+  }
+  if (resolved.componentPropertyPaths || resolved.motion?.tracks) {
+    const shown = withPropertyPaths(resolved, props ?? effectiveComponentProperties(nodes, parts));
+    if (shown !== resolved) Object.assign(resolved, shown);
+  }
+  if (resolved.type === "INSTANCE" && instance.type === "INSTANCE") {
+    const ref = resolved.componentPropertyReferences?.mainComponent;
+    const v = ref ? instance.componentProperties?.[ref] : void 0;
+    if (typeof v === "string" && nodes[v]) resolved.mainComponentId = v;
+  }
+  if (opts?.layout !== false) {
+    const box = instanceChildBox(nodes, id);
+    if (box) {
+      resolved.x = box.x;
+      resolved.y = box.y;
+      resolved.width = box.width;
+      resolved.height = box.height;
+    }
+  }
+  return resolved;
+}
+function createDocument(name = "Untitled", settings) {
+  const pageId = v4_default();
+  const page = {
+    id: pageId,
+    name: "Page 1",
+    type: "PAGE",
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    backgroundColor: createColor(0.12, 0.12, 0.13)
+  };
+  return {
+    id: v4_default(),
+    name,
+    pages: [pageId],
+    nodes: {
+      [pageId]: page
+    },
+    ...settings ? { settings } : {}
+  };
+}
+function createPage(name = "New Page") {
+  return {
+    id: v4_default(),
+    name,
+    type: "PAGE",
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    backgroundColor: createColor(0.12, 0.12, 0.13)
+  };
+}
+function createRectangle(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Rectangle",
+    type: "RECTANGLE",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    ...props
+  };
+}
+function createEllipse(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Ellipse",
+    type: "ELLIPSE",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    ...props
+  };
+}
+function createSticky(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Sticky Note",
+    type: "STICKY",
+    x: 0,
+    y: 0,
+    width: 200,
+    height: 200,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    text: "",
+    authorName: "Unknown",
+    ...createDefaultSceneNodeProps(),
+    fills: [createSolidPaint(createColor(1, 0.9, 0.4, 1))],
+    // Default yellow sticky color
+    ...props
+  };
+}
+function createLine(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Line",
+    type: "LINE",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 0,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    fills: [],
+    // Lines typically have no fill
+    strokes: [{
+      color: createColor(0, 0, 0),
+      width: 2,
+      alignment: "CENTER",
+      cap: "ROUND",
+      join: "ROUND",
+      dashPattern: []
+    }],
+    startPoint: { x: 0, y: 0 },
+    endPoint: { x: 100, y: 0 },
+    ...props
+  };
+}
+function createArrow(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Arrow",
+    type: "ARROW",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 0,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    fills: [],
+    strokes: [{
+      color: createColor(0, 0, 0),
+      width: 2,
+      alignment: "CENTER",
+      cap: "ROUND",
+      join: "ROUND",
+      dashPattern: []
+    }],
+    startPoint: { x: 0, y: 0 },
+    endPoint: { x: 100, y: 0 },
+    startArrowhead: "NONE",
+    endArrowhead: "ARROW",
+    ...props
+  };
+}
+function createPolygon(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Polygon",
+    type: "POLYGON",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    pointCount: 3,
+    // triangle by default
+    ...props
+  };
+}
+function createStar(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Star",
+    type: "STAR",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    pointCount: 5,
+    innerRadius: 0.4,
+    ...props
+  };
+}
+function createSection(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Section",
+    type: "SECTION",
+    x: 0,
+    y: 0,
+    width: 400,
+    height: 300,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    backgroundColor: createColor(0.2, 0.2, 0.22),
+    ...props
+  };
+}
+function createSlice(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Slice",
+    type: "SLICE",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    exportSettings: [{
+      format: "PNG",
+      suffix: "",
+      scale: 1,
+      constraint: { type: "SCALE", value: 1 }
+    }],
+    ...props
+  };
+}
+function createFrame(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Frame",
+    type: "FRAME",
+    x: 0,
+    y: 0,
+    width: 375,
+    height: 667,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    fills: [createSolidPaint(createColor(1, 1, 1))],
+    clipsContent: true,
+    backgroundColor: createColor(1, 1, 1),
+    layoutMode: "NONE",
+    primaryAxisAlignItems: "MIN",
+    counterAxisAlignItems: "MIN",
+    padding: { top: 0, right: 0, bottom: 0, left: 0 },
+    itemSpacing: 0,
+    interactions: [],
+    overflowScrolling: "NONE",
+    isFlowStartingPoint: false,
+    ...props
+  };
+}
+function createText(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Text",
+    type: "TEXT",
+    x: 0,
+    y: 0,
+    width: 200,
+    height: 48,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    fills: [createSolidPaint(createColor(0, 0, 0))],
+    characters: "",
+    // New text starts at 40 (its box: one auto line, ~1.2× the size).
+    fontSize: 40,
+    fontFamily: "Inter",
+    fontWeight: 400,
+    fontStyle: "normal",
+    textAlign: "LEFT",
+    verticalAlign: "TOP",
+    lineHeight: "AUTO",
+    letterSpacing: 0,
+    paragraphSpacing: 0,
+    paragraphIndent: 0,
+    textDecoration: "NONE",
+    textCase: "ORIGINAL",
+    textAutoResize: "WIDTH_AND_HEIGHT",
+    interactions: [],
+    ...props
+  };
+}
+function createGroup(childIds = []) {
+  return {
+    id: v4_default(),
+    name: "Group",
+    type: "GROUP",
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds
+  };
+}
+function createVector(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Vector",
+    type: "VECTOR",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    paths: [],
+    fillRule: "NONZERO",
+    ...props
+  };
+}
+function createBoolean(operation, childIds = [], props = {}) {
+  return {
+    id: v4_default(),
+    name: `Boolean (${operation.toLowerCase()})`,
+    type: "BOOLEAN",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds,
+    ...createDefaultSceneNodeProps(),
+    booleanOperation: operation,
+    // Children are stored relative to this node, like a group's. The marker exists so the one-time
+    // migration in the store can tell an already-converted boolean from one written before the change.
+    booleanChildSpace: "LOCAL",
+    paths: [],
+    fillRule: "NONZERO",
+    ...props
+  };
+}
+function createPixelGrid(props = {}) {
+  const cell = props.cellSize ?? 10;
+  const pw = Math.max(1, Math.min(2048, Math.round(props.pixelWidth ?? (props.width ? props.width / cell : 32))));
+  const ph = Math.max(1, Math.min(2048, Math.round(props.pixelHeight ?? (props.height ? props.height / cell : 32))));
+  const { cellSize: _c, width: _w, height: _h, ...rest } = props;
+  return {
+    id: v4_default(),
+    name: "Pixel canvas",
+    type: "PIXEL_GRID",
+    x: 0,
+    y: 0,
+    width: pw * cell,
+    height: ph * cell,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    fills: [],
+    strokes: [],
+    pixelWidth: pw,
+    pixelHeight: ph,
+    colorMode: "RGBA",
+    palette: presetPalette("PICO-8"),
+    transparentIndex: 0,
+    frames: [{ id: v4_default(), cels: encodeCels(new Uint32Array(pw * ph)), duration: 100 }],
+    activeFrame: 0,
+    tags: [],
+    onionSkin: { enabled: false, prev: 1, next: 1, opacity: 0.35 },
+    tiledMode: "NONE",
+    ...rest
+  };
+}
+function createImage(imageUrl, props = {}) {
+  return {
+    id: v4_default(),
+    name: "Image",
+    type: "IMAGE",
+    x: 0,
+    y: 0,
+    width: 200,
+    height: 200,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    // Image nodes draw their imageUrl; a (default grey) fill would be drawn over it instead.
+    fills: [],
+    imageUrl,
+    scaleMode: "FILL",
+    ...props
+  };
+}
+function createRaster(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Paint layer",
+    type: "RASTER",
+    x: 0,
+    y: 0,
+    width: 1024,
+    height: 768,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    fills: [],
+    strokes: [],
+    pixelWidth: 1024,
+    pixelHeight: 768,
+    rasterTiles: {},
+    ...props
+  };
+}
+function createComponent(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Component",
+    type: "COMPONENT",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    componentPropertyDefinitions: {},
+    ...createDefaultSceneNodeProps(),
+    ...props
+  };
+}
+function createComponentSet(props = {}) {
+  return {
+    id: v4_default(),
+    name: "Component Set",
+    type: "COMPONENT_SET",
+    x: 0,
+    y: 0,
+    width: 200,
+    height: 200,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    componentPropertyDefinitions: {},
+    ...createDefaultSceneNodeProps(),
+    ...props
+  };
+}
+function createInstance(mainComponentId, props = {}) {
+  return {
+    id: v4_default(),
+    name: "Instance",
+    type: "INSTANCE",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    rotation: 0,
+    opacity: 1,
+    visible: true,
+    locked: false,
+    parentId: null,
+    childIds: [],
+    ...createDefaultSceneNodeProps(),
+    mainComponentId,
+    overrides: {},
+    componentProperties: {},
+    ...props
+  };
+}
+function createInstanceOf(main, props = {}) {
+  const m = main;
+  return createInstance(main.id, {
+    name: main.name,
+    width: main.width,
+    height: main.height,
+    fills: m.fills ?? [],
+    strokes: m.strokes ?? [],
+    effects: m.effects ?? [],
+    cornerRadius: m.cornerRadius ?? 0,
+    ...props
+  });
+}
+function addNode(document, node, parentId) {
+  const parent = document.nodes[parentId];
+  if (!parent) {
+    console.error("Parent node not found:", parentId);
+    return document;
+  }
+  const updatedParent = {
+    ...parent,
+    childIds: [...parent.childIds, node.id]
+  };
+  const updatedNode = {
+    ...node,
+    parentId
+  };
+  return {
+    ...document,
+    nodes: {
+      ...document.nodes,
+      [parentId]: updatedParent,
+      [node.id]: updatedNode
+    }
+  };
+}
+function removeNode(document, nodeId) {
+  const node = document.nodes[nodeId];
+  if (!node) return document;
+  const newNodes = { ...document.nodes };
+  if (node.parentId) {
+    const parent = newNodes[node.parentId];
+    if (parent) {
+      newNodes[node.parentId] = {
+        ...parent,
+        childIds: parent.childIds.filter((id) => id !== nodeId)
+      };
+    }
+  }
+  function removeRecursive(id) {
+    const n = newNodes[id];
+    if (n && n.childIds) {
+      n.childIds.forEach(removeRecursive);
+    }
+    delete newNodes[id];
+  }
+  removeRecursive(nodeId);
+  return {
+    ...document,
+    nodes: newNodes
+  };
+}
+function updateNode(document, nodeId, updates) {
+  const node = document.nodes[nodeId];
+  if (!node) return document;
+  return {
+    ...document,
+    nodes: {
+      ...document.nodes,
+      [nodeId]: { ...node, ...updates }
+    }
+  };
+}
+function getDescendants(document, nodeId) {
+  const result = [];
+  const node = document.nodes[nodeId];
+  if (!node) return result;
+  function collectChildren(id) {
+    const n = document.nodes[id];
+    if (n) {
+      result.push(n);
+      n.childIds.forEach(collectChildren);
+    }
+  }
+  node.childIds.forEach(collectChildren);
+  return result;
+}
+function getAncestors(document, nodeId) {
+  const ancestors = [];
+  const node = document.nodes[nodeId];
+  if (!node) return ancestors;
+  let current = node;
+  while (current.parentId) {
+    const parent = document.nodes[current.parentId];
+    if (parent) {
+      ancestors.push(parent);
+      current = parent;
+    } else {
+      break;
+    }
+  }
+  return ancestors;
+}
+function applyConstraints(document, parentId, oldW, oldH, newW, newH) {
+  const parent = document.nodes[parentId];
+  if (!parent || !parent.childIds || parent.childIds.length === 0) return document;
+  if (oldW === 0 || oldH === 0) return document;
+  if (oldW === newW && oldH === newH) return document;
+  if (parent.layoutMode && parent.layoutMode !== "NONE") {
+    return document;
+  }
+  let newDoc = { ...document, nodes: { ...document.nodes } };
+  const deltaW = newW - oldW;
+  const deltaH = newH - oldH;
+  const scaleX = newW / oldW;
+  const scaleY = newH / oldH;
+  for (const childId of parent.childIds) {
+    const child = newDoc.nodes[childId];
+    if (!child) continue;
+    const hConstraint = child.constraints?.horizontal || "MIN";
+    const vConstraint = child.constraints?.vertical || "MIN";
+    let newX = child.x;
+    let newChildW = child.width;
+    let newY = child.y;
+    let newChildH = child.height;
+    switch (hConstraint) {
+      case "MIN":
+        break;
+      case "MAX":
+        newX += deltaW;
+        break;
+      case "CENTER":
+        newX += deltaW / 2;
+        break;
+      case "STRETCH":
+        newChildW = Math.max(1, newChildW + deltaW);
+        break;
+      case "SCALE":
+        newX *= scaleX;
+        newChildW = Math.max(1, newChildW * scaleX);
+        break;
+    }
+    switch (vConstraint) {
+      case "MIN":
+        break;
+      case "MAX":
+        newY += deltaH;
+        break;
+      case "CENTER":
+        newY += deltaH / 2;
+        break;
+      case "STRETCH":
+        newChildH = Math.max(1, newChildH + deltaH);
+        break;
+      case "SCALE":
+        newY *= scaleY;
+        newChildH = Math.max(1, newChildH * scaleY);
+        break;
+    }
+    if (newX !== child.x || newY !== child.y || newChildW !== child.width || newChildH !== child.height) {
+      newDoc.nodes[childId] = {
+        ...child,
+        x: newX,
+        y: newY,
+        width: newChildW,
+        height: newChildH
+      };
+      if (newChildW !== child.width || newChildH !== child.height) {
+        if ("childIds" in child && child.childIds && child.childIds.length > 0) {
+          newDoc = applyConstraints(newDoc, childId, child.width, child.height, newChildW, newChildH);
+        }
+      }
+    }
+  }
+  return newDoc;
+}
+function getRenderableNodes(document, pageId) {
+  const result = [];
+  function collectNodes(nodeId) {
+    const node = document.nodes[nodeId];
+    if (!node || !node.visible) return;
+    if (node.type !== "PAGE") {
+      result.push(node);
+    }
+    if (node.type === "PAGE") {
+      node.childIds.forEach(collectNodes);
+    }
+  }
+  collectNodes(pageId);
+  return result;
+}
+function moveNodeInZOrder(document, nodeId, direction) {
+  const node = document.nodes[nodeId];
+  if (!node || !node.parentId) return document;
+  const parent = document.nodes[node.parentId];
+  if (!parent) return document;
+  const siblings = [...parent.childIds];
+  const currentIndex = siblings.indexOf(nodeId);
+  if (currentIndex === -1) return document;
+  siblings.splice(currentIndex, 1);
+  let newIndex;
+  switch (direction) {
+    case "up":
+      newIndex = Math.min(currentIndex + 1, siblings.length);
+      break;
+    case "down":
+      newIndex = Math.max(currentIndex - 1, 0);
+      break;
+    case "top":
+      newIndex = siblings.length;
+      break;
+    case "bottom":
+      newIndex = 0;
+      break;
+  }
+  siblings.splice(newIndex, 0, nodeId);
+  return {
+    ...document,
+    nodes: {
+      ...document.nodes,
+      [node.parentId]: { ...parent, childIds: siblings }
+    }
+  };
+}
+function uprightBounds(t, width, height) {
+  const hw = width / 2 * t.scaleX, hh = height / 2 * t.scaleY;
+  return { minX: t.cx - hw, minY: t.cy - hh, maxX: t.cx + hw, maxY: t.cy + hh };
+}
+function unmirroredMatrix(t, width, height) {
+  return withoutFlips(t.matrix, t.flipX, t.flipY, width, height);
+}
+function lineShaftEnds(t, width) {
+  const hw = width / 2 * t.scaleX;
+  const cos = Math.cos(t.rotationRad), sin = Math.sin(t.rotationRad);
+  return [{ x: t.cx - hw * cos, y: t.cy - hw * sin }, { x: t.cx + hw * cos, y: t.cy + hw * sin }];
+}
+function place(outer, node, scroll) {
+  const local = localMatrix(node, false, scroll?.x ?? 0, scroll?.y ?? 0);
+  const flips = nodeFlips(node);
+  return {
+    m: outer === ROOT ? local : multiply(outer.m, local),
+    flipX: outer.flipX !== flips.flipX,
+    flipY: outer.flipY !== flips.flipY,
+    angle: outer.sense * ((node.rotation || 0) * Math.PI / 180) + outer.angle,
+    sense: flips.flipX === flips.flipY ? outer.sense : -outer.sense,
+    conformal: outer.conformal && Math.abs(restValue(node, "scaleX")) === Math.abs(restValue(node, "scaleY"))
+  };
+}
+function decomposed(outer, node, p) {
+  const [lx, ly] = localCentre(node);
+  const [cx, cy] = outer === ROOT ? [lx, ly] : apply(outer.m, lx, ly);
+  const q = decompose(withoutFlips(p.m, p.flipX, p.flipY, node.width, node.height));
+  return { cx, cy, rotationRad: p.conformal ? p.angle : q.rotation, flipX: p.flipX, flipY: p.flipY, scaleX: q.scaleX, scaleY: q.scaleY, matrix: p.m };
+}
+function detachedTransform(node) {
+  return decomposed(ROOT, node, place(ROOT, node));
+}
+function rootPlacement(m, outer) {
+  const mirrored = determinant(m) < 0;
+  const q = decompose(m);
+  const uniform = Math.abs(Math.abs(q.scaleX) - Math.abs(q.scaleY)) < 1e-9 && Math.abs(q.skew) < 1e-9;
+  return {
+    m: outer === ROOT ? m : multiply(m, outer.m),
+    flipX: outer.flipX !== mirrored,
+    flipY: outer.flipY,
+    angle: outer.angle + q.rotation,
+    sense: mirrored ? -outer.sense : outer.sense,
+    conformal: outer.conformal && uniform
+  };
+}
+function createResolver(nodes, scrollState, roots) {
+  const placed = /* @__PURE__ */ new Map();
+  const frames = /* @__PURE__ */ new Map();
+  const transforms = /* @__PURE__ */ new Map();
+  const rootFrames = /* @__PURE__ */ new Map();
+  const outerOf = (node) => {
+    const m = roots?.get(node.id);
+    if (!m) return frameOf(node.parentId);
+    let p = rootFrames.get(node.id);
+    if (!p) {
+      p = rootPlacement(m, frameOf(node.parentId));
+      rootFrames.set(node.id, p);
+    }
+    return p;
+  };
+  const placementOf = (id) => {
+    const cached = placed.get(id);
+    if (cached !== void 0) return cached;
+    const node = resolveVirtualNode(nodes, id);
+    const hit = node ? { node, p: place(outerOf(node), node) } : null;
+    placed.set(id, hit);
+    return hit;
+  };
+  function frameOf(containerId) {
+    if (!containerId) return ROOT;
+    const cached = frames.get(containerId);
+    if (cached) return cached;
+    const c = placementOf(containerId);
+    let frame = ROOT;
+    if (c && c.node.type !== "PAGE") {
+      const scroll = scrollState?.[c.node.id];
+      frame = scroll ? place(outerOf(c.node), c.node, scroll) : c.p;
+    }
+    frames.set(containerId, frame);
+    return frame;
+  }
+  return {
+    matrixOf: (id) => placementOf(id)?.p.m ?? IDENTITY,
+    transformOf: (id) => {
+      const cached = transforms.get(id);
+      if (cached) return cached;
+      const hit = placementOf(id);
+      if (!hit) return ZERO_TRANSFORM;
+      const t = decomposed(outerOf(hit.node), hit.node, hit.p);
+      transforms.set(id, t);
+      return t;
+    }
+  };
+}
+function createWorldMatrixResolver(nodes, scrollState) {
+  return createResolver(nodes, scrollState).matrixOf;
+}
+function createWorldTransformResolver(nodes, scrollState, roots) {
+  return createResolver(nodes, scrollState, roots).transformOf;
+}
+function cachedResolver(nodes) {
+  let r = resolverCache.get(nodes);
+  if (!r) {
+    r = createResolver(nodes);
+    resolverCache.set(nodes, r);
+  }
+  return r;
+}
+function getWorldTransform(document, nodeId, scrollState) {
+  return (scrollState ? createResolver(document.nodes, scrollState) : cachedResolver(document.nodes)).transformOf(nodeId);
+}
+function getWorldMatrix(document, nodeId, scrollState) {
+  return (scrollState ? createResolver(document.nodes, scrollState) : cachedResolver(document.nodes)).matrixOf(nodeId);
+}
+function placementUnder(document, nodeId, newParentId) {
+  const node = resolveVirtualNode(document.nodes, nodeId);
+  if (!node) return null;
+  const parent = resolveVirtualNode(document.nodes, newParentId);
+  const inv = !parent || parent.type === "PAGE" ? IDENTITY : invert(getWorldMatrix(document, newParentId));
+  if (!inv) return null;
+  const local = multiply(inv, getWorldMatrix(document, nodeId));
+  let flipH = !!node.flipHorizontal;
+  const flipV = !!node.flipVertical;
+  let m = withoutFlips(local, flipH, flipV, 0, 0);
+  if (determinant(m) < 0) {
+    flipH = !flipH;
+    m = withoutFlips(m, true, false, 0, 0);
+  }
+  const q = decompose(m);
+  const w = node.width, h = node.height;
+  const ax = restValue(node, "anchorX"), ay = restValue(node, "anchorY");
+  const [px, py] = apply(local, ax * w, ay * h);
+  const scale = (key, v) => {
+    const next = Math.abs(v - 1) < 1e-9 ? void 0 : v;
+    return next === void 0 && node[key] === void 0 ? {} : { [key]: next };
+  };
+  return {
+    x: px - ax * w - restValue(node, "translateX"),
+    y: py - ay * h - restValue(node, "translateY"),
+    rotation: nearestAngle(q.rotation * 180 / Math.PI, node.rotation || 0),
+    ...scale("scaleX", q.scaleX),
+    ...scale("scaleY", q.scaleY),
+    ...flipH !== !!node.flipHorizontal ? { flipHorizontal: flipH } : {}
+  };
+}
+function componentsDrawnBy(document, rootId) {
+  const out = /* @__PURE__ */ new Set();
+  const stack = [rootId];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length) {
+    const id = stack.pop();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const n = document.nodes[id];
+    if (!n) continue;
+    if (n.type === "INSTANCE" && n.mainComponentId) {
+      const main = n.mainComponentId;
+      out.add(main);
+      stack.push(main);
+    }
+    if ("childIds" in n && n.childIds) for (const c of n.childIds) stack.push(c);
+  }
+  return out;
+}
+function wouldCreateCycle(document, nodeId, newParentId) {
+  if (nodeId === newParentId) return true;
+  const chain = [document.nodes[newParentId], ...getAncestors(document, newParentId)].filter(Boolean);
+  if (chain.some((a) => a.id === nodeId)) return true;
+  const drawn = componentsDrawnBy(document, nodeId);
+  if (!drawn.size) return false;
+  const enclosing = new Set(chain.filter((a) => a.type === "COMPONENT" || a.type === "COMPONENT_SET").map((a) => a.id));
+  for (const c of drawn) if (enclosing.has(c)) return true;
+  for (const c of drawn) {
+    const comp = document.nodes[c];
+    if (!comp) continue;
+    for (const a of [comp, ...getAncestors(document, c)]) if (enclosing.has(a.id)) return true;
+  }
+  return false;
+}
+function wrapInComponent(document, ids, fallbackParentId, name = "Component") {
+  const nodes = ids.map((id) => resolveVirtualNode(document.nodes, id)).filter(Boolean);
+  if (!nodes.length) return null;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const n of nodes) {
+    const b = uprightBounds(getWorldTransform(document, n.id), n.width, n.height);
+    minX = Math.min(minX, b.minX);
+    minY = Math.min(minY, b.minY);
+    maxX = Math.max(maxX, b.maxX);
+    maxY = Math.max(maxY, b.maxY);
+  }
+  const top = nodes.filter((n) => !n.parentId || !ids.includes(n.parentId));
+  const parentId = (top[0] || nodes[0]).parentId ?? fallbackParentId;
+  const parentNode = document.nodes[parentId];
+  let x = minX, y = minY;
+  if (parentNode && parentNode.type !== "PAGE") {
+    const pw = getWorldTransform(document, parentId);
+    x = minX - (pw.cx - parentNode.width / 2);
+    y = minY - (pw.cy - parentNode.height / 2);
+  }
+  const component = createComponent({ x, y, width: maxX - minX, height: maxY - minY, name, fills: [], componentPropertyDefinitions: {} });
+  let doc = addNode(document, component, parentId);
+  for (const id of ids) {
+    if (!doc.nodes[id]) continue;
+    const placed = placementUnder(doc, id, component.id);
+    if (placed) doc = updateNode(doc, id, placed);
+    doc = reparentNode(doc, id, component.id);
+  }
+  return { document: doc, componentId: component.id };
+}
+function reparentNode(document, nodeId, newParentId, index) {
+  const node = document.nodes[nodeId];
+  if (!node) return document;
+  const newParent = document.nodes[newParentId];
+  if (!newParent) return document;
+  if (wouldCreateCycle(document, nodeId, newParentId)) return document;
+  const newNodes = { ...document.nodes };
+  const updatedOldParentChildIds = node.parentId && newNodes[node.parentId] ? newNodes[node.parentId].childIds.filter((id) => id !== nodeId) : [];
+  if (node.parentId && newNodes[node.parentId]) {
+    newNodes[node.parentId] = {
+      ...newNodes[node.parentId],
+      childIds: updatedOldParentChildIds
+    };
+  }
+  const targetParentChildIds = node.parentId === newParentId ? updatedOldParentChildIds : [...newParent.childIds];
+  if (index !== void 0) {
+    targetParentChildIds.splice(index, 0, nodeId);
+  } else {
+    targetParentChildIds.push(nodeId);
+  }
+  newNodes[newParentId] = {
+    ...newNodes[newParentId],
+    childIds: targetParentChildIds
+  };
+  newNodes[nodeId] = {
+    ...node,
+    parentId: newParentId
+  };
+  return {
+    ...document,
+    nodes: newNodes
+  };
+}
+function duplicateNode(document, nodeId, offset = { x: 10, y: 10 }) {
+  const node = document.nodes[nodeId];
+  if (!node || !node.parentId) {
+    return { document, newNodeId: "" };
+  }
+  function cloneNode(n) {
+    const newNode2 = {
+      ...n,
+      id: v4_default(),
+      name: `${n.name} Copy`,
+      x: n.x + offset.x,
+      y: n.y + offset.y,
+      childIds: []
+    };
+    const anyNode = newNode2;
+    if (Array.isArray(anyNode.cells)) anyNode.cells = anyNode.cells.map((row) => row.map((c) => ({ ...c })));
+    if (Array.isArray(anyNode.colWidths)) anyNode.colWidths = [...anyNode.colWidths];
+    if (Array.isArray(anyNode.rowHeights)) anyNode.rowHeights = [...anyNode.rowHeights];
+    return newNode2;
+  }
+  const newNode = cloneNode(node);
+  let doc = addNode(document, newNode, node.parentId);
+  function cloneChildren(originalId, newParentId) {
+    const original = document.nodes[originalId];
+    if (!original) return;
+    original.childIds.forEach((childId) => {
+      const child = document.nodes[childId];
+      if (child) {
+        const newChild = cloneNode(child);
+        newChild.x = child.x;
+        newChild.y = child.y;
+        doc = addNode(doc, newChild, newParentId);
+        cloneChildren(childId, newChild.id);
+      }
+    });
+  }
+  cloneChildren(nodeId, newNode.id);
+  return { document: doc, newNodeId: newNode.id };
+}
+function getNodeBounds(document, nodeId) {
+  const node = document.nodes[nodeId];
+  if (!node) return null;
+  if (node.childIds.length === 0) {
+    return {
+      x: node.x,
+      y: node.y,
+      width: node.width,
+      height: node.height
+    };
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  function updateBounds(n) {
+    minX = Math.min(minX, n.x);
+    minY = Math.min(minY, n.y);
+    maxX = Math.max(maxX, n.x + n.width);
+    maxY = Math.max(maxY, n.y + n.height);
+  }
+  if (node.type !== "PAGE" && node.type !== "GROUP") {
+    updateBounds(node);
+  }
+  const descendants = getDescendants(document, nodeId);
+  descendants.forEach(updateBounds);
+  if (minX === Infinity) return null;
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function getWorldRenderBounds(document, nodeId) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  function bleedFor(node) {
+    const scene = node;
+    let bleed = 0;
+    let maxStrokeW = 0;
+    for (const s of scene.strokes ?? []) {
+      const w = Array.isArray(s.width) ? Math.max(...s.width) : s.width;
+      maxStrokeW = Math.max(maxStrokeW, w || 0);
+      if (s.alignment === "OUTSIDE") bleed = Math.max(bleed, w);
+      else if (s.alignment === "CENTER") bleed = Math.max(bleed, w / 2);
+    }
+    if (node.type === "LINE" || node.type === "ARROW") {
+      if (node.type === "ARROW" && maxStrokeW === 0) maxStrokeW = 2;
+      bleed = Math.max(bleed, maxStrokeW / 2);
+      if (scene.startArrowhead && scene.startArrowhead !== "NONE" || scene.endArrowhead && scene.endArrowhead !== "NONE") {
+        bleed = Math.max(bleed, Math.max(8, maxStrokeW * 4));
+      }
+    }
+    for (const sh of shadowsOf(scene, document.styles)) {
+      if (sh.type !== "DROP_SHADOW") continue;
+      const reach = Math.max(Math.abs(sh.offset.x), Math.abs(sh.offset.y)) + sh.blur + sh.spread;
+      bleed = Math.max(bleed, reach);
+    }
+    for (const bl of blursOf(scene, document.styles)) {
+      if (bl.type === "LAYER") bleed = Math.max(bleed, bl.radius);
+    }
+    return bleed;
+  }
+  const world = cachedResolver(document.nodes);
+  function visit(id) {
+    const raw = document.nodes[id];
+    if (!raw || !raw.visible) return;
+    const node = resolveNodeVariables(raw, document.variables, document.variableCollections, document.activeVariableModes);
+    const m = world.matrixOf(id);
+    const b = aabbOf(m, node.width, node.height, bleedFor(node) * lengthScale(m));
+    minX = Math.min(minX, b.minX);
+    minY = Math.min(minY, b.minY);
+    maxX = Math.max(maxX, b.maxX);
+    maxY = Math.max(maxY, b.maxY);
+    const clips = "clipsContent" in node && node.clipsContent;
+    if (clips || node.type === "BOOLEAN") return;
+    const scene = scene3dOf(node);
+    if (scene) {
+      const frame = sceneFrame(scene, node.width, node.height);
+      const toWorld = mul4(mul4(fromAffine(m), frame.projection), frame.view);
+      for (const card of sceneLayers(document.nodes, id)) {
+        const pad = bleedFor(card.node);
+        for (const [x, y] of projectRect(mul4(toWorld, card.model), -pad, -pad, card.node.width + pad, card.node.height + pad)) {
+          minX = Math.min(minX, x);
+          minY = Math.min(minY, y);
+          maxX = Math.max(maxX, x);
+          maxY = Math.max(maxY, y);
+        }
+      }
+      return;
+    }
+    node.childIds.forEach(visit);
+  }
+  visit(nodeId);
+  if (minX === Infinity) return null;
+  return { minX, minY, maxX, maxY };
+}
+function gatherLineObstacles(document, line, startAbs, endAbs) {
+  const excluded = /* @__PURE__ */ new Set([line.id]);
+  for (const att of [line.connectorStart, line.connectorEnd]) {
+    if (att && att.nodeId && document.nodes[att.nodeId]) {
+      excluded.add(att.nodeId);
+      for (const a of getAncestors(document, att.nodeId)) excluded.add(a.id);
+      for (const d of getDescendants(document, att.nodeId)) excluded.add(d.id);
+    }
+  }
+  const margin = 160;
+  const rMinX = Math.min(startAbs.x, endAbs.x) - margin;
+  const rMaxX = Math.max(startAbs.x, endAbs.x) + margin;
+  const rMinY = Math.min(startAbs.y, endAbs.y) - margin;
+  const rMaxY = Math.max(startAbs.y, endAbs.y) + margin;
+  const rects = [];
+  for (const n of Object.values(document.nodes)) {
+    if (excluded.has(n.id) || n.visible === false || !OBSTACLE_TYPES.has(n.type)) continue;
+    const { minX: ax, minY: ay, maxX: bx, maxY: by } = aabbOf(getWorldMatrix(document, n.id), n.width, n.height);
+    if (bx < rMinX || ax > rMaxX || by < rMinY || ay > rMaxY) continue;
+    rects.push({ x: ax, y: ay, w: bx - ax, h: by - ay });
+    if (rects.length >= 40) break;
+  }
+  return rects;
+}
+function connectorIdsOf(nodes) {
+  let ids = connectorIdCache.get(nodes);
+  if (!ids) {
+    ids = [];
+    for (const id in nodes) {
+      const t = nodes[id].type;
+      if (t === "LINE" || t === "ARROW") ids.push(id);
+    }
+    connectorIdCache.set(nodes, ids);
+  }
+  return ids;
+}
+function carryConnectorIds(from, to) {
+  if (from === to) return;
+  const ids = connectorIdCache.get(from);
+  if (ids && !connectorIdCache.has(to)) connectorIdCache.set(to, ids);
+}
+function updateConnectors(document, movedNodeIds) {
+  const movedSet = new Set(movedNodeIds);
+  const stack = [...movedNodeIds];
+  while (stack.length) {
+    const n = document.nodes[stack.pop()];
+    if (n && Array.isArray(n.childIds)) {
+      for (const cid of n.childIds) if (!movedSet.has(cid)) {
+        movedSet.add(cid);
+        stack.push(cid);
+      }
+    }
+  }
+  const ids = connectorIdsOf(document.nodes);
+  if (ids.length === 0) return document;
+  const connectors = [];
+  for (const id of ids) {
+    const node = document.nodes[id];
+    if (node) connectors.push(node);
+  }
+  const affectedLineIds = /* @__PURE__ */ new Set();
+  for (const node of connectors) {
+    {
+      const line = node;
+      if (movedSet.has(line.id) || line.connectorStart && movedSet.has(line.connectorStart.nodeId) || line.connectorEnd && movedSet.has(line.connectorEnd.nodeId)) {
+        affectedLineIds.add(line.id);
+      }
+    }
+  }
+  const movedBoxes = [];
+  for (const id of movedSet) {
+    const n = document.nodes[id];
+    if (!n || n.type === "LINE" || n.type === "ARROW") continue;
+    const b = uprightBounds(getWorldTransform(document, id), n.width, n.height);
+    movedBoxes.push({ x0: b.minX, y0: b.minY, x1: b.maxX, y1: b.maxY });
+  }
+  if (movedBoxes.length) {
+    const M = 48;
+    for (const node of connectors) {
+      if (node.routingMode !== "ORTHOGONAL") continue;
+      if (affectedLineIds.has(node.id)) continue;
+      const rp = node.routingPoints;
+      if (!Array.isArray(rp) || rp.length === 0) continue;
+      let lx0 = Infinity, ly0 = Infinity, lx1 = -Infinity, ly1 = -Infinity;
+      for (const p of rp) {
+        lx0 = Math.min(lx0, p.x);
+        ly0 = Math.min(ly0, p.y);
+        lx1 = Math.max(lx1, p.x);
+        ly1 = Math.max(ly1, p.y);
+      }
+      for (const b of movedBoxes) {
+        if (lx1 >= b.x0 - M && lx0 <= b.x1 + M && ly1 >= b.y0 - M && ly0 <= b.y1 + M) {
+          affectedLineIds.add(node.id);
+          break;
+        }
+      }
+    }
+  }
+  if (affectedLineIds.size === 0) return document;
+  const newDoc = { ...document, nodes: { ...document.nodes } };
+  for (const lineId of affectedLineIds) {
+    const line = newDoc.nodes[lineId];
+    const [shaftA, shaftB] = lineShaftEnds(getWorldTransform(document, line.id), line.width);
+    const routed = (line.routingMode === "ORTHOGONAL" || line.routingMode === "BEZIER") && Array.isArray(line.routingPoints) && line.routingPoints.length >= 2;
+    let absA = routed ? { x: line.routingPoints[0].x, y: line.routingPoints[0].y } : shaftA;
+    let absB = routed ? { x: line.routingPoints[line.routingPoints.length - 1].x, y: line.routingPoints[line.routingPoints.length - 1].y } : shaftB;
+    const getTargetAbs = (attachment) => {
+      if (!attachment) return null;
+      const targetNode = newDoc.nodes[attachment.nodeId];
+      if (!targetNode) return null;
+      const a = getConnectorAnchorLocal(targetNode, attachment.position);
+      const [x, y] = apply(unmirroredMatrix(getWorldTransform(document, targetNode.id), targetNode.width, targetNode.height), a.x, a.y);
+      return { x, y };
+    };
+    const newA = getTargetAbs(line.connectorStart);
+    const newB = getTargetAbs(line.connectorEnd);
+    if (newA) absA = newA;
+    if (newB) absB = newB;
+    if (!newA && !newB) continue;
+    const inverseTransformPoint = (worldPt, parentId) => {
+      const parentNode = newDoc.nodes[parentId];
+      if (!parentNode || parentNode.type === "PAGE") return worldPt;
+      const inv = invert(getWorldMatrix(document, parentId));
+      if (!inv) return worldPt;
+      const [x, y] = apply(inv, worldPt.x, worldPt.y);
+      return { x, y };
+    };
+    let parentA = absA;
+    let parentB = absB;
+    if (line.parentId) {
+      parentA = inverseTransformPoint(absA, line.parentId);
+      parentB = inverseTransformPoint(absB, line.parentId);
+    }
+    const dx = parentB.x - parentA.x;
+    const dy = parentB.y - parentA.y;
+    const newWidth = Math.hypot(dx, dy);
+    const newRotation = Math.atan2(dy, dx) * 180 / Math.PI;
+    const updatedLine = {
+      ...line,
+      width: newWidth,
+      rotation: newRotation,
+      x: (parentA.x + parentB.x) / 2 - newWidth / 2,
+      y: (parentA.y + parentB.y) / 2 - Math.max(line.strokeWeight || 1, 2) / 2,
+      height: Math.max(line.strokeWeight || 1, 2)
+    };
+    if (line.routingMode === "ORTHOGONAL" || line.routingMode === "BEZIER") {
+      const getDir = (attach, defaultDir) => {
+        if (!attach) return defaultDir;
+        return connectorPositionDir(attach.position);
+      };
+      const sDir = getDir(line.connectorStart, "CENTER");
+      const eDir = getDir(line.connectorEnd, "CENTER");
+      const routeOpts = {
+        startPos: absA,
+        endPos: absB,
+        startDir: sDir,
+        endDir: eDir
+      };
+      if (line.routingMode === "ORTHOGONAL") {
+        routeOpts.obstacles = gatherLineObstacles(newDoc, line, absA, absB);
+      }
+      const pts = line.routingMode === "BEZIER" ? calculateBezierPath(routeOpts) : calculateOrthogonalPath(routeOpts);
+      updatedLine.routingPoints = pts;
+      if (pts.length > 0) {
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const p of pts) {
+          minX = Math.min(minX, p.x);
+          minY = Math.min(minY, p.y);
+          maxX = Math.max(maxX, p.x);
+          maxY = Math.max(maxY, p.y);
+        }
+        const originLocal = line.parentId ? inverseTransformPoint({ x: minX, y: minY }, line.parentId) : { x: minX, y: minY };
+        updatedLine.width = Math.max(1, maxX - minX);
+        updatedLine.height = Math.max(1, maxY - minY);
+        updatedLine.x = originLocal.x;
+        updatedLine.y = originLocal.y;
+        updatedLine.rotation = 0;
+      }
+    } else {
+      updatedLine.routingPoints = void 0;
+    }
+    newDoc.nodes[lineId] = updatedLine;
+  }
+  carryConnectorIds(document.nodes, newDoc.nodes);
+  return newDoc;
+}
+var ZERO_TRANSFORM, ROOT, resolverCache, OBSTACLE_TYPES, connectorIdCache;
+var init_scene_graph = __esm({
+  "lib/document/scene-graph.ts"() {
+    init_define_POPCRAFT_COMPONENT_IDS();
+    init_dist_node();
+    init_effects();
+    init_variables();
+    init_instances();
+    init_instance_layout();
+    init_cells();
+    init_palettes();
+    init_transform();
+    init_types();
+    init_scene3d();
+    init_transform3d();
+    init_routing();
+    init_shape_outline();
+    ZERO_TRANSFORM = { cx: 0, cy: 0, rotationRad: 0, flipX: false, flipY: false, scaleX: 1, scaleY: 1, matrix: IDENTITY };
+    ROOT = { m: IDENTITY, flipX: false, flipY: false, angle: 0, sense: 1, conformal: true };
+    resolverCache = /* @__PURE__ */ new WeakMap();
+    setVirtualResolver(resolveVirtualNode);
+    OBSTACLE_TYPES = /* @__PURE__ */ new Set([
+      "FRAME",
+      "RECTANGLE",
+      "ELLIPSE",
+      "POLYGON",
+      "STAR",
+      "TEXT",
+      "VECTOR",
+      "BOOLEAN",
+      "TABLE",
+      "COMPONENT",
+      "COMPONENT_SET",
+      "INSTANCE",
+      "STICKY",
+      "IMAGE"
+    ]);
+    connectorIdCache = /* @__PURE__ */ new WeakMap();
+    setSceneApi({ resolve: resolveVirtualNode, childId: virtualChildId, rootOf: virtualRootOf });
+  }
+});
+
+// lib/document/print-pages.ts
+var print_pages_exports = {};
+__export(print_pages_exports, {
+  addHeaderFooterToMaster: () => addHeaderFooterToMaster,
+  assignMaster: () => assignMaster,
+  createMasterPage: () => createMasterPage,
+  createPrintPage: () => createPrintPage,
+  currentPrintPage: () => currentPrintPage,
+  documentFromPreset: () => documentFromPreset,
+  effectiveMasterId: () => effectiveMasterId,
+  foldGuides: () => foldGuides,
+  foldGuidesAt: () => foldGuidesAt,
+  foldsOn: () => foldsOn,
+  isFixedPageKind: () => isFixedPageKind,
+  isMasterPage: () => isMasterPage,
+  isPrintPage: () => isPrintPage,
+  jobPageSize: () => jobPageSize,
+  listMasterPages: () => listMasterPages,
+  listPrintPages: () => listPrintPages,
+  pagePosition: () => pagePosition,
+  placePrintPages: () => placePrintPages,
+  printPageOf: () => printPageOf,
+  reorderPrintPages: () => reorderPrintPages,
+  settingsFromPreset: () => settingsFromPreset
+});
+function listPrintPages(doc, pageId) {
+  const page = doc.nodes[pageId];
+  if (!page) return [];
+  return ordered(page.childIds.map((id) => doc.nodes[id]).filter(isPrintPage));
+}
+function listMasterPages(doc, pageId) {
+  const page = doc.nodes[pageId];
+  if (!page) return [];
+  return ordered(page.childIds.map((id) => doc.nodes[id]).filter(isMasterPage));
+}
+function printPageOf(nodes, nodeId) {
+  let cur = nodes[nodeId.includes("::") ? nodeId.split("::")[0] : nodeId];
+  while (cur && cur.type !== "PAGE") {
+    if (cur.type === "FRAME" && cur.print?.isPrintPage) return cur;
+    cur = cur.parentId ? nodes[cur.parentId] : void 0;
+  }
+  return null;
+}
+function currentPrintPage(doc, pageId, o = {}) {
+  const pages = listPrintPages(doc, pageId);
+  if (!pages.length) return null;
+  for (const id of o.selection ?? []) {
+    const owner = printPageOf(doc.nodes, id);
+    if (owner && pages.some((p) => p.id === owner.id)) return owner;
+  }
+  const c = o.centre;
+  if (c) {
+    const inside = pages.find((p) => c.x >= p.x && c.x <= p.x + p.width && c.y >= p.y && c.y <= p.y + p.height);
+    if (inside) return inside;
+    let best = pages[0], bestD = Infinity;
+    for (const p of pages) {
+      const dx = Math.max(p.x - c.x, 0, c.x - (p.x + p.width));
+      const dy = Math.max(p.y - c.y, 0, c.y - (p.y + p.height));
+      const d = dx * dx + dy * dy;
+      if (d < bestD) {
+        bestD = d;
+        best = p;
+      }
+    }
+    return best;
+  }
+  return pages[0];
+}
+function jobPageSize(doc) {
+  const size = doc.settings?.pageSize;
+  if (!size) return void 0;
+  const preset = presetById(size.presetId);
+  const of = preset?.sheetOf ? presetById(preset.sheetOf.presetId) : void 0;
+  if (of) {
+    const px = presetPx(of);
+    return { width: px.width, height: px.height };
+  }
+  return { width: size.width, height: size.height };
+}
+function settingsFromPreset(preset) {
+  const px = presetPx(preset);
+  const s = {
+    kind: kindForCategory(preset.category),
+    pageSize: { width: px.width, height: px.height, presetId: preset.id }
+  };
+  if (preset.unit !== "px") s.units = preset.unit;
+  if (preset.dpi) s.dpi = preset.dpi;
+  if (px.bleed) s.bleed = edges(px.bleed);
+  if (px.margin) s.margins = edges(px.margin);
+  return s;
+}
+function pagePosition(index, size, facing) {
+  if (!facing) return { x: index * (size.width + gutter(size.width)), y: 0 };
+  const spread = Math.ceil(index / 2);
+  const right = index % 2 === 0;
+  return { x: right ? size.width : 0, y: spread * (size.height + gutter(size.width)) };
+}
+function placePrintPages(doc, pageId) {
+  const patches = {};
+  const facing = doc.settings?.facingPages;
+  const place2 = (frames, at) => frames.forEach((f, i) => {
+    const p = at(i, f);
+    if (f.x !== p.x || f.y !== p.y) patches[f.id] = { ...patches[f.id] ?? {}, ...p };
+  });
+  place2(listPrintPages(doc, pageId), (i, f) => pagePosition(i, f, facing));
+  place2(listMasterPages(doc, pageId), (i, f) => masterPosition(i, f));
+  return patches;
+}
+function foldGuides(preset, width, height) {
+  if (!preset.folds) return [];
+  const span = preset.folds.axis === "X" ? width : height;
+  return preset.folds.at.map((t) => ({ id: v4_default(), axis: preset.folds.axis, pos: Math.round(t * span), kind: "FOLD" }));
+}
+function foldGuidesAt(preset, frame) {
+  if (!preset?.folds) return [];
+  return foldGuides(preset, frame.width, frame.height).map((g) => ({ ...g, pos: g.pos + (g.axis === "X" ? frame.x : frame.y) }));
+}
+function createPrintPage(doc, pageId, opts = {}) {
+  const existing = listPrintPages(doc, pageId);
+  const preset = opts.preset ?? presetById(doc.settings?.pageSize?.presetId);
+  const size = preset ? presetPx(preset) : { width: doc.settings?.pageSize?.width ?? 816, height: doc.settings?.pageSize?.height ?? 1056 };
+  const index = existing.length;
+  const last = existing[existing.length - 1];
+  const frame = createFrame({
+    name: opts.name ?? `Page ${index + 1}`,
+    ...pagePosition(index, size, doc.settings?.facingPages),
+    width: size.width,
+    height: size.height,
+    fills: [{ type: "SOLID", color: createColor(1, 1, 1), opacity: 1, visible: true }],
+    clipsContent: true,
+    print: { isPrintPage: true, index, ...last?.print?.masterId ? { masterId: last.print.masterId } : {} }
+  });
+  frame.parentId = pageId;
+  return frame;
+}
+function createMasterPage(doc, pageId, opts = {}) {
+  const masters = listMasterPages(doc, pageId);
+  const preset = presetById(doc.settings?.pageSize?.presetId);
+  const size = preset ? presetPx(preset) : { width: doc.settings?.pageSize?.width ?? 816, height: doc.settings?.pageSize?.height ?? 1056 };
+  const index = masters.length;
+  const frame = createFrame({
+    name: opts.name ?? `${MASTER_NAMES[index % MASTER_NAMES.length]}-Master`,
+    ...masterPosition(index, size),
+    width: size.width,
+    height: size.height,
+    fills: [{ type: "SOLID", color: createColor(1, 1, 1), opacity: 1, visible: true }],
+    clipsContent: true,
+    print: { isPrintPage: true, isMaster: true, index }
+  });
+  frame.parentId = pageId;
+  return frame;
+}
+function assignMaster(doc, pageIds, masterId) {
+  const patches = {};
+  if (masterId && !isMasterPage(doc.nodes[masterId])) return patches;
+  for (const id of pageIds) {
+    const f = doc.nodes[id];
+    if (!isPrintPage(f) || (f.print.masterId ?? void 0) === masterId) continue;
+    const { masterId: _drop, ...rest } = f.print;
+    patches[id] = { print: masterId ? { ...rest, masterId } : rest };
+  }
+  return patches;
+}
+function effectiveMasterId(doc, frame) {
+  const print = frame.print;
+  if (!print || print.isMaster || !frame.parentId) return void 0;
+  const pages = listPrintPages(doc, frame.parentId);
+  const index = pages.findIndex((p) => p.id === frame.id);
+  if (index < 0) return print.masterId;
+  if (index === 0 && print.masterIdFirst && isMasterPage(doc.nodes[print.masterIdFirst])) return print.masterIdFirst;
+  if (doc.settings?.facingPages && index >= 0) {
+    const isRight = (index + 1) % 2 === 1;
+    if (!isRight && print.masterIdLeft && isMasterPage(doc.nodes[print.masterIdLeft])) return print.masterIdLeft;
+    if (isRight && print.masterIdRight && isMasterPage(doc.nodes[print.masterIdRight])) return print.masterIdRight;
+  }
+  return print.masterId;
+}
+function addHeaderFooterToMaster(doc, masterId, kind) {
+  const master = doc.nodes[masterId];
+  if (!isMasterPage(master)) return null;
+  const margin = 36;
+  const height = 24;
+  const y = kind === "header" ? margin : Math.max(margin, master.height - margin - height);
+  const text = createText({
+    name: kind === "header" ? "Header" : "Footer",
+    x: margin,
+    y,
+    width: Math.max(40, master.width - margin * 2),
+    height,
+    characters: kind === "footer" ? "{{page}}" : "Header",
+    fontSize: 10,
+    textAlign: kind === "footer" ? "CENTER" : "LEFT"
+  });
+  const next = addNode(doc, text, masterId);
+  const band = kind === "header" ? { headerHeight: margin + height + 8 } : { footerHeight: margin + height + 8 };
+  const updated = {
+    ...next,
+    nodes: {
+      ...next.nodes,
+      [masterId]: {
+        ...next.nodes[masterId],
+        print: { ...next.nodes[masterId].print, ...band }
+      }
+    }
+  };
+  return { doc: updated, textId: text.id };
+}
+function reorderPrintPages(doc, pageId, orderedIds) {
+  const current = listPrintPages(doc, pageId);
+  const rest = current.map((f) => f.id).filter((id) => !orderedIds.includes(id));
+  const patches = {};
+  [...orderedIds, ...rest].forEach((id, index) => {
+    const f = doc.nodes[id];
+    if (isPrintPage(f) && f.print.index !== index) patches[id] = { print: { ...f.print, index } };
+  });
+  const renumbered = { ...doc, nodes: { ...doc.nodes } };
+  for (const id in patches) renumbered.nodes[id] = { ...doc.nodes[id], ...patches[id] };
+  const placed = placePrintPages(renumbered, pageId);
+  for (const id in placed) patches[id] = { ...patches[id] ?? {}, ...placed[id] };
+  return patches;
+}
+function documentFromPreset(name, preset) {
+  const doc = createDocument(name, settingsFromPreset(preset));
+  const pageId = doc.pages[0];
+  const first = createPrintPage(doc, pageId, { preset, name: isFixedPageKind(doc.settings?.kind) ? "Page 1" : preset.name });
+  if (!isFixedPageKind(doc.settings?.kind)) delete first.print;
+  const page = doc.nodes[pageId];
+  doc.nodes[first.id] = first;
+  doc.nodes[pageId] = { ...page, childIds: [...page.childIds, first.id] };
+  const guides = foldGuides(preset, first.width, first.height).map((g) => ({ ...g, pos: g.pos + (g.axis === "X" ? first.x : first.y) }));
+  if (guides.length) doc.nodes[pageId].guides = guides;
+  return doc;
+}
+var isFixedPageKind, isPrintPage, isMasterPage, ordered, edges, gutter, masterPosition, foldsOn, MASTER_NAMES;
+var init_print_pages = __esm({
+  "lib/document/print-pages.ts"() {
+    init_define_POPCRAFT_COMPONENT_IDS();
+    init_dist_node();
+    init_scene_graph();
+    init_types();
+    init_page_presets();
+    isFixedPageKind = (kind) => kind === "PRINT" || kind === "SOCIAL" || kind === "PRESENTATION" || kind === "EMAIL";
+    isPrintPage = (n) => !!n && n.type === "FRAME" && !!n.print?.isPrintPage && !n.print?.isMaster;
+    isMasterPage = (n) => !!n && n.type === "FRAME" && !!n.print?.isMaster;
+    ordered = (frames) => frames.map((f, i) => ({ f, i })).sort((a, b) => (a.f.print.index ?? Infinity) - (b.f.print.index ?? Infinity) || a.f.y - b.f.y || a.f.x - b.f.x || a.i - b.i).map((x) => x.f);
+    edges = (v) => ({ top: v, right: v, bottom: v, left: v });
+    gutter = (w) => Math.round(w * 0.15);
+    masterPosition = (index, size) => ({
+      x: index * (size.width + gutter(size.width)),
+      y: -(size.height + 2 * gutter(size.width))
+    });
+    foldsOn = (guides, frame) => (guides ?? []).filter((g) => g.kind === "FOLD" && (g.axis === "X" ? g.pos >= frame.x && g.pos <= frame.x + frame.width : g.pos >= frame.y && g.pos <= frame.y + frame.height));
+    MASTER_NAMES = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  }
+});
+
+export {
+  calculateOrthogonalPath,
+  trimPolyline,
+  calculateBezierPath,
+  init_routing,
+  flattenPaths,
+  init_flatten,
+  glyphLinear,
+  init_glyph_linear,
+  glyphOutline,
+  glyphInstancesToRings,
+  init_text_rings,
+  shapeToRings,
+  init_shape_outline,
+  isFixedPageKind,
+  isPrintPage,
+  isMasterPage,
+  listPrintPages,
+  listMasterPages,
+  printPageOf,
+  currentPrintPage,
+  jobPageSize,
+  settingsFromPreset,
+  pagePosition,
+  placePrintPages,
+  foldGuides,
+  foldGuidesAt,
+  foldsOn,
+  createPrintPage,
+  createMasterPage,
+  assignMaster,
+  effectiveMasterId,
+  addHeaderFooterToMaster,
+  reorderPrintPages,
+  documentFromPreset,
+  init_print_pages,
+  virtualRootOf,
+  virtualChildId,
+  chainOverrides,
+  resolveVirtualNode,
+  createDocument,
+  createPage,
+  createRectangle,
+  createEllipse,
+  createSticky,
+  createLine,
+  createArrow,
+  createPolygon,
+  createStar,
+  createSection,
+  createSlice,
+  createFrame,
+  createText,
+  createGroup,
+  createVector,
+  createBoolean,
+  createPixelGrid,
+  createImage,
+  createRaster,
+  createComponent,
+  createComponentSet,
+  createInstance,
+  createInstanceOf,
+  addNode,
+  removeNode,
+  updateNode,
+  getDescendants,
+  getAncestors,
+  applyConstraints,
+  getRenderableNodes,
+  moveNodeInZOrder,
+  uprightBounds,
+  unmirroredMatrix,
+  lineShaftEnds,
+  detachedTransform,
+  createWorldMatrixResolver,
+  createWorldTransformResolver,
+  getWorldTransform,
+  getWorldMatrix,
+  placementUnder,
+  componentsDrawnBy,
+  wouldCreateCycle,
+  wrapInComponent,
+  reparentNode,
+  duplicateNode,
+  getNodeBounds,
+  getWorldRenderBounds,
+  gatherLineObstacles,
+  connectorIdsOf,
+  carryConnectorIds,
+  updateConnectors,
+  init_scene_graph
+};