@pixerate/editor 0.121.0 → 0.122.0

package/dist/raster/index.d.cts

@@ -1,7 +1,7 @@
 import { R as RasterRect } from '../surface-Cn30xIV6.cjs';
 export { B as BLEND_MODES, a as BlendMode, b as BlendModeInfo, M as MaskSurface, P as PAINTERLY_BLEND_MODES, c as PixelSurface, d as Rgb, e as Rgba, S as SHADOW_AMBIENT, f as SurfaceDraft, T as TILE, g as TILE_SHIFT, h as Tile, i as TileKey, j as TiledSurface, k as blendChannel, l as blendImageData, m as blendLum, n as blendPixel, o as blendRgb, p as canvasCompositeOperation, q as collectTiles, r as contentBounds, s as emptySurface, t as fillRect, u as finishTile, v as isBlendMode, w as isPainterlyBlendMode, x as isSeparableBlendMode, y as mixPigment8, z as mixPigmentRgb, A as normalizeBlendMode, C as packRgba, D as pigment8, E as readPixel, F as readRegion, G as setLum, H as solidSurface, I as standardBlendMode, J as surfaceBytes, K as surfaceFromPixels, L as surfacesEqual, N as tileCoord, O as tileKey, Q as tileRect, U as tilesInRect, V as translateSurface, W as uniformTile, X as writeRegion } from '../surface-Cn30xIV6.cjs';
-import { C as CompositorLayer, R as RasterSources, a as RasterCompositor, b as CompositorProfile } from '../render-DnAbIKcs.cjs';
-export { B as BIT_DEPTHS, c as BevelContour, d as BevelEmbossEffect, e as BevelStyle, f as BevelTechnique, g as BevelTexture, h as BitDepth, i as ColorOverlayEffect, j as CompositeCallOptions, k as CompositeStats, l as CompositorOptions, m as ContourPoint, D as DEFAULT_GLOBAL_LIGHT, n as DeepSamples, o as DropShadowEffect, E as EffectCompositeInput, p as EffectContext, q as EffectContour, r as EffectFill, s as EffectGradient, t as EffectMaps, u as EffectPattern, v as EffectPatternRef, w as EffectRect, G as GlobalLight, x as GlowTechnique, y as GradientColorStop, z as GradientOpacityStop, A as GradientOverlayEffect, F as GradientStyle, H as GroupBlendMode, I as GroupIn, J as INTERPOLATIONS, K as InnerGlowEffect, L as InnerShadowEffect, M as Interpolation, N as LAYER_EFFECT_KINDS, O as LayerEffect, P as LayerEffectError, Q as LayerEffectKind, S as LayerEffects, T as LayerLocation, U as LayerLocks, V as MAX_EFFECT_REACH, W as MAX_TRANSFORM_PIXELS, X as OuterGlowEffect, Y as PatternOverlayEffect, Z as PatternPlacement, _ as PatternTile, $ as PixelFilterSpec, a0 as RasterGroupLayer, a1 as RasterLayer, a2 as RasterLayerBase, a3 as RasterMask, a4 as RasterNode, a5 as RasterPixelLayer, a6 as ResampleOptions, a7 as STROKE_CHAMFER_MAX, a8 as SatinEffect, a9 as StrokeEffect, aa as StrokePosition, ab as TransformTooLargeError, ac as activeEffectItems, ad as blendTile, ae as buildEffectMaps, af as builtinPattern, ag as builtinPatternIds, ah as changedTiles, ai as compositeLayerEffects, aj as compositeSurfaceOver, ak as contourLut, al as convertSurfaceDepth, am as deepBytes, an as deepTile, ao as defaultEffectGradient, ap as defaultLayerEffect, aq as depthOf, ar as effectColorHex, as as effectFillColors, at as effectReach, au as effectsAreLocal, av as effectsFingerprint, aw as effectsMargin, ax as effectsScale, ay as findLayer, az as flattenLayers, aA as gradientT, aB as hasActiveEffects, aC as hashNoise, aD as insertLayer, aE as isBitDepth, aF as isInterpolation, aG as isLayerEffectKind, aH as isLayerLocked, aI as keepDeepSamples, aJ as keysWeight, aK as layerEffectFields, aL as layerEffectLabel, aM as mapLayer, aN as mergeLayerEffect, aO as newEffectId, aP as normalizeLayerEffects, aQ as parseEffectColor, aR as patchEffectMaps, aS as proxyOf, aT as readDeepRegion, aU as reduceSurface, aV as renderLayerEffects, aW as scaleLayerEffect, aX as srgbDecode, aY as srgbEncode, aZ as surfaceDepth, a_ as surfaceFromDeepPixels, a$ as tileSamples, b0 as tileSamples16, b1 as tileSamples32, b2 as to16From32, b3 as to16From8, b4 as to32From16, b5 as to32From8, b6 as to8From16, b7 as to8From32, b8 as transformSurface, b9 as transformedBounds, ba as validateEffectGradient, bb as validateLayerEffect, bc as validateLayerEffects, bd as warpSurface, be as writeDeepRegion } from '../render-DnAbIKcs.cjs';
+import { C as CompositorLayer, R as RasterSources, a as RasterCompositor, b as CompositorProfile } from '../deep-QS3ppbMX.cjs';
+export { B as BIT_DEPTHS, c as BevelContour, d as BevelEmbossEffect, e as BevelStyle, f as BevelTechnique, g as BevelTexture, h as BitDepth, i as ColorOverlayEffect, j as CompositeCallOptions, k as CompositeStats, l as CompositorOptions, m as ContourPoint, D as DEFAULT_GLOBAL_LIGHT, n as DeepSamples, o as DropShadowEffect, E as EffectCompositeInput, p as EffectContext, q as EffectContour, r as EffectFill, s as EffectGradient, t as EffectMaps, u as EffectPattern, v as EffectPatternRef, w as EffectRect, G as GlobalLight, x as GlowTechnique, y as GradientColorStop, z as GradientOpacityStop, A as GradientOverlayEffect, F as GradientStyle, H as GroupBlendMode, I as GroupIn, J as INTERPOLATIONS, K as InnerGlowEffect, L as InnerShadowEffect, M as Interpolation, N as LAYER_EFFECT_KINDS, O as LayerEffect, P as LayerEffectError, Q as LayerEffectKind, S as LayerEffects, T as LayerLocation, U as LayerLocks, V as MAX_EFFECT_REACH, W as MAX_TRANSFORM_PIXELS, X as OuterGlowEffect, Y as PatternOverlayEffect, Z as PatternPlacement, _ as PatternTile, $ as PixelFilterSpec, a0 as RasterGroupLayer, a1 as RasterLayer, a2 as RasterLayerBase, a3 as RasterMask, a4 as RasterNode, a5 as RasterPixelLayer, a6 as ResampleOptions, a7 as STROKE_CHAMFER_MAX, a8 as SatinEffect, a9 as StrokeEffect, aa as StrokePosition, ab as TransformTooLargeError, ac as activeEffectItems, ad as blendTile, ae as buildEffectMaps, af as builtinPattern, ag as builtinPatternIds, ah as changedTiles, ai as compositeLayerEffects, aj as compositeSurfaceOver, ak as contourLut, al as convertSurfaceDepth, am as deepBytes, an as deepTile, ao as defaultEffectGradient, ap as defaultLayerEffect, aq as depthOf, ar as effectColorHex, as as effectFillColors, at as effectReach, au as effectsAreLocal, av as effectsFingerprint, aw as effectsMargin, ax as effectsScale, ay as findLayer, az as flattenLayers, aA as gradientT, aB as hasActiveEffects, aC as hashNoise, aD as insertLayer, aE as isBitDepth, aF as isInterpolation, aG as isLayerEffectKind, aH as isLayerLocked, aI as keepDeepSamples, aJ as keysWeight, aK as layerEffectFields, aL as layerEffectLabel, aM as mapLayer, aN as mergeLayerEffect, aO as newEffectId, aP as normalizeLayerEffects, aQ as parseEffectColor, aR as patchEffectMaps, aS as proxyOf, aT as readDeepRegion, aU as reduceSurface, aV as renderLayerEffects, aW as scaleLayerEffect, aX as srgbDecode, aY as srgbEncode, aZ as surfaceDepth, a_ as surfaceFromDeepPixels, a$ as tileSamples, b0 as tileSamples16, b1 as tileSamples32, b2 as to16From32, b3 as to16From8, b4 as to32From16, b5 as to32From8, b6 as to8From16, b7 as to8From32, b8 as transformSurface, b9 as transformedBounds, ba as validateEffectGradient, bb as validateLayerEffect, bc as validateLayerEffects, bd as warpSurface, be as writeDeepRegion } from '../deep-QS3ppbMX.cjs';
 export { B as BlurEdge, C as CURVE_LUT_SIZE, D as DIRECT_GAUSSIAN_MAX_SIGMA, a as DecodedPng, Z as ZlibError, b as adler32, c as base64ToBytes, d as bytesToBase64, e as curveLut, f as decodePng, g as deflate, h as deflateRaw, i as encodePng, j as gaussianBlur, k as inflate, l as inflateRaw, m as isPng, p as parseDataUrl, n as pngDataUrl } from '../zlib-dxQdgHyN.cjs';
 import '../types-CwMPoRMU.cjs';
 
