@pixerate/editor 0.265.0 → 0.266.1

package/dist/commands/index.js

@@ -1,3 +1,16 @@
+import {
+  CommandRegistry,
+  CommandRegistryError,
+  DEFAULT_RECENT_LIMIT,
+  createCommandRegistry,
+  createCommandToolProvider,
+  defineCommand,
+  exactBonus,
+  fuzzyMatch,
+  fuzzyScore,
+  pushRecent,
+  rankCommands
+} from "../chunk-HAEB3MZD.js";
 import {
   DEFAULT_HISTORY_SHORTCUTS,
   createArrangeCommands,
@@ -9,7 +22,8 @@ import {
   hasVariantCommands,
   matchHistoryShortcut,
   planFreehandPlayback
-} from "../chunk-TMDDMJCR.js";
+} from "../chunk-472INMWH.js";
+import "../chunk-55ALHYJY.js";
 import {
   PLATFORMS,
   ShortcutMap,
@@ -27,387 +41,14 @@ import {
   parseChord,
   shortcutCode,
   toShortcutBindings
-} from "../chunk-LPFQHVCO.js";
-import {
-  derivePlaybackSteps
-} from "../chunk-EHTX34RE.js";
+} from "../chunk-PXXXRCME.js";
+import "../chunk-EHTX34RE.js";
 import {
   createFormatCommands,
   formatCommandsFor
 } from "../chunk-NZ3CTY7K.js";
 import "../chunk-IVSWRVB4.js";
