@pixerate/editor 0.114.0 → 0.116.0

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

@@ -1,17 +1,18 @@
 import { a1 as RasterLayer, a0 as RasterGroupLayer, a5 as RasterPixelLayer, C as CompositorLayer, a as RasterCompositor, R as RasterSources, U as LayerLocks } from '../render-CrmHOgpo.js';
-import { B as BrushSettings, M as MixerSettings, a as MixingModel, b as BlenderSettings, S as SmudgeSettings, C as CoverageMap, D as Dab, c as StrokePoint, d as MixerLoad, P as PaintTileTarget, R as RgbTriple } from '../retouch-Do6tBs2H.js';
-export { e as MAX_BRUSH_SIZE } from '../retouch-Do6tBs2H.js';
+import { D as Dab, C as CoverageMap, B as BrushSettings, e as StrokePoint, P as PaintTileTarget, T as TileMedium, M as MixerSettings, h as MixingModel, i as BlenderSettings, j as SmudgeSettings, a as MixerLoad, W as WetWorld, k as WetTilt, l as WetParams, m as WetFlowSpec, n as RgbTriple, o as WetWorldOptions, p as WetBackendInfo, q as WetSnapshot, r as WetPaperInput } from '../flow-BMtHAmg4.js';
+export { s as DEFAULT_FLOW, t as DEFAULT_WET_PARAMS, u as MAX_BRUSH_SIZE, v as WET_FLOW_KINDS, w as WET_PARAM_KEYS, x as WetFlowKind, y as WetSupport, z as normalizeFlow, A as normalizeWetParams, E as wetSupport } from '../flow-BMtHAmg4.js';
 import { R as RasterRect, j as TiledSurface, a as BlendMode, b as BlendModeInfo } from '../surface-Cn30xIV6.js';
 export { B as BLEND_MODES, P as PAINTERLY_BLEND_MODES, h as Tile, v as isBlendMode, w as isPainterlyBlendMode, I as standardBlendMode } from '../surface-Cn30xIV6.js';
-import { I as ImageEditorAssetStore, S as SerializedLayer, P as PsdExportResult } from '../export-_1dUKwpF.js';
+import { I as ImageEditorAssetStore, S as SerializedLayer, P as PsdExportResult } from '../export-Dm44YUvS.js';
+import { V as VideoProject, A as VideoFfmpegExport } from '../export-Dv0-ZVrV.js';
 import { g as PresenceStore, e as PresenceClock, d as PresenceActorInfo, c as PresenceActor, f as PresenceState } from '../presence-Cb6WhcrQ.js';
-import { a as AgentToolProvider } from '../registry-D-4fit9C.js';
+import { a as AgentToolProvider, A as AgentTool } from '../registry-D-4fit9C.js';
 import '../types-CwMPoRMU.js';
 import '../builtin-CY97ppKM.js';
 import '../bezier-DYBvLgUH.js';
 import '../types-BFkYA4eF.js';
 import '../warp-DMN30aY6.js';
-import '../types-1SUQKDAw.js';
+import '../types-CDLGhAZp.js';
 import '../schema-Di0CS6Pe.js';
 
 /**
@@ -92,6 +93,8 @@ interface PaperSettings {
     permeability: number;
     /** Wet media: how much the grain catches pigment, 0..1. */
     roughness: number;
+    /** Metallic paper (gold or silver leaf, pearlescent card): the grain catches the light, 0..1 (default 0). */
+    metallic?: number;
 }
 /** Side of the generated grain tile in pixels (at scale 1). */
 declare const GRAIN_TILE = 256;
@@ -142,7 +145,365 @@ declare function renderPaper(paper: PaperSettings, rect: {
     y: number;
     width: number;
     height: number;
-}, grain?: PaperGrain): Uint8ClampedArray;
+}, grain?: PaperGrain, light?: {
+    azimuth: number;
+    elevation: number;
+}): Uint8ClampedArray;
+
+/**
+ * The paint editor's dry-media stroke engine, on the shared brush engine (`@pixerate/editor/paint`):
+ *
+ * - Pen input: pressure, tilt (`tiltX` / `tiltY` or `altitude` / `azimuth`), barrel rotation
+ *   (`twist`) and time (for velocity). Position and pressure are smoothed separately.
+ * - `PenDabWalker` walks the points into the shared `Dab`s at `spacing × diameter`, with every
+ *   pen channel interpolated, and applies the brush's dynamics, rotation mode and jitter.
+ *   Jitter is a pure hash of the stroke seed and the dab index, so a stroke replays exactly.
+ * - `DryStroke` rasterizes each dab with the shared round tip, multiplies it by how much of it the
+ *   paper grain catches (`grainCatch`), and builds it up in the shared `CoverageMap`; the session
+ *   then composites the coverage with the shared `applyStrokeToTile`.
+ * - Symmetry: one stroke can paint several copies of its points (mirror and kaleidoscope), each
+ *   with its own walker, into the same coverage, so the copies are one stroke and one undo step.
+ *
+ * Pure data in, pixels out: no DOM, no framework.
+ */
+
+/** One pen sample in document pixels. Every channel but x and y is optional. */
+interface PenPoint {
+    x: number;
+    y: number;
+    /** 0..1 (missing: 1, a mouse). */
+    pressure?: number;
+    /** Milliseconds since any fixed origin (for velocity; missing: no velocity dynamics). */
+    t?: number;
+    /** Pointer Events tilt in degrees, -90..90 (used when `altitude` / `azimuth` are missing). */
+    tiltX?: number;
+    tiltY?: number;
+    /** Radians from the surface: π/2 is upright, 0 lies flat. */
+    altitude?: number;
+    /** Radians clockwise from the +x axis (screen y points down): where the pen leans. */
+    azimuth?: number;
+    /** Barrel rotation in degrees clockwise, 0..359. */
+    twist?: number;
+}
+/** A pen's lean as altitude and azimuth, or `null` when the sample has no tilt. */
+declare function penOrientation(p: PenPoint): {
+    altitude: number;
+    azimuth: number;
+} | null;
+/** Pointer Events `tiltX` / `tiltY` (degrees) → altitude and azimuth (radians). */
+declare function tiltToOrientation(tiltX: number, tiltY: number): {
+    altitude: number;
+    azimuth: number;
+};
+/**
+ * Exponential smoothing of position and of pressure, each by its own amount (0..0.95). Feed raw
+ * samples; the first sample passes through.
+ */
+declare class PenSmoother {
+    private pos;
+    private pressure;
+    private readonly a;
+    private readonly ap;
+    constructor(position: number, pressure: number);
+    push(p: PenPoint): PenPoint;
+    /** Where the smoothed position is now (or `null` before the first sample). */
+    get position(): {
+        x: number;
+        y: number;
+    } | null;
+}
+/** A linear map of document vectors `[a, b, c, d]`: (x, y) → (a·x + b·y, c·x + d·y). */
+type Linear2 = readonly [number, number, number, number];
+/** How one copy of a stroke maps the input: a point map and its linear part (for dab angles). */
+interface StrokeCopy {
+    map(p: PenPoint): PenPoint;
+    linear: Linear2;
+}
+declare const IDENTITY_COPY: StrokeCopy;
+/** A dab with the pen state it was made at (the shared `Dab` plus pressure for the grain). */
+interface PenDab extends Dab {
+    pressure: number;
+    /** Direction of travel at the dab, radians counter-clockwise with y up (as `angle`). */
+    direction: number;
+    /** The dab's index within its copy of the stroke (0, 1, 2 …). */
+    index: number;
+}
+/**
+ * Walks pen samples into dabs, incrementally (any chunking gives the same dabs). Dab angles are in
+ * the shared rasterizer's convention: radians, counter-clockwise with y up.
+ */
+declare class PenDabWalker {
+    readonly brush: PaintBrush;
+    private readonly seed;
+    private readonly linear;
+    private last;
+    private nextAt;
+    private pendingFirst;
+    private index;
+    private dir;
+    private lastT;
+    private speed;
+    constructor(brush: PaintBrush, seed?: number, linear?: Linear2);
+    private sample;
+    private diameter;
+    private stepLen;
+    /** A rasterizer angle (CCW, y up) mapped through this copy's linear part. */
+    private mapAngle;
+    private dab;
+    push(p: PenPoint, out: PenDab[]): void;
+    finish(out: PenDab[]): void;
+}
+interface DryStrokeOptions {
+    /** The paper's dry height field, or `null` for no grain. */
+    grain: PaperGrain | null;
+    /** The paper's grain depth, 0..1 (multiplied by the brush's grain response). */
+    paperDepth: number;
+    /** Jitter seed (record it to replay the stroke exactly). */
+    seed?: number;
+    /** Copies of the stroke (symmetry); default one identity copy. */
+    copies?: readonly StrokeCopy[];
+}
+/**
+ * One dab-engine stroke (dab and eraser brushes): smoothing, the dab walk of every copy, grain and
+ * build-up in a shared coverage map.
+ */
+declare class DryStroke {
+    readonly brush: PaintBrush;
+    private readonly options;
+    readonly coverage: CoverageMap;
+    dabCount: number;
+    private readonly smoother;
+    private readonly walkers;
+    private readonly copies;
+    private readonly depth;
+    private buf;
+    private lastRaw;
+    private lastFed;
+    constructor(brush: PaintBrush, options: DryStrokeOptions);
+    /** Feeds raw pen samples; returns the document rectangles the new dabs touched. */
+    push(points: readonly PenPoint[]): RasterRect[];
+    /** Ends the stroke: the smoothed path catches up with the last raw sample; a single tap paints one dab. */
+    finish(): RasterRect[];
+    private paint;
+}
+/** The shared engine's tip for the Mixer Brush engine (it smooths and walks by itself, so smoothing is applied before). */
+declare function mixerTip(brush: PaintBrush): BrushSettings;
+/** Pen samples → the shared engine's stroke points (pressure only). */
+declare function toStrokePoint(p: PenPoint): StrokePoint;
+
+/**
+ * Stickers: textured stamps sprayed along a stroke onto a sticker layer, where each stays an object
+ * that can be moved, turned, resized, recoloured or deleted afterwards. A sticker layer is a pixel
+ * layer whose pixels are drawn from its stickers (`renderStickers`), so the compositor, exports and
+ * every layer operation see ordinary pixels.
+ *
+ * The stamps are our own procedural shapes (dot, star, heart, leaf, petal flower, confetti, splat,
+ * sparkle, ring), each with a little shading and a seeded paper-like texture, so no artwork is
+ * bundled. The spray (`StickerSpray`) is deterministic: the same points, seed and brush give the
+ * same stickers.
+ */
+
+type StampKind = 'dot' | 'star' | 'heart' | 'leaf' | 'flower' | 'confetti' | 'splat' | 'sparkle' | 'ring';
+declare const STAMP_KINDS: readonly StampKind[];
+/** One sticker (document pixels). */
+interface Sticker {
+    id: string;
+    stamp: StampKind;
+    x: number;
+    y: number;
+    /** Diameter in pixels. */
+    size: number;
+    /** Degrees clockwise. */
+    rotation: number;
+    /** #rrggbb */
+    color: string;
+    /** 0..1 */
+    opacity: number;
+    /** Texture seed. */
+    seed: number;
+}
+/** Sticker spray settings (each 0..1 unless noted). */
+interface StickerSettings {
+    /** The stamps to spray (picked at random per sticker). */
+    stamps: StampKind[];
+    /** Stickers per tip diameter of travel. */
+    density: number;
+    /** Random size change. */
+    sizeJitter: number;
+    /** Random turn, as a fraction of ±180°. */
+    rotationJitter: number;
+    /** How far from the path stickers land, in tip diameters (0..2). */
+    scatter: number;
+    /** Random colour change (hue and lightness). */
+    colorJitter: number;
+}
+declare const DEFAULT_STICKER: Readonly<StickerSettings>;
+declare function normalizeStickerSettings(raw?: Partial<StickerSettings>, base?: StickerSettings): StickerSettings;
+/**
+ * Coverage of a stamp at a point (u, v) of its unit square (−1..1, y down), 0..1, before shading.
+ * `t` is the sticker's seed for shapes with random parts (splat, confetti).
+ */
+declare function stampCoverage(kind: StampKind, u: number, v: number, t: number): number;
+/** The pixel rectangle a sticker covers. */
+declare function stickerRect(s: Sticker): RasterRect;
+/**
+ * Draws one sticker through a `TileMedium` (straight source-over): the stamp's coverage, lit a
+ * little from the top left and given a fine seeded texture, in its colour and opacity.
+ */
+declare function drawSticker(medium: TileMedium, s: Sticker): RasterRect;
+interface StickerSprayInit {
+    brush: PaintBrush;
+    target: PaintTileTarget;
+    /** The paint colour #rrggbb. */
+    color: string;
+    seed: number;
+    copies: readonly StrokeCopy[];
+    /** The next sticker number on the layer (ids `st<n>`). */
+    nextId: number;
+}
+/** A sticker-spray stroke: drops stickers along the path and draws them as it goes. */
+declare class StickerSpray {
+    readonly init: StickerSprayInit;
+    dabCount: number;
+    readonly stickers: Sticker[];
+    private readonly smoother;
+    private readonly walkers;
+    private readonly copies;
+    private readonly medium;
+    private lastRaw;
+    private lastFed;
+    private next;
+    constructor(init: StickerSprayInit);
+    push(points: readonly PenPoint[]): RasterRect[];
+    finish(): RasterRect[];
+    private drop;
+}
+/** A sticker list rendered over a transparent layer, through a tile target. */
+declare function renderStickers(stickers: readonly Sticker[], target: PaintTileTarget): void;
+/** Checks and rounds a sticker change; throws a sentence naming the bad field. */
+declare function normalizeStickerUpdate(u: Partial<Omit<Sticker, 'id'>>): Partial<Omit<Sticker, 'id'>>;
+/** A sticker layer's pixels: its stickers drawn bottom first over a transparent layer. */
+declare function stickerSurface(stickers: readonly Sticker[]): TiledSurface;
+
+/**
+ * Procedural brush engines: marks made by small simulations driven by the pen, rather than by
+ * stamping the tip.
+ *
+ * - **Particle brushes** (`engine: 'particle'`): a handful of particles follow the pen by their own
+ *   rules. `string`: strands of masses on springs, dragged behind the pen like hair or wet string;
+ *   `spring`: each particle tied to the pen by a spring, overshooting and wobbling; `orbit`:
+ *   particles circling the pen (spirograph curls); `flow`: particles thrown off the pen and carried
+ *   by a swirling flow field until they fade. Each is drawn as `dot`s, a continuous `line`, or a
+ *   `sequence` of beads spaced along its path.
+ * - **Bristle brushes** (`engine: 'bristle'`): a tuft of bristles, each its own thin line. Pressure
+ *   splays the tuft, tilt flattens it, and bristles lag behind the tip by their stiffness, so they
+ *   bend into curves at turns; each bristle carries its own paint and runs dry at its own pace, so
+ *   long strokes break into dry-brush streaks.
+ *
+ * Both are deterministic (seeded) and step the simulation by distance travelled, not by how the
+ * input was sampled, so a replay paints the same marks. They build up a `CoverageMap` like the dab
+ * engine, so opacity, blend modes, locks, stencils and symmetry work as for any dry brush.
+ */
+
+interface ProceduralStrokeOptions {
+    grain: PaperGrain | null;
+    paperDepth: number;
+    seed?: number;
+    copies?: readonly StrokeCopy[];
+}
+/** What a coverage-building stroke engine provides to the stroke session. */
+interface CoverageStroke {
+    readonly coverage: CoverageMap;
+    dabCount: number;
+    push(points: readonly PenPoint[]): RasterRect[];
+    finish(): RasterRect[];
+}
+/** Shared plumbing: smoothing, the dab walk per copy (for size, pressure, direction), grain, and stamping marks. */
+declare abstract class MarkStroke implements CoverageStroke {
+    readonly brush: PaintBrush;
+    protected readonly options: ProceduralStrokeOptions;
+    readonly coverage: CoverageMap;
+    dabCount: number;
+    protected readonly smoother: PenSmoother;
+    protected readonly copies: readonly StrokeCopy[];
+    protected readonly walkers: PenDabWalker[];
+    protected readonly depth: number;
+    private buf;
+    private lastRaw;
+    private lastFed;
+    protected readonly seed: number;
+    constructor(brush: PaintBrush, options: ProceduralStrokeOptions);
+    push(points: readonly PenPoint[]): RasterRect[];
+    finish(): RasterRect[];
+    /** One simulation step of copy `copy` with the pen at dab `d`. */
+    protected abstract advance(copy: number, d: PenDab, rects: RasterRect[]): void;
+    /** Stamps one round mark of radius `r` at (x, y) with flow `alpha` towards `opacity`. */
+    protected mark(x: number, y: number, r: number, alpha: number, opacity: number, pressure: number, rects: RasterRect[]): void;
+    /** Marks along a segment, spaced by a fraction of the radius. */
+    protected segment(x0: number, y0: number, x1: number, y1: number, r: number, alpha: number, opacity: number, pressure: number, rects: RasterRect[]): void;
+}
+type ParticleKind = 'string' | 'spring' | 'orbit' | 'flow';
+declare const PARTICLE_KINDS: readonly ParticleKind[];
+type ParticleRender = 'dot' | 'line' | 'sequence';
+declare const PARTICLE_RENDERS: readonly ParticleRender[];
+/** Particle engine settings (each 0..1 unless noted). */
+interface ParticleSettings {
+    kind: ParticleKind;
+    render: ParticleRender;
+    /** Particles, 1..64. */
+    count: number;
+    /** Mark size as a fraction of the tip size. */
+    size: number;
+    /** How far apart the particles start, as a fraction of the tip size. */
+    spread: number;
+    /** Spring and string stiffness (stiff follows closely; soft swings wide). */
+    stiffness: number;
+    /** How quickly motion dies down. */
+    damping: number;
+    /** Orbit and flow speed. */
+    speed: number;
+    /** Pull downwards (−1 up .. 1 down). */
+    gravity: number;
+    /** Flow particles' lifetime. */
+    life: number;
+    /** Sequence: spacing of the beads along each path. */
+    interval: number;
+}
+declare const DEFAULT_PARTICLE: Readonly<ParticleSettings>;
+declare function normalizeParticle(raw?: Partial<ParticleSettings>, base?: ParticleSettings): ParticleSettings;
+/** A particle-brush stroke. */
+declare class ParticleStroke extends MarkStroke {
+    private readonly sets;
+    private readonly s;
+    private spawn;
+    constructor(brush: PaintBrush, options: ProceduralStrokeOptions);
+    private init;
+    protected advance(copy: number, d: PenDab, rects: RasterRect[]): void;
+}
+/** Bristle engine settings (each 0..1 unless noted). */
+interface BristleSettings {
+    /** Bristles in the tuft, 3..128. */
+    count: number;
+    /** Stiff bristles follow the tip; soft ones lag and bend into curves at turns. */
+    stiffness: number;
+    /** How far pressure spreads the tuft. */
+    splay: number;
+    /** Width of each bristle's line as a fraction of the tip size. */
+    thickness: number;
+    /** Paint per bristle: 1 never runs dry; lower, bristles run out along the stroke (dry brush). */
+    load: number;
+    /** Random variation between bristles (length, paint, position). */
+    jitter: number;
+}
+declare const DEFAULT_BRISTLE: Readonly<BristleSettings>;
+declare function normalizeBristle(raw?: Partial<BristleSettings>, base?: BristleSettings): BristleSettings;
+/** A bristle-brush stroke: every bristle draws its own line. */
+declare class BristleStroke extends MarkStroke {
+    private readonly tufts;
+    private readonly s;
+    constructor(brush: PaintBrush, options: ProceduralStrokeOptions);
+    protected advance(copy: number, d: PenDab, rects: RasterRect[]): void;
+}
 
 /**
  * Paint editor brushes: the shared engine's tip settings (`@pixerate/editor/paint`) plus what a
@@ -156,10 +517,74 @@ declare function renderPaper(paper: PaperSettings, rect: {
  * mix exchange when its behaviour asks for it), `eraser` (removes alpha), `mixer` (the Mixer
  * Brush), `blender` (mixes the colours under and near the tip) or `smudge` (drags paint along).
  */
