@pixerate/editor 0.123.0 → 0.124.1

package/dist/{export-DfjzHAJI.d.ts → export-BGtXgMJ3.d.ts}

@@ -1,10 +1,11 @@
 import { a2 as RasterLayerBase, a3 as RasterMask$1, a5 as RasterPixelLayer, H as GroupBlendMode, r as EffectFill, G as GlobalLight, u as EffectPattern, M as Interpolation, T as LayerLocation$1, U as LayerLocks, O as LayerEffect, S as LayerEffects, R as RasterSources, a as RasterCompositor, l as CompositorOptions, Q as LayerEffectKind, p as EffectContext, h as BitDepth } from './deep-wwJa7aR6.js';
 import { c as PixelSurface, a as BlendMode, T as TiledSurface, R as RasterRect } from './surface-1MRncXpF.js';
 import { b as BuiltinProfileId, j as Intent, P as Profile, T as Transform, d as ColorSpace } from './builtin-CY97ppKM.js';
-import { A as AffineMatrix, Q as Quad, a as WarpMesh, V as Vec2$1, H as Homography } from './types-CwMPoRMU.js';
-import { B as BezierPath } from './bezier-DQZE5dxA.js';
-import { b as TextRun, P as ParagraphRun, T as TextShaper, c as ParagraphStyle, d as TextStyle, L as LaidFragment, W as WarpPreset, e as TextLayout } from './warp-Ca5fedzS.js';
-import { w as VectorSubpath, o as Vec2 } from './types-fuXEme9j.js';
+import { A as AffineMatrix, Q as Quad, a as WarpMesh, V as Vec2, H as Homography } from './types-CwMPoRMU.js';
+import { B as BezierPath } from './bezier-CWv6LQal.js';
+import { b as TextRun, P as ParagraphRun, T as TextShaper, c as ParagraphStyle, d as TextStyle, L as LaidFragment, W as WarpPreset, e as TextLayout } from './warp-k_PdtXOG.js';
+import { x as VectorSubpath, p as Vec2$1 } from './types-BcX7sCsn.js';
+import { d as EffectValue, v as EffectsSlot, E as EffectProvider, f as EffectPixels, e as EffectDescription } from './helpers-DX2_7L5t.js';
 import { B as BrushSettings, P as PaintSource, M as MixerSettings, a as MixerLoad, R as RetouchSettings, S as StrokeCoverage, b as MixerTarget, c as MixerStroke, d as RetouchApply, e as StrokePoint, f as RetouchPaint, C as CoverageMap, g as PaintTileTarget, h as StrokeApply } from './rand-DtazXGOB.js';
 
 /**
@@ -141,7 +142,29 @@ interface BlurFilter {
 }
 type LayerFilter = DevelopFilter | BlurFilter;
 type LayerFilterKind = LayerFilter['kind'];
+/**
+ * A provider effect (see `@pixerate/editor/effects`) an effect layer is drawn from: generator or
+ * overlay effects rendered at the document's size and depth. Kept, with the layer's last rendered
+ * pixels, when no provider is registered.
+ */
+interface ImageEffectGenerator {
+    /** The provider's effect id. */
+    effect: string;
+    /** The provider it was rendered with (its `id`). */
+    provider?: string;
+    /** The effect's name when it was applied. */
+    name?: string;
+    /** Control values (over the effect's defaults). */
+    values: Record<string, EffectValue>;
+    /** The moment of the effect drawn (ms, default 0). */
+    time?: number;
+}
 interface PixelLayer extends LayerBase, Omit<RasterPixelLayer, keyof RasterLayerBase> {
+    /**
+     * An effect layer: the pixels are rendered from a provider effect at the document's size and bit
+     * depth, and rendered again when its values change (painting on it is kept until then).
+     */
+    generator?: ImageEffectGenerator;
     /** Live filters, applied bottom (first) to top before the mask and blend. */
     filters?: LayerFilter[];
     /**
@@ -454,8 +477,25 @@ interface PsdSmartFilter {
     /** The filter's `filterFX` item descriptor (versioned descriptor bytes), as read. */
     data: Uint8Array;
 }
