@pixerate/editor 0.201.0 → 0.203.0

package/dist/paint-editor/index.cjs

@@ -6213,6 +6213,49 @@ function withPaintPlayback(provider, options) {
   };
 }
 
+// src/paint-editor/hosted.ts
+function shiftAt(value, keys, dx, dy) {
+  if (value === null || typeof value !== "object") return value;
+  if (keys.length === 0) {
+    if (Array.isArray(value)) return value;
+    const o = { ...value };
+    if (typeof o.x === "number") o.x += dx;
+    if (typeof o.y === "number") o.y += dy;
+    return o;
+  }
+  const [head, ...rest] = keys;
+  const each = head.endsWith("[]");
+  const key = each ? head.slice(0, -2) : head;
+  const inner = key === "" ? value : value[key];
+  if (inner === void 0) return value;
+  const next = each ? Array.isArray(inner) ? inner.map((v) => shiftAt(v, rest, dx, dy)) : inner : shiftAt(inner, rest, dx, dy);
+  if (key === "") return next;
+  return Array.isArray(value) ? value : { ...value, [key]: next };
+}
+var shiftAll = (value, paths, dx, dy) => paths.reduce((v, p) => shiftAt(v, p === "" ? [] : p.split("."), dx, dy), value);
+var toDocument = (value, paths, origin) => shiftAll(value, paths, -origin.x, -origin.y);
+var fromDocument = (value, paths, origin) => shiftAll(value, paths, origin.x, origin.y);
+function hostedText(text) {
+  return text.replace(/\ba document pixel\b/g, "a canvas point").replace(/\bdocument pixels\b/g, "canvas coordinates").replace(/\bDocument ([xy])\b/g, "Canvas $1").replace(/\bdocument ([xy])\b/g, "canvas $1");
+}
+function hostedSchema(schema) {
+  if (Array.isArray(schema)) return schema.map(hostedSchema);
+  if (schema === null || typeof schema !== "object") return schema;
+  const out = {};
+  for (const [k, v] of Object.entries(schema)) out[k] = k === "description" && typeof v === "string" ? hostedText(v) : hostedSchema(v);
+  return out;
+}
+function lazyController(get) {
+  return new Proxy({}, {
+    get(_, key) {
+      const target = get();
+      const value = Reflect.get(target, key, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    has: (_, key) => Reflect.has(get(), key)
+  });
+}
+
 // src/paint-editor/sticker-tools.ts
 var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
@@ -6226,6 +6269,7 @@ function createPaintStickerTools(c) {
       description: "Lists a layer\u2019s stickers bottom first: id, stamp, x, y (centre, document pixels), size (diameter px), rotation (degrees clockwise), color, opacity. Empty for a layer without stickers. Changes nothing.",
       inputSchema: { type: "object", properties: { layerId: LAYER_ID }, additionalProperties: false },
       annotations: { title: "List stickers", ...READ },
+      coordinates: { out: ["stickers[]"] },
       handler: ({ layerId }) => ({ layerId: _nullishCoalesce(layerId, () => ( c.document.activeLayerId)), stickers: c.listStickers(layerId) })
     },
     {
@@ -6249,6 +6293,7 @@ function createPaintStickerTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Change a sticker", ...WRITE },
+      coordinates: { in: [""], out: [""] },
       handler: ({ layerId, id, ...update }) => c.updateSticker(layerId, id, update)
     },
     {
@@ -6304,6 +6349,7 @@ var RECT = {
   required: ["x", "y", "width", "height"],
   additionalProperties: false
 };
+var STENCIL_POSITIONS = ["from", "to", "center", "rect", "points[]"];
 var PNG = { type: "string", minLength: 1, description: "The image as a PNG, base64 or a data:image/png URL." };
 var tracingInfo = (t) => t ? { width: t.width, height: t.height, rect: t.rect, opacity: t.opacity, visible: t.visible, sampleColors: t.sampleColors } : null;
 var refInfo = ({ src: _s, ...r }) => r;
@@ -6332,6 +6378,7 @@ function createPaintGuideTools(c) {
       description: "Reads the painting guides: symmetry (mode, centre, rotation, segments, mirror, and how many copies each stroke paints), the perspective guide (vanishing points, snap), the tracing image (size, placement, opacity, visibility, colour sampling), the reference images and the stencils (id, kind, mode, geometry).",
       inputSchema: EMPTY,
       annotations: { title: "Get the painting guides", ...READ2 },
+      coordinates: { out: ["symmetry.center", "perspective.points[]", "tracing.rect", ...STENCIL_POSITIONS.map((p) => `stencils[].${p}`)] },
       handler: () => {
         const g = guides();
         return { symmetry: { ...g.symmetry, copies: symmetryCopies(g.symmetry).length }, perspective: g.perspective, tracing: tracingInfo(g.tracing), references: g.references.map(refInfo), stencils: g.stencils };
@@ -6353,6 +6400,7 @@ function createPaintGuideTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Set mirror or kaleidoscope painting", ...SET },
+      coordinates: { in: ["center"], out: ["center"] },
       handler: (a) => {
         const s = c.setSymmetry(a);
         return { ...s, copies: symmetryCopies(s).length };
@@ -6372,6 +6420,7 @@ function createPaintGuideTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Set the perspective guide", ...SET },
+      coordinates: { in: ["points[]"], out: ["points[]"] },
       handler: (a) => c.setPerspective(a)
     },
     {
@@ -6390,6 +6439,7 @@ function createPaintGuideTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Set a tracing image", ...WRITE2 },
+      coordinates: { in: ["rect"], out: ["rect"] },
       handler: (a) => tracingInfo(c.setTracingImage(a))
     },
     {
@@ -6407,6 +6457,7 @@ function createPaintGuideTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Change the tracing image", ...SET },
+      coordinates: { in: ["rect"], out: ["rect"] },
       handler: (a) => tracingInfo(c.updateTracing(a))
     },
     {
@@ -6700,6 +6751,7 @@ function createPaintGuideTools(c) {
       description: "Lays a stencil on the canvas: a ruler (straight edge to draw along) or an arc (circle or part of one) that pointer and agent strokes starting near it follow exactly, or a line (straight masking edge) or a shape (rect, ellipse or polygon template) that paint lands only inside of (outside with invert). Editor state saved with the document, not an undo step; replays keep the mask they were painted through. Returns the stencil with its id.",
       inputSchema: { type: "object", properties: { kind: { type: "string", enum: ["ruler", "arc", "line", "shape"], description: "ruler, arc, line or shape." }, ...STENCIL_GEOMETRY }, required: ["kind"], additionalProperties: false },
       annotations: { title: "Lay a stencil", ...WRITE2 },
+      coordinates: { in: STENCIL_POSITIONS, out: STENCIL_POSITIONS },
       handler: (a) => c.addStencil(a)
     },
     {
@@ -6708,6 +6760,7 @@ function createPaintGuideTools(c) {
       description: "Moves, reshapes, switches (guide or mask, invert) or hides (enabled false) a stencil by id from get_guides. Returns the stencil.",
       inputSchema: { type: "object", properties: { id: { type: "string", description: "Stencil id from get_guides." }, ...STENCIL_GEOMETRY }, required: ["id"], additionalProperties: false },
       annotations: { title: "Change a stencil", ...SET },
+      coordinates: { in: STENCIL_POSITIONS, out: STENCIL_POSITIONS },
       handler: ({ id, ...update }) => c.updateStencil(id, update)
     },
     {
@@ -6760,6 +6813,7 @@ function createPaintWetTools(c) {
       description: "Reads the wet media: whether any paint is still wet, the simulation clock (steps), whether time is paused, its speed (steps per second), the canvas tilt, the kernel running it (typescript, wasm, wasm-threads with the thread count, and a message when it runs slower than it could, e.g. without cross-origin isolation), and each wet layer: wet cells, where the water is (wetBounds), live tiles, its settings and flow map. Also engine: Engine B, the WebGPU accelerator (mode auto/off, state, reason, adapter, minTiles, activeTiles). Call it after wet strokes to see what is still wet.",
       inputSchema: EMPTY2,
       annotations: { title: "Get the wet paint", ...READ3 },
+      coordinates: { out: ["layers[].wetBounds", "layers[].flow.center"] },
       handler: () => c.wetState()
     },
     {
@@ -6786,6 +6840,7 @@ function createPaintWetTools(c) {
       description: "Dries wet paint at once: everything settles where it is and the water goes, as a hair dryer at full blast would (the same deterministic bake that saving uses). On one layer or every wet layer, optionally only inside rect. Dried washes stay put: later washes glaze over them instead of mixing in. One undo step. Returns dried (each layer id with the rectangle that dried) and stillWet.",
       inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Only this layer (default every wet layer)." }, rect: RECT2 }, additionalProperties: false },
       annotations: { title: "Dry the wet paint", ...WRITE3 },
+      coordinates: { in: ["rect"], out: ["dried[].bounds"] },
       handler: async ({ layerId, rect }) => {
         await c.wetIdle();
         return c.dryPaint({ layerId, rect });
@@ -6801,6 +6856,7 @@ function createPaintWetTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Pre-wet the paper", ...WRITE3 },
+      coordinates: { in: ["rect"], out: ["rect"] },
       handler: async ({ layerId, rect, amount }) => {
         await c.wetIdle();
         return c.wetPaper({ layerId, rect, amount });
@@ -6843,6 +6899,7 @@ function createPaintWetTools(c) {
         additionalProperties: false
       },
       annotations: { title: "Set a flow map", ...SET2 },
+      coordinates: { in: ["center"], out: ["flow.center"] },
       handler: async ({ layerId, ...flow }) => {
         await c.wetIdle();
         return { layerId: _nullishCoalesce(layerId, () => ( c.document.activeLayerId)), flow: c.setFlowMap(layerId, flow), stillWet: stillWet() };
@@ -6943,6 +7000,7 @@ function createPaintThickTools(c) {
       description: "Reads a layer\u2019s thick paint: where the relief is (bounds, layer pixels), its highest point (0..255) and the lighting. relief is null when the layer is flat. Changes nothing.",
       inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, additionalProperties: false },
       annotations: { title: "Read a layer\u2019s relief", ...READ4 },
+      coordinates: { out: ["relief.bounds"] },
       handler: ({ layerId }) => ({ relief: c.reliefOf(layerId), lighting: c.getLighting() })
     },
     {
@@ -7039,7 +7097,7 @@ var TIP = {
   type: "object",
   description: "The tip (the shared brush engine). Missing fields keep their current values.",
   properties: {
-    size: { type: "number", minimum: 1, maximum: _chunkEBDCRTZIcjs.MAX_BRUSH_SIZE, description: "Diameter in document pixels." },
+    size: { type: "number", minimum: 1, maximum: _chunkEBDCRTZIcjs.MAX_BRUSH_SIZE, description: "Diameter in pixels." },
     hardness: { type: "number", minimum: 0, maximum: 1, description: "Edge hardness, 0 (soft) .. 1 (hard)." },
     spacing: { type: "number", minimum: 0.01, maximum: 10, description: "Dab spacing as a fraction of the diameter (0.05 is smooth, 1 is dotted)." },
     angle: { type: "number", minimum: -360, maximum: 360, description: "Tip angle in degrees, counter-clockwise; with rotation stroke or barrel it is added to the stroke direction or pen rotation." },
@@ -7289,7 +7347,7 @@ function brushSummary(b) {
   };
 }
 function createPaintEditorToolProvider(controller, options = {}) {
-  const c = controller;
+  const c = typeof controller === "function" ? lazyController(controller) : controller;
   const tools = [];
   const add = (t) => tools.push(t);
   const act = async (command, direct) => {
@@ -7301,9 +7359,10 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "get_canvas_info",
     title: "Get the canvas",
-    description: "Reads the canvas: size in pixels and dpi, its origin (where (0, 0) is relative to the canvas it was extended from), the paper (preset, colour, grain depth), the active layer, the active brush id, the paint colour, the view (zoom, rotation, mirror), the hand, how many strokes are recorded, the undo / redo labels, and the blend modes. Call it first.",
+    description: "Reads the canvas: size in pixels and dpi, its origin (where (0, 0) is relative to the canvas it was extended from), bounds (the rectangle the painting covers, in the coordinates every other tool takes), the paper (preset, colour, grain depth), the active layer, the active brush id, the paint colour, the view (zoom, rotation, mirror), the hand, how many strokes are recorded, the undo / redo labels, and the blend modes. Call it first.",
     inputSchema: EMPTY3,
     annotations: { title: "Get the canvas", ...READ6 },
+    coordinates: { out: ["bounds"] },
     handler: () => {
       const s = c.getState();
       const d = s.document;
@@ -7312,6 +7371,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
         height: d.canvas.height,
         dpi: d.canvas.dpi,
         origin: { ..._nullishCoalesce(d.origin, () => ( { x: 0, y: 0 })) },
+        bounds: { x: 0, y: 0, width: d.canvas.width, height: d.canvas.height },
         paper: { preset: d.paper.preset, name: d.paper.name, color: d.paper.color, depth: d.paper.depth },
         activeLayerId: d.activeLayerId,
         layerCount: c.listLayers().length,
@@ -7440,6 +7500,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     description: "Lists the layers top first: id, name, type (pixel or group), visibility, opacity, blend, clipping, locks, whether it is active, the painted bounds in document pixels (null when empty), parent and depth.",
     inputSchema: EMPTY3,
     annotations: { title: "List layers", ...READ6 },
+    coordinates: { out: ["layers[].bounds"] },
     handler: () => ({ layers: c.listLayers(), activeLayerId: c.document.activeLayerId })
   });
   add({
@@ -7457,6 +7518,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "Add a layer", ...WRITE5 },
+    coordinates: { out: ["bounds"] },
     handler: (a) => c.addLayer({ name: a.name, type: a.type, aboveId: a.aboveId, parentId: a.parentId })
   });
   add({
@@ -7492,6 +7554,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "Change a layer", ...SET4 },
+    coordinates: { out: ["bounds"] },
     handler: ({ layerId, ...u }) => c.updateLayer(layerId, u)
   });
   add({
@@ -7516,6 +7579,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     description: "Makes a layer active: strokes, fills and clears without a layerId go to it. Editor state, not an undo step. Returns the layer.",
     inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Layer id from list_layers." } }, required: ["layerId"], additionalProperties: false },
     annotations: { title: "Choose the active layer", ...SET4 },
+    coordinates: { out: ["bounds"] },
     handler: ({ layerId }) => {
       c.setActiveLayer(layerId);
       return c.describeLayer(c.getLayer(layerId));
@@ -7535,6 +7599,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     description: "Copies a layer (a group with its children) directly above it; the copy becomes active. One undo step. Returns the copy.",
     inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Layer id from list_layers." } }, required: ["layerId"], additionalProperties: false },
     annotations: { title: "Duplicate a layer", ...WRITE5 },
+    coordinates: { out: ["bounds"] },
     handler: ({ layerId }) => c.duplicateLayer(layerId)
   });
   add({
@@ -7552,6 +7617,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "Reorder a layer", ...WRITE5 },
+    coordinates: { out: ["bounds"] },
     handler: ({ layerId, index, parentId }) => c.moveLayer(layerId, index, parentId)
   });
   add({
@@ -7560,6 +7626,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     description: "Merges a pixel layer into the pixel layer directly below it, which keeps its name, opacity and blend. One undo step. Returns the merged layer.",
     inputSchema: { type: "object", properties: { layerId: { type: "string", description: "The upper layer, from list_layers." } }, required: ["layerId"], additionalProperties: false },
     annotations: { title: "Merge a layer down", ...DESTRUCTIVE3 },
+    coordinates: { out: ["bounds"] },
     handler: ({ layerId }) => c.mergeDown(layerId)
   });
   add({
@@ -7579,6 +7646,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "Fill a layer", ...WRITE5 },
+    coordinates: { out: ["bounds"] },
     handler: (a) => act({ kind: "fill", fill: a }, () => c.fillLayer(a))
   });
   add({
@@ -7587,6 +7655,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     description: "Removes every pixel of a pixel layer. One undo step. Returns the layer id and the bounds that were cleared (null if it was empty).",
     inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, additionalProperties: false },
     annotations: { title: "Clear a layer", ...DESTRUCTIVE3 },
+    coordinates: { out: ["bounds"] },
     handler: ({ layerId }) => c.clearLayer(layerId)
   });
   add({
@@ -7746,6 +7815,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "Pick a colour", ...READ6 },
+    coordinates: { in: [""] },
     handler: ({ x, y, layerId }) => c.pickColor(x, y, { layerId })
   });
   add({
@@ -7792,6 +7862,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "Paint a brush stroke", ...WRITE5 },
+    coordinates: { in: ["points[]"], out: ["bounds"] },
     handler: async (a) => {
       await c.wetIdle();
       const stroke = { points: a.points, layerId: a.layerId, brushId: a.brushId, brush: a.brush, color: a.color, paint: a.paint, seed: a.seed, snapToPerspective: a.snapToPerspective };
@@ -7812,6 +7883,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "List recorded strokes", ...READ6 },
+    coordinates: { out: ["strokes[].bounds", "strokes[].points[]"] },
     handler: ({ ids, last }) => {
       const all = c.getStrokes();
       const picked = ids ? all.filter((s) => ids.includes(s.id)) : all.slice(-(_nullishCoalesce(last, () => ( 100))));
@@ -7869,6 +7941,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "Replay strokes, varied", ...WRITE5 },
+    coordinates: { in: ["origin"], out: ["bounds"] },
     handler: (a) => {
       const replay = a;
       return act({ kind: "replay", replay }, () => c.replayStrokes(replay));
@@ -7985,15 +8058,33 @@ function createPaintEditorToolProvider(controller, options = {}) {
   tools.push(...createPaintReplayTools(c));
   tools.push(...createPaintStickerTools(c));
   tools.push(..._chunkV7GWZIZKcjs.createPigmentTools.call(void 0, ));
+  const exclude = new Set(_nullishCoalesce(options.exclude, () => ( [])));
+  const description = "Natural-media painting: paper and grain, dry and wet brushes, the brush library, strokes as data, pigment mixing, stencils, guides, layers and export.";
   return withPaintPlayback({
     id: _nullishCoalesce(options.id, () => ( "paint-editor")),
     namespace: options.namespace,
     title: "Paint editor",
-    description: "Natural-media painting: paper and grain, dry and wet brushes, the brush library, strokes as data, pigment mixing, stencils, guides, layers and export.",
+    description: options.origin ? `${description} It is a layer of a larger canvas: every position is in canvas coordinates.` : description,
     skill: "pixerate-paint-editor",
-    tools
+    tools: tools.filter((t) => !exclude.has(t.name)).map((t) => hostTool(t, options))
   }, { director: !!options.director, surface: options.playbackSurface });
 }
+function hostTool({ coordinates, ...tool }, { origin, onChange }) {
+  if (!origin && !onChange) return tool;
+  const write = !_optionalChain([tool, 'access', _320 => _320.annotations, 'optionalAccess', _321 => _321.readOnlyHint]);
+  const done = (result) => {
+    if (write) _optionalChain([onChange, 'optionalCall', _322 => _322({ tool: tool.name })]);
+    return origin && _optionalChain([coordinates, 'optionalAccess', _323 => _323.out]) ? fromDocument(result, coordinates.out, origin) : result;
+  };
+  return {
+    ...tool,
+    ...origin ? { description: hostedText(_nullishCoalesce(tool.description, () => ( ""))), inputSchema: hostedSchema(tool.inputSchema) } : {},
+    handler: (args, context) => {
+      const r = tool.handler(origin && _optionalChain([coordinates, 'optionalAccess', _324 => _324.in]) ? toDocument(args, coordinates.in, origin) : args, context);
+      return r instanceof Promise ? r.then(done) : done(r);
+    }
+  };
+}
 
 // src/paint-editor/ui.ts
 var PAINT_TOOLS = [
@@ -8097,12 +8188,12 @@ var PaintGesture = (_class11 = class {
     if (!m || m.pointerId !== e.pointerId) return;
     this.mode = null;
     this.predicted = [];
-    if (m.kind === "stroke") _optionalChain([this, 'access', _320 => _320.controller, 'access', _321 => _321.activeStroke, 'optionalAccess', _322 => _322.end, 'call', _323 => _323()]);
+    if (m.kind === "stroke") _optionalChain([this, 'access', _325 => _325.controller, 'access', _326 => _326.activeStroke, 'optionalAccess', _327 => _327.end, 'call', _328 => _328()]);
   }
   cancel() {
     this.penDown = false;
     this.predicted = [];
-    if (_optionalChain([this, 'access', _324 => _324.mode, 'optionalAccess', _325 => _325.kind]) === "stroke") _optionalChain([this, 'access', _326 => _326.controller, 'access', _327 => _327.activeStroke, 'optionalAccess', _328 => _328.cancel, 'call', _329 => _329()]);
+    if (_optionalChain([this, 'access', _329 => _329.mode, 'optionalAccess', _330 => _330.kind]) === "stroke") _optionalChain([this, 'access', _331 => _331.controller, 'access', _332 => _332.activeStroke, 'optionalAccess', _333 => _333.cancel, 'call', _334 => _334()]);
     this.mode = null;
   }
   get active() {
@@ -8236,7 +8327,7 @@ var PAPER_SLIDERS = [
 ];
 function readPath(obj, path) {
   let v = obj;
-  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _330 => _330[k]]);
+  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _335 => _335[k]]);
   return typeof v === "number" ? v : 0;
 }
 function patchPath(obj, path, value) {
@@ -8358,7 +8449,7 @@ function brushEngineControls(brush) {
         impastoTool: true
       };
     case "wet": {
-      const tool = _nullishCoalesce(_optionalChain([brush, 'access', _331 => _331.wet, 'optionalAccess', _332 => _332.tool]), () => ( "paint"));
+      const tool = _nullishCoalesce(_optionalChain([brush, 'access', _336 => _336.wet, 'optionalAccess', _337 => _337.tool]), () => ( "paint"));
       const sliders = tool === "paint" ? [
         { path: "wet.water", label: "Water", min: 0, max: 1, step: 0.01 },
         { path: "wet.pigment", label: "Pigment", min: 0, max: 1, step: 0.01 },
@@ -8491,7 +8582,7 @@ function startWetClock(controller, frame, cancel) {
   id = raf(loop);
   return () => {
     stopped = true;
-    _optionalChain([caf, 'optionalCall', _333 => _333(id)]);
+    _optionalChain([caf, 'optionalCall', _338 => _338(id)]);
   };
 }
 function drawWaterOverlay(controller, ctx) {

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

@@ -26,6 +26,7 @@ export * from './mixing-pad.cjs';
 export * from './controller.cjs';
 export * from './presence.cjs';
 export * from './tools.cjs';
+export type { PaintAgentTool, PaintOrigin, PaintToolCoordinates } from './hosted.cjs';
 export * from './ui.cjs';
 export { BLEND_MODES, PAINTERLY_BLEND_MODES, isBlendMode, isPainterlyBlendMode, standardBlendMode, type BlendMode, type BlendModeInfo } from '../raster/blend.cjs';
 export * from './wet.cjs';

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

@@ -26,6 +26,7 @@ export * from './mixing-pad.js';
 export * from './controller.js';
 export * from './presence.js';
 export * from './tools.js';
+export type { PaintAgentTool, PaintOrigin, PaintToolCoordinates } from './hosted.js';
 export * from './ui.js';
 export { BLEND_MODES, PAINTERLY_BLEND_MODES, isBlendMode, isPainterlyBlendMode, standardBlendMode, type BlendMode, type BlendModeInfo } from '../raster/blend.js';
 export * from './wet.js';