@pixerate/editor 0.93.0 → 0.94.0

package/dist/raster/index.d.ts

@@ -1,365 +1,116 @@
-import { B as BlendMode, M as MaskSurface, P as PixelSurface, R as RasterRect, T as TiledSurface, h as TileKey } from '../surface-fJhkmNQn.js';
-export { a as BLEND_MODES, b as BlendModeInfo, c as Rgb, d as Rgba, S as SurfaceDraft, e as TILE, f as TILE_SHIFT, g as Tile, i as blendChannel, j as blendImageData, k as blendLum, l as blendPixel, m as blendRgb, n as canvasCompositeOperation, o as collectTiles, p as contentBounds, q as emptySurface, r as fillRect, s as finishTile, t as isBlendMode, u as isSeparableBlendMode, v as normalizeBlendMode, w as packRgba, x as readPixel, y as readRegion, z as setLum, A as solidSurface, C as surfaceBytes, D as surfaceFromPixels, E as surfacesEqual, F as tileCoord, G as tileKey, H as tileRect, I as tilesInRect, J as translateSurface, K as uniformTile, L as writeRegion } from '../surface-fJhkmNQn.js';
+import { B as BlendMode } from '../surface-CuBg2c6k.js';
+export { a as BLEND_MODES, b as BlendModeInfo, M as MaskSurface, P as PixelSurface, R as RasterRect, c as Rgb, d as Rgba, S as SurfaceDraft, T as TILE, e as TILE_SHIFT, f as Tile, g as TileKey, h as TiledSurface, i as blendChannel, j as blendImageData, k as blendLum, l as blendPixel, m as blendRgb, n as canvasCompositeOperation, o as collectTiles, p as contentBounds, q as emptySurface, r as fillRect, s as finishTile, t as isBlendMode, u as isSeparableBlendMode, v as normalizeBlendMode, w as packRgba, x as readPixel, y as readRegion, z as setLum, A as solidSurface, C as surfaceBytes, D as surfaceFromPixels, E as surfacesEqual, F as tileCoord, G as tileKey, H as tileRect, I as tilesInRect, J as translateSurface, K as uniformTile, L as writeRegion } from '../surface-CuBg2c6k.js';
+import { L as LayerEffect, G as GlobalLight, P as PatternTile, a as LayerEffects, E as EffectContour, b as GradientStyle } from '../zlib-BjQkpMFi.js';
+export { B as BevelContour, c as BevelEmbossEffect, d as BevelStyle, e as BevelTechnique, f as BevelTexture, g as BlurEdge, C as CURVE_LUT_SIZE, h as ColorOverlayEffect, i as CompositeCallOptions, j as CompositeStats, k as CompositorLayer, l as CompositorOptions, m as CompositorProfile, n as ContourPoint, D as DEFAULT_GLOBAL_LIGHT, o as DIRECT_GAUSSIAN_MAX_SIGMA, p as DecodedPng, q as DropShadowEffect, r as EffectFill, s as EffectGradient, t as EffectPattern, u as EffectPatternRef, v as GlowTechnique, w as GradientColorStop, x as GradientOpacityStop, y as GradientOverlayEffect, z as GroupBlendMode, A as GroupIn, I as InnerGlowEffect, F as InnerShadowEffect, H as LAYER_EFFECT_KINDS, J as LayerEffectError, K as LayerEffectKind, M as LayerLocation, N as LayerLocks, O as MAX_EFFECT_REACH, Q as OuterGlowEffect, R as PatternOverlayEffect, S as PatternPlacement, T as PixelFilterSpec, U as RasterCompositor, V as RasterGroupLayer, W as RasterLayer, X as RasterLayerBase, Y as RasterMask, Z as RasterNode, _ as RasterPixelLayer, $ as RasterSources, a0 as SatinEffect, a1 as StrokeEffect, a2 as StrokePosition, a3 as ZlibError, a4 as adler32, a5 as base64ToBytes, a6 as blendTile, a7 as builtinPattern, a8 as builtinPatternIds, a9 as bytesToBase64, aa as changedTiles, ab as curveLut, ac as decodePng, ad as defaultEffectGradient, ae as defaultLayerEffect, af as deflate, ag as deflateRaw, ah as effectColorHex, ai as effectReach, aj as effectsFingerprint, ak as effectsMargin, al as effectsScale, am as encodePng, an as findLayer, ao as flattenLayers, ap as gaussianBlur, aq as hasActiveEffects, ar as hashNoise, as as inflate, at as inflateRaw, au as insertLayer, av as isLayerEffectKind, aw as isLayerLocked, ax as isPng, ay as layerEffectFields, az as layerEffectLabel, aA as mapLayer, aB as mergeLayerEffect, aC as newEffectId, aD as normalizeLayerEffects, aE as parseDataUrl, aF as parseEffectColor, aG as pngDataUrl, aH as scaleLayerEffect, aI as validateEffectGradient, aJ as validateLayerEffect, aK as validateLayerEffects } from '../zlib-BjQkpMFi.js';
 
 /**
- * A layer stack that is not specific to any editor: pixel layers on tiled surfaces, groups (with
- * pass-through), raster masks with density and feather, clipping, locks, opacity, fill and blend
- * modes, plus pure tree helpers. Editors extend these types with their own layer kinds (the image
- * editor adds adjustment and annotation layers, filters and parametric masks).
+ * CPU renderer for layer effects.
  *
- * Layer objects are immutable: every change builds new objects along the path from the root to
- * the changed layer and shares everything else.
- */
-
-/** Blend modes of a layer; groups also accept `pass-through`. */
-type GroupBlendMode = BlendMode | 'pass-through';
-interface LayerLocks {
-    /** Painting and filling are refused. */
-    pixels?: boolean;
-    /** Painting keeps each pixel's alpha. */
-    transparency?: boolean;
-    /** Moving (offset) is refused. */
-    position?: boolean;
-    /** Everything above, plus property changes and deletion. */
-    all?: boolean;
-}
-/**
- * A layer mask: 8-bit coverage (255 reveals, 0 hides) on a tiled surface, plus non-destructive
- * density and feather. `source` is an editor-defined parametric mask (generated instead of
- * painted; the compositor asks its profile for the coverage, and the surface is unused).
- */
-interface RasterMask<Source = unknown> {
-    surface: MaskSurface;
-    /** Value outside the painted tiles (PSD's default colour); equals `surface.defaultValue`. */
-    defaultValue: 0 | 255;
-    /** 0..1 (missing = 1): at 0.5 hidden areas still show half. */
-    density?: number;
-    /** Gaussian σ in pixels (missing = 0). */
-    feather?: number;
-    /** `false` keeps the mask but ignores it. */
-    enabled?: boolean;
-    source?: Source;
-}
-interface RasterLayerBase {
-    id: string;
-    name: string;
-    visible: boolean;
-    /** 0..1 */
-    opacity: number;
-    blend: BlendMode;
-    /** Clip to the nearest unclipped layer below (Photoshop's clipping mask). */
-    clipped?: boolean;
-    mask?: RasterMask;
-    locks?: LayerLocks;
-}
-interface RasterPixelLayer extends RasterLayerBase {
-    type: 'pixel';
-    /** Pixels in layer space; document position = layer position + `offset`. A mask moves with it. */
-    surface: PixelSurface;
-    /** Integer move without re-tiling. */
-    offset: {
-        x: number;
-        y: number;
-    };
-    /** 0..1, PSD "Fill" (missing = 1). */
-    fillOpacity?: number;
-}
-interface RasterGroupLayer<L = RasterLayer> extends Omit<RasterLayerBase, 'blend'> {
-    type: 'group';
-    blend: GroupBlendMode;
-    /** Bottom to top. */
-    children: L[];
-    /** UI only. */
-    collapsed?: boolean;
-}
-/** The plain stack: pixel layers and groups. */
-type RasterLayer = RasterPixelLayer | RasterGroupLayer<RasterLayer>;
-/** What the tree helpers need of a layer: an id, a type, and `children` on groups. */
-interface RasterNode {
-    id: string;
-    type: string;
-}
-/** The group members of a layer union. */
-type GroupIn<T> = Extract<T, {
-    type: 'group';
-}>;
-interface LayerLocation<T extends RasterNode = RasterLayer> {
-    layer: T;
-    /** The containing group, or `null` at the top level. */
-    parent: GroupIn<T> | null;
-    /** Index within the parent's children (or the top-level list). */
-    index: number;
-    /** Ancestors from the top level down to the parent. */
-    path: GroupIn<T>[];
-}
-/** Every layer, depth first, bottom to top (a group comes before its children). */
-declare function flattenLayers<T extends RasterNode>(layers: readonly T[]): T[];
-declare function findLayer<T extends RasterNode>(layers: readonly T[], id: string): LayerLocation<T> | null;
-/** Replaces the layer with `id` by `fn(layer)` (or removes it when `fn` returns `null`). */
-declare function mapLayer<T extends RasterNode>(layers: readonly T[], id: string, fn: (layer: T) => T | null): T[];
-/** Inserts `layer` into `parentId`'s children (or the top level) at `index` (default: top). */
-declare function insertLayer<T extends RasterNode>(layers: readonly T[], layer: T, parentId: string | null, index?: number): T[];
-declare function isLayerLocked(layer: {
-    locks?: LayerLocks;
-}, what: keyof LayerLocks): boolean;
-
-/**
- * The per-tile layer compositor engine. Composites a layer stack (pixel layers and groups with
- * masks, clipping, blend modes, opacity, fill and pass-through) tile by tile in document space,
- * in pure TypeScript, so results are deterministic and testable in Node and Workers.
+ * Render order, bottom to top (Photoshop's layer-style stack read upwards): drop shadows, outer
+ * glows, then the layer itself (content at fill opacity) with pattern, gradient and colour
+ * overlays, satin, inner glows, inner shadows, the inside part of strokes and inner bevels on
+ * top. The outside part of strokes and outer bevels go beneath the layer, onto the backdrop.
+ * Exterior effects blend straight into the backdrop with their own modes; the layer blends with
+ * its mode and, in a mode other than Normal, is merged into the backdrop before the interior
+ * effects paint over it (Photoshop's "Blend Interior Effects as Group" off). Emboss and pillow
+ * emboss then shade the composited result. Layer opacity applies to the whole stack; fill
+ * opacity only to the layer's own pixels.
  *
- * Editors add their own layer kinds through a {@link CompositorProfile}: layers that filter
- * what is below them (adjustment layers), content layers drawn by the editor (annotations),
- * per-layer pixel filters, and parametric mask sources.
+ * Every map depends only on the layer's shape (its alpha after the mask), the effect settings
+ * and the global light, never on the backdrop. {@link buildEffectMaps} computes them once over the
+ * layer's whole region; {@link compositeLayerEffects} paints any part of that region (a tile) from
+ * them, pixel by pixel, so a tiled render equals a whole-image render.
  *
- * Caches:
- * - Each top-level *step* (a content layer and the layers clipped to it, a run of filter layers,
- *   a group) has a per-tile *signature*: its properties plus the identity of every surface tile
- *   it reads. A tile whose signatures are unchanged returns the cached result (same buffer
- *   object, so callers can skip uploading it).
- * - A prefix cache keeps the accumulator *before* the step that changed last time (and, when the
- *   caller names it, before the active layer). Dragging a slider on layer k, or a stroke on layer
- *   k, recomposites from step k upwards only; `dirty` rectangles limit that to where it changed.
- * - Spatial filters and feathered or parametric masks are computed once over the canvas and
- *   cached by the identity of their inputs.
+ * Distances: a stroke's outer edge uses the 5 × 5 chamfer below 20 px and an exact Euclidean
+ * transform from there (the chamfer's octagonal level sets facet wide strokes); inside strokes and
+ * spread / choke keep the chamfer; precise glows and chiselled bevels use the exact transform.
+ * Soft falloffs are two box blurs (a tent).
  */
 