-import {
-  validateJsonSchema
-} from "../chunk-V2ZCJRDM.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 };
-  }
-  /** The history `undoable` commands (and atomic agent batches) record into, if any. */
-  get history() {
-    return this.options.history;
-  }
-  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;
-}
+import "../chunk-V2ZCJRDM.js";
 
 // src/commands/paletteController.ts
 function createCommandPaletteController(registry, options = {}) {
@@ -560,277 +201,6 @@ function matchPaletteHotkey(event, hotkey, 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);
-  function resolveRefs(value, results) {
-    if (typeof value === "string") {
-      const m = /^\$(\d+|last)((?:\.[\w-]+|\[\d+\])*)$/.exec(value);
-      if (!m) return value;
-      const index = m[1] === "last" ? results.length - 1 : Number(m[1]);
-      if (index < 0 || index >= results.length) throw new Error(`"${value}" refers to step ${m[1]}, but only ${results.length} step${results.length === 1 ? " has" : "s have"} run.`);
-      let cur = results[index];
-      for (const part of m[2].match(/[\w-]+/g) ?? []) {
-        if (cur === null || typeof cur !== "object" || !(part in cur)) throw new Error(`"${value}": step ${index}'s result has no "${part}".`);
-        cur = cur[part];
-      }
-      return cur;
-    }
-    if (Array.isArray(value)) return value.map((v) => resolveRefs(v, results));
-    if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, resolveRefs(v, results)]));
-    return value;
-  }
-  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());
-  }
-  function planOne(id, params) {
-    const spec = registry.get(id);
-    if (!spec) return null;
-    const surface = spec.playbackSurface ?? spec.scope ?? (id.includes(".") ? id.slice(0, id.indexOf(".")) : void 0);
-    const planned = spec.plan?.(context(), params ?? {});
-    const own = !planned ? [] : Array.isArray(planned) ? planned : planned.steps;
-    const steps = own.length ? own : derivePlaybackSteps(params);
-    return {
-      steps,
-      ...surface ? { surface } : {},
-      ...planned && !Array.isArray(planned) && planned.surface ? { surface: planned.surface } : {},
-      ...spec.readOnly ? { readOnly: true } : {}
-    };
-  }
-  const hasRefs = (value) => typeof value === "string" ? value.startsWith("$") : Array.isArray(value) ? value.some(hasRefs) : !!value && typeof value === "object" && Object.values(value).some(hasRefs);
-  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 },
-      plan: ({ id, params }) => planOne(String(id), params),
-      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, atomic?: false, label?}. A param string "$0.id" or "$last.id" is replaced by that path of an earlier step's result, so you can use an id a step created without another round trip. Not atomic by default (each step is its own undo step and steps before a failure stay applied); atomic: true makes the batch one undo step named label and takes everything back if a step fails. Returns {completed, failed, skipped, results: [{id, ok, result | code, message}]}.`,
-    inputSchema: {
-      type: "object",
-      properties: {
-        steps: {
-          type: "array",
-          minItems: 1,
-          maxItems: 256,
-          description: "Commands to run in order (at most 256).",
-          items: {
-            type: "object",
-            properties: {
-              id: { type: "string", description: "Command id." },
-              params: { type: "object", description: 'Command parameters; strings like "$0.id" or "$last.series[0]" refer to earlier results.' }
-            },
-            required: ["id"],
-            additionalProperties: false
-          }
-        },
-        stopOnError: { type: "boolean", description: "Stop at the first failing step (default true). Ignored when atomic." },
-        atomic: { type: "boolean", description: "Run every step as one undo step, all or nothing (default false). Needs a registry created with a history." },
-        label: { type: "string", description: 'Undo step name for an atomic batch (default "Run commands").' }
-      },
-      required: ["steps"],
-      additionalProperties: false
-    },
-    annotations: {
-      title: "Run several commands",
-      readOnlyHint: false,
-      destructiveHint: true,
-      idempotentHint: false,
-      openWorldHint: false
-    },
-    // Plays the steps' own plans one after another, then runs the batch once. Steps whose
-    // params refer to earlier results can't be planned before the batch runs and are skipped.
-    plan: ({ steps }) => {
-      const list = steps ?? [];
-      let surface;
-      const out = [];
-      for (const s of list) {
-        if (hasRefs(s.params)) continue;
-        const planned = planOne(s.id, s.params);
-        if (!planned) continue;
-        surface ??= planned.surface;
-        if (planned.surface && planned.surface !== surface) continue;
-        out.push(...planned.steps.filter((step) => step.type !== "commit"));
-      }
-      return out.length || surface ? { steps: out.length ? [...out, { type: "commit" }] : [], ...surface ? { surface } : {} } : null;
-    },
-    handler: async ({ steps, stopOnError = true, atomic = false, label = "Run commands" }) => {
-      let completed = 0;
-      let failed = 0;
-      const results = [];
-      const values = [];
-      const list = steps;
-      const step = (s, run) => {
-        let params;
-        try {
-          params = resolveRefs(s.params, values);
-        } catch (error) {
-          failed++;
-          results.push({ id: s.id, ok: false, code: "invalid_params", message: error.message });
-          return false;
-        }
-        const result = run(s.id, params);
-        if (result.ok) {
-          completed++;
-          const value = toJson(result.result);
-          values.push(value);
-          results.push({ id: result.id, ok: true, result: value });
-          return true;
-        }
-        failed++;
-        values.push(null);
-        results.push({ id: result.id, ok: false, code: result.code, message: result.message });
-        return false;
-      };
-      if (atomic) {
-        const history = registry.history;
-        if (!history) {
-          const message = "atomic batches need a CommandRegistry created with { history }; run the steps without atomic, or ask the host to share its history.";
-          return { isError: true, content: [{ type: "text", text: message }], structuredContent: { error: { code: "unsupported", message } } };
-        }
-        const syncRun = (id, params) => {
-          if (!allowed(id)) return { ok: false, id, code: "unknown_command", message: `Unknown command "${id}".` };
-          const r = registry.execute(id, params ?? {}, context());
-          if (r.ok && r.result && typeof r.result.then === "function") return { ok: false, id, code: "failed", message: `"${id}" runs asynchronously and cannot be part of an atomic batch.` };
-          return r;
-        };
-        try {
-          history.batch(String(label), () => {
-            for (const s of list) if (!step(s, syncRun)) throw new Error("rollback");
-          });
-        } catch {
-        }
-        const summary2 = { completed: failed ? 0 : completed, failed, skipped: list.length - completed - failed, rolledBack: failed > 0, results };
-        return failed > 0 ? { isError: true, content: [{ type: "text", text: JSON.stringify(summary2) }], structuredContent: summary2 } : summary2;
-      }
-      for (const s of list) {
-        let params;
-        try {
-          params = resolveRefs(s.params, values);
-        } catch (error) {
-          failed++;
-          values.push(null);
-          results.push({ id: s.id, ok: false, code: "invalid_params", message: error.message });
-          if (stopOnError) break;
-          continue;
-        }
-        const result = await runOne(s.id, params);
-        if (result.ok) {
-          completed++;
-          const value = toJson(result.result);
-          values.push(value);
-          results.push({ id: result.id, ok: true, result: value });
-        } else {
-          failed++;
-          values.push(null);
-          results.push({ id: result.id, ok: false, code: result.code, message: result.message });
-          if (stopOnError) break;
-        }
-      }
-      const summary = { completed, failed, skipped: list.length - completed - failed, results };
-      return failed > 0 ? { isError: true, content: [{ type: "text", text: JSON.stringify(summary) }], structuredContent: summary } : summary;
-    }
-  };
-  const picked = (id) => typeof options.tools === "function" ? options.tools(id) : !!options.tools?.includes(id);
-  const toolNameOf = (id) => options.toolName?.(id) ?? id.replace(/[^A-Za-z0-9_-]/g, "_");
-  const commandTool = (entry) => ({
-    name: toolNameOf(entry.id),
-    title: entry.label,
-    description: `${entry.description ?? entry.label}${entry.readOnly ? "" : ` (Runs the "${entry.id}" command; refused with the reason when it cannot run now.)`}`,
-    inputSchema: entry.params ?? { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: entry.label, readOnlyHint: entry.readOnly, destructiveHint: !entry.readOnly, idempotentHint: entry.readOnly, openWorldHint: false },
-    plan: (args) => planOne(entry.id, args),
-    handler: async (args) => {
-      const result = await runOne(entry.id, args);
-      return result.ok ? toJson(result.result) : errorResult(result);
-    }
-  });
-  return {
-    id: options.id ?? "commands",
-    namespace: options.namespace,
-    title: "Commands",
-    description: "The app's commands (menu and keyboard actions) with their params schemas: list them, run one, or run several as one undo step.",
-    skill: "pixerate-agent-tools",
-    tools: () => [listCommands, runCommandTool(), runCommands, ...options.tools ? visible().filter((e) => picked(e.id)).map(commandTool) : []],
-    subscribe: (notify) => registry.subscribe(notify)
-  };
-}
-
 // 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 = {