-type PaintBrushEngine = 'dab' | 'eraser' | 'mixer' | 'blender' | 'smudge';
+type PaintBrushEngine = 'dab' | 'eraser' | 'mixer' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker';
 declare const PAINT_BRUSH_ENGINES: readonly PaintBrushEngine[];
-type PaintBrushCategory = 'pencil' | 'pastel' | 'charcoal' | 'airbrush' | 'marker' | 'ink' | 'paint' | 'eraser' | 'blender' | 'smudge' | 'mixer' | 'custom';
+type PaintBrushCategory = 'pencil' | 'pastel' | 'charcoal' | 'airbrush' | 'marker' | 'ink' | 'paint' | 'eraser' | 'blender' | 'smudge' | 'mixer' | 'watercolor' | 'wet-tool' | 'oil' | 'impasto' | 'procedural' | 'bristle' | 'sticker' | 'custom';
 declare const PAINT_BRUSH_CATEGORIES: readonly PaintBrushCategory[];
+/**
+ * What a wet brush does to the wet layer: `paint` (water and pigment), `water` (clear water;
+ * with `rewet` it lifts dried paint), `dry` (a hair dryer: takes water, the pigment settles),
+ * `blow` (pushes the water along the stroke), `blend` (evens out the wet pigment under the tip),
+ * `smudge` (drags wet paint along) or `blot` (a tissue: takes up wet paint).
+ */
+type WetTool = 'paint' | 'water' | 'dry' | 'blow' | 'blend' | 'smudge' | 'blot';
+declare const WET_TOOLS: readonly WetTool[];
+/**
+ * The wet medium a wet brush paints: its layer takes the medium's wet settings the first time it
+ * holds wet paint (`watercolor`: runny, dries in seconds, granulates and darkens at edges;
+ * `gouache`: opaque, flatter; `oil`: thick, barely flows, stays wet for a long time and blends into
+ * the wet paint it meets).
+ */
+type WetMediumKind = 'watercolor' | 'gouache' | 'oil';
+declare const WET_MEDIA: readonly WetMediumKind[];
+/** Wet engine settings, each 0..1. */
+interface WetBrushSettings {
+    tool: WetTool;
+    /** Water the brush lays down (wetness): 0.2 a damp brush, 1 a dripping one. */
+    water: number;
+    /** Pigment concentration: 0 clear water .. 1 paint straight from the tube. */
+    pigment: number;
+    /** Body: 0 a transparent watercolour .. 1 opaque gouache that hides what is under it. */
+    body: number;
+    /** Strength of the dry, blow, blend, smudge and blot tools. */
+    strength: number;
+    /** How much dried paint the water lifts again (re-wetting): 0 none (staining) .. 1. */
+    rewet: number;
+    /** The medium (its layer's wet settings the first time it holds wet paint). */
+    medium: WetMediumKind;
+    /** Paint loading: 1 never runs out; lower, the brush runs dry along a long stroke (reload each stroke). */
+    load: number;
+    /** Thinner (water for watercolour, solvent for oil): thins the paint, so it is more transparent and runnier. */
+    thinner: number;
+}
+declare const DEFAULT_WET_BRUSH: Readonly<WetBrushSettings>;
+declare function normalizeWetBrush(raw?: Partial<WetBrushSettings>, base?: WetBrushSettings): WetBrushSettings;
+/**
+ * What an impasto brush does on a thick-paint layer: `brush` (paint with body: colour and relief),
+ * `tube` (squeezes blobs of paint straight from the tube), `knife` (a palette knife: scrapes the
+ * relief flat and smears the paint along), `roller` (a flat, even band with a stipple), `gloop`
+ * (a thick, glossy, rounded line).
+ */
+type ImpastoTool = 'brush' | 'tube' | 'knife' | 'roller' | 'gloop';
+declare const IMPASTO_TOOLS: readonly ImpastoTool[];
+/** Impasto engine settings, each 0..1. */
+interface ImpastoSettings {
+    tool: ImpastoTool;
+    /** How thick the paint stands up (relief per stroke). */
+    thickness: number;
+    /** Shine of the paint when lit (0 matte .. 1 wet-looking gloss). */
+    gloss: number;
+    /** Metallic paint: highlights take the paint's colour (gold, copper, silver). */
+    metallic: number;
+    /** Paint loading: 1 never runs out; lower, the stroke thins and fades as the brush empties. */
+    load: number;
+    /** Thinner: flatter, more transparent paint that levels out. */
+    thinner: number;
+    /** Knife and brush: how much of the paint under the tool is dragged along (0..1). */
+    drag: number;
+}
+declare const DEFAULT_IMPASTO: Readonly<ImpastoSettings>;
+declare function normalizeImpasto(raw?: Partial<ImpastoSettings>, base?: ImpastoSettings): ImpastoSettings;
 /** Multi-coloured brush: `tip` lays the colours across the tip, `dab` changes colour from dab to dab. */
 type MultiColorMode = 'off' | 'tip' | 'dab';
 declare const MULTI_COLOR_MODES: readonly MultiColorMode[];
@@ -247,6 +672,16 @@ interface PaintBrush {
     blender: BlenderSettings;
     /** Smudge engine only: strength, length and mixing. */
     smudge: SmudgeSettings;
+    /** Wet engine only: the wet tool, water, pigment, body and strength. */
+    wet: WetBrushSettings;
+    /** Impasto engine only: the tool, thickness, gloss, metallic, loading, thinner and drag. */
+    impasto: ImpastoSettings;
+    /** Particle engine only: the particles' kind, how they are drawn, and their physics. */
+    particle: ParticleSettings;
+    /** Bristle engine only: the tuft. */
+    bristle: BristleSettings;
+    /** Sticker engine only: the stamps and how they are sprayed. */
+    sticker: StickerSettings;
     /** True for the built-in presets (they cannot be removed or overwritten). */
     builtin?: boolean;
 }
@@ -259,16 +694,23 @@ type BrushBehaviorInput = Partial<Omit<BrushBehavior, 'multicolor'>> & {
 };
 declare function normalizeBehavior(raw?: BrushBehaviorInput, base?: BrushBehavior): BrushBehavior;
 /** Brush settings to change or read: any subset of a brush and of its blocks. */
-type PaintBrushInput = Partial<Omit<PaintBrush, 'tip' | 'dynamics' | 'mixer' | 'behavior' | 'blender' | 'smudge'>> & {
+type PaintBrushInput = Partial<Omit<PaintBrush, 'tip' | 'dynamics' | 'mixer' | 'behavior' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker'>> & {
     tip?: Partial<BrushSettings>;
     dynamics?: Partial<BrushDynamics>;
     mixer?: Partial<MixerSettings>;
     behavior?: BrushBehaviorInput;
     blender?: Partial<BlenderSettings>;
     smudge?: Partial<SmudgeSettings>;
+    wet?: Partial<WetBrushSettings>;
+    impasto?: Partial<ImpastoSettings>;
+    particle?: Partial<ParticleSettings>;
+    bristle?: Partial<BristleSettings>;
+    sticker?: Partial<StickerSettings>;
 };
-/** Whether a brush can pick paint up from the canvas (the pick-up / mix ratios apply): dab and mixer brushes. */
+/** Whether a brush can pick paint up from the canvas (the pick-up / mix ratios apply): dab, mixer and wet brushes. */
 declare function isWetCapable(brush: Pick<PaintBrush, 'engine'>): boolean;
