@pixerate/editor 0.135.0 → 0.137.0

package/dist/rand-DOH_aMvm.d.cts

@@ -1,2140 +0,0 @@
-import { a as BlendMode, R as RasterRect, j as TileKey, Y as Pigment, T as TiledSurface } from './surface-1MRncXpF.cjs';
-
-/**
- * Gradient paint: a colour slot (the paint colour, a swatch, a stroke's colour) holds a
- * `PaintSource`, either one colour or a gradient that the brush samples dab by dab as the stroke
- * goes: by distance travelled, pen pressure, tilt, speed, direction, time, across the tip, or at
- * random. Shared by the paint editor and the image editor.
- *
- * - **Stops** have the vector and image gradients' shape (`offset`, `color`, `opacity`,
- *   `midpoint`); opacity multiplies the brush's flow. `softness` (1, smooth, by default) turns
- *   each blend into a harder step towards 0.
- * - **Space**: `pigment` (default) mixes neighbouring stops like paint (Kubelka-Munk, so blue to
- *   yellow passes through green), `oklab` perceptually, `srgb` as plain numbers.
- * - **Mapping**: what moves along the gradient. `distance` (default: 300 px, mirrored) is the
- *   "drag it out" paint: the colour changes as the stroke travels. It never stretches over the
- *   whole stroke, whose length is unknown until the pen lifts.
- *
- * Everything is a pure function of the stroke's recorded samples and seed, so replays, time-lapses,
- * re-rendered exports and drying stay exact.
- */
-/** sRGB 0..1. */
-type PaintRgb = [number, number, number];
-/** A gradient stop: the vector and image gradients' shape. */
-interface PaintGradientStop {
-    /** 0..1 along the gradient. */
-    offset: number;
-    /**
-     * #rrggbb, or `paint` / `secondary`: the editor's paint and second colours when the stroke
-     * starts (a gradient between whatever two colours are chosen).
-     */
-    color: string;
-    /** 0..1 (default 1): multiplies the brush's flow where this colour is laid. */
-    opacity?: number;
-    /** Where between this stop and the next (0.05..0.95 of the way) the colours are half mixed (default 0.5). */
-    midpoint?: number;
-}
-/** How neighbouring stops mix. */
-type PaintGradientSpace = 'pigment' | 'oklab' | 'srgb';
-declare const PAINT_GRADIENT_SPACES: readonly PaintGradientSpace[];
-/** Past the end of the gradient: hold the last colour, start again, or run back. */
-type PaintGradientRepeat = 'clamp' | 'repeat' | 'mirror';
-declare const PAINT_GRADIENT_REPEATS: readonly PaintGradientRepeat[];
-/** What moves a stroke along its gradient. */
-type PaintGradientMapping = 
-/** The stroke's travel: `length` px (or dabs, `unit` 'dabs') per run through the gradient. */
-{
-    by: 'distance';
-    length: number;
-    repeat: PaintGradientRepeat;
-    unit?: 'px' | 'dabs';
-}
-/** Pen pressure 0..1; tilt 0 (upright) .. 1 (flat); speed 0 .. 2.5 px/ms; direction of travel 0..360°. */
- | {
-    by: 'pressure';
-} | {
-    by: 'tilt';
-} | {
-    by: 'velocity';
-} | {
-    by: 'direction';
-}
-/** Time since the stroke began: `duration` ms per run through the gradient (needs timed samples). */
- | {
-    by: 'time';
-    duration: number;
-    repeat?: PaintGradientRepeat;
-}
-/** Across the tip, left to right looking along the stroke: a brush loaded with several colours. */
- | {
-    by: 'across-tip';
-}
-/** A random point of the gradient per dab (or per `every` dabs), seeded so replays match. */
- | {
-    by: 'random';
-    every?: number;
-};
-type PaintGradientMappingKind = PaintGradientMapping['by'];
-declare const PAINT_GRADIENT_MAPPINGS: readonly PaintGradientMappingKind[];
-interface PaintColorSource {
-    type: 'color';
-    /** #rrggbb */
-    color: string;
-}
-interface PaintGradientSource {
-    type: 'gradient';
-    /** 2..16 stops, sorted by offset. */
-    stops: PaintGradientStop[];
-    space: PaintGradientSpace;
-    map: PaintGradientMapping;
-    /** 0 (hard steps) .. 1 (smooth blends, default). */
-    softness?: number;
-}
-/** What a colour slot holds: one colour or a gradient. */
-type PaintSource = PaintColorSource | PaintGradientSource;
-/** "Drag it out": 300 px of travel per run, mirrored back and forth. */
-declare const DEFAULT_PAINT_GRADIENT_MAPPING: Readonly<PaintGradientMapping>;
-/** Speed (px/ms) at which `velocity` reaches the end of the gradient (the brush dynamics' full speed). */
-declare const PAINT_GRADIENT_FULL_SPEED = 2.5;
-declare class PaintSourceError extends Error {
-    constructor(message: string);
-}
-/** `#rgb` / `#rrggbb` → lowercase `#rrggbb`, or null. */
-declare function normalizeHexColor(v: unknown): string | null;
-/** `#rrggbb` → sRGB 0..1. */
-declare function hexToPaintRgb(hex: string): PaintRgb;
-/**
- * Reads a paint source strictly: what tools and APIs take. Throws `PaintSourceError` saying what
- * is wrong (unknown type, an unreadable colour, fewer than 2 or more than 16 stops, offsets
- * outside 0..1 or not sorted, a bad mapping) and how to fix it. Missing optional fields get their
- * defaults (space `pigment`, the `distance` mapping, softness 1).
- */
-declare function parsePaintSource(raw: unknown, at?: string): PaintSource;
-/** Reads a paint source leniently (documents, presets): `null` when it is not one. */
-declare function readPaintSource(raw: unknown): PaintSource | null;
-/**
- * The gradient with its `paint` / `secondary` stops replaced by those colours (#rrggbb): what a
- * stroke records and samples.
- */
-declare function resolvePaintGradient(g: PaintGradientSource, colors: {
-    paint: string;
-    secondary: string;
-}): PaintGradientSource;
-/** The gradient for a stroke scaled by `k` (a high-resolution re-render): pixel distances scale with it. */
-declare function scalePaintGradient(g: PaintGradientSource, k: number): PaintGradientSource;
-/** A colour source. */
-declare function solidPaint(color: string): PaintColorSource;
-/** Whether a source is a gradient. */
-declare function isGradientPaint(s: PaintSource | null | undefined): s is PaintGradientSource;
-/** One colour that stands for the source (the colour, or a gradient's first stop): what a plain colour slot shows. */
-declare function paintSourceColor(s: PaintSource, colors?: {
-    paint: string;
-    secondary: string;
-}): string;
-/** The source as a CSS `linear-gradient` (or colour) for colour wells and swatches. */
-declare function paintSourceCss(s: PaintSource, colors?: {
-    paint: string;
-    secondary: string;
-}): string;
-/** A gradient's colour at a dab: sRGB 0..1 and the opacity to multiply the flow by. */
-interface PaintGradientSample {
-    rgb: PaintRgb;
-    alpha: number;
-}
-/** What a dab offers a mapping: all pure functions of the stroke's recorded samples and seed. */
-interface PaintDabParams {
-    /** Path length (px) the stroke has travelled at this dab. */
-    travel: number;
-    /** The dab's index in its copy of the stroke (0, 1, 2 …). */
-    index: number;
-    /** 0..1 */
-    pressure: number;
-    /** 0 upright .. 1 flat. */
-    lean: number;
-    /** px/ms, or `null` without timed samples. */
-    speed: number | null;
-    /** Direction of travel, radians counter-clockwise with y up. */
-    direction: number;
-    /** ms since the stroke's first timed sample, or `null` without timed samples. */
-    time: number | null;
-}
-/**
- * A gradient prepared for sampling. `dab` gives the colour of one dab; `across-tip` gradients give
- * a table across the tip instead (`tipTable`).
- */
-declare class PaintGradientSampler {
-    readonly source: PaintGradientSource;
-    private readonly seed;
-    private readonly stops;
-    private readonly softness;
-    /** Stops at exactly k/(n − 1): segments found by arithmetic, as the multi-colour brush did. */
-    private readonly uniform;
-    readonly acrossTip: boolean;
-    constructor(source: PaintGradientSource, seed?: number);
-    /** The two stops' mix `u` of the way (0..1), in the gradient's space. */
-    private mix;
-    /** The colour at `t` (clamped to 0..1). */
-    sample(t: number, out?: PaintGradientSample): PaintGradientSample;
-    /** Sampled `travel / length` runs along, past the end as `repeat` says. */
-    private along;
-    /** The colour of one dab (not for `across-tip`: see `tipTable`). */
-    dab(d: PaintDabParams, out?: PaintGradientSample): PaintGradientSample;
-    /** `steps` colours from the left edge of the tip to the right (`across-tip`). */
-    tipTable(steps: number): PaintGradientSample[];
-}
-/** JSON Schema of a gradient `PaintSource` (what tools accept for gradient paint). */
-declare const PAINT_GRADIENT_JSON_SCHEMA: {
-    readonly type: "object";
-    readonly description: "Gradient paint: the brush samples it dab by dab as the stroke goes. Example (blue to yellow over 300 px of stroke, and back): { \"type\": \"gradient\", \"stops\": [{ \"offset\": 0, \"color\": \"#1d4ed8\" }, { \"offset\": 1, \"color\": \"#facc15\" }], \"map\": { \"by\": \"distance\", \"length\": 300, \"repeat\": \"mirror\" } }.";
-    readonly properties: {
-        readonly type: {
-            readonly type: "string";
-            readonly enum: readonly ["gradient"];
-            readonly description: "Always \"gradient\".";
-        };
-        readonly stops: {
-            readonly type: "array";
-            readonly minItems: 2;
-            readonly maxItems: 16;
-            readonly items: {
-                readonly type: "object";
-                readonly description: "A gradient stop.";
-                readonly properties: {
-                    readonly offset: {
-                        readonly type: "number";
-                        readonly minimum: 0;
-                        readonly maximum: 1;
-                        readonly description: "Where the stop is, 0..1 along the gradient. Stops must be sorted by offset.";
-                    };
-                    readonly color: {
-                        readonly type: "string";
-                        readonly pattern: "^(#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}|paint|secondary)$";
-                        readonly description: "#rrggbb, or \"paint\" / \"secondary\": the editor's paint or second colour when the stroke starts.";
-                    };
-                    readonly opacity: {
-                        readonly type: "number";
-                        readonly minimum: 0;
-                        readonly maximum: 1;
-                        readonly description: "0..1 (default 1): multiplies the brush's flow where this colour is laid.";
-                    };
-                    readonly midpoint: {
-                        readonly type: "number";
-                        readonly minimum: 0.05;
-                        readonly maximum: 0.95;
-                        readonly description: "Where between this stop and the next the colours are half mixed, 0.05..0.95 of the way (default 0.5).";
-                    };
-                };
-                readonly required: readonly ["offset", "color"];
-                readonly additionalProperties: false;
-            };
-            readonly description: "2..16 stops sorted by offset.";
-        };
-        readonly space: {
-            readonly type: "string";
-            readonly enum: readonly PaintGradientSpace[];
-            readonly description: "How neighbouring stops mix: pigment (default; like paint, blue to yellow passes green), oklab (perceptual) or srgb (plain numbers).";
-        };
-        readonly map: {
-            readonly type: "object";
-            readonly description: "What moves the stroke along the gradient (default distance, 300 px, mirror).";
-            readonly properties: {
-                readonly by: {
-                    readonly type: "string";
-                    readonly enum: readonly ("direction" | "time" | "distance" | "pressure" | "tilt" | "across-tip" | "random" | "velocity")[];
-                    readonly description: "distance: px (or dabs) of stroke travelled; pressure: pen pressure 0..1; tilt: pen lean, upright 0 .. flat 1; velocity: pen speed, 0 .. 2.5 px/ms; direction: direction of travel, once round per 360°; time: ms since the stroke began (needs timed points); across-tip: left to right across the tip, looking along the stroke (a brush loaded with several colours); random: a random point per dab (seeded, so replays match).";
-                };
-                readonly length: {
-                    readonly type: "number";
-                    readonly minimum: 1;
-                    readonly maximum: 100000;
-                    readonly description: "distance: px of travel (or dabs, with unit \"dabs\") per run through the gradient (default 300).";
-                };
-                readonly repeat: {
-                    readonly type: "string";
-                    readonly enum: readonly PaintGradientRepeat[];
-                    readonly description: "distance and time: past the end, clamp (hold the last colour), repeat (start again) or mirror (run back; default for distance, clamp for time).";
-                };
-                readonly unit: {
-                    readonly type: "string";
-                    readonly enum: readonly ["px", "dabs"];
-                    readonly description: "distance: px (default) or dabs.";
-                };
-                readonly duration: {
-                    readonly type: "number";
-                    readonly minimum: 1;
-                    readonly maximum: 600000;
-                    readonly description: "time: ms per run through the gradient (default 2000).";
-                };
-                readonly every: {
-                    readonly type: "integer";
-                    readonly minimum: 1;
-                    readonly maximum: 500;
-                    readonly description: "random: dabs per random pick (default 1).";
-                };
-            };
-            readonly required: readonly ["by"];
-            readonly additionalProperties: false;
-        };
-        readonly softness: {
-            readonly type: "number";
-            readonly minimum: 0;
-            readonly maximum: 1;
-            readonly description: "How softly neighbouring stops blend: 1 smooth (default) .. 0 hard steps.";
-        };
-    };
-    readonly required: readonly ["type", "stops"];
-    readonly additionalProperties: false;
-};
-/** JSON Schema of a colour `PaintSource`. */
-declare const PAINT_COLOR_JSON_SCHEMA: {
-    readonly type: "object";
-    readonly description: "One colour: { \"type\": \"color\", \"color\": \"#rrggbb\" }.";
-    readonly properties: {
-        readonly type: {
-            readonly type: "string";
-            readonly enum: readonly ["color"];
-            readonly description: "Always \"color\".";
-        };
-        readonly color: {
-            readonly type: "string";
-            readonly pattern: "^#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$";
-            readonly description: "#rrggbb";
-        };
-    };
-    readonly required: readonly ["type", "color"];
-    readonly additionalProperties: false;
-};
-/** JSON Schema of a `PaintSource`: a colour or gradient paint. */
-declare const PAINT_SOURCE_JSON_SCHEMA: {
-    readonly description: "What to paint with: one colour, or gradient paint.";
-    readonly oneOf: readonly [{
-        readonly type: "object";
-        readonly description: "One colour: { \"type\": \"color\", \"color\": \"#rrggbb\" }.";
-        readonly properties: {
-            readonly type: {
-                readonly type: "string";
-                readonly enum: readonly ["color"];
-                readonly description: "Always \"color\".";
-            };
-            readonly color: {
-                readonly type: "string";
-                readonly pattern: "^#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$";
-                readonly description: "#rrggbb";
-            };
-        };
-        readonly required: readonly ["type", "color"];
-        readonly additionalProperties: false;
-    }, {
-        readonly type: "object";
-        readonly description: "Gradient paint: the brush samples it dab by dab as the stroke goes. Example (blue to yellow over 300 px of stroke, and back): { \"type\": \"gradient\", \"stops\": [{ \"offset\": 0, \"color\": \"#1d4ed8\" }, { \"offset\": 1, \"color\": \"#facc15\" }], \"map\": { \"by\": \"distance\", \"length\": 300, \"repeat\": \"mirror\" } }.";
-        readonly properties: {
-            readonly type: {
-                readonly type: "string";
-                readonly enum: readonly ["gradient"];
-                readonly description: "Always \"gradient\".";
-            };
-            readonly stops: {
-                readonly type: "array";
-                readonly minItems: 2;
-                readonly maxItems: 16;
-                readonly items: {
-                    readonly type: "object";
-                    readonly description: "A gradient stop.";
-                    readonly properties: {
-                        readonly offset: {
-                            readonly type: "number";
-                            readonly minimum: 0;
-                            readonly maximum: 1;
-                            readonly description: "Where the stop is, 0..1 along the gradient. Stops must be sorted by offset.";
-                        };
-                        readonly color: {
-                            readonly type: "string";
-                            readonly pattern: "^(#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}|paint|secondary)$";
-                            readonly description: "#rrggbb, or \"paint\" / \"secondary\": the editor's paint or second colour when the stroke starts.";
-                        };
-                        readonly opacity: {
-                            readonly type: "number";
-                            readonly minimum: 0;
-                            readonly maximum: 1;
-                            readonly description: "0..1 (default 1): multiplies the brush's flow where this colour is laid.";
-                        };
-                        readonly midpoint: {
-                            readonly type: "number";
-                            readonly minimum: 0.05;
-                            readonly maximum: 0.95;
-                            readonly description: "Where between this stop and the next the colours are half mixed, 0.05..0.95 of the way (default 0.5).";
-                        };
-                    };
-                    readonly required: readonly ["offset", "color"];
-                    readonly additionalProperties: false;
-                };
-                readonly description: "2..16 stops sorted by offset.";
-            };
-            readonly space: {
-                readonly type: "string";
-                readonly enum: readonly PaintGradientSpace[];
-                readonly description: "How neighbouring stops mix: pigment (default; like paint, blue to yellow passes green), oklab (perceptual) or srgb (plain numbers).";
-            };
-            readonly map: {
-                readonly type: "object";
-                readonly description: "What moves the stroke along the gradient (default distance, 300 px, mirror).";
-                readonly properties: {
-                    readonly by: {
-                        readonly type: "string";
-                        readonly enum: readonly ("direction" | "time" | "distance" | "pressure" | "tilt" | "across-tip" | "random" | "velocity")[];
-                        readonly description: "distance: px (or dabs) of stroke travelled; pressure: pen pressure 0..1; tilt: pen lean, upright 0 .. flat 1; velocity: pen speed, 0 .. 2.5 px/ms; direction: direction of travel, once round per 360°; time: ms since the stroke began (needs timed points); across-tip: left to right across the tip, looking along the stroke (a brush loaded with several colours); random: a random point per dab (seeded, so replays match).";
-                    };
-                    readonly length: {
-                        readonly type: "number";
-                        readonly minimum: 1;
-                        readonly maximum: 100000;
-                        readonly description: "distance: px of travel (or dabs, with unit \"dabs\") per run through the gradient (default 300).";
-                    };
-                    readonly repeat: {
-                        readonly type: "string";
-                        readonly enum: readonly PaintGradientRepeat[];
-                        readonly description: "distance and time: past the end, clamp (hold the last colour), repeat (start again) or mirror (run back; default for distance, clamp for time).";
-                    };
-                    readonly unit: {
-                        readonly type: "string";
-                        readonly enum: readonly ["px", "dabs"];
-                        readonly description: "distance: px (default) or dabs.";
-                    };
-                    readonly duration: {
-                        readonly type: "number";
-                        readonly minimum: 1;
-                        readonly maximum: 600000;
-                        readonly description: "time: ms per run through the gradient (default 2000).";
-                    };
-                    readonly every: {
-                        readonly type: "integer";
-                        readonly minimum: 1;
-                        readonly maximum: 500;
-                        readonly description: "random: dabs per random pick (default 1).";
-                    };
-                };
-                readonly required: readonly ["by"];
-                readonly additionalProperties: false;
-            };
-            readonly softness: {
-                readonly type: "number";
-                readonly minimum: 0;
-                readonly maximum: 1;
-                readonly description: "How softly neighbouring stops blend: 1 smooth (default) .. 0 hard steps.";
-            };
-        };
-        readonly required: readonly ["type", "stops"];
-        readonly additionalProperties: false;
-    }];
-};
-/** Labels for the mapping picker. */
-declare const PAINT_GRADIENT_MAPPING_LABELS: Readonly<Record<PaintGradientMappingKind, string>>;
-declare const PAINT_GRADIENT_SPACE_LABELS: Readonly<Record<PaintGradientSpace, string>>;
-declare const PAINT_GRADIENT_REPEAT_LABELS: Readonly<Record<PaintGradientRepeat, string>>;
-/** The paint colour to the second colour, changing as the stroke is dragged out: where a gradient editor starts. */
-declare const DEFAULT_PAINT_GRADIENT: Readonly<PaintGradientSource>;
-/** A few starting gradients for gradient editors. */
-declare const PAINT_GRADIENT_PRESETS: readonly {
-    name: string;
-    paint: PaintGradientSource;
-}[];
-/** Adds a stop at `offset` with the gradient's colour there. Returns the gradient and the new stop's index. */
-declare function addPaintGradientStop(g: PaintGradientSource, offset: number, colors?: {
-    paint: string;
-    secondary: string;
-}): {
-    paint: PaintGradientSource;
-    index: number;
-};
-/** Removes stop `index` (a gradient keeps at least 2). */
-declare function removePaintGradientStop(g: PaintGradientSource, index: number): PaintGradientSource;
-/** Changes stop `index` (moving it keeps the stops sorted). Returns the gradient and where the stop is now. */
-declare function updatePaintGradientStop(g: PaintGradientSource, index: number, patch: Partial<PaintGradientStop>): {
-    paint: PaintGradientSource;
-    index: number;
-};
-/** The gradient with its stops reversed (midpoints measured from the other side). */
-declare function reversePaintGradient(g: PaintGradientSource): PaintGradientSource;
-/** The mapping for `by`, keeping what carries over from `current` (length, repeat, duration …). */
-declare function paintGradientMappingFor(by: PaintGradientMappingKind, current: PaintGradientMapping): PaintGradientMapping;
-/** Everything a gradient-paint editor UI needs, in one object (framework bindings take it from their own entry). */
-declare const PAINT_GRADIENT_KIT: {
-    readonly PAINT_GRADIENT_MAPPINGS: readonly ("direction" | "time" | "distance" | "pressure" | "tilt" | "across-tip" | "random" | "velocity")[];
-    readonly PAINT_GRADIENT_MAPPING_LABELS: Readonly<Record<"direction" | "time" | "distance" | "pressure" | "tilt" | "across-tip" | "random" | "velocity", string>>;
-    readonly PAINT_GRADIENT_PRESETS: readonly {
-        name: string;
-        paint: PaintGradientSource;
-    }[];
-    readonly PAINT_GRADIENT_REPEATS: readonly PaintGradientRepeat[];
-    readonly PAINT_GRADIENT_REPEAT_LABELS: Readonly<Record<PaintGradientRepeat, string>>;
-    readonly PAINT_GRADIENT_SPACES: readonly PaintGradientSpace[];
-    readonly PAINT_GRADIENT_SPACE_LABELS: Readonly<Record<PaintGradientSpace, string>>;
-    readonly addPaintGradientStop: typeof addPaintGradientStop;
-    readonly paintGradientMappingFor: typeof paintGradientMappingFor;
-    readonly paintSourceCss: typeof paintSourceCss;
-    readonly removePaintGradientStop: typeof removePaintGradientStop;
-    readonly reversePaintGradient: typeof reversePaintGradient;
-    readonly updatePaintGradientStop: typeof updatePaintGradientStop;
-};
-type PaintGradientKit = typeof PAINT_GRADIENT_KIT;
-
-/**
- * The brush engine (a subset of photocraft's `crates/paint`): a computed round tip with size,
- * hardness, angle, roundness and spacing; pressure to size and opacity; smoothing; and Photoshop's
- * opacity-versus-flow build-up. Strokes are data, so one replays the same way for undo, agents
- * and tests.
- *
- * - Points are walked into dabs at `spacing × diameter` (`walkDabs`).
- * - Each dab's coverage (`dabCoverage`, photocraft's measured Photoshop profile) builds up in a
- *   stroke coverage map with flow towards the dab's opacity ceiling: `c ← c + v·(ceil − c)`.
- * - The stroke composites once at the stroke opacity over the layer as it was before the stroke,
- *   so overlapping dabs never exceed the opacity.
- */
-
-/** One input sample. Missing pressure is a mouse (1). */
-interface StrokePoint {
-    x: number;
-    y: number;
-    /** 0..1 (default 1). */
-    pressure?: number;
-    /** Milliseconds (optional; kept for replays). */
-    t?: number;
-}
-interface BrushSettings {
-    /** Diameter in pixels (1..2500, default 20). */
-    size: number;
-    /** 0 (soft) .. 1 (hard, default). */
-    hardness: number;
-    /** Dab spacing as a fraction of the diameter (0.01..10, default 0.1). */
-    spacing: number;
-    /** Tip angle in degrees (default 0). */
-    angle: number;
-    /** Tip roundness 0.01..1 (default 1). */
-    roundness: number;
-    /** Stroke opacity ceiling 0..1 (default 1). */
-    opacity: number;
-    /** Build-up per dab 0..1 (default 1). */
-    flow: number;
-    /** Input smoothing 0..0.95 (default 0). */
-    smoothing: number;
-    /** Pressure controls size (default true). */
-    pressureSize: boolean;
-    /** Pressure controls opacity (default false). */
-    pressureOpacity: boolean;
-    /** How the stroke paints onto the layer (default normal). */
-    blend: BlendMode;
-}
-declare const DEFAULT_BRUSH: Readonly<BrushSettings>;
-declare const MAX_BRUSH_SIZE = 2500;
-/** A brush with every field in range (missing fields from `DEFAULT_BRUSH`). */
-declare function normalizeBrush(raw?: Partial<BrushSettings>): BrushSettings;
-/** The core radius and shoulder width (pixels) of a round tip of `radius` and `hardness`. */
-declare function tipShape(radius: number, hardness: number): [number, number];
-/** Opacity of a round tip at distance `d` from its centre. */
-declare function tipFalloff(d: number, radius: number, hardness: number): number;
-/** How far from its centre a round tip still paints. */
-declare function tipReach(radius: number, hardness: number): number;
-/** Coverage of a round dab at distance `d` from its centre. */
-declare function dabCoverage(d: number, radius: number, hardness: number): number;
-interface Dab {
-    x: number;
-    y: number;
-    radius: number;
-    /** Flow (per-dab build-up). */
-    alpha: number;
-    /** Opacity ceiling this dab builds up to. */
-    opacity: number;
-    /** Radians. */
-    angle: number;
-    roundness: number;
-    /** What gradient paint maps by (travel, index, pressure, time …); set by the dab walkers. */
-    params?: PaintDabParams;
-}
-/** Exponential smoothing of input points; the first and last point are kept. */
-declare function smoothPoints(points: readonly StrokePoint[], amount: number): StrokePoint[];
-/**
- * Walks points into dabs (incrementally: feed points in any chunks and get the same dabs). The
- * first point is a dab; then one every `spacing × diameter` along the path.
- */
-declare class DabWalker {
-    readonly brush: BrushSettings;
-    private last;
-    private nextAt;
-    private pendingFirst;
-    private index;
-    private travelled;
-    private dir;
-    private firstT;
-    private lastSpeedT;
-    private lastSpeedAt;
-    private speed;
-    constructor(brush: BrushSettings);
-    private diameter;
-    private stepLen;
-    private dab;
-    /** Tracks time and a smoothed speed from timed samples (for gradient paint). */
-    private timeOf;
-    push(p: StrokePoint, out: Dab[]): void;
-    finish(out: Dab[]): void;
-}
-/** All dabs of a point list (smoothing applied). */
-declare function walkDabs(points: readonly StrokePoint[], brush: BrushSettings): Dab[];
-/** The pixel rectangle a dab can touch. */
-declare function dabRect(d: Dab, hardness: number): RasterRect;
-/**
- * Rasterizes one dab over `rect` into `out` (rect.width × rect.height values, coverage × flow).
- * Small tips (radius below 3 px) take each pixel's covered area from a 4×4 grid.
- */
-declare function rasterizeDab(d: Dab, hardness: number, rect: RasterRect, out: Float32Array): void;
-/** A stroke's accumulated coverage, in 256 px tiles over document space. */
-declare class CoverageMap {
-    readonly tiles: Map<number, Float32Array<ArrayBufferLike>>;
-    /**
-     * Gradient paint: the colour laid at each pixel (sRGB 0..1, 3 per pixel), when dabs carry their
-     * own colours. Each dab blends its colour in by the share of coverage it adds. Missing: the
-     * stroke's one colour (`StrokeApply.color`).
-     */
-    readonly colors: Map<number, Float32Array<ArrayBufferLike>>;
-    bounds: RasterRect | null;
-    private dirty;
-    /** The colour at a pixel (gradient paint), or `null` when the stroke has one colour there. */
-    colorAt(x: number, y: number, out: number[]): number[] | null;
-    get(x: number, y: number): number;
-    /**
-     * Builds up `vals` (over `rect`) with flow towards `ceil`: `c ← c + v·(ceil − c)`. With `color`
-     * (one sRGB colour for the dab) or `field` (sRGB per pixel of `rect`, 3 each), the pixels' colours
-     * move towards it by the share of coverage this dab adds (gradient paint).
-     */
-    accumulate(rect: RasterRect, vals: Float32Array, ceil: number, color?: readonly number[] | null, field?: Float32Array | null): void;
-    /** Tiles changed since the last call. */
-    takeDirty(): TileKey[];
-}
-/** Paints a stroke's dabs into a coverage map, incrementally. */
-declare class StrokeCoverage {
-    readonly brush: BrushSettings;
-    readonly coverage: CoverageMap;
-    private walker;
-    private smoothing;
-    private smoothPos;
-    private buf;
-    private field;
-    private readonly sampler;
-    private readonly tipTable;
-    private readonly sample;
-    dabCount: number;
-    /** `paint`: a gradient source (resolved: no `paint` / `secondary` stops) for gradient paint; `seed` for its `random` mapping. */
-    constructor(brush: BrushSettings, paint?: PaintGradientSource | null, seed?: number);
-    /** Feeds input points; returns the document rectangles the new dabs touched. */
-    push(points: readonly StrokePoint[]): RasterRect[];
-    /** Ends the stroke (a single click still paints one dab). */
-    finish(last?: StrokePoint): RasterRect[];
-    private smooth;
-    private paint;
-    private paintDab;
-}
-/** Colours across the tip of an `across-tip` gradient. */
-declare const TIP_GRADIENT_STEPS = 32;
-/**
- * Gradient paint for one dab: the dab's colour (or, across the tip, a colour per pixel) and its
- * opacity, which multiplies the flow. Shared by every coverage stroke.
- */
-declare function gradientDabColor(sampler: PaintGradientSampler, tipTable: readonly PaintGradientSample[] | null, d: Dab, params: PaintDabParams, rect: RasterRect, vals: Float32Array, scratch: {
-    field: Float32Array;
-    sample: PaintGradientSample;
-}): {
-    color: PaintRgb | null;
-    field: Float32Array | null;
-};
-/** How a stroke changes pixels. */
-interface StrokeApply {
-    /** `paint` puts colour down; `erase` removes alpha (or, with transparency locked, paints `background`). */
-    mode: 'paint' | 'erase';
-    /** RGBA 0..255 (paint colour, or the mask grey in `r`). */
-    color: readonly [number, number, number, number];
-    /** RGBA 0..255 the eraser paints on a transparency-locked layer (and on masks). */
-    background: readonly [number, number, number, number];
-    opacity: number;
-    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 the stroke's coverage over `tileData` (the target's tile (tx, ty) as it was before
- * the stroke, in layer space; RGBA or one byte for masks) and returns the new tile data. With
- * `into` (the tile's previous result) and `region` (document space), only `region` is recomputed
- * and the rest of `into` is kept.
- */
-declare function applyStrokeToTile(coverage: CoverageMap, tileData: Uint8ClampedArray, channels: 1 | 4, tx: number, ty: number, s: StrokeApply, options?: {
-    into?: Uint8ClampedArray;
-    region?: RasterRect;
-}): Uint8ClampedArray;
-/**
- * `applyStrokeToTile` at high bit depth: composites the stroke's coverage over deep RGBA
- * samples (`Uint16Array` sRGB or `Float32Array` linear light, see `raster/deep`) of the target's
- * tile (tx, ty) as it was before the stroke, and returns new samples of the same type. Blending
- * runs in float in the samples' own space (sRGB at 16 bits, linear light at 32 bits); the paint
- * colours are 8-bit sRGB and converted. With `options.channels` 1, a mask's coverage samples
- * (16-bit, or float 0..1) move towards the paint's grey, as `applyStrokeToTile` does at 8 bits.
- */
-declare function applyStrokeToDeepTile(coverage: CoverageMap, samples: Uint16Array | Float32Array, tx: number, ty: number, s: StrokeApply, options?: {
-    into?: Uint16Array | Float32Array;
-    region?: RasterRect;
-    channels?: 1 | 4;
-}): Uint16Array | Float32Array;
-/** Tile coordinates of coverage tile keys (for callers that track dirty tiles). */
-declare function coverageTileCoord(key: TileKey): {
-    tx: number;
-    ty: number;
-};
-
-/**
- * The pick-up / mix exchange between a loaded brush and the paint under it: the one mechanism
- * every wet-capable brush shares. The Mixer Brush (`MixerStroke`) and the paint editor's
- * wet-capable brushes run on it now; the wet layer (phase 3) plugs in as another `PaintMedium`.
- *
- * Two halves:
- *
- * - `PaintExchange` is what the brush carries: a **reservoir** of loaded paint (with an amount
- *   that drains per dab) and a **well** of paint picked up from the canvas. Per dab it
- *   1. picks up: the well moves towards the colour under the dab by the pick-up rate times how
- *      much of the footprint holds paint (`pickUp`);
- *   2. mixes the dab's paint: reservoir weight `amount × (1 − mix)`, well weight `mix`
- *      (`paint`);
- *   3. drains the reservoir (`drain`).
- *   Every mix is RGB or Kubelka-Munk pigment (`mixing`), so a blue brush through yellow goes
- *   green.
- * - `PaintMedium` is what the brush touches: `sample` (the colour and contact under a footprint)
- *   and `deposit` (lay paint at per-pixel amounts). `TileMedium` is the raster layer's pixels.
- *   A wet layer implements the same two calls over its wet pigment and water (sampling only wet
- *   paint, so pick-up lifts what is still wet), and nothing in `PaintExchange` changes.
- *
- * The ratios a user sets are `pickup` (pick-up ratio, 0..1) and `mix` (mix ratio, 0..1);
- * `exchangeRates` turns them into per-dab rates with the Mixer Brush's constants, so a Mixer
- * Brush's `wet` and `mix` are exactly these two ratios. Everything is data in, pixels out.
- */
-
-/** How colours mix: straight sRGB averages, or like paint (Kubelka-Munk). */
-type MixingModel = 'rgb' | 'pigment';
-declare const MIXING_MODELS: readonly MixingModel[];
-/** An sRGB colour, 0..1 per channel. */
-type RgbTriple = [number, number, number];
-/** What a brush carries between dabs and strokes. Colours are straight sRGB, 0..1. */
-interface MixerLoad {
-    /** Loaded paint, or `null` when the brush is unloaded. */
-    readonly reservoir: readonly [number, number, number] | null;
-    /** Reservoir left, 0..1. */
-    readonly amount: number;
-    /** Colour picked up from the canvas (the well), or `null` when the brush is clean. */
-    readonly pickup: readonly [number, number, number] | null;
-}
-declare const EMPTY_MIXER_LOAD: MixerLoad;
-/** Fraction of the way the well moves towards the canvas colour per dab at a pick-up ratio of 1. */
-declare const MIXER_PICKUP_RATE = 0.25;
-/** Fraction of the reservoir that drains per dab at a load of 0. */
-declare const MIXER_DRAIN = 0.08;
-/** Per-dab rates of an exchange. */
-interface ExchangeRates {
-    /** How far the well moves towards the canvas colour per dab at full contact (0: lifts nothing). */
-    pickup: number;
-    /** The well's weight in each dab's paint; the reservoir gets `amount × (1 − mix)`. */
-    mix: number;
-    /** Fraction of the reservoir lost per dab. */
-    drain: number;
-    mixing: MixingModel;
-}
-/**
- * Per-dab rates from the ratios a user sets: pick-up ratio `pickup` (0 dry .. 1), mix ratio
- * `mix` (0 .. 1, scaled by the pick-up ratio: a brush that lifts nothing has nothing to mix) and
- * `load` (1 never drains). The Mixer Brush passes its `wet`, `mix` and `load`.
- */
-declare function exchangeRates(pickup: number, mix: number, load: number, mixing: MixingModel): ExchangeRates;
-/** What a footprint holds: its average paint colour and how much of it holds paint (0..1). */
-interface PaintSample {
-    rgb: RgbTriple;
-    /** Paint-weighted share of the footprint (alpha × coverage over coverage). */
-    contact: number;
-}
-/** The brush side of the exchange: reservoir, amount and well, mixed per dab. */
-declare class PaintExchange {
-    readonly rates: ExchangeRates;
-    private reservoir;
-    private amount;
-    private well;
-    private readonly pig;
-    private readonly out;
-    constructor(rates: ExchangeRates, load: MixerLoad);
-    /** What the brush carries now. */
-    get load(): MixerLoad;
-    /** The colour picked up so far, or `null`. */
-    get pickup(): Readonly<RgbTriple> | null;
-    /** The prepared pigment of the last `paint` colour (pigment mixing only), for `deposit`. */
-    get paintPigment(): Pigment | null;
-    /** Recolours the reservoir without refilling it (a multi-coloured brush, per dab). */
-    setReservoirColor(r: number, g: number, b: number): void;
-    /** `a` mixed `t` of the way to `b` into `this.out`, by the mixing model. */
-    private mix;
-    /** `a` mixed `t` of the way to `b` (sRGB 0..1) by the mixing model, into `out`. */
-    mixColors(a: readonly number[], b: readonly number[], t: number, out: number[]): number[];
-    /** 1. Pick-up: the well moves towards the sampled colour (or takes it, when clean). */
-    pickUp(sample: PaintSample | null): void;
-    /**
-     * 2. The dab's paint: the reservoir mixed with the well, written to `out`. Returns the total
-     * weight (≤ 0: nothing to lay down); deposit `min(1, weight)` of it. With pigment mixing,
-     * `paintPigment` is the result's pigment afterwards.
-     */
-    paint(out: RgbTriple): number;
-    /** 3. The reservoir drains. */
-    drain(): void;
-}
-/**
- * A brush's working tile: 8-bit bytes, or (on a 16- or 32-bit document) floats on the same
- * 0..255 sRGB-encoded scale, which keep the fractions an 8-bit tile would round away.
- */
-type PaintPixels = Uint8ClampedArray | Float32Array;
-/** Writes `v` (0..1) into a working tile: rounded for bytes, kept exact (not below 0) for floats. */
-declare function put255(px: PaintPixels, i: number, v: number): void;
-/** The pixels a brush reads and writes (RGBA tiles in layer space). */
-interface PaintTileTarget {
-    /** The tile (TILE × TILE × 4) at (tx, ty) as it is now, or `null` when it is fully transparent. */
-    readTile(tx: number, ty: number): PaintPixels | null;
-    /** A writable tile at (tx, ty), returned by `readTile` from then on. */
-    writeTile(tx: number, ty: number): PaintPixels;
-    /** Layer offset: layer pixel = document pixel − offset. */
-    offset: {
-        x: number;
-        y: number;
-    };
-    /** Keep alpha and paint only where the layer has pixels. */
-    lockTransparency: boolean;
-    /** Selection coverage (document space, canvas-sized), or `null`. */
-    selection: {
-        width: number;
-        height: number;
-        data: ArrayLike<number>;
-    } | null;
-}
-/** The canvas side of the exchange: where a brush picks paint up and lays it down. */
-interface PaintMedium {
-    /** The paint under a footprint (`cov` over `rect`, document space), or `null` where there is none. */
-    sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null;
-    /**
-     * Lays paint over the footprint at `dep × cov` per pixel. The colour is `paint` (with its
-     * prepared pigment for pigment mixing), or per pixel from `field` (3 floats per pixel of
-     * `rect`, sRGB 0..1) when given.
-     */
-    deposit(rect: RasterRect, cov: ArrayLike<number>, dep: number, paint: Readonly<RgbTriple>, paintPigment: Pigment | null, field?: Float32Array | null): void;
-}
-interface TileMediumOptions {
-    /**
-     * How deposits combine with the pixels. Missing: the exchange's mixing (source-over, or a
-     * pigment mix with pigment mixing), as the Mixer Brush paints. Otherwise any blend mode, as a
-     * brush tip's `blend`.
-     */
-    blend?: BlendMode;
-}
-/** A raster layer's pixels as a `PaintMedium` (through live tiles). */
-declare class TileMedium implements PaintMedium {
-    readonly target: PaintTileTarget;
-    private readonly options;
-    private tx;
-    private ty;
-    private tile;
-    private writable;
-    private readonly canvasPig;
-    private readonly paintPig;
-    private paintKey;
-    private readonly cb;
-    private readonly src;
-    private readonly o;
-    constructor(target: PaintTileTarget, options?: TileMediumOptions);
-    /** Forgets the cached tile (call when another writer may have replaced tiles). */
-    reset(): void;
-    /**
-     * The tile holding document pixel (dx, dy) (`pixels`) and the pixel's byte index in it, or -1
-     * when reading an empty tile.
-     */
-    locate(dx: number, dy: number, write: boolean): number;
-    /** The tile `locate` last found. */
-    get pixels(): PaintPixels;
-    /** Selection coverage at a document pixel, 0..1 (1 without a selection). */
-    selectionAt(dx: number, dy: number): number;
-    sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null;
-    deposit(rect: RasterRect, cov: ArrayLike<number>, dep: number, paint: Readonly<RgbTriple>, paintPigment: Pigment | null, field?: Float32Array | null): void;
-}
-
-/**
- * The Mixer Brush: a reservoir of loaded paint plus a pickup well that takes up colour from the
- * canvas under each dab (photocraft's behavioural model):
- *
- * - Each dab samples the canvas under its footprint (coverage- and alpha-weighted). The pickup
- *   colour `P` moves towards that sample by `PICKUP_RATE × wet` (scaled by the sample's coverage).
- * - The dab's paint mixes the reservoir `R` (weight `amount × (1 − mix·wet)`) with the pickup
- *   (weight `mix·wet`) and lands at `flow × opacity` times the total weight, over the pixels as
- *   they are now, so earlier dabs of the same stroke are picked up again (smearing).
- * - The reservoir drains per dab unless `load` is 1, so low-load strokes run dry. A dry brush
- *   (`wet` 0) paints only reservoir colour; an empty, wet brush smears canvas colour.
- *
- * `mixing: 'pigment'` does all three mixes (pickup, paint and deposit) with the Kubelka-Munk model
- * of `./pigment`, so a blue brush dragged through yellow makes green instead of grey. Everything
- * is data in, pixels out: the same canvas, points, settings and load replay identically.
- */
-
-/** Mixer Brush options. */
-interface MixerSettings {
-    /** How much colour the brush picks up from the canvas (the pick-up ratio), 0 (dry) .. 1 (default 0.5). */
-    wet: number;
-    /** How much paint the reservoir holds, 0 .. 1 (default 0.5): below 1 it drains per dab and the stroke runs dry. */
-    load: number;
-    /** How far each dab's paint moves from the reservoir towards the picked-up colour (the mix ratio), 0 .. 1 (default 0.5). */
-    mix: number;
-    /** Refill the reservoir with the paint colour at the start of each stroke (default true). */
-    loadEachStroke: boolean;
-    /** Empty the pickup well after each stroke (default true); off keeps the brush dirty for the next stroke. */
-    cleanEachStroke: boolean;
-    /** `rgb` (default) or `pigment` (blue and yellow make green). */
-    mixing: MixingModel;
-}
-declare const DEFAULT_MIXER: Readonly<MixerSettings>;
-/** Mixer settings with every field in range (missing fields from `DEFAULT_MIXER`). */
-declare function normalizeMixer(raw?: Partial<MixerSettings>): MixerSettings;
-/** The per-dab exchange rates of Mixer Brush settings (`wet` is the pick-up ratio, `mix` the mix ratio). */
-declare function mixerRates(settings: MixerSettings): ExchangeRates;
-/** The brush loaded full with `color` (sRGB 0..1); the pickup well is kept. */
-declare function loadMixer(load: MixerLoad, color: readonly [number, number, number]): MixerLoad;
-/** The brush with its pickup well emptied; the reservoir is kept. */
-declare function cleanMixer(load: MixerLoad): MixerLoad;
-/** The pixels a mixer stroke reads and writes (RGBA tiles in layer space). */
-type MixerTarget = PaintTileTarget;
-/**
- * One Mixer Brush stroke. Feed points with `push` (any chunks give the same dabs), end with
- * `finish`; `load` is the brush load after the dabs so far. Each call returns the document
- * rectangles it touched. Runs on the shared pick-up / mix exchange (`./exchange`).
- */
-declare class MixerStroke {
-    readonly brush: BrushSettings;
-    dabCount: number;
-    bounds: RasterRect | null;
-    private walker;
-    private smoothPos;
-    private buf;
-    private readonly exchange;
-    private readonly medium;
-    private readonly paintColor;
-    constructor(brush: BrushSettings, settings: Partial<MixerSettings>, load: MixerLoad, target: MixerTarget);
-    /** The brush load after the dabs so far. */
-    get load(): MixerLoad;
-    push(points: readonly StrokePoint[]): RasterRect[];
-    finish(last?: StrokePoint): RasterRect[];
-    private smooth;
-    private paint;
-    private dab;
-}
-
-/**
- * Blending tools on raster tiles, dab by dab (any dab walker can drive them):
- *
- * - **Blender** (`blenderDab`): every pixel under the tip moves towards the mix of the paint
- *   within `distance` of it, so neighbouring colours run together. The mix is taken through the
- *   pigment model: the neighbourhood's K/S spectra are averaged with Kubelka-Munk weights
- *   (alpha × scattering), so blue next to yellow blends into green, not grey. `rgb` averages
- *   straight colours instead.
- * - **Smudge** (`SmudgeTip`): a finger that carries a patch of paint. Each dab lays the patch it
- *   carries over the pixels under the tip (`strength`) and picks up some of the paint that was
- *   there (`1 − length`), so the paint's pattern is dragged along the stroke and fades with distance.
- *   Optional pigment mixing for both steps.
- *
- * Both blend alpha too: blending next to bare canvas softens an edge, smudging drags paint out
- * into it. A transparency-locked layer keeps its alpha. Pure data in, pixels out.
- */
-
-/** Blender options. */
-interface BlenderSettings {
-    /** How far each pixel moves towards the neighbourhood mix per dab at full coverage, 0..1 (default 0.5). */
-    strength: number;
-    /** Blend distance: the neighbourhood's radius as a fraction of the tip diameter, 0..1 (default 0.35). */
-    distance: number;
-    /** `pigment` (default: Kubelka-Munk, blue next to yellow blends green) or `rgb`. */
-    mixing: MixingModel;
-}
-declare const DEFAULT_BLENDER: Readonly<BlenderSettings>;
-/** Smudge options. */
-interface SmudgeSettings {
-    /** How strongly the carried paint covers the pixels under the tip per dab, 0..1 (default 0.7). */
-    strength: number;
-    /** How far paint is dragged: the share of the carried patch kept per dab, 0..1 (default 0.85). */
-    length: number;
-    /** `rgb` (default) or `pigment` (smeared colours mix like paint). */
-    mixing: MixingModel;
-}
-declare const DEFAULT_SMUDGE: Readonly<SmudgeSettings>;
-declare function normalizeBlender(raw?: Partial<BlenderSettings>, base?: BlenderSettings): BlenderSettings;
-declare function normalizeSmudge(raw?: Partial<SmudgeSettings>, base?: SmudgeSettings): SmudgeSettings;
-/** The neighbourhood radius in pixels of a blender dab of `radius`. */
-declare function blendRadius(settings: BlenderSettings, radius: number): number;
-/** Reusable buffers for `blenderDab` (one per stroke). */
-interface BlenderScratch {
-    sums: Float64Array;
-    mix: Pigment;
-    out: number[];
-}
-declare function createBlenderScratch(): BlenderScratch;
-/**
- * One blender dab: `cov` is the tip's coverage over `rect` (document space, 0..1), `opacity` the
- * dab's (pressure) opacity, `radius` its radius in pixels. Reads the neighbourhood as it was
- * before the dab, then writes every covered pixel.
- */
-declare function blenderDab(medium: TileMedium, rect: RasterRect, cov: ArrayLike<number>, opacity: number, radius: number, settings: BlenderSettings, scratch: BlenderScratch): void;
-/** A dab as the smudge needs it: centre, radius (px) and pressure opacity. */
-interface SmudgeDab {
-    x: number;
-    y: number;
-    radius: number;
-    opacity: number;
-}
-/**
- * A smudging finger: carries a patch of paint (straight RGBA, `size × size` cells over the tip,
- * in canvas orientation) from dab to dab. The first dab only picks the patch up.
- */
-declare class SmudgeTip {
-    readonly settings: SmudgeSettings;
-    private readonly size;
-    private readonly patch;
-    private loaded;
-    private readonly out;
-    constructor(settings: SmudgeSettings, 
-    /** The largest tip diameter of the stroke, in pixels (the patch resolution). */
-    diameter: number);
-    private cell;
-    /** Fills the patch from the pixels under the dab. */
-    private load;
-    /** `a` mixed `t` of the way to `b` (both 0..1) into `out`. */
-    private mix;
-    /** One dab: lays the carried patch over the tip's footprint (`cov` over `rect`), then picks up. */
-    dab(medium: TileMedium, d: SmudgeDab, rect: RasterRect, cov: ArrayLike<number>): void;
-}
-
-/**
- * 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 { type PaintGradientRepeat as $, MAX_BRUSH_SIZE as A, type BrushSettings as B, type CloneTransform as C, type Dab as D, PAINT_COLOR_JSON_SCHEMA as E, PAINT_GRADIENT_FULL_SPEED as F, PAINT_GRADIENT_JSON_SCHEMA as G, PAINT_GRADIENT_KIT as H, PAINT_GRADIENT_MAPPINGS as I, PAINT_GRADIENT_MAPPING_LABELS as J, PAINT_GRADIENT_PRESETS as K, PAINT_GRADIENT_REPEATS as L, type MixerSettings as M, PAINT_GRADIENT_REPEAT_LABELS as N, PAINT_GRADIENT_SPACES as O, type PaintSource as P, PAINT_GRADIENT_SPACE_LABELS as Q, type RetouchSettings as R, StrokeCoverage as S, TileMedium as T, PAINT_SOURCE_JSON_SCHEMA as U, type PaintColorSource as V, WetWorld as W, type PaintDabParams as X, type PaintGradientKit as Y, type PaintGradientMapping as Z, type PaintGradientMappingKind as _, type MixerLoad as a, PARAM_FLOATS as a$, type PaintGradientSample as a0, PaintGradientSampler as a1, type PaintGradientSpace as a2, type PaintGradientStop as a3, type PaintRgb as a4, PaintSourceError as a5, WET_FLOW_KINDS as a6, WET_PARAM_KEYS as a7, type WetFlowKind as a8, type WetSupport as a9, DEFAULT_SMUDGE as aA, DEFAULT_WET_PAPER as aB, DRY_EPS as aC, DabWalker as aD, EMPTY_MIXER_LOAD as aE, EX as aF, EY as aG, type ExchangeRates as aH, FLAG_ALIVE as aI, FLAG_BOTTOM as aJ, FLAG_LEFT as aK, FLAG_RIGHT as aL, FLAG_TOP as aM, FLAG_WET as aN, FLAT as aO, FREE_INTERVAL as aP, IDENTITY_CLONE_TRANSFORM as aQ, MAX_BATCH as aR, MAX_TILT_ACCEL as aS, MAX_WET_LANES as aT, MAX_WET_SLOTS as aU, MIXER_DRAIN as aV, MIXER_PICKUP_RATE as aW, MIXING_MODELS as aX, OPP as aY, PAPER_CAPACITY as aZ, PARAM as a_, addPaintGradientStop as aa, hash2 as ab, hexToPaintRgb as ac, isGradientPaint as ad, mix32 as ae, normalizeFlow as af, normalizeHexColor as ag, normalizeWetParams as ah, paintGradientMappingFor as ai, paintSourceColor as aj, paintSourceCss as ak, parsePaintSource as al, rand01 as am, readPaintSource as an, removePaintGradientStop as ao, resolvePaintGradient as ap, reversePaintGradient as aq, scalePaintGradient as ar, solidPaint as as, updatePaintGradientStop as at, wetSupport as au, type BlenderScratch as av, DEFAULT_BLENDER as aw, DEFAULT_BRUSH as ax, DEFAULT_MIXER as ay, DEFAULT_RETOUCH as az, type MixerTarget as b, createBlenderScratch as b$, PIGMENT_CHANNELS as b0, PLANE as b1, PLANE_BYTES as b2, P_D0 as b3, P_EDGE as b4, P_FX as b5, P_FY as b6, P_H as b7, P_P0 as b8, P_RHO as b9, type ToneRange as bA, TransformedPixelSource as bB, U_MAX as bC, W9 as bD, WET_TILE as bE, type WetFlowField as bF, WetGpuEngine as bG, type WetGpuJob as bH, type WetGpuSupport as bI, type WetKernelKind as bJ, type WetLaneOptions as bK, type WetLaneStats as bL, type WetPaper as bM, type WetWorkerLayout as bN, WetWorkerPool as bO, WetWorldError as bP, applyRetouchToTile as bQ, applyStrokeToDeepTile as bR, applyStrokeToTile as bS, applyToneToDeepTile as bT, blendRadius as bU, blenderDab as bV, boxBlurPixels as bW, canShareMemory as bX, cleanMixer as bY, cloneSamplePoint as bZ, coverageTileCoord as b_, P_SW as ba, P_UX as bb, P_UY as bc, PaintExchange as bd, type PaintMedium as be, type PaintPixels as bf, type PaintSample as bg, type PixelSource as bh, RETOUCH_SAMPLES as bi, RegionPixelSource as bj, type RetouchDabEffect as bk, RetouchDabStroke as bl, type RetouchSample as bm, SET_PLANES as bn, SLOT_BYTES as bo, SLOT_PLANES as bp, SLOT_SIDE as bq, SPOT_HEAL_TYPES as br, STRIP as bs, type SmudgeDab as bt, SmudgeTip as bu, type SpotHealType as bv, TIP_GRADIENT_STEPS as bw, TONE_RANGES as bx, type TileMediumOptions as by, TilePixelSource as bz, MixerStroke as c, createWetGpuEngine as c0, dabCoverage as c1, dabRect as c2, dodgeBurn as c3, dodgeBurnCurve as c4, dsincos as c5, edgeBits as c6, exchangeRates as c7, findWebGpu as c8, flowField as c9, spotHealPixels as cA, spotHealWindow as cB, tipFalloff as cC, tipReach as cD, tipShape as cE, toneOf as cF, walkDabs as cG, wetGpuSupport as cH, wetSimdSupported as cI, gradientDabColor as ca, healPixels as cb, isIdentityCloneTransform as cc, latticeViscosity as cd, loadMixer as ce, loadWetKernel as cf, luma as cg, mixerRates as ch, normalizeBlender as ci, normalizeBrush as cj, normalizeMixer as ck, normalizeRetouch as cl, normalizeSmudge as cm, normalizeTilt as cn, packWetParams as co, perDabStrength as cp, put255 as cq, rasterizeDab as cr, readSourceRegion as cs, retouchFilter as ct, rgbaViewOfGrey as cu, saturationOf as cv, smoothPoints as cw, smudgeEffect as cx, sponge as cy, spongeEffect as cz, type RetouchApply as d, type StrokePoint as e, type RetouchPaint as f, CoverageMap as g, type PaintTileTarget as h, type StrokeApply as i, type PaintGradientSource as j, type MixingModel as k, type BlenderSettings as l, type SmudgeSettings as m, type WetTilt as n, type WetParams as o, type WetFlowSpec as p, type RgbTriple as q, type WetWorldOptions as r, type WetGpuProvider as s, type WetBackendInfo as t, type WetSnapshot as u, type WetPaperInput as v, DEFAULT_FLOW as w, DEFAULT_PAINT_GRADIENT as x, DEFAULT_PAINT_GRADIENT_MAPPING as y, DEFAULT_WET_PARAMS as z };