@pixerate/editor 0.271.0 → 0.272.1

package/dist/{chunk-IBXEQOGI.js → chunk-PYHB2EHE.js}

@@ -1,16 +1,9 @@
 import {
-  parseSkillFrontmatter
-} from "./chunk-K4BGRCSH.js";
+  renderStyle
+} from "./chunk-5UGRMVNE.js";
 import {
   readingTime
 } from "./chunk-EHTX34RE.js";
-import {
-  validateJsonSchema
-} from "./chunk-V2ZCJRDM.js";
-import {
-  isUnsafeJsonKey,
-  stripPrototypeKeys
-} from "./chunk-HF5QZS7Z.js";
 
 // src/tools/skill-evals.ts
 function listSkillEvals(files) {
@@ -182,316 +175,6 @@ async function runToolScript(source, script, options = {}) {
   return finish(true);
 }
 
-// src/tools/style.ts
-var STYLE_SKILL_NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
-var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function parseStyleDomains(markdown) {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
-  const line = match?.[1].split(/\r?\n/).find((l) => /^domains:/.test(l));
-  if (!line) return void 0;
-  const raw = line.slice("domains:".length).trim().replace(/^\[|\]$/g, "");
-  return raw.split(",").map((d) => d.trim().replace(/^(['"])(.*)\1$/, "$2")).filter(Boolean);
-}
-function memoryStyleStore(initial = {}, state = {}) {
-  const files = /* @__PURE__ */ new Map();
-  const states = new Map(Object.entries(state));
-  const listeners = /* @__PURE__ */ new Set();
-  const notify = () => listeners.forEach((l) => l());
-  for (const [path, text] of Object.entries(initial)) {
-    const [dir, ...rest] = path.replace(/\\/g, "/").replace(/^\.?\//, "").split("/");
-    if (!dir || !rest.length) continue;
-    if (!files.has(dir)) files.set(dir, /* @__PURE__ */ new Map());
-    files.get(dir).set(rest.join("/"), text);
-  }
-  return {
-    list: () => [.../* @__PURE__ */ new Set([...files.keys(), ...states.keys()])].sort().map((name) => ({ name, ...states.get(name) })),
-    read: (name, file) => files.get(name)?.get(file),
-    files: (name) => [...files.get(name)?.keys() ?? []].sort(),
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    set(name, skillFiles) {
-      files.set(name, new Map(Object.entries(skillFiles)));
-      notify();
-    },
-    remove(name) {
-      files.delete(name);
-      states.delete(name);
-      notify();
-    },
-    setState(name, next) {
-      if (next) states.set(name, next);
-      else states.delete(name);
-      notify();
-    }
-  };
-}
-function resolveTokens(value, tokens, path, errors) {
-  if (Array.isArray(value)) return value.map((v, i) => resolveTokens(v, tokens, `${path}[${i}]`, errors));
-  if (!isPlainObject(value)) return value;
-  if ("$token" in value) {
-    const token = value.$token;
-    const mode = value.mode;
-    if (typeof token !== "string" || !token || mode !== void 0 && typeof mode !== "string" || Object.keys(value).some((k) => k !== "$token" && k !== "mode")) {
-      errors.push(`${path || "profile"}: a token reference is { "$token": "<variable name or id>", "mode"?: "<mode>" }.`);
-      return void 0;
-    }
-    if (!tokens) {
-      errors.push(`${path}: "${token}" is a token reference, but this host has no design tokens to resolve it.`);
-      return void 0;
-    }
-    const resolved = tokens.resolve({ token, ...mode ? { mode } : {} });
-    if (!resolved.ok) errors.push(`${path}: ${resolved.message}`);
-    return resolved.ok ? resolved.value : void 0;
-  }
-  const out = {};
-  for (const [k, v] of Object.entries(value)) out[k] = resolveTokens(v, tokens, path ? `${path}.${k}` : k, errors);
-  return out;
-}
-function checkListErrors(list, domain) {
-  if (list === void 0) return [];
-  if (!Array.isArray(list)) return ['checks: expected a list of check ids or { "id": ..., options } objects.'];
-  const errors = [];
-  list.forEach((entry, i) => {
-    const id = typeof entry === "string" ? entry : isPlainObject(entry) ? entry.id : void 0;
-    if (typeof id !== "string" || !id) {
-      errors.push(`checks[${i}]: expected a check id or { "id": ..., options }.`);
-      return;
-    }
-    const check = domain.checks.find((c) => c.id === id);
-    if (!check || typeof entry === "string") return;
-    const { id: _id, ...options } = entry;
-    const schema = check.optionsSchema ?? { type: "object", properties: {}, additionalProperties: false };
-    for (const e of validateJsonSchema(options, schema)) errors.push(`checks[${i}] (${id})${e.path}: ${e.message}`);
-  });
-  return errors;
-}
-function mergeProfile(target, value, layer, skill, sources, locked, issues, prefix = "") {
-  for (const [key, next] of Object.entries(value)) {
-    if (isUnsafeJsonKey(key) || next === void 0) continue;
-    const path = prefix ? `${prefix}.${key}` : key;
-    const lockedBy = [...locked.entries()].find(([p]) => p === path || path.startsWith(`${p}.`) || p.startsWith(`${path}.`));
-    if (isPlainObject(next)) {
-      if (!isPlainObject(target[key])) {
-        if (lockedBy && lockedBy[1] !== layer.id && target[key] !== void 0) {
-          issues.push({ skill, layer: layer.id, message: `"${path}" is locked by the ${lockedBy[1]} layer, so this skill's value is ignored.` });
-          continue;
-        }
-        target[key] = {};
-        delete sources[path];
-      }
-      mergeProfile(target[key], next, layer, skill, sources, locked, issues, path);
-      continue;
-    }
-    if (lockedBy && lockedBy[1] !== layer.id) {
-      issues.push({ skill, layer: layer.id, message: `"${path}" is locked by the ${lockedBy[1]} layer, so this skill's value is ignored.` });
-      continue;
-    }
-    target[key] = Array.isArray(next) ? structuredClone(next) : next;
-    for (const p of Object.keys(sources)) if (p.startsWith(`${path}.`)) delete sources[p];
-    sources[path] = layer.id;
-    if (layer.locked) locked.set(path, layer.id);
-  }
-}
-function createStyleResolver(options) {
-  const layers = [...options.layers];
-  const domains = [...options.domains];
-  const ids = /* @__PURE__ */ new Set();
-  for (const layer of layers) {
-    if (ids.has(layer.id)) throw new Error(`Two style layers are called "${layer.id}"; give each layer its own id.`);
-    ids.add(layer.id);
-  }
-  const domainIds = domains.map((d) => d.id);
-  const requireDomain = (id) => {
-    const domain = domains.find((d) => d.id === id);
-    if (!domain) throw new Error(`There is no house-style domain "${id}"; expected one of ${domainIds.map((d) => `"${d}"`).join(", ") || "(none registered)"}.`);
-    return domain;
-  };
-  async function load() {
-    const issues = [];
-    const entries = await Promise.all(layers.map(async (layer) => [...await layer.store.list()]));
-    const names = [...new Set(entries.flat().map((e) => e.name))];
-    const skills = [];
-    for (const name of names) {
-      if (!STYLE_SKILL_NAME.test(name)) {
-        issues.push({ skill: name, message: `"${name}" is not a valid skill name (lowercase letters, digits and hyphens, at most 64).` });
-        continue;
-      }
-      const copies = [];
-      for (let i = 0; i < layers.length; i++) {
-        const text = await layers[i].store.read(name, "SKILL.md");
-        if (text !== void 0) copies.push({ index: i, text });
-      }
-      if (!copies.length) continue;
-      const lockedCopy = copies.find((c) => layers[c.index].locked);
-      const winner = lockedCopy ?? copies[copies.length - 1];
-      const layer = layers[winner.index];
-      const skillIssues = [];
-      for (const c of copies) {
-        if (c.index > winner.index) skillIssues.push(`The ${layers[c.index].id} layer's copy is ignored: the ${layer.id} layer is locked.`);
-      }
-      let enabled = true;
-      let order = 0;
-      for (let i = 0; i < layers.length; i++) {
-        const entry = entries[i].find((e) => e.name === name);
-        if (!entry) continue;
-        if (i === winner.index && entry.order !== void 0) order = entry.order;
-        if (entry.enabled === void 0) continue;
-        if (layer.required && i !== winner.index) {
-          if (entry.enabled === false) skillIssues.push(`The ${layers[i].id} layer cannot switch it off: the ${layer.id} layer requires it.`);
-          continue;
-        }
-        enabled = entry.enabled;
-      }
-      const { description = "", body } = parseSkillFrontmatter(winner.text);
-      const named = parseStyleDomains(winner.text);
-      const applies = /* @__PURE__ */ new Set();
-      for (const d of named ?? domainIds) {
-        if (domainIds.includes(d)) applies.add(d);
-        else skillIssues.push(`It names an unknown domain "${d}"; the domains here are ${domainIds.join(", ")}.`);
-      }
-      const profiles = /* @__PURE__ */ new Map();
-      for (const domain of domains) {
-        const raw = await layer.store.read(name, `${domain.id}.json`);
-        if (raw === void 0) continue;
-        const file = `${domain.id}.json`;
-        if (!applies.has(domain.id)) {
-          skillIssues.push(`${file} is left out: the skill's domains do not include ${domain.id}.`);
-          continue;
-        }
-        let parsed;
-        try {
-          parsed = stripPrototypeKeys(JSON.parse(raw));
-        } catch (error) {
-          skillIssues.push(`${file} is not valid JSON: ${error.message}`);
-          continue;
-        }
-        if (!isPlainObject(parsed)) {
-          skillIssues.push(`${file} must hold a JSON object.`);
-          continue;
-        }
-        const errors = [];
-        const resolved = resolveTokens(parsed, options.tokens, "", errors);
-        const { checks, ...rest } = resolved;
-        errors.push(...validateJsonSchema(rest, domain.profileSchema).map((e) => `${e.path || "(profile)"}: ${e.message}`));
-        errors.push(...checkListErrors(checks, domain));
-        if (errors.length) {
-          skillIssues.push(`${file} is left out: ${errors.join(" ")}`);
-          continue;
-        }
-        profiles.set(domain.id, resolved);
-      }
-      skills.push({
-        info: {
-          name,
-          description,
-          layer: layer.id,
-          domains: [...applies],
-          profiles: [...profiles.keys()],
-          enabled,
-          order,
-          issues: skillIssues
-        },
-        layerIndex: winner.index,
-        body: body.trim(),
-        profiles,
-        applies
-      });
-    }
-    skills.sort((a, b) => a.layerIndex - b.layerIndex || a.info.order - b.info.order || a.info.name.localeCompare(b.info.name));
-    return { skills, issues };
-  }
-  async function resolve2(domainId) {
-    requireDomain(domainId);
-    const { skills, issues: loadIssues } = await load();
-    const issues = [...loadIssues];
-    const profile = {};
-    const sources = {};
-    const locked = /* @__PURE__ */ new Map();
-    const applied = [];
-    for (const skill of skills) {
-      if (!skill.applies.has(domainId)) continue;
-      for (const message of skill.info.issues) issues.push({ skill: skill.info.name, layer: skill.info.layer, message });
-      if (!skill.info.enabled) continue;
-      applied.push({ name: skill.info.name, description: skill.info.description, layer: skill.info.layer, body: skill.body });
-      const own = skill.profiles.get(domainId);
-      if (own) mergeProfile(profile, own, layers[skill.layerIndex], skill.info.name, sources, locked, issues);
-    }
-    return { domain: domainId, skills: applied, profile, sources, issues };
-  }
-  async function winnerLayer(name) {
-    const copies = [];
-    for (let i = 0; i < layers.length; i++) if (await layers[i].store.read(name, "SKILL.md") !== void 0) copies.push(i);
-    if (!copies.length) return void 0;
-    return layers[copies.find((i) => layers[i].locked) ?? copies[copies.length - 1]];
-  }
-  return {
-    layers,
-    domains,
-    async list(opts = {}) {
-      if (opts.domain !== void 0) requireDomain(opts.domain);
-      const { skills } = await load();
-      return skills.filter((s) => opts.domain === void 0 || s.applies.has(opts.domain)).map((s) => s.info);
-    },
-    resolve: resolve2,
-    async readFile(name, file) {
-      const layer = await winnerLayer(name);
-      return layer ? layer.store.read(name, file) : void 0;
-    },
-    async files(name) {
-      const layer = await winnerLayer(name);
-      return layer ? [...await layer.store.files(name)] : void 0;
-    },
-    async check(domainId, state) {
-      const domain = requireDomain(domainId);
-      const style = await resolve2(domainId);
-      return { ...runStyleChecks(domain, state, style), style };
-    },
-    subscribe(listener) {
-      const offs = [...layers.map((l) => l.store.subscribe?.(listener)), options.tokens?.subscribe?.(listener)];
-      return () => offs.forEach((off) => off?.());
-    }
-  };
-}
-function runStyleChecks(domain, state, style) {
-  const report = { findings: [], ran: [], skipped: [] };
-  const list = Array.isArray(style.profile.checks) ? style.profile.checks : [];
-  const layer = style.sources.checks;
-  for (const entry of list) {
-    const id = typeof entry === "string" ? entry : isPlainObject(entry) && typeof entry.id === "string" ? entry.id : void 0;
-    if (!id) continue;
-    const check = domain.checks.find((c) => c.id === id);
-    if (!check) {
-      report.skipped.push({ check: id, reason: `There is no "${id}" check for ${domain.id}; it has ${domain.checks.map((c) => `"${c.id}"`).join(", ")}.` });
-      continue;
-    }
-    const { id: _id, ...options } = isPlainObject(entry) ? entry : { id };
-    try {
-      for (const f of check.run(state, style.profile, options)) report.findings.push({ ...f, check: id, ...layer ? { layer } : {} });
-      report.ran.push(id);
-    } catch (error) {
-      report.skipped.push({ check: id, reason: `The check could not run: ${error.message}` });
-    }
-  }
-  return report;
-}
-var escapeAttribute = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
-function renderStyle(style) {
-  if (!style.skills.length) return `No house style applies to ${style.domain}.`;
-  const blocks = style.skills.map((s) => {
-    const body = s.body.replace(/<(\/?)style_skill/gi, "&lt;$1style_skill");
-    return `<style_skill name="${escapeAttribute(s.name)}" layer="${escapeAttribute(s.layer)}">
-${body}
-</style_skill>`;
-  });
-  const profile = Object.keys(style.profile).length ? `
-
-Merged ${style.domain} profile:
-${JSON.stringify(style.profile, null, 2)}` : "";
-  return `${blocks.join("\n\n")}${profile}`;
-}
-
 // src/tools/style-tools.ts
 var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 function createStyleToolProvider(styles, options = {}) {
@@ -773,11 +456,6 @@ export {
   toolResultValue,
   toolResultError,
   runToolScript,
-  parseStyleDomains,
-  memoryStyleStore,
-  createStyleResolver,
-  runStyleChecks,
-  renderStyle,
   createStyleToolProvider,
   createOriginMiddleware,
   ConformanceIds,

package/dist/chunk-QEUI6OGE.cjs

@@ -0,0 +1,336 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkKIJIONZFcjs = require('./chunk-KIJIONZF.cjs');
+
+
+
+var _chunkQJVOJUTDcjs = require('./chunk-QJVOJUTD.cjs');
+
+// src/commands/paletteController.ts
+function createCommandPaletteController(registry, options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  let open = false;
+  let query = "";
+  let activeIndex = 0;
+  let recents = [..._nullishCoalesce(options.recents, () => ( []))];
+  let lastResult = null;
+  let state;
+  const context = () => {
+    const c = options.context;
+    if (c === void 0) return registry.context;
+    return typeof c === "function" ? c() : c;
+  };
+  const scope = () => typeof options.scope === "function" ? options.scope() : options.scope;
+  function computeItems() {
+    if (!open) return [];
+    const entries = registry.list({ scope: scope(), context: context() });
+    const platform = _nullishCoalesce(options.platform, () => ( registry.shortcuts.platform));
+    return _chunkKIJIONZFcjs.rankCommands.call(void 0, query, entries, {
+      recents,
+      recentLimit: options.recentLimit,
+      limit: _nullishCoalesce(options.limit, () => ( 50))
+    }).map((ranked) => ({
+      ...ranked,
+      id: ranked.entry.id,
+      label: ranked.entry.label,
+      ...ranked.entry.group !== void 0 ? { group: ranked.entry.group } : {},
+      ...ranked.entry.shortcuts[0] ? { shortcut: _chunkQJVOJUTDcjs.formatShortcut.call(void 0, ranked.entry.shortcuts[0], platform) } : {},
+      enabled: ranked.entry.enabled,
+      ...ranked.entry.disabledReason ? { disabledReason: ranked.entry.disabledReason } : {}
+    }));
+  }
+  function update() {
+    const items = computeItems();
+    activeIndex = items.length === 0 ? 0 : Math.min(Math.max(activeIndex, 0), items.length - 1);
+    state = { open, query, activeIndex, items, recents, lastResult };
+    for (const listener of Array.from(listeners)) listener(state);
+  }
+  state = { open, query, activeIndex, items: [], recents, lastResult };
+  let unsubscribeRegistry = null;
+  const onRegistryChange = () => {
+    if (open) update();
+  };
+  const controller = {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      unsubscribeRegistry ??= registry.subscribe(onRegistryChange);
+      if (open) update();
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          _optionalChain([unsubscribeRegistry, 'optionalCall', _ => _()]);
+          unsubscribeRegistry = null;
+        }
+      };
+    },
+    setOpen(next) {
+      if (next === open) return;
+      open = next;
+      query = "";
+      activeIndex = 0;
+      update();
+    },
+    toggle() {
+      controller.setOpen(!open);
+    },
+    setQuery(next) {
+      if (next === query) return;
+      query = next;
+      activeIndex = 0;
+      update();
+    },
+    setActiveIndex(index) {
+      activeIndex = index;
+      update();
+    },
+    /** Moves the active row by `delta`, wrapping around. */
+    move(delta) {
+      const n = state.items.length;
+      if (n === 0) return;
+      activeIndex = ((activeIndex + delta) % n + n) % n;
+      update();
+    },
+    /** Runs a command by id, closes the palette and records it as recent. Disabled commands do nothing. */
+    run(id) {
+      if (!registry.isEnabled(id, void 0, context()).enabled) return null;
+      open = false;
+      query = "";
+      activeIndex = 0;
+      recents = _chunkKIJIONZFcjs.pushRecent.call(void 0, recents, id, _nullishCoalesce(options.recentLimit, () => ( _chunkKIJIONZFcjs.DEFAULT_RECENT_LIMIT)));
+      _optionalChain([options, 'access', _2 => _2.onRecentsChange, 'optionalCall', _3 => _3(recents)]);
+      const result = registry.execute(id, void 0, context());
+      lastResult = result;
+      update();
+      _optionalChain([options, 'access', _4 => _4.onRun, 'optionalCall', _5 => _5(result)]);
+      return result;
+    },
+    runActive() {
+      const item = state.items[state.activeIndex];
+      return item ? controller.run(item.id) : null;
+    },
+    /**
+     * Keyboard handling for the palette input: ArrowUp/ArrowDown (wrap), Home/End,
+     * Enter (run the active row) and Escape (close). Returns whether it handled the key.
+     */
+    handleKeyDown(event) {
+      if (!open) return false;
+      switch (event.key) {
+        case "ArrowDown":
+          controller.move(1);
+          break;
+        case "ArrowUp":
+          controller.move(-1);
+          break;
+        case "Home":
+          controller.setActiveIndex(0);
+          break;
+        case "End":
+          controller.setActiveIndex(state.items.length - 1);
+          break;
+        case "Enter":
+          controller.runActive();
+          break;
+        case "Escape":
+          controller.setOpen(false);
+          break;
+        default:
+          return false;
+      }
+      _optionalChain([event, 'access', _6 => _6.preventDefault, 'optionalCall', _7 => _7()]);
+      return true;
+    },
+    /** Re-reads commands and enablement. */
+    refresh() {
+      update();
+    },
+    destroy() {
+      _optionalChain([unsubscribeRegistry, 'optionalCall', _8 => _8()]);
+      unsubscribeRegistry = null;
+      listeners.clear();
+    }
+  };
+  return controller;
+}
+function matchPaletteHotkey(event, hotkey, platform) {
+  const map = new (0, _chunkQJVOJUTDcjs.ShortcutMap)([{ command: "palette", chord: hotkey, allowInEditable: true }], platform ? { platform } : {});
+  return map.resolve(event) !== null;
+}
+
+// src/commands/animation.ts
+var EASING_DESCRIPTION = "Easing preset (linear, ease, ease-in, ease-out, ease-in-out, ease-in-back, ease-out-back, spring, hold) or a CSS cubic-bezier(x1, y1, x2, y2).";
+var VALUES = {
+  type: "object",
+  description: 'Property \u2192 value, e.g. {"x": 200, "opacity": 0.5, "fill": "#ff0000"}. Properties: x, y, width, height, rotation (degrees), scale, opacity (0\u20131), fill, stroke, strokeWidth, cornerRadius, motionPath (0\u20131).',
+  additionalProperties: { type: ["number", "string"] }
+};
+function createCanvasAnimationCommands(controller, options = {}) {
+  const prefix = _nullishCoalesce(options.prefix, () => ( "canvas.animation."));
+  const group = _nullishCoalesce(options.group, () => ( "Animation"));
+  const scope = options.scope === null ? void 0 : _nullishCoalesce(options.scope, () => ( "canvas"));
+  const base = { group, ...scope ? { scope } : {} };
+  const hasSelection = () => controller.getState().selection.length > 0 ? true : "Select keyframes first.";
+  return [
+    {
+      ...base,
+      id: `${prefix}togglePlay`,
+      label: "Play / Pause Animation",
+      keywords: ["play", "pause", "preview", "timeline"],
+      description: "Plays or pauses the canvas animation from the playhead.",
+      run: () => {
+        controller.toggle();
+        return { playing: controller.getState().playing, time: controller.getState().time };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}play`,
+      label: "Play Animation",
+      keywords: ["preview", "timeline"],
+      enabled: () => controller.getState().playing ? "Already playing." : true,
+      run: () => controller.play()
+    },
+    {
+      ...base,
+      id: `${prefix}pause`,
+      label: "Pause Animation",
+      enabled: () => controller.getState().playing ? true : "Not playing.",
+      run: () => controller.pause()
+    },
+    {
+      ...base,
+      id: `${prefix}stop`,
+      label: "Stop Animation",
+      keywords: ["rewind", "reset"],
+      description: "Stops playback and returns to the start.",
+      run: () => controller.stop()
+    },
+    {
+      ...base,
+      id: `${prefix}seek`,
+      label: "Go to Time\u2026",
+      keywords: ["playhead", "scrub", "time"],
+      description: "Moves the playhead.",
+      params: {
+        type: "object",
+        properties: { time: { type: "number", minimum: 0, description: "Time in milliseconds." } },
+        required: ["time"]
+      },
+      run: (_ctx, params) => {
+        controller.seek(params.time);
+        return { time: controller.getState().time };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}addKeyframe`,
+      label: "Add Keyframe at Playhead",
+      keywords: ["key", "animate", "record"],
+      description: "Keys the selected nodes (or `ids`) at the playhead (or `time`): their animated properties, `properties`, or position.",
+      params: {
+        type: "object",
+        properties: {
+          ids: { type: "array", items: { type: "string" }, description: "Node ids (default: selected nodes)." },
+          properties: { type: "array", items: { type: "string" }, description: "Properties to key (default: animated ones, or x and y)." },
+          time: { type: "number", minimum: 0, description: "Time in ms (default: the playhead)." }
+        }
+      },
+      run: (_ctx, params) => controller.addKeyframe(_optionalChain([params, 'optionalAccess', _9 => _9.ids]), _optionalChain([params, 'optionalAccess', _10 => _10.properties]), _optionalChain([params, 'optionalAccess', _11 => _11.time]))
+    },
+    {
+      ...base,
+      id: `${prefix}deleteKeyframes`,
+      label: "Delete Keyframes",
+      keywords: ["remove", "clear"],
+      enabled: hasSelection,
+      run: () => controller.deleteKeyframes()
+    },
+    {
+      ...base,
+      id: `${prefix}setEasing`,
+      label: "Set Keyframe Easing\u2026",
+      keywords: ["interpolation", "ease", "bezier", "spring", "hold", "curve"],
+      description: "Sets the easing of the segments leaving the selected keyframes.",
+      params: {
+        type: "object",
+        properties: { easing: { type: "string", description: EASING_DESCRIPTION } },
+        required: ["easing"]
+      },
+      enabled: hasSelection,
+      run: (_ctx, params) => controller.setEasing(params.easing)
+    },
+    {
+      ...base,
+      id: `${prefix}toggleRecord`,
+      label: "Toggle Record Mode",
+      keywords: ["auto key", "record", "keyframe"],
+      description: "In record mode, changing a property at the playhead keys it.",
+      run: () => {
+        controller.toggleRecording();
+        return { recording: controller.getState().recording };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}nextKeyframe`,
+      label: "Next Keyframe",
+      keywords: ["jump", "navigate"],
+      run: () => controller.nextKeyframe()
+    },
+    {
+      ...base,
+      id: `${prefix}previousKeyframe`,
+      label: "Previous Keyframe",
+      keywords: ["jump", "navigate"],
+      run: () => controller.previousKeyframe()
+    },
+    {
+      ...base,
+      id: `${prefix}animateNode`,
+      label: "Animate Node\u2026",
+      keywords: ["tween", "transition", "move", "fade"],
+      description: "Animates a node from `from` (default: its current values) to `to` over `duration` ms, starting at `delay` ms.",
+      params: {
+        type: "object",
+        properties: {
+          nodeId: { type: "string", description: "Node to animate." },
+          to: VALUES,
+          from: VALUES,
+          duration: { type: "number", exclusiveMinimum: 0, description: "Duration in ms (default 1000)." },
+          delay: { type: "number", minimum: 0, description: "Start time in ms (default 0)." },
+          easing: { type: "string", description: EASING_DESCRIPTION }
+        },
+        required: ["nodeId", "to"]
+      },
+      run: (_ctx, params) => controller.animateNode(params.nodeId, {
+        to: params.to,
+        ...params.from ? { from: params.from } : {},
+        ...params.duration !== void 0 ? { duration: params.duration } : {},
+        ...params.delay !== void 0 ? { delay: params.delay } : {},
+        ...params.easing !== void 0 ? { easing: params.easing } : {}
+      })
+    },
+    {
+      ...base,
+      id: `${prefix}exportCss`,
+      label: "Export Animation as CSS",
+      keywords: ["keyframes", "css", "web animations"],
+      description: "Returns CSS @keyframes for a node's animation.",
+      readOnly: true,
+      params: {
+        type: "object",
+        properties: { nodeId: { type: "string" } },
+        required: ["nodeId"]
+      },
+      run: (_ctx, params) => controller.exportCss(params.nodeId)
+    }
+  ];
+}
+
+
+
+
+
+exports.createCommandPaletteController = createCommandPaletteController; exports.matchPaletteHotkey = matchPaletteHotkey; exports.createCanvasAnimationCommands = createCanvasAnimationCommands;

package/dist/{chunk-6ZSFRRJI.js → chunk-RSF6BT34.js}

@@ -35,7 +35,7 @@ import {
   searchDocument,
   sliceContainsTable,
   syncInitialContent
-} from "./chunk-X4FTNFIA.js";
+} from "./chunk-7MGPW2OV.js";
 import {
   chartDataToTable
 } from "./chunk-47V3WXDG.js";