+/** Whether a brush paints wet media (on the layer's wet layer). */
+declare function isWetBrush(brush: Pick<PaintBrush, 'engine'>): boolean;
 /**
  * Whether a dab brush paints dab by dab through the exchange (it picks up paint or is
  * multi-coloured) instead of building one coverage buffer of one colour.
@@ -295,145 +737,207 @@ interface BrushLibraryFile {
 declare function parseBrushLibrary(raw: unknown, problems?: string[]): PaintBrush[];
 
 /**
- * The paint editor's dry-media stroke engine, on the shared brush engine (`@pixerate/editor/paint`):
- *
- * - Pen input: pressure, tilt (`tiltX` / `tiltY` or `altitude` / `azimuth`), barrel rotation
- *   (`twist`) and time (for velocity). Position and pressure are smoothed separately.
- * - `PenDabWalker` walks the points into the shared `Dab`s at `spacing × diameter`, with every
- *   pen channel interpolated, and applies the brush's dynamics, rotation mode and jitter.
- *   Jitter is a pure hash of the stroke seed and the dab index, so a stroke replays exactly.
- * - `DryStroke` rasterizes each dab with the shared round tip, multiplies it by how much of it the
- *   paper grain catches (`grainCatch`), and builds it up in the shared `CoverageMap`; the session
- *   then composites the coverage with the shared `applyStrokeToTile`.
- * - Symmetry: one stroke can paint several copies of its points (mirror and kaleidoscope), each
- *   with its own walker, into the same coverage, so the copies are one stroke and one undo step.
- *
- * Pure data in, pixels out: no DOM, no framework.
+ * Painting guides: mirror and kaleidoscope symmetry (every stroke paints its reflected or rotated
+ * copies as one stroke), perspective guides with one to three vanishing points that strokes snap
+ * to, a tracing image under the paint (optionally the source of the stroke colour), and floating
+ * reference images to pick colours from. Geometry only: no pixels, no DOM.
  */
 