-/** One smart filter: a layer filter (or a kept PSD filter) with its own blending over the result below it. */
-type SmartFilter = (LayerFilter | PsdSmartFilter) & {
+/**
+ * A provider effect (see `@pixerate/editor/effects`) as a smart filter: a filter effect run on the
+ * result below it. Without a provider (or while it renders) it passes the pixels through; it keeps
+ * its effect id and values either way.
+ */
+interface EffectSmartFilter {
+    id: string;
+    kind: 'effect';
+    enabled: boolean;
+    /** The provider's effect id. */
+    effect: string;
+    provider?: string;
+    /** The effect's name when it was applied. */
+    name?: string;
+    /** Control values (over the effect's defaults). */
+    values: Record<string, EffectValue>;
+}
+/** One smart filter: a layer filter, a provider effect or a kept PSD filter, with its own blending over the result below it. */
+type SmartFilter = (LayerFilter | PsdSmartFilter | EffectSmartFilter) & {
     /** How the filter's result blends with the result below it (Photoshop's Blending Options). */
     blend: BlendMode;
     /** 0..1 */
@@ -788,6 +828,8 @@ interface SerializedPixelLayer extends SerializedLayerBase {
     filters?: LayerFilter[];
     /** `'document'`: the pixels are the document's source image (no asset is stored). */
     source?: 'document';
+    /** An effect layer's provider effect (its pixels are stored as usual). */
+    generator?: ImageEffectGenerator;
     /** 16- or 32-bit samples of the pixels (the PNG asset is their 8-bit rendering), see `raster/deep`. */
     deep?: SerializedDeepPixels;
 }
@@ -819,7 +861,7 @@ interface SerializedAnnotationLayer extends SerializedLayerBase {
     annotation: Annotation;
 }
 /** A smart filter as stored (a Photoshop filter keeps its descriptor as base64). */
-type SerializedSmartFilter = (LayerFilter | (Omit<PsdSmartFilter, 'data'> & {
+type SerializedSmartFilter = (LayerFilter | EffectSmartFilter | (Omit<PsdSmartFilter, 'data'> & {
     data: string;
 })) & {
     blend: string;
@@ -1698,6 +1740,407 @@ declare function projectMaskCoverage(coverage: Float32Array, maskWidth: number,
  */
 declare function buildLayerMaskPlanes(layers: readonly AdjustmentLayer[] | undefined, naturalWidth: number, naturalHeight: number, projection: ImageProjection, targetWidth: number, targetHeight: number): Map<string, Float32Array> | undefined;
 
+/**
+ * Free Transform geometry for the image editor, as pure functions both the UI bindings and the
+ * agent tools use: a transform is the frame being transformed (`box`, document pixels), where its
+ * four corners land (`corners`, TL, TR, BR, BL) and an optional warp mesh over the box. Scale,
+ * rotate, skew and flips keep the corners a parallelogram (an affine map); Distort and Perspective
+ * move them freely (a projective map); Warp bends the box through a Bézier mesh before the corner
+ * map.
+ *
+ * The maths (homographies, meshes, presets) is shared with the vector editor in `src/geom`.
+ */
+
+/** Free Transform modes (Edit › Transform). Scale, rotate and skew stay affine. */
+type FreeTransformMode = 'scale' | 'rotate' | 'skew' | 'distort' | 'perspective' | 'warp';
+declare const FREE_TRANSFORM_MODES: readonly FreeTransformMode[];
+/** The nine reference-point positions of the options bar's locator, over the transformed box. */
+type TransformAnchor = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right';
+declare const TRANSFORM_ANCHORS: readonly TransformAnchor[];
+declare function isTransformAnchor(value: unknown): value is TransformAnchor;
+/** A transform in progress: the frame, where its corners go and an optional warp over the frame. */
+interface FreeTransformGeometry {
+    /** The frame being transformed, in document pixels (the content bounds when it began). */
+    box: CropBox;
+    /** Where the frame's corners land: top-left, top-right, bottom-right, bottom-left (document pixels). */
+    corners: Quad;
+    /**
+     * A warp applied in the frame's own space before the corner map: its control points are in
+     * document pixels of the untransformed frame (`identityWarpMesh(box)` is no warp).
+     */
+    warp?: WarpMesh | null;
+}
+/** The untransformed geometry of a box. */
+declare function identityTransform(box: CropBox): FreeTransformGeometry;
+/** Where `box`'s corners go under the affine `m`. */
+declare function cornersFromMatrix(box: CropBox, m: AffineMatrix): Quad;
+/** The affine matrix taking `box` onto `corners` when they form a parallelogram, else `null`. */
+declare function matrixFromCorners(box: CropBox, corners: Quad, eps?: number): AffineMatrix | null;
+/** The projective map of the corner move (box → corners), or `null` when the corners are degenerate. */
+declare function transformHomography(geometry: FreeTransformGeometry): Homography | null;
+/** Whether a warp mesh changes anything (not the identity over the box). */
+declare function hasWarp(geometry: FreeTransformGeometry): boolean;
+/** Whether the geometry changes nothing. */
+declare function isIdentityTransform(geometry: FreeTransformGeometry): boolean;
+/**
+ * The forward map of the whole transform (document pixels of the source → document pixels of the
+ * result): the warp over the box, then the corner map. `null` where it is undefined.
+ */
+declare function transformMap(geometry: FreeTransformGeometry): ((p: Vec2) => Vec2 | null) | null;
+/** A point of the transformed box at box fractions (`fx`, `fy`), warp included. */
+declare function transformedPoint(geometry: FreeTransformGeometry, fx: number, fy: number): Vec2 | null;
+/** Where an anchor of the box is after the corner map (the warp ignored). */
+declare function anchorPoint(geometry: FreeTransformGeometry, anchor: TransformAnchor): Vec2;
+/** Bounds of the transformed result's outline (document pixels, not rounded). */
+declare function transformedBox(geometry: FreeTransformGeometry): CropBox | null;
+/** Free Transform as numbers, as Photoshop's options bar shows it. */
+interface TransformParams {
+    /** Width in percent of the frame (default 100; negative flips). */
+    scaleX?: number;
+    /** Height in percent of the frame (default 100; negative flips). */
+    scaleY?: number;
+    /** Rotation in degrees, clockwise (default 0). */
+    rotate?: number;
+    /** Horizontal skew in degrees: vertical edges lean right for positive angles (default 0). */
+    skewX?: number;
+    /** Vertical skew in degrees: horizontal edges lean down for positive angles (default 0). */
+    skewY?: number;
+    /** Move after scaling and rotating, in document pixels (default 0). */
+    dx?: number;
+    dy?: number;
+    /** The fixed point of scale, skew and rotation: an anchor of the frame or a document point (default the centre). */
+    reference?: TransformAnchor | Vec2;
+}
+/** The reference point of params over a box (default its centre). */
+declare function referencePoint(box: CropBox, reference: TransformParams['reference']): Vec2;
+/**
+ * The affine matrix of `params` over `box`: about the reference point, skew, then scale, then
+ * rotate; then the move.
+ */
+declare function matrixFromParams(box: CropBox, params: TransformParams): AffineMatrix;
+/** What the options bar shows for a transform. */
+interface TransformReadout {
+    /** False for Distort, Perspective and Warp: only `bounds` and `corners` then mean anything. */
+    affine: boolean;
+    /** Width and height in percent of the frame. */
+    scaleX: number;
+    scaleY: number;
+    /** Rotation in degrees, clockwise, in (−180, 180]. */
+    rotate: number;
+    /** Horizontal skew in degrees (vertical skew is folded into rotation and scale). */
+    skewX: number;
+    /** Where the reference point is now (document pixels). */
+    x: number;
+    y: number;
+    /** Bounds of the transformed outline. */
+    bounds: CropBox | null;
+    corners: Quad;
+}
+/**
+ * Decomposes a transform for the options bar: the linear part as rotate · scale · skew (QR) with
+ * the given reference point. Non-affine geometry reports its bounds and corners only.
+ */
+declare function describeTransform(geometry: FreeTransformGeometry, reference?: TransformParams['reference']): TransformReadout;
+/**
+ * Corners for a transform given as numbers relative to the current corners: `params` are applied
+ * after the current affine part (when the corners are a parallelogram) about the reference point
+ * of the current geometry, so typing "rotate 15" rotates the box as it is now.
+ */
+declare function applyParams(geometry: FreeTransformGeometry, params: TransformParams): Quad;
+/** Flip of the corners about the box's centre line (horizontal: left ↔ right). */
+declare function flipCorners(geometry: FreeTransformGeometry, axis: 'horizontal' | 'vertical'): Quad;
+/** Inverse of `matrixFromCorners` (box space → document) for mapping a document point back into the box. */
+declare function boxPointOf(geometry: FreeTransformGeometry, p: Vec2): Vec2 | null;
+/** A warp mesh from a preset over the box (null when it changes nothing). */
+declare function presetWarp(box: CropBox, preset: WarpPreset): WarpMesh | null;
+/** Validates a warp mesh for a box: well formed, finite, the right number of points. */
+declare function isValidWarp(mesh: unknown): mesh is WarpMesh;
+/** The geometry's affine map when it is one (no warp, a parallelogram), as a homography; else the projective map. */
+declare function geometryHomography(geometry: FreeTransformGeometry): Homography | null;
+
+/**
+ * How far beyond the canvas a smart object is rendered (document pixels): enough for any layer
+ * effect to see the parts just outside the canvas. Further out a smart object is not drawn.
+ */
+declare const SMART_RENDER_MARGIN = 512;
+/** The document canvas a smart object renders for. */
+interface SmartCanvas {
+    width: number;
+    height: number;
+    /** Where provider effect smart filters get their results (the controller's effects engine); without it they pass pixels through. */
+    effects?: SmartEffectResolver;
+}
+/**
+ * Runs provider effect smart filters for `applySmartFilters`, which is synchronous: a result is
+ * returned when it is ready, else `null` (the filter passes the pixels through for now) and, when
+ * `pending` is set, the surface is marked incomplete (`isSmartSurfaceIncomplete`) so it is
+ * rendered again once the result lands.
+ */
+interface SmartEffectResolver {
+    /** Changes whenever results may differ (a new provider): part of the cache key. */
+    readonly token: number;
+    resolve(filter: EffectSmartFilter, input: Uint8ClampedArray, width: number, height: number, key: string): {
+        result: Uint8ClampedArray | null;
+        pending: boolean;
+    };
+}
+/** True for a smart object surface rendered while one of its effect smart filters was still rendering. */
+declare const isSmartSurfaceIncomplete: (surface: PixelSurface) => boolean;
+/** A fresh contents id (independent contents). */
+declare function newContentsId(): string;
+/** The contents' rectangle in its own pixels. */
+declare function contentsBox(contents: SmartContents): CropBox;
+/** A smart object's placement as Free Transform geometry (the frame is the contents' rectangle). */
+declare function placementGeometry(layer: Pick<SmartObjectLayer, 'contents' | 'placement'>): FreeTransformGeometry;
+/** The placement that draws the contents 1:1 with their top-left corner at (`x`, `y`). */
+declare function placementAt(contents: Pick<SmartContents, 'width' | 'height'>, x: number, y: number): SmartPlacement;
+/** Whether the contents can be rendered here (decoded pixels or a layer document). */
+declare function isContentsDecoded(contents: SmartContents): boolean;
+/** The layer with `id`, which must be a smart object. */
+declare function requireSmartObject(layers: readonly ImageLayer[], id: string): SmartObjectLayer;
+/**
+ * The contents as pixels at (0, 0) in their own space: the raster, or the nested document
+ * composited at its size (annotation layers inside need a canvas and are left out). Memoised.
+ */
+declare function contentsSurface(contents: SmartContents): PixelSurface;
+/** Raster contents from RGBA pixels. */
+declare function rasterContents(pixels: {
+    width: number;
+    height: number;
+    data: ArrayLike<number>;
+}, name: string, id?: string): SmartContents;
+/** Document contents from layers on a `width × height` canvas. */
+declare function documentContents(document: SmartDocument, width: number, height: number, name: string, id?: string): SmartContents;
+/** How a render runs: full quality (default), or a fast preview. */
+interface SmartRenderOptions {
+    /** Preview block size (a power of two): sample a reduced copy of the contents once per block. */
+    step?: number;
+    /** Only this part of the document (the visible area). */
+    clip?: RasterRect;
+    /** Leave the smart filters out (previews while transforming). */
+    skipFilters?: boolean;
+    /** Reduced copies of the contents by factor, kept by the caller between previews. */
+    reduced?: Map<number, PixelSurface>;
+}
+/** The contents placed in the document (no filters), clipped to the canvas grown by the render margin. */
+declare function placeContents(layer: Pick<SmartObjectLayer, 'contents' | 'placement'>, canvas: SmartCanvas, options?: SmartRenderOptions): PixelSurface;
+/** The filters of a stack that change pixels (the stack enabled, each filter active, a modelled kind). Provider effects are listed by `activeEffectSmartFilters`. */
+declare function activeSmartFilters(stack: SmartFilterStack | undefined): Array<SmartFilter & LayerFilter>;
+/** The enabled provider effect smart filters of a stack. */
+declare function activeEffectSmartFilters(stack: SmartFilterStack | undefined): Array<SmartFilter & EffectSmartFilter>;
+/** A filter mask's coverage over the canvas (0..1), after density and feather; `null` reveals all. */
+declare function filterMaskCoverage(mask: RasterMask | undefined, canvas: SmartCanvas): Float32Array | null;
+/**
+ * Runs a smart filter stack over the placed contents, over the canvas (spatial filters clamp at
+ * its edges, as a pixel layer's filters do): each filter filters the result below it, and its own
+ * blend mode and opacity mix its result with that input. The filter mask then mixes the filtered
+ * result with the unfiltered contents. Returns `placed` itself when no filter is active.
+ */
+declare function applySmartFilters(placed: PixelSurface, stack: SmartFilterStack | undefined, canvas: SmartCanvas): PixelSurface;
+/** A smart object's pixels: the contents through the placement, then the smart filters. */
+declare function renderSmartObject(layer: Pick<SmartObjectLayer, 'contents' | 'placement' | 'smartFilters'>, canvas: SmartCanvas, options?: SmartRenderOptions): PixelSurface;
+/** The layer with its pixels rendered again (refused when the contents are not decoded). */
+declare function rerender(layer: SmartObjectLayer, canvas: SmartCanvas, action?: string): SmartObjectLayer;
+/** Validates a placement for contents of `width × height`; returns a clean copy. */
+declare function normalizePlacement(raw: SmartPlacement, contents: Pick<SmartContents, 'width' | 'height'>): SmartPlacement;
+/**
+ * Sets a smart object's placement (corners, warp, interpolation) and renders it again from its
+ * contents. A linked layer mask and filter mask follow a warp-free change. Returns the stack and
+ * whether the masks moved.
+ */
+declare function setSmartPlacement(layers: readonly ImageLayer[], id: string, placement: SmartPlacement, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+    masksMoved: boolean;
+};
+/**
+ * Moves a smart object by whole pixels (the move tool): its corners, a linked mask and filter mask
+ * move with it. Without spatial smart filters the rendered pixels are shifted, not resampled.
+ */
+declare function offsetSmartObject(layers: readonly ImageLayer[], id: string, dx: number, dy: number, canvas: SmartCanvas): ImageLayer[];
+interface ConvertOptions {
+    /** The pixels of a pixel layer (resolves the Background's document source). */
+    surfaceOf(layer: PixelLayer): PixelSurface;
+    /** Name of the new layer (default: the top layer's name). */
+    name?: string;
+}
+/**
+ * Layer › Smart Objects › Convert to Smart Object: sibling layers become one smart object at the
+ * position of the topmost one.
+ *
+ * - One pixel layer becomes raster contents (its pixels, cropped to their bounds) and keeps its
+ *   id, name, visibility, opacity, fill, blend, clipping, mask and effects; its filters become
+ *   smart filters. It renders exactly as before.
+ * - Anything else (several layers, a group, an adjustment, a smart object) becomes a nested
+ *   document holding the layers as they were, sized to their bounds (effects included), and the
+ *   new layer is a plain Normal layer named after the top one, rendering the isolated composite.
+ *
+ * Returns the stack, the new layer and its contents.
+ */
+declare function convertToSmartObject(layers: readonly ImageLayer[], ids: readonly string[], canvas: SmartCanvas, options: ConvertOptions): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/**
+ * Layer › Smart Objects › Rasterize: the smart object becomes a pixel layer holding what it
+ * renders (filters baked), with its mask, effects, blend, opacity and fill. Same id.
+ */
+declare function rasterizeSmartObject(layers: readonly ImageLayer[], id: string): {
+    layers: ImageLayer[];
+    layer: PixelLayer;
+};
+/**
+ * Layer › Smart Objects › New Smart Object via Copy (`linked: false`, fresh contents that edit
+ * independently) or a linked duplicate (`linked: true`, shared contents), directly above.
+ */
+declare function copySmartObject(layers: readonly ImageLayer[], id: string, linked: boolean, name?: string): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** Ids of the smart objects in the stack placed from contents `contentsId` (linked instances), bottom first. */
+declare function instancesOf(layers: readonly ImageLayer[], contentsId: string): string[];
+/**
+ * Puts new contents into every instance of `contentsId` and renders them again. With
+ * `keepPlacement` false (Replace Contents of a different size), each instance keeps its scale and
+ * rotation about the contents' centre, and a warp is stretched to the new size.
+ */
+declare function replaceContents(layers: readonly ImageLayer[], contentsId: string, contents: SmartContents, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    ids: string[];
+};
+/** A clean smart filter from loose input: a `develop` or `blur` filter plus blend and opacity. */
+declare function normalizeSmartFilter(raw: Record<string, unknown> & {
+    kind: string;
+}, id?: string): SmartFilter;
+/** Adds a smart filter at `index` (default the top). Returns the stack and the filter. */
+declare function addSmartFilter(layers: readonly ImageLayer[], id: string, filter: SmartFilter, canvas: SmartCanvas, index?: number): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+    filter: SmartFilter;
+};
+/** Changes one smart filter (settings, enabled, blend, opacity; validated). */
+declare function updateSmartFilter(layers: readonly ImageLayer[], id: string, filterId: string, changes: Record<string, unknown>, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+    filter: SmartFilter;
+};
+/** Removes one smart filter. */
+declare function removeSmartFilter(layers: readonly ImageLayer[], id: string, filterId: string, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** Moves one smart filter to `index` (0 = bottom, applied first). */
+declare function moveSmartFilter(layers: readonly ImageLayer[], id: string, filterId: string, index: number, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** Turns the whole smart filter stack on or off (each filter keeps its own switch). */
+declare function setSmartFiltersEnabled(layers: readonly ImageLayer[], id: string, enabled: boolean, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** Sets or removes (`null`) the smart filter mask. */
+declare function setSmartFilterMask(layers: readonly ImageLayer[], id: string, mask: RasterMask | null, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** A smart object's filter mask surface replaced (painting it), rendered again. */
+declare function withFilterMaskSurface(layer: SmartObjectLayer, surface: PixelSurface, canvas: SmartCanvas): SmartObjectLayer;
+/** The transformed outline of a smart object's contents (document bounds, warp included). */
+declare function placementBounds(layer: Pick<SmartObjectLayer, 'contents' | 'placement'>): CropBox | null;
+
+/**
+ * Provider effects in the image editor (see `@pixerate/editor/effects`): `effect` smart filters on
+ * smart objects, and effect layers (pixel layers drawn from a generator or overlay effect at the
+ * document's size and depth).
+ *
+ * Smart filters render synchronously (`applySmartFilters`). An effect filter asks this engine for
+ * its result: a cached one is used at once; a missing one is rendered in the background while the
+ * filter passes its pixels through and the surface is marked incomplete. When the render lands,
+ * the controller renders the smart object again (a cache refresh, not an undo step).
+ */
+
+/** Which uses each place in the image editor takes. */
+declare const IMAGE_EFFECT_PLACES: {
+    /** A smart filter: the effect changes the pixels below it. */
+    readonly filter: readonly ["filter"];
+    /** An effect layer: drawn at the document's size. */
+    readonly layer: readonly ["generator", "overlay", "title"];
+};
+type ImageEffectPlace = keyof typeof IMAGE_EFFECT_PLACES;
+/** Refuses an effect that cannot go in `place`, saying what to use instead. */
+declare function checkImageEffectPlace(d: EffectDescription, place: ImageEffectPlace): void;
+/**
+ * Pixels from a provider as a layer surface at `depth`: 8-bit data, or deep samples from the
+ * provider's linear float (16-bit as encoded codes, 32-bit as linear light).
+ */
+declare function effectPixelsToSurface(p: EffectPixels, depth: 8 | 16 | 32): PixelSurface;
+interface ImageEffectsEngineOptions {
+    /** The provider slot to follow (a controller passes its own). Default: a new one. */
+    slot?: EffectsSlot;
+    /** Smart filter results kept (default 24). */
+    maxEntries?: number;
+    /** Live renderers kept (default 4): GPU providers hold a graphics context each (see `EffectRendererPool`). */
+    maxRenderers?: number;
+}
+/**
+ * Renders provider effects for one image editor and keeps smart filter results. Follows the
+ * provider slot: with no provider effect filters pass pixels through, and a new provider clears
+ * the results and disposes the old renderers.
+ */
+declare class ImageEffectsEngine implements SmartEffectResolver {
+    readonly slot: EffectsSlot;
+    private readonly cache;
+    private readonly pending;
+    private readonly failures;
+    private readonly pool;
+    private readonly descriptions;
+    private readonly listeners;
+    private readonly maxEntries;
+    private generation;
+    private readonly detach;
+    constructor(options?: ImageEffectsEngineOptions);
+    get provider(): EffectProvider | null;
+    /** See `SmartEffectResolver.token`: bumped when the provider changes. */
+    get token(): number;
+    /** True while a render is under way. */
+    get busy(): boolean;
+    /** See `SmartEffectResolver`. */
+    resolve(filter: EffectSmartFilter, input: Uint8ClampedArray, width: number, height: number, key: string): {
+        result: Uint8ClampedArray | null;
+        pending: boolean;
+    };
+    /** A filter effect over `source`: its result, or (for an overlay) the effect drawn over it. */
+    private filter;
+    /**
+     * Renders a generator or overlay effect at a size and depth (an effect layer's pixels). Rejects
+     * with the provider's error, or without a provider.
+     */
+    renderLayer(effect: string, values: Record<string, EffectValue>, size: {
+        width: number;
+        height: number;
+        depth?: 8 | 16 | 32;
+        time?: number;
+    }): Promise<EffectPixels>;
+    /** Why the result for `key` failed, if it did. */
+    failure(key: string): Error | undefined;
+    /** Every failure so far. */
+    failuresList(): {
+        key: string;
+        error: Error;
+    }[];
+    /** Resolves when nothing is rendering. */
+    idle(): Promise<void>;
+    /** The provider's description of an effect, fetched once per provider. */
+    describe(provider: EffectProvider, id: string): Promise<EffectDescription>;
+    private render;
+    /** Forgets every result and failure and disposes the renderers. */
+    reset(): void;
+    subscribe(listener: () => void): () => void;
+    private notify;
+    destroy(): void;
+}
+
 /** A refused layer operation; the message says why and how to fix it. */
 declare class LayerOperationError extends Error {
     constructor(message: string);
@@ -1972,7 +2415,7 @@ interface ShapeEnv {
     pattern?(id: string): EffectPattern | null;
 }
 /** Subpaths with every anchor and handle mapped by `f` (live corners are cut first, then mapped). */
-declare function mapSubpaths(subpaths: readonly VectorSubpath[], f: (p: Vec2) => Vec2): VectorSubpath[];
+declare function mapSubpaths(subpaths: readonly VectorSubpath[], f: (p: Vec2$1) => Vec2$1): VectorSubpath[];
 /** The subpaths a live shape describes, in document pixels. */
 declare function liveShapeSubpaths(live: LiveShape): VectorSubpath[];
 /** A component drawn as a live shape. */
@@ -2043,7 +2486,7 @@ declare function updateShapeLayer(layers: readonly ImageLayer[], id: string, cha
     layer: ShapeLayer;
 };
 /** Moves every component of a shape by `f` (a document-space point map); `affine` keeps live shapes live. */
-declare function transformShapeComponents(components: readonly ShapeComponent[], f: (p: Vec2) => Vec2, affine?: AffineMatrix): ShapeComponent[];
+declare function transformShapeComponents(components: readonly ShapeComponent[], f: (p: Vec2$1) => Vec2$1, affine?: AffineMatrix): ShapeComponent[];
 /** A shape moved by (dx, dy), rendered again. */
 declare function offsetShape(layer: ShapeLayer, dx: number, dy: number, env: ShapeEnv): ShapeLayer;
 /** Merge Shape Components: the combined area as one `combine` component (live shapes become paths). */
@@ -2060,124 +2503,6 @@ declare function annotationBlend(a: Annotation, layerBlend: string): BlendMode;
 /** The annotation a migrated shape layer still is (its blend read from the layer). */
 declare function annotationOfShape(layer: ShapeLayer): Annotation | null;
 
-/**
- * Free Transform geometry for the image editor, as pure functions both the UI bindings and the
- * agent tools use: a transform is the frame being transformed (`box`, document pixels), where its
- * four corners land (`corners`, TL, TR, BR, BL) and an optional warp mesh over the box. Scale,
- * rotate, skew and flips keep the corners a parallelogram (an affine map); Distort and Perspective
- * move them freely (a projective map); Warp bends the box through a Bézier mesh before the corner
- * map.
- *
- * The maths (homographies, meshes, presets) is shared with the vector editor in `src/geom`.
- */
-
-/** Free Transform modes (Edit › Transform). Scale, rotate and skew stay affine. */
-type FreeTransformMode = 'scale' | 'rotate' | 'skew' | 'distort' | 'perspective' | 'warp';
-declare const FREE_TRANSFORM_MODES: readonly FreeTransformMode[];
-/** The nine reference-point positions of the options bar's locator, over the transformed box. */
-type TransformAnchor = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right';
-declare const TRANSFORM_ANCHORS: readonly TransformAnchor[];
-declare function isTransformAnchor(value: unknown): value is TransformAnchor;
-/** A transform in progress: the frame, where its corners go and an optional warp over the frame. */
-interface FreeTransformGeometry {
-    /** The frame being transformed, in document pixels (the content bounds when it began). */
-    box: CropBox;
-    /** Where the frame's corners land: top-left, top-right, bottom-right, bottom-left (document pixels). */
-    corners: Quad;
-    /**
-     * A warp applied in the frame's own space before the corner map: its control points are in
-     * document pixels of the untransformed frame (`identityWarpMesh(box)` is no warp).
-     */
-    warp?: WarpMesh | null;
-}
-/** The untransformed geometry of a box. */
-declare function identityTransform(box: CropBox): FreeTransformGeometry;
-/** Where `box`'s corners go under the affine `m`. */
-declare function cornersFromMatrix(box: CropBox, m: AffineMatrix): Quad;
-/** The affine matrix taking `box` onto `corners` when they form a parallelogram, else `null`. */
-declare function matrixFromCorners(box: CropBox, corners: Quad, eps?: number): AffineMatrix | null;
-/** The projective map of the corner move (box → corners), or `null` when the corners are degenerate. */
-declare function transformHomography(geometry: FreeTransformGeometry): Homography | null;
-/** Whether a warp mesh changes anything (not the identity over the box). */
-declare function hasWarp(geometry: FreeTransformGeometry): boolean;
-/** Whether the geometry changes nothing. */
-declare function isIdentityTransform(geometry: FreeTransformGeometry): boolean;
-/**
- * The forward map of the whole transform (document pixels of the source → document pixels of the
- * result): the warp over the box, then the corner map. `null` where it is undefined.
- */
-declare function transformMap(geometry: FreeTransformGeometry): ((p: Vec2$1) => Vec2$1 | null) | null;
-/** A point of the transformed box at box fractions (`fx`, `fy`), warp included. */
-declare function transformedPoint(geometry: FreeTransformGeometry, fx: number, fy: number): Vec2$1 | null;
-/** Where an anchor of the box is after the corner map (the warp ignored). */
-declare function anchorPoint(geometry: FreeTransformGeometry, anchor: TransformAnchor): Vec2$1;
-/** Bounds of the transformed result's outline (document pixels, not rounded). */
-declare function transformedBox(geometry: FreeTransformGeometry): CropBox | null;
-/** Free Transform as numbers, as Photoshop's options bar shows it. */
-interface TransformParams {
-    /** Width in percent of the frame (default 100; negative flips). */
-    scaleX?: number;
-    /** Height in percent of the frame (default 100; negative flips). */
-    scaleY?: number;
-    /** Rotation in degrees, clockwise (default 0). */
-    rotate?: number;
-    /** Horizontal skew in degrees: vertical edges lean right for positive angles (default 0). */
-    skewX?: number;
-    /** Vertical skew in degrees: horizontal edges lean down for positive angles (default 0). */
-    skewY?: number;
-    /** Move after scaling and rotating, in document pixels (default 0). */
-    dx?: number;
-    dy?: number;
-    /** The fixed point of scale, skew and rotation: an anchor of the frame or a document point (default the centre). */
-    reference?: TransformAnchor | Vec2$1;
-}
-/** The reference point of params over a box (default its centre). */
-declare function referencePoint(box: CropBox, reference: TransformParams['reference']): Vec2$1;
-/**
- * The affine matrix of `params` over `box`: about the reference point, skew, then scale, then
- * rotate; then the move.
- */
-declare function matrixFromParams(box: CropBox, params: TransformParams): AffineMatrix;
-/** What the options bar shows for a transform. */
-interface TransformReadout {
-    /** False for Distort, Perspective and Warp: only `bounds` and `corners` then mean anything. */
-    affine: boolean;
-    /** Width and height in percent of the frame. */
-    scaleX: number;
-    scaleY: number;
-    /** Rotation in degrees, clockwise, in (−180, 180]. */
-    rotate: number;
-    /** Horizontal skew in degrees (vertical skew is folded into rotation and scale). */
-    skewX: number;
-    /** Where the reference point is now (document pixels). */
-    x: number;
-    y: number;
-    /** Bounds of the transformed outline. */
-    bounds: CropBox | null;
-    corners: Quad;
-}
-/**
- * Decomposes a transform for the options bar: the linear part as rotate · scale · skew (QR) with
- * the given reference point. Non-affine geometry reports its bounds and corners only.
- */
-declare function describeTransform(geometry: FreeTransformGeometry, reference?: TransformParams['reference']): TransformReadout;
-/**
- * Corners for a transform given as numbers relative to the current corners: `params` are applied
- * after the current affine part (when the corners are a parallelogram) about the reference point
- * of the current geometry, so typing "rotate 15" rotates the box as it is now.
- */
-declare function applyParams(geometry: FreeTransformGeometry, params: TransformParams): Quad;
-/** Flip of the corners about the box's centre line (horizontal: left ↔ right). */
-declare function flipCorners(geometry: FreeTransformGeometry, axis: 'horizontal' | 'vertical'): Quad;
-/** Inverse of `matrixFromCorners` (box space → document) for mapping a document point back into the box. */
-declare function boxPointOf(geometry: FreeTransformGeometry, p: Vec2$1): Vec2$1 | null;
-/** A warp mesh from a preset over the box (null when it changes nothing). */
-declare function presetWarp(box: CropBox, preset: WarpPreset): WarpMesh | null;
-/** Validates a warp mesh for a box: well formed, finite, the right number of points. */
-declare function isValidWarp(mesh: unknown): mesh is WarpMesh;
-/** The geometry's affine map when it is one (no warp, a parallelogram), as a homography; else the projective map. */
-declare function geometryHomography(geometry: FreeTransformGeometry): Homography | null;
-
 /**
  * Free Transform sessions: what a transform moves (a layer's pixels with its linked mask, a lone
  * unlinked mask, the selected pixels as a floating piece, a copy of them on a new layer, or just
@@ -2850,6 +3175,11 @@ declare class ImageEditorController {
     private viewKey;
     /** For `compositePixels` and mask evaluation (the renderer keeps its own for the viewport). */
     private compositor;
+    /** The effects provider slot (see `setEffectsProvider`). */
+    readonly effects: EffectsSlot;
+    /** Renders provider effects: effect smart filter results and effect layers. */
+    readonly effectsEngine: ImageEffectsEngine;
+    private effectRefresh;
     constructor(options?: ImageEditorOptions);
     /**
      * Loads a new source image and makes it the baseline that `reset()` returns to.
@@ -2867,6 +3197,76 @@ declare class ImageEditorController {
      */
     private pendingDirty;
     private notify;
+    private queueEffectRefresh;
+    /**
+     * Renders smart objects with effect filters again: every one (`all`, after the provider changed)
+     * or those drawn while a result was rendering, once it is in. A cache refresh: no undo step.
+     */
+    private refreshEffectSurfaces;
+    /** The registered effects provider, or `null`. */
+    get effectsProvider(): EffectProvider | null;
+    /** Registers (or with `null` removes) the effects provider. Not an edit: no undo step. */
+    setEffectsProvider(provider: EffectProvider | null): void;
+    /** Registers `provider` and returns a function that removes it again (if it is still the one set). */
+    useEffects(provider: EffectProvider): () => void;
+    /** The provider's description of an effect, checked for `place` (rejects without a provider or for an unknown id). */
+    describeEffect(effect: string, place?: ImageEffectPlace): Promise<EffectDescription>;
+    /** Resolves when every effect render has landed and the surfaces waiting for them are drawn. */
+    effectsIdle(): Promise<void>;
+    /**
+     * Applies a provider filter effect as a smart filter (at `index`, default the top), one undo
+     * step. A pixel, shape or type layer (or a group) is first converted to a smart object in the
+     * same step (Filter › Convert for Smart Filters), keeping its id when it is one layer. `values`
+     * are checked against the effect's controls and stored over its defaults.
+     */
+    applyEffectFilter(layerId: string, effect: string, options?: {
+        values?: Record<string, EffectValue>;
+        index?: number;
+        enabled?: boolean;
+        blend?: string;
+        opacity?: number;
+    }): Promise<{
+        layerId: string;
+        filter: SmartFilter;
+        converted: boolean;
+    }>;
+    /**
+     * Changes an effect smart filter: `values` merged over its own (`null` resets a control to the
+     * effect's default), `enabled`, `blend`, `opacity` or its place in the stack (`index`). Values
+     * are checked against the provider's controls. One undo step (none with `commitToHistory`
+     * false, during a drag).
+     */
+    updateEffectFilter(layerId: string, filterId: string, changes: {
+        values?: Record<string, EffectValue | null>;
+        enabled?: boolean;
+        blend?: string;
+        opacity?: number;
+        index?: number;
+    }, commitToHistory?: boolean): Promise<SmartFilter>;
+    /**
+     * Adds an effect layer: a pixel layer drawn by a provider generator, overlay or title effect at
+     * the document's size and bit depth (at `time` ms, default 0), placed like `addPixelLayer`. One
+     * undo step. Masks, blend and opacity apply as to any layer. Returns its id.
+     */
+    addEffectLayer(effect: string, options?: LayerPlacement & {
+        values?: Record<string, EffectValue>;
+        name?: string;
+        time?: number;
+        opacity?: number;
+        blend?: string;
+        id?: string;
+    }): Promise<string>;
+    /**
+     * Draws an effect layer again with new `values` (merged over its own; `null` resets a control)
+     * or `time`, at the document's size and depth, replacing its pixels (painting on it is lost).
+     * One undo step (none with `commitToHistory` false). Returns its effect settings.
+     */
+    updateEffectLayer(layerId: string, changes: {
+        values?: Record<string, EffectValue | null>;
+        time?: number;
+    }, commitToHistory?: boolean): Promise<NonNullable<PixelLayer['generator']>>;
+    /** Turns an effect layer into a plain pixel layer keeping its pixels (one undo step). */
+    rasterizeEffectLayer(layerId: string): void;
     private displayFor;
     /** Keeps the renderer's display transform in step with the document profile, mode and Proof Setup. */
     private syncDisplay;
@@ -4244,6 +4644,7 @@ interface ExportOptions {
     /** Render only these layers (groups with their children). */
     layerIds?: string[];
 }
+
 interface ImageEditorOptions {
     /**
      * What lays out and draws type layers. Default: the browser's fonts through Canvas 2D
@@ -4263,6 +4664,13 @@ interface ImageEditorOptions {
     maxHistoryBytes?: number;
     /** Viewport fit mode: 'contain' scales to full viewport bounds; 'margin' scales to 85% with 1.0 cap (default). */
     fit?: ImageEditorFit;
+    /**
+     * An effects provider (see `@pixerate/editor/effects`) for effect smart filters and effect
+     * layers. Optional: without one the editor behaves as before; documents keep their effects
+     * (effect filters pass pixels through, effect layers keep their last pixels). Change it later
+     * with `setEffectsProvider`.
+     */
+    effects?: EffectProvider | null;
 }
 interface InpaintOptions {
     prompt: string;
@@ -4318,4 +4726,4 @@ interface PsdExportResult {
 /** Writes the prepared stack as PSD (or PSB) bytes. */
 declare function exportPsd(input: PsdExportInput): PsdExportResult;
 
-export { type AdjustmentLayerBase as $, type AdjustmentKind as A, LayerCompositor as B, type CurvePoint as C, type DepthMaskOptions as D, type SmartFilterStack as E, type SmartFilter as F, type SmartObjectLayer as G, type HueRange as H, type ImageEditorAssetStore as I, type SmartContents as J, type SmartDocument as K, type LevelsChannel as L, type SmartPlacement as M, type FreeTransformGeometry as N, type LiveShapeKind as O, type PsdExportResult as P, type TypeLayerInfo as Q, type RefineEdgeParams as R, type SerializedLayer as S, type TextEnv as T, type LayerPlacement as U, type FreeTransformMode as V, type FreeTransformResult as W, FreeTransformSession as X, type FreeTransformInit as Y, type TransformAnchor as Z, type AIResultOptions as _, type ImageAdjustments as a, type LayerProperties as a$, type AdjustmentLayerInit as a0, type AdjustmentLayerUpdate as a1, type AnnotationPlacement as a2, type AnnotationType as a3, type ArrowAnnotation as a4, type AspectRatio as a5, type BaseAnnotation as a6, type BlackWhiteParams as a7, type BlurFilter as a8, type CircleAnnotation as a9, GUIDED_FILTER_EPS as aA, type GroupLayer as aB, HISTOGRAM_BINS as aC, type HistogramChannel as aD, type HistoryEntryHandle as aE, type HueSaturationParams as aF, IMAGE_EDITOR_SCHEMA_VERSION as aG, type ImageAnnotation as aH, type ImageDimensions as aI, type ImageEditorAIHooks as aJ, type ImageEditorFit as aK, type ImageEditorOptions as aL, ImageEditorRenderer as aM, type ImageEditorState as aN, type ImageEditorTool as aO, type ImageLayerType as aP, type InpaintHook as aQ, type InpaintOptions as aR, type InvertParams as aS, LAYERED_SCHEMA_VERSION as aT, LIVE_SHAPE_KINDS as aU, type LayerBase as aV, type LayerBlendMode as aW, type LayerFilterKind as aX, type LayerLocation as aY, type LayerMaskProps as aZ, LayerOperationError as a_, type CloneSource as aa, type ColorBalanceParams as ab, type ColorBalanceTone as ac, type ColorRangeOptions as ad, type ColorRangeSample as ae, type CreateAnnotationPayload as af, type CropHandle as ag, type CurvesParams as ah, DEFAULT_ADJUSTMENTS as ai, DEFAULT_DEPTH_MASK as aj, DEFAULT_MITER_LIMIT as ak, DEFAULT_PROOF as al, DEFAULT_REFINE_EDGE_PARAMS as am, DEFAULT_TRANSFORM as an, type DeserializeContext as ao, type DevelopSettings as ap, type DocumentColorMode as aq, type DocumentColorProfile as ar, EMPTY_DISTANCE as as, type ExportOptions as at, FREE_TRANSFORM_CONTENTS as au, FREE_TRANSFORM_MODES as av, type FillOptions as aw, type FreeTransformContent as ax, type FreeTransformHost as ay, type FreeTransformPreview as az, type SerializedImageEditorState as b, type SerializedSmartContents as b$, type LayerSourcesHost as b0, type LayerTarget as b1, type LegacySerializedImageEditorState as b2, type LevelsParams as b3, type LineAnnotation as b4, type LiveShape as b5, type MagicWandOptions as b6, type MixerStrokeInit as b7, PARAGRAPH_STYLE_FIELDS as b8, PSD_BLEND_KEYS as b9, type RemoveBackgroundHook as bA, type RemoveBackgroundOptions as bB, type RenderOptions as bC, type RetouchStrokeInit as bD, type RetouchTool as bE, SELECTION_MODES as bF, SELECTION_MODIFY_OPS as bG, SHAPE_OPERATIONS as bH, SHAPE_RENDER_MARGIN as bI, type SampleOptions as bJ, type SelectionChannel as bK, type SelectionCommandOptions as bL, type SelectionModifyOp as bM, type SerializeContext as bN, type SerializedAdjustmentLayer as bO, type SerializedAnnotationLayer as bP, type SerializedColorMode as bQ, type SerializedColorProfile as bR, type SerializedDeepPixels as bS, type SerializedGroupLayer as bT, type SerializedLayerEffects as bU, type SerializedLayeredImageEditorState as bV, type SerializedPattern as bW, type SerializedPixelLayer as bX, type SerializedRasterMask as bY, type SerializedSelection as bZ, type SerializedShapeLayer as b_, type PaintOptions as ba, type PaintStrokeResult as bb, PaintStrokeSession as bc, type PenAnnotation as bd, type PhotoFilterParams as be, type PixelBuffer as bf, type PixelLayerInit as bg, type PixelTransform as bh, type PosterizeParams as bi, type ProofSetup as bj, type PsdChannel as bk, type PsdExportInput as bl, type PsdFile as bm, type PsdHeader as bn, type PsdImportOptions as bo, type PsdImportResult as bp, type PsdLayerMask as bq, type PsdLayerRecord as br, type PsdLayerSummary as bs, type PsdRect as bt, type PsdResource as bu, type PsdSmartFilter as bv, type PsdTaggedBlock as bw, type PsdTreeNode as bx, RETOUCH_TOOLS as by, type RectAnnotation as bz, type AdjustmentLayer as c, contractCoverage as c$, type SerializedSmartFilter as c0, type SerializedSmartObjectLayer as c1, type SerializedTypeLayer as c2, type ShapeArrowhead as c3, type ShapeComponent as c4, type ShapeEnv as c5, type ShapeFillRule as c6, type ShapeGeometryInput as c7, type ShapeLayerData as c8, type ShapeLayerInfo as c9, type TypePsdData as cA, type VibranceParams as cB, type ViewportMetrics as cC, addLayerEffect as cD, addLayerFilter as cE, adjustmentNodeAsLayer as cF, anchorPoint as cG, annotationBlend as cH, annotationOfShape as cI, annotationOfType as cJ, applyImageProjectionToContext as cK, applyParams as cL, blurFilter as cM, borderCoverage as cN, boxMean as cO, boxPointOf as cP, buildLayerMaskPlanes as cQ, calculateCropDrag as cR, canvasToImagePoint as cS, clampCropToImage as cT, colorModePlanes as cU, colorRange as cV, combineSelections as cW, componentPath as cX, compositeDeep as cY, computeHistogram as cZ, computeSelectionBounds as c_, type ShapeLayerInit as ca, type ShapeLineCap as cb, type ShapeLineJoin as cc, type ShapeOperation as cd, type ShapePaint as ce, type ShapePsdData as cf, type ShapeSelectionOptions as cg, type ShapeStroke as ch, type ShapeStrokeAlign as ci, type ShapeStrokeInput as cj, type SmartFilterKind as ck, type SmartObjectInfo as cl, type SmartPsdData as cm, type StrokeInit as cn, type StrokeTool as co, TEXT_RENDER_MARGIN as cp, TEXT_STYLE_FIELDS as cq, TONE_RANGE_PRESETS as cr, TRANSFORM_ANCHORS as cs, type TextAnnotation as ct, type TextLayerInit as cu, type ThresholdParams as cv, type ToneRangePreset as cw, type TransformParams as cx, type TransformReadout as cy, type TypeLayerData as cz, type AdjustmentParamsMap as d, isActiveFilter as d$, convertHex as d0, convertSurfaceColors as d1, cornersFromMatrix as d2, coverageToByte as d3, createSelectionMask as d4, createShapeLayer as d5, createTypeLayer as d6, decodeDeepSurface as d7, decodeLayerChannel as d8, decodeLayerMask as d9, expandCoverage as dA, exportPsd as dB, featherCoverage as dC, flipCorners as dD, fullSelection as dE, geometryHomography as dF, getAnnotationBounds as dG, getCropCursor as dH, getRotatedSize as dI, getViewportMetrics as dJ, getViewportProjection as dK, globalImageCache as dL, greyMorphology as dM, groupLayers as dN, guidePlanes as dO, guidedFilterColor as dP, hasSurface as dQ, hasWarp as dR, hashMaskContent as dS, histogramPath as dT, hitTestAnnotation as dU, hitTestCrop as dV, hueRange as dW, identityTransform as dX, imageToCanvasPoint as dY, importPsd as dZ, invertSelection as d_, decodeMergedImage as da, decodePngDataUrl as db, decodeSelectionRle as dc, defaultShapeName as dd, depthMaskAlpha as de, describeTransform as df, deserializeColorMode as dg, deserializeColorProfile as dh, deserializeEffects as di, deserializeLayer as dj, deserializeLayers as dk, deserializePatterns as dl, deserializeSelection as dm, developFilter as dn, displayTransform as dp, distanceTransform as dq, documentProfile as dr, duplicateLayer as ds, edgeWidth as dt, effectiveProof as du, ellipsePoints as dv, ellipseSelection as dw, encodeDeepSurface as dx, encodeSelectionRle as dy, encodeSurface as dz, type AdjustmentLayerMask as e, refineCoverage as e$, isIdentityTransform as e0, isQuarterTurnSwapped as e1, isRenderedLayer as e2, isRetouchTool as e3, isSelectionEmpty as e4, isSelectionMode as e5, isSpatialFilter as e6, isSrgb as e7, isTransformAnchor as e8, isValidWarp as e9, normalizeShapePaint as eA, normalizeShapeStroke as eB, normalizeStoredAdjustments as eC, normalizeSubpaths as eD, normalizeText as eE, offsetLayer as eF, offsetShape as eG, parseBlend as eH, parseColor as eI, parseSelectionMode as eJ, patchParagraphStyle as eK, patchTextStyle as eL, pixelLayerBounds as eM, pixelLayers as eN, placeLayer as eO, polygonCoverage as eP, polygonSelection as eQ, presetWarp as eR, previewStep as eS, profileBytes as eT, projectImagePoint as eU, projectImageRect as eV, projectMaskCoverage as eW, psdToLayers as eX, readPsd as eY, rectSelection as eZ, referencePoint as e_, layerEffectsOf as ea, layerMaskCoverage as eb, layerMaskFromSelection as ec, layerMaskKey as ed, layerName as ee, layerTree as ef, layerTypeLabel as eg, liveComponent as eh, liveShapeSubpaths as ei, magicWand as ej, mapCropHandle as ek, mapSubpaths as el, matrixFromCorners as em, matrixFromParams as en, mergeShapeComponents as eo, migrateSerializedImageEditorState as ep, migrateToLayeredState as eq, modifySelection as er, moveLayer as es, newLayerId as et, normalizeAngle as eu, normalizeFilter as ev, normalizeLayerMask as ew, normalizeLiveShape as ex, normalizeRect as ey, normalizeRefineEdgeParams as ez, type AdjustmentLayerOf as f, typeAsPixelLayer as f$, refineEdgeHalo as f0, refineSelection as f1, removeLayer as f2, removeLayerEffect as f3, removeLayerFilter as f4, renderShape as f5, renderShapeRect as f6, renderText as f7, replaceTextRange as f8, requireLayer as f9, serializeSelection as fA, setLayerEffects as fB, setLayerEffectsEnabled as fC, setLayerMask as fD, setLayerProperties as fE, shapeAsPixelLayer as fF, shapeFromAnnotation as fG, shapeGeometryBounds as fH, shapeLayers as fI, shapeOutline as fJ, shapeRenderClip as fK, shiftCoverage as fL, smartObjectLayers as fM, smoothCoverage as fN, srgb8ToLab as fO, textMatrix as fP, textOutlines as fQ, textRange as fR, toHex as fS, toTextSpace as fT, toneRange as fU, transformHomography as fV, transformMap as fW, transformShapeComponents as fX, transformTypeLayer as fY, transformedBox as fZ, transformedPoint as f_, requireOperation as fa, requireShapeLayer as fb, requireTypeLayer as fc, requireUnlocked as fd, rerenderShape as fe, rerenderText as ff, resizePixels as fg, resizeSelection as fh, resolveExternalAssets as fi, resolveProfile as fj, runLayerFilters as fk, runLayerFiltersFloat as fl, selectionArea as fm, selectionFromCoverage as fn, selectionFromPixels as fo, selectionToCoverage as fp, selectionToPixels as fq, selectionValueAt as fr, serializeColorMode as fs, serializeColorProfile as ft, serializeContents as fu, serializeEffects as fv, serializeLayer as fw, serializeLayers as fx, serializeLayersExternal as fy, serializePatterns as fz, ImageEditorController as g, typeFrame as g0, typeFromAnnotation as g1, typeLayerName as g2, ungroupLayer as g3, unionRect as g4, unprojectCanvasPoint as g5, updateLayerEffect as g6, updateLayerFilter as g7, updateLayerMaskProps as g8, updateShapeLayer as g9, updateTypeLayer as ga, withNewIds as gb, writePsd as gc, type SelectionMask as h, type SelectionMode as i, type ColorDistance as j, type ImagePoint as k, type ImageLayer as l, type CropBox as m, type RasterMask as n, type Annotation as o, type AdjustmentLayerNode as p, type AnnotationLayer as q, type ShapeLayer as r, type TypeLayer as s, type LayerFilter as t, type PixelLayer as u, type DevelopFilter as v, type ImageTransform as w, type ImageHistogram as x, type ImageProjection as y, type CompositorSources as z };
+export { type AspectRatio as $, type AdjustmentKind as A, LayerCompositor as B, type CurvePoint as C, type DepthMaskOptions as D, type LiveShapeKind as E, type TypeLayerInfo as F, type SmartFilter as G, type HueRange as H, type ImageEditorAssetStore as I, type LayerPlacement as J, type FreeTransformMode as K, type LevelsChannel as L, type FreeTransformResult as M, FreeTransformSession as N, type FreeTransformInit as O, type PsdExportResult as P, type TransformAnchor as Q, type RefineEdgeParams as R, type SerializedLayer as S, type TextEnv as T, type AIResultOptions as U, type AdjustmentLayerBase as V, type AdjustmentLayerInit as W, type AdjustmentLayerUpdate as X, type AnnotationPlacement as Y, type AnnotationType as Z, type ArrowAnnotation as _, type ImageAdjustments as a, type LayerMaskProps as a$, type BaseAnnotation as a0, type BlackWhiteParams as a1, type BlurFilter as a2, type CircleAnnotation as a3, type CloneSource as a4, type ColorBalanceParams as a5, type ColorBalanceTone as a6, type ColorRangeOptions as a7, type ColorRangeSample as a8, type ConvertOptions as a9, type HistogramChannel as aA, type HistoryEntryHandle as aB, type HueSaturationParams as aC, IMAGE_EDITOR_SCHEMA_VERSION as aD, IMAGE_EFFECT_PLACES as aE, type ImageAnnotation as aF, type ImageDimensions as aG, type ImageEditorAIHooks as aH, type ImageEditorFit as aI, type ImageEditorOptions as aJ, ImageEditorRenderer as aK, type ImageEditorState as aL, type ImageEditorTool as aM, type ImageEffectGenerator as aN, type ImageEffectPlace as aO, ImageEffectsEngine as aP, type ImageEffectsEngineOptions as aQ, type ImageLayerType as aR, type InpaintHook as aS, type InpaintOptions as aT, type InvertParams as aU, LAYERED_SCHEMA_VERSION as aV, LIVE_SHAPE_KINDS as aW, type LayerBase as aX, type LayerBlendMode as aY, type LayerFilterKind as aZ, type LayerLocation as a_, type CreateAnnotationPayload as aa, type CropHandle as ab, type CurvesParams as ac, DEFAULT_ADJUSTMENTS as ad, DEFAULT_DEPTH_MASK as ae, DEFAULT_MITER_LIMIT as af, DEFAULT_PROOF as ag, DEFAULT_REFINE_EDGE_PARAMS as ah, DEFAULT_TRANSFORM as ai, type DeserializeContext as aj, type DevelopSettings as ak, type DocumentColorMode as al, type DocumentColorProfile as am, EMPTY_DISTANCE as an, type EffectSmartFilter as ao, type ExportOptions as ap, FREE_TRANSFORM_CONTENTS as aq, FREE_TRANSFORM_MODES as ar, type FillOptions as as, type FreeTransformContent as at, type FreeTransformGeometry as au, type FreeTransformHost as av, type FreeTransformPreview as aw, GUIDED_FILTER_EPS as ax, type GroupLayer as ay, HISTOGRAM_BINS as az, type SerializedImageEditorState as b, type SerializedRasterMask as b$, LayerOperationError as b0, type LayerProperties as b1, type LayerSourcesHost as b2, type LayerTarget as b3, type LegacySerializedImageEditorState as b4, type LevelsParams as b5, type LineAnnotation as b6, type LiveShape as b7, type MagicWandOptions as b8, type MixerStrokeInit as b9, RETOUCH_TOOLS as bA, type RectAnnotation as bB, type RemoveBackgroundHook as bC, type RemoveBackgroundOptions as bD, type RenderOptions as bE, type RetouchStrokeInit as bF, type RetouchTool as bG, SELECTION_MODES as bH, SELECTION_MODIFY_OPS as bI, SHAPE_OPERATIONS as bJ, SHAPE_RENDER_MARGIN as bK, SMART_RENDER_MARGIN as bL, type SampleOptions as bM, type SelectionChannel as bN, type SelectionCommandOptions as bO, type SelectionModifyOp as bP, type SerializeContext as bQ, type SerializedAdjustmentLayer as bR, type SerializedAnnotationLayer as bS, type SerializedColorMode as bT, type SerializedColorProfile as bU, type SerializedDeepPixels as bV, type SerializedGroupLayer as bW, type SerializedLayerEffects as bX, type SerializedLayeredImageEditorState as bY, type SerializedPattern as bZ, type SerializedPixelLayer as b_, PARAGRAPH_STYLE_FIELDS as ba, PSD_BLEND_KEYS as bb, type PaintOptions as bc, type PaintStrokeResult as bd, PaintStrokeSession as be, type PenAnnotation as bf, type PhotoFilterParams as bg, type PixelBuffer as bh, type PixelLayerInit as bi, type PixelTransform as bj, type PosterizeParams as bk, type ProofSetup as bl, type PsdChannel as bm, type PsdExportInput as bn, type PsdFile as bo, type PsdHeader as bp, type PsdImportOptions as bq, type PsdImportResult as br, type PsdLayerMask as bs, type PsdLayerRecord as bt, type PsdLayerSummary as bu, type PsdRect as bv, type PsdResource as bw, type PsdSmartFilter as bx, type PsdTaggedBlock as by, type PsdTreeNode as bz, type AdjustmentLayer as c, blurFilter as c$, type SerializedSelection as c0, type SerializedShapeLayer as c1, type SerializedSmartContents as c2, type SerializedSmartFilter as c3, type SerializedSmartObjectLayer as c4, type SerializedTypeLayer as c5, type ShapeArrowhead as c6, type ShapeComponent as c7, type ShapeEnv as c8, type ShapeFillRule as c9, TEXT_RENDER_MARGIN as cA, TEXT_STYLE_FIELDS as cB, TONE_RANGE_PRESETS as cC, TRANSFORM_ANCHORS as cD, type TextAnnotation as cE, type TextLayerInit as cF, type ThresholdParams as cG, type ToneRangePreset as cH, type TransformParams as cI, type TransformReadout as cJ, type TypeLayerData as cK, type TypePsdData as cL, type VibranceParams as cM, type ViewportMetrics as cN, activeEffectSmartFilters as cO, activeSmartFilters as cP, addLayerEffect as cQ, addLayerFilter as cR, addSmartFilter as cS, adjustmentNodeAsLayer as cT, anchorPoint as cU, annotationBlend as cV, annotationOfShape as cW, annotationOfType as cX, applyImageProjectionToContext as cY, applyParams as cZ, applySmartFilters as c_, type ShapeGeometryInput as ca, type ShapeLayerData as cb, type ShapeLayerInfo as cc, type ShapeLayerInit as cd, type ShapeLineCap as ce, type ShapeLineJoin as cf, type ShapeOperation as cg, type ShapePaint as ch, type ShapePsdData as ci, type ShapeSelectionOptions as cj, type ShapeStroke as ck, type ShapeStrokeAlign as cl, type ShapeStrokeInput as cm, type SmartCanvas as cn, type SmartContents as co, type SmartDocument as cp, type SmartEffectResolver as cq, type SmartFilterKind as cr, type SmartFilterStack as cs, type SmartObjectInfo as ct, type SmartObjectLayer as cu, type SmartPlacement as cv, type SmartPsdData as cw, type SmartRenderOptions as cx, type StrokeInit as cy, type StrokeTool as cz, type AdjustmentParamsMap as d, fullSelection as d$, borderCoverage as d0, boxMean as d1, boxPointOf as d2, buildLayerMaskPlanes as d3, calculateCropDrag as d4, canvasToImagePoint as d5, checkImageEffectPlace as d6, clampCropToImage as d7, colorModePlanes as d8, colorRange as d9, describeTransform as dA, deserializeColorMode as dB, deserializeColorProfile as dC, deserializeEffects as dD, deserializeLayer as dE, deserializeLayers as dF, deserializePatterns as dG, deserializeSelection as dH, developFilter as dI, displayTransform as dJ, distanceTransform as dK, documentContents as dL, documentProfile as dM, duplicateLayer as dN, edgeWidth as dO, effectPixelsToSurface as dP, effectiveProof as dQ, ellipsePoints as dR, ellipseSelection as dS, encodeDeepSurface as dT, encodeSelectionRle as dU, encodeSurface as dV, expandCoverage as dW, exportPsd as dX, featherCoverage as dY, filterMaskCoverage as dZ, flipCorners as d_, combineSelections as da, componentPath as db, compositeDeep as dc, computeHistogram as dd, computeSelectionBounds as de, contentsBox as df, contentsSurface as dg, contractCoverage as dh, convertHex as di, convertSurfaceColors as dj, convertToSmartObject as dk, copySmartObject as dl, cornersFromMatrix as dm, coverageToByte as dn, createSelectionMask as dp, createShapeLayer as dq, createTypeLayer as dr, decodeDeepSurface as ds, decodeLayerChannel as dt, decodeLayerMask as du, decodeMergedImage as dv, decodePngDataUrl as dw, decodeSelectionRle as dx, defaultShapeName as dy, depthMaskAlpha as dz, type AdjustmentLayerMask as e, normalizeRect as e$, geometryHomography as e0, getAnnotationBounds as e1, getCropCursor as e2, getRotatedSize as e3, getViewportMetrics as e4, getViewportProjection as e5, globalImageCache as e6, greyMorphology as e7, groupLayers as e8, guidePlanes as e9, layerEffectsOf as eA, layerMaskCoverage as eB, layerMaskFromSelection as eC, layerMaskKey as eD, layerName as eE, layerTree as eF, layerTypeLabel as eG, liveComponent as eH, liveShapeSubpaths as eI, magicWand as eJ, mapCropHandle as eK, mapSubpaths as eL, matrixFromCorners as eM, matrixFromParams as eN, mergeShapeComponents as eO, migrateSerializedImageEditorState as eP, migrateToLayeredState as eQ, modifySelection as eR, moveLayer as eS, moveSmartFilter as eT, newContentsId as eU, newLayerId as eV, normalizeAngle as eW, normalizeFilter as eX, normalizeLayerMask as eY, normalizeLiveShape as eZ, normalizePlacement as e_, guidedFilterColor as ea, hasSurface as eb, hasWarp as ec, hashMaskContent as ed, histogramPath as ee, hitTestAnnotation as ef, hitTestCrop as eg, hueRange as eh, identityTransform as ei, imageToCanvasPoint as ej, importPsd as ek, instancesOf as el, invertSelection as em, isActiveFilter as en, isContentsDecoded as eo, isIdentityTransform as ep, isQuarterTurnSwapped as eq, isRenderedLayer as er, isRetouchTool as es, isSelectionEmpty as et, isSelectionMode as eu, isSmartSurfaceIncomplete as ev, isSpatialFilter as ew, isSrgb as ex, isTransformAnchor as ey, isValidWarp as ez, type AdjustmentLayerOf as f, runLayerFiltersFloat as f$, normalizeRefineEdgeParams as f0, normalizeShapePaint as f1, normalizeShapeStroke as f2, normalizeSmartFilter as f3, normalizeStoredAdjustments as f4, normalizeSubpaths as f5, normalizeText as f6, offsetLayer as f7, offsetShape as f8, offsetSmartObject as f9, refineCoverage as fA, refineEdgeHalo as fB, refineSelection as fC, removeLayer as fD, removeLayerEffect as fE, removeLayerFilter as fF, removeSmartFilter as fG, renderShape as fH, renderShapeRect as fI, renderSmartObject as fJ, renderText as fK, replaceContents as fL, replaceTextRange as fM, requireLayer as fN, requireOperation as fO, requireShapeLayer as fP, requireSmartObject as fQ, requireTypeLayer as fR, requireUnlocked as fS, rerender as fT, rerenderShape as fU, rerenderText as fV, resizePixels as fW, resizeSelection as fX, resolveExternalAssets as fY, resolveProfile as fZ, runLayerFilters as f_, parseBlend as fa, parseColor as fb, parseSelectionMode as fc, patchParagraphStyle as fd, patchTextStyle as fe, pixelLayerBounds as ff, pixelLayers as fg, placeContents as fh, placeLayer as fi, placementAt as fj, placementBounds as fk, placementGeometry as fl, polygonCoverage as fm, polygonSelection as fn, presetWarp as fo, previewStep as fp, profileBytes as fq, projectImagePoint as fr, projectImageRect as fs, projectMaskCoverage as ft, psdToLayers as fu, rasterContents as fv, rasterizeSmartObject as fw, readPsd as fx, rectSelection as fy, referencePoint as fz, ImageEditorController as g, selectionArea as g0, selectionFromCoverage as g1, selectionFromPixels as g2, selectionToCoverage as g3, selectionToPixels as g4, selectionValueAt as g5, serializeColorMode as g6, serializeColorProfile as g7, serializeContents as g8, serializeEffects as g9, toTextSpace as gA, toneRange as gB, transformHomography as gC, transformMap as gD, transformShapeComponents as gE, transformTypeLayer as gF, transformedBox as gG, transformedPoint as gH, typeAsPixelLayer as gI, typeFrame as gJ, typeFromAnnotation as gK, typeLayerName as gL, ungroupLayer as gM, unionRect as gN, unprojectCanvasPoint as gO, updateLayerEffect as gP, updateLayerFilter as gQ, updateLayerMaskProps as gR, updateShapeLayer as gS, updateSmartFilter as gT, updateTypeLayer as gU, withFilterMaskSurface as gV, withNewIds as gW, writePsd as gX, serializeLayer as ga, serializeLayers as gb, serializeLayersExternal as gc, serializePatterns as gd, serializeSelection as ge, setLayerEffects as gf, setLayerEffectsEnabled as gg, setLayerMask as gh, setLayerProperties as gi, setSmartFilterMask as gj, setSmartFiltersEnabled as gk, setSmartPlacement as gl, shapeAsPixelLayer as gm, shapeFromAnnotation as gn, shapeGeometryBounds as go, shapeLayers as gp, shapeOutline as gq, shapeRenderClip as gr, shiftCoverage as gs, smartObjectLayers as gt, smoothCoverage as gu, srgb8ToLab as gv, textMatrix as gw, textOutlines as gx, textRange as gy, toHex as gz, type SelectionMask as h, type SelectionMode as i, type ColorDistance as j, type ImagePoint as k, type ImageLayer as l, type CropBox as m, type RasterMask as n, type Annotation as o, type AdjustmentLayerNode as p, type AnnotationLayer as q, type ShapeLayer as r, type TypeLayer as s, type LayerFilter as t, type PixelLayer as u, type DevelopFilter as v, type ImageTransform as w, type ImageHistogram as x, type ImageProjection as y, type CompositorSources as z };