@pixerate/editor 0.257.0 → 0.258.0

package/dist/paint-editor/index.js

@@ -3055,6 +3055,7 @@ var PaintStrokeSession = class _PaintStrokeSession {
     if (filter) points = points.map(filter);
     for (const p of points) this.points.push(p);
     this.lastRaw = points[points.length - 1];
+    this.host.sampled?.(this, points);
     this.lightTwin?.push(points);
     if (this.wetDriver) {
       this.wetUpdate(this.wetDriver.push(points));
@@ -5854,6 +5855,7 @@ var PaintEditorController = class _PaintEditorController {
   encodeImage;
   listeners = /* @__PURE__ */ new Set();
   commitListeners = /* @__PURE__ */ new Set();
+  sampleListeners = /* @__PURE__ */ new Set();
   /** Origins set by `withOrigin`, innermost last. */
   origins = [];
   /** `group` in progress: commits fold into one step, recorded when it ends. */
@@ -5968,6 +5970,27 @@ var PaintEditorController = class _PaintEditorController {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
   }
+  /**
+   * Hears the user's live strokes as they are painted (`beginStroke` sessions, not strokes painted
+   * from data): when the pen goes down, each batch of samples, and the end or cancel. For agents
+   * that paint along in real time. Returns an unsubscribe function.
+   */
+  onStrokeSample(listener) {
+    this.sampleListeners.add(listener);
+    return () => {
+      this.sampleListeners.delete(listener);
+    };
+  }
+  notifySample(phase, session, added = [], strokeId) {
+    if (!this.sampleListeners.size || this.previewing) return;
+    const sample = { phase, layerId: session.layerId, brush: session.init.brush, color: session.init.colorHex, points: session.points, added, ...strokeId !== void 0 ? { strokeId } : {} };
+    for (const l of [...this.sampleListeners]) l(sample);
+  }
+  /** The stroke being painted now, or `null`: its layer, brush, colour and samples so far. */
+  getLiveStroke() {
+    const s = this.session;
+    return s ? { layerId: s.layerId, brushId: s.init.brush.id, brushName: s.init.brush.name, color: s.init.colorHex, points: s.points } : null;
+  }
   /** Hears each undo step recorded, merged, undone or redone, with who made it. Returns an unsubscribe function. */
   onCommit(listener) {
     this.commitListeners.add(listener);
@@ -7700,6 +7723,7 @@ var PaintEditorController = class _PaintEditorController {
         this.liveThick = ch ? { layerId, channels: ch } : null;
         this.emit(rects);
       },
+      sampled: (s, points) => this.notifySample("points", s, points),
       commit: (s, surface, cancelled) => {
         this.session = null;
         this.live = null;
@@ -7719,6 +7743,7 @@ var PaintEditorController = class _PaintEditorController {
             this.wet.syncDisplays();
           }
           this.emit();
+          this.notifySample(cancelled ? "cancel" : "end", s, [], cancelled ? void 0 : null);
           return;
         }
         const stroke = this.record(s);
@@ -7738,6 +7763,7 @@ var PaintEditorController = class _PaintEditorController {
         const wetLight = wetStroke && this.wet.world?.hasLane(l.id) ? this.wet.world.lightDisplay(l.id) : null;
         const light = withLayerLight(this.doc.light, l.id, s.lightChannel() ?? wetLight);
         this.commit(`${brush.name} stroke`, this.withWetEvents(withLiveStroke({ ...this.doc, layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {}, ...light ? { light } : {} }, stroke)), wetStroke ? before : this.doc);
+        this.notifySample("end", s, [], stroke.id);
       }
     };
     let session;
@@ -7749,6 +7775,7 @@ var PaintEditorController = class _PaintEditorController {
     }
     this.session = session;
     this.emit([]);
+    this.notifySample("begin", session);
     return session;
   }
   /** The current live stroke, if any. */
@@ -11536,6 +11563,23 @@ function createPaintEditorToolProvider(controller, options = {}) {
       return r.mixerLoad ? { ...r, mixerLoad: loadResult(r.mixerLoad) } : r;
     }
   });