@@ -16,11 +16,13 @@ import '../types-CwMPoRMU.cjs';
  * bits (as Photoshop blends in each mode). Results come back in that space.
  *
  * What it delegates to the 8-bit compositor it wraps:
- * - mask coverage (density, feather and parametric masks), which is coverage, not colour;
- * - layers with layer effects or pixel filters, and content layers the editor draws itself
- *   (annotations): each is rendered alone at 8 bits, converted, and blended in float with its
- *   blend mode and opacity. Such layers keep 8-bit precision (and an effect's own blend mode sees
- *   a transparent backdrop); everything else keeps the samples' full depth.
+ * - mask coverage (density, feather and parametric masks: deep masks are read at depth);
+ * - the effect maps of layers with effects (built from the 8-bit shape); the effects themselves
+ *   composite in float over the deep content (`runEffects`), and pixel filters run in float when
+ *   the profile gives `pixelFiltersDeep`;
+ * - groups with effects, filters it cannot run in float, and content layers the editor draws
+ *   itself (annotations): each is rendered alone at 8 bits, converted, and blended in float with
+ *   its blend mode and opacity.
  */
 
 /** Float hooks of an editor's own layer kinds (see `CompositorProfile`). */
@@ -31,6 +33,15 @@ interface DeepCompositorProfile<L extends CompositorLayer, S extends RasterSourc
      * Missing: filter layers run at 8 bits.
      */
     applyFilterRunDeep?(layers: L[], acc: Float32Array, r: RasterRect, coverage: Map<string, Float32Array> | undefined, sources: S): void;
