@popcraft/kit 0.26.0 → 0.26.1

package/dist/chunks/chunk-62AVP6QT.js

@@ -1,1188 +0,0 @@
-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 {
-  counterRest,
-  formatCounter,
-  init_text_units
-} from "./chunk-MFNTHBR5.js";
-import {
-  init_values,
-  isValueOf
-} from "./chunk-CAGDE6PT.js";
-import {
-  init_morph,
-  pathsExtent
-} from "./chunk-POXV7LS3.js";
-import {
-  init_shader_params,
-  paramComponent,
-  paramComponents,
-  paramLabel,
-  reflectShader,
-  withParamComponent
-} from "./chunk-D3K35HSL.js";
-import {
-  init_scene3d,
-  is3DContext
-} from "./chunk-MF4NUZBE.js";
-import {
-  has3DPlacement,
-  init_transform3d
-} from "./chunk-7ECF2YL5.js";
-import {
-  init_define_POPCRAFT_COMPONENT_IDS
-} from "./chunk-6VMOKHMF.js";
-import {
-  __esm
-} from "./chunk-LJSVREWM.js";
-
-// lib/document/shape-to-path.ts
-function dataFromPoints(points, closed) {
-  const data = [];
-  if (!points.length) return data;
-  data.push("M", points[0].x, points[0].y);
-  const seg = (prev, curr) => {
-    if (prev.handleOut && curr.handleIn) data.push("C", prev.handleOut.x, prev.handleOut.y, curr.handleIn.x, curr.handleIn.y, curr.x, curr.y);
-    else if (prev.handleOut) data.push("Q", prev.handleOut.x, prev.handleOut.y, curr.x, curr.y);
-    else if (curr.handleIn) data.push("Q", curr.handleIn.x, curr.handleIn.y, curr.x, curr.y);
-    else data.push("L", curr.x, curr.y);
-  };
-  for (let i = 1; i < points.length; i++) seg(points[i - 1], points[i]);
-  if (closed) {
-    seg(points[points.length - 1], points[0]);
-    data.push("Z");
-  }
-  return data;
-}
-function polygonCorners(count) {
-  const n = Math.max(3, count || 3);
-  const pts = [];
-  for (let i = 0; i < n; i++) {
-    const a = i / n * Math.PI * 2 - Math.PI / 2;
-    pts.push([Math.cos(a), Math.sin(a)]);
-  }
-  return pts;
-}
-function starCorners(count, inner) {
-  const n = Math.max(3, count || 5);
-  const pts = [];
-  for (let i = 0; i < n * 2; i++) {
-    const a = i / (n * 2) * Math.PI * 2 - Math.PI / 2;
-    const f = i % 2 === 0 ? 1 : inner;
-    pts.push([f * Math.cos(a), f * Math.sin(a)]);
-  }
-  return pts;
-}
-function fitCornersToBox(pts, w, h) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const [x, y] of pts) {
-    minX = Math.min(minX, x);
-    minY = Math.min(minY, y);
-    maxX = Math.max(maxX, x);
-    maxY = Math.max(maxY, y);
-  }
-  const sx = maxX - minX > 1e-6 ? w / (maxX - minX) : 1;
-  const sy = maxY - minY > 1e-6 ? h / (maxY - minY) : 1;
-  return pts.map(([x, y]) => [(x - minX) * sx, (y - minY) * sy]);
-}
-function shapeToVectorPath(node) {
-  const w = Math.max(0, node.width);
-  const h = Math.max(0, node.height);
-  const n = node;
-  const lineTo = (pts) => {
-    const data = [];
-    pts.forEach((p, i) => data.push(i === 0 ? "M" : "L", p.x, p.y));
-    data.push("Z");
-    return { points: pts, closed: true, data };
-  };
-  switch (node.type) {
-    case "RECTANGLE":
-    case "FRAME":
-    case "IMAGE":
-    case "SLICE": {
-      const cr = node.cornerRadius;
-      const raw = Array.isArray(cr) ? [cr[0] || 0, cr[1] || 0, cr[2] || 0, cr[3] || 0] : [cr || 0, cr || 0, cr || 0, cr || 0];
-      const maxR = Math.min(w, h) / 2;
-      const [tl, tr, br, bl] = raw.map((r) => Math.max(0, Math.min(r, maxR)));
-      if (tl < 0.01 && tr < 0.01 && br < 0.01 && bl < 0.01) {
-        return lineTo([
-          { x: 0, y: 0 },
-          { x: w, y: 0 },
-          { x: w, y: h },
-          { x: 0, y: h }
-        ]);
-      }
-      const K = 0.5522847498307936;
-      const pts = [
-        { x: tl, y: 0, handleIn: { x: tl - K * tl, y: 0 } },
-        { x: w - tr, y: 0, handleOut: { x: w - tr + K * tr, y: 0 } },
-        { x: w, y: tr, handleIn: { x: w, y: tr - K * tr } },
-        { x: w, y: h - br, handleOut: { x: w, y: h - br + K * br } },
-        { x: w - br, y: h, handleIn: { x: w - br + K * br, y: h } },
-        { x: bl, y: h, handleOut: { x: bl - K * bl, y: h } },
-        { x: 0, y: h - bl, handleIn: { x: 0, y: h - bl + K * bl } },
-        { x: 0, y: tl, handleOut: { x: 0, y: tl - K * tl } }
-      ];
-      return { points: pts, closed: true, data: dataFromPoints(pts, true) };
-    }
-    case "ELLIPSE": {
-      const cx = w / 2, cy = h / 2, rx = w / 2, ry = h / 2;
-      const k = 0.5522847498307936;
-      const ox = k * rx, oy = k * ry;
-      const pts = [
-        { x: cx, y: 0, handleIn: { x: cx - ox, y: 0 }, handleOut: { x: cx + ox, y: 0 } },
-        // top
-        { x: w, y: cy, handleIn: { x: w, y: cy - oy }, handleOut: { x: w, y: cy + oy } },
-        // right
-        { x: cx, y: h, handleIn: { x: cx + ox, y: h }, handleOut: { x: cx - ox, y: h } },
-        // bottom
-        { x: 0, y: cy, handleIn: { x: 0, y: cy + oy }, handleOut: { x: 0, y: cy - oy } }
-        // left
-      ];
-      const data = ["M", pts[0].x, pts[0].y];
-      for (let i = 0; i < pts.length; i++) {
-        const cur = pts[i], next = pts[(i + 1) % pts.length];
-        data.push("C", cur.handleOut.x, cur.handleOut.y, next.handleIn.x, next.handleIn.y, next.x, next.y);
-      }
-      data.push("Z");
-      return { points: pts, closed: true, data };
-    }
-    // Polygons and stars fill their box, exactly as the GPU draws them (and the export IR traces them).
-    case "POLYGON":
-      return lineTo(fitCornersToBox(polygonCorners(n.pointCount || 3), w, h).map(([x, y]) => ({ x, y })));
-    case "STAR":
-      return lineTo(fitCornersToBox(starCorners(n.pointCount || 5, n.innerRadius ?? 0.4), w, h).map(([x, y]) => ({ x, y })));
-    case "LINE":
-    case "ARROW": {
-      const pts = [{ x: 0, y: 0 }, { x: w, y: 0 }];
-      return { points: pts, closed: false, data: ["M", 0, 0, "L", w, 0] };
-    }
-    default:
-      return null;
-  }
-}
-function canEditAsVector(type) {
-  return type === "VECTOR" || type === "RECTANGLE" || type === "ELLIPSE" || type === "POLYGON" || type === "STAR" || type === "LINE" || type === "ARROW";
-}
-var init_shape_to_path = __esm({
-  "lib/document/shape-to-path.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-  }
-});
-
-// lib/document/trim.ts
-function canTrim(node) {
-  if (!TRIM_TYPES.has(node.type)) return false;
-  const n = node;
-  return n.brushPreset == null && n.stampFill == null && n.arcData == null;
-}
-function trimOf(node) {
-  const t = node.trim;
-  return t && canTrim(node) ? t : void 0;
-}
-function isFullTrim(t) {
-  const spans = trimSpans(t);
-  return spans.length === 1 && spans[0][0] === 0 && spans[0][1] === 1;
-}
-function activeTrim(node) {
-  const t = trimOf(node);
-  return t && !isFullTrim(t) ? t : void 0;
-}
-function trimSpans(t) {
-  let a = clamp01(t.start), b = clamp01(t.end);
-  if (a > b) [a, b] = [b, a];
-  const len = b - a;
-  if (len >= 1 - 1e-6) return [[0, 1]];
-  if (len <= 1e-6) return [];
-  const turns = (Number.isFinite(t.offset) ? t.offset : 0) / 360;
-  let s = a + turns - Math.floor(turns);
-  if (s >= 1) s -= 1;
-  const e = s + len;
-  return e <= 1 ? [[s, e]] : [[s, 1], [0, e - 1]];
-}
-function arcLengths(p) {
-  const cum = [0];
-  for (let i = 2; i < p.length; i += 2) cum.push(cum[cum.length - 1] + Math.hypot(p[i] - p[i - 2], p[i + 1] - p[i - 1]));
-  return cum;
-}
-function slice(p, cum, s0, s1) {
-  const at = (s) => {
-    let lo = 0, hi = cum.length - 1;
-    while (hi - lo > 1) {
-      const mid = lo + hi >> 1;
-      if (cum[mid] <= s) lo = mid;
-      else hi = mid;
-    }
-    const seg = cum[hi] - cum[lo];
-    const k = seg > 1e-9 ? (s - cum[lo]) / seg : 0;
-    return [p[lo * 2] + (p[hi * 2] - p[lo * 2]) * k, p[lo * 2 + 1] + (p[hi * 2 + 1] - p[lo * 2 + 1]) * k];
-  };
-  const out = at(s0);
-  for (let i = 0; i < cum.length; i++) if (cum[i] > s0 && cum[i] < s1) out.push(p[i * 2], p[i * 2 + 1]);
-  out.push(...at(s1));
-  return out;
-}
-function trimOne(p, spans) {
-  const cum = arcLengths(p);
-  const total = cum[cum.length - 1];
-  if (!(total > 0)) return [];
-  if (spans.length === 1 && spans[0][0] === 0 && spans[0][1] === 1) return [p];
-  if (spans.length === 2 && isClosed(p)) return [[...slice(p, cum, spans[0][0] * total, total), ...slice(p, cum, 0, spans[1][1] * total).slice(2)]];
-  return spans.map(([a, b]) => slice(p, cum, a * total, b * total));
-}
-function trimPolylines(polys, t) {
-  const spans = trimSpans(t);
-  if (!spans.length) return [];
-  if (isFullTrim(t)) return polys;
-  if (t.mode !== "SEQUENTIAL" || polys.length < 2) return polys.flatMap((p) => trimOne(p, spans));
-  const cums = polys.map(arcLengths);
-  const total = cums.reduce((sum, c) => sum + c[c.length - 1], 0);
-  if (!(total > 0)) return [];
-  const out = [];
-  for (const [a, b] of spans) {
-    let base = 0;
-    polys.forEach((p, i) => {
-      const len = cums[i][cums[i].length - 1];
-      const s0 = Math.max(a * total, base), s1 = Math.min(b * total, base + len);
-      if (s1 - s0 > 1e-6) out.push(slice(p, cums[i], s0 - base, s1 - base));
-      base += len;
-    });
-  }
-  return out;
-}
-function trimmedShapeAsVector(node) {
-  if (node.type === "VECTOR") return node;
-  let v = shapeVectors.get(node);
-  if (!v) {
-    const path = shapeToVectorPath(node);
-    v = { ...node, type: "VECTOR", paths: [path], fillRule: "NONZERO" };
-    shapeVectors.set(node, v);
-  }
-  return v;
-}
-var TRIM_REST, TRIM_TYPES, clamp01, isClosed, shapeVectors;
-var init_trim = __esm({
-  "lib/document/trim.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-    init_shape_to_path();
-    TRIM_REST = { start: 0, end: 1, offset: 0 };
-    TRIM_TYPES = /* @__PURE__ */ new Set(["VECTOR", "RECTANGLE", "ELLIPSE", "POLYGON", "STAR"]);
-    clamp01 = (v) => Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : 0;
-    isClosed = (p) => p.length > 4 && Math.hypot(p[0] - p[p.length - 2], p[1] - p[p.length - 1]) < 1e-4;
-    shapeVectors = /* @__PURE__ */ new WeakMap();
-  }
-});
-
-// lib/document/effects.ts
-function effectsOf(node, styles) {
-  const n = node;
-  const style = n.effectStyleId && styles?.[n.effectStyleId];
-  if (style && style.type === "EFFECT" && Array.isArray(style.effects)) return style.effects;
-  const own = n.effects ?? [];
-  if (!n.shadows?.length && !n.blurs?.length) return own;
-  return [...own, ...(n.shadows ?? []).map((s) => ({ ...s, type: s.type ?? "DROP_SHADOW" })), ...(n.blurs ?? []).map(blurToEffect)];
-}
-function expandGlass(g) {
-  const rim = g.rim ?? 0.5;
-  return [
-    ...rim > 0 ? [{ type: "INNER_SHADOW", color: { r: 1, g: 1, b: 1, a: 0.9 * rim }, offset: { x: 0, y: 1 }, blur: 1.5, spread: 0, visible: true }] : [],
-    { type: "DROP_SHADOW", color: { r: 0, g: 0, b: 0, a: 0.18 * (g.depth ?? 1) }, offset: { x: 0, y: 6 * (g.depth ?? 1) }, blur: 16 * (g.depth ?? 1), spread: 0, visible: true }
-  ];
-}
-function shadowsOf(node, styles) {
-  const out = [];
-  for (const e of effectsOf(node, styles)) {
-    if (!visible(e)) continue;
-    if (isShadowEffect(e)) out.push(e);
-    else if (e.type === "GLASS") {
-      for (const x of expandGlass(e)) if (isShadowEffect(x)) out.push(x);
-    }
-  }
-  return out;
-}
-function blursOf(node, styles) {
-  const out = [];
-  for (const e of effectsOf(node, styles)) {
-    if (!visible(e)) continue;
-    if (!draws(e)) continue;
-    if (isBlurEffect(e)) out.push({ type: e.type === "BACKGROUND_BLUR" ? "BACKGROUND" : "LAYER", radius: e.radius, visible: true });
-    else if (e.type === "PROGRESSIVE_BLUR") {
-      const { type: _t, visible: _v, ...p } = e;
-      void _t;
-      void _v;
-      out.push({ type: e.target === "BACKGROUND" ? "BACKGROUND" : "LAYER", radius: e.radius, visible: true, progressive: p });
-    } else if (e.type === "MOTION_BLUR") out.push(motionBlurPass(e));
-    else if (e.type === "NOISE") {
-      const { type: _t, visible: _v, ...n } = e;
-      void _t;
-      void _v;
-      out.push({ type: "LAYER", radius: 0, visible: true, noise: n });
-    } else if (e.type === "TEXTURE") {
-      const { type: _t, visible: _v, ...t } = e;
-      void _t;
-      void _v;
-      out.push({ type: "LAYER", radius: 0, visible: true, texture: t });
-    }
-  }
-  return out;
-}
-function normalizeNodeEffects(node) {
-  const n = node;
-  if (n.shadows === void 0 && n.blurs === void 0) return node;
-  const effects = effectsOf(node);
-  const rest = { ...n };
-  delete rest.shadows;
-  delete rest.blurs;
-  return { ...rest, effects };
-}
-function migrateDocumentEffects(doc) {
-  let changed = false;
-  const nodes = { ...doc.nodes };
-  for (const id in nodes) {
-    const next = normalizeNodeEffects(nodes[id]);
-    if (next !== nodes[id]) {
-      nodes[id] = next;
-      changed = true;
-    }
-  }
-  const styles = { ...doc.styles };
-  for (const id in styles) {
-    const st = styles[id];
-    if (st?.type !== "EFFECT" || !st.effects?.some((e) => "effectType" in e || e.type === "LAYER" || e.type === "BACKGROUND")) continue;
-    styles[id] = { ...st, effects: st.effects.map((e) => {
-      const { effectType: effectType2, ...rest } = e;
-      const t = rest.type;
-      if (t === "LAYER" || t === "BACKGROUND") return blurToEffect(rest);
-      if (!t && effectType2) return { ...rest, type: effectType2 };
-      return rest;
-    }) };
-    changed = true;
-  }
-  return changed ? { ...doc, nodes, styles } : doc;
-}
-var visible, draws, blurToEffect, isShadowEffect, isBlurEffect, motionBlurPass, hasEffects, EFFECT_LABELS;
-var init_effects = __esm({
-  "lib/document/effects.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-    visible = (e) => e.visible !== false;
-    draws = (e) => !((isBlurEffect(e) || e.type === "MOTION_BLUR") && !(e.radius > 0));
-    blurToEffect = (b) => ({ type: b.type === "BACKGROUND" ? "BACKGROUND_BLUR" : "LAYER_BLUR", radius: b.radius, visible: b.visible !== false });
-    isShadowEffect = (e) => e.type === "DROP_SHADOW" || e.type === "INNER_SHADOW";
-    isBlurEffect = (e) => e.type === "LAYER_BLUR" || e.type === "BACKGROUND_BLUR";
-    motionBlurPass = (e) => ({ type: "LAYER", radius: e.radius, visible: true, motion: { angle: e.angle } });
-    hasEffects = (node, styles) => effectsOf(node, styles).some((e) => visible(e) && draws(e));
-    EFFECT_LABELS = {
-      DROP_SHADOW: "Drop shadow",
-      INNER_SHADOW: "Inner shadow",
-      LAYER_BLUR: "Layer blur",
-      BACKGROUND_BLUR: "Background blur",
-      PROGRESSIVE_BLUR: "Progressive blur",
-      MOTION_BLUR: "Motion blur",
-      NOISE: "Noise",
-      TEXTURE: "Texture",
-      GLASS: "Glass",
-      HALFTONE: "Halftone"
-    };
-  }
-});
-
-// lib/ai/limits.ts
-function num(v, min, max, fallback) {
-  const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : NaN;
-  return Number.isFinite(n) ? clamp(n, min, max) : clamp(fallback, min, max);
-}
-function str(v, max, fallback = "") {
-  if (typeof v !== "string") return fallback;
-  let s = "";
-  for (const ch of v) {
-    const c = ch.charCodeAt(0);
-    if (c >= 32 ? c !== 127 : c === 9 || c === 10) s += ch;
-  }
-  return s.length > max ? s.slice(0, max) : s;
-}
-var AI_LIMITS, clamp;
-var init_limits = __esm({
-  "lib/ai/limits.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-    AI_LIMITS = {
-      /** Request bodies larger than this are rejected before parsing. */
-      maxBodyBytes: 256e3,
-      maxPromptChars: 2e3,
-      maxStyleHintChars: 400,
-      // Generated designs
-      maxFrames: 6,
-      maxNodesPerFrame: 150,
-      maxTotalNodes: 480,
-      maxDepth: 8,
-      minSize: 1,
-      maxSize: 4e3,
-      maxTextChars: 1200,
-      maxNameChars: 80,
-      minFontSize: 6,
-      maxFontSize: 160,
-      maxSpacing: 400,
-      maxRadius: 1e3,
-      maxStrokeWidth: 40,
-      // Content generation
-      maxTextTargets: 80,
-      maxContextChars: 1500,
-      // Auto-layout suggestions
-      maxLayoutChildren: 60,
-      // Embeddings / search
-      maxEmbedValues: 128,
-      maxEmbedChars: 1e3,
-      maxSearchItems: 2e3,
-      // Images
-      /** Source image for an image action, as a data URL (platform request bodies are capped at ~4.5 MB). */
-      maxSourceImageChars: 4 * 1024 * 1024,
-      /** Selection layers sent as reference images with a prompt. */
-      maxReferenceImages: 4,
-      /** Longest edge each reference is rendered at, in px. */
-      maxReferenceEdgePx: 1024,
-      maxReferenceImageChars: 12e5,
-      /** All references together, leaving room for the prompt and the edit source in one ~4.5 MB body. */
-      maxReferenceTotalChars: 3 * 1024 * 1024,
-      /** Compact document slices sent as context. */
-      maxSliceNodes: 120,
-      maxSliceDepth: 6
-    };
-    clamp = (v, min, max) => Math.min(max, Math.max(min, v));
-  }
-});
-
-// lib/ai/content.ts
-function describeTextTarget(doc, n) {
-  const names = [];
-  let p = n.parentId ? doc.nodes[n.parentId] : void 0;
-  while (p && p.type !== "PAGE" && names.length < 4) {
-    names.unshift(p.name);
-    p = p.parentId ? doc.nodes[p.parentId] : void 0;
-  }
-  const current = str(n.characters ?? "", 400);
-  const charsPerLine = n.textAutoResize === "WIDTH_AND_HEIGHT" ? Math.max(current.length, 8) : Math.max(4, Math.floor(n.width / Math.max(1, n.fontSize * 0.52)));
-  const lines = n.textAutoResize === "NONE" ? Math.max(1, Math.floor(n.height / Math.max(1, n.fontSize * 1.2))) : Math.max(1, current.split("\n").length, Math.round(n.height / Math.max(1, n.fontSize * 1.2)));
-  return {
-    id: n.id,
-    name: str(n.name, AI_LIMITS.maxNameChars),
-    role: inferTextRole(n, names),
-    current,
-    maxChars: Math.max(4, Math.min(AI_LIMITS.maxTextChars, charsPerLine * lines)),
-    path: str(names.join(" / "), 200)
-  };
-}
-function inferTextRole(n, ancestorNames = []) {
-  const hay = `${n.name} ${ancestorNames.slice(-2).join(" ")}`.toLowerCase();
-  const text = (n.characters ?? "").trim();
-  const rules = [
-    [/button|btn|cta/, "button label"],
-    [/price|cost|amount|\$/, "price"],
-    [/e-?mail/, "email address"],
-    [/phone|tel/, "phone number"],
-    [/date|time|day/, "date"],
-    [/name|author|user/, "person name"],
-    [/nav|menu|tab|link/, "navigation label"],
-    [/caption|hint|helper|footnote/, "caption"],
-    [/label|tag|badge|chip/, "label"],
-    [/title|heading|header|headline|h[1-3]\b/, "heading"],
-    [/desc|body|paragraph|copy|subtitle|summary|bio/, "body copy"]
-  ];
-  for (const [re, role] of rules) if (re.test(hay)) return role;
-  if (/^\$?\d[\d,.]*$/.test(text)) return "number";
-  if (n.fontSize >= 24 || n.fontWeight >= 700) return "heading";
-  if (n.fontSize <= 12) return "caption";
-  return text.length > 60 ? "body copy" : "short label";
-}
-function clampSegments(segments, length) {
-  if (!segments?.length) return segments;
-  const out = segments.filter((s) => s.start < length).map((s) => ({ ...s, end: Math.min(s.end, length) })).filter((s) => s.end > s.start);
-  return out.length ? out : void 0;
-}
-function applyContent(doc, targets, items) {
-  const byId = new Map(targets.map((t) => [t.id, t]));
-  const list = Array.isArray(items) ? items : [];
-  let nodes = null;
-  let changed = 0;
-  for (const item of list) {
-    if (!item || typeof item !== "object") continue;
-    const { id, text } = item;
-    if (typeof id !== "string") continue;
-    const target = byId.get(id);
-    const node = doc.nodes[id];
-    if (!target || !isText(node)) continue;
-    const max = Math.min(AI_LIMITS.maxTextChars, Math.max(target.maxChars + 12, Math.ceil(target.maxChars * 1.5)));
-    const next = str(text, max).trim();
-    if (!next || next === node.characters) continue;
-    nodes ??= { ...doc.nodes };
-    nodes[id] = { ...node, characters: next, styledSegments: clampSegments(node.styledSegments, next.length) };
-    byId.delete(id);
-    changed++;
-  }
-  return nodes ? { doc: { ...doc, nodes }, changed } : { doc, changed: 0 };
-}
-var isText;
-var init_content = __esm({
-  "lib/ai/content.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-    init_limits();
-    isText = (n) => !!n && n.type === "TEXT";
-  }
-});
-
-// lib/motion/properties.ts
-function parse(path) {
-  const hit = parsed.get(path);
-  if (hit !== void 0) return hit;
-  if (parsed.size > 4096) parsed.clear();
-  const segments = [];
-  let ok = path.length > 0, bound = true;
-  for (const part of path.split(".")) {
-    const open = part.indexOf("[");
-    const name = open < 0 ? part : part.slice(0, open);
-    if (!NAME.test(name)) {
-      ok = false;
-      break;
-    }
-    if (open < 0) {
-      segments.push({ name });
-      continue;
-    }
-    if (!part.endsWith("]")) {
-      ok = false;
-      break;
-    }
-    const ref = part.slice(open + 1, -1);
-    if (ref.startsWith("@") && SAFE_ID.test(ref.slice(1))) segments.push({ name, id: ref.slice(1) });
-    else if (ref.startsWith("#") && /^\d+$/.test(ref.slice(1))) {
-      segments.push({ name, index: Number(ref.slice(1)) });
-      bound = false;
-    } else {
-      ok = false;
-      break;
-    }
-  }
-  const out = ok ? { segments, pattern: segments.map((s) => s.id !== void 0 || s.index !== void 0 ? `${s.name}[@]` : s.name).join("."), bound } : null;
-  parsed.set(path, out);
-  return out;
-}
-function itemIndex(list, seg) {
-  if (!Array.isArray(list)) return -1;
-  if (seg.index !== void 0) return seg.index < list.length ? seg.index : -1;
-  return list.findIndex((it) => isObj(it) && it.id === seg.id);
-}
-function readAt(root, segments, end = segments.length) {
-  let cur = root;
-  for (let i = 0; i < end; i++) {
-    if (!isObj(cur)) return void 0;
-    const seg = segments[i];
-    const v = cur[seg.name];
-    if (seg.id === void 0 && seg.index === void 0) {
-      cur = v;
-      continue;
-    }
-    const idx = itemIndex(v, seg);
-    cur = idx < 0 ? void 0 : v[idx];
-  }
-  return cur;
-}
-function writeAt(root, segments, i, value, parentDefault) {
-  const seg = segments[i];
-  const last = i === segments.length - 1;
-  const child = root[seg.name];
-  if (seg.id === void 0 && seg.index === void 0) {
-    if (last) return root[seg.name] === value ? root : { ...root, [seg.name]: value };
-    const base = isObj(child) ? child : i === segments.length - 2 && parentDefault ? parentDefault : null;
-    if (!base) return root;
-    const next = writeAt(base, segments, i + 1, value, parentDefault);
-    return next === child ? root : { ...root, [seg.name]: next };
-  }
-  const idx = itemIndex(child, seg);
-  if (idx < 0) return root;
-  const list = child;
-  const item = list[idx];
-  const nextItem = last ? value : isObj(item) ? writeAt(item, segments, i + 1, value, parentDefault) : item;
-  if (nextItem === item) return root;
-  const nextList = list.slice();
-  nextList[idx] = nextItem;
-  return { ...root, [seg.name]: nextList };
-}
-function nodeProp(key, label, c) {
-  const path = asPath(key);
-  const read = c.read ?? ((n) => {
-    const v = readAt(n, parse(key).segments);
-    return isValueOf(c.valueType, v) ? v : c.restDefault;
-  });
-  const applies = (n, parent) => animatable(n) && (c.appliesTo ? c.appliesTo(n, parent) : read(n) !== void 0);
-  return {
-    pattern: key,
-    valueType: c.valueType,
-    group: c.group,
-    control: c.control,
-    layoutAffecting: c.layoutAffecting,
-    essential: c.essential,
-    restDefault: c.restDefault,
-    field: (!c.write || c.plainWrite) && NAME.test(key) ? key : void 0,
-    interpolation: c.valueType === "number" || c.valueType === "color" || c.valueType === "path" ? "continuous" : "discrete",
-    label: () => label,
-    appliesTo: applies,
-    enumerate: (n, p) => applies(n, p) ? [path] : [],
-    read: (n) => read(n),
-    write: (n, _p, v) => {
-      if (!isValueOf(c.valueType, v)) return n;
-      if (c.write) return c.write(n, v);
-      return writeAt(n, parse(key).segments, 0, v);
-    }
-  };
-}
-function storeSegments(spec, path) {
-  const segs = parse(path)?.segments;
-  if (!segs || !spec.head) return segs;
-  const headLen = spec.head.split(".").length;
-  if (segs.length <= headLen) return void 0;
-  return [{ ...segs[headLen - 1], name: spec.list }, ...segs.slice(headLen)];
-}
-function itemProp(spec, field, label, c) {
-  const head = spec.head ?? spec.list;
-  const pattern = c.sub ? `${head}[@].${c.sub.list}[@].${field}` : `${head}[@].${field}`;
-  const listSegs = parse(spec.list).segments;
-  const listDepth = listSegs.length;
-  const itemOf = (n, segs) => readAt(n, segs, listDepth);
-  const readPath2 = (n, path) => {
-    const segs = storeSegments(spec, path);
-    if (!segs) return void 0;
-    const item = itemOf(n, segs);
-    if (!isObj(item) || !c.accepts(item)) return void 0;
-    const depth = listDepth - 1 + (c.sub ? 2 : 1);
-    const v = readAt(n, segs);
-    if (isValueOf(c.valueType, v)) return v;
-    if (!c.defaultOf) return void 0;
-    const parent = readAt(n, segs, segs.length - 1);
-    return isObj(parent) || c.parentDefault && segs.length - 1 > depth ? c.defaultOf(item) : void 0;
-  };
-  const listOf = (n) => readAt(n, listSegs);
-  const list = (n) => {
-    const l = listOf(n);
-    return Array.isArray(l) ? l.filter(isObj) : [];
-  };
-  return {
-    pattern,
-    valueType: c.valueType,
-    group: c.group,
-    control: c.control,
-    layoutAffecting: c.layoutAffecting,
-    essential: c.essential,
-    interpolation: c.valueType === "number" || c.valueType === "color" ? "continuous" : "discrete",
-    label: (n, path) => {
-      const segs = storeSegments(spec, path);
-      const items = list(n);
-      const i = segs ? itemIndex(items, segs[listDepth - 1]) : -1;
-      const head2 = i >= 0 ? spec.itemLabel(items[i], i, items) : spec.itemLabel({}, 0, []);
-      if (!c.sub || !segs) return `${head2} \xB7 ${label}`;
-      const sub = readAt(n, segs, listDepth);
-      const j = isObj(sub) ? itemIndex(sub[c.sub.list], segs[listDepth]) : -1;
-      return `${head2} \xB7 ${c.sub.label(Math.max(0, j))} \xB7 ${label}`;
-    },
-    appliesTo: (n) => animatable(n) && list(n).some(c.accepts),
-    enumerate: (n) => {
-      if (!animatable(n)) return [];
-      const out = [];
-      const items = listOf(n);
-      if (!Array.isArray(items)) return out;
-      items.forEach((item, i) => {
-        if (!isObj(item) || !c.accepts(item)) return;
-        const at = `${head}[${itemRef(item, i)}]`;
-        if (c.sub) {
-          const subs = item[c.sub.list];
-          if (Array.isArray(subs)) subs.forEach((s, j) => {
-            const p2 = asPath(`${at}.${c.sub.list}[${itemRef(s, j)}].${field}`);
-            if (readPath2(n, p2) !== void 0) out.push(p2);
-          });
-          return;
-        }
-        const p = asPath(`${at}.${field}`);
-        if (readPath2(n, p) !== void 0) out.push(p);
-      });
-      return out;
-    },
-    read: readPath2,
-    write: (n, path, v) => {
-      const segs = storeSegments(spec, path);
-      if (!segs || !isValueOf(c.valueType, v)) return n;
-      const item = itemOf(n, segs);
-      if (!isObj(item) || !c.accepts(item)) return n;
-      return writeAt(n, segs, 0, v, c.parentDefault);
-    }
-  };
-}
-function shaderParamProp() {
-  const resolve = (n, path) => {
-    const segs = parse(path)?.segments;
-    if (!segs || segs.length < 3 || segs.length > 4 || segs[0].name !== "fills" || segs[1].name !== "shaderParams") return void 0;
-    const fill = readAt(n, segs, 1);
-    if (!isObj(fill) || fill.type !== "SHADER" || typeof fill.shaderCode !== "string") return void 0;
-    const param = reflectShader(fill.shaderCode).params.find((p) => p.name === segs[2].name);
-    const component = segs[3]?.name;
-    if (!param || component === void 0 !== (param.type === "f32") || component !== void 0 && !paramComponents(param).includes(component)) return void 0;
-    return { fill, param, component, segs };
-  };
-  const shaderFills = (n) => {
-    const l = fieldOf(n, "fills");
-    return Array.isArray(l) ? l.filter((it) => isObj(it) && it.type === "SHADER" && typeof it.shaderCode === "string") : [];
-  };
-  return {
-    pattern: SHADER_PARAM_PATTERN,
-    valueType: "number",
-    group: "Fill",
-    control: { kind: "number", step: 0.01 },
-    interpolation: "continuous",
-    label: (n, path) => {
-      const r = resolve(n, path);
-      const fills = fieldOf(n, "fills");
-      const i = r && Array.isArray(fills) ? itemIndex(fills, r.segs[0]) : -1;
-      const segs = parse(path)?.segments;
-      const name = paramLabel(segs?.[2]?.name ?? "param");
-      const comp = segs?.[3] ? ` ${COMPONENT_LABEL[segs[3].name] ?? segs[3].name}` : "";
-      return `${FILLS.itemLabel({}, Math.max(0, i), [])} \xB7 ${name}${comp}`;
-    },
-    appliesTo: (n) => animatable(n) && shaderFills(n).some((f) => reflectShader(f.shaderCode).params.length > 0),
-    enumerate: (n) => {
-      if (!animatable(n)) return [];
-      const fills = fieldOf(n, "fills");
-      if (!Array.isArray(fills)) return [];
-      const out = [];
-      fills.forEach((fill, i) => {
-        if (!isObj(fill) || fill.type !== "SHADER" || typeof fill.shaderCode !== "string") return;
-        const at = `fills[${itemRef(fill, i)}].shaderParams`;
-        for (const p of reflectShader(fill.shaderCode).params) {
-          const comps = paramComponents(p);
-          if (!comps.length) out.push(asPath(`${at}.${p.name}`));
-          else for (const c of comps) out.push(asPath(`${at}.${p.name}.${c}`));
-        }
-      });
-      return out;
-    },
-    read: (n, path) => {
-      const r = resolve(n, path);
-      return r ? paramComponent(r.param, r.fill.shaderParams, r.component) : void 0;
-    },
-    write: (n, path, v) => {
-      const r = resolve(n, path);
-      if (!r || !isValueOf("number", v) || paramComponent(r.param, r.fill.shaderParams, r.component) === v) return n;
-      const shaderParams = withParamComponent(r.param, r.fill.shaderParams, r.component, v);
-      return writeAt(n, r.segs.slice(0, 2), 0, shaderParams);
-    }
-  };
-}
-function effectProp(field, label, valueType, control, types, parentDefault) {
-  return itemProp(EFFECTS, field, label, {
-    valueType,
-    group: "Effects",
-    control,
-    parentDefault,
-    accepts: effectType(...Object.keys(types)),
-    defaultOf: (item) => types[item.type] ?? void 0
-  });
-}
-function propertyFor(path) {
-  const pattern = patternOf(path);
-  if (pattern === void 0) return void 0;
-  return byPattern.get(pattern) ?? (SHADER_PARAM_PATH.test(pattern) ? byPattern.get(SHADER_PARAM_PATTERN) : void 0);
-}
-function propertiesOf(node, parent) {
-  const out = [];
-  for (const prop of REGISTRY) {
-    if (!prop.appliesTo(node, parent)) continue;
-    for (const path of prop.enumerate(node, parent)) out.push({ prop, path });
-  }
-  return out;
-}
-function readPath(node, path) {
-  return propertyFor(path)?.read(node, path);
-}
-function writePath(node, path, v) {
-  const prop = propertyFor(path);
-  return prop ? prop.write(node, path, v) : node;
-}
-function freshId(name, list) {
-  const used = new Set(list.map((it) => isObj(it) ? it.id : void 0));
-  const prefix = ID_PREFIX[name] ?? "i";
-  for (let n = 1; ; n++) if (!used.has(`${prefix}${n}`)) return `${prefix}${n}`;
-}
-function bindPath(node, path) {
-  const p = parse(path);
-  const prop = propertyFor(path);
-  if (!p || !prop || prop.read(node, path) === void 0) return null;
-  if (p.bound) return { node, path };
-  let root = node;
-  const segs = p.segments.map((s) => ({ ...s }));
-  const bind = (obj, i) => {
-    if (i >= segs.length) return obj;
-    const seg = segs[i];
-    const child = obj[seg.name];
-    if (seg.id === void 0 && seg.index === void 0) {
-      if (i === segs.length - 1) return obj;
-      if (!isObj(child)) return obj;
-      const next = bind(child, i + 1);
-      return next === null ? null : next === child ? obj : { ...obj, [seg.name]: next };
-    }
-    const idx = itemIndex(child, seg);
-    if (idx < 0) return null;
-    const list = child;
-    const found = list[idx];
-    if (!isObj(found)) return null;
-    const item = typeof found.id === "string" && SAFE_ID.test(found.id) ? found : { ...found, id: freshId(seg.name, list) };
-    segs[i] = { name: seg.name, id: item.id };
-    const nextItem = bind(item, i + 1);
-    if (nextItem === null) return null;
-    if (nextItem === list[idx]) return obj;
-    const nextList = list.slice();
-    nextList[idx] = nextItem;
-    return { ...obj, [seg.name]: nextList };
-  };
-  const bound = bind(root, 0);
-  if (!bound) return null;
-  root = bound;
-  return { node: root, path: asPath(segs.map((s) => s.id !== void 0 ? `${s.name}[@${s.id}]` : s.name).join(".")) };
-}
-var SAFE_ID, NAME, parsed, asPath, pathSegments, patternOf, isBoundPath, isObj, PAGE_TYPES, animatable, fieldOf, FILLS, UNIT_LABEL, TEXT_ANIMATORS, STROKES, LIGHT_NAMES, LIGHTS, EFFECTS, itemRef, SHADER_PARAM_PATTERN, SHADER_PARAM_PATH, COMPONENT_LABEL, px, size, angle, percent, unbounded, color, T, A, inFlow, num2, effectType, SHADOWS, in3D, materialProp, trimProp, cameraProp, poiRest, lightProp, POSITIONED, AIMED, BLACK, CLEAR, GRADIENTS, HALFTONE_BAND_KEYS, REGISTRY, byPattern, ANIMATABLE_PROPERTIES, ID_PREFIX;
-var init_properties = __esm({
-  "lib/motion/properties.ts"() {
-    init_define_POPCRAFT_COMPONENT_IDS();
-    init_trim();
-    init_morph();
-    init_effects();
-    init_scene3d();
-    init_transform3d();
-    init_shader_params();
-    init_content();
-    init_text_units();
-    init_values();
-    SAFE_ID = /^[\w-]+$/;
-    NAME = /^[A-Za-z_]\w*$/;
-    parsed = /* @__PURE__ */ new Map();
-    asPath = (s) => s;
-    pathSegments = (path) => parse(path)?.segments;
-    patternOf = (path) => parse(path)?.pattern;
-    isBoundPath = (path) => !!parse(path)?.bound;
-    isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-    PAGE_TYPES = /* @__PURE__ */ new Set(["PAGE"]);
-    animatable = (n) => !PAGE_TYPES.has(n.type);
-    fieldOf = (n, key) => n[key];
-    FILLS = { list: "fills", itemLabel: (_it, i) => `Fill ${i + 1}` };
-    UNIT_LABEL = { letter: "Letters", word: "Words", line: "Lines" };
-    TEXT_ANIMATORS = {
-      list: "textAnimators",
-      head: "text.animators",
-      itemLabel: (it, i) => typeof it.name === "string" && it.name ? it.name : `${UNIT_LABEL[it.unit] ?? "Animator"} ${i + 1}`
-    };
-    STROKES = { list: "strokes", itemLabel: (_it, i) => `Stroke ${i + 1}` };
-    LIGHT_NAMES = { AMBIENT: "Ambient light", DIRECTIONAL: "Directional light", POINT: "Point light", SPOT: "Spot light" };
-    LIGHTS = {
-      list: "scene3d.lights",
-      itemLabel: (it, i, list) => {
-        if (typeof it.name === "string" && it.name) return it.name;
-        const name = LIGHT_NAMES[it.type] ?? "Light";
-        const same = list.filter((l) => l.type === it.type);
-        return same.length > 1 ? `${name} ${same.indexOf(list[i]) + 1}` : name;
-      }
-    };
-    EFFECTS = {
-      list: "effects",
-      itemLabel: (it, i, list) => {
-        const type = it.type;
-        const same = list.filter((e) => e.type === type);
-        const name = EFFECT_LABELS[type] ?? "Effect";
-        return same.length > 1 ? `${name} ${same.indexOf(list[i]) + 1}` : name;
-      }
-    };
-    itemRef = (item, index) => isObj(item) && typeof item.id === "string" && SAFE_ID.test(item.id) ? `@${item.id}` : `#${index}`;
-    SHADER_PARAM_PATTERN = "fills[@].shaderParams.*";
-    SHADER_PARAM_PATH = /^fills\[@\]\.shaderParams\.[A-Za-z_]\w*(?:\.[xyzrgba])?$/;
-    COMPONENT_LABEL = { x: "X", y: "Y", z: "Z", r: "R", g: "G", b: "B", a: "A" };
-    px = { kind: "number", unit: "px" };
-    size = { kind: "number", unit: "px", min: 0 };
-    angle = { kind: "angle", unit: "\xB0" };
-    percent = { kind: "percent", min: 0, max: 1, step: 0.01 };
-    unbounded = { kind: "percent", step: 0.01 };
-    color = { kind: "color" };
-    T = "Transform";
-    A = "Appearance";
-    inFlow = (n, parent) => {
-      const mode = parent ? fieldOf(parent, "layoutMode") : void 0;
-      return !!mode && mode !== "NONE" && fieldOf(n, "layoutPositioning") !== "ABSOLUTE";
-    };
-    num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
-    effectType = (...types) => {
-      const set = new Set(types);
-      return (item) => set.has(item.type);
-    };
-    SHADOWS = effectType("DROP_SHADOW", "INNER_SHADOW");
-    in3D = (n, parent) => has3DPlacement(n) || !!parent && (is3DContext(parent) || parent.type === "GROUP" && has3DPlacement(parent));
-    materialProp = (key, label, control, restDefault) => nodeProp(`material3d.${key}`, label, {
-      valueType: "number",
-      group: "3D",
-      control,
-      restDefault,
-      appliesTo: in3D,
-      write: (n, v) => {
-        const m = n.material3d;
-        return m?.[key] === v ? n : { ...n, material3d: { ...m, [key]: v } };
-      }
-    });
-    trimProp = (key, label, control, restDefault) => nodeProp(`trim.${key}`, label, {
-      valueType: "number",
-      group: "Stroke",
-      control,
-      restDefault,
-      appliesTo: (n) => canTrim(n) && Array.isArray(fieldOf(n, "strokes")) && fieldOf(n, "strokes").length > 0,
-      write: (n, v) => {
-        const t = n.trim;
-        return t?.[key] === v ? n : { ...n, trim: { ...TRIM_REST, ...t, [key]: v } };
-      }
-    });
-    cameraProp = (key, label, control, restDefault, read) => nodeProp(`scene3d.camera.${key}`, label, { valueType: "number", group: "Camera", control, restDefault, appliesTo: is3DContext, read });
-    poiRest = (axis) => (n) => {
-      const s = n.scene3d;
-      if (!s?.camera) return void 0;
-      const v = num2(s.camera[`poi${axis}`]);
-      if (v !== void 0) return v;
-      return axis === "X" ? (num2(s.originX) ?? 0.5) * n.width : axis === "Y" ? (num2(s.originY) ?? 0.5) * n.height : 0;
-    };
-    lightProp = (field, label, control, types, defaultOf) => itemProp(LIGHTS, field, label, { valueType: "number", group: "Lights", control, accepts: (it) => types.includes(it.type), defaultOf });
-    POSITIONED = ["DIRECTIONAL", "POINT", "SPOT"];
-    AIMED = ["DIRECTIONAL", "SPOT"];
-    BLACK = { r: 0, g: 0, b: 0, a: 1 };
-    CLEAR = { r: 0, g: 0, b: 0, a: 0 };
-    GRADIENTS = /* @__PURE__ */ new Set(["GRADIENT_LINEAR", "GRADIENT_RADIAL", "GRADIENT_ANGULAR", "GRADIENT_DIAMOND"]);
-    HALFTONE_BAND_KEYS = ["light", "mid", "dark"];
-    REGISTRY = [
-      // Transform
-      nodeProp("x", "X", { valueType: "number", group: T, control: px, essential: true, appliesTo: (n, p) => !inFlow(n, p) }),
-      nodeProp("y", "Y", { valueType: "number", group: T, control: px, essential: true, appliesTo: (n, p) => !inFlow(n, p) }),
-      nodeProp("width", "Width", { valueType: "number", group: T, control: size, essential: true, layoutAffecting: true }),
-      nodeProp("height", "Height", { valueType: "number", group: T, control: size, essential: true, layoutAffecting: true }),
-      nodeProp("rotation", "Rotation", { valueType: "number", group: T, control: angle, essential: true, restDefault: 0 }),
-      nodeProp("scaleX", "Scale X", { valueType: "number", group: T, control: unbounded, restDefault: 1 }),
-      nodeProp("scaleY", "Scale Y", { valueType: "number", group: T, control: unbounded, restDefault: 1 }),
-      nodeProp("anchorX", "Anchor X", { valueType: "number", group: T, control: unbounded, restDefault: 0.5 }),
-      nodeProp("anchorY", "Anchor Y", { valueType: "number", group: T, control: unbounded, restDefault: 0.5 }),
-      nodeProp("translateX", "Offset X", { valueType: "number", group: T, control: px, restDefault: 0 }),
-      nodeProp("translateY", "Offset Y", { valueType: "number", group: T, control: px, restDefault: 0 }),
-      // 3D: a layer of a 3D context (lib/document/scene3d.ts). `rotation` is its turn about the view axis (rotateZ).
-      nodeProp("rotateX", "Rotate X", { valueType: "number", group: "3D", control: angle, restDefault: 0, appliesTo: in3D }),
-      nodeProp("rotateY", "Rotate Y", { valueType: "number", group: "3D", control: angle, restDefault: 0, appliesTo: in3D }),
-      nodeProp("z", "Z", { valueType: "number", group: "3D", control: px, restDefault: 0, appliesTo: in3D }),
-      materialProp("ambient", "Ambient", { kind: "percent", min: 0, step: 0.01 }, 1),
-      materialProp("diffuse", "Diffuse", { kind: "percent", min: 0, step: 0.01 }, 1),
-      materialProp("specular", "Specular", { kind: "percent", min: 0, step: 0.01 }, 0),
-      materialProp("shininess", "Shininess", { kind: "number", min: 1, max: 512, step: 1 }, 24),
-      // The camera of a 3D context. Focal length is the truth; the zoom distance and field of view are derived.
-      cameraProp("focalLength", "Focal length", { kind: "number", unit: "mm", min: 1, max: 1e3, step: 1 }, 50),
-      cameraProp("x", "Camera X", px, 0),
-      cameraProp("y", "Camera Y", px, 0),
-      cameraProp("z", "Camera Z", px, 0),
-      cameraProp("orbit", "Orbit", angle, 0),
-      cameraProp("rotateX", "Tilt", angle, 0),
-      cameraProp("rotateY", "Pan", angle, 0),
-      cameraProp("roll", "Roll", angle, 0),
-      cameraProp("poiX", "Point of interest X", px, 0, poiRest("X")),
-      cameraProp("poiY", "Point of interest Y", px, 0, poiRest("Y")),
-      cameraProp("poiZ", "Point of interest Z", px, 0, poiRest("Z")),
-      // Lights of a 3D context, each addressed by its id.
-      itemProp(LIGHTS, "color", "Color", { valueType: "color", group: "Lights", control: color, accepts: () => true }),
-      lightProp("intensity", "Intensity", { kind: "percent", min: 0, step: 0.01 }, ["AMBIENT", ...POSITIONED]),
-      lightProp("x", "X", px, POSITIONED),
-      lightProp("y", "Y", px, POSITIONED),
-      lightProp("z", "Z", px, POSITIONED),
-      lightProp("targetX", "Target X", px, AIMED),
-      lightProp("targetY", "Target Y", px, AIMED),
-      lightProp("targetZ", "Target Z", px, AIMED),
-      lightProp("coneAngle", "Cone angle", { kind: "angle", unit: "\xB0", min: 1, max: 179 }, ["SPOT"], () => 60),
-      lightProp("coneFeather", "Cone feather", percent, ["SPOT"], () => 0.5),
-      // Appearance
-      nodeProp("opacity", "Opacity", { valueType: "number", group: A, control: percent, essential: true, restDefault: 1 }),
-      nodeProp("cornerRadius", "Corner radius", {
-        valueType: "number",
-        group: A,
-        control: size,
-        essential: true,
-        appliesTo: (n) => "cornerRadius" in n,
-        // Every corner at once: a per-corner radius reads as its first corner and is written uniform.
-        read: (n) => {
-          const r = fieldOf(n, "cornerRadius");
-          return num2(r) ?? (Array.isArray(r) ? num2(r[0]) : void 0) ?? ("cornerRadius" in n ? 0 : void 0);
-        },
-        write: (n, v) => fieldOf(n, "cornerRadius") === v ? n : { ...n, cornerRadius: v },
-        plainWrite: true
-      }),
-      // Path: a vector's outline, morphing between keys. Its box follows the outline (the paths' extent from its origin).
-      nodeProp("paths", "Path", {
-        valueType: "path",
-        group: "Path",
-        control: { kind: "path" },
-        appliesTo: (n) => n.type === "VECTOR" && fieldOf(n, "brushPreset") == null && fieldOf(n, "stampFill") == null && fieldOf(n, "strokePoints") == null,
-        write: (n, v) => {
-          if (fieldOf(n, "paths") === v) return n;
-          const { width, height } = pathsExtent(v);
-          return { ...n, paths: v, width, height };
-        }
-      }),
-      // Fill
-      itemProp(FILLS, "color", "Color", { valueType: "color", group: "Fill", control: color, essential: true, accepts: (it) => it.type === "SOLID" }),
-      itemProp(FILLS, "opacity", "Opacity", { valueType: "number", group: "Fill", control: percent, accepts: () => true, defaultOf: () => 1 }),
-      // A picture's address, swapped whole: what an IMAGE component property feeds (a product card's photo).
-      itemProp(FILLS, "imageUrl", "Picture", { valueType: "string", group: "Fill", control: { kind: "text" }, accepts: (it) => it.type === "IMAGE" }),
-      nodeProp("imageUrl", "Picture", { valueType: "string", group: "Fill", control: { kind: "text" }, appliesTo: (n) => n.type === "IMAGE" }),
-      itemProp(FILLS, "color", "Color", { valueType: "color", group: "Fill", control: color, accepts: (it) => GRADIENTS.has(it.type), sub: { list: "gradientStops", label: (j) => `Stop ${j + 1}` } }),
-      itemProp(FILLS, "position", "Position", { valueType: "number", group: "Fill", control: percent, accepts: (it) => GRADIENTS.has(it.type), sub: { list: "gradientStops", label: (j) => `Stop ${j + 1}` } }),
-      shaderParamProp(),
-      // Stroke
-      itemProp(STROKES, "color", "Color", { valueType: "color", group: "Stroke", control: color, accepts: () => true }),
-      // Weight: a per-side width reads as its first side and is written uniform.
-      itemProp(STROKES, "width", "Weight", { valueType: "number", group: "Stroke", control: size, accepts: () => true, defaultOf: (it) => Array.isArray(it.width) ? num2(it.width[0]) : void 0 }),
-      trimProp("start", "Trim start", percent, 0),
-      trimProp("end", "Trim end", percent, 1),
-      trimProp("offset", "Trim offset", angle, 0),
-      // Effects: every numeric and colour field of every effect type (lib/document/types.ts `Effect`).
-      itemProp(EFFECTS, "color", "Color", { valueType: "color", group: "Effects", control: color, accepts: SHADOWS }),
-      itemProp(EFFECTS, "offset.x", "X offset", { valueType: "number", group: "Effects", control: px, accepts: SHADOWS }),
-      itemProp(EFFECTS, "offset.y", "Y offset", { valueType: "number", group: "Effects", control: px, accepts: SHADOWS }),
-      itemProp(EFFECTS, "blur", "Blur", { valueType: "number", group: "Effects", control: size, accepts: SHADOWS }),
-      itemProp(EFFECTS, "spread", "Spread", { valueType: "number", group: "Effects", control: px, accepts: SHADOWS }),
-      effectProp("radius", "Radius", "number", size, { LAYER_BLUR: null, BACKGROUND_BLUR: null, PROGRESSIVE_BLUR: null, MOTION_BLUR: null, GLASS: null }),
-      effectProp("angle", "Angle", "number", angle, { PROGRESSIVE_BLUR: null, MOTION_BLUR: null, HALFTONE: 45 }),
-      effectProp("start", "Start", "number", percent, { PROGRESSIVE_BLUR: null }),
-      effectProp("end", "End", "number", percent, { PROGRESSIVE_BLUR: null }),
-      effectProp("amount", "Amount", "number", percent, { NOISE: null }),
-      effectProp("size", "Size", "number", size, { NOISE: null }),
-      effectProp("density", "Density", "number", percent, { NOISE: 1 }),
-      effectProp("colorA", "Color A", "color", color, { NOISE: null, TEXTURE: null }),
-      effectProp("colorB", "Color B", "color", color, { NOISE: null, TEXTURE: null }),
-      effectProp("scale", "Scale", "number", { kind: "number", min: 0 }, { TEXTURE: null }),
-      effectProp("contrast", "Contrast", "number", { kind: "number", min: 0, max: 3, step: 0.01 }, { TEXTURE: null, HALFTONE: 1 }),
-      effectProp("opacity", "Opacity", "number", percent, { TEXTURE: null }),
-      // The grain's and the texture's offset into their noise: keyed, it boils (film grain) or drifts.
-      effectProp("seed", "Seed", "number", { kind: "number", min: 0, step: 1 }, { NOISE: null, TEXTURE: null }),
-      effectProp("refraction", "Refraction", "number", size, { GLASS: 12 }),
-      effectProp("dispersion", "Dispersion", "number", percent, { GLASS: 0.3 }),
-      effectProp("rim", "Rim", "number", percent, { GLASS: 0.5 }),
-      effectProp("depth", "Depth", "number", { kind: "number", min: 0, max: 2, step: 0.01 }, { GLASS: 1 }),
-      effectProp("dotSize", "Dot size", "number", size, { HALFTONE: 4 }),
-      effectProp("gradientAngle", "Gradient angle", "number", angle, { HALFTONE: 0 }),
-      effectProp("center.x", "Center X", "number", unbounded, { HALFTONE: 0.5 }, { x: 0.5, y: 0.5 }),
-      effectProp("center.y", "Center Y", "number", unbounded, { HALFTONE: 0.5 }, { x: 0.5, y: 0.5 }),
-      effectProp("color1", "Ink", "color", color, { HALFTONE: BLACK }),
-      effectProp("color2", "Paper", "color", color, { HALFTONE: CLEAR }),
-      effectProp("bands.midStart", "Mid tones from", "number", percent, { HALFTONE: null }),
-      effectProp("bands.darkStart", "Dark tones from", "number", percent, { HALFTONE: null }),
-      ...HALFTONE_BAND_KEYS.flatMap((b) => {
-        const name = b[0].toUpperCase() + b.slice(1);
-        return [
-          effectProp(`bands.${b}.color`, `${name} color`, "color", color, { HALFTONE: null }),
-          effectProp(`bands.${b}.scale`, `${name} dot scale`, "number", { kind: "number", min: 0, step: 0.01 }, { HALFTONE: 1 })
-        ];
-      }),
-      // Text: the characters, swapped whole (discrete). Style runs past the new end are trimmed. A counting text's
-      // characters are its counter's.
-      nodeProp("text.content", "Text", {
-        valueType: "string",
-        group: "Text",
-        control: { kind: "text" },
-        layoutAffecting: true,
-        appliesTo: (n) => n.type === "TEXT" && !n.threadPrevId && !n.textCounter,
-        read: (n) => n.type === "TEXT" ? n.characters ?? "" : void 0,
-        write: (n, v) => {
-          const t = n;
-          if (n.type !== "TEXT" || t.characters === v) return n;
-          const styledSegments = clampSegments(t.styledSegments, v.length);
-          return { ...t, characters: v, ...t.styledSegments ? { styledSegments } : {} };
-        }
-      }),
-      // A counter's value: the text shows it formatted (lib/motion/text-units.ts `formatCounter`).
-      nodeProp("text.counter", "Counter", {
-        valueType: "number",
-        group: "Text",
-        control: { kind: "number", step: 1 },
-        layoutAffecting: true,
-        appliesTo: (n) => n.type === "TEXT" && !!n.textCounter,
-        read: (n) => {
-          const c = n.type === "TEXT" ? n.textCounter : void 0;
-          return c ? counterRest(c) : void 0;
-        },
-        write: (n, v) => {
-          const t = n;
-          const c = t.textCounter;
-          if (n.type !== "TEXT" || !c || counterRest(c) === v) return n;
-          const characters = formatCounter(c, v);
-          const styledSegments = clampSegments(t.styledSegments, characters.length);
-          const { value: _was, ...rest } = c;
-          void _was;
-          return { ...t, characters, textCounter: v === c.to ? rest : { ...rest, value: v }, ...t.styledSegments ? { styledSegments } : {} };
-        }
-      }),
-      // Text animators (lib/motion/text-animators.ts): each one's range, amount and the props it moves units by.
-      ...[["range.start", "Range start"], ["range.end", "Range end"], ["range.offset", "Range offset"]].map(([f, label]) => itemProp(TEXT_ANIMATORS, f, label, { valueType: "number", group: "Text animators", control: unbounded, accepts: () => true })),
-      itemProp(TEXT_ANIMATORS, "amount", "Amount", { valueType: "number", group: "Text animators", control: percent, accepts: () => true, defaultOf: () => 1 }),
-      itemProp(TEXT_ANIMATORS, "props.translateX", "Offset X", { valueType: "number", group: "Text animators", control: px, accepts: () => true }),
-      itemProp(TEXT_ANIMATORS, "props.translateY", "Offset Y", { valueType: "number", group: "Text animators", control: px, accepts: () => true }),
-      itemProp(TEXT_ANIMATORS, "props.scale", "Scale", { valueType: "number", group: "Text animators", control: unbounded, accepts: () => true }),
-      itemProp(TEXT_ANIMATORS, "props.rotation", "Rotation", { valueType: "number", group: "Text animators", control: angle, accepts: () => true }),
-      itemProp(TEXT_ANIMATORS, "props.opacity", "Opacity", { valueType: "number", group: "Text animators", control: percent, accepts: () => true }),
-      itemProp(TEXT_ANIMATORS, "props.blur", "Blur", { valueType: "number", group: "Text animators", control: size, accepts: () => true }),
-      itemProp(TEXT_ANIMATORS, "props.color", "Tint", { valueType: "color", group: "Text animators", control: color, accepts: () => true })
-    ];
-    byPattern = new Map(REGISTRY.map((p) => [p.pattern, p]));
-    if (byPattern.size !== REGISTRY.length) throw new Error("motion registry: duplicate property pattern");
-    ANIMATABLE_PROPERTIES = REGISTRY;
-    ID_PREFIX = { fills: "f", strokes: "s", effects: "e", gradientStops: "g", lights: "l" };
-  }
-});
-
-export {
-  effectsOf,
-  isShadowEffect,
-  shadowsOf,
-  blursOf,
-  hasEffects,
-  migrateDocumentEffects,
-  init_effects,
-  polygonCorners,
-  starCorners,
-  fitCornersToBox,
-  shapeToVectorPath,
-  canEditAsVector,
-  init_shape_to_path,
-  trimOf,
-  isFullTrim,
-  activeTrim,
-  trimPolylines,
-  trimmedShapeAsVector,
-  init_trim,
-  AI_LIMITS,
-  num,
-  str,
-  init_limits,
-  describeTextTarget,
-  applyContent,
-  init_content,
-  asPath,
-  pathSegments,
-  patternOf,
-  isBoundPath,
-  itemRef,
-  ANIMATABLE_PROPERTIES,
-  propertyFor,
-  propertiesOf,
-  readPath,
-  writePath,
-  bindPath,
-  init_properties
-};