@pixerate/editor 0.22.0 → 0.24.0

package/dist/commands/index.cjs

@@ -0,0 +1,860 @@
+"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 _class;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk26BVFKHUcjs = require('../chunk-26BVFKHU.cjs');
+
+
+var _chunkCPOKFNBGcjs = require('../chunk-CPOKFNBG.cjs');
+
+// src/commands/registry.ts
+var CommandRegistryError = class extends Error {
+  
+  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(_nullishCoalesce(_optionalChain([schema, 'optionalAccess', _2 => _2.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 = class {
+  /** Shortcut bindings of the registered commands (plus any user overrides). */
+  
+  __init() {this.commands = /* @__PURE__ */ new Map()}
+  __init2() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  __init3() {this.version = 0}
+  // Set while register/unregister change the shortcut map, so they notify once.
+  __init4() {this.muted = false}
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+    this.options = options;
+    this.shortcuts = new (0, _chunk26BVFKHUcjs.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 "${_optionalChain([s, 'optionalAccess', _3 => _3.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) => _chunk26BVFKHUcjs.toShortcutBindings.call(void 0, 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 _optionalChain([this, 'access', _4 => _4.commands, 'access', _5 => _5.get, 'call', _6 => _6(id), 'optionalAccess', _7 => _7.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 = _nullishCoalesce(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 = _chunkCPOKFNBGcjs.validateJsonSchema.call(void 0, 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: _nullishCoalesce(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;
+    _optionalChain([event, 'access', _8 => _8.preventDefault, 'optionalCall', _9 => _9()]);
+    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);
+      }
+    }
+  }
+}, _class);
+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 _nullishCoalesce(_optionalChain([fuzzyMatch, 'call', _10 => _10(query, text), 'optionalAccess', _11 => _11.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 = _nullishCoalesce(options.recents, () => ( []));
+  const disabledLast = _nullishCoalesce(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, _nullishCoalesce(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 ((_nullishCoalesce(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 _nullishCoalesce(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, ..._nullishCoalesce(entry.keywords, () => ( []))]) + (recentIndex >= 0 ? Math.max(1, 4 - recentIndex) : 0);
+      ranked.push({ entry, score, labelIndices: _nullishCoalesce(_optionalChain([label, 'optionalAccess', _12 => _12.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 = [..._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 rankCommands(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: _chunk26BVFKHUcjs.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', _13 => _13()]);
+          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, _nullishCoalesce(options.recentLimit, () => ( DEFAULT_RECENT_LIMIT)));
+      _optionalChain([options, 'access', _14 => _14.onRecentsChange, 'optionalCall', _15 => _15(recents)]);
+      const result = registry.execute(id, void 0, context());
+      lastResult = result;
+      update();
+      _optionalChain([options, 'access', _16 => _16.onRun, 'optionalCall', _17 => _17(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', _18 => _18.preventDefault, 'optionalCall', _19 => _19()]);
+      return true;
+    },
+    /** Re-reads commands and enablement. */
+    refresh() {
+      update();
+    },
+    destroy() {
+      _optionalChain([unsubscribeRegistry, 'optionalCall', _20 => _20()]);
+      unsubscribeRegistry = null;
+      listeners.clear();
+    }
+  };
+  return controller;
+}
+function matchPaletteHotkey(event, hotkey, platform) {
+  const map = new (0, _chunk26BVFKHUcjs.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 (e2) {
+    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) => !_optionalChain([options, 'access', _21 => _21.exclude, 'optionalCall', _22 => _22(e.id)]));
+  const allowed = (id) => registry.has(id) && !_optionalChain([options, 'access', _23 => _23.exclude, 'optionalCall', _24 => _24(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, _nullishCoalesce(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: _nullishCoalesce(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 = _nullishCoalesce(options.prefix, () => ( "history."));
+  const group = _nullishCoalesce(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 (0, _chunk26BVFKHUcjs.ShortcutMap)(DEFAULT_HISTORY_SHORTCUTS);
+  return _nullishCoalesce(_optionalChain([historyShortcutMap, 'access', _25 => _25.resolve, 'call', _26 => _26(event, options), 'optionalAccess', _27 => _27.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 = _nullishCoalesce(options.prefix, () => ( "canvas."));
+  const group = _nullishCoalesce(options.group, () => ( "Arrange"));
+  const scope = options.scope === null ? void 0 : _nullishCoalesce(options.scope, () => ( "canvas"));
+  const bindings = _nullishCoalesce(options.bindings, () => ( _chunk26BVFKHUcjs.DEFAULT_ARRANGE_SHORTCUTS));
+  const count = (params) => _nullishCoalesce(_optionalChain([params, 'optionalAccess', _28 => _28.ids, 'optionalAccess', _29 => _29.length]), () => ( _optionalChain([options, 'access', _30 => _30.getSelectedIds, 'optionalCall', _31 => _31(), 'access', _32 => _32.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: () => _optionalChain([options, 'access', _33 => _33.scenes, 'optionalAccess', _34 => _34.next, 'call', _35 => _35()]),
+    previousScene: () => _optionalChain([options, 'access', _36 => _36.scenes, 'optionalAccess', _37 => _37.previous, 'call', _38 => _38()])
+  };
+  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](_optionalChain([params, 'optionalAccess', _39 => _39.ids]))
+    };
+  });
+}
+function createSpreadsheetCommands(controller, options = {}) {
+  const prefix = _nullishCoalesce(options.prefix, () => ( "spreadsheet."));
+  const scope = options.scope === null ? void 0 : _nullishCoalesce(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() }
+  ];
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CommandRegistry = CommandRegistry; exports.CommandRegistryError = CommandRegistryError; exports.DEFAULT_HISTORY_SHORTCUTS = DEFAULT_HISTORY_SHORTCUTS; exports.DEFAULT_RECENT_LIMIT = DEFAULT_RECENT_LIMIT; exports.PLATFORMS = _chunk26BVFKHUcjs.PLATFORMS; exports.ShortcutMap = _chunk26BVFKHUcjs.ShortcutMap; exports.chordToString = _chunk26BVFKHUcjs.chordToString; exports.codeFromKey = _chunk26BVFKHUcjs.codeFromKey; exports.codeToKeyText = _chunk26BVFKHUcjs.codeToKeyText; exports.createArrangeCommands = createArrangeCommands; exports.createCommandPaletteController = createCommandPaletteController; exports.createCommandRegistry = createCommandRegistry; exports.createCommandToolProvider = createCommandToolProvider; exports.createHistoryCommands = createHistoryCommands; exports.createSpreadsheetCommands = createSpreadsheetCommands; exports.defineCommand = defineCommand; exports.detectPlatform = _chunk26BVFKHUcjs.detectPlatform; exports.effectiveChord = _chunk26BVFKHUcjs.effectiveChord; exports.effectiveChordKey = _chunk26BVFKHUcjs.effectiveChordKey; exports.eventCode = _chunk26BVFKHUcjs.eventCode; exports.exactBonus = exactBonus; exports.formatShortcut = _chunk26BVFKHUcjs.formatShortcut; exports.fuzzyMatch = fuzzyMatch; exports.fuzzyScore = fuzzyScore; exports.isEditableEventTarget = _chunk26BVFKHUcjs.isEditableEventTarget; exports.keyToCode = _chunk26BVFKHUcjs.keyToCode; exports.matchHistoryShortcut = matchHistoryShortcut; exports.matchPaletteHotkey = matchPaletteHotkey; exports.normalizeChord = _chunk26BVFKHUcjs.normalizeChord; exports.parseChord = _chunk26BVFKHUcjs.parseChord; exports.pushRecent = pushRecent; exports.rankCommands = rankCommands; exports.shortcutCode = _chunk26BVFKHUcjs.shortcutCode; exports.toShortcutBindings = _chunk26BVFKHUcjs.toShortcutBindings;
+//# sourceMappingURL=index.cjs.map