@popcraft/kit 0.26.0 → 0.27.0

package/dist/chunks/chunk-GDUMY3VG.js

@@ -0,0 +1,689 @@
+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 {
+  videoNodeIds
+} from "./chunk-W5NE37NW.js";
+import {
+  motionEnd,
+  motionNodes,
+  nodeIndex,
+  runsOn,
+  sampleNode
+} from "./chunk-VIDOT3BT.js";
+import {
+  init_scene_graph,
+  resolveVirtualNode
+} from "./chunk-BDU2OUVJ.js";
+import {
+  init_instance_layout,
+  joinVirtual
+} from "./chunk-4PE7EX3N.js";
+import {
+  componentDefinitions,
+  effectiveComponentProperties,
+  init_instances,
+  propertyDefaults
+} from "./chunk-NIHPNDDJ.js";
+import {
+  asPath,
+  bindPath,
+  init_properties
+} from "./chunk-TZHWIVE5.js";
+import {
+  DEFAULT_PLAYBACK,
+  PLAYBACK_FIELDS,
+  init_time,
+  instanceTime,
+  isPlaybackValue,
+  layerTimer,
+  localTime,
+  playbackEnd,
+  playbackLive,
+  playbackRange,
+  timeShift
+} from "./chunk-AYZ32MGJ.js";
+import {
+  init_values,
+  lerpColor,
+  lerpNumber
+} from "./chunk-CAGDE6PT.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-6VMOKHMF.js";
+
+// lib/motion/instances.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_instances();
+init_scene_graph();
+init_instance_layout();
+
+// lib/editor/smart-animate.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_values();
+var SMART_ANIMATE_PROPS = [
+  { key: "x", rest: 0 },
+  { key: "y", rest: 0 },
+  { key: "width", rest: 0 },
+  { key: "height", rest: 0 },
+  { key: "rotation", rest: 0 },
+  { key: "opacity", rest: 1 },
+  // Scale and translation are transforms: children, text and strokes scale with them, so a world scaled up about a
+  // planet on the next screen is a camera flying into it.
+  { key: "scaleX", rest: 1 },
+  { key: "scaleY", rest: 1 },
+  { key: "translateX", rest: 0 },
+  { key: "translateY", rest: 0 },
+  // A 3D layer's depth and tilts (lib/document/scene3d.ts), so a part lifts out of a 3D scene as it glides.
+  { key: "z", rest: 0 },
+  { key: "rotateX", rest: 0 },
+  { key: "rotateY", rest: 0 }
+];
+var CONTAINERS = /* @__PURE__ */ new Set(["FRAME", "GROUP", "COMPONENT", "COMPONENT_SET", "SECTION"]);
+function lerpPaint(pa, pb, t) {
+  if (!pa || pa.type !== pb.type) return pb;
+  const opacity = lerpNumber(pa.opacity ?? 1, pb.opacity ?? 1, t);
+  if (pa.type === "SOLID" && pa.color && pb.color) return { ...pb, color: lerpColor(pa.color, pb.color, t), opacity };
+  const sa = pa.gradientStops, sb = pb.gradientStops;
+  if (sa && sb && sa.length === sb.length) {
+    const ha = pa.gradientHandlePositions, hb = pb.gradientHandlePositions;
+    return {
+      ...pb,
+      opacity,
+      gradientStops: sb.map((s, i) => ({ ...s, position: lerpNumber(sa[i].position, s.position, t), color: lerpColor(sa[i].color, s.color, t) })),
+      ...ha && hb && ha.length === hb.length ? { gradientHandlePositions: hb.map((h, i) => ({ x: lerpNumber(ha[i].x, h.x, t), y: lerpNumber(ha[i].y, h.y, t) })) } : {}
+    };
+  }
+  return { ...pb, opacity };
+}
+function lerpFills(a, b, t) {
+  if (!a?.length || !b?.length) return b;
+  return b.map((pb, i) => lerpPaint(a[i], pb, t));
+}
+function interpolate(a, b, t) {
+  const sa = a, sb = b;
+  const out = { ...b };
+  for (const p of SMART_ANIMATE_PROPS) {
+    const va = sa[p.key], vb = sb[p.key];
+    if (typeof va !== "number" && typeof vb !== "number") continue;
+    out[p.key] = lerpNumber(typeof va === "number" ? va : p.rest, typeof vb === "number" ? vb : p.rest, t);
+  }
+  if (typeof sa.cornerRadius === "number" && typeof sb.cornerRadius === "number") out.cornerRadius = lerpNumber(sa.cornerRadius, sb.cornerRadius, t);
+  const fills = lerpFills(sa.fills, sb.fills, t);
+  if (fills) out.fills = fills;
+  return out;
+}
+function staggeredProgress(s, i, n) {
+  const delay = Math.max(0, Math.min(s.delay, n > 1 ? s.duration / n : s.delay));
+  const span = s.duration - delay * Math.max(0, n - 1);
+  if (span <= 0) return s.ease(s.raw >= 1 ? 1 : 0);
+  return s.ease(Math.min(1, Math.max(0, (s.raw * s.duration - i * delay) / span)));
+}
+function sharedUnder(nodes, rootId) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = (id) => {
+    for (const c of nodes[id]?.childIds ?? []) {
+      const n = nodes[c];
+      if (!n) continue;
+      if (n.sharedElement) out.set(n.sharedElement, [...out.get(n.sharedElement) ?? [], c]);
+      walk(c);
+    }
+  };
+  walk(rootId);
+  return out;
+}
+function related(nodes, a, b) {
+  const real = b.includes("::") ? b.slice(0, b.indexOf("::")) : b;
+  const up = (from, to) => {
+    for (let n = from; n; n = nodes[n]?.parentId ?? null) if (n === to) return true;
+    return false;
+  };
+  return up(real, a) || up(a, real);
+}
+var pick = (nodes, ids, via) => via && ids.find((id) => related(nodes, id, via)) || ids[0];
+function offsetIn(nodes, id, rootId) {
+  let x = 0, y = 0;
+  for (let n = nodes[id]; n && n.id !== rootId; n = n.parentId ? nodes[n.parentId] : void 0) {
+    x += n.x + (n.translateX ?? 0);
+    y += n.y + (n.translateY ?? 0);
+  }
+  return { x, y };
+}
+function smartAnimateNodes(nodes, sourceId, destId, t, opts = {}) {
+  const out = {};
+  const src = nodes[sourceId], dst = nodes[destId];
+  if (!src || !dst) return out;
+  const fromShared = sharedUnder(nodes, sourceId), toShared = sharedUnder(nodes, destId);
+  const pairs = [];
+  for (const [key, ds] of toShared) {
+    const ss = fromShared.get(key);
+    if (ss) pairs.push([pick(nodes, ss, opts.via?.source), pick(nodes, ds, opts.via?.destination)]);
+  }
+  const pairedSrc = new Set(pairs.map((p) => p[0])), pairedDst = new Map(pairs.map((p) => [p[1], p[0]]));
+  const progressOf = /* @__PURE__ */ new Map();
+  const visit = (srcParent, dstParent, at) => {
+    const srcKids = (srcParent?.childIds ?? []).map((id) => nodes[id]).filter((k) => k && !pairedSrc.has(k.id));
+    const byName = /* @__PURE__ */ new Map();
+    for (const k of srcKids) {
+      const arr = byName.get(k.name) ?? [];
+      arr.push(k);
+      byName.set(k.name, arr);
+    }
+    const used = /* @__PURE__ */ new Set();
+    const extra = [];
+    const kids = dstParent.childIds;
+    kids.forEach((id, i) => {
+      const d = nodes[id];
+      if (!d) return;
+      const k = at(i, kids.length);
+      progressOf.set(id, k);
+      if (pairedDst.has(id)) return;
+      const s = byName.get(d.name)?.find((c) => !used.has(c.id) && c.type === d.type);
+      if (s) {
+        used.add(s.id);
+        out[id] = interpolate(s, d, k);
+        if (d.childIds.length || s.childIds.length) visit(s, d, () => k);
+      } else {
+        out[id] = { ...d, opacity: (d.opacity ?? 1) * Math.max(0, Math.min(1, k)) };
+      }
+    });
+    if (opts.ghosts !== false) for (const s of srcKids) {
+      if (used.has(s.id)) continue;
+      const ghostId = `__sa_${s.id}`;
+      const fade = Math.max(0, Math.min(1, at(0, 1)));
+      out[ghostId] = { ...s, id: ghostId, parentId: dstParent.id, childIds: pairedSrc.size ? s.childIds.filter((c) => !pairedSrc.has(c)) : s.childIds, opacity: (s.opacity ?? 1) * (1 - fade) };
+      extra.push(ghostId);
+    }
+    if (extra.length) out[dstParent.id] = { ...out[dstParent.id] ?? dstParent, childIds: [...dstParent.childIds, ...extra] };
+  };
+  const st = opts.stagger;
+  visit(src, dst, st ? (i, n) => staggeredProgress(st, i, n) : () => t);
+  if (pairs.length) {
+    const patched = { ...nodes, ...out };
+    for (const [sId, dId] of pairs) {
+      const s = nodes[sId], d = nodes[dId];
+      if (!s || !d) continue;
+      const k = progressOf.get(dId) ?? progressOfAncestor(nodes, progressOf, dId, destId) ?? t;
+      const from = offsetIn(nodes, sId, sourceId), to = offsetIn(nodes, dId, destId);
+      const parent = d.parentId ? offsetIn(patched, d.parentId, destId) : { x: 0, y: 0 };
+      const moved = interpolate(s, d, k);
+      moved.x = lerpNumber(from.x - (s.translateX ?? 0), to.x - (d.translateX ?? 0), k) - parent.x;
+      moved.y = lerpNumber(from.y - (s.translateY ?? 0), to.y - (d.translateY ?? 0), k) - parent.y;
+      out[dId] = moved;
+      patched[dId] = moved;
+      if (CONTAINERS.has(d.type) && (d.childIds.length || s.childIds.length)) visit(s, d, () => k);
+    }
+  }
+  return out;
+}
+function progressOfAncestor(nodes, progress, id, rootId) {
+  for (let n = nodes[id]?.parentId; n && n !== rootId; n = nodes[n]?.parentId ?? null) {
+    const k = progress.get(n);
+    if (k !== void 0) return k;
+  }
+  return void 0;
+}
+
+// lib/motion/instances.ts
+init_properties();
+init_time();
+var NO_RUNTIME = /* @__PURE__ */ new Map();
+var MAX_DEPTH = 16;
+var freshIndex = () => ({ layers: /* @__PURE__ */ new Map(), nested: /* @__PURE__ */ new Map(), motion: /* @__PURE__ */ new Map(), instances: null, implied: /* @__PURE__ */ new Map() });
+var indexOf = nodeIndex(() => freshIndex(), (prev, from, to, changed) => carryIndex(prev, from, to, changed));
+var isComponentLike = (n) => n?.type === "COMPONENT" || n?.type === "COMPONENT_SET";
+function inComponent(nodes, id) {
+  for (let n = nodes[id], depth = 0; n && depth < 256; n = n.parentId ? nodes[n.parentId] : void 0, depth++) if (isComponentLike(n)) return true;
+  return false;
+}
+function carryIndex(prev, from, to, changed) {
+  let instancesHold = true;
+  for (const id of changed) {
+    const a = from[id], b = to[id];
+    if (inComponent(from, id) || inComponent(to, id)) return void 0;
+    if (a?.type === "INSTANCE" || b?.type === "INSTANCE") {
+      if (a?.type !== b?.type || a?.mainComponentId !== b?.mainComponentId) instancesHold = false;
+    }
+  }
+  const ix = freshIndex();
+  for (const [k, v] of prev.layers) if (isComponentLike(to[k])) ix.layers.set(k, v);
+  for (const [k, v] of prev.motion) if (isComponentLike(to[k])) ix.motion.set(k, v);
+  for (const [k, v] of prev.nested) if (isComponentLike(to[k])) ix.nested.set(k, v);
+  for (const [k, v] of prev.implied) if (isComponentLike(to[k])) ix.implied.set(k, v);
+  if (instancesHold) ix.instances = prev.instances;
+  return ix;
+}
+function componentLayers(nodes, componentId) {
+  const ix = indexOf(nodes);
+  let list = ix.layers.get(componentId);
+  if (!list) {
+    list = motionNodes(nodes, componentId);
+    ix.layers.set(componentId, list);
+  }
+  return list;
+}
+function nestedInstances(nodes, rootId) {
+  const ix = indexOf(nodes);
+  let list = ix.nested.get(rootId);
+  if (!list) {
+    const out = [];
+    const walk = (id, depth) => {
+      const n = nodes[id];
+      if (!n || depth > 64) return;
+      for (const c of n.childIds ?? []) {
+        const k = nodes[c];
+        if (!k) continue;
+        if (k.type === "INSTANCE") out.push(c);
+        else walk(c, depth + 1);
+      }
+    };
+    walk(rootId, 0);
+    list = out;
+    ix.nested.set(rootId, list);
+  }
+  return list;
+}
+function isMotionComponent(nodes, componentId, visiting = /* @__PURE__ */ new Set()) {
+  const ix = indexOf(nodes);
+  const hit = ix.motion.get(componentId);
+  if (hit !== void 0) return hit;
+  if (!nodes[componentId] || visiting.has(componentId)) return false;
+  visiting.add(componentId);
+  let moves = componentLayers(nodes, componentId).length > 0;
+  if (!moves) for (const id of nestedInstances(nodes, componentId)) {
+    const main = nodes[id].mainComponentId;
+    if (main && isMotionComponent(nodes, main, visiting)) {
+      moves = true;
+      break;
+    }
+  }
+  visiting.delete(componentId);
+  ix.motion.set(componentId, moves);
+  return moves;
+}
+function isMotionFamily(nodes, componentId) {
+  const c = nodes[componentId];
+  if (!c) return false;
+  const set = c.parentId ? nodes[c.parentId] : void 0;
+  if (set?.type === "COMPONENT_SET") return set.childIds.some((id) => nodes[id]?.type === "COMPONENT" && isMotionComponent(nodes, id));
+  return isMotionComponent(nodes, componentId);
+}
+function hostInstanceOf(nodes, id) {
+  for (let cur = id; cur; ) {
+    const n = cur.includes("::") ? resolveVirtualNode(nodes, cur) : nodes[cur];
+    if (n?.type === "INSTANCE") return cur;
+    if (!cur.includes("::")) return null;
+    cur = cur.slice(0, cur.lastIndexOf("::"));
+  }
+  return null;
+}
+function motionInstanceIds(nodes) {
+  const ix = indexOf(nodes);
+  if (!ix.instances) {
+    const out = [];
+    for (const id in nodes) {
+      const n = nodes[id];
+      if (n.type === "INSTANCE" && n.mainComponentId && isMotionFamily(nodes, n.mainComponentId)) out.push(id);
+    }
+    ix.instances = out;
+  }
+  return ix.instances;
+}
+function playbackOf(nodes, instance, componentId) {
+  const pb = { ...DEFAULT_PLAYBACK };
+  const defs = componentDefinitions(nodes, componentId);
+  for (const name in defs) {
+    const d = defs[name];
+    if (d.type === "MOTION" && d.binds && isPlaybackValue(d.binds, d.defaultValue)) pb[d.binds] = d.defaultValue;
+  }
+  const own = instance.playback;
+  if (own) {
+    for (const f of PLAYBACK_FIELDS) if (own[f] !== void 0 && isPlaybackValue(f, own[f])) pb[f] = own[f];
+  }
+  return { ...pb, range: playbackRange(frameTimeline(nodes, componentId), own?.range) };
+}
+function shownComponent(nodes, instance, run) {
+  const pick2 = run?.component;
+  if (pick2 && nodes[pick2]?.type === "COMPONENT") return pick2;
+  const main = instance.mainComponentId;
+  return main && nodes[main] ? main : void 0;
+}
+var selfStarting = (m) => m.trigger === "load" || m.trigger === "inView";
+var startedAt = (m, layerElapsed, run) => run?.elapsed !== void 0 ? run.elapsed : selfStarting(m) ? layerElapsed : null;
+function instanceNow(nodes, id, run, layerElapsed) {
+  const inst = id.includes("::") ? resolveVirtualNode(nodes, id) : nodes[id];
+  if (!inst || inst.type !== "INSTANCE") return null;
+  const comp = shownComponent(nodes, inst, run);
+  if (!comp) return null;
+  if (run?.scrub !== void 0) return { component: comp, time: run.scrub };
+  const m = playbackOf(nodes, inst, comp);
+  return { component: comp, time: instanceTime(startedAt(m, layerElapsed, run), m) };
+}
+function instanceTrigger(nodes, id, run) {
+  const inst = id.includes("::") ? resolveVirtualNode(nodes, id) : nodes[id];
+  if (!inst || inst.type !== "INSTANCE") return null;
+  const comp = shownComponent(nodes, inst, run);
+  return comp && isMotionComponent(nodes, comp) ? playbackOf(nodes, inst, comp).trigger : null;
+}
+function timelineDuration(nodes, rootId) {
+  return nodes[rootId]?.timeline?.duration ?? Math.max(2e3, Math.ceil(frameMotionEnd(nodes, rootId) / 500) * 500);
+}
+function frameTimeline(nodes, rootId) {
+  const stored = nodes[rootId]?.timeline;
+  if (stored) return stored;
+  const ix = indexOf(nodes);
+  let tl = ix.implied.get(rootId);
+  if (!tl) {
+    tl = { duration: timelineDuration(nodes, rootId) };
+    ix.implied.set(rootId, tl);
+  }
+  return tl;
+}
+function rootInstances(nodes, rootId) {
+  const out = [];
+  for (const id of motionInstanceIds(nodes)) {
+    if (id === rootId || localTime(nodes, id, rootId, 0) === void 0) continue;
+    const inst = nodes[id];
+    const comp = shownComponent(nodes, inst, void 0);
+    if (!comp || !isMotionComponent(nodes, comp)) continue;
+    const m = playbackOf(nodes, inst, comp);
+    if (selfStarting(m)) out.push({ id, m, shift: timeShift(nodes, id, rootId) });
+  }
+  return out;
+}
+function frameMotionEnd(nodes, rootId) {
+  let memo = endMemo.get(nodes);
+  if (!memo) {
+    memo = /* @__PURE__ */ new Map();
+    endMemo.set(nodes, memo);
+  }
+  const hit = memo.get(rootId);
+  if (hit !== void 0) return hit;
+  let end = motionEnd(nodes, rootId);
+  for (const { m, shift } of rootInstances(nodes, rootId)) {
+    const e = playbackEnd(m);
+    if (Number.isFinite(e)) end = Math.max(end, shift + e);
+  }
+  memo.set(rootId, end);
+  return end;
+}
+var endMemo = /* @__PURE__ */ new WeakMap();
+function frameRunsOn(nodes, rootId) {
+  return motionNodes(nodes, rootId).some(runsOn) || rootInstances(nodes, rootId).some(({ m }) => playbackEnd(m) === Infinity);
+}
+function hasFrameMotion(nodes, rootId) {
+  if (motionNodes(nodes, rootId).length) return true;
+  for (const id of videoNodeIds(nodes)) if (id !== rootId && localTime(nodes, id, rootId, 0) !== void 0) return true;
+  for (const id of motionInstanceIds(nodes)) if (id !== rootId && localTime(nodes, id, rootId, 0) !== void 0) return true;
+  return false;
+}
+var HOST_OWNS = /* @__PURE__ */ new Set(["x", "y", "width", "height"]);
+var rootTracksMemo = /* @__PURE__ */ new WeakMap();
+function rootMotion(root) {
+  let m = rootTracksMemo.get(root);
+  if (m === void 0) {
+    const tracks = root.motion?.tracks;
+    const kept = {};
+    let any = false;
+    if (tracks) {
+      for (const p in tracks) if (!HOST_OWNS.has(p)) {
+        kept[p] = tracks[p];
+        any = true;
+      }
+    }
+    m = any ? { tracks: kept } : null;
+    rootTracksMemo.set(root, m);
+  }
+  return m;
+}
+function layerOf(nodes, vid, id, comp) {
+  let byComp = layerMemo.get(nodes);
+  if (!byComp) {
+    byComp = /* @__PURE__ */ new Map();
+    layerMemo.set(nodes, byComp);
+  }
+  let memo = byComp.get(comp);
+  if (!memo) {
+    memo = /* @__PURE__ */ new Map();
+    byComp.set(comp, memo);
+  }
+  const key = joinVirtual(vid, id);
+  let hit = memo.get(key);
+  if (hit === void 0) {
+    const resolved = resolveVirtualNode(nodes, key);
+    const parent = nodes[id]?.parentId;
+    const parentId = parent === comp ? vid : joinVirtual(vid, parent ?? "");
+    hit = !resolved ? null : resolved.parentId === parentId ? resolved : { ...resolved, parentId };
+    memo.set(key, hit);
+  }
+  return hit;
+}
+var layerMemo = /* @__PURE__ */ new WeakMap();
+function valuesFor(nodes, ownerParts, componentId) {
+  const set = effectiveComponentProperties(nodes, [...ownerParts, ""]);
+  return { values: { ...propertyDefaults(componentDefinitions(nodes, componentId)), ...set }, set };
+}
+function clockOf(nodes, inst, elapsed, run) {
+  const comp = shownComponent(nodes, inst, run);
+  if (!comp) return null;
+  if (run?.scrub !== void 0) return { comp, ct: run.scrub, live: !!run.gliding || !!run.from };
+  const m = playbackOf(nodes, inst, comp);
+  const started = startedAt(m, elapsed, run);
+  return { comp, ct: instanceTime(started, m), live: playbackLive(started, m) || !!run?.from };
+}
+function poseInstance(w, vid, inst, elapsed, depth, clock = clockOf(w.nodes, inst, elapsed, w.runtime.get(vid))) {
+  const { nodes } = w;
+  const run = w.runtime.get(vid);
+  if (!clock || depth > MAX_DEPTH || w.expanding.has(clock.comp)) return;
+  const { comp, ct } = clock;
+  if (clock.live) w.live = true;
+  const parts = vid.split("::");
+  const inputs = valuesFor(nodes, parts, comp);
+  w.expanding.add(comp);
+  try {
+    let self = w.out[vid] ?? inst;
+    if (comp !== inst.mainComponentId) self = { ...self, mainComponentId: comp };
+    const rm = nodes[comp] ? rootMotion(nodes[comp]) : null;
+    if (rm) {
+      const own = self.motion;
+      const playing = sampleNode({ ...self, motion: rm }, ct, nodes, { values: inputs.values, set: {} });
+      self = { ...playing, motion: own };
+    }
+    if (self !== inst) w.out[vid] = self;
+    const timeOf = layerTimer(nodes, comp, ct);
+    for (const layer of componentLayers(nodes, comp)) {
+      if (layer.id === comp) continue;
+      const t = timeOf(layer.id);
+      if (t === void 0 || t === false) continue;
+      const cid = joinVirtual(vid, layer.id);
+      const resolved = layerOf(nodes, vid, layer.id, comp);
+      if (!resolved) continue;
+      if (t === null) {
+        if (resolved.visible !== false) w.out[cid] = { ...resolved, visible: false };
+        continue;
+      }
+      const posed = sampleNode(resolved, t, nodes, inputs);
+      if (posed !== resolved) w.out[cid] = posed;
+    }
+    const from = run?.from;
+    if (from && nodes[from.componentId]?.type === "COMPONENT" && from.componentId !== comp) glide(w, vid, self, from.componentId, from.time, comp, from.progress);
+    for (const nid of nestedInstances(nodes, comp)) {
+      const t = localTime(nodes, nid, comp, ct);
+      if (typeof t !== "number") continue;
+      const nvid = joinVirtual(vid, nid);
+      const nested = w.out[nvid] ?? resolveVirtualNode(nodes, nvid);
+      if (nested?.type === "INSTANCE" && nested.visible !== false) poseInstance(w, nvid, nested, t, depth + 1);
+    }
+  } finally {
+    w.expanding.delete(comp);
+  }
+}
+function variantTree(w, vid, componentId, time, into, posed) {
+  const { nodes } = w;
+  const parts = vid.split("::");
+  const inputs = valuesFor(nodes, parts, componentId);
+  const visit = (childIds, depth) => {
+    const ids = [];
+    if (depth > 32) return ids;
+    for (const c of childIds) {
+      const cid = joinVirtual(vid, c);
+      let node = posed?.[cid] ?? layerOf(nodes, vid, c, componentId);
+      if (!node) continue;
+      if (!posed) {
+        const t = localTime(nodes, c, componentId, time);
+        if (typeof t === "number") node = sampleNode(node, t, nodes, inputs);
+      }
+      const kids = node.type === "INSTANCE" ? [] : visit(node.childIds ?? [], depth + 1);
+      into[cid] = { ...node, childIds: kids };
+      ids.push(cid);
+    }
+    return ids;
+  };
+  return visit(nodes[componentId]?.childIds ?? [], 0);
+}
+function glide(w, vid, self, fromId, fromTime, toId, progress) {
+  const tree = {};
+  const FROM = `${vid}\0from`;
+  const fromKids = variantTree(w, vid, fromId, fromTime, tree);
+  const toKids = variantTree(w, vid, toId, 0, tree, w.out);
+  tree[FROM] = { ...self, id: FROM, childIds: fromKids };
+  tree[vid] = { ...self, childIds: toKids };
+  const patches = smartAnimateNodes(tree, FROM, vid, progress, { ghosts: false });
+  for (const id in patches) {
+    if (id === vid) continue;
+    const real = w.out[id] ?? layerOf(w.nodes, vid, id.slice(vid.length + 2), toId);
+    if (real) w.out[id] = { ...patches[id], id, childIds: real.childIds, parentId: real.parentId };
+  }
+}
+function instancePoseAt(nodes, id, componentMs) {
+  const inst = nodes[id];
+  const comp = inst ? shownComponent(nodes, inst, void 0) : void 0;
+  if (!inst || !comp) return {};
+  const w = { nodes, runtime: NO_RUNTIME, out: {}, live: false, expanding: /* @__PURE__ */ new Set() };
+  poseInstance(w, id, inst, null, 0, { comp, ct: componentMs, live: false });
+  return w.out;
+}
+var idle = /* @__PURE__ */ new WeakMap();
+function touches(runtime, hostId) {
+  if (!runtime.size) return false;
+  const prefix = `${hostId}::`;
+  for (const id of runtime.keys()) if (id === hostId || id.startsWith(prefix)) return true;
+  return false;
+}
+function sampleInstances(nodes, rootId, rootMs, runtime = NO_RUNTIME, base = {}) {
+  const candidates = motionInstanceIds(nodes);
+  let extra = null;
+  if (runtime.size) {
+    for (const id of runtime.keys()) if (!id.includes("::") && nodes[id]?.type === "INSTANCE" && !candidates.includes(id)) (extra ??= []).push(id);
+  }
+  const patches = {};
+  let live = false;
+  const one = (id) => {
+    if (id === rootId) return;
+    const t = localTime(nodes, id, rootId, rootMs);
+    if (typeof t !== "number") return;
+    const inst = base[id] ?? nodes[id];
+    if (inst.visible === false) return;
+    const touched = touches(runtime, id);
+    const clock = clockOf(nodes, inst, t, runtime.get(id));
+    if (!clock) return;
+    const cached = touched ? void 0 : idle.get(inst);
+    let posed;
+    if (cached && cached.nodes === nodes && cached.comp === clock.comp && cached.ct === clock.ct) posed = cached.posed;
+    else {
+      const w = { nodes, runtime, out: {}, live: false, expanding: /* @__PURE__ */ new Set() };
+      poseInstance(w, id, inst, t, 0, clock);
+      for (const _ in w.out) {
+        if (!w.out[id]) w.out[id] = { ...inst };
+        break;
+      }
+      posed = { patches: w.out, live: w.live };
+      if (!touched) idle.set(inst, { nodes, comp: clock.comp, ct: clock.ct, posed });
+    }
+    Object.assign(patches, posed.patches);
+    if (posed.live) live = true;
+  };
+  for (const id of candidates) one(id);
+  if (extra) for (const id of extra) one(id);
+  return { patches, live };
+}
+function motionComponentProblems(nodes, componentId) {
+  const root = nodes[componentId];
+  if (!root) return [`no component ${componentId}`];
+  const set = root.type === "COMPONENT" && root.parentId && nodes[root.parentId]?.type === "COMPONENT_SET" ? nodes[root.parentId] : null;
+  const defs = componentDefinitions(nodes, set ? set.childIds[0] ?? componentId : componentId);
+  const roots = set ? set.childIds.filter((id) => nodes[id]?.type === "COMPONENT") : [componentId];
+  const used = /* @__PURE__ */ new Set();
+  const out = [];
+  const variantAxes = /* @__PURE__ */ new Set();
+  const walk = (id, depth) => {
+    const n = nodes[id];
+    if (!n || depth > 64) return;
+    if (n.type === "COMPONENT") for (const k in n.variantProperties ?? {}) variantAxes.add(k);
+    const refs = n.componentPropertyReferences;
+    if (refs) for (const k in refs) used.add(refs[k]);
+    for (const p in n.componentPropertyPaths ?? {}) used.add(n.componentPropertyPaths[p]);
+    const tracks = n.motion?.tracks;
+    if (tracks) for (const p in tracks) {
+      const tr = tracks[p];
+      for (const k of tr?.keys ?? []) if (k.bind) used.add(k.bind.prop);
+      if (p === "text.content" && refs?.characters && tr?.keys.some((k) => !k.bind)) out.push(`"${n.name}" keys its text but takes its words from "${refs.characters}": the keys ignore what an instance types (bind the keys to the property)`);
+    }
+    if (n.type !== "INSTANCE") for (const c of n.childIds ?? []) walk(c, depth + 1);
+  };
+  for (const r of roots) walk(r, 0);
+  for (const name in defs) {
+    const d = defs[name];
+    if (d.type === "MOTION") {
+      if (!d.binds) out.push(`"${name}" is a motion property bound to no playback setting`);
+      continue;
+    }
+    if (d.type === "VARIANT" || d.type === "INSTANCE_SWAP") continue;
+    if (d.type === "TEXT" && variantAxes.has(name)) continue;
+    if (!used.has(name)) out.push(`"${name}" reaches no layer: nothing in the component shows it`);
+  }
+  if (!roots.some((r) => isMotionComponent(nodes, r))) out.push(`"${root.name}" has no timeline to play`);
+  return out;
+}
+function newPropertyDefinition(type, binds = "speed") {
+  return type === "NUMBER" ? { type, defaultValue: 0, min: 0, max: 100, step: 1 } : type === "COLOR" ? { type, defaultValue: { r: 0.18, g: 0.42, b: 1, a: 1 } } : type === "MOTION" ? { type, binds, defaultValue: DEFAULT_PLAYBACK[binds] } : { type, defaultValue: type === "BOOLEAN" ? true : type === "TEXT" ? "Text" : "" };
+}
+function layerInputPatch(node, name, path) {
+  const b = path ? bindPath(node, asPath(path)) : null;
+  if (path && !b) return null;
+  const bound = node.componentPropertyPaths ?? {};
+  const next = {};
+  for (const p in bound) if (bound[p] !== name) next[p] = bound[p];
+  if (b) next[b.path] = name;
+  const props = { componentPropertyPaths: Object.keys(next).length ? next : void 0 };
+  if (b) {
+    for (const k of ["fills", "strokes", "effects"]) if (b.node[k] !== node[k]) props[k] = b.node[k];
+  }
+  return props;
+}
+
+export {
+  NO_RUNTIME,
+  componentLayers,
+  nestedInstances,
+  isMotionComponent,
+  isMotionFamily,
+  hostInstanceOf,
+  motionInstanceIds,
+  playbackOf,
+  instanceNow,
+  instanceTrigger,
+  timelineDuration,
+  frameTimeline,
+  frameMotionEnd,
+  frameRunsOn,
+  hasFrameMotion,
+  instancePoseAt,
+  sampleInstances,
+  motionComponentProblems,
+  newPropertyDefinition,
+  layerInputPatch
+};