+    /**
+     * A pixel layer's filters in float (`null`: none, or none it can run): `apply` filters float
+     * RGBA in the working space (`linear` at 32 bits) in place; `reach` is how many pixels each
+     * side they read (0 for per-pixel filters). Missing: filtered layers are drawn at 8 bits.
+     */
+    pixelFiltersDeep?(layer: L): {
+        reach: number;
+        apply(data: Float32Array, width: number, height: number, linear: boolean): void;
+    } | null;
 }
 declare class DeepCompositor<L extends CompositorLayer, S extends RasterSources> {
     /** The 8-bit compositor for masks and the layers it renders (see the module comment). */
@@ -50,13 +61,24 @@ declare class DeepCompositor<L extends CompositorLayer, S extends RasterSources>
     private buildSteps;
     private runSteps;
     private runStep;
+    /**
+     * A pixel layer with effects onto `acc` over `r`: its deep content (filters, mask, clipped
+     * layers) and the effects composited in float. Effect maps come from the 8-bit shape. At 32
+     * bits the effects composite in sRGB-encoded values (their colours and blends are defined
+     * there) and the result is decoded back. Returns whether anything was drawn.
+     */
+    private runEffects;
     private applyClipped;
     private applyFilterRun;
     /** Layers drawn by the 8-bit compositor alone (effects, pixel filters, content the editor draws). */
+    /** A pixel(-like) layer with effects: composited in float through `compositeLayerEffects`. */
+    private deepEffects;
     private renderedAlone;
     private blendOf;
     /** A layer's float RGBA over `r` (straight alpha, working space), or `null` when it has none there. */
     private content;
+    /** A surface's samples over `rect` (layer space) in the working space. */
+    private samples;
     /** 8-bit RGBA to the working space. */
     private from8;
     /** The working space to 8-bit RGBA. */

package/dist/raster/index.d.ts

@@ -1,7 +1,7 @@
 import { R as RasterRect } from '../surface-Cn30xIV6.js';
 export { B as BLEND_MODES, a as BlendMode, b as BlendModeInfo, M as MaskSurface, P as PAINTERLY_BLEND_MODES, c as PixelSurface, d as Rgb, e as Rgba, S as SHADOW_AMBIENT, f as SurfaceDraft, T as TILE, g as TILE_SHIFT, h as Tile, i as TileKey, j as TiledSurface, k as blendChannel, l as blendImageData, m as blendLum, n as blendPixel, o as blendRgb, p as canvasCompositeOperation, q as collectTiles, r as contentBounds, s as emptySurface, t as fillRect, u as finishTile, v as isBlendMode, w as isPainterlyBlendMode, x as isSeparableBlendMode, y as mixPigment8, z as mixPigmentRgb, A as normalizeBlendMode, C as packRgba, D as pigment8, E as readPixel, F as readRegion, G as setLum, H as solidSurface, I as standardBlendMode, J as surfaceBytes, K as surfaceFromPixels, L as surfacesEqual, N as tileCoord, O as tileKey, Q as tileRect, U as tilesInRect, V as translateSurface, W as uniformTile, X as writeRegion } from '../surface-Cn30xIV6.js';
-import { C as CompositorLayer, R as RasterSources, a as RasterCompositor, b as CompositorProfile } from '../render-B05K68_h.js';
-export { B as BIT_DEPTHS, c as BevelContour, d as BevelEmbossEffect, e as BevelStyle, f as BevelTechnique, g as BevelTexture, h as BitDepth, i as ColorOverlayEffect, j as CompositeCallOptions, k as CompositeStats, l as CompositorOptions, m as ContourPoint, D as DEFAULT_GLOBAL_LIGHT, n as DeepSamples, o as DropShadowEffect, E as EffectCompositeInput, p as EffectContext, q as EffectContour, r as EffectFill, s as EffectGradient, t as EffectMaps, u as EffectPattern, v as EffectPatternRef, w as EffectRect, G as GlobalLight, x as GlowTechnique, y as GradientColorStop, z as GradientOpacityStop, A as GradientOverlayEffect, F as GradientStyle, H as GroupBlendMode, I as GroupIn, J as INTERPOLATIONS, K as InnerGlowEffect, L as InnerShadowEffect, M as Interpolation, N as LAYER_EFFECT_KINDS, O as LayerEffect, P as LayerEffectError, Q as LayerEffectKind, S as LayerEffects, T as LayerLocation, U as LayerLocks, V as MAX_EFFECT_REACH, W as MAX_TRANSFORM_PIXELS, X as OuterGlowEffect, Y as PatternOverlayEffect, Z as PatternPlacement, _ as PatternTile, $ as PixelFilterSpec, a0 as RasterGroupLayer, a1 as RasterLayer, a2 as RasterLayerBase, a3 as RasterMask, a4 as RasterNode, a5 as RasterPixelLayer, a6 as ResampleOptions, a7 as STROKE_CHAMFER_MAX, a8 as SatinEffect, a9 as StrokeEffect, aa as StrokePosition, ab as TransformTooLargeError, ac as activeEffectItems, ad as blendTile, ae as buildEffectMaps, af as builtinPattern, ag as builtinPatternIds, ah as changedTiles, ai as compositeLayerEffects, aj as compositeSurfaceOver, ak as contourLut, al as convertSurfaceDepth, am as deepBytes, an as deepTile, ao as defaultEffectGradient, ap as defaultLayerEffect, aq as depthOf, ar as effectColorHex, as as effectFillColors, at as effectReach, au as effectsAreLocal, av as effectsFingerprint, aw as effectsMargin, ax as effectsScale, ay as findLayer, az as flattenLayers, aA as gradientT, aB as hasActiveEffects, aC as hashNoise, aD as insertLayer, aE as isBitDepth, aF as isInterpolation, aG as isLayerEffectKind, aH as isLayerLocked, aI as keepDeepSamples, aJ as keysWeight, aK as layerEffectFields, aL as layerEffectLabel, aM as mapLayer, aN as mergeLayerEffect, aO as newEffectId, aP as normalizeLayerEffects, aQ as parseEffectColor, aR as patchEffectMaps, aS as proxyOf, aT as readDeepRegion, aU as reduceSurface, aV as renderLayerEffects, aW as scaleLayerEffect, aX as srgbDecode, aY as srgbEncode, aZ as surfaceDepth, a_ as surfaceFromDeepPixels, a$ as tileSamples, b0 as tileSamples16, b1 as tileSamples32, b2 as to16From32, b3 as to16From8, b4 as to32From16, b5 as to32From8, b6 as to8From16, b7 as to8From32, b8 as transformSurface, b9 as transformedBounds, ba as validateEffectGradient, bb as validateLayerEffect, bc as validateLayerEffects, bd as warpSurface, be as writeDeepRegion } from '../render-B05K68_h.js';
+import { C as CompositorLayer, R as RasterSources, a as RasterCompositor, b as CompositorProfile } from '../deep-DLwKZDFr.js';
+export { B as BIT_DEPTHS, c as BevelContour, d as BevelEmbossEffect, e as BevelStyle, f as BevelTechnique, g as BevelTexture, h as BitDepth, i as ColorOverlayEffect, j as CompositeCallOptions, k as CompositeStats, l as CompositorOptions, m as ContourPoint, D as DEFAULT_GLOBAL_LIGHT, n as DeepSamples, o as DropShadowEffect, E as EffectCompositeInput, p as EffectContext, q as EffectContour, r as EffectFill, s as EffectGradient, t as EffectMaps, u as EffectPattern, v as EffectPatternRef, w as EffectRect, G as GlobalLight, x as GlowTechnique, y as GradientColorStop, z as GradientOpacityStop, A as GradientOverlayEffect, F as GradientStyle, H as GroupBlendMode, I as GroupIn, J as INTERPOLATIONS, K as InnerGlowEffect, L as InnerShadowEffect, M as Interpolation, N as LAYER_EFFECT_KINDS, O as LayerEffect, P as LayerEffectError, Q as LayerEffectKind, S as LayerEffects, T as LayerLocation, U as LayerLocks, V as MAX_EFFECT_REACH, W as MAX_TRANSFORM_PIXELS, X as OuterGlowEffect, Y as PatternOverlayEffect, Z as PatternPlacement, _ as PatternTile, $ as PixelFilterSpec, a0 as RasterGroupLayer, a1 as RasterLayer, a2 as RasterLayerBase, a3 as RasterMask, a4 as RasterNode, a5 as RasterPixelLayer, a6 as ResampleOptions, a7 as STROKE_CHAMFER_MAX, a8 as SatinEffect, a9 as StrokeEffect, aa as StrokePosition, ab as TransformTooLargeError, ac as activeEffectItems, ad as blendTile, ae as buildEffectMaps, af as builtinPattern, ag as builtinPatternIds, ah as changedTiles, ai as compositeLayerEffects, aj as compositeSurfaceOver, ak as contourLut, al as convertSurfaceDepth, am as deepBytes, an as deepTile, ao as defaultEffectGradient, ap as defaultLayerEffect, aq as depthOf, ar as effectColorHex, as as effectFillColors, at as effectReach, au as effectsAreLocal, av as effectsFingerprint, aw as effectsMargin, ax as effectsScale, ay as findLayer, az as flattenLayers, aA as gradientT, aB as hasActiveEffects, aC as hashNoise, aD as insertLayer, aE as isBitDepth, aF as isInterpolation, aG as isLayerEffectKind, aH as isLayerLocked, aI as keepDeepSamples, aJ as keysWeight, aK as layerEffectFields, aL as layerEffectLabel, aM as mapLayer, aN as mergeLayerEffect, aO as newEffectId, aP as normalizeLayerEffects, aQ as parseEffectColor, aR as patchEffectMaps, aS as proxyOf, aT as readDeepRegion, aU as reduceSurface, aV as renderLayerEffects, aW as scaleLayerEffect, aX as srgbDecode, aY as srgbEncode, aZ as surfaceDepth, a_ as surfaceFromDeepPixels, a$ as tileSamples, b0 as tileSamples16, b1 as tileSamples32, b2 as to16From32, b3 as to16From8, b4 as to32From16, b5 as to32From8, b6 as to8From16, b7 as to8From32, b8 as transformSurface, b9 as transformedBounds, ba as validateEffectGradient, bb as validateLayerEffect, bc as validateLayerEffects, bd as warpSurface, be as writeDeepRegion } from '../deep-DLwKZDFr.js';
 export { B as BlurEdge, C as CURVE_LUT_SIZE, D as DIRECT_GAUSSIAN_MAX_SIGMA, a as DecodedPng, Z as ZlibError, b as adler32, c as base64ToBytes, d as bytesToBase64, e as curveLut, f as decodePng, g as deflate, h as deflateRaw, i as encodePng, j as gaussianBlur, k as inflate, l as inflateRaw, m as isPng, p as parseDataUrl, n as pngDataUrl } from '../zlib-dxQdgHyN.js';
 import '../types-CwMPoRMU.js';
 
@@ -16,11 +16,13 @@ import '../types-CwMPoRMU.js';
  * bits (as Photoshop blends in each mode). Results come back in that space.
  *
  * What it delegates to the 8-bit compositor it wraps:
- * - mask coverage (density, feather and parametric masks), which is coverage, not colour;
- * - layers with layer effects or pixel filters, and content layers the editor draws itself
- *   (annotations): each is rendered alone at 8 bits, converted, and blended in float with its
- *   blend mode and opacity. Such layers keep 8-bit precision (and an effect's own blend mode sees
- *   a transparent backdrop); everything else keeps the samples' full depth.
+ * - mask coverage (density, feather and parametric masks: deep masks are read at depth);
+ * - the effect maps of layers with effects (built from the 8-bit shape); the effects themselves
+ *   composite in float over the deep content (`runEffects`), and pixel filters run in float when
+ *   the profile gives `pixelFiltersDeep`;
+ * - groups with effects, filters it cannot run in float, and content layers the editor draws
+ *   itself (annotations): each is rendered alone at 8 bits, converted, and blended in float with
+ *   its blend mode and opacity.
  */
 
 /** Float hooks of an editor's own layer kinds (see `CompositorProfile`). */
@@ -31,6 +33,15 @@ interface DeepCompositorProfile<L extends CompositorLayer, S extends RasterSourc
      * Missing: filter layers run at 8 bits.
      */
     applyFilterRunDeep?(layers: L[], acc: Float32Array, r: RasterRect, coverage: Map<string, Float32Array> | undefined, sources: S): void;
+    /**
+     * A pixel layer's filters in float (`null`: none, or none it can run): `apply` filters float
+     * RGBA in the working space (`linear` at 32 bits) in place; `reach` is how many pixels each
+     * side they read (0 for per-pixel filters). Missing: filtered layers are drawn at 8 bits.
+     */
+    pixelFiltersDeep?(layer: L): {
+        reach: number;
+        apply(data: Float32Array, width: number, height: number, linear: boolean): void;
+    } | null;
 }
 declare class DeepCompositor<L extends CompositorLayer, S extends RasterSources> {
     /** The 8-bit compositor for masks and the layers it renders (see the module comment). */
@@ -50,13 +61,24 @@ declare class DeepCompositor<L extends CompositorLayer, S extends RasterSources>
     private buildSteps;
     private runSteps;
     private runStep;
+    /**
+     * A pixel layer with effects onto `acc` over `r`: its deep content (filters, mask, clipped
+     * layers) and the effects composited in float. Effect maps come from the 8-bit shape. At 32
+     * bits the effects composite in sRGB-encoded values (their colours and blends are defined
+     * there) and the result is decoded back. Returns whether anything was drawn.
+     */
+    private runEffects;
     private applyClipped;
     private applyFilterRun;
     /** Layers drawn by the 8-bit compositor alone (effects, pixel filters, content the editor draws). */
+    /** A pixel(-like) layer with effects: composited in float through `compositeLayerEffects`. */
+    private deepEffects;
     private renderedAlone;
     private blendOf;
     /** A layer's float RGBA over `r` (straight alpha, working space), or `null` when it has none there. */
     private content;
+    /** A surface's samples over `rect` (layer space) in the working space. */
+    private samples;
     /** 8-bit RGBA to the working space. */
     private from8;
     /** The working space to 8-bit RGBA. */

package/dist/raster/index.js

@@ -61,7 +61,7 @@ import {
   validateLayerEffects,
   warpSurface,
   workingToSamples
-} from "../chunk-4I54JSJ6.js";
+} from "../chunk-CLTTLLWA.js";
 import "../chunk-GX332W2C.js";
 import {
   BIT_DEPTHS,

package/package.json

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

package/skills/pixerate-canvas/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: pixerate-canvas
-description: How to build and edit a Pixerate design canvas or node graph through its agent tools - adding, connecting, updating and laying out nodes (canvas_add_node, canvas_layout), reading state with get_editor_state and looking at it with view_editor, reusable components with variants, instances and overrides (create_component, add_variant, set_instance_properties), align, distribute, lock and layer order, shape boolean operations (unite, subtract, offset path, outline stroke), auto layout frames, and keyframe animation with easing and CSS export. Use when working on a canvas, whiteboard, flow chart, node graph, frame, design system, component library, button variants, layout, alignment, z-order or a canvas animation in a Pixerate editor.
+description: How to build and edit a Pixerate design canvas or node graph through its agent tools - drawing freehand pen, highlighter and dry-brush strokes (canvas.drawFreehand), adding, connecting, updating and laying out nodes (canvas_add_node, canvas_layout), reading state with get_editor_state and looking at it with view_editor, reusable components with variants, instances and overrides (create_component, add_variant, set_instance_properties), align, distribute, lock and layer order, shape boolean operations (unite, subtract, offset path, outline stroke), auto layout frames, and keyframe animation with easing and CSS export. Use when working on a canvas, whiteboard, flow chart, node graph, frame, design system, component library, button variants, layout, alignment, z-order or a canvas animation in a Pixerate editor.
 ---
 
 # Pixerate canvas
@@ -71,6 +71,12 @@ batching and error codes.
   everything at once. Animate `opacity`, `x`, `y`, `scale` and `rotation`; colour tweens
   interpolate in OKLab.
 
+- **Brushed strokes.** Use a brush when the user wants a hand-drawn look (sketching, ink,
+  pencil, marker); keep plain strokes for diagrams and UI. Send points every 2 to 8 canvas units
+  along a curve, and shape the line with a short `pressure` profile (tapered ends:
+  `[0.2, 0.9, 1, 0.9, 0.2]`) rather than many points of different widths. `width` is the brush
+  size.
+
 ## Tool reference
 
 ### Read
@@ -157,6 +163,17 @@ are kept exactly). They need unlocked shapes; other selected nodes are ignored.
 | `canvas.offsetPath` | Grow (`distance` > 0) or shrink (< 0) shapes by `distance` canvas units (default 10), with `join` `miter` (default), `round` or `bevel` and `miterLimit` (default 4). |
 | `canvas.outlineStroke` | Turn shapes' strokes into filled shapes: `join` (default miter), `cap` `butt` (default), `round` or `square`, `miterLimit` (default 4). The fill stays as a separate shape below. |
 
