@pixerate/editor 0.140.3 → 0.141.0

package/dist/chunk-MFFE55CS.js

@@ -0,0 +1,406 @@
+import {
+  PRESENCE_COLORS,
+  realPresenceClock
+} from "./chunk-PEEP2YR7.js";
+
+// src/tools/playback.ts
+var ARG_KINDS = {
+  nodeId: "node",
+  edgeId: "edge",
+  layerId: "layer",
+  clipId: "clip",
+  trackId: "track",
+  seriesId: "series",
+  parameterId: "parameter",
+  keyframeId: "keyframe",
+  shapeId: "shape"
+};
+function pushRef(out, kind, id) {
+  if (typeof id !== "string" || !id) return;
+  if (!out.some((r) => r.kind === kind && r.id === id)) out.push({ kind, id });
+}
+function playbackRefsFromArgs(args, defaultKind = "item") {
+  const out = [];
+  const visit = (value, depth) => {
+    if (!value || typeof value !== "object" || Array.isArray(value) || depth > 1) return;
+    const record = value;
+    pushRef(out, defaultKind, record.id);
+    if (Array.isArray(record.ids)) for (const id of record.ids) pushRef(out, defaultKind, id);
+    for (const [key, kind] of Object.entries(ARG_KINDS)) {
+      pushRef(out, kind, record[key]);
+      const many = record[`${key}s`];
+      if (Array.isArray(many)) for (const id of many) pushRef(out, kind, id);
+    }
+    pushRef(out, "cell", record.range);
+    pushRef(out, "cell", record.cell);
+    visit(record.params, depth + 1);
+  };
+  visit(args, 0);
+  return out;
+}
+function playbackRefsFromResult(value, defaultKind = "item") {
+  const out = [];
+  const visit = (v, depth) => {
+    if (!v || typeof v !== "object" || depth > 2) return;
+    if (Array.isArray(v)) {
+      for (const item of v) if (item && typeof item === "object") pushRef(out, defaultKind, item.id);
+      return;
+    }
+    const record = v;
+    if (Array.isArray(record.content) && record.structuredContent) return visit(record.structuredContent, depth);
+    pushRef(out, defaultKind, record.id);
+    if (Array.isArray(record.ids)) for (const id of record.ids) pushRef(out, defaultKind, id);
+    if (record.node && typeof record.node === "object") pushRef(out, "node", record.node.id);
+    pushRef(out, "layer", record.layerId);
+    if (record.layer && typeof record.layer === "object") pushRef(out, "layer", record.layer.id);
+    const created = record.created;
+    if (Array.isArray(created)) visit(created, depth + 1);
+    else if (created && typeof created === "object") {
+      const c = created;
+      for (const n of c.nodes ?? []) pushRef(out, "node", n?.id);
+      for (const e of c.edges ?? []) pushRef(out, "edge", e?.id);
+    }
+    if (record.result && typeof record.result === "object") visit(record.result, depth + 1);
+  };
+  visit(value, 0);
+  return out;
+}
+function derivePlaybackSteps(args, defaultKind) {
+  const refs = playbackRefsFromArgs(args, defaultKind).slice(0, 8);
+  if (!refs.length) return [{ type: "commit" }];
+  return [...refs.map((ref) => ({ type: "target", ref })), { type: "press" }, { type: "release" }, { type: "commit" }];
+}
+function readingTime(text) {
+  return Math.min(2200, Math.max(600, text.length * 65));
+}
+function unionRects(rects) {
+  const list = rects.filter((r) => !!r);
+  if (!list.length) return null;
+  const x = Math.min(...list.map((r) => r.x));
+  const y = Math.min(...list.map((r) => r.y));
+  return { x, y, width: Math.max(...list.map((r) => r.x + r.width)) - x, height: Math.max(...list.map((r) => r.y + r.height)) - y };
+}
+function normalizePlan(plan) {
+  if (!plan) return null;
+  if (Array.isArray(plan)) return plan.length ? { steps: plan } : null;
+  return plan.steps?.length || plan.surface || plan.readOnly !== void 0 ? plan : null;
+}
+var isErrorResult = (value) => !!value && typeof value === "object" && value.isError === true;
+var center = (r) => ({ x: r.x + r.width / 2, y: r.y + r.height / 2 });
+var GLANCE_STEPS = /* @__PURE__ */ new Set(["move", "target", "focus", "say", "wait", "commit"]);
+var AgentPlayback = class {
+  /** 1 = natural pace; `Infinity` plays nothing (calls run instantly). Takes effect on the next step. */
+  speed;
+  reads;
+  clock;
+  linger;
+  defaultActor;
+  surfaces = /* @__PURE__ */ new Map();
+  actors = /* @__PURE__ */ new Map();
+  recordings = /* @__PURE__ */ new Set();
+  installed = /* @__PURE__ */ new WeakSet();
+  listeners = /* @__PURE__ */ new Set();
+  generation = 0;
+  running = 0;
+  calls = 0;
+  constructor(options = {}) {
+    this.clock = options.clock ?? realPresenceClock;
+    this.speed = options.speed ?? 1;
+    this.reads = options.reads ?? "glance";
+    this.linger = options.linger ?? 1500;
+    this.defaultActor = options.actor ?? { id: "agent", name: "Agent" };
+  }
+  /** The registry middleware that plays each call. */
+  middleware = (call, next) => this.perform(call, next);
+  /** Adds the middleware to `registry` once (later calls with the same registry do nothing). */
+  install(registry) {
+    if (this.installed.has(registry)) return;
+    this.installed.add(registry);
+    registry.use(this.middleware);
+  }
+  /** Whether a performance is playing now (e.g. to make the editor read-only meanwhile). */
+  get active() {
+    return this.running > 0;
+  }
+  /** Called when `active` changes. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Attaches a surface under a provider id (or the id providers name as `playbackSurface`). */
+  attach(id, surface) {
+    this.surfaces.set(id, surface);
+    return () => {
+      if (this.surfaces.get(id) !== surface) return;
+      this.surfaces.delete(id);
+      for (const actor of this.actors.values()) if (actor.surface === id) actor.surface = void 0;
+    };
+  }
+  /** The surface attached under `id`. */
+  surface(id) {
+    return this.surfaces.get(id);
+  }
+  /** Shows `text` in the actor's bubble on the surface it last worked on (until its next step). */
+  say(text, options = {}) {
+    const actor = this.actorState(options.actor);
+    const surface = actor.surface ? this.surfaces.get(actor.surface) : void 0;
+    if (surface?.presence.get(actor.info.id)) surface.presence.set({ id: actor.info.id, message: text });
+  }
+  /** Finishes every running performance at once (the calls still run and keep their results). */
+  stop() {
+    this.generation++;
+  }
+  /** Collects every step played from now on (for tests). */
+  record() {
+    const list = [];
+    this.recordings.add(list);
+    return list;
+  }
+  actorState(info) {
+    const base = info ?? this.defaultActor;
+    let actor = this.actors.get(base.id);
+    if (!actor) {
+      actor = { info: { ...base, color: base.color ?? PRESENCE_COLORS[this.actors.size % PRESENCE_COLORS.length] }, queue: Promise.resolve(), version: 0 };
+      this.actors.set(base.id, actor);
+    } else if (info?.name && info.name !== actor.info.name) actor.info = { ...actor.info, name: info.name };
+    return actor;
+  }
+  enqueue(actor, run) {
+    const result = actor.queue.then(run);
+    actor.queue = result.catch(() => void 0);
+    return result;
+  }
+  surfaceFor(provider, hint) {
+    for (const id of [hint, provider.playbackSurface, provider.id, provider.namespace]) {
+      const surface = id ? this.surfaces.get(id) : void 0;
+      if (id && surface) return [id, surface];
+    }
+    return null;
+  }
+  async perform(call, next) {
+    const tool = call.tool;
+    if (tool.playback === false || !Number.isFinite(this.speed)) return next();
+    const actor = this.actorState(call.context.actor);
+    if (tool.playback === "self") return this.enqueue(actor, next);
+    const fallback = this.surfaceFor(call.provider);
+    let planned = null;
+    if (tool.plan) {
+      try {
+        const state = {
+          surfaceId: fallback?.[0] ?? null,
+          locate: (ref) => fallback?.[1].locate?.(ref) ?? null
+        };
+        planned = normalizePlan(tool.plan(call.args, state));
+      } catch {
+        planned = null;
+      }
+    }
+    const readOnly = planned?.readOnly ?? tool.annotations?.readOnlyHint === true;
+    if (readOnly && this.reads === "skip") return next();
+    const found = this.surfaceFor(call.provider, planned?.surface);
+    if (!found) return next();
+    const [surfaceId, surface] = found;
+    const steps = planned?.steps?.length ? planned.steps : derivePlaybackSteps(call.args, surface.defaultKind);
+    const glance = readOnly && this.reads === "glance";
+    const played = glance ? steps.filter((s) => GLANCE_STEPS.has(s.type)) : steps;
+    if (!played.some((s) => s.type !== "commit")) return next();
+    return this.enqueue(actor, async () => {
+      if (surface.visible && !surface.visible()) {
+        await surface.reveal?.();
+        if (surface.visible && !surface.visible()) return next();
+      }
+      return this.play({ call, next, actor, surfaceId, surface, steps: played, readOnly, glance });
+    });
+  }
+  async play(run) {
+    const { call, next, actor, surfaceId, surface, readOnly } = run;
+    const id = actor.info.id;
+    const gen = this.generation;
+    const instant = () => gen !== this.generation || !Number.isFinite(this.speed);
+    const pace = () => Math.max(0.1, this.speed) * (run.glance ? 1.6 : 1);
+    const wait = (ms) => instant() || ms <= 0 ? Promise.resolve() : this.clock.wait(ms / pace());
+    const presence = surface.presence;
+    const locate = (ref) => surface.locate?.(ref.kind === "item" ? { kind: surface.defaultKind ?? "item", id: ref.id } : ref) ?? null;
+    const record = (step) => {
+      for (const list of this.recordings) list.push({ actor: id, surface: surfaceId, tool: call.name, step });
+    };
+    this.running++;
+    if (this.running === 1) this.listeners.forEach((l) => l());
+    try {
+      if (actor.surface && actor.surface !== surfaceId) this.surfaces.get(actor.surface)?.presence.remove(id);
+      if (!presence.get(id)) {
+        const bounds = surface.bounds?.() ?? null;
+        let at = actor.viewport && surface.fromViewport ? surface.fromViewport(actor.viewport) : null;
+        if (at && bounds) at = { x: Math.min(bounds.x + bounds.width, Math.max(bounds.x, at.x)), y: Math.min(bounds.y + bounds.height, Math.max(bounds.y, at.y)) };
+        at ??= bounds ? { x: bounds.x + bounds.width - 48, y: bounds.y + 32 } : null;
+        if (!at) {
+          const first = run.steps.find((s) => s.type === "move" || s.type === "target" || s.type === "drag");
+          const rect = first?.type === "target" ? locate(first.ref) : null;
+          at = first && first.type !== "target" ? first.to : rect ? center(rect) : { x: 0, y: 0 };
+        }
+        presence.set({ id, name: actor.info.name ?? id, color: actor.info.color, x: at.x, y: at.y, pressed: false });
+      } else presence.set({ id, name: actor.info.name ?? id, color: actor.info.color });
+      actor.surface = surfaceId;
+      actor.version++;
+      const argRefs = playbackRefsFromArgs(call.args, surface.defaultKind);
+      if (!readOnly) surface.beginGesture?.(`agent:${id}:${++this.calls}`);
+      let result;
+      let committed = false;
+      try {
+        for (const step of run.steps) {
+          record(step);
+          if (step.type === "commit") {
+            if (committed) continue;
+            committed = true;
+            result = await next();
+            continue;
+          }
+          if (step.type === "open") {
+            if (!surface.open) continue;
+            const rect = locate(step.ref);
+            if (rect) {
+              await this.glide(presence, id, { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 }, step.ms, instant);
+              presence.set({ id, pressed: true });
+              await wait(90);
+            }
+            await surface.open(step.ref);
+            presence.set({ id, pressed: false });
+            await wait(220);
+            continue;
+          }
+          await this.step(presence, locate, id, step, wait, instant);
+        }
+        if (!committed) {
+          record({ type: "commit" });
+          result = await next();
+        }
+      } catch (error) {
+        presence.set({ id, pressed: false, message: `\u2717 ${error instanceof Error ? error.message : String(error)}`.slice(0, 140) });
+        await wait(900);
+        throw error;
+      } finally {
+        if (!readOnly) surface.endGesture?.();
+        presence.set({ id, pressed: false });
+      }
+      if (isErrorResult(result)) {
+        const text = result.content?.find((c) => c.type === "text")?.text ?? "The tool failed.";
+        presence.set({ id, message: `\u2717 ${text}`.slice(0, 140) });
+        await wait(900);
+      } else if (!readOnly) {
+        const known = new Set(argRefs.map((r) => `${r.kind}:${r.id}`));
+        const fresh = playbackRefsFromResult(result, surface.defaultKind).filter((r) => !known.has(`${r.kind}:${r.id}`));
+        const rect = unionRects(fresh.slice(0, 16).map(locate));
+        if (rect) {
+          const step = { type: "focus", rect };
+          record(step);
+          presence.set({ id, focus: rect });
+          await wait(450);
+        }
+      }
+      presence.set({ id, message: void 0, focus: void 0 });
+      const here = presence.get(id);
+      if (here && surface.toViewport) actor.viewport = surface.toViewport({ x: here.x, y: here.y });
+      this.scheduleLinger(actor, surface);
+      return result;
+    } finally {
+      this.running--;
+      if (this.running === 0) this.listeners.forEach((l) => l());
+    }
+  }
+  scheduleLinger(actor, surface) {
+    if (this.linger <= 0) return;
+    const version = actor.version;
+    void this.clock.wait(this.linger).then(() => {
+      if (actor.version !== version) return;
+      surface.presence.remove(actor.info.id);
+      for (const [sid, s] of this.surfaces) if (s === surface && actor.surface === sid) actor.surface = void 0;
+    });
+  }
+  async step(presence, locate, id, step, wait, instant) {
+    switch (step.type) {
+      case "move":
+        return this.glide(presence, id, step.to, step.ms, instant);
+      case "drag":
+        presence.set({ id, pressed: true });
+        return this.glide(presence, id, step.to, step.ms, instant);
+      case "target": {
+        const rect = locate(step.ref);
+        if (!rect) return;
+        await this.glide(presence, id, center(rect), step.ms, instant);
+        presence.set({ id, focus: rect });
+        return;
+      }
+      case "focus":
+        presence.set({ id, focus: step.rect ?? void 0 });
+        return;
+      case "say":
+        presence.set({ id, message: step.text });
+        return wait(step.ms ?? readingTime(step.text));
+      case "press":
+        presence.set({ id, pressed: true });
+        return wait(90);
+      case "release":
+        presence.set({ id, pressed: false });
+        return wait(60);
+      case "type": {
+        const total = step.ms ?? Math.min(900, 40 * step.text.length + 150);
+        if (instant() || total <= 0) {
+          presence.set({ id, message: step.text });
+          return;
+        }
+        const start = this.clock.now();
+        for (; ; ) {
+          const t = Math.min(1, (this.clock.now() - start) / (total / Math.max(0.1, this.speed)));
+          presence.set({ id, message: step.text.slice(0, Math.max(1, Math.round(step.text.length * t))) });
+          if (t >= 1 || instant()) break;
+          await this.clock.wait(16);
+        }
+        presence.set({ id, message: step.text });
+        return;
+      }
+      case "wait":
+        return wait(step.ms);
+    }
+  }
+  /** Glides along a slight arc with ease-out, by elapsed time (fewer frames in a throttled tab, never longer). */
+  async glide(presence, id, to, ms, instant) {
+    const a = presence.get(id);
+    const from = a ? { x: a.x, y: a.y } : to;
+    const dist = Math.hypot(to.x - from.x, to.y - from.y);
+    const duration = (ms ?? Math.min(900, 260 + dist * 0.5)) / Math.max(0.1, this.speed);
+    if (instant() || dist < 1 || duration <= 0) {
+      presence.set({ id, x: to.x, y: to.y });
+      return;
+    }
+    const bend = Math.min(60, dist * 0.12);
+    const ctrl = { x: (from.x + to.x) / 2 - (to.y - from.y) / dist * bend, y: (from.y + to.y) / 2 + (to.x - from.x) / dist * bend };
+    const start = this.clock.now();
+    for (; ; ) {
+      const t = Math.min(1, (this.clock.now() - start) / duration);
+      const e = 1 - Math.pow(1 - t, 3);
+      const u = 1 - e;
+      presence.set({ id, x: u * u * from.x + 2 * u * e * ctrl.x + e * e * to.x, y: u * u * from.y + 2 * u * e * ctrl.y + e * e * to.y });
+      if (t >= 1) break;
+      if (instant()) {
+        presence.set({ id, x: to.x, y: to.y });
+        break;
+      }
+      await this.clock.wait(16);
+    }
+  }
+};
+function createAgentPlayback(options = {}) {
+  return new AgentPlayback(options);
+}
+
+export {
+  playbackRefsFromArgs,
+  playbackRefsFromResult,
+  derivePlaybackSteps,
+  readingTime,
+  unionRects,
+  AgentPlayback,
+  createAgentPlayback
+};

