@pixerate/editor 0.135.0 → 0.137.0

package/dist/rand-Cw9VLrVC.d.cts

@@ -0,0 +1,1118 @@
+import { a as BlendMode, R as RasterRect, T as TiledSurface } from './surface-1MRncXpF.cjs';
+import { T as TileMedium, D as Dab, B as BrushSettings, P as PaintTileTarget, S as StrokePoint, f as PaintPixels, C as CoverageMap, d as SmudgeSettings } from './blending-D7jCmjO6.cjs';
+
+/**
+ * The retouching tools on the shared brush engine: Clone Stamp, Healing Brush, Spot Healing
+ * Brush, Smudge, Dodge, Burn and Sponge. Two stroke shapes cover them all:
+ *
+ * - **Accumulate, then composite** (Clone Stamp, Dodge, Burn; the Healing tools' result): the
+ *   stroke's dabs build up one `CoverageMap` (flow builds towards the dab's opacity ceiling), and
+ *   per-pixel paint taken from the pre-stroke state (a cloned source, a toned copy of the pixel,
+ *   a healed patch) is composited through it with `applyRetouchToTile`. Pixels painted earlier in
+ *   the stroke are never sampled again, and overlapping dabs never exceed the stroke's opacity.
+ * - **Sequential dabs** (Smudge, Sponge): `RetouchDabStroke` runs each dab in order over live
+ *   tiles, so dab n sees what dab n − 1 did.
+ *
+ * The Healing Brush clones while it is drawn and, when the stroke ends, replaces the clone with a
+ * seamless clone (`healPixels`, Poisson blending): the source's texture with the colour and light
+ * of the pixels around the stroke. The Spot Healing Brush finds its own source (`spotHealPixels`).
+ *
+ * Tone curves (`dodgeBurnCurve`, `dodgeBurn`, `sponge`) are photocraft's, made to behave like
+ * Photoshop's tools: the chosen range moves most, black and white stay put for midtones, and
+ * Protect Tones works on luma so hue and saturation are kept. Data in, pixels out; no DOM.
+ */
+
+/** The tonal range Dodge and Burn work on most. */
+type ToneRange = 'shadows' | 'midtones' | 'highlights';
+declare const TONE_RANGES: readonly ToneRange[];
+/** Rec. 601 luma of straight RGB (0..1). */
+declare function luma(r: number, g: number, b: number): number;
+/** The dodge (or burn) transfer of one value `v` (0..1) at exposure `e` (0..1). */
+declare function dodgeBurnCurve(v: number, e: number, range: ToneRange, burn: boolean): number;
+/**
+ * Dodge (or burn) straight RGB `c` (0..1, written in place) at exposure `e`. With `protectTones`
+ * the curve moves luma and the colour is scaled to it (hue and saturation kept); otherwise each
+ * channel goes through the curve.
+ */
+declare function dodgeBurn(c: number[], e: number, range: ToneRange, burn: boolean, protectTones: boolean): number[];
+/** HSV saturation (chroma / max) of straight RGB. */
+declare function saturationOf(r: number, g: number, b: number): number;
+/**
+ * Sponge: moves straight RGB `c` (written in place) away from (`saturate`) or towards its luma
+ * grey by `amount` (0..1). `vibrance` damps it where it would clip: saturating touches already
+ * saturated colours less, desaturating touches near-greys less. Gamut-compressed, never clipped.
+ */
+declare function sponge(c: number[], amount: number, saturate: boolean, vibrance: boolean): number[];
+/** Per-dab strength so that one pass over a point totals about `e`, whatever the spacing. */
+declare function perDabStrength(e: number, spacing: number): number;
+/** Which pixels the Clone Stamp and the Healing tools sample. */
+type RetouchSample = 'current' | 'current-below' | 'all';
+declare const RETOUCH_SAMPLES: readonly RetouchSample[];
+/** How the Spot Healing Brush finds its source. */
+type SpotHealType = 'proximity-match' | 'content-aware' | 'smooth';
+declare const SPOT_HEAL_TYPES: readonly SpotHealType[];
+/** The retouching tools' options. */
+interface RetouchSettings {
+    /** Clone / heal: keep the source offset from stroke to stroke (default true); off, every stroke starts at the source point. */
+    aligned: boolean;
+    /** Clone / heal / spot heal: what is sampled (default `current`: the target layer). */
+    sample: RetouchSample;
+    /** Spot heal: `proximity-match` (default: the best matching patch nearby), `content-aware` (texture and edges synthesised from patches around it) or `smooth` (a smooth fill from the edges). */
+    spotType: SpotHealType;
+    /** Dodge / burn: the tonal range (default `midtones`). */
+    range: ToneRange;
+    /** Dodge / burn: exposure 0..1 (default 0.5). */
+    exposure: number;
+    /** Dodge / burn: tone luma only, keeping hue and saturation (default true). */
+    protectTones: boolean;
+    /** Sponge: `desaturate` (default) or `saturate`. */
+    spongeMode: 'desaturate' | 'saturate';
+    /** Sponge: damp the change where colours would clip (default true). */
+    vibrance: boolean;
+    /** Smudge: how strongly the finger carries and lays paint; Blur / Sharpen: how strongly they act, 0..1 (default 0.5). */
+    strength: number;
+    /** History Brush: how many undo steps back it paints from; 0 (default) is the oldest state history keeps. */
+    historySteps: number;
+}
+declare const DEFAULT_RETOUCH: Readonly<RetouchSettings>;
+/** Retouch settings with every field valid (missing or invalid fields from `base`). */
+declare function normalizeRetouch(raw?: Partial<RetouchSettings>, base?: RetouchSettings): RetouchSettings;
+/**
+ * Box blur of `data` (`w × h × n` floats) in place, `r` pixels each side, edges clamped. RGBA
+ * blurs premultiplied, so transparent pixels lend no colour. Run twice for a near-Gaussian.
+ */
+declare function boxBlurPixels(data: Float32Array, w: number, h: number, n: 1 | 4, r: number): void;
+/**
+ * The Blur / Sharpen tools' filter over a padded region (`w × h × n` floats on the 0..255 scale,
+ * in place): `blur` is two box passes of `radius`; `sharpen` is an unsharp mask of `amount`
+ * over a radius-1 blur (colour only; alpha kept). Values stay at or above 0.
+ */
+declare function retouchFilter(data: Float32Array, w: number, h: number, n: 1 | 4, kind: 'blur' | 'sharpen', radius?: number, amount?: number): void;
+/** Pixels a retouching stroke samples, by document pixel. */
+interface PixelSource {
+    /** Straight RGBA 0..255 of document pixel (x, y) into `out`; false (and `out` zeroed) where there is nothing. */
+    sample(x: number, y: number, out: number[]): boolean;
+}
+/**
+ * Photoshop's Clone Source transform: the cloned pixels appear scaled by `scaleX` / `scaleY`
+ * (negative flips) and rotated by `rotate` degrees (clockwise) about the stroke's start.
+ */
+interface CloneTransform {
+    scaleX: number;
+    scaleY: number;
+    rotate: number;
+}
+declare const IDENTITY_CLONE_TRANSFORM: CloneTransform;
+declare function isIdentityCloneTransform(t: CloneTransform): boolean;
+/**
+ * Where a clone samples for target point (`x`, `y`): `source + M⁻¹ · (p − anchor)`, with `M` the
+ * transform (scale then rotate) and `anchor` the target point that maps onto the source point.
+ */
+declare function cloneSamplePoint(t: CloneTransform, source: {
+    x: number;
+    y: number;
+}, anchor: {
+    x: number;
+    y: number;
+}, x: number, y: number): [number, number];
+/** A source seen through a map from document points to source points (bilinear, premultiplied). */
+declare class TransformedPixelSource implements PixelSource {
+    private readonly inner;
+    private readonly map;
+    private readonly px;
+    constructor(inner: PixelSource, map: (x: number, y: number) => [number, number]);
+    sample(x: number, y: number, out: number[]): boolean;
+}
+/**
+ * A source over raster tiles (layer pixels, a mask, or composite tiles): `readTile` gives tile
+ * (tx, ty) in source space or `null` when it is empty; source pixel = document pixel − `offset`.
+ * One-channel tiles read as grey (alpha 255). Tiles are cached, so make one per stroke.
+ */
+declare class TilePixelSource implements PixelSource {
+    /** A tile's bytes, or a float working tile on the same 0..255 scale (16 / 32 bits). */
+    private readonly readTile;
+    readonly channels: 1 | 4;
+    readonly offset: {
+        x: number;
+        y: number;
+    };
+    private readonly cache;
+    private lastKey;
+    private last;
+    constructor(
+    /** A tile's bytes, or a float working tile on the same 0..255 scale (16 / 32 bits). */
+    readTile: (tx: number, ty: number) => PaintPixels | null, channels: 1 | 4, offset?: {
+        x: number;
+        y: number;
+    });
+    sample(x: number, y: number, out: number[]): boolean;
+}
+/** A source over a region of float RGBA pixels (0..255), e.g. a healed patch. */
+declare class RegionPixelSource implements PixelSource {
+    readonly rect: RasterRect;
+    readonly data: Float32Array;
+    constructor(rect: RasterRect, data: Float32Array);
+    sample(x: number, y: number, out: number[]): boolean;
+}
+/** `rect` of a source, shifted by (dx, dy), as float RGBA 0..255 (`rect.width × rect.height × 4`). */
+declare function readSourceRegion(source: PixelSource, rect: RasterRect, dx?: number, dy?: number): Float32Array;
+/** What a coverage-based retouching stroke lays through its coverage. */
+type RetouchPaint = 
+/** Source pixels at document pixel + (dx, dy) (Clone Stamp, a healed patch). */
+{
+    kind: 'source';
+    source: PixelSource;
+    dx: number;
+    dy: number;
+}
+/** The target pixel itself, toned (Dodge, Burn): `tone` edits straight RGB 0..1 in place. */
+ | {
+    kind: 'tone';
+    tone: (rgb: number[]) => void;
+}
+/** A flat colour (the Spot Healing Brush's trail while it is drawn), RGBA 0..255. */
+ | {
+    kind: 'color';
+    color: readonly [number, number, number, number];
+};
+/** How a coverage-based retouching stroke composites. */
+interface RetouchApply {
+    /** Stroke opacity 0..1. */
+    opacity: number;
+    /** Blend mode for source paint (default normal). */
+    blend?: BlendMode;
+    lockTransparency: boolean;
+    /** Selection coverage (document space, canvas-sized), or `null`. */
+    selection: {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+    /** Layer offset (target pixels are in layer space). */
+    offset: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Composites `paint` through the stroke's coverage over `tileData` (target tile (tx, ty) as it was
+ * before the stroke, layer space; RGBA, or one byte per pixel for masks) and returns the new tile.
+ * With `into` (the previous result) and `region` (document space), only `region` is recomputed.
+ * Tone paint keeps alpha; source and colour paint composite with `blend` (source-over by
+ * default), keeping alpha on a locked layer.
+ */
+declare function applyRetouchToTile<T extends PaintPixels>(coverage: CoverageMap, tileData: T, channels: 1 | 4, tx: number, ty: number, paint: RetouchPaint, s: RetouchApply, options?: {
+    into?: T;
+    region?: RasterRect;
+}): T;
+/**
+ * Dodge / Burn at 16 or 32 bits: `applyRetouchToTile`'s tone paint on a layer tile's deep samples
+ * (`Uint16Array` sRGB-encoded, or `Float32Array` linear light, RGBA). The tone curves work on
+ * encoded values as at 8 bits, so 32-bit samples are encoded, toned and decoded (colour above 1 is
+ * toned at 1 and keeps its excess). Returns the new samples.
+ */
+declare function applyToneToDeepTile(coverage: CoverageMap, samples: Uint16Array | Float32Array, tx: number, ty: number, tone: (rgb: number[]) => void, s: RetouchApply, options?: {
+    into?: Uint16Array | Float32Array;
+    region?: RasterRect;
+}): Uint16Array | Float32Array;
+/** The tone function of a Dodge or Burn stroke. */
+declare function toneOf(tool: 'dodge' | 'burn', settings: Pick<RetouchSettings, 'exposure' | 'range' | 'protectTones'>): (rgb: number[]) => void;
+/**
+ * Heals `src` into `dst` over `mask` (all `w × h`, RGBA floats 0..255): a seamless clone solved
+ * only over the mask's bounds plus a one-pixel fixed ring; elsewhere the result is `dst`.
+ */
+declare function healPixels(w: number, h: number, src: Float32Array, dst: Float32Array, mask: ArrayLike<boolean | number>): Float32Array;
+/**
+ * Spot healing: fills `hole` (`w × h`) of `img` (RGBA floats 0..255) with no given source, then
+ * heals the fill into its surroundings. `proximity-match` copies the best matching nearby patch
+ * (falling back to `smooth` when none fits); `smooth` interpolates the edges inwards. `size` is
+ * the brush diameter in pixels. Returns the healed pixels over the whole grid.
+ */
+declare function spotHealPixels(w: number, h: number, img: Float32Array, hole: ArrayLike<boolean | number>, size: number, type: SpotHealType, 
+/** Told the patch offset it copied (`null`: a smooth fill). */
+onOffset?: (offset: [number, number] | null) => void): Float32Array;
+/** The window a Spot Healing stroke over `bounds` looks for texture in: the bounds grown by their size, on the canvas. */
+declare function spotHealWindow(bounds: RasterRect, canvas: {
+    width: number;
+    height: number;
+}): RasterRect;
+/**
+ * One dab of a sequential retouching stroke: `cov` is the tip's pure coverage over `rect`
+ * (document space, 0..1); `d.alpha` is the flow and `d.opacity` the pressure opacity.
+ */
+type RetouchDabEffect = (medium: TileMedium, d: Dab, rect: RasterRect, cov: Float32Array) => void;
+/**
+ * A stroke whose dabs edit live tiles in order (Smudge, Sponge). Feed points with `push` (any
+ * chunks give the same dabs), end with `finish`; each returns the document rectangles it touched.
+ */
+declare class RetouchDabStroke {
+    readonly brush: BrushSettings;
+    private readonly effect;
+    dabCount: number;
+    bounds: RasterRect | null;
+    private readonly walker;
+    private readonly medium;
+    private smoothPos;
+    private buf;
+    constructor(brush: BrushSettings, target: PaintTileTarget, effect: RetouchDabEffect);
+    push(points: readonly StrokePoint[]): RasterRect[];
+    finish(last?: StrokePoint): RasterRect[];
+    private smooth;
+    private paint;
+}
+/** The Smudge's per-dab effect: a `SmudgeTip` whose strength carries and lays the paint. */
+declare function smudgeEffect(brush: BrushSettings, strength: number, mixing?: SmudgeSettings['mixing']): RetouchDabEffect;
+/** The Sponge's per-dab effect: each dab moves saturation by about half its flow, compounding over passes. */
+declare function spongeEffect(brush: BrushSettings, saturate: boolean, vibrance: boolean): RetouchDabEffect;
+/**
+ * An RGBA view of one-channel tiles (masks), for the sequential-dab tools: reads expand grey to
+ * opaque RGB, writes land in RGBA copies, and `flush` writes their red channel back through
+ * `target.writeTile`. Alpha is locked, so a mask's values are all a dab changes.
+ */
+declare function rgbaViewOfGrey(target: PaintTileTarget): {
+    target: PaintTileTarget;
+    flush(): void;
+};
+
+/**
+ * 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;
+}
+
+/**
+ * Engine B: the wet-media step and display shading on WebGPU, an accelerator for large wet areas.
+ *
+ * The CPU engine (`WetWorld`, WebAssembly SIMD) stays the authority: it owns the clock, edits,
+ * drying, save, export and replay, and gives the same bits everywhere. This engine mirrors the CPU
+ * state on the GPU (same slot layout, uploaded region by region as the CPU edits it), steps it and
+ * shades it into RGBA8 tiles for display. Its results stay within about 1/255 of the CPU's but are
+ * not bit-identical (shader compilers differ), so nothing it computes is ever saved.
+ *
+ * DOM-free and dependency-free: it takes a `navigator.gpu`-like object (or finds one) and uses
+ * only the WebGPU API. Without one, `createWetGpuEngine` says why and the CPU does everything.
+ */
+interface GBuffer {
+    readonly size: number;
+    destroy(): void;
+    mapAsync(mode: number, offset?: number, size?: number): Promise<void>;
+    getMappedRange(offset?: number, size?: number): ArrayBuffer;
+    unmap(): void;
+}
+interface GPass {
+    setPipeline(p: unknown): void;
+    setBindGroup(i: number, g: unknown): void;
+    dispatchWorkgroups(x: number, y?: number, z?: number): void;
+    end(): void;
+}
+interface GEncoder {
+    beginComputePass(): GPass;
+    copyBufferToBuffer(src: GBuffer, so: number, dst: GBuffer, d: number, size: number): void;
+    clearBuffer(b: GBuffer, offset?: number, size?: number): void;
+    finish(): unknown;
+}
+interface GQueue {
+    writeBuffer(b: GBuffer, offset: number, data: ArrayBufferView | ArrayBufferLike, dataOffset?: number, size?: number): void;
+    submit(cmds: unknown[]): void;
+    onSubmittedWorkDone(): Promise<void>;
+}
+interface GPipeline {
+    getBindGroupLayout(i: number): unknown;
+}
+interface GDevice {
+    readonly queue: GQueue;
+    readonly limits: Record<string, number>;
+    readonly lost?: Promise<{
+        message?: string;
+        reason?: string;
+    }>;
+    createBuffer(d: {
+        size: number;
+        usage: number;
+        label?: string;
+    }): GBuffer;
+    createShaderModule(d: {
+        code: string;
+        label?: string;
+    }): unknown;
+    createComputePipeline(d: {
+        layout: 'auto';
+        compute: {
+            module: unknown;
+            entryPoint: string;
+        };
+        label?: string;
+    }): GPipeline;
+    createComputePipelineAsync?(d: {
+        layout: 'auto';
+        compute: {
+            module: unknown;
+            entryPoint: string;
+        };
+        label?: string;
+    }): Promise<GPipeline>;
+    createBindGroup(d: {
+        layout: unknown;
+        entries: {
+            binding: number;
+            resource: {
+                buffer: GBuffer;
+                offset?: number;
+                size?: number;
+            };
+        }[];
+    }): unknown;
+    createCommandEncoder(): GEncoder;
+    pushErrorScope?(filter: string): void;
+    popErrorScope?(): Promise<{
+        message: string;
+    } | null>;
+    destroy(): void;
+}
+/** A `navigator.gpu`-like object. */
+interface WetGpuProvider {
+    requestAdapter(options?: {
+        powerPreference?: 'high-performance' | 'low-power';
+    }): Promise<unknown>;
+}
+/** Whether Engine B can run here, and if not, why. */
+interface WetGpuSupport {
+    supported: boolean;
+    /** Why not (no WebGPU, no adapter, too little buffer space, the device failed), or `null`. */
+    reason: string | null;
+    /** The GPU's vendor and architecture, when known. */
+    adapter: string | null;
+    /** Most wet tiles (256 px, all layers) the GPU can hold. */
+    maxSlots: number;
+}
+/** A tile to step or shade: its slot, lane, the slots of its 8 neighbours, and its size on the canvas. */
+interface WetGpuJob {
+    slot: number;
+    lane: number;
+    /** Neighbour slots in the order n, s, w, e, nw, ne, sw, se; −1 for none. */
+    neighbours: readonly number[];
+    /** Pixels of the tile on the canvas (256 except at the right and bottom edges). */
+    width: number;
+    height: number;
+}
+/** The `navigator.gpu` of this context, if any. */
+declare function findWebGpu(): WetGpuProvider | null;
+/**
+ * Starts Engine B on `gpu` (default `navigator.gpu`). Resolves with the engine, or `null` and the
+ * reason it cannot run (no WebGPU, no adapter, too little storage-buffer space, a failed device).
+ */
+declare function createWetGpuEngine(gpu?: WetGpuProvider | null): Promise<{
+    engine: WetGpuEngine | null;
+    support: WetGpuSupport;
+}>;
+/** Whether Engine B can run here (starts and stops a device). */
+declare function wetGpuSupport(gpu?: WetGpuProvider | null): Promise<WetGpuSupport>;
+/** The engine on a started device. Make one with `createWetGpuEngine`. */
+declare class WetGpuEngine {
+    private readonly device;
+    /** Most tiles the GPU can hold. */
+    readonly maxSlots: number;
+    /** The GPU, when known. */
+    readonly adapter: string | null;
+    private readonly stepPipe;
+    private readonly haloPipe;
+    private readonly shadePipe;
+    /** Steps run on the GPU so far (for stats). */
+    steps: number;
+    /** Set once the device is lost; the engine does nothing after that. */
+    lostReason: string | null;
+    private state;
+    private slots;
+    private readonly params;
+    private jobs;
+    private jobCap;
+    private flags;
+    private flagsRead;
+    private readonly uni;
+    private readonly shadeUni;
+    private srcTiles;
+    private outTiles;
+    private outRead;
+    private tileCap;
+    private groups;
+    private constructor();
+    /** @internal Compiles the kernels; use `createWetGpuEngine`. */
+    static start(device: GDevice, maxSlots: number, adapter: string | null): Promise<WetGpuEngine>;
+    /** Bytes of GPU memory in use. */
+    memoryBytes(): number;
+    /** Slots the state buffer holds now. */
+    get capacity(): number;
+    /** Grows the state buffer to hold `n` slots (keeping its contents). Returns false past `maxSlots`. */
+    ensureSlots(n: number): boolean;
+    /** Writes floats into a slot (`offset` floats from the slot's start). */
+    writeSlot(slot: number, offset: number, data: Float32Array): void;
+    /** Sets a lane's packed parameters (`packWetParams`). */
+    setParams(lane: number, prm: Float32Array): void;
+    private writeJobs;
+    private bindGroups;
+    /**
+     * Runs `steps` steps of `jobs` from set `parity` (as the CPU's `runHere`: each step, then each
+     * tile's halo in the new set). With `readFlags`, resolves with each job's flag bits OR-ed over
+     * the steps (`FLAG_*`); otherwise once the work is submitted.
+     */
+    step(jobs: readonly WetGpuJob[], parity: number, steps: number, readFlags?: boolean): Promise<Uint32Array | null>;
+    /** Refills each job's halo in set `parity` from its neighbours (after uploads). */
+    refreshHalos(jobs: readonly WetGpuJob[], parity: number): void;
+    /**
+     * Shades `jobs` (set `parity`) over their base tiles (`src[i]`: RGBA8 256 × 256, or `null` for
+     * transparent) on paper `paper` (sRGB bytes). `mode` 'display' darkens wet paper a little;
+     * 'dried' shows the paint as it would dry. Resolves with one RGBA8 tile per job.
+     */
+    shade(jobs: readonly WetGpuJob[], parity: number, src: readonly (Uint8ClampedArray | null)[], paper: readonly [number, number, number], mode?: 'display' | 'dried'): Promise<Uint8ClampedArray[]>;
+    /** Reads floats back from a slot (tests and diagnostics). */
+    readSlot(slot: number, offset: number, count: number): Promise<Float32Array>;
+    /** Waits for submitted work. */
+    idle(): 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.
+ * - **Engine B (WebGPU).** With a GPU engine attached (`attachGpu`) and at least `gpuMinTiles` live
+ *   tiles, the GPU keeps a mirror of the slots: each edit uploads the rows it changed, each batch
+ *   runs on the GPU too, and `displayGpu` shades every stale tile there at once. In lead mode
+ *   (between strokes) the GPU steps a batch frame by frame while the CPU computes it (`gpuLead`).
+ *   The CPU state stays the authority (edits, reads, drying, snapshots, baking); the GPU's copy
+ *   only feeds the display.
+ */
+
+/** 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;
+    private gpu;
+    /** Live tiles at which the GPU takes over the display (default 16: a fully wet 1024² canvas). */
+    gpuMinTiles: number;
+    private gpuLive;
+    private gpuFailure;
+    /** Slot → rows (1..256, inclusive) to upload; `[0, 257]` means the whole slot. */
+    private readonly gpuDirty;
+    private gpuParamsDirty;
+    /**
+     * Lead mode (between strokes): a batch is not sent to the GPU all at once; `gpuLead` steps it
+     * frame by frame while the CPU works through it, so the display moves on before the CPU is done.
+     */
+    gpuLeadMode: boolean;
+    /** The batch the GPU is working through in lead mode. */
+    private gpuPlan;
+    /** 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>;
+    /**
+     * Steps only the live tiles that touch `region` (canvas pixels): a viewport, say, so a huge wet
+     * canvas costs what is on screen. The other live tiles hold still (no flow, no drying) until a
+     * later step reaches them, and water flowing out of the region stops at their edge; tiles the
+     * region's water wakes up are stepped as usual. Holding tiles makes the result depend on the
+     * regions, so a replay is only bit-identical with the same regions. Returns the clock.
+     */
+    stepRegion(steps: number, region: RasterRect): Promise<number>;
+    /** `stepRegion` on this thread (throws while worker threads are in use, like `stepSync`). */
+    stepRegionSync(steps: number, region: RasterRect): number;
+    /**
+     * Takes the live tiles that miss `region` out of the active list until the returned release
+     * is called. Their state is copied into the other ping-pong set first, so they read the same
+     * whichever set is current when they come back.
+     */
+    private hold;
+    /** 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;
+    /**
+     * Attaches a GPU engine (or `null` to detach). From then on, whenever at least `gpuMinTiles` tiles
+     * are live, the GPU mirrors the slots and `displayGpu` shades on it. The CPU stays the authority.
+     */
+    attachGpu(engine: WetGpuEngine | null): void;
+    /** The attached GPU engine, if any. */
+    get gpuEngine(): WetGpuEngine | null;
+    /** Whether the GPU mirror is in use now (an engine is attached and the wet area is large). */
+    get gpuActive(): boolean;
+    /** Why the GPU stopped (a lost device, out of GPU memory), or `null`. */
+    get gpuError(): string | null;
+    private gpuDirtySlot;
+    private gpuStop;
+    /** Turns the mirror on or off for the current wet area. Returns whether it is on. */
+    private gpuDecide;
+    /** Sends the rest of a lead batch to the GPU (before anything else touches its state). */
+    private gpuFinishPlan;
+    /**
+     * Lead mode: steps the GPU up to `steps` further into the batch the CPU is running (never past
+     * it, so the GPU is never ahead of the CPU's next edit). Returns the steps taken.
+     */
+    gpuLead(steps: number): number;
+    /** Steps the GPU is ahead of the CPU's last finished batch (lead mode), 0 otherwise. */
+    get gpuAhead(): number;
+    /** Whether the GPU can show steps the CPU has not finished (a lead batch is running). */
+    get gpuLeading(): boolean;
+    /** Uploads what the CPU changed since the last upload (the current set and deposits; whole slots on wake-up). */
+    private gpuSync;
+    private gpuJobs;
+    /** Runs the coming CPU batch of `n` steps on the GPU mirror too. */
+    private gpuBatch;
+    /**
+     * Like `display`, but shades every stale tile on the GPU at once (when the mirror is in use;
+     * otherwise, or when the world changed while the GPU worked, it is `display(id, maxCpuTiles)`).
+     * Call between batches.
+     */
+    displayGpu(id: string, maxCpuTiles?: number, lead?: boolean): Promise<{
+        surface: TiledSurface;
+        changed: RasterRect[];
+        pending: number;
+        gpu: boolean;
+    }>;
+    /** 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;
+
+/**
+ * Counter-based seeded randomness on 32-bit integer hashes: every value is a pure function of its
+ * inputs, so strokes and papers regenerate identically on every machine. Shared by the paint
+ * engine (`/paint`) and the paint editor (which re-exports it from `noise.ts`).
+ */
+/** A 32-bit finaliser (murmur3's `fmix32`). */
+declare function mix32(h: number): number;
+/** Hash of integer coordinates and a salt to [0, 1). */
+declare function hash2(x: number, y: number, salt: number): number;
+/** Uniform in [0, 1) from a seed, an index and a stream (one stream per random quantity). */
+declare function rand01(seed: number, index: number, stream: number): number;
+
+export { P_FY as $, FLAG_LEFT as A, FLAG_RIGHT as B, type CloneTransform as C, DEFAULT_FLOW as D, EX as E, FLAG_ALIVE as F, FLAG_TOP as G, FLAG_WET as H, FLAT as I, FREE_INTERVAL as J, IDENTITY_CLONE_TRANSFORM as K, MAX_TILT_ACCEL as L, MAX_BATCH as M, MAX_WET_LANES as N, MAX_WET_SLOTS as O, OPP as P, PAPER_CAPACITY as Q, type RetouchSettings as R, PARAM as S, PARAM_FLOATS as T, PIGMENT_CHANNELS as U, PLANE as V, WetWorld as W, PLANE_BYTES as X, P_D0 as Y, P_EDGE as Z, P_FX as _, type RetouchApply as a, sponge as a$, P_H as a0, P_P0 as a1, P_RHO as a2, P_SW as a3, P_UX as a4, P_UY as a5, type PixelSource as a6, RETOUCH_SAMPLES as a7, RegionPixelSource as a8, type RetouchDabEffect as a9, WetWorldError as aA, applyRetouchToTile as aB, applyToneToDeepTile as aC, boxBlurPixels as aD, canShareMemory as aE, cloneSamplePoint as aF, createWetGpuEngine as aG, dodgeBurn as aH, dodgeBurnCurve as aI, dsincos as aJ, edgeBits as aK, findWebGpu as aL, flowField as aM, healPixels as aN, isIdentityCloneTransform as aO, latticeViscosity as aP, loadWetKernel as aQ, luma as aR, normalizeRetouch as aS, normalizeTilt as aT, packWetParams as aU, perDabStrength as aV, readSourceRegion as aW, retouchFilter as aX, rgbaViewOfGrey as aY, saturationOf as aZ, smudgeEffect as a_, RetouchDabStroke as aa, type RetouchSample as ab, SET_PLANES as ac, SLOT_BYTES as ad, SLOT_PLANES as ae, SLOT_SIDE as af, SPOT_HEAL_TYPES as ag, STRIP as ah, type SpotHealType as ai, TONE_RANGES as aj, TilePixelSource as ak, type ToneRange as al, TransformedPixelSource as am, U_MAX as an, W9 as ao, WET_TILE as ap, type WetFlowField as aq, WetGpuEngine as ar, type WetGpuJob as as, type WetGpuSupport as at, type WetKernelKind as au, type WetLaneOptions as av, type WetLaneStats as aw, type WetPaper as ax, type WetWorkerLayout as ay, WetWorkerPool as az, type RetouchPaint as b, spongeEffect as b0, spotHealPixels as b1, spotHealWindow as b2, toneOf as b3, wetGpuSupport as b4, wetSimdSupported as b5, type WetTilt as c, type WetParams as d, type WetFlowSpec as e, type WetWorldOptions as f, type WetGpuProvider as g, type WetBackendInfo as h, type WetSnapshot as i, type WetPaperInput as j, DEFAULT_WET_PARAMS as k, WET_FLOW_KINDS as l, WET_PARAM_KEYS as m, type WetFlowKind as n, type WetSupport as o, hash2 as p, mix32 as q, normalizeFlow as r, normalizeWetParams as s, rand01 as t, DEFAULT_RETOUCH as u, DEFAULT_WET_PAPER as v, wetSupport as w, DRY_EPS as x, EY as y, FLAG_BOTTOM as z };