@popcraft/kit 0.35.0 → 0.35.2

package/dist/chunks/chunk-TTCX2CIW.js

@@ -0,0 +1,1132 @@
+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 {
+  VOICES
+} from "./chunk-DHA7XGJM.js";
+import {
+  repairStateMachine
+} from "./chunk-WPVEUIHC.js";
+import {
+  resolveTextNodeStyles
+} from "./chunk-OAZ4ELDI.js";
+import {
+  casedText,
+  estimateTextHeight,
+  measureAutoWidth
+} from "./chunk-P4KLGWND.js";
+import {
+  applyAutoLayout
+} from "./chunk-7VLM7FPN.js";
+import {
+  clampSpeed
+} from "./chunk-3WU5CFFS.js";
+import {
+  isTimelineFps
+} from "./chunk-M4ZB26XO.js";
+import {
+  AUDIO_SIGNALS,
+  GAIN_PROPERTY,
+  MAX_AUDIO_LANES,
+  audioClipLength,
+  audioSpeed,
+  placeAudio
+} from "./chunk-MEWJ3DMI.js";
+import {
+  sequenceClips
+} from "./chunk-U7I4I55Q.js";
+import {
+  TRANSITION_TYPES
+} from "./chunk-4CKVXCTN.js";
+import {
+  init_scene_graph,
+  updateConnectors,
+  updateNode
+} from "./chunk-HZPJZB6K.js";
+import {
+  init_instance_layout,
+  measureTextLayout
+} from "./chunk-YYEDFSIT.js";
+import {
+  effectsOf,
+  init_effects,
+  init_properties,
+  isBoundPath,
+  isShadowEffect,
+  propertyFor
+} from "./chunk-ZR7VLCYY.js";
+import {
+  PLAYBACK_FIELDS,
+  init_time,
+  isPlaybackValue
+} from "./chunk-N7FRTGM3.js";
+import {
+  init_values,
+  isColor,
+  isValueOf
+} from "./chunk-6WRFVZ6J.js";
+import {
+  DEFAULT_KEY_INTERP,
+  EASINGS,
+  init_easing
+} from "./chunk-GRZNA5QW.js";
+import {
+  init_scene3d,
+  repairScene3D
+} from "./chunk-WC3I3ZEX.js";
+import {
+  init_transform,
+  invalidTransformFields
+} from "./chunk-FFJA4HPI.js";
+import {
+  repairShaderGraph
+} from "./chunk-BBUOBDRE.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-APZ7CG5P.js";
+
+// lib/document/invariants.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_scene_graph();
+
+// lib/document/text-bounds.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_instance_layout();
+function autoTextBounds(node, styles) {
+  const autoResize = node.textAutoResize ?? "WIDTH_AND_HEIGHT";
+  if (autoResize !== "WIDTH_AND_HEIGHT" && autoResize !== "HEIGHT") return null;
+  if (node.textPath || node.textArea) return null;
+  const hugs = autoResize === "WIDTH_AND_HEIGHT";
+  const resolved = resolveTextNodeStyles(node, styles);
+  const laid = measureTextLayout(resolved);
+  if (laid) return { width: hugs ? Math.max(1, laid.width) : node.width, height: Math.max(1, laid.height) };
+  const chars = casedText(resolved.characters || "", resolved.textCase);
+  const family = resolved.fontFamily || "Inter", weight = resolved.fontWeight || 400, size = resolved.fontSize || 16;
+  const width = hugs ? Math.max(measureAutoWidth({ ...resolved, fontFamily: family, fontWeight: weight, fontSize: size }) || size, 10) : node.width;
+  const estimate = estimateTextHeight(chars, width, family, weight, size, resolved.lineHeight ?? "AUTO", !hugs, resolved.letterSpacing || 0);
+  return { width, height: hugs ? estimate : Math.max(node.height, estimate) };
+}
+
+// lib/text/effect-presets.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_effects();
+var DEFAULTS = {
+  SHADOW: { distance: 17.68, angle: 45, blur: 12.5, thickness: 0, intensity: 45 },
+  LIFT: { distance: 25, angle: 90, blur: 62.5, thickness: 0, intensity: 30 },
+  NEON: { distance: 0, angle: 90, blur: 75, thickness: 0, intensity: 90 },
+  GLOW: { distance: 0, angle: 90, blur: 50, thickness: 0, intensity: 85 },
+  OUTLINE: { distance: 0, angle: 90, blur: 0, thickness: 8, intensity: 100 },
+  HOLLOW: { distance: 0, angle: 90, blur: 0, thickness: 4, intensity: 100 },
+  ECHO: { distance: 8, angle: 45, blur: 0, thickness: 0, intensity: 50 },
+  BACKGROUND: { distance: 0, angle: 90, blur: 0, thickness: 30, intensity: 18 }
+};
+var BLACK = { r: 0, g: 0, b: 0, a: 1 };
+var WHITE = { r: 1, g: 1, b: 1, a: 1 };
+var fillPaint = (n) => n.fills?.find((f) => f.visible !== false && f.type === "SOLID");
+var fillColor = (n) => fillPaint(n)?.color ?? BLACK;
+var shadow = (color, alpha, offset, blur, spread = 0) => ({ color: { ...color, a: alpha }, offset, blur, spread, visible: true, type: "DROP_SHADOW" });
+var round = (v) => Math.round(v * 100) / 100;
+var OUTLINED = /* @__PURE__ */ new Set(["OUTLINE", "HOLLOW"]);
+function textEffectPatch(node, preset, params) {
+  const size = Math.max(1, node.fontSize || 16);
+  const em = size / 100;
+  const keep = effectsOf(node).filter((e) => !isShadowEffect(e));
+  const p = DEFAULTS[preset] ? { ...DEFAULTS[preset], ...node.textEffectPreset === preset ? node.textEffectParams : void 0, ...params } : void 0;
+  const prev = node.textEffectPreset;
+  const reset = {};
+  if (prev && OUTLINED.has(prev) && !OUTLINED.has(preset)) {
+    reset.strokes = [];
+    reset.paintOrder = void 0;
+  }
+  if (prev === "HOLLOW" && preset !== "HOLLOW") reset.fills = (node.fills ?? []).map((f) => f.type === "SOLID" ? { ...f, opacity: 1 } : f);
+  if (prev === "CURVE" && preset !== "CURVE") reset.textPath = void 0;
+  const base = { ...reset, shadows: void 0, blurs: void 0, textEffectPreset: preset === "NONE" ? void 0 : preset, textEffectParams: p, textEffectSize: p ? size : void 0 };
+  if (!p) {
+    if (preset === "CURVE") return { ...base, effects: keep, textPath: { mode: "ARC", bend: 50 } };
+    return { ...base, effects: keep };
+  }
+  const rad = p.angle * Math.PI / 180;
+  const off = (k = 1) => ({ x: round(Math.cos(rad) * p.distance * em * k), y: round(Math.sin(rad) * p.distance * em * k) });
+  const a = Math.max(0, Math.min(1, p.intensity / 100));
+  const c = fillColor(node);
+  switch (preset) {
+    case "SHADOW":
+    case "LIFT":
+      return { ...base, effects: [...keep, shadow(p.color ?? BLACK, a, off(), round(p.blur * em))] };
+    case "NEON": {
+      const glow = p.color ?? c;
+      const bright = { type: "SOLID", color: { r: Math.min(1, glow.r + 0.6), g: Math.min(1, glow.g + 0.6), b: Math.min(1, glow.b + 0.6), a: 1 }, visible: true, opacity: 1 };
+      return { ...base, fills: [bright], effects: [...keep, shadow(glow, a, { x: 0, y: 0 }, round(p.blur * em))] };
+    }
+    case "GLOW":
+      return { ...base, effects: [...keep, shadow(p.color ?? WHITE, a, { x: 0, y: 0 }, round(p.blur * em))] };
+    case "BACKGROUND":
+      return { ...base, effects: [...keep, shadow(p.color ?? c, a, { x: 0, y: 0 }, round(p.thickness * em * 0.25), round(p.thickness * em))] };
+    case "ECHO":
+      return { ...base, effects: [...keep, ...[1, 2, 3].map((k) => shadow(p.color ?? c, a / k, off(k), 0))] };
+    case "OUTLINE":
+      return {
+        ...base,
+        effects: keep,
+        paintOrder: "STROKE_FIRST",
+        strokes: [{ color: { ...p.color ?? BLACK, a: 1 }, width: Math.max(0.5, round(p.thickness * em)), alignment: "OUTSIDE", cap: "NONE", join: "ROUND", dashPattern: [] }]
+      };
+    case "HOLLOW":
+      return {
+        ...base,
+        effects: keep,
+        paintOrder: "FILL_FIRST",
+        fills: (node.fills?.length ? node.fills : [{ type: "SOLID", color: c, visible: true }]).map((f) => f.type === "SOLID" ? { ...f, opacity: 0 } : f),
+        strokes: [{ color: { ...c, a: 1 }, width: Math.max(0.5, round(p.thickness * em)), alignment: "CENTER", cap: "NONE", join: "ROUND", dashPattern: [] }]
+      };
+  }
+  return { ...base, effects: keep };
+}
+function rescaleTextEffect(node) {
+  const preset = node.textEffectPreset;
+  const at = node.textEffectSize;
+  if (!preset || !DEFAULTS[preset] || !at || at === node.fontSize) return null;
+  const patch = textEffectPatch(node, preset);
+  if (preset !== "HOLLOW") delete patch.fills;
+  return patch;
+}
+
+// lib/motion/invariants.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_easing();
+init_properties();
+init_time();
+init_values();
+
+// lib/audio/presentation/repair.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/audio/presentation/types.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var VOICE_MODELS = ["natural", "hd", "standard"];
+var MUSIC_MODELS = ["hq", "standard"];
+var PRESENTATION_STYLES = ["conversational", "corporate", "energetic", "calm", "documentary"];
+var MUSIC_MOODS = ["uplifting", "ambient", "cinematic", "lofi", "electronic", "acoustic", "none"];
+var DEFAULT_SETTINGS = {
+  narration: true,
+  voice: "alloy",
+  voiceModel: "natural",
+  speed: 1,
+  style: "conversational",
+  mood: "uplifting",
+  musicModel: "hq",
+  stingers: true,
+  loudness: -16,
+  truePeak: -1,
+  beatAlign: false,
+  autoAdvance: true,
+  musicDb: -8,
+  duckDb: -12,
+  stingerDb: -6,
+  leadInMs: 500,
+  introMs: 1500,
+  tailMs: 900,
+  minSlideMs: 3e3
+};
+var LANES = { voice: 0, musicA: 1, musicB: 2, stinger: 3 };
+var CLIP_ID = {
+  voice: (frameId) => `pa-vo-${frameId}`,
+  music: (n) => `pa-music-${n}`,
+  stinger: (n) => `pa-sting-${n}`
+};
+var isManagedClip = (id) => id.startsWith("pa-");
+
+// lib/audio/presentation/repair.ts
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var finite = (v) => typeof v === "number" && Number.isFinite(v);
+var HASH = /^[0-9a-f]{32}$/;
+var RANGES = {
+  speed: [0.5, 2],
+  loudness: [-36, -8],
+  truePeak: [-6, 0],
+  musicDb: [-40, 0],
+  duckDb: [-40, 0],
+  stingerDb: [-40, 6],
+  leadInMs: [0, 1e4],
+  introMs: [0, 2e4],
+  tailMs: [0, 1e4],
+  minSlideMs: [500, 6e5]
+};
+var ENUMS = {
+  voice: VOICES,
+  voiceModel: VOICE_MODELS,
+  style: PRESENTATION_STYLES,
+  mood: MUSIC_MOODS,
+  musicModel: MUSIC_MODELS
+};
+function repairSettings(raw) {
+  const src = isObj(raw) ? raw : {};
+  const out = { ...DEFAULT_SETTINGS };
+  for (const k of Object.keys(DEFAULT_SETTINGS)) {
+    const v = src[k];
+    if (v === void 0) continue;
+    const range = RANGES[k], values = ENUMS[k];
+    if (range) {
+      if (finite(v)) out[k] = Math.max(range[0], Math.min(range[1], v));
+    } else if (values) {
+      if (typeof v === "string" && values.includes(v)) out[k] = v;
+    } else if (typeof v === typeof DEFAULT_SETTINGS[k]) out[k] = v;
+  }
+  return out;
+}
+var validAsset = (a) => isObj(a) && typeof a.mediaHash === "string" && HASH.test(a.mediaHash) && finite(a.durationMs) && a.durationMs > 0 && typeof a.name === "string";
+function repairSoundtrack(raw) {
+  if (!isObj(raw) || typeof raw.pageId !== "string" || !raw.pageId) return null;
+  const settings = repairSettings(raw.settings);
+  const slides = {};
+  let changed = JSON.stringify(settings) !== JSON.stringify(raw.settings);
+  for (const [id, s] of Object.entries(isObj(raw.slides) ? raw.slides : {})) {
+    if (!isObj(s)) {
+      changed = true;
+      continue;
+    }
+    const next = { ...s };
+    if (s.voice !== void 0 && !validAsset(s.voice)) {
+      delete next.voice;
+      changed = true;
+    }
+    if (s.holdMs !== void 0 && !(finite(s.holdMs) && s.holdMs > 0)) {
+      delete next.holdMs;
+      changed = true;
+    }
+    slides[id] = next;
+  }
+  if (!isObj(raw.slides)) changed = true;
+  const out = { ...raw, settings, slides };
+  for (const k of ["music", "stinger"]) if (raw[k] !== void 0 && !validAsset(raw[k])) {
+    delete out[k];
+    changed = true;
+  }
+  if (out.stinger && !finite(out.stinger.hitMs)) {
+    out.stinger = { ...out.stinger, hitMs: 0 };
+    changed = true;
+  }
+  if (raw.trimDb !== void 0 && !(finite(raw.trimDb) && raw.trimDb <= 0)) {
+    delete out.trimDb;
+    changed = true;
+  }
+  return changed ? out : raw;
+}
+
+// lib/document/paint-repair.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+function hexColor(s) {
+  const h = s.trim().replace(/^#/, "");
+  const full = h.length === 3 || h.length === 4 ? h.split("").map((c) => c + c).join("") : h;
+  if (!/^[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(full)) return { r: 0, g: 0, b: 0, a: 1 };
+  const v = (i) => parseInt(full.slice(i, i + 2), 16) / 255;
+  return { r: v(0), g: v(2), b: v(4), a: full.length === 8 ? v(6) : 1 };
+}
+function repairList(list) {
+  if (!Array.isArray(list) || !list.some((p) => broken(p))) return list;
+  return list.map((p) => {
+    if (!broken(p)) return p;
+    const paint = p;
+    return { ...paint, visible: paint.visible ?? true, opacity: paint.opacity ?? 1, ...typeof paint.color === "string" ? { color: hexColor(paint.color) } : {} };
+  });
+}
+var broken = (p) => {
+  if (!p || typeof p !== "object") return false;
+  const paint = p;
+  return typeof paint.color === "string" || paint.type === "SOLID" && (paint.visible === void 0 || paint.opacity === void 0);
+};
+function repairFillGraphs(node) {
+  const fills = node.fills;
+  if (!Array.isArray(fills) || !fills.some((f) => f && f.shaderGraph !== void 0)) return node;
+  let changed = false;
+  const next = fills.map((f) => {
+    if (!f || f.shaderGraph === void 0) return f;
+    const graph = repairShaderGraph(f.shaderGraph);
+    if (graph === f.shaderGraph) return f;
+    changed = true;
+    const { shaderGraph: _gone, ...rest } = f;
+    void _gone;
+    return graph ? { ...rest, shaderGraph: graph } : rest;
+  });
+  return changed ? { ...node, fills: next } : node;
+}
+function repairDocumentPaints(doc) {
+  let changed = false;
+  const nodes = { ...doc.nodes };
+  for (const id in nodes) {
+    const n = repairFillGraphs(nodes[id]);
+    if (n !== nodes[id]) {
+      nodes[id] = n;
+      changed = true;
+    }
+    const fills = repairList(n.fills);
+    const strokes = repairList(n.strokes);
+    if (fills !== n.fills || strokes !== n.strokes) {
+      nodes[id] = { ...n, fills, strokes };
+      changed = true;
+    }
+  }
+  const styles = { ...doc.styles };
+  for (const id in styles) {
+    const paints = repairList(styles[id]?.paints);
+    if (paints !== styles[id]?.paints) {
+      styles[id] = { ...styles[id], paints };
+      changed = true;
+    }
+  }
+  return changed ? { ...doc, nodes, styles } : doc;
+}
+
+// lib/motion/invariants.ts
+var isObj2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var finite2 = (v) => typeof v === "number" && Number.isFinite(v);
+var optFinite = (v) => v === void 0 || finite2(v);
+function isValidInterp(i) {
+  if (!isObj2(i)) return false;
+  switch (i.kind) {
+    case "hold":
+    case "linear":
+      return true;
+    case "bezier":
+      return Array.isArray(i.cp) && i.cp.length === 4 && i.cp.every(finite2);
+    case "ease":
+      return typeof i.name === "string" && i.name in EASINGS && optFinite(i.param);
+    case "spring":
+      return finite2(i.stiffness) && i.stiffness > 0 && finite2(i.damping) && i.damping >= 0 && finite2(i.mass) && i.mass > 0;
+    default:
+      return false;
+  }
+}
+function isValidModifier(m, numberTrack) {
+  if (!isObj2(m)) return false;
+  if (m.kind !== "loop" && m.kind !== "audio" && !numberTrack) return false;
+  switch (m.kind) {
+    case "spin":
+      return finite2(m.rate);
+    case "sine":
+      return finite2(m.amp) && finite2(m.freq) && optFinite(m.phase);
+    case "noise":
+      return finite2(m.amp) && finite2(m.freq) && finite2(m.seed) && optFinite(m.octaves);
+    case "bounce":
+      return finite2(m.amp) && finite2(m.freq) && finite2(m.decay) && finite2(m.start) && optFinite(m.end);
+    case "loop":
+      return (m.mode === "cycle" || m.mode === "pingpong" || m.mode === "continue" || m.mode === "offset") && (m.range === void 0 || Array.isArray(m.range) && m.range.length === 2 && m.range.every(finite2) && m.range[0] < m.range[1]);
+    case "mod":
+      return finite2(m.period) && m.period > 0 && optFinite(m.offset);
+    case "clamp":
+      return optFinite(m.min) && optFinite(m.max);
+    case "audio":
+      return typeof m.signal === "string" && AUDIO_SIGNALS.includes(m.signal) && finite2(m.gain) && finite2(m.from) && finite2(m.to) && (m.mode === void 0 || m.mode === "add" || m.mode === "set" || m.mode === "multiply") && optFinite(m.bin) && optFinite(m.attack) && optFinite(m.release) && optFinite(m.lag) && optFinite(m.threshold) && (m.clip === void 0 || typeof m.clip === "string") && (m.color === void 0 || isColor(m.color));
+    case "link":
+      return isObj2(m.source) && typeof m.source.nodeId === "string" && typeof m.source.path === "string" && isBoundPath(m.source.path) && optFinite(m.mul) && optFinite(m.add) && optFinite(m.delay);
+    default:
+      return false;
+  }
+}
+function repairNumberKeys(raw) {
+  if (!Array.isArray(raw)) return null;
+  const ids = /* @__PURE__ */ new Set();
+  const keys = [];
+  let changed = false;
+  for (const k of raw) {
+    if (!isObj2(k) || !finite2(k.t) || !finite2(k.v)) {
+      changed = true;
+      continue;
+    }
+    const out = isValidInterp(k.out) ? k.out : DEFAULT_KEY_INTERP;
+    const id = typeof k.id === "string" && k.id && !ids.has(k.id) ? k.id : freshKeyId(ids);
+    ids.add(id);
+    const t = Math.max(0, k.t);
+    if (out !== k.out || id !== k.id || t !== k.t) changed = true;
+    keys.push(out !== k.out || id !== k.id || t !== k.t ? { id, t, v: k.v, out } : k);
+  }
+  for (let i = 1; i < keys.length; i++) if (keys[i - 1].t > keys[i].t) {
+    keys.sort((a, b) => a.t - b.t);
+    changed = true;
+    break;
+  }
+  if (!keys.length) return null;
+  return changed ? keys : raw;
+}
+function repairModifierKeys(mods) {
+  const ids = /* @__PURE__ */ new Set();
+  return mods.map((m) => {
+    let out = m;
+    if (m.id !== void 0 && (typeof m.id !== "string" || !m.id || ids.has(m.id))) {
+      out = { ...out };
+      delete out.id;
+    }
+    if (typeof out.id === "string") ids.add(out.id);
+    const a = m.animated;
+    if (a === void 0) return out;
+    if (!isObj2(a)) {
+      out = { ...out };
+      delete out.animated;
+      return out;
+    }
+    const animated = {};
+    let changed = false;
+    for (const name of Object.keys(a)) {
+      const keys = repairNumberKeys(a[name]);
+      if (keys !== a[name]) changed = true;
+      if (keys) animated[name] = keys;
+    }
+    if (!changed) return out;
+    out = { ...out };
+    if (Object.keys(animated).length) out.animated = animated;
+    else delete out.animated;
+    return out;
+  });
+}
+var isVec = (v) => Array.isArray(v) && v.length === 2 && finite2(v[0]) && finite2(v[1]);
+function repairSpatial(sp, numberTrack) {
+  if (!numberTrack || !isObj2(sp)) return void 0;
+  const inOk = sp.in === void 0 || isVec(sp.in), outOk = sp.out === void 0 || isVec(sp.out);
+  if (inOk && outOk && (sp.in !== void 0 || sp.out !== void 0)) return sp;
+  const out = {};
+  if (isVec(sp.in)) out.in = sp.in;
+  if (isVec(sp.out)) out.out = sp.out;
+  return out.in || out.out ? out : void 0;
+}
+var TIMELINE_COLOR_IDS = ["accent", "success", "warning", "danger", "component", "prototype", "ai"];
+var TIMELINE_COLORS = new Set(TIMELINE_COLOR_IDS);
+function freshKeyId(used) {
+  for (let n = 1; ; n++) if (!used.has(`k${n}`)) {
+    used.add(`k${n}`);
+    return `k${n}`;
+  }
+}
+function repairTrack(track, prop) {
+  if (!isObj2(track) || !Array.isArray(track.keys)) return null;
+  let changed = false;
+  const discrete = prop.interpolation === "discrete";
+  const ids = /* @__PURE__ */ new Set();
+  const keys = [];
+  let sorted = true;
+  for (const raw of track.keys) {
+    if (!isObj2(raw) || !finite2(raw.t) || !isValueOf(prop.valueType, raw.v)) {
+      changed = true;
+      continue;
+    }
+    let k = raw;
+    if (k.bind !== void 0 && !validBinding(k.bind)) {
+      const { bind: _b, ...bare } = k;
+      void _b;
+      k = bare;
+      changed = true;
+    }
+    const out = discrete ? isObj2(k.out) && k.out.kind === "hold" ? k.out : { kind: "hold" } : isValidInterp(k.out) ? k.out : DEFAULT_KEY_INTERP;
+    const t = Math.max(0, k.t);
+    const id = typeof k.id === "string" && k.id && !ids.has(k.id) ? k.id : freshKeyId(ids);
+    ids.add(id);
+    if (out !== k.out || t !== k.t || id !== k.id) {
+      k = { ...k, id, t, out };
+      changed = true;
+    }
+    if (k.spatial !== void 0) {
+      const sp = repairSpatial(k.spatial, prop.valueType === "number");
+      if (sp !== k.spatial) {
+        k = { ...k };
+        if (sp) k.spatial = sp;
+        else delete k.spatial;
+        changed = true;
+      }
+    }
+    if (keys.length && keys[keys.length - 1].t > k.t) sorted = false;
+    keys.push(k);
+  }
+  if (!sorted) {
+    keys.sort((a, b) => a.t - b.t);
+    changed = true;
+  }
+  let modifiers = track.modifiers;
+  if (modifiers !== void 0) {
+    const valid = Array.isArray(modifiers) ? modifiers.filter((m) => isValidModifier(m, prop.valueType === "number")) : [];
+    const repaired = repairModifierKeys(valid);
+    if (!Array.isArray(modifiers) || repaired.length !== modifiers.length || repaired.some((m, i) => m !== modifiers[i])) {
+      modifiers = repaired.length ? repaired : void 0;
+      changed = true;
+    }
+  }
+  const muted = track.muted;
+  if (muted !== void 0 && typeof muted !== "boolean") changed = true;
+  if (!keys.length && !modifiers?.length) return null;
+  if (!changed) return track;
+  return { keys, ...modifiers?.length ? { modifiers } : {}, ...muted === true ? { muted } : {} };
+}
+function validBinding(b) {
+  return isObj2(b) && typeof b.prop === "string" && b.prop.length > 0 && optFinite(b.mul) && optFinite(b.add);
+}
+function validStagger(s) {
+  if (!isObj2(s) || !finite2(s.delay) || !optFinite(s.seed)) return false;
+  if (s.distribution !== void 0 && !isValidInterp(s.distribution)) return false;
+  const o = s.order;
+  return o === "index" || o === "reverse" || o === "center" || o === "random" || isObj2(o) && Array.isArray(o.ids) && o.ids.every((id) => typeof id === "string");
+}
+function repairMotion(node, motion) {
+  if (!isObj2(motion)) return void 0;
+  let changed = false;
+  const tracksIn = isObj2(motion.tracks) ? motion.tracks : {};
+  if (tracksIn !== motion.tracks) changed = true;
+  const tracks = {};
+  for (const key of Object.keys(tracksIn)) {
+    const prop = isBoundPath(key) ? propertyFor(key) : void 0;
+    const repaired = prop && prop.read(node, key) !== void 0 ? repairTrack(tracksIn[key], prop) : null;
+    if (repaired !== tracksIn[key]) changed = true;
+    if (repaired) tracks[key] = repaired;
+  }
+  const out = { ...motion, tracks: changed ? tracks : motion.tracks };
+  if (out.timeOffset !== void 0 && !finite2(out.timeOffset)) {
+    delete out.timeOffset;
+    changed = true;
+  }
+  if (out.span !== void 0) {
+    const sp = out.span;
+    if (!isObj2(sp) || !finite2(sp.in)) {
+      delete out.span;
+      changed = true;
+    } else if (sp.out !== void 0 && !(finite2(sp.out) && sp.out > sp.in)) {
+      out.span = { in: sp.in };
+      changed = true;
+    }
+  }
+  if (out.stagger !== void 0 && !validStagger(out.stagger)) {
+    delete out.stagger;
+    changed = true;
+  }
+  const empty = !Object.keys(out.tracks).length && out.timeOffset === void 0 && out.span === void 0 && out.stagger === void 0;
+  if (empty) return void 0;
+  return changed ? out : motion;
+}
+function repairTimeline(tl) {
+  if (!isObj2(tl) || !finite2(tl.duration) || tl.duration <= 0) return null;
+  let changed = false;
+  const out = { ...tl };
+  if (out.fps !== void 0 && !isTimelineFps(out.fps)) {
+    delete out.fps;
+    changed = true;
+  }
+  const wa = out.workArea;
+  if (wa !== void 0 && !(Array.isArray(wa) && wa.length === 2 && finite2(wa[0]) && finite2(wa[1]) && wa[0] >= 0 && wa[0] < wa[1])) {
+    delete out.workArea;
+    changed = true;
+  }
+  const raw = out.markers;
+  if (raw !== void 0) {
+    const ids = /* @__PURE__ */ new Set();
+    const markers = [];
+    let ok = Array.isArray(raw);
+    for (const m of Array.isArray(raw) ? raw : []) {
+      if (!isObj2(m) || typeof m.id !== "string" || !m.id || ids.has(m.id) || !finite2(m.t) || m.t < 0 || m.label !== void 0 && typeof m.label !== "string" || m.kind !== void 0 && m.kind !== "marker" && m.kind !== "pause") {
+        ok = false;
+        continue;
+      }
+      ids.add(m.id);
+      if (markers.length && markers[markers.length - 1].t > m.t) ok = false;
+      markers.push(m);
+    }
+    if (!ok) {
+      markers.sort((a, b) => a.t - b.t);
+      if (markers.length) out.markers = markers;
+      else delete out.markers;
+      changed = true;
+    }
+  }
+  if (out.audio !== void 0) {
+    const audio = repairAudio(out.audio);
+    if (audio !== out.audio) {
+      changed = true;
+      if (audio.length) out.audio = audio;
+      else delete out.audio;
+    }
+  }
+  return changed ? out : tl;
+}
+function repairVideoClip(node) {
+  const fills = node.fills;
+  if (!Array.isArray(fills) || !fills.some((f) => f?.type === "VIDEO")) return node;
+  let changed = false;
+  const next = fills.map((f) => {
+    if (f?.type !== "VIDEO") return f;
+    const p = { ...f };
+    let dirty = false;
+    if (p.videoIn !== void 0 && (!finite2(p.videoIn) || p.videoIn === 0)) {
+      delete p.videoIn;
+      dirty = true;
+    }
+    if (p.videoSpeed !== void 0) {
+      const sp = clampSpeed(p.videoSpeed);
+      if (sp === 1) delete p.videoSpeed;
+      else if (sp !== p.videoSpeed) p.videoSpeed = sp;
+      dirty ||= sp !== f.videoSpeed;
+    }
+    if (p.videoTime !== void 0) {
+      delete p.videoTime;
+      dirty = true;
+    }
+    if (p.videoTransition !== void 0) {
+      const tr = p.videoTransition;
+      if (!isObj2(tr) || !["DISSOLVE", "DIP_BLACK", "DIP_WHITE"].includes(tr.type) || !finite2(tr.duration) || tr.duration <= 0) {
+        delete p.videoTransition;
+        dirty = true;
+      }
+    }
+    if (p.videoSound !== void 0) {
+      const s = repairSound(p.videoSound);
+      if (s !== p.videoSound) {
+        dirty = true;
+        if (s) p.videoSound = s;
+        else delete p.videoSound;
+      }
+    }
+    if (!dirty) return f;
+    changed = true;
+    return p;
+  });
+  return changed ? { ...node, fills: next } : node;
+}
+function repairSound(raw) {
+  if (!isObj2(raw)) return null;
+  const s = raw;
+  const out = { ...s };
+  for (const k of ["fadeIn", "fadeOut"]) if (out[k] !== void 0 && (!finite2(out[k]) || out[k] <= 0)) delete out[k];
+  if (out.offset !== void 0 && (!finite2(out.offset) || out.offset === 0)) delete out.offset;
+  if (out.pan !== void 0) {
+    if (!finite2(out.pan) || out.pan === 0) delete out.pan;
+    else out.pan = Math.max(-1, Math.min(1, out.pan));
+  }
+  if (out.muted !== void 0 && out.muted !== true) delete out.muted;
+  if (out.fadeCurve !== void 0 && out.fadeCurve !== "equalPower") delete out.fadeCurve;
+  if (out.gain !== void 0) {
+    const g = repairTrack(out.gain, GAIN_PROPERTY);
+    if (g) out.gain = g;
+    else delete out.gain;
+  }
+  const keys = Object.keys(out);
+  return keys.length === Object.keys(s).length && keys.every((k) => out[k] === s[k]) ? s : out;
+}
+var UNITS = /* @__PURE__ */ new Set(["letter", "word", "line"]);
+var ORDERS = /* @__PURE__ */ new Set(["forward", "reverse", "center", "random"]);
+var PROP_KEYS = ["translateX", "translateY", "scale", "rotation", "opacity", "blur"];
+var ANIMATOR_ID = /^[\w-]+$/;
+function repairAnimator(raw, used) {
+  if (!isObj2(raw) || typeof raw.id !== "string" || !ANIMATOR_ID.test(raw.id) || used.has(raw.id) || !UNITS.has(raw.unit)) return null;
+  used.add(raw.id);
+  let changed = false;
+  const r = isObj2(raw.range) ? raw.range : {};
+  const range = { start: finite2(r.start) ? r.start : 0, end: finite2(r.end) ? r.end : 1, offset: finite2(r.offset) ? r.offset : 0 };
+  if (!isObj2(raw.range) || range.start !== r.start || range.end !== r.end || range.offset !== r.offset) changed = true;
+  const pIn = isObj2(raw.props) ? raw.props : {};
+  const props = {};
+  for (const k of PROP_KEYS) {
+    const v = pIn[k];
+    if (finite2(v)) props[k] = v;
+    else if (v !== void 0) changed = true;
+  }
+  if (pIn.color !== void 0) {
+    if (isColor(pIn.color)) props.color = pIn.color;
+    else changed = true;
+  }
+  if (!isObj2(raw.props)) changed = true;
+  const out = { id: raw.id, unit: raw.unit, range, order: ORDERS.has(raw.order) ? raw.order : "forward", props };
+  if (out.order !== raw.order) changed = true;
+  if (typeof raw.name === "string") out.name = raw.name;
+  else if (raw.name !== void 0) changed = true;
+  for (const k of ["amount", "seed", "stagger"]) {
+    const v = raw[k];
+    if (finite2(v)) out[k] = v;
+    else if (v !== void 0) changed = true;
+  }
+  if (raw.ease !== void 0) {
+    if (isValidInterp(raw.ease)) out.ease = raw.ease;
+    else changed = true;
+  }
+  return changed ? out : raw;
+}
+function repairCounter(raw) {
+  if (!isObj2(raw) || !finite2(raw.from) || !finite2(raw.to)) return null;
+  let changed = false;
+  const out = { from: raw.from, to: raw.to };
+  if (raw.decimals !== void 0) {
+    if (finite2(raw.decimals)) {
+      out.decimals = Math.max(0, Math.min(6, Math.round(raw.decimals)));
+      if (out.decimals !== raw.decimals) changed = true;
+    } else changed = true;
+  }
+  for (const k of ["prefix", "suffix", "separator"]) {
+    const v = raw[k];
+    if (typeof v === "string") out[k] = v;
+    else if (v !== void 0) changed = true;
+  }
+  if (raw.value !== void 0) {
+    if (finite2(raw.value)) out.value = raw.value;
+    else changed = true;
+  }
+  if (raw.step !== void 0) {
+    if (finite2(raw.step) && raw.step > 0) out.step = raw.step;
+    else changed = true;
+  }
+  return changed ? out : raw;
+}
+function repairTextMotion(node) {
+  const n = node;
+  if (n.textAnimators === void 0 && n.textCounter === void 0) return node;
+  const isText = node.type === "TEXT";
+  let animators;
+  let same = true;
+  if (n.textAnimators !== void 0) {
+    const list = isText && Array.isArray(n.textAnimators) ? n.textAnimators : [];
+    const used = /* @__PURE__ */ new Set();
+    animators = [];
+    for (const a of list) {
+      const r = repairAnimator(a, used);
+      if (r !== a) same = false;
+      if (r) animators.push(r);
+    }
+    if (!Array.isArray(n.textAnimators) || animators.length !== list.length) same = false;
+  }
+  const counter = n.textCounter === void 0 ? void 0 : isText ? repairCounter(n.textCounter) : null;
+  if (same && counter === n.textCounter) return node;
+  const next = { ...node };
+  if (animators?.length) next.textAnimators = same ? n.textAnimators : animators;
+  else delete next.textAnimators;
+  if (counter) next.textCounter = counter;
+  else delete next.textCounter;
+  return next;
+}
+function repairPlayback(pb) {
+  if (!isObj2(pb)) return void 0;
+  let changed = false;
+  const out = {};
+  for (const f of PLAYBACK_FIELDS) if (pb[f] !== void 0) {
+    if (isPlaybackValue(f, pb[f])) out[f] = pb[f];
+    else changed = true;
+  }
+  const r = pb.range;
+  if (r !== void 0) {
+    if (Array.isArray(r) && r.length === 2 && r.every((id) => typeof id === "string" && id) && r[0] !== r[1]) out.range = r;
+    else changed = true;
+  }
+  for (const k in pb) if (!(k in out) && pb[k] !== void 0 && !PLAYBACK_FIELDS.includes(k) && k !== "range") changed = true;
+  if (!Object.keys(out).length) return void 0;
+  return changed ? out : pb;
+}
+function validDefinition(d) {
+  if (!isObj2(d)) return false;
+  switch (d.type) {
+    case "NUMBER":
+      return finite2(d.defaultValue) && optFinite(d.min) && optFinite(d.max) && optFinite(d.step) && (d.min === void 0 || d.max === void 0 || d.min <= d.max);
+    case "COLOR":
+      return isColor(d.defaultValue);
+    case "MOTION":
+      return typeof d.binds === "string" && PLAYBACK_FIELDS.includes(d.binds) && isPlaybackValue(d.binds, d.defaultValue);
+    default:
+      return true;
+  }
+}
+var MOTION_TYPES = /* @__PURE__ */ new Set(["NUMBER", "COLOR", "MOTION"]);
+function repairComponentMotion(node) {
+  let next = node;
+  const put = (k, v) => {
+    if (next === node) next = { ...node };
+    const o = next;
+    if (v === void 0) delete o[k];
+    else o[k] = v;
+  };
+  if (node.type === "INSTANCE" && node.playback !== void 0) {
+    const pb = repairPlayback(node.playback);
+    if (pb !== node.playback) put("playback", pb);
+  }
+  const paths = node.componentPropertyPaths;
+  if (paths !== void 0) {
+    const ok = {};
+    let bad = !isObj2(paths);
+    if (isObj2(paths)) for (const p in paths) {
+      if (isBoundPath(p) && propertyFor(p) && typeof paths[p] === "string" && paths[p]) ok[p] = paths[p];
+      else bad = true;
+    }
+    if (bad) put("componentPropertyPaths", Object.keys(ok).length ? ok : void 0);
+  }
+  if ((node.type === "COMPONENT" || node.type === "COMPONENT_SET") && isObj2(node.componentPropertyDefinitions)) {
+    const defs = node.componentPropertyDefinitions;
+    let bad = false;
+    const ok = {};
+    for (const name in defs) {
+      if (!MOTION_TYPES.has(defs[name]?.type) || validDefinition(defs[name])) ok[name] = defs[name];
+      else bad = true;
+    }
+    if (bad) put("componentPropertyDefinitions", ok);
+  }
+  return next;
+}
+function repairNodeMotion(node, hasNode = () => true) {
+  const base = repairVideoClip(repairComponentMotion(repairTextMotion(repairFillGraphs(node))));
+  const hasMotion = base.motion !== void 0, hasTimeline = base.timeline !== void 0, hasMachine = base.stateMachine !== void 0;
+  const badColor = base.timelineColor !== void 0 && !TIMELINE_COLORS.has(base.timelineColor);
+  if (!hasMotion && !hasTimeline && !badColor && !hasMachine) return base;
+  const motion = hasMotion ? repairMotion(base, base.motion) : void 0;
+  const timeline = hasTimeline ? repairTimeline(base.timeline) : void 0;
+  const machine = hasMachine ? repairStateMachine(base.stateMachine, new Set(timeline?.markers?.map((m) => m.id) ?? []), hasNode) : void 0;
+  if (motion === base.motion && timeline === base.timeline && machine === base.stateMachine && !badColor) return base;
+  const next = { ...base };
+  if (motion) next.motion = motion;
+  else delete next.motion;
+  if (timeline) next.timeline = timeline;
+  else delete next.timeline;
+  if (machine) next.stateMachine = machine;
+  else delete next.stateMachine;
+  if (badColor) delete next.timelineColor;
+  return next;
+}
+var TRANSITIONS = new Set(TRANSITION_TYPES);
+var isFraction = (v) => finite2(v) && v >= 0 && v <= 1;
+function repairTransition(tr) {
+  if (!isObj2(tr) || typeof tr.type !== "string" || !TRANSITIONS.has(tr.type) || !finite2(tr.duration) || tr.duration <= 0 || !isValidInterp(tr.interp)) return null;
+  const params = tr.params;
+  if (params === void 0) return tr;
+  const center = isObj2(params) ? params.center : void 0;
+  const okCenter = center === void 0 || isObj2(center) && isFraction(center.x) && isFraction(center.y);
+  if (isObj2(params) && okCenter && Object.keys(params).every((k) => k === "center")) return tr;
+  const { params: _p, ...bare } = tr;
+  void _p;
+  return okCenter && center ? { ...bare, params: { center } } : bare;
+}
+var MEDIA_HASH = /^[0-9a-f]{32}$/;
+function repairAudioClip(c) {
+  if (!isObj2(c) || typeof c.id !== "string" || !c.id || typeof c.mediaHash !== "string" || !MEDIA_HASH.test(c.mediaHash) || !finite2(c.start) || !finite2(c.in) || !finite2(c.out) || c.in < 0 || c.out <= c.in) return null;
+  const clip = c;
+  const next = { ...clip };
+  if (typeof next.name !== "string") next.name = "Audio";
+  if (next.start < 0) next.start = 0;
+  if (!Number.isInteger(next.lane) || next.lane < 0 || next.lane >= MAX_AUDIO_LANES) next.lane = finite2(next.lane) ? Math.max(0, Math.min(MAX_AUDIO_LANES - 1, Math.round(next.lane))) : 0;
+  const len = audioClipLength(next);
+  for (const k of ["fadeIn", "fadeOut"]) {
+    const v = next[k];
+    if (v === void 0) continue;
+    if (!finite2(v) || v <= 0) delete next[k];
+    else if (v > len) next[k] = len;
+  }
+  if (next.pan !== void 0) {
+    if (!finite2(next.pan) || next.pan === 0) delete next.pan;
+    else next.pan = Math.max(-1, Math.min(1, next.pan));
+  }
+  if (next.muted !== void 0 && next.muted !== true) delete next.muted;
+  if (next.fadeCurve !== void 0 && next.fadeCurve !== "equalPower") delete next.fadeCurve;
+  if (next.speed !== void 0) {
+    const sp = finite2(next.speed) ? audioSpeed(next) : 1;
+    if (sp === 1) delete next.speed;
+    else if (sp !== next.speed) next.speed = sp;
+  }
+  if (next.link !== void 0) delete next.link;
+  if (next.gain !== void 0) {
+    const gain = repairTrack(next.gain, GAIN_PROPERTY);
+    if (gain) next.gain = gain;
+    else delete next.gain;
+  }
+  const same = Object.keys(next).length === Object.keys(clip).length && Object.keys(next).every((k) => next[k] === clip[k]);
+  return same ? clip : next;
+}
+function repairAudio(raw) {
+  if (!Array.isArray(raw)) return [];
+  let changed = false;
+  const ids = /* @__PURE__ */ new Set();
+  let clips = [];
+  for (const c of raw) {
+    const fixed = repairAudioClip(c);
+    if (!fixed || ids.has(fixed.id)) {
+      changed = true;
+      continue;
+    }
+    ids.add(fixed.id);
+    if (fixed !== c) changed = true;
+    clips.push(fixed);
+  }
+  const sorted = clips.slice().sort((a, b) => a.lane - b.lane || a.start - b.start);
+  let placed = [];
+  for (const c of sorted) placed = placeAudio(placed, c);
+  if (placed.some((c, i) => c !== clips[i]) || placed.length !== clips.length) {
+    clips = placed;
+    changed = true;
+  }
+  return changed ? clips : raw;
+}
+function repairComposition(comp, nodes) {
+  if (!isObj2(comp) || typeof comp.id !== "string" || !comp.id || !finite2(comp.width) || comp.width <= 0 || !finite2(comp.height) || comp.height <= 0) return null;
+  let changed = false;
+  const out = { ...comp };
+  if (typeof out.name !== "string") {
+    out.name = "Composition";
+    changed = true;
+  }
+  if (!isTimelineFps(out.fps)) {
+    out.fps = 30;
+    changed = true;
+  }
+  if (out.background !== void 0 && !isColor(out.background)) {
+    delete out.background;
+    changed = true;
+  }
+  const raw = Array.isArray(comp.clips) ? comp.clips : [];
+  if (!Array.isArray(comp.clips)) changed = true;
+  const ids = /* @__PURE__ */ new Set();
+  let clips = [];
+  for (const c of raw) {
+    if (!isObj2(c) || typeof c.id !== "string" || !c.id || ids.has(c.id) || typeof c.frameId !== "string" || nodes[c.frameId]?.type !== "FRAME" || !finite2(c.start) || !finite2(c.in) || !finite2(c.out) || c.in < 0 || c.out <= c.in) {
+      changed = true;
+      continue;
+    }
+    ids.add(c.id);
+    let clip = c;
+    if (clip.transitionIn !== void 0) {
+      const tr = repairTransition(clip.transitionIn);
+      if (tr !== clip.transitionIn) {
+        changed = true;
+        if (tr) clip = { ...clip, transitionIn: tr };
+        else {
+          const { transitionIn: _t, ...bare } = clip;
+          void _t;
+          clip = bare;
+        }
+      }
+    }
+    clips.push(clip);
+  }
+  if (clips.some((c, i) => i > 0 && clips[i - 1].start > c.start)) {
+    clips = clips.slice().sort((a, b) => a.start - b.start);
+    changed = true;
+  }
+  const sequenced = sequenceClips(clips);
+  if (sequenced !== clips) {
+    clips = sequenced;
+    changed = true;
+  }
+  out.clips = clips;
+  if (comp.audio !== void 0) {
+    const audio = repairAudio(comp.audio);
+    if (audio !== comp.audio) {
+      changed = true;
+      if (audio.length) out.audio = audio;
+      else delete out.audio;
+    }
+  }
+  if (out.presentation !== void 0) {
+    const p = repairSoundtrack(out.presentation);
+    if (p !== out.presentation) {
+      changed = true;
+      if (p) out.presentation = p;
+      else delete out.presentation;
+    }
+  }
+  if (out.workArea !== void 0 || out.markers !== void 0) {
+    const tl = { duration: Number.MAX_SAFE_INTEGER, ...out.workArea !== void 0 ? { workArea: out.workArea } : {}, ...out.markers !== void 0 ? { markers: out.markers } : {} };
+    const fixed = repairTimeline(tl);
+    if (fixed !== tl) {
+      changed = true;
+      if (fixed?.workArea) out.workArea = fixed.workArea;
+      else delete out.workArea;
+      if (fixed?.markers) out.markers = fixed.markers;
+      else delete out.markers;
+    }
+  }
+  return changed ? out : comp;
+}
+function repairCompositions(comps, nodes) {
+  if (!comps) return comps;
+  let out = null;
+  for (const key in comps) {
+    const fixed = repairComposition(comps[key], nodes);
+    const ok = fixed && fixed.id === key ? fixed : null;
+    if (ok === comps[key]) continue;
+    out ??= { ...comps };
+    if (ok) out[key] = ok;
+    else delete out[key];
+  }
+  return out ?? comps;
+}
+
+// lib/document/invariants.ts
+init_transform();
+init_scene3d();
+var isVirtualId = (id) => id.includes("::");
+function applyInvariants(doc, touched) {
+  const ids = [...new Set(touched)].filter((id) => !isVirtualId(id));
+  let next = doc;
+  for (const id of ids) next = repairMotion2(repair3D(dropInvalidTransform(remeasureAutoText(rescaleTextEffects(next, id), id), id), id), id);
+  next = updateConnectors(next, ids);
+  next = repairDocumentCompositions(next);
+  return applyAutoLayout(next);
+}
+function rescaleTextEffects(doc, id) {
+  const n = doc.nodes[id];
+  if (!n || n.type !== "TEXT") return doc;
+  const patch = rescaleTextEffect(n);
+  return patch ? updateNode(doc, id, patch) : doc;
+}
+function repairDocumentCompositions(doc) {
+  const comps = repairCompositions(doc.compositions, doc.nodes);
+  if (comps === doc.compositions) return doc;
+  if (comps && Object.keys(comps).length) return { ...doc, compositions: comps };
+  const { compositions: _c, ...rest } = doc;
+  void _c;
+  return rest;
+}
+function dropInvalidTransform(doc, id) {
+  const n = doc.nodes[id];
+  if (!n) return doc;
+  const bad = invalidTransformFields(n);
+  if (!bad.length) return doc;
+  return updateNode(doc, id, Object.fromEntries(bad.map((f) => [f, void 0])));
+}
+function repair3D(doc, id) {
+  const n = doc.nodes[id];
+  if (!n) return doc;
+  const next = repairScene3D(n);
+  return next === n ? doc : { ...doc, nodes: { ...doc.nodes, [id]: next } };
+}
+function repairMotion2(doc, id) {
+  const n = doc.nodes[id];
+  if (!n) return doc;
+  const next = repairNodeMotion(n, (nid) => !!doc.nodes[nid]);
+  return next === n ? doc : { ...doc, nodes: { ...doc.nodes, [id]: next } };
+}
+function remeasureAutoText(doc, id) {
+  const n = doc.nodes[id];
+  if (!n || n.type !== "TEXT") return doc;
+  const bounds = autoTextBounds(n, doc.styles);
+  if (!bounds || bounds.width === n.width && bounds.height === n.height) return doc;
+  return updateNode(doc, id, bounds);
+}
+function resyncText(doc, ids) {
+  if (typeof window === "undefined") return;
+  for (const id of ids) {
+    const n = doc.nodes[isVirtualId(id) ? id.split("::")[0] : id];
+    if (!n) continue;
+    if (n.type === "TEXT" || isVirtualId(id)) window.dispatchEvent(new CustomEvent("popcraft-resync-text", { detail: { nodeId: id } }));
+  }
+}
+
+export {
+  repairDocumentPaints,
+  autoTextBounds,
+  textEffectPatch,
+  rescaleTextEffect,
+  VOICE_MODELS,
+  MUSIC_MODELS,
+  PRESENTATION_STYLES,
+  MUSIC_MOODS,
+  DEFAULT_SETTINGS,
+  LANES,
+  CLIP_ID,
+  isManagedClip,
+  repairSettings,
+  isValidInterp,
+  TIMELINE_COLOR_IDS,
+  repairNodeMotion,
+  repairCompositions,
+  applyInvariants,
+  repairDocumentCompositions,
+  resyncText
+};