+  add({
+    name: "get_live_stroke",
+    title: "Get the stroke being painted",
+    description: "Reads the stroke the user is painting right now, if any: its layer, brush id and name, colour, and the pen samples so far (document pixels; at most the last `limit`). Returns live: false when no stroke is in progress. For agents that paint along with the user: hosts stream the same samples to them live (onStrokeSample); this is a snapshot.",
+    inputSchema: {
+      type: "object",
+      properties: { limit: { type: "integer", minimum: 1, maximum: 5e3, description: "Most recent samples to return (default 500)." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Get the stroke being painted", ...READ6 },
+    handler: (args) => {
+      const live = c.getLiveStroke();
+      if (!live) return { live: false };
+      const limit = args.limit ?? 500;
+      return { live: true, layerId: live.layerId, brushId: live.brushId, brushName: live.brushName, color: live.color, total: live.points.length, points: live.points.slice(-limit) };
+    }
+  });
   add({
     name: "list_strokes",
     title: "List recorded strokes",
@@ -12967,6 +13011,37 @@ function paintProposalGhost(proposal) {
   if (!b || !b.width || !b.height || proposal.ghost.length !== b.width * b.height * 4) return null;
   return { x: b.x, y: b.y, width: b.width, height: b.height, data: proposal.ghost };
 }
+function createPaintAgentStrokes() {
+  let state = { strokes: [] };
+  const listeners = /* @__PURE__ */ new Set();
+  const set = (strokes) => {
+    state = { strokes };
+    listeners.forEach((l) => l(state));
+  };
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    set(stroke) {
+      const i = state.strokes.findIndex((s) => s.id === stroke.id);
+      set(i < 0 ? [...state.strokes, stroke] : state.strokes.map((s, j) => j === i ? stroke : s));
+    },
+    remove(id) {
+      if (state.strokes.some((s) => s.id === id)) set(state.strokes.filter((s) => s.id !== id));
+    },
+    clear(origin) {
+      const keep = origin ? state.strokes.filter((s) => s.origin !== origin) : [];
+      if (keep.length !== state.strokes.length) set(keep);
+    }
+  };
+}
+function paintAgentStrokePoints(stroke) {
+  return stroke.points.map((p) => `${Math.round(p.x * 10) / 10},${Math.round(p.y * 10) / 10}`).join(" ");
+}
 
 // src/paint-editor/collaboration-tools.ts
 var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
@@ -13256,6 +13331,7 @@ export {
   colorHarmony2 as colorHarmony,
   composeAffine,
   contactSheet,
+  createPaintAgentStrokes,
   createPaintBrushLibraryToolProvider,
   createPaintChangeFeed,
   createPaintCompositor,
@@ -13348,6 +13424,7 @@ export {
   normalizeWetParams,
   overPixels,
   padSampleRadius,
+  paintAgentStrokePoints,
   paintGradientMappingFor,
   paintPlaybackPanel,
   paintProposalGhost,

package/dist/paint-editor/stroke.d.cts

@@ -26,6 +26,8 @@ export interface StrokeSessionHost {
     update(layerId: string, surface: TiledSurface, rects: RasterRect[]): void;
     /** Ends the stroke: `surface` is the new pixels, or `null` when nothing changed / it was cancelled. */
     commit(session: PaintStrokeSession, surface: TiledSurface | null, cancelled: boolean): void;
+    /** Hears the raw samples as they arrive (after the input filter), before they are painted. */
+    sampled?(session: PaintStrokeSession, points: readonly PenPoint[]): void;
 }
 export interface StrokeSessionInit {
     layerId: string;

package/dist/paint-editor/stroke.d.ts

@@ -26,6 +26,8 @@ export interface StrokeSessionHost {
     update(layerId: string, surface: TiledSurface, rects: RasterRect[]): void;
     /** Ends the stroke: `surface` is the new pixels, or `null` when nothing changed / it was cancelled. */
     commit(session: PaintStrokeSession, surface: TiledSurface | null, cancelled: boolean): void;
+    /** Hears the raw samples as they arrive (after the input filter), before they are painted. */
+    sampled?(session: PaintStrokeSession, points: readonly PenPoint[]): void;
 }
 export interface StrokeSessionInit {
     layerId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixerate/editor",
-  "version": "0.257.0",
+  "version": "0.258.0",
   "description": "UI-agnostic rich text and media editing core library",
   "author": "Pixerate",
   "license": "MIT",

package/skills/pixerate-paint-editor/SKILL.md

@@ -321,6 +321,7 @@ Listing, saving, sharing and previewing brushes are the brush library's tools (`
 | --- | --- |
 | `paint_stroke` | Paint one stroke through `points` (document px; `pressure` 0..1, `t` ms, `tiltX` / `tiltY` or `altitude` / `azimuth`, `twist`) with `brushId` (default the active brush), optional per-stroke `brush` facet changes (as `set_brush` takes), `color` or `paint` (a gradient for this stroke), `layerId`, `seed`, `snapToPerspective`. The symmetry guide adds its copies; a sampling tracing image supplies the colour when `color` is missing. Returns `layerId`, `bounds`, `dabs`, `strokeId` and, for brushes that pick up paint, `mixerLoad` (what the brush carries now). Refused on locked, hidden or group layers, with the fix in the message. |
 | `list_strokes` | Read the recorded strokes, oldest first (default the last 100): id, layer, brush, colour, point count, seed, bounds, `live`. With `ids`, their points too; with `layerId`, one layer's. With `live: true`, the editable strokes of stroke layers as they are now, bottom first: the ids for the stroke layer tools. |
+| `get_live_stroke` | Read the stroke the user is painting right now (layer, brush, colour, samples so far; `live: false` when none). For painting along with the user; hosts stream the samples live. |
 | `stroke_at` | Read the top-most stroke of a stroke layer that painted the pixel at `x`, `y`, or null. Use it to pick one stroke among overlapping ones. |
 | `update_stroke` | Change a stroke on a stroke layer: `brushId` (keeps its size), `brush` facets (as `set_brush` takes), `color`, `paint` (null drops a gradient), `seed`. Redraws exactly. One undo step. Returns the stroke and the changed `bounds`. |
 | `edit_stroke_points` | Replace a stroke's `points`, or `transform` it (`dx`, `dy`, `scale`, `rotate`, `flipX`, about its centre or `origin`). One undo step. Returns the stroke with its points and the changed `bounds`. |