@pixerate/editor 0.121.0 → 0.122.0

package/dist/{render-B05K68_h.d.ts → deep-DLwKZDFr.d.ts}

@@ -558,6 +558,143 @@ declare function isLayerLocked(layer: {
     locks?: LayerLocks;
 }, what: keyof LayerLocks): boolean;
 
+/**
+ * CPU renderer for layer effects.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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).
+ */
+
+interface EffectRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** 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[];
+/**
+ * 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 effectsAreLocal(items: readonly LayerEffect[]): boolean;
+/**
+ * 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 buildEffectMaps(items: LayerEffect[], shape: Float32Array, rect: EffectRect, ctx: EffectContext): EffectMaps;
+/**
+ * `prev` brought up to date for a shape over `rect` that differs from the one it was built from only
+ * inside `changed` (document rects), or `null` when a full {@link buildEffectMaps} is the better
+ * deal (the change covers much of the region) or the effects are not local
+ * ({@link effectsAreLocal}). `items` must be the ones `prev` was built with, reaching at most
+ * `margin` px, and `shapeOver(r)` returns the new shape over `r`.
+ *
+ * Every map pixel within `margin` of a change, or outside `prev.rect`, is rebuilt from the shape
+ * within `margin` of it (a window of the change grown by twice the margin) and pasted in; the rest
+ * is kept. A local map pixel depends only on the shape within the margin and the blur sums exactly,
+ * so the result paints exactly what a full build over `rect` would. `prev`'s buffers are reused
+ * when `rect` is unchanged.
+ */
+declare function patchEffectMaps(prev: EffectMaps, items: LayerEffect[], rect: EffectRect, changed: readonly EffectRect[], margin: number, shapeOver: (r: EffectRect) => Float32Array, ctx: EffectContext): EffectMaps | null;
+/** 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;
+/**
+ * The colours an effect fill paints over `rect`, as straight float RGBA (0..1, `width × height`
+ * pixels, row by row): a solid colour, a gradient laid out in `frame` (when aligned with the layer)
+ * or `canvas`, or a pattern tiled from `anchor` (when linked). Shape layers paint with it, so their
+ * fills and strokes match the overlays of layer effects.
+ */
+declare function effectFillColors(fill: EffectFill, rect: EffectRect, frame: EffectRect, canvas: EffectRect, anchor: {
+    x: number;
+    y: number;
+}, ctx: EffectContext): Float32Array;
+interface EffectCompositeInput {
+    /**
+     * The accumulator (straight RGBA over `rect`); receives the layer and its effects. Bytes, or
+     * (high bit depth) floats 0..1 sRGB-encoded, written back unrounded.
+     */
+    backdrop: Uint8ClampedArray | Float32Array;
+    /** The layer's pixels over `rect` (straight RGBA, mask applied to alpha, clipped layers applied); bytes or floats 0..1 as `backdrop`. */
+    content: Uint8ClampedArray | Float32Array;
+    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;
+/**
+ * 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 function renderLayerEffects(effects: LayerEffects, layer: {
+    content: Uint8ClampedArray;
+    rect: EffectRect;
+    blend: BlendMode;
+    opacity: number;
+    fillOpacity?: number;
+}, backdrop: Uint8ClampedArray, canvas: EffectRect, ctx: EffectContext): void;
+
 /**
  * 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,
@@ -733,6 +870,12 @@ declare class RasterCompositor<L extends CompositorLayer = CompositorLayer, S ex
      * over `r` in document space, or `null` when it reveals all of `r`.
      */
     maskCoverage(layer: L, r: RasterRect, sources: S): Float32Array | null;
+    /**
+     * For the float compositor: everything `compositeLayerEffects` needs for `layer` over `r` but
+     * the pixels (the area its effects reach inside `r`, the effect maps built from its 8-bit
+     * shape, blend, opacities, canvas and context), or `null` when nothing reaches `r`.
+     */
+    effectsInput(layer: L, r: RasterRect, sources: S): Omit<EffectCompositeInput, 'backdrop' | 'content'> | null;
     /** Pixel layers, and the layer kinds the profile composites like them. */
     private isPixel;
     private isFilter;
@@ -925,138 +1068,4 @@ declare function deepBytes(surface: TiledSurface): number;
  */
 declare function keepDeepSamples(before: TiledSurface, after: TiledSurface): TiledSurface;
 
-/**
- * CPU renderer for layer effects.
- *
- * 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.
- *
- * 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.
- *
- * 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).
- */
-
-interface EffectRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/** 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[];
-/**
- * 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 effectsAreLocal(items: readonly LayerEffect[]): boolean;
-/**
- * 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 buildEffectMaps(items: LayerEffect[], shape: Float32Array, rect: EffectRect, ctx: EffectContext): EffectMaps;
-/**
- * `prev` brought up to date for a shape over `rect` that differs from the one it was built from only
- * inside `changed` (document rects), or `null` when a full {@link buildEffectMaps} is the better
- * deal (the change covers much of the region) or the effects are not local
- * ({@link effectsAreLocal}). `items` must be the ones `prev` was built with, reaching at most
- * `margin` px, and `shapeOver(r)` returns the new shape over `r`.
- *
- * Every map pixel within `margin` of a change, or outside `prev.rect`, is rebuilt from the shape
- * within `margin` of it (a window of the change grown by twice the margin) and pasted in; the rest
- * is kept. A local map pixel depends only on the shape within the margin and the blur sums exactly,
- * so the result paints exactly what a full build over `rect` would. `prev`'s buffers are reused
- * when `rect` is unchanged.
- */
-declare function patchEffectMaps(prev: EffectMaps, items: LayerEffect[], rect: EffectRect, changed: readonly EffectRect[], margin: number, shapeOver: (r: EffectRect) => Float32Array, ctx: EffectContext): EffectMaps | null;
-/** 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;
-/**
- * The colours an effect fill paints over `rect`, as straight float RGBA (0..1, `width × height`
- * pixels, row by row): a solid colour, a gradient laid out in `frame` (when aligned with the layer)
- * or `canvas`, or a pattern tiled from `anchor` (when linked). Shape layers paint with it, so their
- * fills and strokes match the overlays of layer effects.
- */
-declare function effectFillColors(fill: EffectFill, rect: EffectRect, frame: EffectRect, canvas: EffectRect, anchor: {
-    x: number;
-    y: number;
-}, ctx: EffectContext): Float32Array;
-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;
-/**
- * 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 function renderLayerEffects(effects: LayerEffects, layer: {
-    content: Uint8ClampedArray;
-    rect: EffectRect;
-    blend: BlendMode;
-    opacity: number;
-    fillOpacity?: number;
-}, backdrop: Uint8ClampedArray, canvas: EffectRect, ctx: EffectContext): void;
-
 export { type PixelFilterSpec as $, type GradientOverlayEffect as A, BIT_DEPTHS as B, type CompositorLayer as C, DEFAULT_GLOBAL_LIGHT as D, type EffectCompositeInput as E, type GradientStyle as F, type GlobalLight as G, type GroupBlendMode as H, type GroupIn as I, INTERPOLATIONS as J, type InnerGlowEffect as K, type InnerShadowEffect as L, type Interpolation as M, LAYER_EFFECT_KINDS as N, type LayerEffect as O, LayerEffectError as P, type LayerEffectKind as Q, type RasterSources as R, type LayerEffects as S, type LayerLocation as T, type LayerLocks as U, MAX_EFFECT_REACH as V, MAX_TRANSFORM_PIXELS as W, type OuterGlowEffect as X, type PatternOverlayEffect as Y, PatternPlacement as Z, PatternTile as _, RasterCompositor as a, tileSamples as a$, type RasterGroupLayer as a0, type RasterLayer as a1, type RasterLayerBase as a2, type RasterMask as a3, type RasterNode as a4, type RasterPixelLayer as a5, type ResampleOptions as a6, STROKE_CHAMFER_MAX as a7, type SatinEffect as a8, type StrokeEffect as a9, gradientT as aA, hasActiveEffects as aB, hashNoise as aC, insertLayer as aD, isBitDepth as aE, isInterpolation as aF, isLayerEffectKind as aG, isLayerLocked as aH, keepDeepSamples as aI, keysWeight as aJ, layerEffectFields as aK, layerEffectLabel as aL, mapLayer as aM, mergeLayerEffect as aN, newEffectId as aO, normalizeLayerEffects as aP, parseEffectColor as aQ, patchEffectMaps as aR, proxyOf as aS, readDeepRegion as aT, reduceSurface as aU, renderLayerEffects as aV, scaleLayerEffect as aW, srgbDecode as aX, srgbEncode as aY, surfaceDepth as aZ, surfaceFromDeepPixels as a_, type StrokePosition as aa, TransformTooLargeError as ab, activeEffectItems as ac, blendTile as ad, buildEffectMaps as ae, builtinPattern as af, builtinPatternIds as ag, changedTiles as ah, compositeLayerEffects as ai, compositeSurfaceOver as aj, contourLut as ak, convertSurfaceDepth as al, deepBytes as am, deepTile as an, defaultEffectGradient as ao, defaultLayerEffect as ap, depthOf as aq, effectColorHex as ar, effectFillColors as as, effectReach as at, effectsAreLocal as au, effectsFingerprint as av, effectsMargin as aw, effectsScale as ax, findLayer as ay, flattenLayers as az, type CompositorProfile as b, tileSamples16 as b0, tileSamples32 as b1, to16From32 as b2, to16From8 as b3, to32From16 as b4, to32From8 as b5, to8From16 as b6, to8From32 as b7, transformSurface as b8, transformedBounds as b9, validateEffectGradient as ba, validateLayerEffect as bb, validateLayerEffects as bc, warpSurface as bd, writeDeepRegion as be, type BevelContour as c, type BevelEmbossEffect as d, type BevelStyle as e, type BevelTechnique as f, type BevelTexture as g, type BitDepth as h, type ColorOverlayEffect as i, type CompositeCallOptions as j, type CompositeStats as k, type CompositorOptions as l, type ContourPoint as m, type DeepSamples as n, type DropShadowEffect as o, type EffectContext as p, type EffectContour as q, type EffectFill as r, type EffectGradient as s, type EffectMaps as t, type EffectPattern as u, type EffectPatternRef as v, type EffectRect as w, type GlowTechnique as x, type GradientColorStop as y, type GradientOpacityStop as z };

package/dist/{render-DnAbIKcs.d.cts → deep-QS3ppbMX.d.cts}

@@ -558,6 +558,143 @@ declare function isLayerLocked(layer: {
     locks?: LayerLocks;
 }, what: keyof LayerLocks): boolean;
 
+/**
+ * CPU renderer for layer effects.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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).
+ */
+
+interface EffectRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** 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[];
+/**
+ * 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 effectsAreLocal(items: readonly LayerEffect[]): boolean;
+/**
+ * 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 buildEffectMaps(items: LayerEffect[], shape: Float32Array, rect: EffectRect, ctx: EffectContext): EffectMaps;
+/**
+ * `prev` brought up to date for a shape over `rect` that differs from the one it was built from only
+ * inside `changed` (document rects), or `null` when a full {@link buildEffectMaps} is the better
+ * deal (the change covers much of the region) or the effects are not local
+ * ({@link effectsAreLocal}). `items` must be the ones `prev` was built with, reaching at most
+ * `margin` px, and `shapeOver(r)` returns the new shape over `r`.
+ *
+ * Every map pixel within `margin` of a change, or outside `prev.rect`, is rebuilt from the shape
+ * within `margin` of it (a window of the change grown by twice the margin) and pasted in; the rest
+ * is kept. A local map pixel depends only on the shape within the margin and the blur sums exactly,
+ * so the result paints exactly what a full build over `rect` would. `prev`'s buffers are reused
+ * when `rect` is unchanged.
+ */
+declare function patchEffectMaps(prev: EffectMaps, items: LayerEffect[], rect: EffectRect, changed: readonly EffectRect[], margin: number, shapeOver: (r: EffectRect) => Float32Array, ctx: EffectContext): EffectMaps | null;
+/** 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;
+/**
+ * The colours an effect fill paints over `rect`, as straight float RGBA (0..1, `width × height`
+ * pixels, row by row): a solid colour, a gradient laid out in `frame` (when aligned with the layer)
+ * or `canvas`, or a pattern tiled from `anchor` (when linked). Shape layers paint with it, so their
+ * fills and strokes match the overlays of layer effects.
+ */
+declare function effectFillColors(fill: EffectFill, rect: EffectRect, frame: EffectRect, canvas: EffectRect, anchor: {
+    x: number;
+    y: number;
+}, ctx: EffectContext): Float32Array;
+interface EffectCompositeInput {
+    /**
+     * The accumulator (straight RGBA over `rect`); receives the layer and its effects. Bytes, or
+     * (high bit depth) floats 0..1 sRGB-encoded, written back unrounded.
+     */
+    backdrop: Uint8ClampedArray | Float32Array;
+    /** The layer's pixels over `rect` (straight RGBA, mask applied to alpha, clipped layers applied); bytes or floats 0..1 as `backdrop`. */
+    content: Uint8ClampedArray | Float32Array;
+    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;
+/**
+ * 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 function renderLayerEffects(effects: LayerEffects, layer: {
+    content: Uint8ClampedArray;
+    rect: EffectRect;
+    blend: BlendMode;
+    opacity: number;
+    fillOpacity?: number;
+}, backdrop: Uint8ClampedArray, canvas: EffectRect, ctx: EffectContext): void;
+
 /**
  * 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,
@@ -733,6 +870,12 @@ declare class RasterCompositor<L extends CompositorLayer = CompositorLayer, S ex
      * over `r` in document space, or `null` when it reveals all of `r`.
      */
     maskCoverage(layer: L, r: RasterRect, sources: S): Float32Array | null;
+    /**
+     * For the float compositor: everything `compositeLayerEffects` needs for `layer` over `r` but
+     * the pixels (the area its effects reach inside `r`, the effect maps built from its 8-bit
+     * shape, blend, opacities, canvas and context), or `null` when nothing reaches `r`.
+     */
+    effectsInput(layer: L, r: RasterRect, sources: S): Omit<EffectCompositeInput, 'backdrop' | 'content'> | null;
     /** Pixel layers, and the layer kinds the profile composites like them. */
     private isPixel;
     private isFilter;
@@ -925,138 +1068,4 @@ declare function deepBytes(surface: TiledSurface): number;
  */
 declare function keepDeepSamples(before: TiledSurface, after: TiledSurface): TiledSurface;
 
-/**
- * CPU renderer for layer effects.
- *
- * 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.
- *
- * 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.
- *
- * 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).
- */
-
-interface EffectRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/** 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[];
-/**
- * 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 effectsAreLocal(items: readonly LayerEffect[]): boolean;
-/**
- * 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 buildEffectMaps(items: LayerEffect[], shape: Float32Array, rect: EffectRect, ctx: EffectContext): EffectMaps;
-/**
- * `prev` brought up to date for a shape over `rect` that differs from the one it was built from only
- * inside `changed` (document rects), or `null` when a full {@link buildEffectMaps} is the better
- * deal (the change covers much of the region) or the effects are not local
- * ({@link effectsAreLocal}). `items` must be the ones `prev` was built with, reaching at most
- * `margin` px, and `shapeOver(r)` returns the new shape over `r`.
- *
- * Every map pixel within `margin` of a change, or outside `prev.rect`, is rebuilt from the shape
- * within `margin` of it (a window of the change grown by twice the margin) and pasted in; the rest
- * is kept. A local map pixel depends only on the shape within the margin and the blur sums exactly,
- * so the result paints exactly what a full build over `rect` would. `prev`'s buffers are reused
- * when `rect` is unchanged.
- */
-declare function patchEffectMaps(prev: EffectMaps, items: LayerEffect[], rect: EffectRect, changed: readonly EffectRect[], margin: number, shapeOver: (r: EffectRect) => Float32Array, ctx: EffectContext): EffectMaps | null;
-/** 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;
-/**
- * The colours an effect fill paints over `rect`, as straight float RGBA (0..1, `width × height`
- * pixels, row by row): a solid colour, a gradient laid out in `frame` (when aligned with the layer)
- * or `canvas`, or a pattern tiled from `anchor` (when linked). Shape layers paint with it, so their
- * fills and strokes match the overlays of layer effects.
- */
-declare function effectFillColors(fill: EffectFill, rect: EffectRect, frame: EffectRect, canvas: EffectRect, anchor: {
-    x: number;
-    y: number;
-}, ctx: EffectContext): Float32Array;
-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;
-/**
- * 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 function renderLayerEffects(effects: LayerEffects, layer: {
-    content: Uint8ClampedArray;
-    rect: EffectRect;
-    blend: BlendMode;
-    opacity: number;
-    fillOpacity?: number;
-}, backdrop: Uint8ClampedArray, canvas: EffectRect, ctx: EffectContext): void;
-
 export { type PixelFilterSpec as $, type GradientOverlayEffect as A, BIT_DEPTHS as B, type CompositorLayer as C, DEFAULT_GLOBAL_LIGHT as D, type EffectCompositeInput as E, type GradientStyle as F, type GlobalLight as G, type GroupBlendMode as H, type GroupIn as I, INTERPOLATIONS as J, type InnerGlowEffect as K, type InnerShadowEffect as L, type Interpolation as M, LAYER_EFFECT_KINDS as N, type LayerEffect as O, LayerEffectError as P, type LayerEffectKind as Q, type RasterSources as R, type LayerEffects as S, type LayerLocation as T, type LayerLocks as U, MAX_EFFECT_REACH as V, MAX_TRANSFORM_PIXELS as W, type OuterGlowEffect as X, type PatternOverlayEffect as Y, PatternPlacement as Z, PatternTile as _, RasterCompositor as a, tileSamples as a$, type RasterGroupLayer as a0, type RasterLayer as a1, type RasterLayerBase as a2, type RasterMask as a3, type RasterNode as a4, type RasterPixelLayer as a5, type ResampleOptions as a6, STROKE_CHAMFER_MAX as a7, type SatinEffect as a8, type StrokeEffect as a9, gradientT as aA, hasActiveEffects as aB, hashNoise as aC, insertLayer as aD, isBitDepth as aE, isInterpolation as aF, isLayerEffectKind as aG, isLayerLocked as aH, keepDeepSamples as aI, keysWeight as aJ, layerEffectFields as aK, layerEffectLabel as aL, mapLayer as aM, mergeLayerEffect as aN, newEffectId as aO, normalizeLayerEffects as aP, parseEffectColor as aQ, patchEffectMaps as aR, proxyOf as aS, readDeepRegion as aT, reduceSurface as aU, renderLayerEffects as aV, scaleLayerEffect as aW, srgbDecode as aX, srgbEncode as aY, surfaceDepth as aZ, surfaceFromDeepPixels as a_, type StrokePosition as aa, TransformTooLargeError as ab, activeEffectItems as ac, blendTile as ad, buildEffectMaps as ae, builtinPattern as af, builtinPatternIds as ag, changedTiles as ah, compositeLayerEffects as ai, compositeSurfaceOver as aj, contourLut as ak, convertSurfaceDepth as al, deepBytes as am, deepTile as an, defaultEffectGradient as ao, defaultLayerEffect as ap, depthOf as aq, effectColorHex as ar, effectFillColors as as, effectReach as at, effectsAreLocal as au, effectsFingerprint as av, effectsMargin as aw, effectsScale as ax, findLayer as ay, flattenLayers as az, type CompositorProfile as b, tileSamples16 as b0, tileSamples32 as b1, to16From32 as b2, to16From8 as b3, to32From16 as b4, to32From8 as b5, to8From16 as b6, to8From32 as b7, transformSurface as b8, transformedBounds as b9, validateEffectGradient as ba, validateLayerEffect as bb, validateLayerEffects as bc, warpSurface as bd, writeDeepRegion as be, type BevelContour as c, type BevelEmbossEffect as d, type BevelStyle as e, type BevelTechnique as f, type BevelTexture as g, type BitDepth as h, type ColorOverlayEffect as i, type CompositeCallOptions as j, type CompositeStats as k, type CompositorOptions as l, type ContourPoint as m, type DeepSamples as n, type DropShadowEffect as o, type EffectContext as p, type EffectContour as q, type EffectFill as r, type EffectGradient as s, type EffectMaps as t, type EffectPattern as u, type EffectPatternRef as v, type EffectRect as w, type GlowTechnique as x, type GradientColorStop as y, type GradientOpacityStop as z };