package/dist/{chunk-BSGPXPTW.js → chunk-PEEP2YR7.js}

@@ -1,4 +1,4 @@
-// src/animation/presence.ts
+// src/tools/presence.ts
 var PRESENCE_COLORS = ["#7c3aed", "#db2777", "#0891b2", "#ea580c", "#16a34a"];
 var PresenceStore = class {
   state = { actors: [] };

package/dist/{chunk-RB62U6MS.js → chunk-RFBFTLVN.js}

@@ -413,7 +413,7 @@ function readTools(provider) {
   return typeof provider.tools === "function" ? provider.tools() : provider.tools;
 }
 function toDefinition2(name, tool) {
-  const { handler: _handler, name: _name, ...rest } = tool;
+  const { handler: _handler, name: _name, plan: _plan, playback: _playback, ...rest } = tool;
   return { name, ...rest };
 }
 function errorResult(error) {
@@ -442,6 +442,7 @@ var ToolRegistry = class {
   capabilities = { tools: { listChanged: true } };
   entries = [];
   listeners = /* @__PURE__ */ new Set();
+  middleware = [];
   options;
   timer = null;
   lastSignature;
@@ -502,6 +503,17 @@ var ToolRegistry = class {
     this.notifyListChanged();
     return true;
   }
+  /**
+   * Adds a middleware that wraps every tool call (first added runs outermost), e.g. agent
+   * playback's `playback.middleware`. Returns a function that removes it.
+   */
+  use(middleware) {
+    this.middleware.push(middleware);
+    return () => {
+      const index = this.middleware.indexOf(middleware);
+      if (index !== -1) this.middleware.splice(index, 1);
+    };
+  }
   /** Registered provider ids in registration order. */
   providerIds() {
     return this.entries.map((e) => e.provider.id);
@@ -609,11 +621,16 @@ var ToolRegistry = class {
       }
     }
     try {
-      const value = await found.tool.handler(input, {
+      const context = {
         name,
         providerId: found.provider.id,
-        signal: options.signal
-      });
+        signal: options.signal,
+        ...options.actor ? { actor: options.actor } : {}
+      };
+      const call = { name, tool: found.tool, provider: found.provider, args: input, context };
+      const chain = [...this.middleware];
+      const run = async (i) => i < chain.length ? chain[i](call, () => run(i + 1)) : found.tool.handler(call.args, context);
+      const value = await run(0);
       return toToolResult(value);
     } catch (error) {
       return errorResult({
@@ -896,6 +913,7 @@ function createMcpServer(registry, options) {
   };
   const readSkillPath = (path) => skillFiles?.[path] ?? skillFiles?.[`./${path}`];
   let initialized = false;
+  let actor;
   let unsubscribe = null;
   const running = /* @__PURE__ */ new Map();
   const startNotifications = () => {
@@ -909,6 +927,10 @@ function createMcpServer(registry, options) {
     const params = request.params ?? {};
     switch (request.method) {
       case "initialize": {
+        const client = params.clientInfo;
+        if (client && typeof client.name === "string" && client.name) {
+          actor = { id: `mcp:${client.name}`, name: typeof client.title === "string" && client.title ? client.title : client.name };
+        }
         const instructions = typeof options.instructions === "function" ? options.instructions(registry) : options.instructions;
         const requested = String(params.protocolVersion ?? "");
         const protocolVersion = MCP_PROTOCOL_VERSIONS.includes(requested) ? requested : MCP_PROTOCOL_VERSIONS[0];
@@ -951,7 +973,7 @@ function createMcpServer(registry, options) {
         const controller = new AbortController();
         if (!isNotification) running.set(id, controller);
         try {
-          const result = await registry.callTool(name, args ?? {}, { signal: controller.signal });
+          const result = await registry.callTool(name, args ?? {}, { signal: controller.signal, ...actor ? { actor } : {} });
           if (controller.signal.aborted) return null;
           return { jsonrpc: "2.0", id, result };
         } finally {