@popcraft/kit 0.29.0 → 0.30.0

package/dist/chunks/chunk-4VICNBUI.js

@@ -0,0 +1,1188 @@
+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-IPETYEVH.js";
+import {
+  init_values,
+  isValueOf
+} from "./chunk-5X7A23T7.js";
+import {
+  init_morph,
+  pathsExtent
+} from "./chunk-ONN5A5XM.js";
+import {
+  init_scene3d,
+  is3DContext
+} from "./chunk-NMFXCSU4.js";
+import {
+  init_shader_params,
+  paramComponent,
+  paramComponents,
+  paramLabel,
+  reflectShader,
+  withParamComponent
+} from "./chunk-TSWHCDM7.js";
+import {
+  has3DPlacement,
+  init_transform3d
+} from "./chunk-CK43FENV.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-FFS4SO7R.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
+};