@pixerate/editor 0.22.0 → 0.24.0

package/dist/commands/index.js

@@ -0,0 +1,860 @@
+import {
+  DEFAULT_ARRANGE_SHORTCUTS,
+  PLATFORMS,
+  ShortcutMap,
+  chordToString,
+  codeFromKey,
+  codeToKeyText,
+  detectPlatform,
+  effectiveChord,
+  effectiveChordKey,
+  eventCode,
+  formatShortcut,
+  isEditableEventTarget,
+  keyToCode,
+  normalizeChord,
+  parseChord,
+  shortcutCode,
+  toShortcutBindings
+} from "../chunk-7DWMJCAT.js";
+import {
+  validateJsonSchema
+} from "../chunk-ARRTP33I.js";
+
+// src/commands/registry.ts
+var CommandRegistryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "CommandRegistryError";
+    this.code = code;
+  }
+};
+var COMMAND_ID_REGEX = /^[A-Za-z0-9_.:-]{1,128}$/;
+function enablement(result) {
+  if (result === void 0 || result === true) return { enabled: true };
+  if (result === false) return { enabled: false, reason: "This command is not available right now." };
+  return { enabled: false, reason: String(result) };
+}
+function unknownParams(spec, params) {
+  const keys = Object.keys(params).filter((k) => params[k] !== void 0);
+  if (keys.length === 0) return null;
+  const schema = spec.params;
+  if (schema && schema.additionalProperties !== void 0 && schema.additionalProperties !== false) return null;
+  const accepted = Object.keys(schema?.properties ?? {});
+  const bad = keys.find((k) => !accepted.includes(k));
+  if (!bad) return null;
+  return `Unknown parameter "${bad}" for command "${spec.id}"; expected ${accepted.length ? accepted.map((k) => `"${k}"`).join(", ") : "no parameters"}.`;
+}
+var isThenable = (value) => !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+var CommandRegistry = class {
+  /** Shortcut bindings of the registered commands (plus any user overrides). */
+  shortcuts;
+  commands = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  options;
+  version = 0;
+  // Set while register/unregister change the shortcut map, so they notify once.
+  muted = false;
+  constructor(options = {}) {
+    this.options = options;
+    this.shortcuts = new ShortcutMap([], options.shortcuts);
+    this.shortcuts.subscribe(() => {
+      if (!this.muted) this.notify();
+    });
+  }
+  /** Monotonic counter bumped on every change (useful as a snapshot key). */
+  getVersion() {
+    return this.version;
+  }
+  /** The default context. */
+  get context() {
+    const ctx = this.options.context;
+    return typeof ctx === "function" ? ctx() : ctx;
+  }
+  /**
+   * Registers a command (or several) and returns a function that unregisters it.
+   * Throws a `CommandRegistryError` for a duplicate or invalid id, or invalid chord text.
+   */
+  register(spec) {
+    const specs = Array.isArray(spec) ? spec : [spec];
+    const seen = /* @__PURE__ */ new Set();
+    for (const s of specs) {
+      if (!s || typeof s.id !== "string" || !COMMAND_ID_REGEX.test(s.id)) {
+        throw new CommandRegistryError("invalid_command", `Invalid command id "${s?.id}".`);
+      }
+      if (typeof s.run !== "function") {
+        throw new CommandRegistryError("invalid_command", `Command "${s.id}" has no run function.`);
+      }
+      if (this.commands.has(s.id) || seen.has(s.id)) {
+        throw new CommandRegistryError("duplicate_command", `Command "${s.id}" is already registered.`);
+      }
+      seen.add(s.id);
+    }
+    const bindings = specs.map((s) => toShortcutBindings(s.id, s.shortcut, s.scope));
+    const unbinds = [];
+    this.muted = true;
+    try {
+      for (const b of bindings) unbinds.push(this.shortcuts.bind(b));
+    } catch (error) {
+      unbinds.forEach((u) => u());
+      throw new CommandRegistryError("invalid_command", error instanceof Error ? error.message : String(error));
+    } finally {
+      this.muted = false;
+    }
+    specs.forEach((s, i) => this.commands.set(s.id, { spec: s, unbind: unbinds[i] }));
+    this.notify();
+    let registered = true;
+    return () => {
+      if (!registered) return;
+      registered = false;
+      let changed = false;
+      for (const s of specs) {
+        const entry = this.commands.get(s.id);
+        if (entry && entry.spec === s) {
+          this.commands.delete(s.id);
+          this.unbindQuietly(entry);
+          changed = true;
+        }
+      }
+      if (changed) this.notify();
+    };
+  }
+  /** Removes a command by id. Returns whether it was registered. */
+  unregister(id) {
+    const entry = this.commands.get(id);
+    if (!entry) return false;
+    this.commands.delete(id);
+    this.unbindQuietly(entry);
+    this.notify();
+    return true;
+  }
+  unbindQuietly(entry) {
+    this.muted = true;
+    try {
+      entry.unbind();
+    } finally {
+      this.muted = false;
+    }
+  }
+  has(id) {
+    return this.commands.has(id);
+  }
+  get(id) {
+    return this.commands.get(id)?.spec;
+  }
+  /** Registered ids in registration order. */
+  ids() {
+    return [...this.commands.keys()];
+  }
+  /** Whether `id` can run now (`{ enabled, reason }`); `params` are the targets a caller named. */
+  isEnabled(id, params, context = this.context) {
+    const spec = this.get(id);
+    if (!spec) return { enabled: false, reason: `Unknown command "${id}".` };
+    if (!spec.enabled) return { enabled: true };
+    try {
+      return enablement(spec.enabled(context, params));
+    } catch (error) {
+      return { enabled: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  /** Commands for menus, palettes and agents, with their current enablement. */
+  list(options = {}) {
+    const scopes = options.scope === void 0 ? null : typeof options.scope === "string" ? [options.scope] : options.scope;
+    const context = "context" in options ? options.context : this.context;
+    const platform = this.shortcuts.platform;
+    const out = [];
+    for (const { spec } of this.commands.values()) {
+      if (spec.hidden && !options.includeHidden) continue;
+      if (scopes && spec.scope !== void 0 && !scopes.includes(spec.scope)) continue;
+      const { enabled, reason } = this.isEnabled(spec.id, void 0, context);
+      if (options.enabledOnly && !enabled) continue;
+      out.push({
+        id: spec.id,
+        label: spec.label,
+        ...spec.group !== void 0 ? { group: spec.group } : {},
+        ...spec.keywords ? { keywords: spec.keywords } : {},
+        ...spec.description !== void 0 ? { description: spec.description } : {},
+        ...spec.params ? { params: spec.params } : {},
+        ...spec.scope !== void 0 ? { scope: spec.scope } : {},
+        shortcuts: this.shortcuts.forCommand(spec.id, platform),
+        enabled,
+        ...enabled ? {} : { disabledReason: reason },
+        undoable: !!spec.undoable,
+        readOnly: !!spec.readOnly
+      });
+    }
+    return out;
+  }
+  check(id, params, context) {
+    const spec = this.get(id);
+    if (!spec) return { ok: false, id, code: "unknown_command", message: `Unknown command "${id}".` };
+    const input = params ?? {};
+    if (typeof input !== "object" || Array.isArray(input)) {
+      return { ok: false, id, code: "invalid_params", message: `Parameters for command "${id}" must be an object.` };
+    }
+    const unknown = unknownParams(spec, input);
+    if (unknown) return { ok: false, id, code: "invalid_params", message: unknown };
+    if (spec.params) {
+      const details = validateJsonSchema(input, spec.params);
+      if (details.length > 0) {
+        return {
+          ok: false,
+          id,
+          code: "invalid_params",
+          message: `Invalid parameters for command "${id}": ${details.map((d) => `${d.path} ${d.message}`).join("; ")}`,
+          details
+        };
+      }
+    }
+    const { enabled, reason } = this.isEnabled(id, params === void 0 ? void 0 : input, context);
+    if (!enabled) return { ok: false, id, code: "disabled", message: reason ?? "Disabled." };
+    return { spec, params: input };
+  }
+  invoke(spec, params, context) {
+    const history = this.options.history;
+    if (!spec.undoable || !history) return spec.run(context, params);
+    let value;
+    history.batch(spec.label, () => {
+      value = spec.run(context, params);
+    });
+    return value;
+  }
+  /**
+   * Runs a command synchronously and returns a structured result; never throws.
+   * A command whose `run` returns a promise yields `{ ok: true, result: promise }`
+   * (use `executeAsync` to await it and catch its rejection).
+   */
+  execute(id, params, context = this.context) {
+    const checked = this.check(id, params, context);
+    if ("ok" in checked) return checked;
+    try {
+      const result = this.invoke(checked.spec, checked.params, context);
+      this.notify();
+      return { ok: true, id, result };
+    } catch (error) {
+      this.notify();
+      return { ok: false, id, code: "failed", message: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  /** Like `execute`, but awaits async commands (rejections become `failed` results). */
+  async executeAsync(id, params, context = this.context) {
+    const outcome = this.execute(id, params, context);
+    if (!outcome.ok || !isThenable(outcome.result)) return outcome;
+    try {
+      const result = await outcome.result;
+      this.notify();
+      return { ok: true, id, result };
+    } catch (error) {
+      this.notify();
+      return { ok: false, id, code: "failed", message: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  /**
+   * Resolves a keydown event to a command (see `ShortcutMap.resolve`) and runs it when
+   * enabled, calling `preventDefault()`. Disabled commands leave the event alone, so the
+   * browser or a focused editor can still handle it. Returns the result, or `null`.
+   */
+  handleKeyDown(event, options = {}) {
+    if (event.defaultPrevented) return null;
+    const match = this.shortcuts.resolve(event, options);
+    if (!match) return null;
+    const context = "context" in options ? options.context : this.context;
+    if (!this.isEnabled(match.command, void 0, context).enabled) return null;
+    event.preventDefault?.();
+    return this.execute(match.command, void 0, context);
+  }
+  /** Display-ready primary shortcut of a command (`⇧⌘Z` / `Ctrl+Shift+Z`), or `undefined`. */
+  shortcutFor(id, platform = this.shortcuts.platform) {
+    return this.shortcuts.forCommand(id, platform)[0];
+  }
+  /**
+   * Subscribes to changes: commands registered or removed, shortcut overrides, executed
+   * commands and `invalidate()` calls (e.g. when enablement inputs change).
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Tells subscribers that enablement may have changed (e.g. the selection changed). */
+  invalidate() {
+    this.notify();
+  }
+  notify() {
+    this.version++;
+    for (const listener of Array.from(this.listeners)) {
+      try {
+        listener();
+      } catch (error) {
+        console.error("[CommandRegistry] Error in listener:", error);
+      }
+    }
+  }
+};
+function createCommandRegistry(options) {
+  return new CommandRegistry(options);
+}
+function defineCommand(spec) {
+  return spec;
+}
+
+// src/commands/palette.ts
+var WORD_SEPARATORS = /* @__PURE__ */ new Set([" ", "-", "_", ".", "/", ":", "\u203A", "("]);
+function fuzzyMatch(query, text) {
+  const q = query.trim().toLowerCase();
+  if (!q) return { score: 0, indices: [] };
+  const t = text.toLowerCase();
+  let score = 0;
+  let ti = 0;
+  let last = -2;
+  const indices = [];
+  for (const qc of q) {
+    if (qc === " ") continue;
+    let found = false;
+    while (ti < t.length) {
+      if (t[ti] === qc) {
+        score += last === ti - 1 ? 8 : 1;
+        if (ti === 0 || WORD_SEPARATORS.has(t[ti - 1])) score += 5;
+        last = ti;
+        indices.push(ti);
+        ti++;
+        found = true;
+        break;
+      }
+      ti++;
+    }
+    if (!found) return null;
+  }
+  return { score: score - Math.floor(t.length / 8), indices };
+}
+function fuzzyScore(query, text) {
+  return fuzzyMatch(query, text)?.score ?? null;
+}
+function exactBonus(query, names) {
+  const q = query.trim().toLowerCase();
+  if (!q) return 0;
+  return names.some((n) => n.replace(/(…|\.\.\.)$/, "").trim().toLowerCase() === q) ? 1e3 : 0;
+}
+var DEFAULT_RECENT_LIMIT = 8;
+function pushRecent(list, id, cap = DEFAULT_RECENT_LIMIT) {
+  return [id, ...list.filter((x) => x !== id)].slice(0, Math.max(0, cap));
+}
+function rankCommands(query, entries, options = {}) {
+  const recents = options.recents ?? [];
+  const disabledLast = options.disabledLast ?? true;
+  const q = query.trim();
+  let ranked;
+  if (!q) {
+    const byId = new Map(entries.map((e) => [e.id, e]));
+    const recentIds = [...new Set(recents)].filter((id) => byId.has(id)).slice(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
+    const recentSet = new Set(recentIds);
+    ranked = recentIds.map((id, i) => ({ entry: byId.get(id), score: 1e3 - i, labelIndices: [], recent: true, order: i }));
+    if ((options.emptyQuery ?? "all") === "all") {
+      entries.forEach((entry, i) => {
+        if (!recentSet.has(entry.id)) ranked.push({ entry, score: 0, labelIndices: [], recent: false, order: recentIds.length + i });
+      });
+    }
+  } else {
+    ranked = [];
+    entries.forEach((entry, order) => {
+      const label = fuzzyMatch(q, entry.label);
+      const candidates = [];
+      if (label) candidates.push(label.score);
+      if (entry.group) {
+        const grouped = fuzzyScore(q, `${entry.group} ${entry.label}`);
+        if (grouped !== null) candidates.push(grouped - 1);
+      }
+      for (const keyword of entry.keywords ?? []) {
+        const s = fuzzyScore(q, keyword);
+        if (s !== null) candidates.push(s - 2);
+      }
+      const byId = fuzzyScore(q, entry.id);
+      if (byId !== null) candidates.push(byId - 3);
+      if (candidates.length === 0) return;
+      const recentIndex = recents.indexOf(entry.id);
+      const score = Math.max(...candidates) + exactBonus(q, [entry.label, ...entry.keywords ?? []]) + (recentIndex >= 0 ? Math.max(1, 4 - recentIndex) : 0);
+      ranked.push({ entry, score, labelIndices: label?.indices ?? [], recent: false, order });
+    });
+    ranked.sort((a, b) => b.score - a.score || a.entry.label.length - b.entry.label.length || a.order - b.order);
+  }
+  if (disabledLast) {
+    ranked = [...ranked.filter((r) => r.entry.enabled !== false), ...ranked.filter((r) => r.entry.enabled === false)];
+  }
+  const out = ranked.map(({ order: _order, ...rest }) => rest);
+  return options.limit !== void 0 ? out.slice(0, options.limit) : out;
+}
+
+// src/commands/paletteController.ts
+function createCommandPaletteController(registry, options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  let open = false;
+  let query = "";
+  let activeIndex = 0;
+  let recents = [...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 = options.platform ?? registry.shortcuts.platform;
+    return rankCommands(query, entries, {
+      recents,
+      recentLimit: options.recentLimit,
+      limit: 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: formatShortcut(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) {
+          unsubscribeRegistry?.();
+          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 = pushRecent(recents, id, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
+      options.onRecentsChange?.(recents);
+      const result = registry.execute(id, void 0, context());
+      lastResult = result;
+      update();
+      options.onRun?.(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;
+      }
+      event.preventDefault?.();
+      return true;
+    },
+    /** Re-reads commands and enablement. */
+    refresh() {
+      update();
+    },
+    destroy() {
+      unsubscribeRegistry?.();
+      unsubscribeRegistry = null;
+      listeners.clear();
+    }
+  };
+  return controller;
+}
+function matchPaletteHotkey(event, hotkey, platform) {
+  const map = new ShortcutMap([{ command: "palette", chord: hotkey, allowInEditable: true }], platform ? { platform } : {});
+  return map.resolve(event) !== null;
+}
+
+// src/commands/agentTools.ts
+var toJson = (value) => {
+  if (value === void 0) return null;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+};
+function errorResult(result) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: `${result.code}: ${result.message}` }],
+    structuredContent: {
+      error: { code: result.code, message: result.message, command: result.id, ...result.details ? { details: result.details } : {} }
+    }
+  };
+}
+function createCommandToolProvider(registry, options = {}) {
+  const context = () => {
+    const c = options.context;
+    if (c === void 0) return registry.context;
+    return typeof c === "function" ? c() : c;
+  };
+  const visible = () => registry.list({ scope: options.scope, context: context() }).filter((e) => !options.exclude?.(e.id));
+  const allowed = (id) => registry.has(id) && !options.exclude?.(id) && visible().some((e) => e.id === id);
+  async function runOne(id, params) {
+    if (!allowed(id)) return { ok: false, id, code: "unknown_command", message: `Unknown command "${id}".` };
+    return registry.executeAsync(id, params ?? {}, context());
+  }
+  const listCommands = {
+    name: "list_commands",
+    title: "List commands",
+    description: "Lists the commands you can run with run_command: id, label, group, params (JSON Schema), shortcuts, and whether each is enabled now (with the reason when it is not).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Fuzzy filter on label, keywords, group and id." },
+        enabledOnly: { type: "boolean", description: "Only commands that can run now (default false)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "List commands", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: ({ query = "", enabledOnly = false }) => {
+      let entries = visible();
+      if (enabledOnly) entries = entries.filter((e) => e.enabled);
+      if (String(query).trim()) entries = rankCommands(String(query), entries, { disabledLast: false }).map((r) => r.entry);
+      return {
+        commands: entries.map((e) => ({
+          id: e.id,
+          label: e.label,
+          ...e.group ? { group: e.group } : {},
+          ...e.description ? { description: e.description } : {},
+          ...e.params ? { params: e.params } : {},
+          ...e.shortcuts.length ? { shortcuts: e.shortcuts } : {},
+          enabled: e.enabled,
+          ...e.disabledReason ? { disabledReason: e.disabledReason } : {},
+          readOnly: e.readOnly
+        }))
+      };
+    }
+  };
+  const runCommandTool = () => {
+    const ids = visible().map((e) => e.id);
+    return {
+      name: "run_command",
+      title: "Run a command",
+      description: "Runs one command by id with optional params (see list_commands for each command's params schema). Unknown params are rejected.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Command id from list_commands.", ...ids.length ? { enum: ids } : {} },
+          params: { type: "object", description: "Command parameters." }
+        },
+        required: ["id"],
+        additionalProperties: false
+      },
+      annotations: { title: "Run a command", readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      handler: async ({ id, params }) => {
+        const result = await runOne(String(id), params);
+        return result.ok ? { id: result.id, ok: true, result: toJson(result.result) } : errorResult(result);
+      }
+    };
+  };
+  const runCommands = {
+    name: "run_commands",
+    title: "Run several commands",
+    description: "Runs several commands in order: {steps: [{id, params?}], stopOnError?: true}. Each step is its own command and undo step; the batch is NOT atomic (steps before a failure stay applied). Returns {completed, failed, results: [{id, ok, result | code, message}]}.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        steps: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string", description: "Command id." },
+              params: { type: "object", description: "Command parameters." }
+            },
+            required: ["id"],
+            additionalProperties: false
+          }
+        },
+        stopOnError: { type: "boolean", description: "Stop at the first failing step (default true)." }
+      },
+      required: ["steps"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Run several commands",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    handler: async ({ steps, stopOnError = true }) => {
+      let completed = 0;
+      let failed = 0;
+      const results = [];
+      for (const step of steps) {
+        const result = await runOne(step.id, step.params);
+        if (result.ok) {
+          completed++;
+          results.push({ id: result.id, ok: true, result: toJson(result.result) });
+        } else {
+          failed++;
+          results.push({ id: result.id, ok: false, code: result.code, message: result.message });
+          if (stopOnError) break;
+        }
+      }
+      const summary = { completed, failed, skipped: steps.length - completed - failed, results };
+      return failed > 0 ? { isError: true, content: [{ type: "text", text: JSON.stringify(summary) }], structuredContent: summary } : summary;
+    }
+  };
+  return {
+    id: options.id ?? "commands",
+    namespace: options.namespace,
+    tools: () => [listCommands, runCommandTool(), runCommands],
+    subscribe: (notify) => registry.subscribe(notify)
+  };
+}
+
+// src/commands/builtins.ts
+var DEFAULT_HISTORY_SHORTCUTS = [
+  { command: "undo", chord: "Mod+Z" },
+  { command: "redo", chord: "Mod+Shift+Z" },
+  { command: "redo", chord: "Mod+Y", platforms: ["windows", "linux"] }
+];
+function createHistoryCommands(history, options = {}) {
+  const prefix = options.prefix ?? "history.";
+  const group = options.group ?? "Edit";
+  const shortcutsOf = (command) => DEFAULT_HISTORY_SHORTCUTS.filter((b) => b.command === command).map(({ command: _c, ...rest }) => rest);
+  return [
+    {
+      id: `${prefix}undo`,
+      label: "Undo",
+      group,
+      keywords: ["revert", "back"],
+      description: "Reverts the last change.",
+      shortcut: shortcutsOf("undo"),
+      ...options.scope ? { scope: options.scope } : {},
+      enabled: () => history.getState().canUndo ? true : "Nothing to undo.",
+      run: () => {
+        history.undo();
+        return { undone: true, state: history.getState() };
+      }
+    },
+    {
+      id: `${prefix}redo`,
+      label: "Redo",
+      group,
+      keywords: ["repeat", "forward"],
+      description: "Re-applies the last undone change.",
+      shortcut: shortcutsOf("redo"),
+      ...options.scope ? { scope: options.scope } : {},
+      enabled: () => history.getState().canRedo ? true : "Nothing to redo.",
+      run: () => {
+        history.redo();
+        return { redone: true, state: history.getState() };
+      }
+    }
+  ];
+}
+var historyShortcutMap = null;
+function matchHistoryShortcut(event, options = {}) {
+  historyShortcutMap ??= new ShortcutMap(DEFAULT_HISTORY_SHORTCUTS);
+  return historyShortcutMap.resolve(event, options)?.command ?? null;
+}
+var ARRANGE_LABELS = {
+  alignLeft: "Align Left",
+  alignCenter: "Align Horizontal Centers",
+  alignRight: "Align Right",
+  alignTop: "Align Top",
+  alignMiddle: "Align Vertical Centers",
+  alignBottom: "Align Bottom",
+  distributeHorizontal: "Distribute Horizontally",
+  distributeVertical: "Distribute Vertically",
+  lock: "Lock",
+  unlock: "Unlock",
+  bringForward: "Bring Forward",
+  sendBackward: "Send Backward",
+  bringToFront: "Bring to Front",
+  sendToBack: "Send to Back",
+  nextScene: "Next Scene",
+  previousScene: "Previous Scene"
+};
+var IDS_PARAMS = {
+  type: "object",
+  properties: {
+    ids: {
+      type: "array",
+      items: { type: "string" },
+      description: "Node ids to act on (default: the selection)."
+    }
+  }
+};
+function createArrangeCommands(controller, options = {}) {
+  const prefix = options.prefix ?? "canvas.";
+  const group = options.group ?? "Arrange";
+  const scope = options.scope === null ? void 0 : options.scope ?? "canvas";
+  const bindings = options.bindings ?? DEFAULT_ARRANGE_SHORTCUTS;
+  const count = (params) => params?.ids?.length ?? options.getSelectedIds?.().length;
+  const needs = (min, what) => (_, params) => {
+    const n = count(params);
+    if (n === void 0 || n >= min) return true;
+    return min === 1 ? `Select a ${what} first.` : `Select at least ${min} ${what}s.`;
+  };
+  const run = {
+    alignLeft: (ids) => controller.align("left", ids),
+    alignCenter: (ids) => controller.align("center", ids),
+    alignRight: (ids) => controller.align("right", ids),
+    alignTop: (ids) => controller.align("top", ids),
+    alignMiddle: (ids) => controller.align("middle", ids),
+    alignBottom: (ids) => controller.align("bottom", ids),
+    distributeHorizontal: (ids) => controller.distribute("horizontal", "gaps", ids),
+    distributeVertical: (ids) => controller.distribute("vertical", "gaps", ids),
+    lock: (ids) => controller.lock(ids),
+    unlock: (ids) => controller.unlock(ids),
+    bringForward: (ids) => controller.reorder("bringForward", ids),
+    sendBackward: (ids) => controller.reorder("sendBackward", ids),
+    bringToFront: (ids) => controller.reorder("bringToFront", ids),
+    sendToBack: (ids) => controller.reorder("sendToBack", ids),
+    nextScene: () => options.scenes?.next(),
+    previousScene: () => options.scenes?.previous()
+  };
+  const actions = Object.keys(ARRANGE_LABELS);
+  return actions.filter((action) => options.scenes || action !== "nextScene" && action !== "previousScene").map((action) => {
+    const isScene = action === "nextScene" || action === "previousScene";
+    const enabled = isScene ? void 0 : action.startsWith("align") ? needs(2, "node") : action.startsWith("distribute") ? needs(3, "node") : needs(1, "node");
+    return {
+      id: `${prefix}${action}`,
+      label: ARRANGE_LABELS[action],
+      group: isScene ? "Scenes" : group,
+      keywords: isScene ? ["scene", "slide", "page"] : action.startsWith("align") ? ["align"] : ["arrange", "layer", "order"],
+      ...scope ? { scope } : {},
+      shortcut: bindings.filter((b) => b.action === action).map((b) => b.label),
+      ...isScene ? {} : { params: IDS_PARAMS },
+      ...enabled ? { enabled } : {},
+      run: (_ctx, params) => run[action](params?.ids)
+    };
+  });
+}
+function createSpreadsheetCommands(controller, options = {}) {
+  const prefix = options.prefix ?? "spreadsheet.";
+  const scope = options.scope === null ? void 0 : options.scope ?? "spreadsheet";
+  const hasRange = () => controller.selectedRange ? true : "Select a range first.";
+  const base = { group: "Table", ...scope ? { scope } : {} };
+  return [
+    { ...base, id: `${prefix}toggleFilters`, label: "Toggle Filters", keywords: ["filter"], run: () => controller.toggleFilters() },
+    {
+      ...base,
+      id: `${prefix}clearFilters`,
+      label: "Clear Filters",
+      keywords: ["filter", "reset"],
+      enabled: () => controller.getFilterState().rules.length > 0 ? true : "No filters to clear.",
+      run: () => controller.clearFilters()
+    },
+    { ...base, id: `${prefix}unhideAll`, label: "Unhide All Rows and Columns", keywords: ["show", "hidden"], run: () => controller.unhideAll() },
+    { ...base, id: `${prefix}mergeCells`, label: "Merge Cells", keywords: ["combine"], enabled: hasRange, run: () => controller.mergeCells() },
+    { ...base, id: `${prefix}unmergeCells`, label: "Unmerge Cells", keywords: ["split"], enabled: hasRange, run: () => controller.unmergeCells() },
+    { ...base, id: `${prefix}transposeRange`, label: "Transpose Range", keywords: ["rotate", "swap rows columns"], enabled: hasRange, run: () => controller.transposeRange() }
+  ];
+}
+export {
+  CommandRegistry,
+  CommandRegistryError,
+  DEFAULT_HISTORY_SHORTCUTS,
+  DEFAULT_RECENT_LIMIT,
+  PLATFORMS,
+  ShortcutMap,
+  chordToString,
+  codeFromKey,
+  codeToKeyText,
+  createArrangeCommands,
+  createCommandPaletteController,
+  createCommandRegistry,
+  createCommandToolProvider,
+  createHistoryCommands,
+  createSpreadsheetCommands,
+  defineCommand,
+  detectPlatform,
+  effectiveChord,
+  effectiveChordKey,
+  eventCode,
+  exactBonus,
+  formatShortcut,
+  fuzzyMatch,
+  fuzzyScore,
+  isEditableEventTarget,
+  keyToCode,
+  matchHistoryShortcut,
+  matchPaletteHotkey,
+  normalizeChord,
+  parseChord,
+  pushRecent,
+  rankCommands,
+  shortcutCode,
+  toShortcutBindings
+};
+//# sourceMappingURL=index.js.map