@pixerate/editor 0.135.0 → 0.137.0

package/dist/blending-D7jCmjO6.d.cts

@@ -0,0 +1,1026 @@
+import { a as BlendMode, R as RasterRect, j as TileKey, Y as Pigment } 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 ("velocity" | "distance" | "pressure" | "tilt" | "direction" | "across-tip" | "random" | "time")[];
+                    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 ("velocity" | "distance" | "pressure" | "tilt" | "direction" | "across-tip" | "random" | "time")[];
+                        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 ("velocity" | "distance" | "pressure" | "tilt" | "direction" | "across-tip" | "random" | "time")[];
+    readonly PAINT_GRADIENT_MAPPING_LABELS: Readonly<Record<"velocity" | "distance" | "pressure" | "tilt" | "direction" | "across-tip" | "random" | "time", 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;
+}
+
+export { parsePaintSource as $, type PaintColorSource as A, type BrushSettings as B, CoverageMap as C, type Dab as D, type PaintDabParams as E, type PaintGradientKit as F, type PaintGradientMapping as G, type PaintGradientMappingKind as H, type PaintGradientRepeat as I, type PaintGradientSample as J, PaintGradientSampler as K, type PaintGradientSpace as L, type MixerSettings as M, type PaintGradientStop as N, type PaintRgb as O, type PaintTileTarget as P, PaintSourceError as Q, type RgbTriple as R, type StrokePoint as S, TileMedium as T, addPaintGradientStop as U, hexToPaintRgb as V, isGradientPaint as W, normalizeHexColor as X, paintGradientMappingFor as Y, paintSourceColor as Z, paintSourceCss as _, type PaintGradientSource as a, readPaintSource as a0, removePaintGradientStop as a1, resolvePaintGradient as a2, reversePaintGradient as a3, scalePaintGradient as a4, solidPaint as a5, updatePaintGradientStop as a6, type BlenderScratch as a7, DEFAULT_BLENDER as a8, DEFAULT_BRUSH as a9, loadMixer as aA, mixerRates as aB, normalizeBlender as aC, normalizeBrush as aD, normalizeMixer as aE, normalizeSmudge as aF, put255 as aG, rasterizeDab as aH, smoothPoints as aI, tipFalloff as aJ, tipReach as aK, tipShape as aL, walkDabs as aM, DEFAULT_MIXER as aa, DEFAULT_SMUDGE as ab, DabWalker as ac, EMPTY_MIXER_LOAD as ad, type ExchangeRates as ae, MIXER_DRAIN as af, MIXER_PICKUP_RATE as ag, MIXING_MODELS as ah, PaintExchange as ai, type PaintMedium as aj, type PaintSample as ak, type SmudgeDab as al, SmudgeTip as am, TIP_GRADIENT_STEPS as an, type TileMediumOptions as ao, applyStrokeToDeepTile as ap, applyStrokeToTile as aq, blendRadius as ar, blenderDab as as, cleanMixer as at, coverageTileCoord as au, createBlenderScratch as av, dabCoverage as aw, dabRect as ax, exchangeRates as ay, gradientDabColor as az, type MixingModel as b, type BlenderSettings as c, type SmudgeSettings as d, type PaintSource as e, type PaintPixels as f, type MixerLoad as g, StrokeCoverage as h, type MixerTarget as i, MixerStroke as j, type StrokeApply as k, DEFAULT_PAINT_GRADIENT as l, DEFAULT_PAINT_GRADIENT_MAPPING as m, MAX_BRUSH_SIZE as n, PAINT_COLOR_JSON_SCHEMA as o, PAINT_GRADIENT_FULL_SPEED as p, PAINT_GRADIENT_JSON_SCHEMA as q, PAINT_GRADIENT_KIT as r, PAINT_GRADIENT_MAPPINGS as s, PAINT_GRADIENT_MAPPING_LABELS as t, PAINT_GRADIENT_PRESETS as u, PAINT_GRADIENT_REPEATS as v, PAINT_GRADIENT_REPEAT_LABELS as w, PAINT_GRADIENT_SPACES as x, PAINT_GRADIENT_SPACE_LABELS as y, PAINT_SOURCE_JSON_SCHEMA as z };