@kokoa/clotho-editor 0.1.0

package/dist/chunk-UE32Q6U5.js

@@ -0,0 +1,943 @@
+import { computeSnapshot, encodeImageAsset, inlineAssetFromDataUri, animationDocumentSchema } from '@kokoa/clotho';
+
+// src/legacy/state/internals.ts
+var listeners = /* @__PURE__ */ new Set();
+var state = {
+  def: null,
+  dirty: false,
+  selection: { kind: "none" },
+  currentTime: 0,
+  isDraft: false
+};
+var HISTORY_LIMIT = 60;
+var past = [];
+var future = [];
+var inTransient = false;
+function snapshotJson() {
+  return state.def ? JSON.stringify(state.def) : null;
+}
+function pushHistory(label, kind) {
+  const snap = snapshotJson();
+  if (snap === null) return;
+  past.push({ snap, label, kind, timestamp: Date.now() });
+  if (past.length > HISTORY_LIMIT) past.shift();
+  future.length = 0;
+}
+function setInTransient(value) {
+  inTransient = value;
+}
+function subscribe(fn) {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+function emit() {
+  for (const fn of listeners) fn();
+}
+function mutateDef(fn, label = "edit", kind = "other") {
+  if (!state.def) return;
+  if (!inTransient) pushHistory(label, kind);
+  const cloned = JSON.parse(JSON.stringify(state.def));
+  fn(cloned);
+  const parsed = animationDocumentSchema.safeParse(cloned);
+  if (!parsed.success) {
+    past.pop();
+    console.warn("[studio.state] invalid mutation", parsed.error.issues);
+    return;
+  }
+  state.def = parsed.data;
+  state.dirty = true;
+  emit();
+}
+function isDraft() {
+  return state.isDraft;
+}
+function setDraft(def) {
+  state.def = def;
+  state.dirty = false;
+  state.isDraft = true;
+  state.selection = { kind: "none" };
+  state.currentTime = 0;
+  past.length = 0;
+  future.length = 0;
+  emit();
+}
+function promoteDraftToSaved() {
+  state.isDraft = false;
+  emit();
+}
+function getDef() {
+  return state.def;
+}
+function getSelection() {
+  return state.selection;
+}
+function isDirty() {
+  return state.dirty;
+}
+function getCurrentTime() {
+  return state.currentTime;
+}
+function setCurrentTime(time) {
+  state.currentTime = Math.max(0, Math.round(time));
+  emit();
+}
+function setDef(def, markDirty = false) {
+  state.def = def;
+  state.dirty = markDirty;
+  state.isDraft = false;
+  state.selection = { kind: "none" };
+  state.currentTime = 0;
+  past.length = 0;
+  future.length = 0;
+  emit();
+}
+function markClean() {
+  state.dirty = false;
+  emit();
+}
+function setSelection(sel) {
+  state.selection = sel;
+  emit();
+}
+function getSelectedElementIds(sel) {
+  if (sel.kind === "element") return [sel.elementId];
+  if (sel.kind === "elements") return sel.elementIds;
+  return [];
+}
+function isElementSelected(sel, id) {
+  if (sel.kind === "element") return sel.elementId === id;
+  if (sel.kind === "elements") return sel.elementIds.includes(id);
+  return false;
+}
+function toggleSelectionFor(sel, id) {
+  const cur = getSelectedElementIds(sel);
+  if (cur.includes(id)) {
+    const next2 = cur.filter((x) => x !== id);
+    if (next2.length === 0) return { kind: "none" };
+    if (next2.length === 1) return { kind: "element", elementId: next2[0] };
+    return { kind: "elements", elementIds: next2 };
+  }
+  const next = [...cur, id];
+  if (next.length === 1) return { kind: "element", elementId: next[0] };
+  return { kind: "elements", elementIds: next };
+}
+function getCurrentSnapshot() {
+  if (!state.def) return /* @__PURE__ */ new Map();
+  return computeSnapshot(state.def, state.currentTime);
+}
+
+// src/legacy/state/history.ts
+function beginTransient(label = "edit", kind = "other") {
+  if (!state.def) return;
+  pushHistory(label, kind);
+  setInTransient(true);
+}
+function endTransient() {
+  setInTransient(false);
+}
+function canUndo() {
+  return past.length > 0;
+}
+function canRedo() {
+  return future.length > 0;
+}
+function undo() {
+  if (past.length === 0) return;
+  const prev = past[past.length - 1];
+  const cur = snapshotJson();
+  if (cur !== null) {
+    future.push({
+      snap: cur,
+      label: prev.label,
+      kind: prev.kind,
+      timestamp: prev.timestamp
+    });
+  }
+  past.pop();
+  state.def = JSON.parse(prev.snap);
+  state.dirty = true;
+  emit();
+}
+function redo() {
+  if (future.length === 0) return;
+  const next = future[future.length - 1];
+  const cur = snapshotJson();
+  if (cur !== null) {
+    past.push({
+      snap: cur,
+      label: next.label,
+      kind: next.kind,
+      timestamp: next.timestamp
+    });
+  }
+  future.pop();
+  state.def = JSON.parse(next.snap);
+  state.dirty = true;
+  emit();
+}
+function resetHistory() {
+  past.length = 0;
+  future.length = 0;
+}
+function getHistory() {
+  return { past, future };
+}
+function jumpBack(steps) {
+  if (steps <= 0 || past.length === 0) return;
+  const n = Math.min(steps, past.length);
+  for (let i = 0; i < n; i += 1) undo();
+}
+function jumpForward(steps) {
+  if (steps <= 0 || future.length === 0) return;
+  const n = Math.min(steps, future.length);
+  for (let i = 0; i < n; i += 1) redo();
+}
+
+// src/legacy/state/elements.ts
+function ensureAppearance(el, def) {
+  if (!el.appearances || el.appearances.length === 0) {
+    el.appearances = [
+      { start: 0, end: def.duration, entryDuration: 300, exitDuration: 300 }
+    ];
+  }
+}
+function addElement(el) {
+  const kind = el.type === "group" ? "group" : "add";
+  const label = el.type === "group" ? "\uADF8\uB8F9 \uC0DD\uC131" : `\uC694\uC18C \uCD94\uAC00: ${el.type}`;
+  mutateDef(
+    (def) => {
+      const cloned = JSON.parse(JSON.stringify(el));
+      ensureAppearance(cloned, def);
+      if (!cloned.tracks) cloned.tracks = [];
+      def.elements.push(cloned);
+    },
+    label,
+    kind
+  );
+  state.selection = { kind: "element", elementId: el.id };
+  emit();
+}
+function deleteElement(id) {
+  const targetEl = state.def?.elements.find((e) => e.id === id);
+  const isGroupKind = targetEl?.type === "group";
+  mutateDef(
+    (def) => {
+      def.elements = def.elements.filter((e) => e.id !== id);
+      def.effects = def.effects.filter((e) => e.elementId !== id);
+      for (const el of def.elements) {
+        if (el.parentId === id) delete el.parentId;
+      }
+    },
+    isGroupKind ? `\uADF8\uB8F9 \uD574\uC81C` : `\uC694\uC18C \uC0AD\uC81C: ${id}`,
+    isGroupKind ? "group" : "delete"
+  );
+  if (state.selection.kind === "element" && state.selection.elementId === id) {
+    state.selection = { kind: "none" };
+  } else if (state.selection.kind === "elements") {
+    const remaining = state.selection.elementIds.filter((x) => x !== id);
+    if (remaining.length === 0) state.selection = { kind: "none" };
+    else if (remaining.length === 1)
+      state.selection = { kind: "element", elementId: remaining[0] };
+    else state.selection = { kind: "elements", elementIds: remaining };
+  }
+  emit();
+}
+function labelForPatch(id, patch) {
+  const keys = Object.keys(patch);
+  if (keys.length === 0) return { label: `\uC694\uC18C \uC218\uC815: ${id}`, kind: "other" };
+  const posKeys = ["x", "y", "cx", "cy", "x1", "y1", "x2", "y2", "points"];
+  const sizeKeys = ["width", "height", "r", "fontSize", "cellWidth"];
+  const styleKeys = [
+    "fill",
+    "stroke",
+    "strokeWidth",
+    "color",
+    "opacity",
+    "cornerRadius",
+    "labelColor",
+    "labelSize"
+  ];
+  if (keys.some((k) => posKeys.includes(k)))
+    return { label: `\uC774\uB3D9: ${id}`, kind: "move" };
+  if (keys.some((k) => sizeKeys.includes(k)))
+    return { label: `\uD06C\uAE30 \uBCC0\uACBD: ${id}`, kind: "resize" };
+  if (keys.includes("rotation"))
+    return { label: `\uD68C\uC804: ${id}`, kind: "rotate" };
+  if (keys.some((k) => styleKeys.includes(k)))
+    return { label: `\uC2A4\uD0C0\uC77C: ${id} (${keys.join(", ")})`, kind: "style" };
+  if (keys.includes("name")) return { label: `\uC774\uB984 \uBCC0\uACBD: ${id}`, kind: "meta" };
+  return { label: `\uC694\uC18C \uC218\uC815: ${id} (${keys.join(", ")})`, kind: "other" };
+}
+function updateElementBase(id, patch) {
+  const { label, kind } = labelForPatch(id, patch);
+  mutateDef(
+    (def) => {
+      const idx = def.elements.findIndex((e) => e.id === id);
+      if (idx < 0) return;
+      const baseEl = def.elements[idx];
+      const merged = {
+        ...baseEl
+      };
+      for (const [k, v] of Object.entries(patch)) {
+        if (v === null || v === void 0) delete merged[k];
+        else merged[k] = v;
+      }
+      def.elements[idx] = merged;
+    },
+    label,
+    kind
+  );
+}
+function reorderElement(sourceId, targetId, position) {
+  mutateDef(
+    (def) => {
+      const srcIdx = def.elements.findIndex((e) => e.id === sourceId);
+      if (srcIdx < 0) return;
+      const [moved] = def.elements.splice(srcIdx, 1);
+      let targetIdx = def.elements.findIndex((e) => e.id === targetId);
+      if (targetIdx < 0) {
+        def.elements.push(moved);
+        return;
+      }
+      if (position === "after") targetIdx += 1;
+      def.elements.splice(targetIdx, 0, moved);
+    },
+    `\uC21C\uC11C \uBCC0\uACBD: ${sourceId}`,
+    "reorder"
+  );
+}
+function moveElementToEnd(id) {
+  mutateDef(
+    (def) => {
+      const idx = def.elements.findIndex((e) => e.id === id);
+      if (idx < 0) return;
+      const [moved] = def.elements.splice(idx, 1);
+      def.elements.push(moved);
+    },
+    `\uB9E8 \uC55E\uC73C\uB85C: ${id}`,
+    "reorder"
+  );
+}
+function moveElementToFront(id) {
+  mutateDef(
+    (def) => {
+      const idx = def.elements.findIndex((e) => e.id === id);
+      if (idx < 0) return;
+      const [moved] = def.elements.splice(idx, 1);
+      def.elements.unshift(moved);
+    },
+    `\uB9E8 \uB4A4\uB85C: ${id}`,
+    "reorder"
+  );
+}
+function addAppearance(id, ap) {
+  mutateDef(
+    (def) => {
+      const el = def.elements.find((e) => e.id === id);
+      if (!el) return;
+      el.appearances.push(ap);
+      el.appearances.sort((a, b) => a.start - b.start);
+    },
+    `\uCD9C\uD604 \uCD94\uAC00: ${id}`,
+    "appearance"
+  );
+}
+function updateAppearance(id, apIdx, patch) {
+  mutateDef(
+    (def) => {
+      const el = def.elements.find((e) => e.id === id);
+      if (!el || !el.appearances[apIdx]) return;
+      el.appearances[apIdx] = { ...el.appearances[apIdx], ...patch };
+      el.appearances.sort((a, b) => a.start - b.start);
+    },
+    `\uCD9C\uD604 \uC870\uC815: ${id}`,
+    "appearance"
+  );
+}
+function removeAppearance(id, apIdx) {
+  mutateDef(
+    (def) => {
+      const el = def.elements.find((e) => e.id === id);
+      if (!el) return;
+      el.appearances.splice(apIdx, 1);
+      if (el.appearances.length === 0) ensureAppearance(el, def);
+    },
+    `\uCD9C\uD604 \uC0AD\uC81C: ${id}`,
+    "appearance"
+  );
+}
+function findTrack(el, property) {
+  return el.tracks.find((t) => t.property === property);
+}
+function setTrackKeyframe(elementId, property, time, value) {
+  mutateDef(
+    (def) => {
+      const el = def.elements.find((e) => e.id === elementId);
+      if (!el) return;
+      let track = findTrack(el, property);
+      if (!track) {
+        track = { property, keyframes: [] };
+        el.tracks.push(track);
+      }
+      const existing = track.keyframes.find((k) => k.time === time);
+      if (existing) {
+        existing.value = value;
+      } else {
+        track.keyframes.push({ time, value });
+        track.keyframes.sort((a, b) => a.time - b.time);
+      }
+    },
+    `keyframe ${property} @ ${time}ms`,
+    "track"
+  );
+}
+function removeTrackKeyframe(elementId, property, time) {
+  mutateDef(
+    (def) => {
+      const el = def.elements.find((e) => e.id === elementId);
+      if (!el) return;
+      const track = findTrack(el, property);
+      if (!track) return;
+      track.keyframes = track.keyframes.filter((k) => k.time !== time);
+      if (track.keyframes.length === 0) {
+        el.tracks = el.tracks.filter((t) => t.property !== property);
+      }
+    },
+    `keyframe \uC0AD\uC81C ${property} @ ${time}ms`,
+    "track"
+  );
+}
+function setElementValueAtTime(elementId, patch) {
+  const time = state.currentTime;
+  if (time <= 0) {
+    updateElementBase(elementId, patch);
+    return;
+  }
+  if (!state.def) return;
+  const el = state.def.elements.find((e) => e.id === elementId);
+  if (!el) return;
+  for (const [prop, value] of Object.entries(patch)) {
+    if (value === null || value === void 0) continue;
+    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
+      continue;
+    const hasTrack = el.tracks.some((t) => t.property === prop);
+    if (!hasTrack) {
+      const baseVal = el[prop];
+      if (typeof baseVal === "string" || typeof baseVal === "number" || typeof baseVal === "boolean") {
+        setTrackKeyframe(elementId, prop, 0, baseVal);
+      }
+    }
+    setTrackKeyframe(elementId, prop, time, value);
+  }
+}
+function removeTrack(elementId, property) {
+  mutateDef(
+    (def) => {
+      const el = def.elements.find((e) => e.id === elementId);
+      if (!el) return;
+      el.tracks = el.tracks.filter((t) => t.property !== property);
+    },
+    `\uD2B8\uB799 \uC0AD\uC81C: ${property}`,
+    "track"
+  );
+}
+
+// src/legacy/state/timeline.ts
+function addChapter(c) {
+  mutateDef(
+    (def) => {
+      def.chapters.push(c);
+      def.chapters.sort((a, b) => a.time - b.time);
+    },
+    `Chapter \uCD94\uAC00: ${c.label || c.id}`,
+    "chapter"
+  );
+  state.selection = { kind: "chapter", chapterId: c.id };
+  emit();
+}
+function updateChapter(id, patch) {
+  const keys = Object.keys(patch).join(", ");
+  mutateDef(
+    (def) => {
+      const idx = def.chapters.findIndex((c) => c.id === id);
+      if (idx < 0) return;
+      def.chapters[idx] = { ...def.chapters[idx], ...patch };
+      def.chapters.sort((a, b) => a.time - b.time);
+    },
+    `Chapter \uC218\uC815: ${id} (${keys})`,
+    "chapter"
+  );
+}
+function deleteChapter(id) {
+  mutateDef(
+    (def) => {
+      def.chapters = def.chapters.filter((c) => c.id !== id);
+    },
+    `Chapter \uC0AD\uC81C: ${id}`,
+    "chapter"
+  );
+  if (state.selection.kind === "chapter" && state.selection.chapterId === id) {
+    state.selection = { kind: "none" };
+  }
+  emit();
+}
+function addEffect(eff) {
+  mutateDef(
+    (def) => {
+      def.effects.push(eff);
+      def.effects.sort((a, b) => a.time - b.time);
+    },
+    `\uD6A8\uACFC \uCD94\uAC00: ${eff.type}`,
+    "effect"
+  );
+}
+function updateEffect(id, patch) {
+  mutateDef(
+    (def) => {
+      const idx = def.effects.findIndex((e) => e.id === id);
+      if (idx < 0) return;
+      def.effects[idx] = { ...def.effects[idx], ...patch };
+      def.effects.sort((a, b) => a.time - b.time);
+    },
+    `\uD6A8\uACFC \uC218\uC815: ${id}`,
+    "effect"
+  );
+}
+function deleteEffect(id) {
+  mutateDef(
+    (def) => {
+      def.effects = def.effects.filter((e) => e.id !== id);
+    },
+    `\uD6A8\uACFC \uC0AD\uC81C: ${id}`,
+    "effect"
+  );
+  if (state.selection.kind === "effect" && state.selection.effectId === id) {
+    state.selection = { kind: "none" };
+  }
+  emit();
+}
+function updateDuration(ms) {
+  mutateDef(
+    (def) => {
+      def.duration = Math.max(0, Math.round(ms));
+      for (const el of def.elements) {
+        for (const ap of el.appearances) {
+          if (ap.end > def.duration) ap.end = def.duration;
+          if (ap.start > def.duration) ap.start = def.duration;
+        }
+      }
+      for (const ch of def.chapters) {
+        if (ch.time > def.duration) ch.time = def.duration;
+      }
+      for (const eff of def.effects) {
+        if (eff.time > def.duration) eff.time = def.duration;
+      }
+    },
+    `duration: ${ms} ms`,
+    "meta"
+  );
+  if (state.currentTime > ms) state.currentTime = ms;
+}
+function updateMeta(patch) {
+  const keys = Object.keys(patch).join(", ");
+  mutateDef(
+    (def) => {
+      Object.assign(def, patch);
+    },
+    `\uBA54\uD0C0 \uC218\uC815: ${keys}`,
+    "meta"
+  );
+}
+function updateCanvas(patch) {
+  const keys = Object.keys(patch).join(", ");
+  mutateDef(
+    (def) => {
+      def.canvas = { ...def.canvas, ...patch };
+    },
+    `\uCE94\uBC84\uC2A4: ${keys}`,
+    "canvas"
+  );
+}
+function updateSettings(patch) {
+  const keys = Object.keys(patch).join(", ");
+  mutateDef(
+    (def) => {
+      def.settings = { ...def.settings, ...patch };
+    },
+    `\uC124\uC815: ${keys}`,
+    "settings"
+  );
+}
+function uniqueElementId(type) {
+  if (!state.def) return type + "-1";
+  const used = new Set(state.def.elements.map((e) => e.id));
+  let i = 1;
+  while (used.has(`${type}-${i}`)) i += 1;
+  return `${type}-${i}`;
+}
+function uniqueChapterId() {
+  if (!state.def) return "chapter-1";
+  const used = new Set(state.def.chapters.map((c) => c.id));
+  let i = 1;
+  while (used.has(`chapter-${i}`)) i += 1;
+  return `chapter-${i}`;
+}
+function uniqueEffectId() {
+  if (!state.def) return "effect-1";
+  const used = new Set(state.def.effects.map((e) => e.id));
+  let i = 1;
+  while (used.has(`effect-${i}`)) i += 1;
+  return `effect-${i}`;
+}
+function registerExternalAsset(url) {
+  const def = getDef();
+  if (def) {
+    for (const [id2, asset] of Object.entries(def.assets)) {
+      if (asset.kind === "external" && asset.url === url) return id2;
+    }
+  }
+  const id = uniqueAssetId();
+  mutateDef(
+    (draft) => {
+      draft.assets[id] = { kind: "external", url };
+    },
+    `\uC5D0\uC14B \uB4F1\uB85D: ${id}`,
+    "asset"
+  );
+  return id;
+}
+function registerInlineAsset(bytes, mime) {
+  const { asset } = encodeImageAsset(bytes, mime);
+  const id = uniqueAssetId();
+  mutateDef(
+    (draft) => {
+      draft.assets[id] = asset;
+    },
+    `\uC5D0\uC14B \uB4F1\uB85D: ${id}`,
+    "asset"
+  );
+  return id;
+}
+function uniqueAssetId() {
+  const def = getDef();
+  const existing = def ? new Set(Object.keys(def.assets)) : /* @__PURE__ */ new Set();
+  let n = 1;
+  while (existing.has(`asset-${n}`)) n += 1;
+  return `asset-${n}`;
+}
+function registerDataUriAsset(dataUri) {
+  const inline = inlineAssetFromDataUri(dataUri);
+  if (!inline) return registerExternalAsset(dataUri);
+  const id = uniqueAssetId();
+  mutateDef(
+    (draft) => {
+      draft.assets[id] = inline;
+    },
+    `\uC5D0\uC14B \uB4F1\uB85D: ${id}`,
+    "asset"
+  );
+  return id;
+}
+
+// src/legacy/studio-groups.ts
+function isGroup(el) {
+  return el.type === "group";
+}
+function childIdsOf(groupId) {
+  const def = getDef();
+  if (!def) return [];
+  return def.elements.filter((el) => el.parentId === groupId).map((el) => el.id);
+}
+function findContainingGroup(elementId) {
+  const def = getDef();
+  if (!def) return null;
+  const element = def.elements.find((el) => el.id === elementId);
+  const parentId = element?.parentId;
+  if (parentId === void 0) return null;
+  const parent = def.elements.find((el) => el.id === parentId);
+  if (!parent || !isGroup(parent)) return null;
+  return findContainingGroup(parent.id) ?? parent;
+}
+function expandToLeafIds(ids) {
+  const def = getDef();
+  if (!def) return ids;
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [...ids];
+  while (stack.length) {
+    const id = stack.pop();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const el = def.elements.find((e) => e.id === id);
+    if (el && isGroup(el)) {
+      for (const childId of childIdsOf(el.id)) stack.push(childId);
+    }
+  }
+  const out = [];
+  for (const id of seen) {
+    const el = def.elements.find((e) => e.id === id);
+    if (el && !isGroup(el)) out.push(id);
+  }
+  return out;
+}
+function groupBbox(groupId) {
+  const def = getDef();
+  if (!def) return null;
+  const leafIds = expandToLeafIds([groupId]);
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let any = false;
+  for (const id of leafIds) {
+    const el = def.elements.find((e) => e.id === id);
+    if (!el) continue;
+    const b = elementBbox(el);
+    if (!b) continue;
+    any = true;
+    if (b.x < minX) minX = b.x;
+    if (b.y < minY) minY = b.y;
+    if (b.x + b.w > maxX) maxX = b.x + b.w;
+    if (b.y + b.h > maxY) maxY = b.y + b.h;
+  }
+  return any ? { x: minX, y: minY, w: maxX - minX, h: maxY - minY } : null;
+}
+function elementBbox(el) {
+  if (el.type === "rect" || el.type === "image")
+    return { x: el.x, y: el.y, w: el.width, h: el.height };
+  if (el.type === "circle")
+    return { x: el.cx - el.r, y: el.cy - el.r, w: el.r * 2, h: el.r * 2 };
+  if (el.type === "text")
+    return {
+      x: el.x - 40,
+      y: el.y - (el.fontSize ?? 16),
+      w: 80,
+      h: el.fontSize ?? 16
+    };
+  if (el.type === "line" || el.type === "arrow") {
+    if (typeof el.x1 !== "number" || typeof el.x2 !== "number" || typeof el.y1 !== "number" || typeof el.y2 !== "number")
+      return null;
+    return {
+      x: Math.min(el.x1, el.x2),
+      y: Math.min(el.y1, el.y2),
+      w: Math.abs(el.x2 - el.x1),
+      h: Math.abs(el.y2 - el.y1)
+    };
+  }
+  if (el.type === "polygon") {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    let any = false;
+    for (const pair of el.points.trim().split(/\s+/)) {
+      const [x, y] = pair.split(",").map(Number);
+      if (!Number.isFinite(x) || !Number.isFinite(y)) continue;
+      any = true;
+      if (x < minX) minX = x;
+      if (y < minY) minY = y;
+      if (x > maxX) maxX = x;
+      if (y > maxY) maxY = y;
+    }
+    return any ? { x: minX, y: minY, w: maxX - minX, h: maxY - minY } : null;
+  }
+  if (el.type === "path") return { x: el.x ?? 0, y: el.y ?? 0, w: 60, h: 60 };
+  return null;
+}
+function shiftLeafBy(el, dx, dy) {
+  if (dx === 0 && dy === 0) return;
+  if (el.type === "rect" || el.type === "image" || el.type === "text") {
+    updateElementBase(el.id, { x: el.x + dx, y: el.y + dy });
+  } else if (el.type === "circle") {
+    updateElementBase(el.id, { cx: el.cx + dx, cy: el.cy + dy });
+  } else if (el.type === "line" || el.type === "arrow") {
+    const patch = {};
+    if (typeof el.x1 === "number") patch.x1 = el.x1 + dx;
+    if (typeof el.y1 === "number") patch.y1 = el.y1 + dy;
+    if (typeof el.x2 === "number") patch.x2 = el.x2 + dx;
+    if (typeof el.y2 === "number") patch.y2 = el.y2 + dy;
+    updateElementBase(el.id, patch);
+  } else if (el.type === "path") {
+    updateElementBase(el.id, { x: (el.x ?? 0) + dx, y: (el.y ?? 0) + dy });
+  } else if (el.type === "polygon") {
+    const shifted = el.points.trim().split(/\s+/).map((pair) => {
+      const [x, y] = pair.split(",").map(Number);
+      if (Number.isFinite(x) && Number.isFinite(y))
+        return `${(x + dx).toFixed(1)},${(y + dy).toFixed(1)}`;
+      return pair;
+    }).join(" ");
+    updateElementBase(el.id, { points: shifted });
+  }
+}
+function moveGroupBy(groupId, dx, dy) {
+  const def = getDef();
+  if (!def) return;
+  const leafIds = expandToLeafIds([groupId]);
+  for (const id of leafIds) {
+    const el = def.elements.find((e) => e.id === id);
+    if (el) shiftLeafBy(el, dx, dy);
+  }
+  const group = def.elements.find((e) => e.id === groupId);
+  if (group && isGroup(group)) {
+    updateElementBase(groupId, { x: group.x + dx, y: group.y + dy });
+  }
+}
+function groupElements(ids) {
+  if (ids.length < 2) return null;
+  const def = getDef();
+  if (!def) return null;
+  const valid = ids.filter((id) => def.elements.some((e) => e.id === id));
+  if (valid.length < 2) return null;
+  const newId = uniqueElementId("group");
+  (() => {
+    let minX = Infinity, minY = Infinity;
+    for (const id of valid) {
+      const el = def.elements.find((e) => e.id === id);
+      if (!el) continue;
+      const b = elementBbox(el);
+      if (!b) continue;
+      if (b.x < minX) minX = b.x;
+      if (b.y < minY) minY = b.y;
+    }
+    return {
+      x: Number.isFinite(minX) ? minX : 0,
+      y: Number.isFinite(minY) ? minY : 0
+    };
+  })();
+  const group = {
+    type: "group",
+    id: newId,
+    name: `Group ${newId.split("-")[1] ?? ""}`.trim(),
+    rotation: 0,
+    appearances: [],
+    tracks: [],
+    // Children keep their absolute coordinates, so the group's own transform starts at
+    // the identity. Setting x/y here would shift every member on the next render.
+    x: 0,
+    y: 0
+  };
+  addElement(group);
+  for (const id of valid) updateElementBase(id, { parentId: newId });
+  setSelection({ kind: "element", elementId: newId });
+  return newId;
+}
+function ungroupElement(groupId) {
+  const def = getDef();
+  if (!def) return [];
+  const group = def.elements.find((e) => e.id === groupId);
+  if (!group || !isGroup(group)) return [];
+  const childIds = childIdsOf(groupId);
+  for (const id of childIds) updateElementBase(id, { parentId: void 0 });
+  deleteElement(groupId);
+  if (childIds.length === 1) {
+    setSelection({ kind: "element", elementId: childIds[0] });
+  } else if (childIds.length > 1) {
+    setSelection({ kind: "elements", elementIds: childIds });
+  } else {
+    setSelection({ kind: "none" });
+  }
+  return childIds;
+}
+
+// src/legacy/host.ts
+var placeholderUrl = "/uploads/placeholder.png";
+function configureHost(options) {
+  if (options.placeholderImageUrl) placeholderUrl = options.placeholderImageUrl;
+}
+function placeholderImageUrl() {
+  return placeholderUrl;
+}
+var DEFAULT_BASE = "/api/admin/animations";
+var BASE = DEFAULT_BASE;
+function configureApi(options) {
+  if (options.baseUrl) BASE = options.baseUrl.replace(/\/+$/, "");
+}
+function apiBaseUrl() {
+  return BASE;
+}
+var revisions = /* @__PURE__ */ new Map();
+var MissingAnimationRevisionError = class extends Error {
+};
+var AnimationStudioApiError = class extends Error {
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+async function readJson(res) {
+  if (!res.ok) {
+    const text = await res.text();
+    throw new AnimationStudioApiError(`HTTP ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+function parseRevision(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError("Animation revision is malformed");
+  }
+  return value;
+}
+function parseAnimationEnvelope(value) {
+  if (!isRecord(value)) throw new TypeError("Animation response is malformed");
+  return {
+    def: animationDocumentSchema.parse(value.def),
+    revision: parseRevision(value.revision)
+  };
+}
+async function listAnimations() {
+  const res = await fetch(BASE);
+  const data = await readJson(res);
+  if (!isRecord(data) || !Array.isArray(data.items))
+    throw new TypeError("Animation list response is malformed");
+  return data.items.map((item) => {
+    if (!isRecord(item) || typeof item.id !== "string" || typeof item.title !== "string" || typeof item.description !== "string") {
+      throw new TypeError("Animation summary is malformed");
+    }
+    return {
+      id: item.id,
+      title: item.title,
+      description: item.description,
+      ...typeof item.updatedAt === "string" ? { updatedAt: item.updatedAt } : {}
+    };
+  });
+}
+async function loadAnimation(id) {
+  const res = await fetch(`${BASE}/${encodeURIComponent(id)}`);
+  const data = parseAnimationEnvelope(await readJson(res));
+  revisions.set(data.def.id, data.revision);
+  return data.def;
+}
+async function saveAnimation(def) {
+  const revision = revisions.get(def.id);
+  if (revision === void 0)
+    throw new MissingAnimationRevisionError(
+      `Animation '${def.id}' has no loaded revision`
+    );
+  const res = await fetch(`${BASE}/${encodeURIComponent(def.id)}`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ def, revision })
+  });
+  const data = parseAnimationEnvelope(await readJson(res));
+  revisions.set(data.def.id, data.revision);
+  return data.def;
+}
+async function createAnimation(id, title) {
+  const res = await fetch(BASE, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ id, title })
+  });
+  const data = parseAnimationEnvelope(await readJson(res));
+  revisions.set(data.def.id, data.revision);
+  return data.def;
+}
+async function deleteAnimation(id) {
+  const res = await fetch(`${BASE}/${encodeURIComponent(id)}`, {
+    method: "DELETE"
+  });
+  await readJson(res);
+  revisions.delete(id);
+}
+async function duplicateAnimation(sourceId, newId, newTitle) {
+  const source = await loadAnimation(sourceId);
+  const cloned = { ...source, id: newId, title: newTitle };
+  await createAnimation(newId, newTitle);
+  return await saveAnimation(cloned);
+}
+
+export { addAppearance, addChapter, addEffect, addElement, apiBaseUrl, beginTransient, canRedo, canUndo, childIdsOf, configureApi, configureHost, createAnimation, deleteAnimation, deleteChapter, deleteEffect, deleteElement, duplicateAnimation, endTransient, findContainingGroup, getCurrentSnapshot, getCurrentTime, getDef, getHistory, getSelectedElementIds, getSelection, groupBbox, groupElements, isDirty, isDraft, isElementSelected, isGroup, jumpBack, jumpForward, listAnimations, loadAnimation, markClean, moveElementToEnd, moveElementToFront, moveGroupBy, placeholderImageUrl, promoteDraftToSaved, redo, registerDataUriAsset, registerExternalAsset, registerInlineAsset, removeAppearance, removeTrack, removeTrackKeyframe, reorderElement, resetHistory, saveAnimation, setCurrentTime, setDef, setDraft, setElementValueAtTime, setSelection, setTrackKeyframe, subscribe, toggleSelectionFor, undo, ungroupElement, uniqueChapterId, uniqueEffectId, uniqueElementId, updateAppearance, updateCanvas, updateChapter, updateDuration, updateEffect, updateElementBase, updateMeta, updateSettings };
+//# sourceMappingURL=chunk-UE32Q6U5.js.map
+//# sourceMappingURL=chunk-UE32Q6U5.js.map