-/** What the compositor needs from its host besides the layers. */
-interface RasterSources {
-    /** Canvas (document) size: spatial filters and mask feathering clamp at this rect. */
+interface EffectRect {
+    x: number;
+    y: number;
     width: number;
     height: number;
-    /** The pixels of a pixel layer (lets a host resolve layers whose pixels live elsewhere). */
-    surfaceOf?(layer: CompositorLayer): PixelSurface;
-    /** Changes whenever one of the host's callbacks would return something new for the same layers. */
-    version?: number | string;
-}
-/** The fields the engine reads; editor layer types are wider. */
-interface CompositorLayer extends RasterNode {
-    visible: boolean;
-    opacity: number;
-    blend: string;
-    clipped?: boolean;
-    mask?: RasterMask;
-    /** Pixel layers. */
-    surface?: PixelSurface;
-    offset?: {
-        x: number;
-        y: number;
-    };
-    fillOpacity?: number;
-    /** Groups. */
-    children?: readonly CompositorLayer[];
-}
-/** A pixel layer's filters as the engine runs them. */
-interface PixelFilterSpec {
-    /** Identifies the settings (part of the cache key). */
-    key: string;
-    /** Needs neighbouring pixels: runs once over the canvas instead of per tile. */
-    spatial: boolean;
-    /** Filters RGBA `data` (`width × height`) in place. */
-    apply(data: Uint8ClampedArray, width: number, height: number): void;
-}
-/** How an editor's own layer kinds composite. Every hook is optional. */
-interface CompositorProfile<L extends CompositorLayer, S extends RasterSources> {
-    /** Layers that change what is below them; adjacent ones run as one step. */
-    isFilterLayer?(layer: L): boolean;
-    /** Applies a run of visible filter layers to `acc` (RGBA over `r`); `coverage` holds masked ones by id. */
-    applyFilterRun?(layers: L[], acc: Uint8ClampedArray, r: RasterRect, coverage: Map<string, Float32Array> | undefined, sources: S): void;
-    /** RGBA of a content layer that is neither a pixel layer nor a group, over `r`, or `null`. */
-    contentTile?(layer: L, r: RasterRect, sources: S): Uint8ClampedArray | null;
-    /** The blend mode a content layer draws with (default `layer.blend`). */
-    contentBlend?(layer: L): BlendMode;
-    /** Properties of a layer beyond the generic ones that change its pixels (part of its signature). */
-    layerKey?(layer: L): unknown;
-    /** Active filters of a pixel layer, or `null`. */
-    pixelFilters?(layer: L): PixelFilterSpec | null;
-    /** Canvas coverage (0..1, `width × height`) of a parametric mask source, or `null` to reveal all. */
-    maskSourcePlane?(source: unknown, width: number, height: number, sources: S): Float32Array | null;
-}
-interface CompositorOptions {
-    /** Upper bound for cached tile buffers (default 256 MiB). */
-    maxCacheBytes?: number;
-}
-interface CompositeCallOptions {
-    /**
-     * The layer about to be edited (the active layer): every tile composited in this call keeps a
-     * checkpoint below its step, so strokes and slider drags on it start there.
-     */
-    checkpointLayerId?: string | null;
-    /**
-     * Where the layers changed since the previous call, when the caller knows (a stroke's dabs).
-     * Changed tiles are then recomposited only inside these rectangles. Changes outside them would
-     * be missed, so pass nothing when unsure.
-     */
-    dirty?: RasterRect[];
 }
+/** Outside stroke width from which the outer edge uses the exact Euclidean transform. */
+declare const STROKE_CHAMFER_MAX = 20;
+/** A contour as a 0..1 LUT (corner points split the spline), or `null` for linear. */
+declare function contourLut(c: EffectContour | undefined): Float32Array | null;
+/** Where a bevel paints: inside the shape, outside it, or both (emboss styles). */
+type BevelPaint = 'inner' | 'outer' | 'both';
+interface EffectContext {
+    light: GlobalLight;
+    /** A pattern tile by id, or `null` when missing (pattern effects then paint nothing). */
+    pattern(id: string): PatternTile | null;
+}
+/** Effect maps of one layer over its region: see {@link buildEffectMaps}. */
+interface EffectMaps {
+    /** The region the maps cover (document space). */
+    rect: EffectRect;
+    /** The enabled effects, Scale Effects applied, in list order. */
+    items: LayerEffect[];
+    /** Pixel bounds of the shape (alpha above half a step), or `null` when the shape is empty. */
+    bounds: EffectRect | null;
+    shape: Float32Array;
+    /** Per item: the maps it paints through. */
+    per: Float32Array[][];
+    bevelPaint: (BevelPaint | null)[];
+    din: Float32Array | null;
+    dout: Float32Array | null;
+    doutExact: Float32Array | null;
+    /** Frames of gradient strokes by item index. */
+    frames: Map<number, EffectRect>;
+    /** Approximate size in bytes (cache budgeting). */
+    bytes: number;
+}
+/** The enabled effects of `effects` with Scale Effects applied (empty when the master switch is off). */
+declare function activeEffectItems(effects: LayerEffects | undefined | null): LayerEffect[];
 /**
- * Blends straight-alpha `src` over `dst` (both RGBA) in place with `mode`, scaling the source
- * alpha by `alpha` and, per pixel, by `coverage`. Same maths as `blendPixel`.
+ * Whether every map pixel of `items` depends only on the shape within the effects' margin, so a
+ * tile is unchanged while the layer is unchanged within its margin. Not local: anything laid out
+ * over the layer's bounds (aligned gradient overlays, gradient strokes, linked patterns) and noise
+ * (it speckles any coverage above zero, which picks up the blur's float noise from far away).
  */
-declare function blendTile(dst: Uint8ClampedArray, src: ArrayLike<number>, mode: BlendMode, alpha: number, coverage: ArrayLike<number> | null): void;
-/** Statistics of the last `composite` call (for benchmarks and tests). */
-interface CompositeStats {
-    tiles: number;
-    /** Tiles returned straight from the cache. */
-    cached: number;
-    /** Steps actually run, summed over tiles. */
-    stepsRun: number;
-}
-declare class RasterCompositor<L extends CompositorLayer = CompositorLayer, S extends RasterSources = RasterSources> {
-    private readonly profile;
-    private readonly tiles;
-    private readonly maxCacheBytes;
-    private cacheBytes;
-    private stamp;
-    private sources;
-    private sourcesVersion;
-    private filteredCache;
-    private planeCache;
-    private planeIds;
-    private nextPlaneId;
-    private contentCache;
-    private readonly stepsCache;
-    private readonly propsKeyCache;
-    lastStats: CompositeStats;
-    private hint;
-    constructor(profile?: CompositorProfile<L, S>, options?: CompositorOptions);
-    /** Drops every cached tile and plane. */
-    clear(): void;
-    private setSources;
-    /** The composite of `layers` over `rect` as `rect.width × rect.height` RGBA (straight alpha). */
-    composite(layers: readonly L[], rect: RasterRect, sources: S, options?: CompositeCallOptions): Uint8ClampedArray;
-    /**
-     * Composites every tile intersecting `rect` and calls `onTile` with each tile's RGBA buffer
-     * (TILE × TILE). A tile whose inputs did not change since the last call returns the same buffer
-     * object; never mutate it.
-     */
-    compositeTiles(layers: readonly L[], rect: RasterRect, sources: S, onTile: (tx: number, ty: number, data: Uint8ClampedArray, changed: boolean) => void, options?: CompositeCallOptions): void;
-    /** The composite of one tile (cached; do not mutate the result). */
-    tile(layers: readonly L[], tx: number, ty: number, sources: S): Uint8ClampedArray;
-    /**
-     * A layer's effective mask coverage (0..1, after density, feather or parametric evaluation)
-     * over `r` in document space, or `null` when it reveals all of `r`.
-     */
-    maskCoverage(layer: L, r: RasterRect, sources: S): Float32Array | null;
-    private isFilter;
-    /**
-     * Groups a layer list into compositing steps: clipped layers join the nearest unclipped
-     * content or group layer below; consecutive unclipped filter layers form one run.
-     */
-    private buildSteps;
-    /** The index of the top-level step that holds layer `id` (searching groups and clipped layers), or -1. */
-    private stepIndexOf;
-    /** Properties of a layer that change pixels, minus its surfaces (memoised per object). */
-    private propsKey;
-    private compositeTile;
-    private entryBytes;
-    private evict;
-    private stepSig;
-    private layerSig;
-    private groupSig;
-    private contentSig;
-    private maskRefs;
-    /**
-     * A pixel layer's pixels after spatial filters: the surface and the offset to apply. Layers
-     * with a spatial filter are filtered once over the canvas (in document space, offset 0).
-     */
-    private layerPixels;
-    /** RGBA of a content layer over `r` (document space, inside one tile), or `null` when it has nothing there. */
-    private contentTile;
-    private planeKey;
-    /** Canvas-sized coverage of a feathered or parametric mask (cached). */
-    private planeFor;
-    private maskTile;
-    /** Runs one step onto `acc`; returns whether `acc` is still empty. */
-    private runStep;
-    private runSteps;
-    private contentBlend;
-    private blendOnto;
-    private applyClipped;
-    private applyFilterRun;
-}
-/** Tiles that differ between two surfaces (by tile identity), as tile keys. */
-declare function changedTiles(a: TiledSurface, b: TiledSurface): TileKey[];
-
-/** Above this σ a Gaussian is approximated by three box passes (cost independent of σ). */
-declare const DIRECT_GAUSSIAN_MAX_SIGMA = 8;
-/** How a blur treats pixels beyond the image: `zero`, or `clamp` (replicate the border). */
-type BlurEdge = 'zero' | 'clamp';
-type Edge = BlurEdge;
+declare function effectsAreLocal(items: readonly LayerEffect[]): boolean;
 /**
- * Separable Gaussian blur of a single-channel float image. `edge` `zero` treats pixels beyond
- * the image as 0 (selection feather), `clamp` replicates the border (mask refinement). σ up to
- * {@link DIRECT_GAUSSIAN_MAX_SIGMA} is convolved directly; wider blurs use three box passes, so
- * the cost per pixel never grows with σ.
+ * Builds every map `items` paints through from the layer's alpha `shape` (0..1) over `rect`.
+ * `rect` should cover the layer's shape plus the effects' margin.
  */
-declare function gaussianBlur(src: ArrayLike<number>, w: number, h: number, sigma: number, edge?: Edge): Float32Array;
-
-/**
- * Dependency-free, synchronous PNG encode / decode for layer pixels and masks, plus base64 and
- * data-URL helpers. Canvas `toDataURL` is lossy for partly transparent pixels (it goes through
- * premultiplied alpha), so layer assets use this codec and round-trip exactly.
- *
- * Encodes 8-bit greyscale (masks) or RGBA (layers). Decodes non-interlaced 1/2/4/8/16-bit
- * greyscale, RGB, palette, grey + alpha and RGBA, always to 8-bit RGBA or grey.
- */
-interface DecodedPng {
-    width: number;
-    height: number;
-    /** 4 for RGBA output, 1 for greyscale without alpha when `keepGray` was asked for. */
-    channels: 1 | 4;
-    data: Uint8ClampedArray;
-}
-/** PNG bytes for `width × height` pixels of 1 (grey) or 4 (RGBA) bytes each. */
-declare function encodePng(width: number, height: number, data: ArrayLike<number>, channels?: 1 | 4): Uint8Array;
-declare function isPng(bytes: Uint8Array): boolean;
-/**
- * Decodes a PNG. Output is RGBA (4 channels) unless `keepGray` is set and the image is
- * greyscale without alpha, in which case it is one byte per pixel.
- */
-declare function decodePng(bytes: Uint8Array, options?: {
-    keepGray?: boolean;
-    maxPixels?: number;
-}): DecodedPng;
-declare function bytesToBase64(bytes: Uint8Array): string;
-declare function base64ToBytes(text: string): Uint8Array;
-/** The bytes and MIME type of a `data:` URL (base64 or percent-encoded). */
-declare function parseDataUrl(url: string): {
-    mime: string;
-    bytes: Uint8Array;
-} | null;
-declare function pngDataUrl(width: number, height: number, data: ArrayLike<number>, channels?: 1 | 4): string;
-
+declare function buildEffectMaps(items: LayerEffect[], shape: Float32Array, rect: EffectRect, ctx: EffectContext): EffectMaps;
+/** Gradient parameter `t` (0..1) at pixel centre `(x, y)` of a gradient laid out in `frame`. */
+declare function gradientT(style: GradientStyle, angle: number, scale: number, reverse: boolean, offset: {
+    x: number;
+    y: number;
+}, frame: EffectRect, x: number, y: number): number;
+interface EffectCompositeInput {
+    /** The accumulator (straight RGBA over `rect`); receives the layer and its effects. */
+    backdrop: Uint8ClampedArray;
+    /** The layer's pixels over `rect` (straight RGBA, mask applied to alpha, clipped layers applied). */
+    content: Uint8ClampedArray;
+    rect: EffectRect;
+    maps: EffectMaps;
+    blend: BlendMode;
+    /** Layer opacity: the whole stack. */
+    opacity: number;
+    /** Fill opacity: the layer's own pixels only. */
+    fillOpacity: number;
+    /** The canvas (unaligned gradients span it). */
+    canvas: EffectRect;
+    ctx: EffectContext;
+}
+/** Composites a layer's content and its effects onto `backdrop` in place (see the module comment for the order). */
+declare function compositeLayerEffects(input: EffectCompositeInput): void;
 /**
- * Synchronous zlib (RFC 1950) and raw deflate (RFC 1951), dependency-free, for the image editor's
- * layer PNGs and PSD ZIP channels. `CompressionStream` is asynchronous and not everywhere, and
- * layer pixels must serialize inside the synchronous `toJSON()`.
- *
- * - `inflate` handles stored, fixed and dynamic blocks and refuses to produce more than
- *   `maxOutput` bytes (a decompression bomb guard).
- * - `deflate` is a greedy LZ77 (hash chains, 32 KiB window) with one dynamic Huffman block per
- *   64 Ki symbols. It favours simplicity over the last few percent of ratio.
+ * Renders one layer with its effects over a whole region in one pass (no tiles): the reference
+ * the per-tile compositor is checked against, and a convenience for one-off renders.
  */
-declare class ZlibError extends Error {
-    constructor(message: string);
-}
-/** Inflates raw deflate data (no zlib header). */
-declare function inflateRaw(data: Uint8Array, options?: {
-    maxOutput?: number;
-    sizeHint?: number;
-}): Uint8Array;
-/** Adler-32 checksum (zlib trailer). */
-declare function adler32(data: Uint8Array): number;
-/** Inflates zlib data (header, deflate stream, Adler-32 trailer). */
-declare function inflate(data: Uint8Array, options?: {
-    maxOutput?: number;
-    sizeHint?: number;
-    verify?: boolean;
-}): Uint8Array;
-/** Raw deflate (no zlib header). `level` 0 stores the data uncompressed. */
-declare function deflateRaw(data: Uint8Array, level?: 0 | 1): Uint8Array;
-/** zlib stream: header, raw deflate, Adler-32. */
-declare function deflate(data: Uint8Array, level?: 0 | 1): Uint8Array;
+declare function renderLayerEffects(effects: LayerEffects, layer: {
+    content: Uint8ClampedArray;
+    rect: EffectRect;
+    blend: BlendMode;
+    opacity: number;
+    fillOpacity?: number;
+}, backdrop: Uint8ClampedArray, canvas: EffectRect, ctx: EffectContext): void;
 
-export { BlendMode, type BlurEdge, type CompositeCallOptions, type CompositeStats, type CompositorLayer, type CompositorOptions, type CompositorProfile, DIRECT_GAUSSIAN_MAX_SIGMA, type DecodedPng, type GroupBlendMode, type GroupIn, type LayerLocation, type LayerLocks, MaskSurface, type PixelFilterSpec, PixelSurface, RasterCompositor, type RasterGroupLayer, type RasterLayer, type RasterLayerBase, type RasterMask, type RasterNode, type RasterPixelLayer, RasterRect, type RasterSources, TileKey, TiledSurface, ZlibError, adler32, base64ToBytes, blendTile, bytesToBase64, changedTiles, decodePng, deflate, deflateRaw, encodePng, findLayer, flattenLayers, gaussianBlur, inflate, inflateRaw, insertLayer, isLayerLocked, isPng, mapLayer, parseDataUrl, pngDataUrl };
+export { BlendMode, type EffectCompositeInput, type EffectContext, EffectContour, type EffectMaps, type EffectRect, GlobalLight, GradientStyle, LayerEffect, LayerEffects, PatternTile, STROKE_CHAMFER_MAX, activeEffectItems, buildEffectMaps, compositeLayerEffects, contourLut, effectsAreLocal, gradientT, renderLayerEffects };

package/dist/raster/index.js

@@ -1,28 +1,66 @@
 import {
+  CURVE_LUT_SIZE,
+  DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
+  LAYER_EFFECT_KINDS,
+  LayerEffectError,
+  MAX_EFFECT_REACH,
+  PatternPlacement,
+  PatternTile,
   RasterCompositor,
+  STROKE_CHAMFER_MAX,
   ZlibError,
+  activeEffectItems,
   adler32,
   base64ToBytes,
   blendTile,
+  buildEffectMaps,
+  builtinPattern,
+  builtinPatternIds,
   bytesToBase64,
   changedTiles,
+  compositeLayerEffects,
+  contourLut,
+  curveLut,
   decodePng,
+  defaultEffectGradient,
+  defaultLayerEffect,
   deflate,
   deflateRaw,
+  effectColorHex,
+  effectReach,
+  effectsAreLocal,
+  effectsFingerprint,
+  effectsMargin,
+  effectsScale,
   encodePng,
   findLayer,
   flattenLayers,
   gaussianBlur,
+  gradientT,
+  hasActiveEffects,
+  hashNoise,
   inflate,
   inflateRaw,
   insertLayer,
+  isLayerEffectKind,
   isLayerLocked,
   isPng,
+  layerEffectFields,
+  layerEffectLabel,
   mapLayer,
+  mergeLayerEffect,
+  newEffectId,
+  normalizeLayerEffects,
   parseDataUrl,
-  pngDataUrl
-} from "../chunk-P5TPUNBZ.js";
+  parseEffectColor,
+  pngDataUrl,
+  renderLayerEffects,
+  scaleLayerEffect,
+  validateEffectGradient,
+  validateLayerEffect,
+  validateLayerEffects
+} from "../chunk-747CGOT2.js";
 import {
   BLEND_MODES,
   SurfaceDraft,
@@ -61,13 +99,22 @@ import {
 } from "../chunk-D4ZCU72J.js";
 export {
   BLEND_MODES,
+  CURVE_LUT_SIZE,
+  DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
+  LAYER_EFFECT_KINDS,
+  LayerEffectError,
+  MAX_EFFECT_REACH,
+  PatternPlacement,
+  PatternTile,
   RasterCompositor,
+  STROKE_CHAMFER_MAX,
   SurfaceDraft,
   TILE,
   TILE_SHIFT,
   TiledSurface,
   ZlibError,
+  activeEffectItems,
   adler32,
   base64ToBytes,
   blendChannel,
@@ -76,14 +123,28 @@ export {
   blendPixel,
   blendRgb,
   blendTile,
+  buildEffectMaps,
+  builtinPattern,
+  builtinPatternIds,
   bytesToBase64,
   canvasCompositeOperation,
   changedTiles,
   collectTiles,
+  compositeLayerEffects,
   contentBounds,
+  contourLut,
+  curveLut,
   decodePng,
+  defaultEffectGradient,
+  defaultLayerEffect,
   deflate,
   deflateRaw,
+  effectColorHex,
+  effectReach,
+  effectsAreLocal,
+  effectsFingerprint,
+  effectsMargin,
+  effectsScale,
   emptySurface,
   encodePng,
   fillRect,
@@ -91,20 +152,32 @@ export {
   finishTile,
   flattenLayers,
   gaussianBlur,
+  gradientT,
+  hasActiveEffects,
+  hashNoise,
   inflate,
   inflateRaw,
   insertLayer,
   isBlendMode,
+  isLayerEffectKind,
   isLayerLocked,
   isPng,
   isSeparableBlendMode,
+  layerEffectFields,
+  layerEffectLabel,
   mapLayer,
+  mergeLayerEffect,
+  newEffectId,
   normalizeBlendMode,
+  normalizeLayerEffects,
   packRgba,
   parseDataUrl,
+  parseEffectColor,
   pngDataUrl,
   readPixel,
   readRegion,
+  renderLayerEffects,
+  scaleLayerEffect,
   setLum,
   solidSurface,
   surfaceBytes,
@@ -116,6 +189,9 @@ export {
   tilesInRect,
   translateSurface,
   uniformTile,
+  validateEffectGradient,
+  validateLayerEffect,
+  validateLayerEffects,
   writeRegion
 };
 //# sourceMappingURL=index.js.map

package/dist/{surface-fJhkmNQn.d.cts → surface-CuBg2c6k.d.cts}

@@ -178,4 +178,4 @@ declare function collectTiles(surface: TiledSurface, into: Set<Tile>): void;
 /** True when two surfaces hold the same pixels (cheap when they share tiles). */
 declare function surfacesEqual(a: TiledSurface, b: TiledSurface): boolean;
 
-export { solidSurface as A, type BlendMode as B, surfaceBytes as C, surfaceFromPixels as D, surfacesEqual as E, tileCoord as F, tileKey as G, tileRect as H, tilesInRect as I, translateSurface as J, uniformTile as K, writeRegion as L, type MaskSurface as M, type PixelSurface as P, type RasterRect as R, SurfaceDraft as S, TiledSurface as T, BLEND_MODES as a, type BlendModeInfo as b, type Rgb as c, type Rgba as d, TILE as e, TILE_SHIFT as f, type Tile as g, type TileKey as h, blendChannel as i, blendImageData as j, blendLum as k, blendPixel as l, blendRgb as m, canvasCompositeOperation as n, collectTiles as o, contentBounds as p, emptySurface as q, fillRect as r, finishTile as s, isBlendMode as t, isSeparableBlendMode as u, normalizeBlendMode as v, packRgba as w, readPixel as x, readRegion as y, setLum as z };
+export { solidSurface as A, type BlendMode as B, surfaceBytes as C, surfaceFromPixels as D, surfacesEqual as E, tileCoord as F, tileKey as G, tileRect as H, tilesInRect as I, translateSurface as J, uniformTile as K, writeRegion as L, type MaskSurface as M, type PixelSurface as P, type RasterRect as R, SurfaceDraft as S, TILE as T, BLEND_MODES as a, type BlendModeInfo as b, type Rgb as c, type Rgba as d, TILE_SHIFT as e, type Tile as f, type TileKey as g, TiledSurface as h, blendChannel as i, blendImageData as j, blendLum as k, blendPixel as l, blendRgb as m, canvasCompositeOperation as n, collectTiles as o, contentBounds as p, emptySurface as q, fillRect as r, finishTile as s, isBlendMode as t, isSeparableBlendMode as u, normalizeBlendMode as v, packRgba as w, readPixel as x, readRegion as y, setLum as z };

package/dist/{surface-fJhkmNQn.d.ts → surface-CuBg2c6k.d.ts}

@@ -178,4 +178,4 @@ declare function collectTiles(surface: TiledSurface, into: Set<Tile>): void;
 /** True when two surfaces hold the same pixels (cheap when they share tiles). */
 declare function surfacesEqual(a: TiledSurface, b: TiledSurface): boolean;
 
-export { solidSurface as A, type BlendMode as B, surfaceBytes as C, surfaceFromPixels as D, surfacesEqual as E, tileCoord as F, tileKey as G, tileRect as H, tilesInRect as I, translateSurface as J, uniformTile as K, writeRegion as L, type MaskSurface as M, type PixelSurface as P, type RasterRect as R, SurfaceDraft as S, TiledSurface as T, BLEND_MODES as a, type BlendModeInfo as b, type Rgb as c, type Rgba as d, TILE as e, TILE_SHIFT as f, type Tile as g, type TileKey as h, blendChannel as i, blendImageData as j, blendLum as k, blendPixel as l, blendRgb as m, canvasCompositeOperation as n, collectTiles as o, contentBounds as p, emptySurface as q, fillRect as r, finishTile as s, isBlendMode as t, isSeparableBlendMode as u, normalizeBlendMode as v, packRgba as w, readPixel as x, readRegion as y, setLum as z };
+export { solidSurface as A, type BlendMode as B, surfaceBytes as C, surfaceFromPixels as D, surfacesEqual as E, tileCoord as F, tileKey as G, tileRect as H, tilesInRect as I, translateSurface as J, uniformTile as K, writeRegion as L, type MaskSurface as M, type PixelSurface as P, type RasterRect as R, SurfaceDraft as S, TILE as T, BLEND_MODES as a, type BlendModeInfo as b, type Rgb as c, type Rgba as d, TILE_SHIFT as e, type Tile as f, type TileKey as g, TiledSurface as h, blendChannel as i, blendImageData as j, blendLum as k, blendPixel as l, blendRgb as m, canvasCompositeOperation as n, collectTiles as o, contentBounds as p, emptySurface as q, fillRect as r, finishTile as s, isBlendMode as t, isSeparableBlendMode as u, normalizeBlendMode as v, packRgba as w, readPixel as x, readRegion as y, setLum as z };