@pixerate/editor 0.115.0 → 0.116.0

package/dist/{retouch-Bxkuc0KH.d.cts → flow-COCB42TP.d.cts}

@@ -1,4 +1,4 @@
-import { a as BlendMode, R as RasterRect, i as TileKey, Y as Pigment } from './surface-Cn30xIV6.cjs';
+import { a as BlendMode, R as RasterRect, i as TileKey, Y as Pigment, j as TiledSurface } from './surface-Cn30xIV6.cjs';
 
 /**
  * The brush engine (a subset of photocraft's `crates/paint`): a computed round tip with size,
@@ -700,4 +700,563 @@ declare function rgbaViewOfGrey(target: PaintTileTarget): {
     flush(): void;
 };
 
-export { cleanMixer as $, type PixelSource as A, type BrushSettings as B, CoverageMap as C, type Dab as D, EMPTY_MIXER_LOAD as E, RETOUCH_SAMPLES as F, RegionPixelSource as G, type RetouchDabEffect as H, RetouchDabStroke as I, type RetouchSample as J, SPOT_HEAL_TYPES as K, type SmudgeDab as L, type MixerSettings as M, SmudgeTip as N, type SpotHealType as O, type PaintTileTarget as P, TileMedium as Q, type RgbTriple as R, type SmudgeSettings as S, TONE_RANGES as T, type TileMediumOptions as U, TilePixelSource as V, type ToneRange as W, applyRetouchToTile as X, applyStrokeToTile as Y, blendRadius as Z, blenderDab as _, type MixingModel as a, coverageTileCoord as a0, createBlenderScratch as a1, dabCoverage as a2, dabRect as a3, dodgeBurn as a4, dodgeBurnCurve as a5, exchangeRates as a6, healPixels as a7, loadMixer as a8, luma as a9, mixerRates as aa, normalizeBlender as ab, normalizeBrush as ac, normalizeMixer as ad, normalizeRetouch as ae, normalizeSmudge as af, perDabStrength as ag, rasterizeDab as ah, readSourceRegion as ai, rgbaViewOfGrey as aj, saturationOf as ak, smoothPoints as al, smudgeEffect as am, sponge as an, spongeEffect as ao, spotHealPixels as ap, spotHealWindow as aq, tipFalloff as ar, tipReach as as, tipShape as at, toneOf as au, walkDabs as av, type BlenderSettings as b, type StrokePoint as c, type MixerLoad as d, MAX_BRUSH_SIZE as e, type RetouchSettings as f, StrokeCoverage as g, type MixerTarget as h, MixerStroke as i, type RetouchApply as j, type RetouchPaint as k, type StrokeApply as l, type BlenderScratch as m, DEFAULT_BLENDER as n, DEFAULT_BRUSH as o, DEFAULT_MIXER as p, DEFAULT_RETOUCH as q, DEFAULT_SMUDGE as r, DabWalker as s, type ExchangeRates as t, MIXER_DRAIN as u, MIXER_PICKUP_RATE as v, MIXING_MODELS as w, PaintExchange as x, type PaintMedium as y, type PaintSample as z };
+/**
+ * The wet-media model: water and pigment on paper, simulated per cell on 256 px tiles.
+ *
+ * Written from the published literature only (no code, presets or textures from any product):
+ *
+ * - **Water** is a D2Q9 lattice Boltzmann fluid with BGK collision, τ = 3ν + ½ (any LBM text, e.g.
+ *   Krüger et al., *The Lattice Boltzmann Method*, 2017). Streaming uses partial bounce-back with a
+ *   blocking factor from the paper fibres, and the wet front is *pinned* until the water behind it
+ *   is deep enough: Chu & Tai, "MoXi: Real-Time Ink Dispersion in Absorbent Paper", SIGGRAPH 2005.
+ *   Tilt and flow maps are a velocity-shift force, with |u| capped at `U_MAX` cells per step.
+ * - **Paper** soaks water up until it holds its capacity, and damp paper stops pinning the front
+ *   (wet-in-wet). Water evaporates faster in a band along the wet front (an "edge" field, 1 at the
+ *   front and fading over a few cells inwards, as Curtis et al. blur the wet-area mask), so water
+ *   flows out to the edge and carries pigment there: edge darkening.
+ * - **Pigment** (Curtis et al., "Computer-Generated Watercolor", SIGGRAPH 1997) is suspended in the
+ *   water, advected with a first-order upwind finite-volume flux (it conserves pigment and never
+ *   goes negative while |u| ≤ ¼), spreads a little between wet cells (bleed), settles into the
+ *   paper (more in grain valleys: granulation; more at the wet edge: edge darkening), is lifted
+ *   back by water (more where water arrives: blooms), and settles completely where a cell dries.
+ * - **Colour** is Kubelka-Munk: each cell carries pigment as absorption `K` per channel (linear
+ *   R, G, B) plus one scattering `S`, so mixes are exactly linear (two-constant KM, `K = Σ cᵢKᵢ`,
+ *   `S = Σ cᵢSᵢ`) and transparent washes multiply like glazes. A colour becomes `K` and `S` with the
+ *   same two-flux formulas as the shipped pigment model (`K/S = (1 − R)² / 2R`).
+ *
+ * `stepCellsTs` in `kernel.ts` is the specification of one step, in exact f32 arithmetic. The
+ * WebAssembly SIMD kernel (`assembly/wet.ts`) is a lane-for-lane port of it and gives the same bits,
+ * so the simulation is deterministic across browsers, kernels and worker counts.
+ */
+/** Tile side in cells (the raster tile size). */
+declare const WET_TILE = 256;
+/** A tile slot's side: the tile plus a one-cell halo on each side. */
+declare const SLOT_SIDE = 258;
+/** Floats per plane of a slot. */
+declare const PLANE: number;
+declare const PLANE_BYTES: number;
+/** Planes in each ping-ponged set: f0..f8, depth, velocity, paper water, 4 pigment channels, edge. */
+declare const SET_PLANES = 18;
+declare const P_RHO = 9;
+declare const P_UX = 10;
+declare const P_UY = 11;
+/** Water held in the paper. */
+declare const P_SW = 12;
+/** Suspended pigment: K red, K green, K blue, S. */
+declare const P_P0 = 13;
+/** Edge: 1 at the wet front, fading over a few cells into the wet area (0 where dry). */
+declare const P_EDGE = 17;
+/** Single (not ping-ponged) planes, after the two sets. */
+declare const P_D0: number;
+declare const P_H: number;
+declare const P_FX: number;
+declare const P_FY: number;
+declare const SLOT_PLANES: number;
+declare const SLOT_BYTES: number;
+/** Pigment channels per cell. */
+declare const PIGMENT_CHANNELS = 4;
+/** D2Q9 lattice velocities: 0 rest, 1–4 axis (E, S, W, N in screen space), 5–8 diagonals. */
+declare const EX: readonly [0, 1, 0, -1, 0, 1, -1, -1, 1];
+declare const EY: readonly [0, 0, 1, 0, -1, 1, 1, -1, -1];
+declare const OPP: readonly [0, 3, 4, 1, 2, 7, 8, 5, 6];
+declare const W9: readonly [number, number, number, number, number, number, number, number, number];
+/** Water shallower than this counts as dry. */
+declare const DRY_EPS = 0.001;
+/** Fluid speed cap in cells per step: keeps the LBM low-Mach and the pigment flux CFL-stable. */
+declare const U_MAX = 0.25;
+/** A tile's wet cells within this many cells of an edge wake the neighbouring tile. */
+declare const STRIP = 64;
+/** Steps per batch at most: the wake-up strip stays ahead of anything that moves a cell a step. */
+declare const MAX_BATCH = 32;
+/** Dry tiles are baked and freed only on steps that are multiples of this (so it is deterministic). */
+declare const FREE_INTERVAL = 32;
+/** Per-tile flag bits a step returns. */
+declare const FLAG_ALIVE = 1;
+declare const FLAG_LEFT = 2;
+declare const FLAG_RIGHT = 4;
+declare const FLAG_TOP = 8;
+declare const FLAG_BOTTOM = 16;
+declare const FLAG_WET = 32;
+/** f32 parameters per lane (one per wet layer). */
+declare const PARAM_FLOATS = 32;
+/** Index of each packed parameter (the kernels read these offsets). */
+declare const PARAM: {
+    readonly omega: 0;
+    readonly tau: 1;
+    readonly evap: 2;
+    readonly edgeEvap: 3;
+    readonly mobility: 4;
+    readonly depRate: 5;
+    readonly pickup: 6;
+    readonly absorption: 7;
+    readonly invCap: 8;
+    readonly blockScale: 9;
+    readonly rough: 10;
+    readonly pinT: 11;
+    readonly gx: 12;
+    readonly gy: 13;
+    readonly flowK: 14;
+    readonly granulation: 15;
+    readonly edgeDep: 16;
+    readonly bloom: 17;
+    readonly paperEvap: 18;
+    readonly hasFlow: 19;
+    readonly bleed: 20;
+};
+/**
+ * A wet layer's settings, each 0..1 unless noted. The paper's absorption, permeability and
+ * roughness come from the paper, not from here.
+ */
+interface WetParams {
+    /** How thick the water is: 0 runny (ink) .. 1 very thick (oil). Default 0.3 (watercolour). */
+    viscosity: number;
+    /** How fast the water dries: 0 never .. 1 very fast. Default 0.45. */
+    evaporation: number;
+    /** Darker, crisper edges where a wash dries: 0 none .. 1 strong. Default 0.5. */
+    edgeDarkening: number;
+    /** How heavy the pigment is: heavy pigment travels less and settles sooner. Default 0.3. */
+    pigmentWeight: number;
+    /** How much pigment collects in the paper's valleys. Default 0.4. */
+    granulation: number;
+    /** How readily water lifts settled pigment back up (re-wetting). Default 0.2. */
+    pickup: number;
+    /** How fast suspended pigment settles into the paper (staining). Default 0.2. */
+    fixture: number;
+    /** Blooms (backruns): water flowing into a drying wash pushes its pigment out. Default 0.4. */
+    bloom: number;
+    /** Colour bleed: pigment spreading between touching wet areas. Default 0.3. */
+    bleed: number;
+}
+declare const DEFAULT_WET_PARAMS: Readonly<WetParams>;
+declare const WET_PARAM_KEYS: (keyof WetParams)[];
+/** The paper as wet media read it (all 0..1; from the paint editor's paper settings). */
+interface WetPaper {
+    absorption: number;
+    permeability: number;
+    roughness: number;
+}
+declare const DEFAULT_WET_PAPER: Readonly<WetPaper>;
+/** Canvas tilt (shared by every wet layer): water runs downhill. */
+interface WetTilt {
+    /** Degrees from flat, 0 (flat) .. 90 (upright). */
+    angle: number;
+    /** Which way is downhill, degrees clockwise from canvas down (0 = towards the bottom edge). */
+    direction: number;
+}
+declare const FLAT: Readonly<WetTilt>;
+/** Settings with every field in range; missing fields come from `base`. */
+declare function normalizeWetParams(raw?: Partial<WetParams>, base?: WetParams): WetParams;
+declare function normalizeTilt(raw?: Partial<WetTilt>, base?: WetTilt): WetTilt;
+/** Kinematic viscosity (lattice units) for `viscosity` 0..1: 0.02 .. 1.5, exponential. */
+declare function latticeViscosity(v: number): number;
+/** Water a cell of paper holds when saturated, in depth units. */
+declare const PAPER_CAPACITY = 0.08;
+/** Largest tilt acceleration (cells per step²), at 90°. */
+declare const MAX_TILT_ACCEL = 0.025;
+/** Packs a lane's settings into the f32 block the kernels read. `flowStrength` 0 turns the flow map off. */
+declare function packWetParams(params: WetParams, paper: WetPaper, tilt: WetTilt, flowStrength: number, out?: Float32Array<ArrayBuffer>): Float32Array;
+/** Flag bits for a wet (or alive) cell at tile-local (lx, ly): which neighbours it wakes. */
+declare function edgeBits(lx: number, ly: number): number;
+
+/**
+ * Loading the wet-media WebAssembly kernel and its Web Workers.
+ *
+ * - The kernel is two small modules (shared memory for workers, ordinary memory for one thread),
+ *   embedded base64 in `kernel-wasm.ts`, which is only ever imported dynamically, so bundlers split
+ *   it into its own chunk and nothing loads until the first wet stroke.
+ * - Workers run from a Blob URL of `wetWorkerMain`'s source: no extra file for the host to serve
+ *   and no bundler configuration. They share one `WebAssembly.Memory`, which needs
+ *   `SharedArrayBuffer`, which browsers only give cross-origin isolated pages (COOP `same-origin`
+ *   plus COEP `require-corp` or `credentialless`). Without it the kernel runs on one thread.
+ * - Everything here is optional: without WebAssembly SIMD the TypeScript kernel runs, with the same
+ *   results (only slower).
+ */
+/** What the wet engine can use here, and why not when it cannot. */
+interface WetSupport {
+    /** WebAssembly with SIMD. */
+    simd: boolean;
+    /** `SharedArrayBuffer` and shared wasm memory (cross-origin isolation in browsers). */
+    sharedMemory: boolean;
+    /** Web Workers. */
+    workers: boolean;
+    /** Logical cores reported (`navigator.hardwareConcurrency`, 1 when unknown). */
+    cores: number;
+    /** A sentence for the user when wet paint will run slower than it could, else `null`. */
+    message: string | null;
+}
+/** Compiles the kernel (`shared`: the shared-memory variant). Cached; loads the chunk once. */
+declare function loadWetKernel(shared: boolean): Promise<WebAssembly.Module>;
+/** Whether shared wasm memory can be made here. */
+declare function canShareMemory(): boolean;
+/** Whether this runtime validates WebAssembly SIMD (checked against the kernel itself). */
+declare function wetSimdSupported(): Promise<boolean>;
+/** What the wet engine can use (SIMD is only known after `wetSimdSupported`). */
+declare function wetSupport(simd?: boolean): WetSupport;
+/** The layout numbers a worker needs. */
+interface WetWorkerLayout {
+    ctl: number;
+    params: number;
+    table: number;
+    list: number;
+    flags: number;
+    last: number;
+    slots: number;
+    slotBytes: number;
+    perLane: number;
+    tilesX: number;
+    tilesY: number;
+    keys: number;
+}
+/** A pool of workers stepping one shared memory together. */
+declare class WetWorkerPool {
+    private readonly workers;
+    private readonly url;
+    private constructor();
+    get size(): number;
+    /** Starts `count` workers on `memory` (shared) with the shared kernel. Rejects if any fails. */
+    static create(count: number, module: WebAssembly.Module, memory: WebAssembly.Memory, layout: WetWorkerLayout): Promise<WetWorkerPool>;
+    /** Runs `steps` steps over the active list in shared memory; resolves when every worker is done. */
+    run(steps: number): Promise<void>;
+    destroy(): void;
+}
+
+/**
+ * `WetWorld`: the wet-media simulation of one canvas. It holds up to `MAX_WET_LANES` wet layers
+ * ("lanes"), each a sparse set of 256 px tile slots in one `WebAssembly.Memory`, and steps all of
+ * them together.
+ *
+ * - **Kernels.** It starts on the TypeScript kernel at once and switches to the WebAssembly SIMD
+ *   kernel (in Web Workers when the page is cross-origin isolated, else on this thread) as soon as
+ *   that has loaded. The kernels give identical bits, so the switch never changes the painting.
+ * - **Determinism.** Time is counted in steps (`clock`), never in wall time. Batches never cross a
+ *   multiple of `FREE_INTERVAL` and are at most `MAX_BATCH` steps, tiles wake up when anything
+ *   alive comes within `STRIP` cells of their edge (so earlier or later wake-ups change nothing),
+ *   and dry tiles are baked and freed only on multiples of `FREE_INTERVAL`, judged by their state
+ *   at that step. So the result depends only on the edits and the steps at which they were made,
+ *   not on frame rate, batch sizes, worker counts or the browser.
+ * - **Edits** (dabs, water, drying, blowing, blending, smudging, blotting, re-wetting) run on this
+ *   thread between batches; while a batch runs (`busy`) they throw, so callers queue them.
+ * - **Display.** Each lane has a `base` surface: the layer's pixels under the wet paint. `display`
+ *   gives the base with every live tile shaded (`filmPixel`), as an ordinary RGBA surface for the
+ *   compositor. Tiles that dry are baked into the base and their slots freed.
+ */
+
+/** Wet layers a world can hold at once. */
+declare const MAX_WET_LANES = 8;
+/** Tile slots at most (about 3.8 GB, inside wasm32's 4 GB). Water reaching a tile past this is lost. */
+declare const MAX_WET_SLOTS = 352;
+/** A flow map: a vector per document pixel, in cells per step² at strength 1. */
+type WetFlowField = (x: number, y: number) => readonly [number, number];
+/** The paper as the simulation reads it. */
+interface WetPaperInput extends WetPaper {
+    /** Grain height 0..1 at a document position (the paper's wet height map). */
+    heightAt(x: number, y: number): number;
+    /** Paper colour, sRGB bytes. */
+    color: readonly [number, number, number];
+}
+type WetKernelKind = 'typescript' | 'wasm' | 'wasm-threads';
+interface WetBackendInfo {
+    kind: WetKernelKind;
+    /** Threads stepping the simulation. */
+    threads: number;
+    /** Why it runs slower than it could, or `null`. */
+    message: string | null;
+}
+interface WetWorldOptions {
+    /** Which kernel: `auto` (default: the fastest available), or force `typescript` / `wasm` (one thread). */
+    kernel?: 'auto' | 'typescript' | 'wasm';
+    /** Worker threads for the wasm kernel: `auto` (default: cores − 1, at most 10) or a number (0: none). */
+    threads?: number | 'auto';
+}
+interface WetLaneOptions {
+    params?: Partial<WetParams>;
+    /** The layer's pixels under the wet paint (default empty). */
+    base?: TiledSurface;
+    flow?: WetFlowField | null;
+    /** Flow map strength (default 1 when a flow map is given). */
+    flowStrength?: number;
+}
+/** Totals for one wet layer. */
+interface WetLaneStats {
+    /** Tiles being simulated. */
+    activeTiles: number;
+    /** Cells with surface water (at least `DRY_EPS` deep). */
+    wetCells: number;
+    /** Water on the surface plus in the paper, in cell-depth units. */
+    water: number;
+    /** Suspended plus settled pigment mass (sum of the four channels). */
+    pigment: number;
+    /** Document rectangle of the wet cells, or `null` when nothing is wet. */
+    wetBounds: RasterRect | null;
+}
+/** A copy of the whole simulation (for undo). */
+interface WetSnapshot {
+    readonly clock: number;
+    readonly tilt: WetTilt;
+    readonly lanes: ReadonlyArray<{
+        id: string;
+        index: number;
+        params: WetParams;
+        flow: WetFlowField | null;
+        flowStrength: number;
+        base: TiledSurface;
+    }>;
+    /** Per active key: the current set and the deposit planes; and its last flags. */
+    readonly slots: ReadonlyMap<number, {
+        planes: Float32Array;
+        last: number;
+    }>;
+    /** Bytes held. */
+    readonly bytes: number;
+}
+/** Thrown for edits while a batch is running, and for bad arguments. */
+declare class WetWorldError extends Error {
+    constructor(message: string);
+}
+interface Layout extends WetWorkerLayout {
+    width: number;
+    height: number;
+}
+declare class WetWorld {
+    readonly width: number;
+    readonly height: number;
+    readonly layout: Layout;
+    /** Steps simulated so far. */
+    clock: number;
+    /** Messages for the user (slots ran out, a backend failed). */
+    readonly warnings: string[];
+    private memory;
+    private readonly shared;
+    private f32;
+    private i32;
+    private u32;
+    private slotCount;
+    private readonly freeSlots;
+    private readonly active;
+    private parity;
+    private readonly lanes;
+    private tilt;
+    private paper;
+    private paperBytes;
+    private kind;
+    private wasm;
+    private pool;
+    private busyFlag;
+    private destroyed;
+    private support;
+    private readonly prm;
+    /** Resolves when the fastest available kernel is running (it may stay `typescript`). */
+    readonly ready: Promise<WetBackendInfo>;
+    constructor(width: number, height: number, paper: WetPaperInput, options?: WetWorldOptions);
+    private views;
+    private start;
+    /** The kernel in use and why it is not faster. */
+    backend(): WetBackendInfo;
+    /** Whether a batch is running (edits throw until it ends). */
+    get busy(): boolean;
+    destroy(): void;
+    private laneOf;
+    hasLane(id: string): boolean;
+    laneIds(): string[];
+    /** Adds a wet layer (or returns it). Throws when `MAX_WET_LANES` are in use. */
+    ensureLane(id: string, options?: WetLaneOptions): void;
+    /** Drops a wet layer and its wet paint (nothing is baked). */
+    removeLane(id: string): void;
+    getParams(id: string): WetParams;
+    setParams(id: string, params: Partial<WetParams>): WetParams;
+    getTilt(): WetTilt;
+    setTilt(tilt: Partial<WetTilt>): WetTilt;
+    /** Changes the paper: heights of live tiles are refilled, rates repacked. */
+    setPaper(paper: WetPaperInput): void;
+    /** Sets a layer's flow map (`null` removes it). */
+    setFlow(id: string, flow: WetFlowField | null, strength?: number): void;
+    hasFlow(id: string): boolean;
+    /** The pixels under a layer's wet paint. */
+    getBase(id: string): TiledSurface;
+    /** Replaces the pixels under a layer's wet paint. */
+    setBase(id: string, base: TiledSurface): void;
+    private pack;
+    private touchAll;
+    private laneIndexOf;
+    private slotOf;
+    private slotBase;
+    private requireIdle;
+    /** Writes the active list into memory for the kernels. */
+    private syncList;
+    private grow;
+    /** Activates a tile of a lane. Returns false when no slot can be had. */
+    private activate;
+    private free;
+    private tileXY;
+    private tileKeyOf;
+    private fillPaper;
+    private fillFlow;
+    /** Activates every tile of a lane within `STRIP` cells of a document rectangle. */
+    private wake;
+    /** Fills one slot's halo in the current set from its neighbours (TypeScript). */
+    private haloTs;
+    private halo;
+    /** Refills every live slot's halo in the current set (after edits or wake-ups). */
+    private refreshHalos;
+    /** Whether anything is being simulated (in `id`, or any layer). */
+    isActive(id?: string): boolean;
+    /** Steps until the next batch boundary: at most `want`, `MAX_BATCH`, and the next free check. */
+    private batchSize;
+    /** Runs `n` steps on this thread (TypeScript or wasm kernel). */
+    private runHere;
+    /** After a batch: wake neighbours from the flags, free dead tiles on a free step, restamp. */
+    private afterBatch;
+    /**
+     * Steps the simulation `steps` times on this thread (the TypeScript or single-thread wasm
+     * kernel). Throws while worker threads are in use; use `step` there.
+     */
+    stepSync(steps: number): number;
+    /** Steps the simulation `steps` times (in worker threads when there are any). */
+    step(steps: number): Promise<number>;
+    /** Steps until nothing is wet or `maxSteps` have run. Returns the steps run. */
+    stepUntilDry(maxSteps: number): Promise<number>;
+    /** Float index of a cell's plane-0 value in the current set, or −1 (inactive / off the canvas). */
+    private cell;
+    /** Index of the same cell in the single (deposit, height, flow) planes, given `cell`. */
+    private single;
+    /**
+     * Runs `fn` for every cell of a footprint (`cov` over `rect`, document cells) on a lane, waking
+     * the tiles around it first, then refreshes halos. `fn` gets the cell index and its coverage.
+     */
+    private footprint;
+    private markEdited;
+    /** Adds water (depth units) at rest. */
+    private addWaterAt;
+    /**
+     * Lays paint: `water` depth and pigment mass `pigment` (K r, g, b, S) per unit of coverage, or
+     * per pixel from `field` (4 values per pixel of `rect`). Pigment without water lands straight in
+     * the paper (settled).
+     */
+    paint(id: string, rect: RasterRect, cov: ArrayLike<number> | null, water: number, pigment: ArrayLike<number> | null, field?: ArrayLike<number> | null): void;
+    /** Damp paper: fills the paper's water towards its capacity by `amount` (0..1) × coverage, plus a thin film of surface water. */
+    wetPaper(id: string, rect: RasterRect, cov: ArrayLike<number> | null, amount: number): void;
+    /**
+     * Takes water (and suspended pigment, and settled pigment) away: `water`, `suspended`,
+     * `settled` are fractions 0..1 × coverage. A hair dryer takes water only (the pigment stays and
+     * settles); blotting takes all three.
+     */
+    remove(id: string, rect: RasterRect, cov: ArrayLike<number> | null, water: number, suspended: number, settled: number, paperWater?: number): void;
+    /** Pushes the water: adds velocity (`ux`, `uy` cells per step, each at most 0.1) × coverage. */
+    push(id: string, rect: RasterRect, cov: ArrayLike<number> | null, ux: number, uy: number): void;
+    /** Blends wet paint: each wet cell's suspended pigment moves `strength` × coverage towards the footprint's mean. */
+    blend(id: string, rect: RasterRect, cov: ArrayLike<number> | null, strength: number): void;
+    /**
+     * Drags wet paint by (`dx`, `dy`) cells: each footprint cell takes `strength` × coverage of the
+     * water and suspended pigment of the cell it came from (a smudge through wet paint).
+     */
+    drag(id: string, rect: RasterRect, cov: ArrayLike<number> | null, dx: number, dy: number, strength: number): void;
+    /**
+     * Re-wetting: lifts `amount` × coverage of the dried paint in the layer's pixels (`base`) back into
+     * the paper as settled pigment, so water can move it again. Only where there is surface water.
+     */
+    rewet(id: string, rect: RasterRect, cov: ArrayLike<number> | null, amount: number, paper: readonly [number, number, number]): void;
+    /**
+     * Dries wet paint at once (everything settles where it is, the water goes): in `rect`, or the
+     * whole layer. Whole tiles that end up dry are baked into the base and freed. Returns the
+     * document rectangle that changed, or `null`.
+     */
+    dry(id: string, rect?: RasterRect): RasterRect | null;
+    /**
+     * Bakes a slot's pigment into its lane's base (settling suspended pigment too when `all`).
+     * Returns whether any pixel changed.
+     */
+    private bakeKey;
+    /**
+     * Shades one slot over a base tile. `display`: the wet look (suspended + settled, wet paper a
+     * little darker); `bake`: settled pigment only; `bake-all`: suspended and settled (dry now).
+     * Returns `null` when nothing would change the base.
+     */
+    private shadeSlot;
+    /** The layer's pixels with all its wet paint dried where it is (the bake of "dry on save"); changes nothing. */
+    bakedSurface(id: string): TiledSurface;
+    /**
+     * Sums over a footprint of a lane, weighted by coverage: `weight` (coverage), `water` (surface
+     * depth), `wet` (coverage of wet cells), `pigment` (suspended, 4 channels), `settled` (4 channels).
+     */
+    sample(id: string, rect: RasterRect, cov: ArrayLike<number> | null): {
+        weight: number;
+        water: number;
+        wet: number;
+        pigment: number[];
+        settled: number[];
+    };
+    /** Surface water depth at a document cell (0 where nothing is simulated). */
+    waterAt(id: string, x: number, y: number): number;
+    /** Totals for a layer (scans its live tiles). */
+    stats(id: string): WetLaneStats;
+    /** Whether a layer (or any) has surface water anywhere. */
+    isWet(id?: string): boolean;
+    /** Document rectangles of a layer's live tiles. */
+    activeRects(id: string): RasterRect[];
+    /** A number that changes whenever a layer's display may have changed. */
+    stamp(id: string): number;
+    /**
+     * The layer's pixels with its wet paint shaded in: the base with each live tile shaded over it.
+     * At most `maxTiles` stale tiles are reshaded per call (edited tiles first); the rest keep their
+     * last shading until the next call. Returns the surface and the tiles reshaded.
+     */
+    display(id: string, maxTiles?: number): {
+        surface: TiledSurface;
+        changed: RasterRect[];
+        pending: number;
+    };
+    /**
+     * The water as an overlay tile (RGBA, blue, alpha from surface depth and damp paper) for a
+     * document tile, or `null` where nothing is wet.
+     */
+    waterOverlay(id: string, tx: number, ty: number): Uint8ClampedArray | null;
+    /** A copy of everything (for undo): live slots, layers, clock and tilt. */
+    snapshot(): WetSnapshot;
+    /** Puts a snapshot back exactly (the simulation then continues as it would have). */
+    restore(snap: WetSnapshot): void;
+    /** Bytes of wasm memory held. */
+    memoryBytes(): number;
+    /** Live tiles across all layers. */
+    activeTiles(): number;
+    /** Memory for tests and tools: the raw f32 view (read only, please). */
+    get rawFloats(): Float32Array;
+    /** The current set's parity (tests). */
+    get currentParity(): number;
+    /** Float index of a slot's first plane (tests). */
+    slotIndex(id: string, tx: number, ty: number): number;
+}
+
+/**
+ * Flow maps: a push on the water at every cell (cells per step², like tilt), from a few generated
+ * patterns. Every pattern is computed with + − × ÷ only, so it is the same in every engine.
+ */
+
+type WetFlowKind = 'none' | 'linear' | 'swirl' | 'radial' | 'turbulent';
+declare const WET_FLOW_KINDS: readonly WetFlowKind[];
+/** A flow map as settings (saved with the document). */
+interface WetFlowSpec {
+    kind: WetFlowKind;
+    /** 0..1: how hard it pushes (1 is about as strong as a 25° tilt). */
+    strength: number;
+    /** `linear`: direction in degrees clockwise from canvas down. */
+    angle: number;
+    /** `swirl` / `radial`: centre in document pixels (default the canvas centre). */
+    center?: {
+        x: number;
+        y: number;
+    };
+    /** `swirl`: true turns clockwise. */
+    clockwise: boolean;
+    /** `turbulent`: eddy size in pixels (8..1024). */
+    scale: number;
+    seed: number;
+}
+declare const DEFAULT_FLOW: Readonly<WetFlowSpec>;
+/** sin and cos of an angle in radians, by range reduction and Taylor series (deterministic). */
+declare function dsincos(a: number): [number, number];
+/** Settings with every field in range. */
+declare function normalizeFlow(raw?: Partial<WetFlowSpec>, base?: WetFlowSpec): WetFlowSpec;
+/** The flow field of a spec on a canvas, or `null` for `none` (strength is applied by the world). */
+declare function flowField(spec: WetFlowSpec, width: number, height: number): WetFlowField | null;
+
+export { FLAG_RIGHT as $, normalizeWetParams as A, type BrushSettings as B, CoverageMap as C, type Dab as D, wetSupport as E, type BlenderScratch as F, DEFAULT_BLENDER as G, DEFAULT_BRUSH as H, DEFAULT_MIXER as I, DEFAULT_RETOUCH as J, DEFAULT_SMUDGE as K, DEFAULT_WET_PAPER as L, type MixerSettings as M, DRY_EPS as N, DabWalker as O, type PaintTileTarget as P, EMPTY_MIXER_LOAD as Q, type RetouchSettings as R, StrokeCoverage as S, TileMedium as T, EX as U, EY as V, WetWorld as W, type ExchangeRates as X, FLAG_ALIVE as Y, FLAG_BOTTOM as Z, FLAG_LEFT as _, type MixerLoad as a, blendRadius as a$, FLAG_TOP as a0, FLAG_WET as a1, FLAT as a2, FREE_INTERVAL as a3, MAX_BATCH as a4, MAX_TILT_ACCEL as a5, MAX_WET_LANES as a6, MAX_WET_SLOTS as a7, MIXER_DRAIN as a8, MIXER_PICKUP_RATE as a9, type RetouchSample as aA, SET_PLANES as aB, SLOT_BYTES as aC, SLOT_PLANES as aD, SLOT_SIDE as aE, SPOT_HEAL_TYPES as aF, STRIP as aG, type SmudgeDab as aH, SmudgeTip as aI, type SpotHealType as aJ, TONE_RANGES as aK, type TileMediumOptions as aL, TilePixelSource as aM, type ToneRange as aN, U_MAX as aO, W9 as aP, WET_TILE as aQ, type WetFlowField as aR, type WetKernelKind as aS, type WetLaneOptions as aT, type WetLaneStats as aU, type WetPaper as aV, type WetWorkerLayout as aW, WetWorkerPool as aX, WetWorldError as aY, applyRetouchToTile as aZ, applyStrokeToTile as a_, MIXING_MODELS as aa, OPP as ab, PAPER_CAPACITY as ac, PARAM as ad, PARAM_FLOATS as ae, PIGMENT_CHANNELS as af, PLANE as ag, PLANE_BYTES as ah, P_D0 as ai, P_EDGE as aj, P_FX as ak, P_FY as al, P_H as am, P_P0 as an, P_RHO as ao, P_SW as ap, P_UX as aq, P_UY as ar, PaintExchange as as, type PaintMedium as at, type PaintSample as au, type PixelSource as av, RETOUCH_SAMPLES as aw, RegionPixelSource as ax, type RetouchDabEffect as ay, RetouchDabStroke as az, type MixerTarget as b, blenderDab as b0, canShareMemory as b1, cleanMixer as b2, coverageTileCoord as b3, createBlenderScratch as b4, dabCoverage as b5, dabRect as b6, dodgeBurn as b7, dodgeBurnCurve as b8, dsincos as b9, spotHealWindow as bA, tipFalloff as bB, tipReach as bC, tipShape as bD, toneOf as bE, walkDabs as bF, wetSimdSupported as bG, edgeBits as ba, exchangeRates as bb, flowField as bc, healPixels as bd, latticeViscosity as be, loadMixer as bf, loadWetKernel as bg, luma as bh, mixerRates as bi, normalizeBlender as bj, normalizeBrush as bk, normalizeMixer as bl, normalizeRetouch as bm, normalizeSmudge as bn, normalizeTilt as bo, packWetParams as bp, perDabStrength as bq, rasterizeDab as br, readSourceRegion as bs, rgbaViewOfGrey as bt, saturationOf as bu, smoothPoints as bv, smudgeEffect as bw, sponge as bx, spongeEffect as by, spotHealPixels as bz, MixerStroke as c, type RetouchApply as d, type StrokePoint as e, type RetouchPaint as f, type StrokeApply as g, type MixingModel as h, type BlenderSettings as i, type SmudgeSettings as j, type WetTilt as k, type WetParams as l, type WetFlowSpec as m, type RgbTriple as n, type WetWorldOptions as o, type WetBackendInfo as p, type WetSnapshot as q, type WetPaperInput as r, DEFAULT_FLOW as s, DEFAULT_WET_PARAMS as t, MAX_BRUSH_SIZE as u, WET_FLOW_KINDS as v, WET_PARAM_KEYS as w, type WetFlowKind as x, type WetSupport as y, normalizeFlow as z };