+### Draw
+
+Freehand strokes are `path` shape nodes, so they select, move, group, erase and export like any
+shape. A stroke with `data.shape.brush` is painted with a dry paint brush instead of an SVG stroke
+(the path stays the data; the paint is rendered from it).
+
+| Command | Use it to |
+| --- | --- |
+| `canvas.drawFreehand` | Draw a pen or highlighter stroke through `points` (`[x, y]` pairs in canvas units, in drawing order; one undo step). `tool` picks the defaults (`pen`: blue, width 3; `highlighter`: yellow, width 24, opacity 0.35); `color`, `width`, `opacity` override them. Pass `brush` (a preset id from `canvas.listBrushes`, or tip settings) to paint it with a dry brush, plus `pressure` / `tiltX` / `tiltY` profiles spread along its length (`[0.2, 1, 0.3]` swells in the middle). Returns the node `id`, its `bounds` and the stored `brush`. |
+| `canvas.listBrushes` | Read-only: the dry paint presets `canvas.drawFreehand` accepts as `brush` (`id`, `name`, `category`, the preset's own `size`). Call it before the first brushed stroke instead of guessing ids. |
+
 ### Components (command form)
 
 The same operations as the component tools, for command palettes and `run_commands` batches.
@@ -210,6 +227,11 @@ easing applies to the segment leaving a keyframe. Animatable properties: `x`, `y
 
 ## Pitfalls
 
+- **Brushes are dry only.** Wet presets (watercolour, gouache, wet oils), mixer, blender, smudge and
+  eraser presets are refused: wet paint needs an area to flow in, and the others need paint under
+  them. `pressure` and tilt without a `brush` are refused too.
+- **Shape operations drop the brush.** Unite, subtract, offset path and outline stroke turn
+  brushed strokes into plain filled or stroked paths.
 - `canvas_*` tools validate ids against the current state; an "Unknown node id" error means call
   `get_editor_state` again, not guess.
 - `canvas_add_node` with `nearNodeId` also adds an edge from that node. Pass an explicit

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

@@ -182,6 +182,10 @@ drawing or editing either.
    replays the same. To carry dirty paint from stroke to stroke, pass `mixer.loadEachStroke:
    false` and `cleanEachStroke: false`, start with `load_mixer_brush`, read the brush with
    `get_mixer_brush` when unsure, and reset it with `clean_mixer_brush`.
+8. **Gradient paint** (colour that changes as the stroke goes): `set_paint` with `{ type:
+   "gradient", stops, map }`, or `paint_stroke` `paint` for one stroke (brush only). `map.by`
+   `distance` (default 300 px, mirrored) for drag-it-out colour, `pressure`, `direction`,
+   `across-tip`, `random`; stops may be `"paint"` / `"secondary"` (foreground / background).
 
 ### Colour management
 
@@ -370,7 +374,9 @@ in the source frame at the document's bit depth, colour mode and profile. Read
 | `remove_layer_effect` | Delete one effect. To hide it and keep its settings, set `enabled: false` with `update_layer_effect` instead. Returns the remaining effects. |
 | `set_layer_effects_enabled` | Switch all of a layer's effects on or off (`enabled`) and optionally set Scale Effects (`scale`, 1 = 100 %, multiplies sizes, distances and pattern scales). Returns the effects. |
 | `set_global_light` | Set the document light (`angle`, `altitude` in degrees) that every shadow and bevel with `useGlobalLight` follows. Returns the light. |
-| `paint_stroke` | Paint (`tool` brush), blend with the Mixer Brush (`tool` mixer) or erase (`tool` eraser) along `points` in document px (optional `pressure` 0..1) on a pixel layer or its mask (`channel`; the mixer paints pixels only); `color` #rrggbb (on a mask: black hides, white reveals; for the mixer, the reservoir colour); `brush` `{size, hardness, spacing, angle, roundness, opacity, flow, smoothing, pressureSize, pressureOpacity, blend}`; `mixer` `{wet, load, mix, loadEachStroke, cleanEachStroke, mixing: rgb \| pigment}` (tool mixer only). The selection limits the paint. One undo step per call. Returns the layer, channel, changed `bounds`, dab count and, for the mixer, `mixerLoad` `{reservoir, amount, pickup}`. |
+| `paint_stroke` | Paint (`tool` brush), blend with the Mixer Brush (`tool` mixer) or erase (`tool` eraser) along `points` in document px (optional `pressure` 0..1) on a pixel layer or its mask (`channel`; the mixer paints pixels only); `color` #rrggbb (on a mask: black hides, white reveals; for the mixer, the reservoir colour) or `paint` (brush only: a gradient for this stroke); `brush` `{size, hardness, spacing, angle, roundness, opacity, flow, smoothing, pressureSize, pressureOpacity, blend}`; `mixer` `{wet, load, mix, loadEachStroke, cleanEachStroke, mixing: rgb \| pigment}` (tool mixer only). The selection limits the paint. One undo step per call. Returns the layer, channel, changed `bounds`, dab count and, for the mixer, `mixerLoad` `{reservoir, amount, pickup}`. |
+| `set_paint` | Set what the brush paints: one colour (it becomes the foreground) or gradient paint (`stops` sorted by offset, `space` pigment / oklab / srgb, `map`, `softness`). Errors say what is wrong. Returns `paint`, `foreground`, `background`, `brush`. |
+| `get_paint` | Read-only. What the brush paints (`paint`), the foreground and background colours and the brush settings. |
 | `get_mixer_brush` | Read-only. The Mixer Brush settings and what it carries (`reservoir` #rrggbb or null, `amount` left 0..1, `pickup` #rrggbb or null). Call it before a mixer stroke with `loadEachStroke: false`. |
 | `load_mixer_brush` | Fill the Mixer Brush reservoir with `color` (default the foreground), amount 1; keeps the pickup. View state, not an undo step. Use before strokes with `loadEachStroke: false`. Returns the load. |
 | `clean_mixer_brush` | Empty the Mixer Brush pickup well (`emptyReservoir: true` also drops the loaded paint, so it only smears). View state, not an undo step. Returns the load. |

package/skills/pixerate-image-editor/references/photoshop-files.md

@@ -27,9 +27,10 @@
    (resampled at depth; whole-pixel moves exact) keep the depth (32-bit paint and resampling work
    in linear light). Layer masks keep the depth too: 16- and 32-bit masks open and save at depth,
    blend with their full precision, and the brush, eraser, `fill_pixels` and `clear_pixels` paint
-   them at depth (retouching on a mask stays 8-bit). Layer filters and layer effects still
-   compute in 8 bits: the pixels they change get 8-bit precision, every pixel they leave alone
-   keeps its deep samples. Afterwards work with `list_layers` as
+   them at depth (retouching on a mask stays 8-bit). Layer filters (develop, blur) and layer
+   effects composite at depth in merges, `compositeDeepPixels` and the exported merged image (a
+   group's effects and legacy-process develop filters stay 8-bit). The viewport always shows
+   the 8-bit rendering. Afterwards work with `list_layers` as
    usual: there is no Background source image, every pixel comes from the layers.
 4. **Smart objects come in live**: embedded contents (a PSB opens as a nested document you can
    edit with `edit_smart_object_contents`, a PNG as raster contents), the placement and warp, the

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

@@ -187,6 +187,30 @@ is never part of a layer. Coordinates are document pixels, (0, 0) top-left, y do
   `get_relief` reads a layer's relief; `flatten_relief` removes it but keeps the colour.
 - **Metallic paper**: `set_paper` `metallic` 0..1 makes the grain sparkle under the light.
 
+## Gradient paint
+
+Paint that changes colour as the stroke goes: give a gradient where a colour would go.
+
+1. **`set_paint`** with `{ type: "gradient", stops, map }` makes it the paint for every following
+   stroke (`set_color` goes back to one colour); `paint_stroke` `paint` overrides it for one stroke;
+   a brush can carry its own (`set_brush` `paint`, presets `gradient-round`, `pressure-ombre`,
+   `rainbow-marker`, `gradient-wash`).
+2. **Choose the mapping by what the stroke should do**: `distance` (default, 300 px then
+   `mirror` back) for "drag it out" colour; `pressure` for light-to-heavy shading in one stroke;
+   `direction` for strokes coloured by their heading; `across-tip` for a brush loaded with several
+   colours side by side; `random` (`every` dabs) for speckled or confetti colour; `time` and
+   `velocity` need timed points (`t`). Set `length` to about the stroke length you will paint.
+3. **Stops**: 2..16, sorted by `offset`; `"paint"` / `"secondary"` follow the two editor colours;
+   `opacity` multiplies flow (fade a stroke out); `midpoint` shifts where two colours meet;
+   `softness` 0 makes hard bands. `space` `pigment` (default) mixes like paint (blue to yellow
+   through green), `oklab` keeps rainbows bright.
+4. **It works with every colour engine**: dab, Mixer Brush (each dab reloads its reservoir),
+   watercolour and gouache (each deposit carries its pigment into the wet layer, which then flows
+   and mixes), oil and impasto (the colour varies along the relief), particles, bristles and
+   stickers. Erasers, blenders and smudges ignore it; the eyedropper picks one colour.
+5. Strokes record the gradient (with concrete colours), so replays, time-lapses, high-res
+   re-renders and drying are exact. `get_brush` `strokePaint` says what the next stroke paints.
+
 ## Procedural brushes, bristles, stickers and stencils
 
 - **Particle brushes** (category `procedural`): `hair-strands` (strings of masses dragged behind
@@ -240,9 +264,9 @@ is never part of a layer. Coordinates are document pixels, (0, 0) top-left, y do
 
 | Tool | Use |
 | --- | --- |
-| `list_brushes` | Read the library (built-in and saved): id, name, category, engine, size, grain response, rotation, `wetCapable`, `pickup`, `dirty`, `multicolor` mode, `builtin`; plus the active brush id and whether it is edited. |
-| `get_brush` | Read every setting of a brush, or of the active brush as edited (no `id`). Read before changing a brush you did not build. |
-| `set_brush` | Choose the active brush (`id`) and / or change it: `tip` (size px, hardness, spacing, angle, roundness, opacity, flow, smoothing, pressureSize, pressureOpacity, blend), `grain`, `pressureSmoothing`, `rotation`, `dynamics` (minSize, pressureFlow, tiltSize, tiltRoundness, tiltOpacity, velocitySize, velocityOpacity, jitters, scatter), `engine`, `mixer`, `loadsColor`, `behavior` (pickup, mix, dirty, mixing, multicolor: mode, colors, order, length, softness), `blender` (strength, distance, mixing), `smudge` (strength, length, mixing). Editor state. Returns the brush. |
+| `list_brushes` | Read the library (built-in and saved): id, name, category, engine, size, grain response, rotation, `wetCapable`, `pickup`, `dirty`, `gradient` (has its own gradient paint), `multicolor` mode, `builtin`; plus the active brush id and whether it is edited. |
+| `get_brush` | Read every setting of a brush, or of the active brush as edited (no `id`), including `paint` (its own gradient, or null) and `strokePaint` (what its next stroke paints). Read before changing a brush you did not build. |
+| `set_brush` | Choose the active brush (`id`) and / or change it: `tip` (size px, hardness, spacing, angle, roundness, opacity, flow, smoothing, pressureSize, pressureOpacity, blend), `grain`, `pressureSmoothing`, `rotation`, `dynamics` (minSize, pressureFlow, tiltSize, tiltRoundness, tiltOpacity, velocitySize, velocityOpacity, jitters, scatter), `engine`, `mixer`, `loadsColor`, `behavior` (pickup, mix, dirty, mixing; multicolor is the older form of `paint`), `paint` (the brush's own gradient, or null for the editor's paint), `blender` (strength, distance, mixing), `smudge` (strength, length, mixing). Editor state. Returns the brush. |
 | `save_brush` | Store the active brush in the user library under `id` (lowercase, digits, dashes) and `name`. Built-in ids are refused. |
 | `remove_brush` | Delete a user brush. Built-in brushes cannot be removed. |
 | `export_brushes` | Get a brush library file (JSON) of `ids`, or of every user brush. |
@@ -254,14 +278,15 @@ is never part of a layer. Coordinates are document pixels, (0, 0) top-left, y do
 | Tool | Use |
 | --- | --- |
 | `mix_colors` | Predict a mix: `colors` with `weight` parts (and optional tinting `strength`), `model` `pigment` (default, Kubelka-Munk: what pigment blends, the Mixer Brush, pigment blending tools and the pad do) or `rgb` (what normal blending and rgb mixing do). Returns `mixed` by the model plus `pigment` and `rgbLerp` for comparison. Changes nothing. Use it to choose stroke colours. |
-| `set_color` | Set the default paint `color` (and `secondaryColor`). |
+| `set_color` | Set the default paint `color` (and `secondaryColor`); back to one colour after gradient paint. |
+| `set_paint` | Set the paint: one colour, or gradient paint (`stops`, `space`, `map`, `softness`; see Gradient paint). Errors say what is wrong (unsorted stops, a bad mapping). Returns `paint`, `color`, `secondaryColor`. |
 | `pick_color` | Read the colour at `x`, `y`: of the painting with its paper, or of one layer (with alpha). |
 | `get_mixer_brush` | Read what the brush carries: the Mixer Brush `reservoir` and `amount` left, and `pickup` (paint picked up, kept by dirty brushes). |
 | `load_mixer_brush` | Fill the Mixer Brush reservoir with a colour (keeps its pickup). |
 | `clean_mixer_brush` | Wipe the brush: drop the picked-up paint a dirty brush or the Mixer Brush carries (and with `emptyReservoir` the Mixer Brush paint). |
 | `color_harmony` | Get a harmony (`kind`: complementary, split-complementary, analogous, triadic, tetradic, square, monochromatic) around `color` (default the paint colour), on the `ryb` painter's wheel (default; red ↔ green) or the `rgb` wheel (red ↔ cyan), `spread` degrees for analogous and split. Changes nothing. |
-| `list_swatches` | Read the swatches (index, colour, name). |
-| `add_swatch` | Keep a colour as a swatch (saved with the document). |
+| `list_swatches` | Read the swatches (index, colour, name, and `paint` for a gradient swatch). |
+| `add_swatch` | Keep a colour (`color`) or a gradient (`paint`) as a swatch (saved with the document). |
 | `remove_swatch` | Remove a swatch by `index`. |
 | `mixing_pad_stroke` | Paint on the 360 × 220 mixing pad (pad px): `tool` paint lays `color` with a pigment Mixer Brush, `knife` smears what is there and mixes it as paint. Scratch space, not the painting, no undo. |
 | `pick_mixing_pad_color` | Read the mix on the pad at `x`, `y` (averaged over `radius`, default 3); `setColor` makes it the paint colour. Null where the pad is bare. |
@@ -277,7 +302,7 @@ is never part of a layer. Coordinates are document pixels, (0, 0) top-left, y do
 
 | Tool | Use |
 | --- | --- |
-| `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` changes, `color`, `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. |
+| `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` changes, `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. With `ids`, their points too. |
 | `replay_strokes` | Paint recorded `strokeIds` again: exactly, or varied by `dx` / `dy` (px), `rotate` (degrees clockwise), `scale` (brush size follows), `flipX`, `origin`, `pressureScale`, `color`, `brushId`, `layerId`, `repeat` (each copy applies the variation again). One undo step. Returns the new stroke ids, bounds and layers. |
 | `undo_paint` | Undo the last step (a wet stroke's undo puts the wet paint back as it was before it). Returns what was undone and what is next. |