-/** One pen sample in document pixels. Every channel but x and y is optional. */
-interface PenPoint {
+type SymmetryMode = 'off' | 'vertical' | 'horizontal' | 'dual' | 'diagonal' | 'kaleidoscope';
+declare const SYMMETRY_MODES: readonly SymmetryMode[];
+interface SymmetryGuide {
+    mode: SymmetryMode;
+    /** Centre of the axes in document pixels (default the canvas centre). */
+    center: {
+        x: number;
+        y: number;
+    };
+    /** Turns the axes, degrees clockwise (default 0). */
+    rotation: number;
+    /** Kaleidoscope: number of segments, 2..32 (default 6). */
+    segments: number;
+    /** Kaleidoscope: reflect every other segment as well as rotating (default true), like a real kaleidoscope. */
+    mirror: boolean;
+}
+interface Point2 {
     x: number;
     y: number;
-    /** 0..1 (missing: 1, a mouse). */
-    pressure?: number;
-    /** Milliseconds since any fixed origin (for velocity; missing: no velocity dynamics). */
-    t?: number;
-    /** Pointer Events tilt in degrees, -90..90 (used when `altitude` / `azimuth` are missing). */
-    tiltX?: number;
-    tiltY?: number;
-    /** Radians from the surface: π/2 is upright, 0 lies flat. */
-    altitude?: number;
-    /** Radians clockwise from the +x axis (screen y points down): where the pen leans. */
-    azimuth?: number;
-    /** Barrel rotation in degrees clockwise, 0..359. */
-    twist?: number;
 }
-/** A pen's lean as altitude and azimuth, or `null` when the sample has no tilt. */
-declare function penOrientation(p: PenPoint): {
-    altitude: number;
-    azimuth: number;
-} | null;
-/** Pointer Events `tiltX` / `tiltY` (degrees) → altitude and azimuth (radians). */
-declare function tiltToOrientation(tiltX: number, tiltY: number): {
-    altitude: number;
-    azimuth: number;
-};
-/**
- * Exponential smoothing of position and of pressure, each by its own amount (0..0.95). Feed raw
- * samples; the first sample passes through.
- */
-declare class PenSmoother {
-    private pos;
-    private pressure;
-    private readonly a;
-    private readonly ap;
-    constructor(position: number, pressure: number);
-    push(p: PenPoint): PenPoint;
-    /** Where the smoothed position is now (or `null` before the first sample). */
-    get position(): {
+interface PerspectiveGuide {
+    enabled: boolean;
+    /** One to three vanishing points in document pixels (they may lie outside the canvas). */
+    points: Point2[];
+    /** Strokes snap to the guide lines (default true when enabled). */
+    snap: boolean;
+}
+/** A view-only image under the paint, placed over the canvas. */
+interface TracingImage {
+    /** PNG or JPEG data URL. */
+    src: string;
+    /** Natural size of the image in pixels. */
+    width: number;
+    height: number;
+    /** Where it is drawn, in document pixels (default: fitted to the canvas). */
+    rect: {
         x: number;
         y: number;
-    } | null;
+        width: number;
+        height: number;
+    };
+    /** 0..1 (default 0.35). */
+    opacity: number;
+    visible: boolean;
+    /** Strokes without an explicit colour take the tracing image's colour where they start. */
+    sampleColors: boolean;
 }
-/** A linear map of document vectors `[a, b, c, d]`: (x, y) → (a·x + b·y, c·x + d·y). */
-type Linear2 = readonly [number, number, number, number];
-/** How one copy of a stroke maps the input: a point map and its linear part (for dab angles). */
-interface StrokeCopy {
-    map(p: PenPoint): PenPoint;
-    linear: Linear2;
+/** A floating image to look at and pick colours from (shown beside the canvas, never painted). */
+interface ReferenceImage {
+    id: string;
+    name: string;
+    src: string;
+    width: number;
+    height: number;
+    /** Where the panel floats over the viewport, in screen pixels, and its displayed width. */
+    x: number;
+    y: number;
+    displayWidth: number;
+    visible: boolean;
 }
-declare const IDENTITY_COPY: StrokeCopy;
-/** A dab with the pen state it was made at (the shared `Dab` plus pressure for the grain). */
-interface PenDab extends Dab {
-    pressure: number;
-    /** Direction of travel at the dab, radians counter-clockwise with y up (as `angle`). */
-    direction: number;
-    /** The dab's index within its copy of the stroke (0, 1, 2 …). */
-    index: number;
+interface PaintGuides {
+    symmetry: SymmetryGuide;
+    perspective: PerspectiveGuide;
+    tracing: TracingImage | null;
+    references: ReferenceImage[];
+    /** Rulers, arcs, straight edges and shape templates that guide or mask strokes. */
+    stencils: Stencil[];
 }
+declare function defaultGuides(canvas: {
+    width: number;
+    height: number;
+}): PaintGuides;
+declare const MAX_COORDINATE = 1000000;
+declare function normalizeSymmetry(raw: Partial<SymmetryGuide> | Record<string, unknown>, base: SymmetryGuide): SymmetryGuide;
+/** The axis directions of a mirror mode (radians), as photocraft's `directions`. */
+declare function symmetryAxisAngles(g: SymmetryGuide): number[];
 /**
- * Walks pen samples into dabs, incrementally (any chunking gives the same dabs). Dab angles are in
- * the shared rasterizer's convention: radians, counter-clockwise with y up.
+ * The extra copies a stroke paints under the symmetry guide, as affine maps (the stroke itself is
+ * not included). Vertical, horizontal and diagonal: one reflection. Dual: two reflections and the
+ * point reflection. Kaleidoscope: rotations by 360°/n, and with `mirror` the reflections between them.
  */
-declare class PenDabWalker {
-    readonly brush: PaintBrush;
-    private readonly seed;
-    private readonly linear;
-    private last;
-    private nextAt;
-    private pendingFirst;
-    private index;
+declare function symmetryCopies(g: SymmetryGuide): Affine[];
+/** The axes clipped to the canvas, for drawing (photocraft's `segments`). */
+declare function symmetryAxisSegments(g: SymmetryGuide, size: {
+    width: number;
+    height: number;
+}): Array<[Point2, Point2]>;
+declare function normalizePerspective(raw: Partial<PerspectiveGuide> | Record<string, unknown>, base: PerspectiveGuide): PerspectiveGuide;
+/** The line families a perspective guide snaps to at `p`: unit directions. */
+declare function perspectiveDirections(g: PerspectiveGuide, p: Point2): Point2[];
+/** How far the pen must move before a stroke chooses its perspective line (document pixels). */
+declare const SNAP_DECIDE_DISTANCE = 6;
+/**
+ * Snaps one stroke to a perspective guide: once the pen has moved `SNAP_DECIDE_DISTANCE` from
+ * where it started, the stroke picks the guide line through its start that best matches its
+ * direction, and every sample after that is projected onto the line.
+ */
+declare class PerspectiveSnapper {
+    private readonly guide;
+    private start;
     private dir;
-    private lastT;
-    private speed;
-    constructor(brush: PaintBrush, seed?: number, linear?: Linear2);
-    private sample;
-    private diameter;
-    private stepLen;
-    /** A rasterizer angle (CCW, y up) mapped through this copy's linear part. */
-    private mapAngle;
-    private dab;
-    push(p: PenPoint, out: PenDab[]): void;
-    finish(out: PenDab[]): void;
+    constructor(guide: PerspectiveGuide);
+    /** The line the stroke follows, once chosen. */
+    get line(): {
+        from: Point2;
+        direction: Point2;
+    } | null;
+    snap<P extends Point2>(p: P): P;
 }
-interface DryStrokeOptions {
-    /** The paper's dry height field, or `null` for no grain. */
-    grain: PaperGrain | null;
-    /** The paper's grain depth, 0..1 (multiplied by the brush's grain response). */
-    paperDepth: number;
-    /** Jitter seed (record it to replay the stroke exactly). */
-    seed?: number;
-    /** Copies of the stroke (symmetry); default one identity copy. */
-    copies?: readonly StrokeCopy[];
+/** Guide lines to draw for a perspective guide: rays from each vanishing point through the canvas. */
+declare function perspectiveGuideLines(g: PerspectiveGuide, size: {
+    width: number;
+    height: number;
+}, count?: number): Array<[Point2, Point2]>;
+
+/**
+ * Stencils: shapes laid on the canvas that guide or mask strokes, like a ruler, a French curve or a
+ * masking template held over the paper.
+ *
+ * - `ruler` (a straight edge) and `arc` (a circle or part of one) **guide**: a stroke that starts
+ *   within `snap` pixels of the edge follows it exactly; one that starts further away is free.
+ * - `line` (a straight edge across the canvas) and `shape` (rectangle, ellipse or polygon)
+ *   **mask**: paint lands only on one side of the line, or only inside the shape (outside with
+ *   `invert`), with an anti-aliased edge. Several masks combine (paint lands where all allow it).
+ * - Any stencil can be switched to the other `mode`: a shape can guide (strokes follow its
+ *   outline) and a ruler can mask (paint on one side of it).
+ *
+ * Geometry only; `stencilMask` makes the canvas coverage the stroke engines read as a selection.
+ */
+
+type StencilKind = 'ruler' | 'arc' | 'line' | 'shape';
+declare const STENCIL_KINDS: readonly StencilKind[];
+type StencilShape = 'rect' | 'ellipse' | 'polygon';
+declare const STENCIL_SHAPES: readonly StencilShape[];
+interface Stencil {
+    id: string;
+    kind: StencilKind;
+    /** `guide`: strokes that start near the edge follow it; `mask`: paint lands only inside (or on one side). */
+    mode: 'guide' | 'mask';
+    /** Shown and in effect (default true). */
+    enabled: boolean;
+    /** ruler / line: two points on the edge (document pixels). */
+    from?: Point2;
+    to?: Point2;
+    /** arc: centre and radius, and the part of the circle in degrees clockwise from +x (default the whole circle). */
+    center?: Point2;
+    radius?: number;
+    startAngle?: number;
+    endAngle?: number;
+    /** shape: its kind and geometry (`rect` for rect and ellipse, `points` for a polygon). */
+    shape?: StencilShape;
+    rect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    points?: Point2[];
+    /** mask: paint outside the shape (or on the other side of the line) instead. */
+    invert: boolean;
+    /** guide: how near the edge (px) a stroke must start to follow it (default 40). */
+    snap: number;
+    /** mask: soft edge width in pixels (default 1, anti-aliased). */
+    feather: number;
 }
+type StencilInput = Partial<Omit<Stencil, 'id'>> & {
+    kind: StencilKind;
+};
+/** A stencil with every field in range; throws a sentence naming what is missing. */
+declare function normalizeStencil(raw: StencilInput, id: string, base?: Stencil): Stencil;
+/** The outline of a stencil as a polyline (document pixels), for drawing and for shape guides. */
+declare function stencilOutline(s: Stencil): Point2[];
 /**
- * One dab-engine stroke (dab and eraser brushes): smoothing, the dab walk of every copy, grain and
- * build-up in a shared coverage map.
+ * Snaps a stroke to the guide stencils: the first point picks the nearest guide within its `snap`
+ * distance (or none), and every point after it is moved onto that guide's edge.
  */
-declare class DryStroke {
-    readonly brush: PaintBrush;
-    private readonly options;
-    readonly coverage: CoverageMap;
-    dabCount: number;
-    private readonly smoother;
-    private readonly walkers;
-    private readonly copies;
-    private readonly depth;
-    private buf;
-    private lastRaw;
-    private lastFed;
-    constructor(brush: PaintBrush, options: DryStrokeOptions);
-    /** Feeds raw pen samples; returns the document rectangles the new dabs touched. */
-    push(points: readonly PenPoint[]): RasterRect[];
-    /** Ends the stroke: the smoothed path catches up with the last raw sample; a single tap paints one dab. */
-    finish(): RasterRect[];
-    private paint;
+declare class StencilSnapper {
+    private readonly stencils;
+    private guide;
+    constructor(stencils: readonly Stencil[]);
+    /** The stencil the stroke follows, once chosen (`null`: none). */
+    get following(): Stencil | null;
+    snap<P extends Point2>(p: P): P;
 }
-/** The shared engine's tip for the Mixer Brush engine (it smooths and walks by itself, so smoothing is applied before). */
-declare function mixerTip(brush: PaintBrush): BrushSettings;
-/** Pen samples → the shared engine's stroke points (pressure only). */
-declare function toStrokePoint(p: PenPoint): StrokePoint;
+/**
+ * The combined coverage of the enabled mask stencils over a `width × height` canvas (0..255 per
+ * pixel), or `null` when no stencil masks.
+ */
+declare function stencilMask(stencils: readonly Stencil[], width: number, height: number): {
+    width: number;
+    height: number;
+    data: Uint8Array;
+} | null;
+/** A stencil scaled about the origin by `k` (for repainting at a larger size). */
+declare function scaleStencil(s: Stencil, k: number): Stencil;
 
 /**
  * Strokes as data. Every committed stroke is recorded with the brush, colour, raw pen samples,
@@ -457,6 +961,10 @@ interface RecordedStroke {
     copies?: Affine[];
     /** What the brush carried at the start (Mixer Brush and wet-capable brushes), so a replay mixes the same. */
     load?: MixerLoad;
+    /** Wet brushes: the wet simulation's clock (steps) at which each point was applied, so a replay lets the paint flow the same. */
+    steps?: number[];
+    /** The mask stencils it was painted through (so a replay keeps to them). */
+    stencils?: Stencil[];
 }
 declare function applyAffine(m: Affine, x: number, y: number): {
     x: number;
@@ -496,13 +1004,339 @@ interface StrokeVariation {
     /** Multiply every pressure by this (default 1). */
     pressureScale?: number;
 }
-/** The affine map of a variation about `origin`. */
-declare function variationAffine(v: StrokeVariation, origin: {
-    x: number;
-    y: number;
-}): Affine;
-/** A stroke varied by `m` (points mapped; symmetry copies conjugated so they stay symmetric). */
-declare function varyStroke(stroke: RecordedStroke, m: Affine, v: StrokeVariation): RecordedStroke;
+/** The affine map of a variation about `origin`. */
+declare function variationAffine(v: StrokeVariation, origin: {
+    x: number;
+    y: number;
+}): Affine;
+/** A stroke varied by `m` (points mapped; symmetry copies conjugated so they stay symmetric). */
+declare function varyStroke(stroke: RecordedStroke, m: Affine, v: StrokeVariation): RecordedStroke;
+
+/**
+ * Wet media in the paint editor (watercolour first): a layer painted with a wet brush gets a wet
+ * layer in the document's `WetWorld` (`@pixerate/editor/paint`), and its pixels are the world's
+ * display of it until the paint dries.
+ *
+ * - **Wet brushes** (`engine: 'wet'`) run through `WetStrokeDriver`: the same pen input as dry
+ *   media (`PenDabWalker`: pressure, tilt, rotation, jitter, symmetry copies), each dab's tip
+ *   coverage (quantised to 1/4096, so tiny floating-point differences between engines never reach
+ *   the simulation) applied by the brush's wet tool. `paint` goes through the shared pick-up / mix
+ *   exchange over a `WetMedium`, so a wet brush lifts and mixes wet paint like the phase 2 brushes.
+ * - **Time** is the world's step clock. The host calls `tick` every frame (the bindings do); it
+ *   steps at `speed` steps per second unless paused. Agents call `advance` or `dry`.
+ * - **Dabs between steps.** Edits only happen between batches: points pushed while a batch runs
+ *   (in Web Workers) wait for it, and every raw point records the clock it was applied at
+ *   (`RecordedStroke.steps`), so a stroke replays exactly.
+ * - **Drying.** Tiles that have dried are baked into the layer's pixels by the world; when a whole
+ *   layer is dry its wet layer is dropped and it is an ordinary pixel layer again. `dry` dries at
+ *   once. Saving and exporting use the deterministic bake of everything still wet ("wet paint is
+ *   dried on save": the document holds dried pixels, never wet state).
+ * - **Undo.** Each wet step of history keeps a snapshot of the world before and after it, within
+ *   `undoMemory` bytes; older snapshots are dropped, and undoing past them leaves that paint dry
+ *   as it looked.
+ */
+
+/** The paper as the wet simulation reads it. */
+declare function wetPaperInput(paper: PaperSettings): WetPaperInput;
+interface WetStrokeInit {
+    world: WetWorld;
+    laneId: string;
+    brush: PaintBrush;
+    /** Paint colour, sRGB 0..1. */
+    color: RgbTriple;
+    load: MixerLoad;
+    grain: PaperGrain | null;
+    paperDepth: number;
+    paperColor: readonly [number, number, number];
+    seed: number;
+    copies: readonly StrokeCopy[];
+    /** Where paint may land (canvas-sized coverage 0..255: the stencils' mask), or none. */
+    mask?: {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+}
+/**
+ * One wet-brush stroke: pen samples → dabs → wet tool edits. Points are applied only while the
+ * world is between batches (`flush` applies the ones that waited).
+ */
+declare class WetStrokeDriver {
+    readonly init: WetStrokeInit;
+    dabCount: number;
+    bounds: RasterRect | null;
+    /** The world's clock at which each raw point was applied (recorded with the stroke). */
+    readonly steps: number[];
+    private readonly smoother;
+    private readonly states;
+    private readonly medium;
+    private readonly queue;
+    private finishing;
+    private finished;
+    private lastRaw;
+    private lastFed;
+    private tip;
+    private cov;
+    private readonly paint;
+    private readonly depth;
+    constructor(init: WetStrokeInit);
+    private readonly copies;
+    /** What copy 0's brush carries after the dabs so far. */
+    get load(): MixerLoad | null;
+    /** Whether every point (and the end) has been applied. */
+    get done(): boolean;
+    /** Adds raw points; applies them now unless a batch is running. Returns where pixels changed. */
+    push(points: readonly PenPoint[]): RasterRect[];
+    /** Asks for the end; it happens now unless a batch is running (then at the next `flush`). */
+    finish(): RasterRect[];
+    /** Applies waiting points (and the end, when asked) if the world is between batches. */
+    flush(): RasterRect[];
+    private applyDabs;
+    /** The tip's coverage over `rect`, with the grain, quantised. */
+    private coverage;
+    private dab;
+}
+/** The wet settings each medium gives a layer the first time it holds wet paint. */
+declare const WET_MEDIUM_PARAMS: Readonly<Record<WetMediumKind, Partial<WetParams>>>;
+/** Settings of one wet layer (saved with the document). */
+interface WetLayerSettings {
+    params: WetParams;
+    flow: WetFlowSpec;
+}
+/** One wet layer as tools describe it. */
+interface WetLayerInfo {
+    layerId: string;
+    /** Surface water anywhere on the layer. */
+    wet: boolean;
+    /** Cells with surface water. */
+    wetCells: number;
+    /** Where the surface water is, or `null`. */
+    wetBounds: RasterRect | null;
+    /** 256 px tiles being simulated. */
+    activeTiles: number;
+    params: WetParams;
+    flow: WetFlowSpec;
+}
+/** An event recorded with the clock it happened at (strokes are recorded separately), for replays. */
+interface WetEvent {
+    clock: number;
+    /** How many strokes were recorded before it (where it falls between strokes in a replay). */
+    at?: number;
+    kind: 'dry' | 'tilt' | 'params' | 'flow' | 'wet-paper';
+    layerId?: string;
+    data?: unknown;
+}
+interface PaintWetHost {
+    canvas(): {
+        width: number;
+        height: number;
+    };
+    paper(): PaperSettings;
+    /** The layer's current pixels (`null` when it is not a pixel layer). */
+    layerSurface(id: string): TiledSurface | null;
+    /** Shows new pixels for wet layers (not an undo step); `rects` are where they changed. */
+    updateSurfaces(surfaces: ReadonlyMap<string, TiledSurface>, rects: RasterRect[]): void;
+    /** The paint dried while time passed (the editor records nothing, it just redraws). */
+    changed(): void;
+}
+interface PaintWetOptions extends WetWorldOptions {
+    /** Steps per second while time runs (default 120). */
+    speed?: number;
+    /** Bytes of wet snapshots kept for undo (default 512 MB). */
+    undoMemory?: number;
+}
+/** The paint editor's wet layers: one `WetWorld` per canvas, its settings and time. */
+declare class PaintWetLayers {
+    private readonly host;
+    private readonly options;
+    world: WetWorld | null;
+    tilt: WetTilt;
+    readonly settings: Map<string, WetLayerSettings>;
+    paused: boolean;
+    /** Wet strokes dry as soon as they end (one undo step with the stroke). */
+    instantDry: boolean;
+    speed: number;
+    overlay: boolean;
+    readonly undoMemory: number;
+    /** The live wet stroke, if any. */
+    driver: WetStrokeDriver | null;
+    private lastTick;
+    private ticking;
+    private stepsOwed;
+    constructor(host: PaintWetHost, options?: PaintWetOptions);
+    /** The world (made on first use, at the canvas size). */
+    ensureWorld(): WetWorld;
+    /** Whether any layer (or `layerId`) has wet paint. */
+    isWet(layerId?: string): boolean;
+    /** Layers holding a wet layer (wet or drying). */
+    wetLayerIds(): string[];
+    /** Whether a batch is running (edits wait). */
+    get busy(): boolean;
+    /** Resolves when no batch is running. */
+    idle(): Promise<void>;
+    settingsOf(layerId: string, medium?: WetMediumKind): WetLayerSettings;
+    /** Puts a layer in the world (its current pixels become the base under the wet paint). */
+    ensureLane(layerId: string, medium?: WetMediumKind): WetWorld;
+    setParams(layerId: string, update: Partial<WetParams>): WetParams;
+    setFlow(layerId: string, update: Partial<WetFlowSpec>): WetFlowSpec;
+    setTilt(update: Partial<WetTilt>): WetTilt;
+    /** The paper changed. */
+    paperChanged(): void;
+    /** A layer as tools describe it. */
+    info(layerId: string): WetLayerInfo;
+    backend(): WetBackendInfo | null;
+    /** Shows the current wet pixels (at most `maxTiles` reshaded per layer). */
+    syncDisplays(maxTiles?: number): RasterRect[];
+    /** Drops the wet layers whose paint has all dried (they become ordinary pixel layers). */
+    private retireDry;
+    /**
+     * Advances time by the wall clock (`now` in ms, e.g. `performance.now()`): `speed` steps per
+     * second, at most `maxSteps` per call. Call it every frame; it does nothing while paused or dry.
+     * Resolves when the steps are done and the display is up to date.
+     */
+    tick(now: number, maxSteps?: number): Promise<void>;
+    private flushDriver;
+    /** Called when a live stroke that ended mid-batch has finished applying. */
+    onDriverDone: ((driver: WetStrokeDriver) => void) | null;
+    /** Steps `steps` times now (agents, tests). Returns the steps run. */
+    advance(steps: number): Promise<number>;
+    /**
+     * Dries at once (everything settles where it is), on one layer or all, optionally only in a
+     * rectangle. Returns the layers and rectangles that dried.
+     */
+    dry(layerId?: string, rect?: RasterRect): Array<{
+        layerId: string;
+        bounds: RasterRect | null;
+    }>;
+    /** The layer's pixels with all its wet paint dried (deterministic), without changing anything. */
+    bakedSurface(layerId: string): TiledSurface | null;
+    /** A snapshot of the world for undo (`null` when there is none). */
+    snapshot(): WetSnapshot | null;
+    /** Puts a snapshot back (`null`: no wet layers). Returns the layer surfaces it implies. */
+    restore(snap: WetSnapshot | null): void;
+    /** Forgets everything wet (a new canvas, a resize, opening a document). */
+    reset(): void;
+    /** Water overlay tiles (RGBA) over a document rectangle, for the view. */
+    waterOverlay(rect: RasterRect): Array<{
+        tx: number;
+        ty: number;
+        data: Uint8ClampedArray;
+    }>;
+    destroy(): void;
+}
+/** The pigment (K r, g, b, S) of a colour at a body, per unit mass (for tools that report it). */
+declare function wetPigmentOf(hex: string, body: number): number[];
+
+/**
+ * Thick paint (impasto): a pixel layer can carry two extra channels, a **height** map (how far the
+ * paint stands up, 0..255) and a **material** map (R gloss, G metallic, 0..255), and it is lit at
+ * render time: a normal from the height's slope, diffuse light from `PaintLighting`, and a
+ * Blinn-Phong highlight whose sharpness follows the gloss, tinted by the paint where it is
+ * metallic. The layer's own pixels stay the paint's colour (albedo), so relighting never repaints
+ * anything, saving keeps colour, height and material apart, and only tiles whose inputs changed are
+ * relit (the lit tiles are cached by the identity of their input tiles).
+ *
+ * Impasto strokes (`ThickStrokeDriver`) lay colour through the shared pick-up / mix exchange (paint
+ * mixes into the wet paint it meets, like oil) and raise the height: `brush` with bristle ridges
+ * along the stroke, `tube` in domed blobs, `knife` scraping the relief flat while it smears the
+ * paint, `roller` as a flat stippled band, `gloop` as a thick glossy round bead. The paint runs out
+ * along the stroke with `load` below 1, and `thinner` flattens and thins it.
+ */
+
+/** Where the light comes from. */
+interface PaintLighting {
+    /** Degrees clockwise from the top of the canvas (315: top left, the default). */
+    azimuth: number;
+    /** Degrees above the canvas, 5 (grazing, deep shadows) .. 90 (straight on, no relief). Default 40. */
+    elevation: number;
+    /** How strongly the relief shows, 0 (flat) .. 1 (default 0.7). */
+    relief: number;
+}
+declare const DEFAULT_LIGHTING: Readonly<PaintLighting>;
+declare function normalizeLighting(raw?: Partial<PaintLighting>, base?: PaintLighting): PaintLighting;
+/** A layer's thick-paint channels (layer space, like its pixels). */
+interface ThickChannels {
+    /** Height 0..255 per pixel (1 channel). */
+    height: TiledSurface;
+    /** Material per pixel (4 channels): R gloss, G metallic, B and A unused. */
+    material: TiledSurface;
+}
+declare function emptyThickChannels(): ThickChannels;
+declare function lightingKey(l: PaintLighting): string;
+/**
+ * One tile of a thick layer lit: `color` (RGBA, straight), the height and material of the tile, and
+ * the height of its 8 neighbours for the slopes at the border (`heightAt(dx, dy)` returns the
+ * neighbouring tile's data or null). Returns a new RGBA tile.
+ */
+declare function lightTile(color: Uint8ClampedArray, height: Uint8ClampedArray | null, heightAround: (dx: number, dy: number) => Uint8ClampedArray | null, material: Uint8ClampedArray | null, light: PaintLighting): Uint8ClampedArray;
+/** Cache of lit tiles for one layer, by the identity of their inputs. */
+declare class LitCache {
+    private readonly tiles;
+    /** The layer's pixels lit (tiles without relief nearby are the colour tiles themselves). */
+    lit(color: TiledSurface, ch: ThickChannels, light: PaintLighting): TiledSurface;
+}
+interface ThickStrokeInit {
+    brush: PaintBrush;
+    /** Where the colour goes (the session's live tiles). */
+    target: PaintTileTarget;
+    /** The layer's channels before the stroke. */
+    channels: ThickChannels;
+    /** Paint colour, sRGB 0..1. */
+    color: RgbTriple;
+    load: MixerLoad;
+    seed: number;
+    copies: readonly StrokeCopy[];
+}
+/** One impasto stroke: colour through the exchange, height and material into live channel tiles. */
+declare class ThickStrokeDriver {
+    readonly init: ThickStrokeInit;
+    dabCount: number;
+    private readonly smoother;
+    private readonly states;
+    private readonly medium;
+    private readonly height;
+    private readonly material;
+    private readonly paint;
+    private tip;
+    private lastRaw;
+    private lastFed;
+    private version;
+    constructor(init: ThickStrokeInit);
+    private readonly copies;
+    /** What copy 0 carries after the dabs so far. */
+    get load(): MixerLoad;
+    /** The channels with the stroke so far (new objects whenever they changed). */
+    channels(): ThickChannels;
+    private heightTile;
+    private materialTile;
+    private getH;
+    private setH;
+    push(points: readonly PenPoint[]): RasterRect[];
+    finish(): RasterRect[];
+    private applyDabs;
+    private dab;
+    /** The knife: flattens the relief under it and carries some of it along (a patch, like a smudge). */
+    private knifeHeight;
+    private paintMaterial;
+}
+/** Height statistics of a layer's relief (for tools). */
+declare function reliefInfo(ch: ThickChannels): {
+    bounds: RasterRect | null;
+    maxHeight: number;
+    tiles: number;
+};
+/** A layer's thick-paint channels as saved: PNG data URLs over a rectangle (layer space). */
+interface SavedThickChannels {
+    rect: RasterRect;
+    /** Greyscale PNG of the height. */
+    height: string;
+    /** RGBA PNG of the material (R gloss, G metallic). */
+    material: string;
+}
+/** Channels → saved form (`null` when there is no relief). */
+declare function thickToJSON(ch: ThickChannels): SavedThickChannels | null;
+/** Saved form → channels; throws a sentence when it cannot be read. */
+declare function thickFromJSON(raw: unknown): ThickChannels;
 
 /**
  * The paint editor's document: a canvas (size and resolution), a paper, and the shared raster
@@ -537,6 +1371,22 @@ interface PaintDocumentState {
     activeLayerId: string | null;
     /** Every committed stroke, oldest first (strokes are data: replay, vary, time-lapse later). */
     strokes: RecordedStroke[];
+    /** Wet-media events other than strokes (drying, tilt, settings), with the clock they happened at. */
+    wetEvents?: WetEvent[];
+    /** Changes besides strokes that a replay repeats (fills, clears, flattened relief), in order. */
+    paintEvents?: PaintEvent[];
+    /** Sticker layers: each layer's stickers, bottom first (its pixels are drawn from them). */
+    stickers?: Readonly<Record<string, Sticker[]>>;
+    /** Thick paint: each layer's height and material channels (layers without relief are missing). */
+    thick?: Readonly<Record<string, ThickChannels>>;
+}
+/** A change a replay repeats besides strokes, recorded with how many strokes came before it. */
+interface PaintEvent {
+    at: number;
+    kind: 'fill' | 'clear' | 'flatten' | 'stickers';
+    layerId: string;
+    /** The fill's options (colour, opacity, grain, pressure, blend), or the layer's stickers after an edit. */
+    data?: Record<string, unknown>;
 }
 /** A new layer id, unique in this session. */
 declare function newPaintLayerId(): string;
@@ -627,18 +1477,6 @@ declare class PaintDabStroke {
     private depositWithCeiling;
 }
 
-/**
- * A live stroke on one pixel layer. Points arrive while the pen moves; the layer shows the stroke
- * so far through a live surface (no history); `end()` commits it as one undo step.
- *
- * - Dab and eraser brushes: the coverage is cumulative, so each update recomposites the touched
- *   region from the pre-stroke tile (`applyStrokeToTile` with `into` and `region`).
- * - Dab-by-dab brushes (`PaintDabStroke`: the Mixer Brush, blender, smudge, and dab brushes that
- *   pick up paint or are multi-coloured): dabs read what earlier dabs laid down, so they paint
- *   into live tile copies; every tile written since the last update gets a new `Tile` object,
- *   because the compositor caches by tile identity.
- */
-
 interface StrokeSessionHost {
     /** Shows the layer's live surface (no history); `rects` are where it changed. */
     update(layerId: string, surface: TiledSurface, rects: RasterRect[]): void;
@@ -672,6 +1510,28 @@ interface StrokeSessionInit {
     mixerLoad: MixerLoad;
     /** The secondary colour 0..255 RGBA (a multi-colour brush without its own colours uses it). */
     secondary?: readonly [number, number, number, number];
+    /**
+     * Wet brushes: the driver that applies the stroke to the wet layer, and the layer's current
+     * pixels (the wet layer's display). The session's own surface is not used.
+     */
+    wet?: {
+        driver: WetStrokeDriver;
+        surface: () => TiledSurface;
+    };
+    /** Impasto brushes: the layer's thick-paint channels before the stroke. */
+    thick?: {
+        channels: ThickChannels;
+    };
+    /** Where paint may land (canvas-sized coverage 0..255: the stencils' mask), or none. */
+    selection?: {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+    /** Sticker brushes: the next sticker number on the layer. */
+    sticker?: {
+        nextId: number;
+    };
 }
 interface PaintStrokeResult {
     layerId: string;
@@ -682,6 +1542,8 @@ interface PaintStrokeResult {
     strokeId: string | null;
     /** Mixer and wet-capable dab brushes: what the brush carries after the stroke (cleaned unless it is dirty). */
     mixerLoad?: MixerLoad;
+    /** Wet brushes: the paint is wet (it keeps moving until it dries; see dry_paint / advance_wet_paint). */
+    wet?: boolean;
 }
 declare class PaintStrokeSession {
     private readonly host;
@@ -695,17 +1557,35 @@ declare class PaintStrokeSession {
     private readonly fresh;
     private readonly dry;
     private readonly wet;
+    private readonly wetDriver;
+    private readonly thickDriver;
+    private readonly stickerSpray;
+    /** A wet stroke that ended while the simulation was mid-batch: it commits when the driver catches up. */
+    private wetEndPending;
     private readonly apply;
     private readonly copies;
     private bounds;
     private lastRaw;
     private closed;
     result: PaintStrokeResult | null;
+    /** The mask stencils this stroke was painted with when they are not the editor's (replays). */
+    maskStencils: readonly Stencil[] | null;
     constructor(host: StrokeSessionHost, init: StrokeSessionInit);
     private tileTarget;
     get open(): boolean;
     /** Adds raw pen samples (document pixels). */
     push(points: readonly PenPoint[]): void;
+    /** Sticker strokes: the stickers sprayed so far. */
+    stickers(): Sticker[] | null;
+    /** Impasto strokes: the layer's thick-paint channels with the stroke so far. */
+    thickChannels(): ThickChannels | null;
+    /** Shows a wet stroke's progress (the wet layer's display). */
+    wetUpdate(rects: RasterRect[]): void;
+    /** Whether a wet stroke has ended but waits for the simulation to finish a batch. */
+    get pendingEnd(): boolean;
+    /** Completes a wet stroke whose end waited (the controller calls it when the driver is done). */
+    completeWetEnd(): void;
+    private finishWet;
     private update;
     /** Ends the stroke (one undo step) and returns what changed. */
     end(): PaintStrokeResult;
@@ -736,6 +1616,11 @@ interface PaperNode extends CompositorLayer {
     opacity: number;
     blend: 'normal';
     paper: PaperSettings;
+    /** The light, for metallic paper. */
+    light?: {
+        azimuth: number;
+        elevation: number;
+    };
 }
 /** A view-only RGBA image under the paint (the tracing image), drawn at its opacity. */
 interface ImageNode extends CompositorLayer {
@@ -757,9 +1642,15 @@ interface ImageNode extends CompositorLayer {
 type ViewLayer = PaintLayer | PaperNode | ImageNode;
 declare const PAPER_NODE_ID = "__paper";
 declare const TRACING_NODE_ID = "__tracing";
-declare function paperKey(p: PaperSettings): string;
-/** The paper as a compositor layer (one object per paper settings object, so caches hold). */
-declare function paperNode(paper: PaperSettings): PaperNode;
+declare function paperKey(p: PaperSettings, light?: {
+    azimuth: number;
+    elevation: number;
+}): string;
+/** The paper as a compositor layer (one object per paper settings object and light, so caches hold). */
+declare function paperNode(paper: PaperSettings, light?: {
+    azimuth: number;
+    elevation: number;
+}): PaperNode;
 /** The paper's dry height field, built once per settings. */
 declare function paperGrain(paper: PaperSettings): PaperGrain;
 /** A compositor for paint editor stacks (paper and view-only images included). */
@@ -788,7 +1679,7 @@ type PaintAssetStore = ImageEditorAssetStore;
 /**
  * Fields a later version adds. Phase 1 writes none of them and keeps any it reads. Planned:
  * `layerChannels: { [layerId]: { height?: asset, material?: asset } }` for impasto and
- * metallic paint. Wet paint is never saved (saving dries it), so there is no wet field.
+ * metallic paint. Wet paint itself is never saved (saving dries it); its settings are (`wet`).
  */
 type PaintDocumentExtensions = Record<string, unknown>;
 interface SerializedPaintDocument {
@@ -820,6 +1711,8 @@ interface SerializeOptions {
     swatches?: unknown;
     /** The mixing pad: `{ current?: png data URL, saved: [{ id, name, png }] }`. */
     mixingPad?: unknown;
+    /** Wet media settings: `{ tilt, layers: { [layerId]: { params, flow } } }`. */
+    wet?: unknown;
 }
 /** The document as JSON with inline PNG data URLs. */
 declare function serializePaintDocument(state: PaintDocumentState, options?: SerializeOptions): SerializedPaintDocument;
@@ -833,6 +1726,8 @@ interface LoadedPaintDocument {
     swatches?: unknown;
     /** The saved mixing pad, as stored (the controller validates it). */
     mixingPad?: unknown;
+    /** The saved wet settings, as stored (the controller validates them). */
+    wet?: unknown;
     /** What could not be read (the rest still loads). */
     problems: string[];
 }
@@ -1016,126 +1911,6 @@ declare function renderBrushThumbnail(brush: PaintBrush, options: {
     color: string;
 }): BrushThumbnail;
 
-/**
- * Painting guides: mirror and kaleidoscope symmetry (every stroke paints its reflected or rotated
- * copies as one stroke), perspective guides with one to three vanishing points that strokes snap
- * to, a tracing image under the paint (optionally the source of the stroke colour), and floating
- * reference images to pick colours from. Geometry only: no pixels, no DOM.
- */
-
-type SymmetryMode = 'off' | 'vertical' | 'horizontal' | 'dual' | 'diagonal' | 'kaleidoscope';
-declare const SYMMETRY_MODES: readonly SymmetryMode[];
-interface SymmetryGuide {
-    mode: SymmetryMode;
-    /** Centre of the axes in document pixels (default the canvas centre). */
-    center: {
-        x: number;
-        y: number;
-    };
-    /** Turns the axes, degrees clockwise (default 0). */
-    rotation: number;
-    /** Kaleidoscope: number of segments, 2..32 (default 6). */
-    segments: number;
-    /** Kaleidoscope: reflect every other segment as well as rotating (default true), like a real kaleidoscope. */
-    mirror: boolean;
-}
-interface Point2 {
-    x: number;
-    y: number;
-}
-interface PerspectiveGuide {
-    enabled: boolean;
-    /** One to three vanishing points in document pixels (they may lie outside the canvas). */
-    points: Point2[];
-    /** Strokes snap to the guide lines (default true when enabled). */
-    snap: boolean;
-}
-/** A view-only image under the paint, placed over the canvas. */
-interface TracingImage {
-    /** PNG or JPEG data URL. */
-    src: string;
-    /** Natural size of the image in pixels. */
-    width: number;
-    height: number;
-    /** Where it is drawn, in document pixels (default: fitted to the canvas). */
-    rect: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    /** 0..1 (default 0.35). */
-    opacity: number;
-    visible: boolean;
-    /** Strokes without an explicit colour take the tracing image's colour where they start. */
-    sampleColors: boolean;
-}
-/** A floating image to look at and pick colours from (shown beside the canvas, never painted). */
-interface ReferenceImage {
-    id: string;
-    name: string;
-    src: string;
-    width: number;
-    height: number;
-    /** Where the panel floats over the viewport, in screen pixels, and its displayed width. */
-    x: number;
-    y: number;
-    displayWidth: number;
-    visible: boolean;
-}
-interface PaintGuides {
-    symmetry: SymmetryGuide;
-    perspective: PerspectiveGuide;
-    tracing: TracingImage | null;
-    references: ReferenceImage[];
-}
-declare function defaultGuides(canvas: {
-    width: number;
-    height: number;
-}): PaintGuides;
-declare const MAX_COORDINATE = 1000000;
-declare function normalizeSymmetry(raw: Partial<SymmetryGuide> | Record<string, unknown>, base: SymmetryGuide): SymmetryGuide;
-/** The axis directions of a mirror mode (radians), as photocraft's `directions`. */
-declare function symmetryAxisAngles(g: SymmetryGuide): number[];
-/**
- * The extra copies a stroke paints under the symmetry guide, as affine maps (the stroke itself is
- * not included). Vertical, horizontal and diagonal: one reflection. Dual: two reflections and the
- * point reflection. Kaleidoscope: rotations by 360°/n, and with `mirror` the reflections between them.
- */
-declare function symmetryCopies(g: SymmetryGuide): Affine[];
-/** The axes clipped to the canvas, for drawing (photocraft's `segments`). */
-declare function symmetryAxisSegments(g: SymmetryGuide, size: {
-    width: number;
-    height: number;
-}): Array<[Point2, Point2]>;
-declare function normalizePerspective(raw: Partial<PerspectiveGuide> | Record<string, unknown>, base: PerspectiveGuide): PerspectiveGuide;
-/** The line families a perspective guide snaps to at `p`: unit directions. */
-declare function perspectiveDirections(g: PerspectiveGuide, p: Point2): Point2[];
-/** How far the pen must move before a stroke chooses its perspective line (document pixels). */
-declare const SNAP_DECIDE_DISTANCE = 6;
-/**
- * Snaps one stroke to a perspective guide: once the pen has moved `SNAP_DECIDE_DISTANCE` from
- * where it started, the stroke picks the guide line through its start that best matches its
- * direction, and every sample after that is projected onto the line.
- */
-declare class PerspectiveSnapper {
-    private readonly guide;
-    private start;
-    private dir;
-    constructor(guide: PerspectiveGuide);
-    /** The line the stroke follows, once chosen. */
-    get line(): {
-        from: Point2;
-        direction: Point2;
-    } | null;
-    snap<P extends Point2>(p: P): P;
-}
-/** Guide lines to draw for a perspective guide: rays from each vanishing point through the canvas. */
-declare function perspectiveGuideLines(g: PerspectiveGuide, size: {
-    width: number;
-    height: number;
-}, count?: number): Array<[Point2, Point2]>;
-
 /**
  * Colour for painters: hex / RGB / HSV / HSL conversions, a colour wheel that is either the
  * painter's red-yellow-blue wheel (where red's complement is green) or the RGB wheel (where it is
@@ -1270,6 +2045,107 @@ declare class MixingPad {
     pixels(): Uint8ClampedArray;
 }
 
+/**
+ * Replaying a painting from its data: every recorded stroke, and the changes recorded between them
+ * (fills, clears, flattened relief, and wet-media events at the simulation clock they happened at),
+ * repainted into a fresh, headless editor.
+ *
+ * - **Time-lapse**: frames of the painting as it is repainted (after strokes, and while wet paint
+ *   flows between them), as PNGs and as a `VideoProject` of stills that the video editor's export
+ *   path (`toVideoFfmpeg`) turns into an MP4.
+ * - **High-resolution export**: the same replay at a larger scale (points, brush sizes, paper grain
+ *   and rectangles scaled), so the picture is painted again with more pixels instead of upscaled.
+ *
+ * Strokes paint exactly as recorded: same seed, load and symmetry copies, and wet strokes apply
+ * each point at the clock it was recorded at, with the simulation stepped in between, so wet paint
+ * flows as it did. What was not recorded as data (imported pixels, merges, transforms of layers,
+ * changes made before strokes were recorded) is not repeated: those layers start empty.
+ */
+
+interface PaintReplayOptions {
+    /** Paint at this many times the size (1 for a time-lapse; 1..8 for a high-resolution export). */
+    scale?: number;
+    /** Stop after this many strokes (default all). */
+    strokes?: number;
+}
+/** One frame of a replay. */
+interface ReplayFrame extends PixelImage {
+    /** Strokes painted so far. */
+    stroke: number;
+    /** Wet-media clock (steps). */
+    clock: number;
+}
+interface TimeLapseOptions {
+    /** Longest side of each frame in pixels (default 720). */
+    maxSide?: number;
+    /** A frame after every this many strokes (default: about `frames` frames over the whole painting). */
+    strokesPerFrame?: number;
+    /** About how many frames in all (default 120). */
+    frames?: number;
+    /** While wet paint flows between strokes, a frame every this many steps (default 60; 0: none). */
+    wetStepsPerFrame?: number;
+    /** Frames per second of the video (default 12). */
+    fps?: number;
+    /** Hold the finished painting this long at the end (ms, default 1500). */
+    holdMs?: number;
+    /** Called after each frame with how far along the replay is (0..1). */
+    onProgress?: (done: number) => void;
+}
+interface TimeLapse {
+    fps: number;
+    width: number;
+    height: number;
+    /** Each frame as PNG bytes. */
+    frames: Uint8Array[];
+    /** The frames as stills on a timeline (assets `frame-0001.png`…; `src` is that file name). */
+    video: VideoProject;
+    /** The ffmpeg command that renders `video` to `timelapse.mp4` from the frame files. */
+    ffmpeg: VideoFfmpegExport;
+    durationMs: number;
+}
+type Item = {
+    kind: 'stroke';
+    stroke: RecordedStroke;
+} | {
+    kind: 'wet';
+    event: WetEvent;
+} | {
+    kind: 'paint';
+    event: NonNullable<PaintDocumentState['paintEvents']>[number];
+};
+/** Strokes and events in the order they happened. */
+declare function replayItems(doc: PaintDocumentState): Item[];
+/** The layer tree with every pixel layer empty (what a replay paints into). */
+declare function emptiedLayers(layers: readonly PaintLayer[]): PaintLayer[];
+/**
+ * Replays a controller's painting into `target` (a fresh controller the caller made at the scaled
+ * size; see `PaintEditorController.createReplayTarget`), calling `onFrame` where frames are due.
+ */
+declare function replayPainting(source: PaintDocumentState, target: PaintEditorController, options?: PaintReplayOptions & {
+    onStroke?: (index: number) => Promise<void> | void;
+    onWetSteps?: (clock: number) => Promise<void> | void;
+    wetChunk?: number;
+}): Promise<void>;
+/** A frame of `target` at most `maxSide` pixels on its longest side. */
+declare function replayFrame(target: PaintEditorController, maxSide: number, stroke: number): ReplayFrame;
+/** Frames as stills on a video timeline, `1 / fps` each, with the last held for `holdMs`. */
+declare function timeLapseVideo(frameCount: number, width: number, height: number, fps: number, holdMs: number, name?: string): {
+    video: VideoProject;
+    ffmpeg: VideoFfmpegExport;
+    durationMs: number;
+};
+/** Builds the time-lapse of a painting (see `PaintEditorController.timeLapse`). */
+declare function buildTimeLapse(source: PaintDocumentState, target: PaintEditorController, options?: TimeLapseOptions): Promise<TimeLapse>;
+/** A contact sheet: up to `count` frames side by side, for a quick look. */
+declare function contactSheet(frames: readonly PixelImage[], columns?: number, cell?: number): PixelImage;
+
+/**
+ * A time-lapse as one ZIP: the frames (`frame-0001.png`…), the video project (`timelapse.json`,
+ * which the video editor opens), and `render.sh` with the ffmpeg command that turns them into
+ * `timelapse.mp4`.
+ */
+declare function timeLapseZip(tl: TimeLapse): Promise<Uint8Array>;
+
 /**
  * `PaintEditorController`: the natural-media paint editor's state, framework-free.
  *
@@ -1301,6 +2177,26 @@ interface PaintEditorOptions extends Partial<PaintCanvas> {
     encodeImage?: ImageEncoder;
     /** Undo steps kept (default 200). */
     historyLimit?: number;
+    /** Wet media: kernel, threads, speed (steps per second) and the memory kept for undoing wet strokes. */
+    wet?: PaintWetOptions;
+}
+/** Wet media as panels show it. */
+interface PaintWetStateInfo {
+    /** Layers with a wet layer (paint still wet or drying). */
+    layerIds: string[];
+    /** Some paint is wet. */
+    wet: boolean;
+    /** Time is stopped (the paint stays wet). */
+    paused: boolean;
+    /** The water overlay is shown. */
+    overlay: boolean;
+    /** Wet strokes dry as soon as they end. */
+    instantDry: boolean;
+    /** Steps per second while time runs. */
+    speed: number;
+    /** Simulation steps so far. */
+    clock: number;
+    tilt: WetTilt;
 }
 interface PaintEditorState {
     document: PaintDocumentState;
@@ -1330,6 +2226,8 @@ interface PaintEditorState {
     savedMixingPads: readonly SavedMixingPadInfo[];
     /** A stroke is in progress. */
     stroking: boolean;
+    /** Wet media. */
+    wet: PaintWetStateInfo;
     /** Increments on every change. */
     version: number;
 }
@@ -1371,6 +2269,10 @@ interface PaintStrokeInit {
     };
     /** What the brush carries at the start (default: from the editor's brush load); replays pass the recorded one. */
     load?: MixerLoad;
+    /** Follow guide stencils and keep to mask stencils (default true; replays pass false, their points already follow them). */
+    stencils?: boolean;
+    /** Mask with these stencils instead (replays pass the ones recorded with the stroke). */
+    maskStencils?: readonly Stencil[];
 }
 interface LayerUpdate {
     name?: string;
@@ -1409,6 +2311,12 @@ interface RenderOptions {
     paper?: boolean;
     /** Only these layers (a group with its children). */
     layerIds?: readonly string[];
+    /**
+     * Wet paint as it is now (`display`: still wet, wet paper a little darker) or dried where it is
+     * (`dried`, the deterministic bake that saving uses). Default `dried` for exports and `display`
+     * for previews and picks.
+     */
+    wet?: 'display' | 'dried';
 }
 interface PixelImage {
     width: number;
@@ -1456,6 +2364,16 @@ declare class PaintEditorController {
     private nextReferenceId;
     private readonly viewCompositor;
     private readonly exportCompositor;
+    /** Wet media: the simulation, its settings and time. */
+    readonly wet: PaintWetLayers;
+    private readonly wetOptions;
+    /** Where the light comes from for thick paint (saved with the document, not undo steps). */
+    private lighting;
+    private readonly litCaches;
+    /** The live impasto stroke's channels. */
+    private liveThick;
+    /** Set while an operation that changes wet paint runs: the simulation before it (for undo). */
+    private wetOp;
     constructor(options?: PaintEditorOptions);
     subscribe(listener: () => void): () => void;
     private emit;
@@ -1469,6 +2387,24 @@ declare class PaintEditorController {
     takeDirty(): RasterRect[] | 'all';
     private requireIdle;
     private commit;
+    /** Keeps the wet snapshots in history within the wet undo memory, dropping the oldest. */
+    private trimWetHistory;
+    /** Throws when wet paint is mid-step (a batch in worker threads); `wetIdle()` waits for it. */
+    private requireWetIdle;
+    /** Starts an operation that changes wet paint: keeps the simulation as it is now for undo. */
+    private beginWetOp;
+    /**
+     * Before a non-wet change to layers that hold wet paint (a dry brush, a fill, a merge…): dries
+     * them first, in the same undo step. Returns the ids dried.
+     */
+    private dryLayersFirst;
+    /** Records a wet event (for replays) in the document being built. */
+    private pendingWetEvents;
+    private logWet;
+    /** The document with a paint event appended (for replays). */
+    private withPaintEvent;
+    /** The document with the pending wet events appended. */
+    private withWetEvents;
     undo(): string | null;
     redo(): string | null;
     /** Labels of the undo steps, oldest first. */
@@ -1621,6 +2557,134 @@ declare class PaintEditorController {
         bounds: RasterRect | null;
         layerIds: string[];
     };
+    /** The document's `thick` without these layers (as a spread: `{}` when unchanged). */
+    private thickWithout;
+    /** Where the light comes from for thick paint and metallic paper. */
+    getLighting(): PaintLighting;
+    /** Moves the light (thick paint and metallic paper are relit; nothing is repainted). Saved with the document, not an undo step. */
+    setLighting(update: Partial<PaintLighting>): PaintLighting;
+    /** A layer's relief: where it is, its highest point (0..255) and its tiles; `null` when it has none. */
+    reliefOf(layerId?: string): {
+        layerId: string;
+        bounds: RasterRect | null;
+        maxHeight: number;
+    } | null;
+    /** Flattens a layer's thick paint (its colour stays; the relief and material go). One undo step. */
+    flattenRelief(layerId?: string): {
+        layerId: string;
+        flattened: boolean;
+    };
+    /**
+     * A fresh, headless editor for replaying this painting at `scale` (canvas, dpi and paper grain
+     * scaled; every pixel layer empty; the same brushes, lighting and wet options). Dispose of it
+     * when done.
+     */
+    createReplayTarget(scale?: number): PaintEditorController;
+    /**
+     * Repaints the painting from its recorded strokes and events, as a time-lapse: PNG frames (after
+     * strokes, and while wet paint flows), a `VideoProject` of the frames as stills and the ffmpeg
+     * command that renders it (the video editor's export path). Changes nothing here.
+     */
+    timeLapse(options?: TimeLapseOptions): Promise<TimeLapse>;
+    /**
+     * The painting repainted from its recorded strokes at `scale` times the size (brush sizes,
+     * paper grain, fills and wet events scaled), wet paint dried: more detail instead of upscaled
+     * pixels. Layers painted without recorded strokes (imported pixels) come out empty. Changes nothing here.
+     */
+    /** `renderHighRes` as PNG bytes. */
+    exportHighResPng(options: {
+        scale: number;
+        paper?: boolean;
+    }): Promise<Uint8Array>;
+    renderHighRes(options: {
+        scale: number;
+        paper?: boolean;
+    }): Promise<PixelImage>;
+    /**
+     * Lets wet paint flow with the wall clock: call every frame with `performance.now()` (the
+     * bindings do). Steps at the wet speed unless paused; resolves when the frame's steps are done.
+     */
+    tickWet(now: number): Promise<void>;
+    /** Resolves when the wet kernel is as fast as it will get here (`null` when nothing is wet yet). */
+    wetReady(): Promise<WetBackendInfo | null>;
+    /** Stops the wet simulation's worker threads (call when the editor goes away). */
+    dispose(): void;
+    /** Resolves when wet paint is between steps (edits, undo and exports can run). */
+    wetIdle(): Promise<void>;
+    private wetLayer;
+    private checkRect;
+    /** Wet media as panels and tools show it, with each wet layer's state. */
+    wetState(): PaintWetStateInfo & {
+        layers: WetLayerInfo[];
+        backend: WetBackendInfo | null;
+        message: string | null;
+    };
+    /** One layer's wet settings and state. */
+    wetLayerInfo(layerId?: string): WetLayerInfo;
+    /**
+     * Lets the paint flow for `steps` simulation steps now (or `seconds` at the wet speed): what
+     * agents call between strokes. Not an undo step (time passing never is). Returns the steps run
+     * and which layers are still wet.
+     */
+    advanceWet(options: {
+        steps?: number;
+        seconds?: number;
+    }): Promise<{
+        steps: number;
+        clock: number;
+        stillWet: boolean;
+        layers: WetLayerInfo[];
+    }>;
+    /**
+     * Dries wet paint at once: everything settles where it is and the water goes (one undo step).
+     * On one layer or all, optionally only inside `rect`. Returns what dried and whether anything is
+     * still wet.
+     */
+    dryPaint(options?: {
+        layerId?: string;
+        rect?: RasterRect;
+    }): {
+        dried: Array<{
+            layerId: string;
+            bounds: RasterRect | null;
+        }>;
+        stillWet: boolean;
+    };
+    /**
+     * Pre-wets the paper (wet-in-wet): fills the paper's water over `rect` (default the canvas) by
+     * `amount` 0..1 on a layer's wet layer, so paint laid there spreads softly. One undo step.
+     */
+    wetPaper(options?: {
+        layerId?: string;
+        rect?: RasterRect;
+        amount?: number;
+    }): {
+        layerId: string;
+        rect: RasterRect;
+        wet: boolean;
+    };
+    /** Records a settings change as a wet event (not an undo step). */
+    private recordWetSetting;
+    /** Changes a layer's wet settings (viscosity, evaporation, granulation…). Editor settings saved with the document, not an undo step. */
+    setWetParams(layerId: string | undefined, update: Partial<WetParams>): WetParams;
+    /** Sets a layer's flow map (water pushed in a pattern). Saved with the document, not an undo step. */
+    setFlowMap(layerId: string | undefined, update: Partial<WetFlowSpec>): WetFlowSpec;
+    /** Tilts the canvas (water runs downhill; steep tilts make drips). Saved with the document, not an undo step. */
+    setCanvasTilt(update: Partial<WetTilt>): WetTilt;
+    /** Stops (or restarts) time: paused paint stays wet. Editor state. */
+    setWetPaused(paused: boolean): boolean;
+    /** Simulation steps per second while time runs (1..2000; default 120). Editor state. */
+    setWetSpeed(speed: number): number;
+    /** Wet strokes dry as soon as they end (each stroke still one undo step). Editor state. */
+    setInstantDry(on: boolean): boolean;
+    /** Shows or hides the water overlay (where the water is, view only). */
+    setWaterOverlay(visible: boolean): boolean;
+    /** The water overlay's tiles over a document rectangle (RGBA, view only). */
+    waterOverlayTiles(rect: RasterRect): Array<{
+        tx: number;
+        ty: number;
+        data: Uint8ClampedArray;
+    }>;
     private sources;
     /** The layers with the live stroke's surface in place. */
     private currentLayers;
@@ -1628,6 +2692,10 @@ declare class PaintEditorController {
     protected underlayLayers(): ViewLayer[];
     /** The tracing image resampled onto the canvas (cached until it or the canvas changes). */
     private tracingNode;
+    /** The layers with every wet layer dried where it is (what saving and exporting see). */
+    private driedLayers;
+    /** The layers with thick paint lit (each thick layer's pixels replaced by its lit tiles). */
+    private litLayers;
     private renderLayers;
     /**
      * Composites the viewport stack (paper, view-only underlays, layers with the live stroke) tile by
@@ -1644,6 +2712,15 @@ declare class PaintEditorController {
         maxSide?: number;
     }): PixelImage;
     /** The document as JSON with inline PNG assets. */
+    /** The document as saved: wet paint dried where it is (deterministically); wet settings as data. */
+    private savedState;
+    /** Wet settings saved with the document (`null` when they are all defaults). */
+    private wetJSON;
+    private readWet;
+    /** Thick paint and light as saved (`layerChannels`, `lighting`), merged into the extensions. */
+    private thickExtensions;
+    /** Reads `layerChannels` and `lighting` from loaded extensions into the document. */
+    private readThick;
     toJSON(options?: {
         strokes?: boolean;
     }): SerializedPaintDocument;
@@ -1726,6 +2803,36 @@ declare class PaintEditorController {
     /** The colour of a reference image at its pixel (x, y). */
     pickReferenceColor(id: string, x: number, y: number): string;
     private readGuides;
+    /** The document's `stickers` without these layers (as a spread: `{}` when unchanged). */
+    private stickersWithout;
+    /** The next free sticker number (ids `st<n>` are unique across the document). */
+    private nextStickerNumber;
+    private stickerLayer;
+    /** A layer's stickers, bottom first. */
+    listStickers(layerId?: string): Sticker[];
+    /** Replaces a layer's stickers and redraws its pixels from them (one undo step). */
+    private commitStickers;
+    /** Moves, turns, resizes, recolours or restamps one sticker (one undo step). Returns it. */
+    updateSticker(layerId: string | undefined, id: string, update: Partial<Omit<Sticker, 'id'>>): Sticker;
+    /** Brings stickers to the top (`front`) or bottom of their layer (one undo step). */
+    arrangeStickers(layerId: string | undefined, ids: readonly string[], to: 'front' | 'back'): string[];
+    /** Deletes stickers (`ids`, or all of them on the layer) (one undo step). Returns the ids removed. */
+    removeStickers(layerId: string | undefined, ids?: readonly string[]): string[];
+    /** Sets a layer's stickers (replays). */
+    replaceStickers(layerId: string, stickers: readonly Sticker[]): void;
+    private stencilCache;
+    private nextStencilId;
+    /** The mask stencils' coverage over the canvas (cached), or `null` when none masks. */
+    private stencilSelection;
+    /** The stencils. */
+    listStencils(): Stencil[];
+    /** Lays a stencil on the canvas (a ruler or arc to follow, a straight edge or shape to mask). Editor state saved with the document, not an undo step. */
+    addStencil(input: StencilInput): Stencil;
+    private requireStencil;
+    /** Moves, reshapes, switches (guide / mask, invert) or hides a stencil. */
+    updateStencil(id: string, update: Partial<Omit<Stencil, 'id' | 'kind'>>): Stencil;
+    /** Takes stencils away (`ids`, or all of them). Returns the ids removed. */
+    removeStencils(ids?: readonly string[]): string[];
     /** Colour harmonies around a colour (default the paint colour) on the painter's RYB wheel or the RGB wheel. */
     harmony(kind: HarmonyKind, options?: {
         color?: string;
@@ -1990,7 +3097,7 @@ declare class PaintCanvasPresenter {
 declare function guideOverlay(controller: PaintEditorController): Array<{
     from: Point2;
     to: Point2;
-    kind: 'symmetry' | 'perspective' | 'snap';
+    kind: 'symmetry' | 'perspective' | 'snap' | 'stencil';
 }>;
 /** One slider of a panel: a path into the brush (or paper) settings. */
 interface SliderControl {
@@ -2045,6 +3152,14 @@ interface BrushEngineControls {
     multicolor: boolean;
     /** Load / Clean buttons and a swatch of what the brush carries. */
     load: boolean;
+    /** The wet tool menu (`wet.tool`, `WET_TOOLS`) and medium menu (`wet.medium`, `WET_MEDIA`). */
+    wetTool?: boolean;
+    /** The impasto tool menu (`impasto.tool`, `IMPASTO_TOOLS`). */
+    impastoTool?: boolean;
+    /** The particle kind and render menus (`particle.kind`, `particle.render`). */
+    particleMenus?: boolean;
+    /** The sticker stamp toggles (`sticker.stamps`, `STAMP_KINDS`). */
+    stickerStamps?: boolean;
 }
 /**
  * The controls the active brush's engine adds to the brush panel (`null` for the eraser):
@@ -2053,7 +3168,9 @@ interface BrushEngineControls {
  * pigment choice; dab and mixer brushes also have the dirty and multi-colour controls. Pick-up
  * and mix always go through `behavior`, which keeps a Mixer Brush's `mixer` block in sync.
  */
-declare function brushEngineControls(brush: Pick<PaintBrush, 'engine'>): BrushEngineControls | null;
+declare function brushEngineControls(brush: Pick<PaintBrush, 'engine'> & {
+    wet?: PaintBrush['wet'];
+}): BrushEngineControls | null;
 /** The multi-colour sliders for a mode: softness, and dabs per colour in `dab` mode. */
 declare function multiColorSliders(mode: string): readonly SliderControl[];
 /** A brush change setting `path` (e.g. `smudge.mixing`, `behavior.dirty`) to any value, keeping the rest of its block. */
@@ -2064,5 +3181,136 @@ declare function brushLoadColor(load: MixerLoad): string | null;
 declare const PAD_SAMPLE_SIZES: readonly number[];
 /** The averaging radius `mixingPadPick` takes for a sample size: 1 → 0, 3 → 1, 5 → 2 … */
 declare function padSampleRadius(size: number): number;
+/** Labels of the wet tools, for the wet brush's tool menu. */
+declare const WET_TOOL_LABELS: Readonly<Record<WetTool, string>>;
+/** The wet panel's sliders for a layer's wet settings (paths into `WetParams`). */
+declare const WET_PARAM_SLIDERS: readonly SliderControl[];
+/** The canvas tilt sliders. */
+declare const WET_TILT_SLIDERS: readonly SliderControl[];
+/** The speed slider (steps per second). */
+declare const WET_SPEED_SLIDER: SliderControl;
+/**
+ * Runs the wet paint's clock with the display: `controller.tickWet(now)` every animation frame
+ * (it does nothing while nothing is wet or time is paused). Returns a function that stops it.
+ * Bindings call it once per mounted canvas.
+ */
+declare function startWetClock(controller: PaintEditorController, frame?: (cb: (t: number) => void) => number, cancel?: (id: number) => void): () => void;
+/**
+ * Draws the water overlay (blue where the surface is wet, faint where the paper is damp) into a
+ * document-sized 2D context, clearing it first. Draws nothing when the overlay is off.
+ */
+declare function drawWaterOverlay(controller: PaintEditorController, ctx: Paint2DContext & {
+    clearRect(x: number, y: number, w: number, h: number): void;
+}): number;
+/** Labels of the wet media, for the wet brush's medium menu. */
+declare const WET_MEDIUM_LABELS: Readonly<Record<WetMediumKind, string>>;
+/** Labels of the impasto tools. */
+declare const IMPASTO_TOOL_LABELS: Readonly<Record<ImpastoTool, string>>;
+/** The light sliders (thick paint and metallic paper). */
+declare const LIGHT_SLIDERS: readonly SliderControl[];
+/** Labels of the particle kinds and renders. */
+declare const PARTICLE_KIND_LABELS: Readonly<Record<ParticleKind, string>>;
+declare const PARTICLE_RENDER_LABELS: Readonly<Record<ParticleRender, string>>;
+/** Labels of the sticker stamps. */
+declare const STAMP_LABELS: Readonly<Record<StampKind, string>>;
+/** Toggles one stamp in a sticker brush's set (never leaving it empty). */
+declare function toggleStamp(stamps: readonly StampKind[], stamp: StampKind): StampKind[];
+/** The sticker panel's sliders for the selected sticker. */
+declare const STICKER_SLIDERS: readonly SliderControl[];
+/** Stencils a toolbar can lay with one click, centred on the canvas. */
+declare function quickStencil(kind: 'ruler' | 'circle' | 'ellipse-mask' | 'edge-mask', canvas: {
+    width: number;
+    height: number;
+}): StencilInput;
+
+/**
+ * Agent tools for wet media (watercolour and gouache on a simulated wet layer). Wet strokes are
+ * painted with `paint_stroke` and a wet brush (`list_brushes` category `watercolor` or
+ * `wet-tool`); these tools read and steer the wet paint. Every result says whether paint is still
+ * wet. Settings (wet parameters, flow maps, tilt) are saved with the document but are not undo
+ * steps; drying and wetting the paper are.
+ */
+
+declare const WET_PARAM_SCHEMA: {
+    readonly viscosity: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+    readonly evaporation: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+    readonly edgeDarkening: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+    readonly pigmentWeight: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+    readonly granulation: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+    readonly pickup: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+    readonly fixture: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+    readonly bloom: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+    readonly bleed: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+};
+declare function createPaintWetTools(c: PaintEditorController): AgentTool[];
+
+/**
+ * Agent tools for thick paint and light: impasto strokes are painted with `paint_stroke` and an
+ * impasto brush; these tools move the light, read and flatten a layer's relief, and switch instant
+ * drying of wet strokes.
+ */
+
+declare function createPaintThickTools(c: PaintEditorController): AgentTool[];
+
+/**
+ * Agent tools for replaying a painting from its data: a time-lapse (frames, a video project of the
+ * frames and the ffmpeg command that renders it) and a high-resolution export repainted from the
+ * recorded strokes.
+ */
+
+declare function createPaintReplayTools(c: PaintEditorController): AgentTool[];
+
+/**
+ * Agent tools for stickers: stamps sprayed with a sticker brush (`paint_stroke`, list_brushes
+ * category sticker) stay objects on their layer, which these tools list, move, turn, resize,
+ * recolour, reorder and delete. Each change is one undo step and redraws the layer.
+ */
+
+declare function createPaintStickerTools(c: PaintEditorController): AgentTool[];
 
-export { type Affine, BLEND_MENU_GROUPS, BRUSH_ID, BRUSH_ROTATIONS, BRUSH_SLIDERS, BUILTIN_BRUSHES, type BlendMenuGroup, BlendMode, BlendModeInfo, type BrushBehavior, type BrushBehaviorInput, type BrushDynamics, type BrushEngineControls, type BrushLibraryFile, type BrushRotation, type BrushThumbnail, type ColorWheel, DEFAULT_BEHAVIOR, DEFAULT_BRUSH_ID, DEFAULT_DPI, DEFAULT_DYNAMICS, DEFAULT_MULTI_COLOR, DEFAULT_PAPER, DEFAULT_SWATCHES, DEFAULT_VIEW, DryStroke, type DryStrokeOptions, type FillLayerOptions, GRAIN_PATTERNS, GRAIN_TILE, type GrainPattern, type GrainTuning, HARMONY_KINDS, type Hand, type HarmonyColor, type HarmonyKind, IDENTITY_AFFINE, IDENTITY_COPY, type ImageEncoder, type ImageFormat, type ImageNode, type LayerUpdate, type Linear2, type LoadedPaintDocument, MAX_CANVAS_SIDE, MAX_COORDINATE, MAX_IMAGE_SIDE, MAX_ZOOM, MIN_CANVAS_SIDE, MIN_ZOOM, MIXING_PAD_HEIGHT, MIXING_PAD_WIDTH, MULTI_COLOR_MODES, MixingPad, type MixingPadTool, type MultiColorMode, type MultiColorSettings, PAD_SAMPLE_SIZES, PAINT_BRUSH_CATEGORIES, PAINT_BRUSH_ENGINES, PAINT_FORMAT, PAINT_SCHEMA_VERSION, PAINT_TOOLS, PAPER_FAMILIES, PAPER_LIBRARY, PAPER_NODE_ID, PAPER_SLIDERS, type PadMixOptions, type PadMixPart, type Paint2DContext, type PaintAgentCommand, type PaintAssetStore, type PaintBrush, type PaintBrushCategory, type PaintBrushEngine, type PaintBrushInput, type PaintCanvas, PaintCanvasPresenter, PaintDabStroke, type PaintDabStrokeOptions, PaintDirector, type PaintDirectorOptions, PaintDocumentError, type PaintDocumentExtensions, type PaintDocumentState, PaintEditorController, PaintEditorError, type PaintEditorOptions, type PaintEditorState, type PaintEditorToolProviderOptions, PaintGesture, type PaintGroupLayer, type PaintGuides, type PaintLayer, type PaintLayerInfo, type PaintPerformanceResult, type PaintPixelLayer, type PaintPointerEvent, PaintPresence, type PaintPresenceActor, type PaintPresenceState, type PaintStrokeInit, type PaintStrokeResult, PaintStrokeSession, type PaintTool, type PaintView, type PaperFamily, PaperGrain, type PaperNode, type PaperSettings, type PaperTiling, type PenDab, PenDabWalker, type PenPoint, PenSmoother, type PerspectiveGuide, PerspectiveSnapper, type PixelImage, type Point2, type PointerSample, type RecordedStroke, type ReferenceImage, type RenderOptions, type ReplayOptions, type Rgb255, SNAP_DECIDE_DISTANCE, SYMMETRY_MODES, type SavedMixingPadInfo, type SerializeOptions, type SerializedPaintDocument, type SliderControl, type StrokeCopy, type StrokeSessionHost, type StrokeSessionInit, type StrokeVariation, type Swatch, type SymmetryGuide, type SymmetryMode, TRACING_NODE_ID, TileableNoise, type TracingImage, type ViewLayer, type ViewportBox, affineCopy, applyAffine, brushEngineControls, brushLoadColor, brushLoadForStroke, brushToJSON, clonePaper, colorHarmony, composeAffine, createPaintCompositor, createPaintDocument, createPaintEditorToolProvider, createPaintLayer, decodeImageBlob, defaultGuides, defaultImageEncoder, deserializePaintDocument, deserializePaintDocumentAsync, documentExtensions, documentToScreen, downloadBytes, downsampleRgba, fitZoom, grainCatch, grainHeights, guideOverlay, handlePaintShortcut, hash2, hexToRgb8, hslToRgb, hsvToRgb, hueToWheel, invertAffine, isPalmTouch, isWetCapable, mapPenPoint, mix32, mixerLoadForStroke, mixerTip, multiColorForDab, multiColorGradient, multiColorPalette, multiColorSliders, newPaintLayerId, normalizeBehavior, normalizeBrushStroke, normalizeCanvas, normalizeDynamics, normalizeMultiColor, normalizePaintBrush, normalizePaper, normalizePerspective, normalizeRotation, normalizeSymmetry, normalizeView, padSampleRadius, paperGrain, paperKey, paperNode, paperPreset, parseBrushLibrary, parseHexColor, patchBrushValue, patchPath, penOrientation, perspectiveDirections, perspectiveGuideLines, pointerToPenPoint, rand01, randSigned, readPath, renderBrushThumbnail, renderColorWheel, renderPaper, rgbToHexColor, rgbToHsl, rgbToHsv, samplePressure, screenToDocument, seedFromString, serializePaintDocument, serializePaintDocumentExternal, strokeBounds, strokeDuration, strokeSchedule, sweepPath, symmetryAxisAngles, symmetryAxisSegments, symmetryCopies, thumbnailStroke, tiltToOrientation, toStrokePoint, usesPaintExchange, variationAffine, varyStroke, viewCssTransform, viewMatrix, viewPenToDocument, wheelAngle, wheelPick, wheelPoint, wheelToHue };
+export { type Affine, BLEND_MENU_GROUPS, BRUSH_ID, BRUSH_ROTATIONS, BRUSH_SLIDERS, BUILTIN_BRUSHES, type BlendMenuGroup, BlendMode, BlendModeInfo, type BristleSettings, BristleStroke, type BrushBehavior, type BrushBehaviorInput, type BrushDynamics, type BrushEngineControls, type BrushLibraryFile, type BrushRotation, type BrushThumbnail, type ColorWheel, type CoverageStroke, DEFAULT_BEHAVIOR, DEFAULT_BRISTLE, DEFAULT_BRUSH_ID, DEFAULT_DPI, DEFAULT_DYNAMICS, DEFAULT_IMPASTO, DEFAULT_LIGHTING, DEFAULT_MULTI_COLOR, DEFAULT_PAPER, DEFAULT_PARTICLE, DEFAULT_STICKER, DEFAULT_SWATCHES, DEFAULT_VIEW, DEFAULT_WET_BRUSH, DryStroke, type DryStrokeOptions, type FillLayerOptions, GRAIN_PATTERNS, GRAIN_TILE, type GrainPattern, type GrainTuning, HARMONY_KINDS, type Hand, type HarmonyColor, type HarmonyKind, IDENTITY_AFFINE, IDENTITY_COPY, IMPASTO_TOOLS, IMPASTO_TOOL_LABELS, type ImageEncoder, type ImageFormat, type ImageNode, type ImpastoSettings, type ImpastoTool, LIGHT_SLIDERS, type LayerUpdate, type Linear2, LitCache, type LoadedPaintDocument, MAX_CANVAS_SIDE, MAX_COORDINATE, MAX_IMAGE_SIDE, MAX_ZOOM, MIN_CANVAS_SIDE, MIN_ZOOM, MIXING_PAD_HEIGHT, MIXING_PAD_WIDTH, MULTI_COLOR_MODES, MixingPad, type MixingPadTool, type MultiColorMode, type MultiColorSettings, PAD_SAMPLE_SIZES, PAINT_BRUSH_CATEGORIES, PAINT_BRUSH_ENGINES, PAINT_FORMAT, PAINT_SCHEMA_VERSION, PAINT_TOOLS, PAPER_FAMILIES, PAPER_LIBRARY, PAPER_NODE_ID, PAPER_SLIDERS, PARTICLE_KINDS, PARTICLE_KIND_LABELS, PARTICLE_RENDERS, PARTICLE_RENDER_LABELS, type PadMixOptions, type PadMixPart, type Paint2DContext, type PaintAgentCommand, type PaintAssetStore, type PaintBrush, type PaintBrushCategory, type PaintBrushEngine, type PaintBrushInput, type PaintCanvas, PaintCanvasPresenter, PaintDabStroke, type PaintDabStrokeOptions, PaintDirector, type PaintDirectorOptions, PaintDocumentError, type PaintDocumentExtensions, type PaintDocumentState, PaintEditorController, PaintEditorError, type PaintEditorOptions, type PaintEditorState, type PaintEditorToolProviderOptions, type PaintEvent, PaintGesture, type PaintGroupLayer, type PaintGuides, type PaintLayer, type PaintLayerInfo, type PaintLighting, type PaintPerformanceResult, type PaintPixelLayer, type PaintPointerEvent, PaintPresence, type PaintPresenceActor, type PaintPresenceState, type PaintReplayOptions, type PaintStrokeInit, type PaintStrokeResult, PaintStrokeSession, type PaintTool, type PaintView, type PaintWetHost, PaintWetLayers, type PaintWetOptions, type PaintWetStateInfo, type PaperFamily, PaperGrain, type PaperNode, type PaperSettings, type PaperTiling, type ParticleKind, type ParticleRender, type ParticleSettings, ParticleStroke, type PenDab, PenDabWalker, type PenPoint, PenSmoother, type PerspectiveGuide, PerspectiveSnapper, type PixelImage, type Point2, type PointerSample, type ProceduralStrokeOptions, type RecordedStroke, type ReferenceImage, type RenderOptions, type ReplayFrame, type ReplayOptions, type Rgb255, SNAP_DECIDE_DISTANCE, STAMP_KINDS, STAMP_LABELS, STENCIL_KINDS, STENCIL_SHAPES, STICKER_SLIDERS, SYMMETRY_MODES, type SavedMixingPadInfo, type SavedThickChannels, type SerializeOptions, type SerializedPaintDocument, type SliderControl, type StampKind, type Stencil, type StencilInput, type StencilKind, type StencilShape, StencilSnapper, type Sticker, type StickerSettings, StickerSpray, type StickerSprayInit, type StrokeCopy, type StrokeSessionHost, type StrokeSessionInit, type StrokeVariation, type Swatch, type SymmetryGuide, type SymmetryMode, TRACING_NODE_ID, type ThickChannels, ThickStrokeDriver, type ThickStrokeInit, TileableNoise, type TimeLapse, type TimeLapseOptions, type TracingImage, type ViewLayer, type ViewportBox, WET_MEDIA, WET_MEDIUM_LABELS, WET_MEDIUM_PARAMS, WET_PARAM_SCHEMA, WET_PARAM_SLIDERS, WET_SPEED_SLIDER, WET_TILT_SLIDERS, WET_TOOLS, WET_TOOL_LABELS, WetBackendInfo, type WetBrushSettings, type WetEvent, WetFlowSpec, type WetLayerInfo, type WetLayerSettings, type WetMediumKind, WetParams, WetStrokeDriver, type WetStrokeInit, WetTilt, type WetTool, affineCopy, applyAffine, brushEngineControls, brushLoadColor, brushLoadForStroke, brushToJSON, buildTimeLapse, clonePaper, colorHarmony, composeAffine, contactSheet, createPaintCompositor, createPaintDocument, createPaintEditorToolProvider, createPaintLayer, createPaintReplayTools, createPaintStickerTools, createPaintThickTools, createPaintWetTools, decodeImageBlob, defaultGuides, defaultImageEncoder, deserializePaintDocument, deserializePaintDocumentAsync, documentExtensions, documentToScreen, downloadBytes, downsampleRgba, drawSticker, drawWaterOverlay, emptiedLayers, emptyThickChannels, fitZoom, grainCatch, grainHeights, guideOverlay, handlePaintShortcut, hash2, hexToRgb8, hslToRgb, hsvToRgb, hueToWheel, invertAffine, isPalmTouch, isWetBrush, isWetCapable, lightTile, lightingKey, mapPenPoint, mix32, mixerLoadForStroke, mixerTip, multiColorForDab, multiColorGradient, multiColorPalette, multiColorSliders, newPaintLayerId, normalizeBehavior, normalizeBristle, normalizeBrushStroke, normalizeCanvas, normalizeDynamics, normalizeImpasto, normalizeLighting, normalizeMultiColor, normalizePaintBrush, normalizePaper, normalizeParticle, normalizePerspective, normalizeRotation, normalizeStencil, normalizeStickerSettings, normalizeStickerUpdate, normalizeSymmetry, normalizeView, normalizeWetBrush, padSampleRadius, paperGrain, paperKey, paperNode, paperPreset, parseBrushLibrary, parseHexColor, patchBrushValue, patchPath, penOrientation, perspectiveDirections, perspectiveGuideLines, pointerToPenPoint, quickStencil, rand01, randSigned, readPath, reliefInfo, renderBrushThumbnail, renderColorWheel, renderPaper, renderStickers, replayFrame, replayItems, replayPainting, rgbToHexColor, rgbToHsl, rgbToHsv, samplePressure, scaleStencil, screenToDocument, seedFromString, serializePaintDocument, serializePaintDocumentExternal, stampCoverage, startWetClock, stencilMask, stencilOutline, stickerRect, stickerSurface, strokeBounds, strokeDuration, strokeSchedule, sweepPath, symmetryAxisAngles, symmetryAxisSegments, symmetryCopies, thickFromJSON, thickToJSON, thumbnailStroke, tiltToOrientation, timeLapseVideo, timeLapseZip, toStrokePoint, toggleStamp, usesPaintExchange, variationAffine, varyStroke, viewCssTransform, viewMatrix, viewPenToDocument, wetPaperInput, wetPigmentOf, wheelAngle, wheelPick, wheelPoint, wheelToHue };