@pixerate/editor 0.102.0 → 0.105.0

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

@@ -0,0 +1,1680 @@
+import { R as RasterLayer, a as RasterGroupLayer, b as RasterPixelLayer, C as CompositorLayer, c as RasterCompositor, d as RasterSources, L as LayerLocks } from '../compositor-Bc3PNP3C.cjs';
+import { B as BrushSettings, M as MixerSettings, C as CoverageMap, D as Dab, S as StrokePoint, a as MixerLoad } from '../mixer-C1M1Nua_.cjs';
+export { b as MAX_BRUSH_SIZE } from '../mixer-C1M1Nua_.cjs';
+import { R as RasterRect, a as TiledSurface, B as BlendMode } from '../surface-BBJN9wxg.cjs';
+export { b as BLEND_MODES, c as Tile, i as isBlendMode } from '../surface-BBJN9wxg.cjs';
+import { I as ImageEditorAssetStore, S as SerializedLayer, P as PsdExportResult } from '../export-_m3Es4ru.cjs';
+import { a as AgentToolProvider } from '../registry-BqA1AZt0.cjs';
+import '../types-CwMPoRMU.cjs';
+import '../warp-D5jz_tN7.cjs';
+import '../schema-Di0CS6Pe.cjs';
+
+/**
+ * Seeded, deterministic noise for paper grain and brush jitter (photocraft's counter-based
+ * randomness and tileable value noise, on 32-bit integer hashes instead of 64-bit ones so it runs
+ * fast in JavaScript). Every value is a pure function of its inputs, so a paper or a stroke
+ * regenerates identically on every machine.
+ */
+/** 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;
+/** Uniform in [-1, 1). */
+declare function randSigned(seed: number, index: number, stream: number): number;
+/** A seed from a string (FNV-1a, then mixed). */
+declare function seedFromString(text: string): number;
+/**
+ * Tileable fractal value noise in 0..1 over a `size`-pixel square: `cellsX × cellsY` lattice cells
+ * at the base octave (unequal counts give fibres and streaks), doubling per octave, so the result
+ * repeats exactly every `size` pixels.
+ */
+declare class TileableNoise {
+    readonly size: number;
+    private readonly octaves;
+    constructor(size: number, cellsX: number, cellsY: number, octaves: number, salt: number);
+    /** Fractal noise at pixel (x, y). */
+    at(x: number, y: number): number;
+}
+
+/**
+ * Paper: a generated grain height map (0 = valley, 1 = peak) that tiles across the canvas, a paper
+ * colour, grain depth, and the three properties wet media will read later (absorption,
+ * permeability, roughness). Dry media catch the peaks: a light stroke only marks the high grain, a
+ * firm one fills the valleys too. Everything is generated from a pattern and a seed, so a paper is
+ * a few numbers in the document, never a bitmap, and no third-party texture is bundled.
+ */
+/** Grain generators. Each is our own procedural pattern (no scanned textures). */
+type GrainPattern = 'smooth' | 'cold-pressed' | 'hot-pressed' | 'rough' | 'vellum' | 'laid' | 'ingres' | 'sanded' | 'canvas' | 'linen' | 'gesso';
+declare const GRAIN_PATTERNS: readonly GrainPattern[];
+/** Paper families, as a library groups them. */
+type PaperFamily = 'watercolor' | 'drawing' | 'pastel' | 'canvas' | 'panel' | 'smooth';
+declare const PAPER_FAMILIES: readonly PaperFamily[];
+/** How a height map is tuned for one kind of media. */
+interface GrainTuning {
+    /** Height contrast around the middle, 0..3 (default 1). */
+    contrast: number;
+    /** Swap peaks and valleys (default false). */
+    invert: boolean;
+}
+type PaperTiling = 'repeat' | 'mirror';
+interface PaperSettings {
+    /** The library preset this paper started from (`custom` when it matches none). */
+    preset: string;
+    name: string;
+    family: PaperFamily;
+    pattern: GrainPattern;
+    /** Grain seed: another seed gives another sheet of the same paper. */
+    seed: number;
+    /** Paper colour #rrggbb. */
+    color: string;
+    /** Grain scale: 1 is the pattern's natural size, 2 twice as coarse (0.25..8). */
+    scale: number;
+    /** How the grain tile repeats: `repeat` or `mirror` (alternate tiles flipped, so seams vanish). */
+    tiling: PaperTiling;
+    /** Grain depth 0..1: how much grain-responsive dry media skip the valleys (0: none). */
+    depth: number;
+    /** How much the grain shades the paper colour on screen and in exports, 0..1. */
+    shading: number;
+    /** The height map as dry media read it. */
+    dry: GrainTuning;
+    /** The height map as wet media will read it (stored now; wet media is a later phase). */
+    wet: GrainTuning;
+    /** Wet media: how fast the paper takes up water, 0..1. */
+    absorption: number;
+    /** Wet media: how far water spreads inside the paper, 0..1. */
+    permeability: number;
+    /** Wet media: how much the grain catches pigment, 0..1. */
+    roughness: number;
+}
+/** Side of the generated grain tile in pixels (at scale 1). */
+declare const GRAIN_TILE = 256;
+type PaperPreset = PaperSettings;
+/** The built-in paper library: generated papers in families. */
+declare const PAPER_LIBRARY: readonly PaperPreset[];
+declare const DEFAULT_PAPER: Readonly<PaperSettings>;
+/** A paper from the library by id, or `undefined`. */
+declare function paperPreset(id: string): PaperSettings | undefined;
+declare function clonePaper(p: PaperSettings): PaperSettings;
+/**
+ * A paper with every field in range. Missing fields come from `base` (default: the library preset
+ * named by `raw.preset`, else cold pressed).
+ */
+declare function normalizePaper(raw?: Partial<PaperSettings> | Record<string, unknown>, base?: PaperSettings): PaperSettings;
+/** The raw height map of a pattern (`GRAIN_TILE` square, 0..1), generated once per pattern and seed. */
+declare function grainHeights(pattern: GrainPattern, seed: number, size?: number): Float32Array;
+/**
+ * A paper's height field over the canvas (document pixels), tuned for one kind of media. Read it
+ * with `at(x, y)`: bilinear, tiled by `paper.tiling`, at `paper.scale`.
+ */
+declare class PaperGrain {
+    readonly size = 256;
+    private readonly heights;
+    private readonly scale;
+    private readonly mirror;
+    readonly flat: boolean;
+    constructor(paper: PaperSettings, media?: 'dry' | 'wet');
+    /** Tile cell index for a coordinate in grain pixels (mirrored on odd tiles when mirroring). */
+    private wrap;
+    /** Height 0..1 at document position (x, y). */
+    at(x: number, y: number): number;
+}
+/**
+ * How much of a dry dab lands at grain height `h` (0..1): the media catches the peaks first, and
+ * pressure pushes it into the valleys. `depth` is the paper's grain depth times the brush's grain
+ * response; at 0 everything lands (1).
+ */
+declare function grainCatch(h: number, depth: number, pressure: number): number;
+/** `#rrggbb` → [r, g, b] 0..255. */
+declare function hexToRgb8(hex: string): [number, number, number];
+/**
+ * The paper as opaque RGBA over `rect` (document pixels): its colour, darkened in the valleys by
+ * `shading`.
+ */
+declare function renderPaper(paper: PaperSettings, rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, grain?: PaperGrain): Uint8ClampedArray;
+
+/**
+ * Paint editor brushes: the shared engine's tip settings (`@pixerate/editor/paint`) plus what a
+ * natural-media brush adds: paper grain response, pen dynamics (pressure, tilt, barrel rotation,
+ * velocity), separate pressure smoothing, a rotation mode, jitter, and Mixer Brush settings for
+ * the blending brushes. The built-in presets are our own settings; none come from another product.
+ */
+
+/** How a brush makes marks: dabs into a stroke buffer, removing alpha, or the Mixer Brush engine. */
+type PaintBrushEngine = 'dab' | 'eraser' | 'mixer';
+declare const PAINT_BRUSH_ENGINES: readonly PaintBrushEngine[];
+type PaintBrushCategory = 'pencil' | 'pastel' | 'charcoal' | 'airbrush' | 'marker' | 'ink' | 'eraser' | 'blender' | 'smudge' | 'mixer' | 'custom';
+declare const PAINT_BRUSH_CATEGORIES: readonly PaintBrushCategory[];
+/** What turns the tip: a fixed angle, the direction of the stroke, or the pen's barrel rotation. */
+type BrushRotation = 'fixed' | 'stroke' | 'barrel';
+declare const BRUSH_ROTATIONS: readonly BrushRotation[];
+/** Pen dynamics and jitter. Every amount is 0 (off) .. 1 unless noted. */
+interface BrushDynamics {
+    /** Size at zero pressure as a fraction of the full size, when pressure controls size (default 0). */
+    minSize: number;
+    /** How much pressure scales flow (default 0). */
+    pressureFlow: number;
+    /** Laying the pen down widens the tip, up to 2.5× (default 0). */
+    tiltSize: number;
+    /** Laying the pen down flattens the tip along the tilt direction (default 0). */
+    tiltRoundness: number;
+    /** Laying the pen down lightens the mark, as when shading with the side of a pencil (default 0). */
+    tiltOpacity: number;
+    /** -1..1: positive grows the tip when the pen moves fast, negative thins it (default 0). */
+    velocitySize: number;
+    /** -1..1: positive darkens fast marks, negative lightens them (default 0). */
+    velocityOpacity: number;
+    /** Random size change per dab (default 0). */
+    sizeJitter: number;
+    /** Random angle per dab, as a fraction of ±180° (default 0). */
+    angleJitter: number;
+    /** Random opacity drop per dab (default 0). */
+    opacityJitter: number;
+    /** Random offset across the stroke in diameters, 0..4 (default 0). */
+    scatter: number;
+}
+declare const DEFAULT_DYNAMICS: Readonly<BrushDynamics>;
+interface PaintBrush {
+    /** Library id (lowercase letters, digits and dashes). */
+    id: string;
+    name: string;
+    category: PaintBrushCategory;
+    engine: PaintBrushEngine;
+    /** The shared engine's tip: size, hardness, spacing, angle, roundness, opacity, flow, position smoothing, pressure to size / opacity, blend. */
+    tip: BrushSettings;
+    /** How strongly the mark follows the paper grain, 0 (ignores it) .. 1 (catches only the peaks at light pressure). */
+    grain: number;
+    /** Pressure smoothing 0..0.95, separate from the tip's position smoothing (default 0). */
+    pressureSmoothing: number;
+    rotation: BrushRotation;
+    dynamics: BrushDynamics;
+    /** Mixer engine only: the Mixer Brush settings. */
+    mixer: MixerSettings;
+    /** Mixer engine only: load the current colour each stroke (false: a smudge or blender that only moves paint). */
+    loadsColor: boolean;
+    /** True for the built-in presets (they cannot be removed or overwritten). */
+    builtin?: boolean;
+}
+declare function normalizeDynamics(raw?: Partial<BrushDynamics>, base?: BrushDynamics): BrushDynamics;
+declare const BRUSH_ID: RegExp;
+/** Brush settings to change or read: any subset of a brush, its tip, dynamics and mixer. */
+type PaintBrushInput = Partial<Omit<PaintBrush, 'tip' | 'dynamics' | 'mixer'>> & {
+    tip?: Partial<BrushSettings>;
+    dynamics?: Partial<BrushDynamics>;
+    mixer?: Partial<MixerSettings>;
+};
+/** A brush with every field in range; missing fields come from `base` (default: a plain round dab brush). */
+declare function normalizePaintBrush(raw?: PaintBrushInput, base?: PaintBrush): PaintBrush;
+/** The built-in brush library. */
+declare const BUILTIN_BRUSHES: readonly PaintBrush[];
+declare const DEFAULT_BRUSH_ID = "pencil-6b";
+
+/** A brush as plain JSON (for export, agents and saved libraries): no `builtin` flag. */
+declare function brushToJSON(brush: PaintBrush): Omit<PaintBrush, 'builtin'>;
+/** The JSON file a brush library exports to and imports from. */
+interface BrushLibraryFile {
+    format: 'pixerate-brushes';
+    version: 1;
+    brushes: Array<Omit<PaintBrush, 'builtin'>>;
+}
+/**
+ * Brushes read from a brush library file (or a bare array of brushes). Each is normalised; ones
+ * without a valid id or name are reported in `problems` and skipped.
+ */
+declare function parseBrushLibrary(raw: unknown, problems?: string[]): PaintBrush[];
+
+/**
+ * The paint editor's dry-media stroke engine, on the shared brush engine (`@pixerate/editor/paint`):
+ *
+ * - Pen input: pressure, tilt (`tiltX` / `tiltY` or `altitude` / `azimuth`), barrel rotation
+ *   (`twist`) and time (for velocity). Position and pressure are smoothed separately.
+ * - `PenDabWalker` walks the points into the shared `Dab`s at `spacing × diameter`, with every
+ *   pen channel interpolated, and applies the brush's dynamics, rotation mode and jitter.
+ *   Jitter is a pure hash of the stroke seed and the dab index, so a stroke replays exactly.
+ * - `DryStroke` rasterizes each dab with the shared round tip, multiplies it by how much of it the
+ *   paper grain catches (`grainCatch`), and builds it up in the shared `CoverageMap`; the session
+ *   then composites the coverage with the shared `applyStrokeToTile`.
+ * - Symmetry: one stroke can paint several copies of its points (mirror and kaleidoscope), each
+ *   with its own walker, into the same coverage, so the copies are one stroke and one undo step.
+ *
+ * Pure data in, pixels out: no DOM, no framework.
+ */
+
+/** One pen sample in document pixels. Every channel but x and y is optional. */
+interface PenPoint {
+    x: number;
+    y: number;
+    /** 0..1 (missing: 1, a mouse). */
+    pressure?: number;
+    /** Milliseconds since any fixed origin (for velocity; missing: no velocity dynamics). */
+    t?: number;
+    /** Pointer Events tilt in degrees, -90..90 (used when `altitude` / `azimuth` are missing). */
+    tiltX?: number;
+    tiltY?: number;
+    /** Radians from the surface: π/2 is upright, 0 lies flat. */
+    altitude?: number;
+    /** Radians clockwise from the +x axis (screen y points down): where the pen leans. */
+    azimuth?: number;
+    /** Barrel rotation in degrees clockwise, 0..359. */
+    twist?: number;
+}
+/** A pen's lean as altitude and azimuth, or `null` when the sample has no tilt. */
+declare function penOrientation(p: PenPoint): {
+    altitude: number;
+    azimuth: number;
+} | null;
+/** Pointer Events `tiltX` / `tiltY` (degrees) → altitude and azimuth (radians). */
+declare function tiltToOrientation(tiltX: number, tiltY: number): {
+    altitude: number;
+    azimuth: number;
+};
+/**
+ * Exponential smoothing of position and of pressure, each by its own amount (0..0.95). Feed raw
+ * samples; the first sample passes through.
+ */
+declare class PenSmoother {
+    private pos;
+    private pressure;
+    private readonly a;
+    private readonly ap;
+    constructor(position: number, pressure: number);
+    push(p: PenPoint): PenPoint;
+    /** Where the smoothed position is now (or `null` before the first sample). */
+    get position(): {
+        x: number;
+        y: number;
+    } | null;
+}
+/** A linear map of document vectors `[a, b, c, d]`: (x, y) → (a·x + b·y, c·x + d·y). */
+type Linear2 = readonly [number, number, number, number];
+/** How one copy of a stroke maps the input: a point map and its linear part (for dab angles). */
+interface StrokeCopy {
+    map(p: PenPoint): PenPoint;
+    linear: Linear2;
+}
+declare const IDENTITY_COPY: StrokeCopy;
+/** A dab with the pen state it was made at (the shared `Dab` plus pressure for the grain). */
+interface PenDab extends Dab {
+    pressure: number;
+}
+/**
+ * Walks pen samples into dabs, incrementally (any chunking gives the same dabs). Dab angles are in
+ * the shared rasterizer's convention: radians, counter-clockwise with y up.
+ */
+declare class PenDabWalker {
+    readonly brush: PaintBrush;
+    private readonly seed;
+    private readonly linear;
+    private last;
+    private nextAt;
+    private pendingFirst;
+    private index;
+    private dir;
+    private lastT;
+    private speed;
+    constructor(brush: PaintBrush, seed?: number, linear?: Linear2);
+    private sample;
+    private diameter;
+    private stepLen;
+    /** A rasterizer angle (CCW, y up) mapped through this copy's linear part. */
+    private mapAngle;
+    private dab;
+    push(p: PenPoint, out: PenDab[]): void;
+    finish(out: PenDab[]): void;
+}
+interface DryStrokeOptions {
+    /** The paper's dry height field, or `null` for no grain. */
+    grain: PaperGrain | null;
+    /** The paper's grain depth, 0..1 (multiplied by the brush's grain response). */
+    paperDepth: number;
+    /** Jitter seed (record it to replay the stroke exactly). */
+    seed?: number;
+    /** Copies of the stroke (symmetry); default one identity copy. */
+    copies?: readonly StrokeCopy[];
+}
+/**
+ * One dab-engine stroke (dab and eraser brushes): smoothing, the dab walk of every copy, grain and
+ * build-up in a shared coverage map.
+ */
+declare class DryStroke {
+    readonly brush: PaintBrush;
+    private readonly options;
+    readonly coverage: CoverageMap;
+    dabCount: number;
+    private readonly smoother;
+    private readonly walkers;
+    private readonly copies;
+    private readonly depth;
+    private buf;
+    private lastRaw;
+    private lastFed;
+    constructor(brush: PaintBrush, options: DryStrokeOptions);
+    /** Feeds raw pen samples; returns the document rectangles the new dabs touched. */
+    push(points: readonly PenPoint[]): RasterRect[];
+    /** Ends the stroke: the smoothed path catches up with the last raw sample; a single tap paints one dab. */
+    finish(): RasterRect[];
+    private paint;
+}
+/** The shared engine's tip for the Mixer Brush engine (it smooths and walks by itself, so smoothing is applied before). */
+declare function mixerTip(brush: PaintBrush): BrushSettings;
+/** Pen samples → the shared engine's stroke points (pressure only). */
+declare function toStrokePoint(p: PenPoint): StrokePoint;
+
+/**
+ * Strokes as data. Every committed stroke is recorded with the brush, colour, raw pen samples,
+ * jitter seed and symmetry copies it was painted with, so it replays to the same pixels, and can
+ * be replayed moved, scaled, rotated, recoloured or with another brush (`replay_strokes`).
+ */
+
+/** An affine map [a, b, c, d, e, f]: (x, y) → (a·x + b·y + e, c·x + d·y + f). */
+type Affine = readonly [number, number, number, number, number, number];
+declare const IDENTITY_AFFINE: Affine;
+interface RecordedStroke {
+    id: string;
+    layerId: string;
+    brush: PaintBrush;
+    /** #rrggbb */
+    color: string;
+    /** Raw pen samples in document pixels, before smoothing. */
+    points: PenPoint[];
+    seed: number;
+    /** Extra copies painted with the stroke (mirror / kaleidoscope), as affine maps of the points. */
+    copies?: Affine[];
+}
+declare function applyAffine(m: Affine, x: number, y: number): {
+    x: number;
+    y: number;
+};
+/** `a ∘ b` (b first). */
+declare function composeAffine(a: Affine, b: Affine): Affine;
+declare function invertAffine(m: Affine): Affine;
+/** The pen sample mapped by `m` (tilt and twist are kept: they describe the pen, not the path). */
+declare function mapPenPoint(m: Affine, p: PenPoint): PenPoint;
+/** An affine copy as the engine's `StrokeCopy`. */
+declare function affineCopy(m: Affine): StrokeCopy;
+/** A recorded stroke read from JSON, or `null` when it is not one. */
+declare function normalizeBrushStroke(raw: unknown): RecordedStroke | null;
+/** The bounding box of a stroke's points. */
+declare function strokeBounds(points: readonly PenPoint[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+interface StrokeVariation {
+    /** Move by this many document pixels (default 0). */
+    dx?: number;
+    dy?: number;
+    /** Scale about the origin (default 1); brush size scales with it. */
+    scale?: number;
+    /** Rotate about the origin, degrees clockwise (default 0). */
+    rotate?: number;
+    /** Mirror horizontally about the origin (default false). */
+    flipX?: boolean;
+    /** The origin for scale, rotate and flip (default: the centre of the strokes' bounds). */
+    origin?: {
+        x: number;
+        y: number;
+    };
+    /** Multiply every pressure by this (default 1). */
+    pressureScale?: number;
+}
+/** The affine map of a variation about `origin`. */
+declare function variationAffine(v: StrokeVariation, origin: {
+    x: number;
+    y: number;
+}): Affine;
+/** A stroke varied by `m` (points mapped; symmetry copies conjugated so they stay symmetric). */
+declare function varyStroke(stroke: RecordedStroke, m: Affine, v: StrokeVariation): RecordedStroke;
+
+/**
+ * The paint editor's document: a canvas (size and resolution), a paper, and the shared raster
+ * layer stack (`@pixerate/editor/raster`: pixel layers and groups with masks, clipping, locks and
+ * blend modes). Layers are immutable and share tiles, so a history entry is a reference to a
+ * whole document state.
+ *
+ * Saved documents are JSON plus PNG assets, through the image editor's layer serializer (so the
+ * same layer tree loads in both editors), with the paper as plain settings.
+ */
+
+type PaintPixelLayer = RasterPixelLayer;
+type PaintGroupLayer = RasterGroupLayer<PaintLayer>;
+/** A layer of the paint editor: the shared stack's pixel layers and groups. */
+type PaintLayer = RasterLayer;
+/** Canvas size limits (pixels per side). */
+declare const MIN_CANVAS_SIDE = 1;
+declare const MAX_CANVAS_SIDE = 16384;
+declare const DEFAULT_DPI = 300;
+interface PaintCanvas {
+    width: number;
+    height: number;
+    /** Pixels per inch, for print sizes and PSD resolution (default 300). */
+    dpi: number;
+}
+/** Everything one undo step restores. */
+interface PaintDocumentState {
+    canvas: PaintCanvas;
+    paper: PaperSettings;
+    /** Bottom to top. */
+    layers: PaintLayer[];
+    activeLayerId: string | null;
+    /** Every committed stroke, oldest first (strokes are data: replay, vary, time-lapse later). */
+    strokes: RecordedStroke[];
+}
+/** A new layer id, unique in this session. */
+declare function newPaintLayerId(): string;
+/** An empty, visible, normal pixel layer. */
+declare function createPaintLayer(name: string, id?: string): PaintPixelLayer;
+declare class PaintDocumentError extends Error {
+    constructor(message: string);
+}
+/** Validates and rounds a canvas size; throws a `PaintDocumentError` that says what is wrong. */
+declare function normalizeCanvas(raw: Partial<PaintCanvas>): PaintCanvas;
+/** A blank document: one empty layer over the paper. */
+declare function createPaintDocument(options?: Partial<PaintCanvas> & {
+    paper?: Partial<PaperSettings>;
+}): PaintDocumentState;
+
+/**
+ * A live stroke on one pixel layer. Points arrive while the pen moves; the layer shows the stroke
+ * so far through a live surface (no history); `end()` commits it as one undo step.
+ *
+ * - Dab and eraser brushes: the coverage is cumulative, so each update recomposites the touched
+ *   region from the pre-stroke tile (`applyStrokeToTile` with `into` and `region`).
+ * - Mixer engine brushes (Mixer Brush, blender, smudge): dabs read what earlier dabs laid down, so
+ *   they paint into live tile copies; every tile written since the last update gets a new `Tile`
+ *   object, because the compositor caches by tile identity.
+ */
+
+interface StrokeSessionHost {
+    /** Shows the layer's live surface (no history); `rects` are where it changed. */
+    update(layerId: string, surface: TiledSurface, rects: RasterRect[]): void;
+    /** Ends the stroke: `surface` is the new pixels, or `null` when nothing changed / it was cancelled. */
+    commit(session: PaintStrokeSession, surface: TiledSurface | null, cancelled: boolean): void;
+}
+interface StrokeSessionInit {
+    layerId: string;
+    surface: TiledSurface;
+    offset: {
+        x: number;
+        y: number;
+    };
+    lockTransparency: boolean;
+    brush: PaintBrush;
+    /** Paint colour 0..255 RGBA. */
+    color: readonly [number, number, number, number];
+    /** What the eraser paints on a transparency-locked layer (the paper colour). */
+    background: readonly [number, number, number, number];
+    grain: PaperGrain | null;
+    paperDepth: number;
+    seed: number;
+    /** The paint colour as #rrggbb (recorded with the stroke). */
+    colorHex: string;
+    /** The stroke's extra copies as affine maps (recorded with the stroke); `copies` holds all of them as engine copies. */
+    affineCopies: readonly Affine[];
+    copies: readonly StrokeCopy[];
+    /** Applied to each raw sample before it is painted and recorded (perspective snapping). */
+    inputFilter?: (p: PenPoint) => PenPoint;
+    /** Mixer engine: the brush load at the start of the stroke. */
+    mixerLoad: MixerLoad;
+}
+interface PaintStrokeResult {
+    layerId: string;
+    /** Document rectangle the stroke touched, or `null` when no pixel changed. */
+    bounds: RasterRect | null;
+    dabs: number;
+    /** Id of the recorded stroke (see `list_strokes` / `replay_strokes`), or `null` when nothing changed. */
+    strokeId: string | null;
+    /** Mixer engine brushes: what the brush carries after the stroke. */
+    mixerLoad?: MixerLoad;
+}
+declare class PaintStrokeSession {
+    private readonly host;
+    readonly init: StrokeSessionInit;
+    readonly layerId: string;
+    /** The raw input so far (what a replay feeds back in). */
+    readonly points: PenPoint[];
+    private readonly base;
+    private readonly live;
+    private readonly touched;
+    private readonly fresh;
+    private readonly dry;
+    private readonly mixers;
+    private readonly mixerSmoother;
+    private readonly apply;
+    private readonly copies;
+    private bounds;
+    private lastRaw;
+    private closed;
+    result: PaintStrokeResult | null;
+    constructor(host: StrokeSessionHost, init: StrokeSessionInit);
+    private mixerTarget;
+    get open(): boolean;
+    /** Adds raw pen samples (document pixels). */
+    push(points: readonly PenPoint[]): void;
+    private update;
+    /** Ends the stroke (one undo step) and returns what changed. */
+    end(): PaintStrokeResult;
+    /** Abandons the stroke and restores the layer. */
+    cancel(): void;
+}
+/** The Mixer Brush load a stroke starts with. */
+declare function mixerLoadForStroke(brush: PaintBrush, current: MixerLoad, color: readonly [number, number, number]): MixerLoad;
+
+/**
+ * Compositing for the paint editor, on the shared `RasterCompositor`: the paper is a content layer
+ * at the bottom of the stack (its tiles are generated from the paper settings), and view-only
+ * layers (the tracing image) sit between it and the paint. No compositor of our own.
+ */
+
+/** The paper as a layer of the compositor (generated, never stored). */
+interface PaperNode extends CompositorLayer {
+    type: 'paper';
+    id: string;
+    name: string;
+    visible: boolean;
+    opacity: number;
+    blend: 'normal';
+    paper: PaperSettings;
+}
+/** A view-only RGBA image under the paint (the tracing image), drawn at its opacity. */
+interface ImageNode extends CompositorLayer {
+    type: 'image';
+    id: string;
+    name: string;
+    visible: boolean;
+    opacity: number;
+    blend: 'normal';
+    /** Canvas-sized RGBA. */
+    image: {
+        width: number;
+        height: number;
+        data: Uint8ClampedArray;
+    };
+    /** Changes when the pixels change. */
+    version: number;
+}
+type ViewLayer = PaintLayer | PaperNode | ImageNode;
+declare const PAPER_NODE_ID = "__paper";
+declare const TRACING_NODE_ID = "__tracing";
+declare function paperKey(p: PaperSettings): string;
+/** The paper as a compositor layer (one object per paper settings object, so caches hold). */
+declare function paperNode(paper: PaperSettings): PaperNode;
+/** The paper's dry height field, built once per settings. */
+declare function paperGrain(paper: PaperSettings): PaperGrain;
+/** A compositor for paint editor stacks (paper and view-only images included). */
+declare function createPaintCompositor(): RasterCompositor<ViewLayer, RasterSources>;
+/**
+ * Area-averaged downscale of straight-alpha RGBA (colours weighted by alpha). Sizes at or above
+ * the source copy it.
+ */
+declare function downsampleRgba(data: ArrayLike<number>, width: number, height: number, tw: number, th: number): Uint8ClampedArray;
+
+/**
+ * Saved paint documents: JSON plus PNG assets. Layers go through the image editor's layer
+ * serializer (`serializeLayers` / `deserializeLayers`), so pixel layers and groups are stored the
+ * same way in both editors, including external asset stores. The paper is plain settings: it is
+ * regenerated on load, never stored as pixels.
+ *
+ * Forward compatibility: readers keep fields they do not know at the top level (`extensions`) and
+ * write them back, so a later version can add per-layer wet state, height or material channels
+ * as new assets keyed by layer id without breaking older readers (see `PaintDocumentExtensions`).
+ */
+
+declare const PAINT_FORMAT: "pixerate-paint";
+declare const PAINT_SCHEMA_VERSION: 1;
+/** Where a host keeps layer PNGs outside the JSON (the image editor's asset store contract). */
+type PaintAssetStore = ImageEditorAssetStore;
+/**
+ * Fields a later version adds. Phase 1 writes none of them and keeps any it reads. Planned:
+ * `layerChannels: { [layerId]: { height?: asset, material?: asset } }` for impasto and
+ * metallic paint. Wet paint is never saved (saving dries it), so there is no wet field.
+ */
+type PaintDocumentExtensions = Record<string, unknown>;
+interface SerializedPaintDocument {
+    format: typeof PAINT_FORMAT;
+    version: typeof PAINT_SCHEMA_VERSION;
+    width: number;
+    height: number;
+    dpi: number;
+    paper: PaperSettings;
+    /** Bottom to top: pixel layers and groups, as the image editor stores them. */
+    layers: SerializedLayer[];
+    /** Asset id → PNG data URL (or an external reference). */
+    assets: Record<string, string>;
+    activeLayerId: string | null;
+    /** Recorded strokes (strokes are data), oldest first; missing when saved without them. */
+    strokes?: RecordedStroke[];
+    /** Everything else (document-level state of later phases), written back as read. */
+    [extension: string]: unknown;
+}
+/** Fields of a saved document this version does not read, kept for writing back. */
+declare function documentExtensions(raw: Record<string, unknown>): PaintDocumentExtensions;
+interface SerializeOptions {
+    /** Include the recorded strokes (default true). */
+    strokes?: boolean;
+    /** Later-phase fields to write as they were read. */
+    extensions?: PaintDocumentExtensions;
+    /** Painting guides (symmetry, perspective, tracing and reference images as PNG data URLs). */
+    guides?: unknown;
+    swatches?: unknown;
+}
+/** The document as JSON with inline PNG data URLs. */
+declare function serializePaintDocument(state: PaintDocumentState, options?: SerializeOptions): SerializedPaintDocument;
+/** The document as JSON with each PNG uploaded to `store` once (by content). */
+declare function serializePaintDocumentExternal(state: PaintDocumentState, store: PaintAssetStore, options?: SerializeOptions): Promise<SerializedPaintDocument>;
+interface LoadedPaintDocument {
+    state: PaintDocumentState;
+    extensions: PaintDocumentExtensions;
+    /** The saved guides and swatches, as stored (the controller validates them). */
+    guides?: unknown;
+    swatches?: unknown;
+    /** What could not be read (the rest still loads). */
+    problems: string[];
+}
+/** Reads a saved document with inline assets. Throws when it is not a paint document at all. */
+declare function deserializePaintDocument(raw: unknown): LoadedPaintDocument;
+/** Reads a saved document whose assets may be external references in `store`. */
+declare function deserializePaintDocumentAsync(raw: unknown, store?: PaintAssetStore): Promise<LoadedPaintDocument>;
+
+/**
+ * The canvas view: zoom, pan, rotation and mirroring. View state only: the pixels never resample,
+ * the view maps document pixels to the screen and pointer positions back.
+ */
+
+interface PaintView {
+    /** Screen pixels per document pixel (0.02..64, default 1). */
+    zoom: number;
+    /** Offset of the canvas centre from the viewport centre, in screen pixels. */
+    pan: {
+        x: number;
+        y: number;
+    };
+    /** Rotation in degrees clockwise, -180..180 (default 0). */
+    rotation: number;
+    /** Mirror the view left to right (default false). */
+    mirror: boolean;
+}
+declare const MIN_ZOOM = 0.02;
+declare const MAX_ZOOM = 64;
+declare const DEFAULT_VIEW: Readonly<PaintView>;
+/** Degrees into -180..180. */
+declare function normalizeRotation(deg: number): number;
+declare function normalizeView(raw: Partial<PaintView>, base?: PaintView): PaintView;
+/**
+ * Document → screen for a canvas of `canvas` size shown in a viewport of `viewport` size:
+ * the canvas centre goes to the viewport centre plus `pan`, then zoom, rotation and mirroring
+ * apply about it.
+ */
+declare function viewMatrix(view: PaintView, canvas: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}): Affine;
+/** Screen position → document position. */
+declare function screenToDocument(view: PaintView, canvas: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}, x: number, y: number): {
+    x: number;
+    y: number;
+};
+/** Document position → screen position. */
+declare function documentToScreen(view: PaintView, canvas: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}, x: number, y: number): {
+    x: number;
+    y: number;
+};
+/** A CSS `matrix(...)` for an element of the canvas size placed at the viewport's top-left. */
+declare function viewCssTransform(view: PaintView, canvas: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}): string;
+/** The zoom that fits the canvas in the viewport (with `margin` screen pixels around it). */
+declare function fitZoom(canvas: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}, margin?: number): number;
+/**
+ * Pen rotation as the document sees it: a rotated or mirrored view turns the pen's azimuth and
+ * barrel rotation too, so a tilted pencil shades the same way on screen however the canvas is turned.
+ */
+declare function viewPenToDocument<P extends {
+    azimuth?: number;
+    twist?: number;
+}>(view: PaintView, p: P): P;
+
+/**
+ * Pen input helpers for the bindings: Pointer Events (structurally typed, no DOM import) into
+ * `PenPoint`s, palm rejection by hand, and which hand the user draws with. The bindings feed
+ * coalesced events into the stroke and draw predicted ones as a throwaway preview.
+ */
+
+/** The Pointer Event fields the paint editor reads. */
+interface PointerSample {
+    pointerType?: string;
+    pressure?: number;
+    tiltX?: number;
+    tiltY?: number;
+    /** Radians (Pointer Events Level 3). */
+    altitudeAngle?: number;
+    azimuthAngle?: number;
+    /** Degrees 0..359. */
+    twist?: number;
+    timeStamp?: number;
+}
+/** Which hand holds the pen: palm rejection ignores touches on that side of it. */
+type Hand = 'right' | 'left';
+/**
+ * Pressure of a pointer sample: pens report it; mice report 0.5 while pressed and pens 0 on
+ * `pointerup`, both of which mean "use full" (see GOTCHAS).
+ */
+declare function samplePressure(e: PointerSample): number;
+/**
+ * A pointer sample at document position (x, y) as a pen point. Only pens report tilt and twist;
+ * a pen's lean and barrel rotation are turned with the view, so marks look the same on screen
+ * whatever the canvas rotation and mirroring.
+ */
+declare function pointerToPenPoint(e: PointerSample, x: number, y: number, view?: PaintView): PenPoint;
+/**
+ * Palm rejection: whether a touch at `touch` (screen pixels) is probably the drawing hand resting
+ * on the screen while the pen is at `pen`. A right hand rests below and to the right of the pen, a
+ * left hand below and to the left.
+ */
+declare function isPalmTouch(touch: {
+    x: number;
+    y: number;
+}, pen: {
+    x: number;
+    y: number;
+} | null, hand: Hand): boolean;
+
+/**
+ * JPEG and WebP encoding. PNG is encoded in pure TypeScript (`encodePng`); the lossy formats need
+ * the platform's codecs, so they go through an `OffscreenCanvas` (browsers and Workers) or a host
+ * encoder. Nothing is imported: the globals are looked up at call time.
+ */
+type ImageFormat = 'image/png' | 'image/jpeg' | 'image/webp';
+/** Encodes straight-alpha RGBA as `format` at `quality` (0..1). */
+type ImageEncoder = (image: {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+}, format: 'image/jpeg' | 'image/webp', quality: number) => Promise<Uint8Array>;
+/** An encoder through `OffscreenCanvas`, or `null` where there is none (Node, tests). */
+declare function defaultImageEncoder(): ImageEncoder | null;
+/**
+ * Decodes an image file (PNG, JPEG, WebP, … whatever the browser reads) into RGBA pixels through
+ * `createImageBitmap` and an `OffscreenCanvas`. Browser and Worker only.
+ */
+declare function decodeImageBlob(blob: Blob): Promise<{
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+}>;
+/** Saves bytes as a file through a temporary link. Browser only. */
+declare function downloadBytes(bytes: Uint8Array | string, fileName: string, mimeType: string): void;
+
+/**
+ * Brush thumbnails: a test stroke (an S-curve with pressure swelling and fading, at a steady
+ * speed) painted with the brush on the paper. Brushes that only move paint (blender, smudge) are
+ * shown dragged across two bands of colour. Pure TypeScript, so thumbnails render in Node too.
+ */
+
+interface BrushThumbnail {
+    width: number;
+    height: number;
+    /** RGBA, opaque (the paper is under the stroke). */
+    data: Uint8ClampedArray;
+}
+/** The test stroke's samples for a `width × height` thumbnail. */
+declare function thumbnailStroke(width: number, height: number): PenPoint[];
+declare function renderBrushThumbnail(brush: PaintBrush, options: {
+    paper: PaperSettings;
+    width?: number;
+    height?: number;
+    color: string;
+}): BrushThumbnail;
+
+/**
+ * Painting guides: mirror and kaleidoscope symmetry (every stroke paints its reflected or rotated
+ * copies as one stroke), perspective guides with one to three vanishing points that strokes snap
+ * to, a tracing image under the paint (optionally the source of the stroke colour), and floating
+ * reference images to pick colours from. Geometry only: no pixels, no DOM.
+ */
+
+type SymmetryMode = 'off' | 'vertical' | 'horizontal' | 'dual' | 'diagonal' | 'kaleidoscope';
+declare const SYMMETRY_MODES: readonly SymmetryMode[];
+interface SymmetryGuide {
+    mode: SymmetryMode;
+    /** Centre of the axes in document pixels (default the canvas centre). */
+    center: {
+        x: number;
+        y: number;
+    };
+    /** Turns the axes, degrees clockwise (default 0). */
+    rotation: number;
+    /** Kaleidoscope: number of segments, 2..32 (default 6). */
+    segments: number;
+    /** Kaleidoscope: reflect every other segment as well as rotating (default true), like a real kaleidoscope. */
+    mirror: boolean;
+}
+interface Point2 {
+    x: number;
+    y: number;
+}
+interface PerspectiveGuide {
+    enabled: boolean;
+    /** One to three vanishing points in document pixels (they may lie outside the canvas). */
+    points: Point2[];
+    /** Strokes snap to the guide lines (default true when enabled). */
+    snap: boolean;
+}
+/** A view-only image under the paint, placed over the canvas. */
+interface TracingImage {
+    /** PNG or JPEG data URL. */
+    src: string;
+    /** Natural size of the image in pixels. */
+    width: number;
+    height: number;
+    /** Where it is drawn, in document pixels (default: fitted to the canvas). */
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** 0..1 (default 0.35). */
+    opacity: number;
+    visible: boolean;
+    /** Strokes without an explicit colour take the tracing image's colour where they start. */
+    sampleColors: boolean;
+}
+/** A floating image to look at and pick colours from (shown beside the canvas, never painted). */
+interface ReferenceImage {
+    id: string;
+    name: string;
+    src: string;
+    width: number;
+    height: number;
+    /** Where the panel floats over the viewport, in screen pixels, and its displayed width. */
+    x: number;
+    y: number;
+    displayWidth: number;
+    visible: boolean;
+}
+interface PaintGuides {
+    symmetry: SymmetryGuide;
+    perspective: PerspectiveGuide;
+    tracing: TracingImage | null;
+    references: ReferenceImage[];
+}
+declare function defaultGuides(canvas: {
+    width: number;
+    height: number;
+}): PaintGuides;
+declare const MAX_COORDINATE = 1000000;
+declare function normalizeSymmetry(raw: Partial<SymmetryGuide> | Record<string, unknown>, base: SymmetryGuide): SymmetryGuide;
+/** The axis directions of a mirror mode (radians), as photocraft's `directions`. */
+declare function symmetryAxisAngles(g: SymmetryGuide): number[];
+/**
+ * The extra copies a stroke paints under the symmetry guide, as affine maps (the stroke itself is
+ * not included). Vertical, horizontal and diagonal: one reflection. Dual: two reflections and the
+ * point reflection. Kaleidoscope: rotations by 360°/n, and with `mirror` the reflections between them.
+ */
+declare function symmetryCopies(g: SymmetryGuide): Affine[];
+/** The axes clipped to the canvas, for drawing (photocraft's `segments`). */
+declare function symmetryAxisSegments(g: SymmetryGuide, size: {
+    width: number;
+    height: number;
+}): Array<[Point2, Point2]>;
+declare function normalizePerspective(raw: Partial<PerspectiveGuide> | Record<string, unknown>, base: PerspectiveGuide): PerspectiveGuide;
+/** The line families a perspective guide snaps to at `p`: unit directions. */
+declare function perspectiveDirections(g: PerspectiveGuide, p: Point2): Point2[];
+/** How far the pen must move before a stroke chooses its perspective line (document pixels). */
+declare const SNAP_DECIDE_DISTANCE = 6;
+/**
+ * Snaps one stroke to a perspective guide: once the pen has moved `SNAP_DECIDE_DISTANCE` from
+ * where it started, the stroke picks the guide line through its start that best matches its
+ * direction, and every sample after that is projected onto the line.
+ */
+declare class PerspectiveSnapper {
+    private readonly guide;
+    private start;
+    private dir;
+    constructor(guide: PerspectiveGuide);
+    /** The line the stroke follows, once chosen. */
+    get line(): {
+        from: Point2;
+        direction: Point2;
+    } | null;
+    snap<P extends Point2>(p: P): P;
+}
+/** Guide lines to draw for a perspective guide: rays from each vanishing point through the canvas. */
+declare function perspectiveGuideLines(g: PerspectiveGuide, size: {
+    width: number;
+    height: number;
+}, count?: number): Array<[Point2, Point2]>;
+
+/**
+ * Colour for painters: hex / RGB / HSV / HSL conversions, a colour wheel that is either the
+ * painter's red-yellow-blue wheel (where red's complement is green) or the RGB wheel (where it is
+ * cyan), harmonies on it, and swatches.
+ */
+type Rgb255 = [number, number, number];
+declare function parseHexColor(value: unknown, what?: string): Rgb255;
+declare function rgbToHexColor(r: number, g: number, b: number): string;
+/** RGB 0..255 → HSV with h in degrees 0..360, s and v 0..1. */
+declare function rgbToHsv(r: number, g: number, b: number): {
+    h: number;
+    s: number;
+    v: number;
+};
+declare function hsvToRgb(h: number, s: number, v: number): Rgb255;
+/** RGB 0..255 → HSL with h in degrees, s and l 0..1. */
+declare function rgbToHsl(r: number, g: number, b: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+declare function hslToRgb(h: number, s: number, l: number): Rgb255;
+/** Which wheel hues live on: `ryb` (painter's: red ↔ green complements) or `rgb` (red ↔ cyan). */
+type ColorWheel = 'ryb' | 'rgb';
+/** A wheel angle (degrees) → an RGB hue. */
+declare function wheelToHue(angle: number, wheel: ColorWheel): number;
+/** An RGB hue → its wheel angle (degrees). */
+declare function hueToWheel(hue: number, wheel: ColorWheel): number;
+type HarmonyKind = 'complementary' | 'split-complementary' | 'analogous' | 'triadic' | 'tetradic' | 'square' | 'monochromatic';
+declare const HARMONY_KINDS: readonly HarmonyKind[];
+interface HarmonyColor {
+    color: string;
+    /** Position on the wheel, degrees. */
+    angle: number;
+}
+/**
+ * The colours of a harmony around `base`, the base first. Hue-based harmonies keep the base's
+ * saturation and value and turn it around the wheel; `analogous` spreads by `spread` degrees
+ * (default 30); `monochromatic` keeps the hue and steps the lightness.
+ */
+declare function colorHarmony(base: string, kind: HarmonyKind, options?: {
+    wheel?: ColorWheel;
+    spread?: number;
+}): HarmonyColor[];
+interface Swatch {
+    color: string;
+    name?: string;
+}
+/** A starting palette of our own generic paint colours. */
+declare const DEFAULT_SWATCHES: readonly Swatch[];
+
+/**
+ * The mixing pad: a small canvas beside the painting to put paint on, smear it with a palette
+ * knife and pick the mixed colour from. Paint is laid with the Mixer Brush in pigment mode and the
+ * knife is a pigment smudge, so blue and yellow pushed together make green. It is scratch space:
+ * not part of the painting and not in its undo history.
+ */
+
+type MixingPadTool = 'paint' | 'knife';
+declare const MIXING_PAD_WIDTH = 360;
+declare const MIXING_PAD_HEIGHT = 220;
+declare class MixingPad {
+    readonly width = 360;
+    readonly height = 220;
+    private surface;
+    /** Increments on every change (for redrawing). */
+    version: number;
+    /** Paints (`paint`, with `color`) or smears (`knife`) through `points` in pad pixels. */
+    stroke(points: readonly PenPoint[], options: {
+        tool: MixingPadTool;
+        color: string;
+        size?: number;
+    }): {
+        bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | null;
+    };
+    /** The average colour within `radius` pixels of (x, y), or `null` where the pad is bare. */
+    pick(x: number, y: number, radius?: number): string | null;
+    clear(): void;
+    /** The pad over white, `width × height` RGBA. */
+    pixels(): Uint8ClampedArray;
+}
+
+/**
+ * `PaintEditorController`: the natural-media paint editor's state, framework-free.
+ *
+ * - The document (canvas, paper, the shared raster layer stack, recorded strokes) is immutable
+ *   and tiled copy-on-write; each undo step is a reference to a whole document state.
+ * - Strokes: `beginStroke` gives a live session for pointer input (one undo step at `end`);
+ *   `paintStroke` paints a whole stroke from data (agents, tests, replays).
+ * - The brush, colour, Mixer Brush load, view and hand are editor state, not undo steps.
+ * - Rendering goes through the shared compositor with the paper as its bottom layer; exports
+ *   are PNG (pure TypeScript), JPEG / WebP (through a canvas or a host encoder) and PSD (through
+ *   the shared PSD writer, with the paper as a pixel layer).
+ */
+
+/** A refusal with a message that says what is wrong and how to fix it. */
+declare class PaintEditorError extends Error {
+    constructor(message: string);
+}
+interface PaintEditorOptions extends Partial<PaintCanvas> {
+    /** Paper settings, or a library preset id (default cold pressed). */
+    paper?: Partial<PaperSettings> | string;
+    /** Active brush id (default `pencil-6b`). */
+    brushId?: string;
+    /** Saved user brushes to start the library with. */
+    brushes?: readonly PaintBrush[];
+    /** Paint colour #rrggbb (default #1f2937). */
+    color?: string;
+    hand?: Hand;
+    /** Encodes JPEG / WebP (default: a canvas, when there is one). */
+    encodeImage?: ImageEncoder;
+    /** Undo steps kept (default 200). */
+    historyLimit?: number;
+}
+interface PaintEditorState {
+    document: PaintDocumentState;
+    /** The active brush (possibly edited from its preset). */
+    brush: PaintBrush;
+    /** The brush library: built-in presets, then the user's brushes. */
+    brushes: readonly PaintBrush[];
+    /** Paint colour #rrggbb. */
+    color: string;
+    /** The second colour (swap with `swapColors`). */
+    secondaryColor: string;
+    /** What the Mixer Brush carries between strokes. */
+    mixerLoad: MixerLoad;
+    view: PaintView;
+    hand: Hand;
+    canUndo: boolean;
+    canRedo: boolean;
+    undoLabel: string | null;
+    redoLabel: string | null;
+    /** Mirror / kaleidoscope, perspective, tracing image and reference images (saved with the document, not undo steps). */
+    guides: PaintGuides;
+    /** The colour swatches (saved with the document, not undo steps). */
+    swatches: readonly Swatch[];
+    /** Changes whenever the mixing pad does. */
+    mixingPadVersion: number;
+    /** A stroke is in progress. */
+    stroking: boolean;
+    /** Increments on every change. */
+    version: number;
+}
+/** A layer as tools and panels describe it. */
+interface PaintLayerInfo {
+    id: string;
+    name: string;
+    type: 'pixel' | 'group';
+    visible: boolean;
+    opacity: number;
+    blend: string;
+    clipped: boolean;
+    locks: LayerLocks;
+    active: boolean;
+    /** Painted content (document pixels), or `null` when empty. */
+    bounds: RasterRect | null;
+    parentId: string | null;
+    depth: number;
+}
+interface PaintStrokeInit {
+    /** Default the active layer. */
+    layerId?: string;
+    /** Default the editor colour. */
+    color?: string;
+    /** Default the active brush. */
+    brushId?: string;
+    /** Changes to the brush for this stroke only. */
+    brush?: PaintBrushInput;
+    /** Jitter seed (default: a new one per stroke). */
+    seed?: number;
+    /** Extra copies of the stroke as affine maps (default: the symmetry guide's). */
+    copies?: readonly Affine[];
+    /** Snap the samples to the perspective guide (default true for `beginStroke`, false for `paintStroke`). */
+    snapToPerspective?: boolean;
+    /** Where the stroke starts, for taking its colour from the tracing image before the first sample (`beginStroke`). */
+    start?: {
+        x: number;
+        y: number;
+    };
+}
+interface LayerUpdate {
+    name?: string;
+    visible?: boolean;
+    opacity?: number;
+    blend?: BlendMode;
+    clipped?: boolean;
+    locks?: LayerLocks;
+}
+interface FillLayerOptions {
+    layerId?: string;
+    /** Default the editor colour. */
+    color?: string;
+    /** 0..1 (default 1). */
+    opacity?: number;
+    /** Paper grain response 0..1 (default 0: a flat fill); above 0 the fill catches the grain like pastel rubbed across the paper. */
+    grain?: number;
+    /** With grain: pressure 0..1, how far the fill reaches into the valleys (default 0.5). */
+    pressure?: number;
+    blend?: BlendMode;
+}
+interface ReplayOptions extends StrokeVariation {
+    /** Recorded stroke ids (see `getStrokes`). */
+    strokeIds: readonly string[];
+    /** Paint on this layer instead of each stroke's own. */
+    layerId?: string;
+    /** Recolour (default each stroke's colour). */
+    color?: string;
+    /** Replay with this brush instead (default each stroke's brush). */
+    brushId?: string;
+    /** Repeat the variation this many times, each one applied on top of the last (default 1). */
+    repeat?: number;
+}
+interface RenderOptions {
+    /** Include the paper (default true); without it the result is transparent where nothing is painted. */
+    paper?: boolean;
+    /** Only these layers (a group with its children). */
+    layerIds?: readonly string[];
+}
+interface PixelImage {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+}
+declare class PaintEditorController {
+    private doc;
+    private extensions;
+    private undoStack;
+    private redoStack;
+    private readonly historyLimit;
+    private brush;
+    private userBrushes;
+    private color;
+    private secondaryColor;
+    private mixerLoad;
+    private view;
+    private hand;
+    private readonly encodeImage;
+    private listeners;
+    private version;
+    private cached;
+    private session;
+    private live;
+    private liveLayers;
+    private dirty;
+    private seedCounter;
+    private strokeCounter;
+    private guides;
+    private swatches;
+    private readonly pad;
+    private tracingVersion;
+    private tracingCache;
+    private readonly imagePixels;
+    private nextReferenceId;
+    private readonly viewCompositor;
+    private readonly exportCompositor;
+    constructor(options?: PaintEditorOptions);
+    subscribe(listener: () => void): () => void;
+    private emit;
+    /** A snapshot of the editor (the same object until something changes). */
+    getState(): PaintEditorState;
+    get document(): PaintDocumentState;
+    /**
+     * Where the rendered stack changed since the last call: rectangles (a stroke's dabs) or `'all'`.
+     * The viewport passes it to `compositeTiles` as `dirty`.
+     */
+    takeDirty(): RasterRect[] | 'all';
+    private requireIdle;
+    private commit;
+    undo(): string | null;
+    redo(): string | null;
+    /** Labels of the undo steps, oldest first. */
+    historyLabels(): {
+        undo: string[];
+        redo: string[];
+    };
+    private resolvePaper;
+    /** Starts a new canvas: one empty layer over the paper (one undo step; undo brings the old one back). */
+    newCanvas(options?: Partial<PaintCanvas> & {
+        paper?: Partial<PaperSettings> | string;
+    }): PaintDocumentState;
+    /** Changes the canvas size (keeping the pixels where they are, anchored top-left) or resolution. */
+    setCanvas(update: Partial<PaintCanvas>): PaintCanvas;
+    /** Changes the paper: a library preset (`preset`), and / or any of its settings (one undo step). */
+    setPaper(update: Partial<PaperSettings> & {
+        preset?: string;
+    }): PaperSettings;
+    getLayer(id: string): PaintLayer | undefined;
+    /** The active pixel layer (or `undefined`). */
+    getActiveLayer(): PaintLayer | undefined;
+    /** Every layer, top first, as panels and tools describe them. */
+    listLayers(): PaintLayerInfo[];
+    describeLayer(l: PaintLayer, parentId?: string | null, depth?: number): PaintLayerInfo;
+    private requireLayer;
+    /** The pixel layer a paint operation targets, checked for locks and visibility. */
+    private paintTarget;
+    setActiveLayer(id: string): void;
+    /** Adds an empty pixel layer or group above `aboveId` (default: the active layer) and makes it active. */
+    addLayer(options?: {
+        name?: string;
+        type?: 'pixel' | 'group';
+        aboveId?: string;
+        parentId?: string | null;
+    }): PaintLayerInfo;
+    updateLayer(id: string, update: LayerUpdate): PaintLayerInfo;
+    removeLayer(id: string): {
+        removed: string;
+        activeLayerId: string | null;
+    };
+    duplicateLayer(id: string): PaintLayerInfo;
+    /** Moves a layer to `index` (0 = bottom) within `parentId` (default its own parent; `null` = top level). */
+    moveLayer(id: string, index: number, parentId?: string | null): PaintLayerInfo;
+    /** Merges a pixel layer into the pixel layer below it (keeping the lower one's settings). */
+    mergeDown(id: string): PaintLayerInfo;
+    /** Removes every pixel of a layer. */
+    clearLayer(layerId?: string): {
+        layerId: string;
+        bounds: RasterRect | null;
+    };
+    /**
+     * Fills a layer across the canvas with a colour. With `grain` above 0 the fill follows the paper
+     * grain (it catches the peaks, as pastel or charcoal rubbed across the sheet).
+     */
+    fillLayer(options?: FillLayerOptions): {
+        layerId: string;
+        bounds: RasterRect;
+    };
+    private applyCoverage;
+    private findBrush;
+    /** A library brush by id (`undefined` when unknown). */
+    getBrush(id: string): PaintBrush | undefined;
+    private requireBrush;
+    /**
+     * Chooses the active brush (`id`: a library brush) and / or changes its settings. Editor state,
+     * not an undo step. Returns the active brush.
+     */
+    setBrush(update?: {
+        id?: string;
+    } & Omit<PaintBrushInput, 'id'>): PaintBrush;
+    /** Saves the active brush (or `brush`) into the user library under `id` / `name`. */
+    saveBrush(options: {
+        id: string;
+        name?: string;
+        brush?: PaintBrushInput;
+    }): PaintBrush;
+    removeBrush(id: string): void;
+    /** The user's saved brushes. */
+    getUserBrushes(): PaintBrush[];
+    /** A brush library file of the given brushes (default: the user's brushes). */
+    exportBrushes(ids?: readonly string[]): BrushLibraryFile;
+    /**
+     * Adds the brushes of a library file to the user library. A brush whose id is taken is skipped
+     * unless `replace` (built-in ids are always skipped). Returns the ids added and the problems.
+     */
+    importBrushes(file: unknown, options?: {
+        replace?: boolean;
+    }): {
+        added: string[];
+        skipped: string[];
+        problems: string[];
+    };
+    /** A thumbnail of a brush: a test stroke on the current paper. */
+    brushThumbnail(id: string, options?: {
+        width?: number;
+        height?: number;
+        color?: string;
+    }): BrushThumbnail;
+    setColor(color: string): string;
+    setSecondaryColor(color: string): string;
+    swapColors(): void;
+    /** The colour at a document pixel: of the composite (paper included) or of one layer. */
+    pickColor(x: number, y: number, options?: {
+        layerId?: string;
+    }): {
+        color: string;
+        alpha: number;
+    };
+    /** Fills the Mixer Brush reservoir with a colour (default the editor colour). */
+    loadMixerBrush(color?: string): MixerLoad;
+    /** Empties the pickup well (and with `emptyReservoir` the loaded paint too). */
+    cleanMixerBrush(emptyReservoir?: boolean): MixerLoad;
+    /** Zoom, pan, rotation and mirroring: view state only, the pixels never resample. */
+    setView(update: Partial<PaintView>): PaintView;
+    resetView(): PaintView;
+    setHand(hand: Hand): Hand;
+    private strokeBrush;
+    /** Extra copies every new stroke paints (the painting guides add mirror and kaleidoscope copies). */
+    protected strokeCopies(): Affine[];
+    private sessionFor;
+    private record;
+    /**
+     * Starts a live stroke for pointer input: `push` raw pen samples (document pixels), then `end()`
+     * (one undo step) or `cancel()`.
+     */
+    beginStroke(init?: PaintStrokeInit): PaintStrokeSession;
+    /** The current live stroke, if any. */
+    get activeStroke(): PaintStrokeSession | null;
+    /** Runs a whole stroke against `doc` without touching the editor; returns the new document. */
+    private runStroke;
+    /** Paints one stroke from data (one undo step). */
+    paintStroke(init: PaintStrokeInit & {
+        points: readonly PenPoint[];
+    }): PaintStrokeResult;
+    private checkPoints;
+    /** Every recorded stroke, oldest first. */
+    getStrokes(): readonly RecordedStroke[];
+    /**
+     * Replays recorded strokes, varied (moved, scaled, rotated, flipped, recoloured, with another
+     * brush or layer), `repeat` times: all of it one undo step. Returns the new strokes.
+     */
+    replayStrokes(options: ReplayOptions): {
+        strokeIds: string[];
+        bounds: RasterRect | null;
+        layerIds: string[];
+    };
+    private sources;
+    /** The layers with the live stroke's surface in place. */
+    private currentLayers;
+    /** View-only layers between the paper and the paint (the painting guides add the tracing image). */
+    protected underlayLayers(): ViewLayer[];
+    /** The tracing image resampled onto the canvas (cached until it or the canvas changes). */
+    private tracingNode;
+    private renderLayers;
+    /**
+     * Composites the viewport stack (paper, view-only underlays, layers with the live stroke) tile by
+     * tile over `rect`, calling `onTile` with each 256 px tile's RGBA (cached: unchanged tiles come back
+     * as the same buffer). Pass `takeDirty()` as `dirty`.
+     */
+    compositeTiles(rect: RasterRect, onTile: (tx: number, ty: number, data: Uint8ClampedArray, changed: boolean) => void, options?: {
+        dirty?: RasterRect[] | 'all';
+    }): void;
+    /** The canvas as canvas-sized RGBA (paper included by default). */
+    compositePixels(options?: RenderOptions): PixelImage;
+    /** The canvas (or some layers), scaled so the longest side is at most `maxSide`. */
+    renderPreview(options?: RenderOptions & {
+        maxSide?: number;
+    }): PixelImage;
+    /** The document as JSON with inline PNG assets. */
+    toJSON(options?: {
+        strokes?: boolean;
+    }): SerializedPaintDocument;
+    /** The document as JSON with each PNG stored in `store`. */
+    toJSONExternal(store: PaintAssetStore, options?: {
+        strokes?: boolean;
+    }): Promise<SerializedPaintDocument>;
+    private adopt;
+    /** Opens a saved document (clears the history). Returns what could not be read. */
+    loadJSON(raw: unknown): string[];
+    /** Opens a saved document whose assets may live in `store`. */
+    loadJSONAsync(raw: unknown, store?: PaintAssetStore): Promise<string[]>;
+    /** The canvas as PNG bytes (paper included by default; `scale` below 1 shrinks it). */
+    exportPng(options?: RenderOptions & {
+        scale?: number;
+    }): Uint8Array;
+    private scaled;
+    /**
+     * The canvas as PNG, JPEG or WebP bytes. JPEG has no alpha, so it always includes the paper.
+     * JPEG and WebP need a canvas (a browser or Worker) or the `encodeImage` option.
+     */
+    exportImage(options?: RenderOptions & {
+        format?: ImageFormat;
+        quality?: number;
+        scale?: number;
+    }): Promise<Uint8Array>;
+    /**
+     * The document as an 8-bit RGB PSD through the shared PSD writer: every layer and group, with
+     * the paper as a locked "Paper" pixel layer at the bottom (it is generated, so PSD gets its
+     * pixels), and the composite as the merged image.
+     */
+    exportPsd(): PsdExportResult;
+    /** `render_preview` as a base64 PNG. */
+    previewPngBase64(options?: RenderOptions & {
+        maxSide?: number;
+    }): {
+        data: string;
+        width: number;
+        height: number;
+    };
+    private setGuides;
+    /** Mirror and kaleidoscope painting: every new stroke paints its copies too (one stroke, one undo step). */
+    setSymmetry(update: Partial<SymmetryGuide>): SymmetryGuide;
+    /** Perspective guides with one to three vanishing points that pointer strokes snap to. */
+    setPerspective(update: Partial<PerspectiveGuide>): PerspectiveGuide;
+    /** An image from a PNG (base64 or data URL) or from RGBA pixels, stored as a PNG data URL. */
+    private importImage;
+    private decodeImage;
+    /**
+     * Puts an image under the paint to trace over: view only, never in exports. Placed to fit the
+     * canvas unless `rect` is given; `sampleColors` makes strokes take their colour from it.
+     */
+    setTracingImage(options: {
+        png?: string;
+        pixels?: PixelImage;
+        rect?: TracingImage['rect'];
+        opacity?: number;
+        sampleColors?: boolean;
+    }): TracingImage;
+    /** Changes the tracing image's opacity, visibility, placement or colour sampling. */
+    updateTracing(update: Partial<Pick<TracingImage, 'opacity' | 'visible' | 'sampleColors' | 'rect'>>, base?: TracingImage | null): TracingImage;
+    clearTracingImage(): void;
+    /** The tracing image's colour at a document pixel, or `null` outside it or where it is clear. */
+    sampleTracingColor(x: number, y: number): string | null;
+    /** Adds a floating reference image to look at and pick colours from. */
+    addReferenceImage(options: {
+        png?: string;
+        pixels?: PixelImage;
+        name?: string;
+        x?: number;
+        y?: number;
+        displayWidth?: number;
+    }): ReferenceImage;
+    private requireReference;
+    /** Moves, resizes, renames, shows or hides a reference image. */
+    updateReferenceImage(id: string, update: Partial<Pick<ReferenceImage, 'name' | 'x' | 'y' | 'displayWidth' | 'visible'>>): ReferenceImage;
+    removeReferenceImage(id: string): void;
+    /** A reference image's pixels (decoded once). */
+    referencePixels(id: string): PixelImage;
+    /** The colour of a reference image at its pixel (x, y). */
+    pickReferenceColor(id: string, x: number, y: number): string;
+    private readGuides;
+    /** Colour harmonies around a colour (default the paint colour) on the painter's RYB wheel or the RGB wheel. */
+    harmony(kind: HarmonyKind, options?: {
+        color?: string;
+        wheel?: ColorWheel;
+        spread?: number;
+    }): HarmonyColor[];
+    addSwatch(color: string, name?: string): Swatch[];
+    removeSwatch(index: number): Swatch[];
+    setSwatches(swatches: readonly Swatch[]): Swatch[];
+    get mixingPad(): MixingPad;
+    /** Paints (`paint`) or smears with the palette knife (`knife`) on the mixing pad, in pad pixels. */
+    mixingPadStroke(points: readonly PenPoint[], options?: {
+        tool?: MixingPadTool;
+        color?: string;
+        size?: number;
+    }): {
+        bounds: RasterRect | null;
+    };
+    /** Picks the mixed colour on the pad (averaged over `radius` px); with `setColor` it becomes the paint colour. */
+    mixingPadPick(x: number, y: number, options?: {
+        radius?: number;
+        setColor?: boolean;
+    }): string | null;
+    clearMixingPad(): void;
+    /** A layer's tile surface (live while stroking), for thumbnails. */
+    layerSurface(id: string): TiledSurface | null;
+}
+
+/** Largest tracing or reference image side, in pixels. */
+declare const MAX_IMAGE_SIDE = 8192;
+
+/**
+ * Agent tools for the paint editor (`createPaintEditorToolProvider`). Strict schemas, every
+ * argument described, all four annotations. Each write is one undo step (or editor state, said so)
+ * and returns what it changed; ids come from the read tools (`list_layers`, `list_brushes`,
+ * `list_papers`, `list_strokes`).
+ */
+
+interface PaintEditorToolProviderOptions {
+    /** Provider id (unique per registry). Default `paint-editor`. */
+    id?: string;
+    /** Always prefix tool names with `<namespace>__`. */
+    namespace?: string;
+}
+/** Agent tools for one paint editor. */
+declare function createPaintEditorToolProvider(controller: PaintEditorController, options?: PaintEditorToolProviderOptions): AgentToolProvider;
+
+/**
+ * Framework-free UI logic shared by the React and Svelte paint editors, so both behave the same:
+ *
+ * - `PaintGesture` turns pointer events (structurally typed, no DOM import) into strokes (with
+ *   coalesced samples and a predicted tail), colour picks, pans, view rotation and zoom, with palm
+ *   rejection while a pen is down.
+ * - `PaintCanvasPresenter` keeps a document-sized 2D canvas up to date from the compositor,
+ *   uploading only the tiles that changed.
+ * - Guide overlays as line segments, and the slider tables of the brush and paper panels.
+ */
+
+/** The Pointer Event fields the gesture reads. */
+interface PaintPointerEvent extends PointerSample {
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    button?: number;
+    buttons?: number;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    getCoalescedEvents?(): PaintPointerEvent[];
+    getPredictedEvents?(): PaintPointerEvent[];
+}
+type PaintTool = 'brush' | 'eyedropper' | 'pan' | 'rotate';
+declare const PAINT_TOOLS: ReadonlyArray<{
+    id: PaintTool;
+    label: string;
+    key: string;
+}>;
+/** Where the viewport element is on screen and how big it is (CSS pixels). */
+interface ViewportBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+declare class PaintGesture {
+    private readonly controller;
+    private readonly box;
+    tool: PaintTool;
+    /** The last refusal (a hidden or locked layer), for the editor to show. */
+    error: string | null;
+    /** The predicted tail of the current stroke in document pixels (draw it as a thin preview). */
+    predicted: PenPoint[];
+    private mode;
+    private penAt;
+    private penDown;
+    constructor(controller: PaintEditorController, box: () => ViewportBox);
+    private doc;
+    private pen;
+    /** Pointer down; returns true when the gesture took the pointer (capture it). */
+    down(e: PaintPointerEvent): boolean;
+    private pick;
+    move(e: PaintPointerEvent): void;
+    up(e: PaintPointerEvent): void;
+    cancel(): void;
+    get active(): boolean;
+    /** Wheel: zoom about the pointer (Ctrl / pinch or plain wheel), Shift+wheel rotates the view. */
+    wheel(e: {
+        clientX: number;
+        clientY: number;
+        deltaY: number;
+        shiftKey?: boolean;
+    }): void;
+}
+/** Keyboard shortcuts shared by both editors; returns true when it handled the key. */
+declare function handlePaintShortcut(controller: PaintEditorController, gesture: PaintGesture, e: {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    target?: unknown;
+}): boolean;
+/** The 2D context methods the presenter uses (a `CanvasRenderingContext2D`). */
+interface Paint2DContext {
+    createImageData(width: number, height: number): {
+        data: Uint8ClampedArray;
+    };
+    putImageData(image: never, dx: number, dy: number, sx?: number, sy?: number, sw?: number, sh?: number): void;
+}
+/** Keeps a document-sized canvas in step with the controller, tile by tile. */
+declare class PaintCanvasPresenter {
+    private readonly controller;
+    private readonly uploaded;
+    private scratch;
+    private size;
+    constructor(controller: PaintEditorController);
+    /** Draws what changed into `ctx` (a canvas the size of the document); returns the tiles drawn. */
+    render(ctx: Paint2DContext): number;
+}
+/** Lines to draw over the canvas for the guides, in document pixels, with a style key. */
+declare function guideOverlay(controller: PaintEditorController): Array<{
+    from: Point2;
+    to: Point2;
+    kind: 'symmetry' | 'perspective' | 'snap';
+}>;
+/** One slider of a panel: a path into the brush (or paper) settings. */
+interface SliderControl {
+    path: string;
+    label: string;
+    min: number;
+    max: number;
+    step: number;
+}
+declare const BRUSH_SLIDERS: readonly SliderControl[];
+declare const PAPER_SLIDERS: readonly SliderControl[];
+/** Reads `a.b` from an object. */
+declare function readPath(obj: unknown, path: string): number;
+/** `{a: {b: value}}` for `a.b`, keeping the rest of `obj`'s `a`. */
+declare function patchPath(obj: Record<string, unknown>, path: string, value: number): Record<string, unknown>;
+/** The point on a colour wheel of `radius` (centre 0, 0) for a wheel angle in degrees, red at the top. */
+declare function wheelPoint(angle: number, radius: number): Point2;
+/** The wheel angle (degrees, red at the top, clockwise) of a point relative to the wheel centre. */
+declare function wheelAngle(x: number, y: number): number;
+/**
+ * A hue ring for a colour wheel, `size × size` RGBA: hues at full saturation and value between
+ * `inner` and 1 of the radius, red at the top, laid out on the RYB or RGB wheel.
+ */
+declare function renderColorWheel(size: number, wheel: ColorWheel, inner?: number): {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+};
+/** The colour for a click on the wheel ring at (dx, dy) from its centre, keeping `color`'s saturation and value. */
+declare function wheelPick(dx: number, dy: number, wheel: ColorWheel, color: string): string;
+
+export { type Affine, BRUSH_ID, BRUSH_ROTATIONS, BRUSH_SLIDERS, BUILTIN_BRUSHES, BlendMode, type BrushDynamics, type BrushLibraryFile, type BrushRotation, type BrushThumbnail, type ColorWheel, DEFAULT_BRUSH_ID, DEFAULT_DPI, DEFAULT_DYNAMICS, DEFAULT_PAPER, DEFAULT_SWATCHES, DEFAULT_VIEW, DryStroke, type DryStrokeOptions, type FillLayerOptions, GRAIN_PATTERNS, GRAIN_TILE, type GrainPattern, type GrainTuning, HARMONY_KINDS, type Hand, type HarmonyColor, type HarmonyKind, IDENTITY_AFFINE, IDENTITY_COPY, type ImageEncoder, type ImageFormat, type ImageNode, type LayerUpdate, type Linear2, type LoadedPaintDocument, MAX_CANVAS_SIDE, MAX_COORDINATE, MAX_IMAGE_SIDE, MAX_ZOOM, MIN_CANVAS_SIDE, MIN_ZOOM, MIXING_PAD_HEIGHT, MIXING_PAD_WIDTH, MixingPad, type MixingPadTool, PAINT_BRUSH_CATEGORIES, PAINT_BRUSH_ENGINES, PAINT_FORMAT, PAINT_SCHEMA_VERSION, PAINT_TOOLS, PAPER_FAMILIES, PAPER_LIBRARY, PAPER_NODE_ID, PAPER_SLIDERS, type Paint2DContext, type PaintAssetStore, type PaintBrush, type PaintBrushCategory, type PaintBrushEngine, type PaintBrushInput, type PaintCanvas, PaintCanvasPresenter, PaintDocumentError, type PaintDocumentExtensions, type PaintDocumentState, PaintEditorController, PaintEditorError, type PaintEditorOptions, type PaintEditorState, type PaintEditorToolProviderOptions, PaintGesture, type PaintGroupLayer, type PaintGuides, type PaintLayer, type PaintLayerInfo, type PaintPixelLayer, type PaintPointerEvent, type PaintStrokeInit, type PaintStrokeResult, PaintStrokeSession, type PaintTool, type PaintView, type PaperFamily, PaperGrain, type PaperNode, type PaperSettings, type PaperTiling, type PenDab, PenDabWalker, type PenPoint, PenSmoother, type PerspectiveGuide, PerspectiveSnapper, type PixelImage, type Point2, type PointerSample, type RecordedStroke, type ReferenceImage, type RenderOptions, type ReplayOptions, type Rgb255, SNAP_DECIDE_DISTANCE, SYMMETRY_MODES, type SerializeOptions, type SerializedPaintDocument, type SliderControl, type StrokeCopy, type StrokeSessionHost, type StrokeSessionInit, type StrokeVariation, type Swatch, type SymmetryGuide, type SymmetryMode, TRACING_NODE_ID, TileableNoise, type TracingImage, type ViewLayer, type ViewportBox, affineCopy, applyAffine, brushToJSON, clonePaper, colorHarmony, composeAffine, createPaintCompositor, createPaintDocument, createPaintEditorToolProvider, createPaintLayer, decodeImageBlob, defaultGuides, defaultImageEncoder, deserializePaintDocument, deserializePaintDocumentAsync, documentExtensions, documentToScreen, downloadBytes, downsampleRgba, fitZoom, grainCatch, grainHeights, guideOverlay, handlePaintShortcut, hash2, hexToRgb8, hslToRgb, hsvToRgb, hueToWheel, invertAffine, isPalmTouch, mapPenPoint, mix32, mixerLoadForStroke, mixerTip, newPaintLayerId, normalizeBrushStroke, normalizeCanvas, normalizeDynamics, normalizePaintBrush, normalizePaper, normalizePerspective, normalizeRotation, normalizeSymmetry, normalizeView, paperGrain, paperKey, paperNode, paperPreset, parseBrushLibrary, parseHexColor, patchPath, penOrientation, perspectiveDirections, perspectiveGuideLines, pointerToPenPoint, rand01, randSigned, readPath, renderBrushThumbnail, renderColorWheel, renderPaper, rgbToHexColor, rgbToHsl, rgbToHsv, samplePressure, screenToDocument, seedFromString, serializePaintDocument, serializePaintDocumentExternal, strokeBounds, symmetryAxisAngles, symmetryAxisSegments, symmetryCopies, thumbnailStroke, tiltToOrientation, toStrokePoint, variationAffine, varyStroke, viewCssTransform, viewMatrix, viewPenToDocument, wheelAngle, wheelPick, wheelPoint, wheelToHue };