@pixerate/editor 0.102.0 → 0.103.0

package/dist/mixer-DG_9Yu2W.d.ts

@@ -0,0 +1,282 @@
+import { B as BlendMode, R as RasterRect, T as TileKey } from './surface-AfHCH7BR.js';
+
+/**
+ * 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;
+}
+/** 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;
+    constructor(brush: BrushSettings);
+    private diameter;
+    private stepLen;
+    private dab;
+    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>>;
+    bounds: RasterRect | null;
+    private dirty;
+    get(x: number, y: number): number;
+    /** Builds up `vals` (over `rect`) with flow towards `ceil`: `c ← c + v·(ceil − c)`. */
+    accumulate(rect: RasterRect, vals: Float32Array, ceil: number): 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;
+    dabCount: number;
+    constructor(brush: BrushSettings);
+    /** 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;
+}
+/** 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;
+/** Tile coordinates of coverage tile keys (for callers that track dirty tiles). */
+declare function coverageTileCoord(key: TileKey): {
+    tx: number;
+    ty: number;
+};
+
+/**
+ * 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.
+ */
+
+/** How the Mixer Brush mixes colours: straight sRGB averages, or like paint (Kubelka-Munk). */
+type MixingModel = 'rgb' | 'pigment';
+declare const MIXING_MODELS: readonly MixingModel[];
+/** Mixer Brush options. */
+interface MixerSettings {
+    /** How much colour the brush picks up from the canvas, 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, 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>;
+/** Fraction of the way the pickup colour moves towards the canvas per dab at 100 % wet. */
+declare const MIXER_PICKUP_RATE = 0.25;
+/** Fraction of the reservoir that drains per dab at 0 % load. */
+declare const MIXER_DRAIN = 0.08;
+/** Mixer settings with every field in range (missing fields from `DEFAULT_MIXER`). */
+declare function normalizeMixer(raw?: Partial<MixerSettings>): MixerSettings;
+/** What the brush carries between 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, or `null` when the brush is clean. */
+    readonly pickup: readonly [number, number, number] | null;
+}
+declare const EMPTY_MIXER_LOAD: MixerLoad;
+/** 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). */
+interface MixerTarget {
+    /** The tile (TILE × TILE × 4) at (tx, ty) as it is now, or `null` when it is fully transparent. */
+    readTile(tx: number, ty: number): Uint8ClampedArray | null;
+    /** A writable tile at (tx, ty), returned by `readTile` from then on. */
+    writeTile(tx: number, ty: number): Uint8ClampedArray;
+    /** 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;
+}
+/**
+ * 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.
+ */
+declare class MixerStroke {
+    readonly brush: BrushSettings;
+    private readonly target;
+    dabCount: number;
+    bounds: RasterRect | null;
+    private walker;
+    private smoothPos;
+    private buf;
+    private readonly settings;
+    private readonly reservoir;
+    private amount;
+    private pickup;
+    private readonly pig;
+    private readonly out;
+    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;
+    /** `a` mixed `t` of the way to `b` into `this.out`, by the mixing model. */
+    private mix;
+    private paint;
+    private tx;
+    private ty;
+    private tile;
+    private writable;
+    /** Index of document pixel (dx, dy) in `this.tile`, or -1 when reading an empty tile. */
+    private locate;
+    private dab;
+    /** Lays `paint` over the pixels under the dab at `dep` × coverage (× selection). */
+    private deposit;
+}
+
+export { walkDabs as A, type BrushSettings as B, CoverageMap as C, type Dab as D, EMPTY_MIXER_LOAD as E, type MixerSettings as M, type StrokePoint as S, type MixerLoad as a, MAX_BRUSH_SIZE as b, StrokeCoverage as c, type MixerTarget as d, MixerStroke as e, type StrokeApply as f, DEFAULT_BRUSH as g, DEFAULT_MIXER as h, DabWalker as i, MIXER_DRAIN as j, MIXER_PICKUP_RATE as k, MIXING_MODELS as l, type MixingModel as m, applyStrokeToTile as n, cleanMixer as o, coverageTileCoord as p, dabCoverage as q, dabRect as r, loadMixer as s, normalizeBrush as t, normalizeMixer as u, rasterizeDab as v, smoothPoints as w, tipFalloff as x, tipReach as y, tipShape as z };

package/dist/mixer-DGcH6HLu.d.cts

@@ -0,0 +1,282 @@
+import { B as BlendMode, R as RasterRect, T as TileKey } from './surface-AfHCH7BR.cjs';
+
+/**
+ * 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;
+}
+/** 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;
+    constructor(brush: BrushSettings);
+    private diameter;
+    private stepLen;
+    private dab;
+    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>>;
+    bounds: RasterRect | null;
+    private dirty;
+    get(x: number, y: number): number;
+    /** Builds up `vals` (over `rect`) with flow towards `ceil`: `c ← c + v·(ceil − c)`. */
+    accumulate(rect: RasterRect, vals: Float32Array, ceil: number): 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;
+    dabCount: number;
+    constructor(brush: BrushSettings);
+    /** 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;
+}
+/** 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;
+/** Tile coordinates of coverage tile keys (for callers that track dirty tiles). */
+declare function coverageTileCoord(key: TileKey): {
+    tx: number;
+    ty: number;
+};
+
+/**
+ * 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.
+ */
+
+/** How the Mixer Brush mixes colours: straight sRGB averages, or like paint (Kubelka-Munk). */
+type MixingModel = 'rgb' | 'pigment';
+declare const MIXING_MODELS: readonly MixingModel[];
+/** Mixer Brush options. */
+interface MixerSettings {
+    /** How much colour the brush picks up from the canvas, 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, 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>;
+/** Fraction of the way the pickup colour moves towards the canvas per dab at 100 % wet. */
+declare const MIXER_PICKUP_RATE = 0.25;
+/** Fraction of the reservoir that drains per dab at 0 % load. */
+declare const MIXER_DRAIN = 0.08;
+/** Mixer settings with every field in range (missing fields from `DEFAULT_MIXER`). */
+declare function normalizeMixer(raw?: Partial<MixerSettings>): MixerSettings;
+/** What the brush carries between 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, or `null` when the brush is clean. */
+    readonly pickup: readonly [number, number, number] | null;
+}
+declare const EMPTY_MIXER_LOAD: MixerLoad;
+/** 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). */
+interface MixerTarget {
+    /** The tile (TILE × TILE × 4) at (tx, ty) as it is now, or `null` when it is fully transparent. */
+    readTile(tx: number, ty: number): Uint8ClampedArray | null;
+    /** A writable tile at (tx, ty), returned by `readTile` from then on. */
+    writeTile(tx: number, ty: number): Uint8ClampedArray;
+    /** 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;
+}
+/**
+ * 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.
+ */
+declare class MixerStroke {
+    readonly brush: BrushSettings;
+    private readonly target;
+    dabCount: number;
+    bounds: RasterRect | null;
+    private walker;
+    private smoothPos;
+    private buf;
+    private readonly settings;
+    private readonly reservoir;
+    private amount;
+    private pickup;
+    private readonly pig;
+    private readonly out;
+    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;
+    /** `a` mixed `t` of the way to `b` into `this.out`, by the mixing model. */
+    private mix;
+    private paint;
+    private tx;
+    private ty;
+    private tile;
+    private writable;
+    /** Index of document pixel (dx, dy) in `this.tile`, or -1 when reading an empty tile. */
+    private locate;
+    private dab;
+    /** Lays `paint` over the pixels under the dab at `dep` × coverage (× selection). */
+    private deposit;
+}
+
+export { walkDabs as A, type BrushSettings as B, CoverageMap as C, type Dab as D, EMPTY_MIXER_LOAD as E, type MixerSettings as M, type StrokePoint as S, type MixerLoad as a, MAX_BRUSH_SIZE as b, StrokeCoverage as c, type MixerTarget as d, MixerStroke as e, type StrokeApply as f, DEFAULT_BRUSH as g, DEFAULT_MIXER as h, DabWalker as i, MIXER_DRAIN as j, MIXER_PICKUP_RATE as k, MIXING_MODELS as l, type MixingModel as m, applyStrokeToTile as n, cleanMixer as o, coverageTileCoord as p, dabCoverage as q, dabRect as r, loadMixer as s, normalizeBrush as t, normalizeMixer as u, rasterizeDab as v, smoothPoints as w, tipFalloff as x, tipReach as y, tipShape as z };

package/dist/paint/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../chunk-6BU5WU4R.cjs');
 
 
 
@@ -25,7 +25,8 @@
 
 
 
-var _chunkZZOTHJ4Kcjs = require('../chunk-ZZOTHJ4K.cjs');
+
+var _chunkPV42JITTcjs = require('../chunk-PV42JITT.cjs');
 
 
 
@@ -77,5 +78,5 @@ var _chunkCRMAXIUVcjs = require('../chunk-CRMAXIUV.cjs');
 
 
 
-exports.CoverageMap = _chunkZZOTHJ4Kcjs.CoverageMap; exports.DEFAULT_BRUSH = _chunkZZOTHJ4Kcjs.DEFAULT_BRUSH; exports.DEFAULT_MIXER = _chunkZZOTHJ4Kcjs.DEFAULT_MIXER; exports.DabWalker = _chunkZZOTHJ4Kcjs.DabWalker; exports.EMPTY_MIXER_LOAD = _chunkZZOTHJ4Kcjs.EMPTY_MIXER_LOAD; exports.MAX_BRUSH_SIZE = _chunkZZOTHJ4Kcjs.MAX_BRUSH_SIZE; exports.MIXER_DRAIN = _chunkZZOTHJ4Kcjs.MIXER_DRAIN; exports.MIXER_PICKUP_RATE = _chunkZZOTHJ4Kcjs.MIXER_PICKUP_RATE; exports.MIXING_MODELS = _chunkZZOTHJ4Kcjs.MIXING_MODELS; exports.MixerStroke = _chunkZZOTHJ4Kcjs.MixerStroke; exports.PIGMENT_BANDS = _chunkCRMAXIUVcjs.PIGMENT_BANDS; exports.PIGMENT_LAMBDA_MIN = _chunkCRMAXIUVcjs.PIGMENT_LAMBDA_MIN; exports.PIGMENT_LAMBDA_STEP = _chunkCRMAXIUVcjs.PIGMENT_LAMBDA_STEP; exports.PIGMENT_WAVELENGTHS = _chunkCRMAXIUVcjs.PIGMENT_WAVELENGTHS; exports.StrokeCoverage = _chunkZZOTHJ4Kcjs.StrokeCoverage; exports.applyStrokeToTile = _chunkZZOTHJ4Kcjs.applyStrokeToTile; exports.cleanMixer = _chunkZZOTHJ4Kcjs.cleanMixer; exports.coverageTileCoord = _chunkZZOTHJ4Kcjs.coverageTileCoord; exports.createPigment = _chunkCRMAXIUVcjs.createPigment; exports.createPigmentTools = _chunkZZOTHJ4Kcjs.createPigmentTools; exports.dabCoverage = _chunkZZOTHJ4Kcjs.dabCoverage; exports.dabRect = _chunkZZOTHJ4Kcjs.dabRect; exports.lerpPigment = _chunkCRMAXIUVcjs.lerpPigment; exports.lerpPigmentInto = _chunkCRMAXIUVcjs.lerpPigmentInto; exports.loadMixer = _chunkZZOTHJ4Kcjs.loadMixer; exports.mixPigments = _chunkCRMAXIUVcjs.mixPigments; exports.normalizeBrush = _chunkZZOTHJ4Kcjs.normalizeBrush; exports.normalizeMixer = _chunkZZOTHJ4Kcjs.normalizeMixer; exports.rasterizeDab = _chunkZZOTHJ4Kcjs.rasterizeDab; exports.reflectanceToRgb = _chunkCRMAXIUVcjs.reflectanceToRgb; exports.rgbToReflectance = _chunkCRMAXIUVcjs.rgbToReflectance; exports.setPigmentColor = _chunkCRMAXIUVcjs.setPigmentColor; exports.smoothPoints = _chunkZZOTHJ4Kcjs.smoothPoints; exports.tipFalloff = _chunkZZOTHJ4Kcjs.tipFalloff; exports.tipReach = _chunkZZOTHJ4Kcjs.tipReach; exports.tipShape = _chunkZZOTHJ4Kcjs.tipShape; exports.walkDabs = _chunkZZOTHJ4Kcjs.walkDabs;
+exports.CoverageMap = _chunkPV42JITTcjs.CoverageMap; exports.DEFAULT_BRUSH = _chunkPV42JITTcjs.DEFAULT_BRUSH; exports.DEFAULT_MIXER = _chunkPV42JITTcjs.DEFAULT_MIXER; exports.DabWalker = _chunkPV42JITTcjs.DabWalker; exports.EMPTY_MIXER_LOAD = _chunkPV42JITTcjs.EMPTY_MIXER_LOAD; exports.MAX_BRUSH_SIZE = _chunkPV42JITTcjs.MAX_BRUSH_SIZE; exports.MIXER_DRAIN = _chunkPV42JITTcjs.MIXER_DRAIN; exports.MIXER_PICKUP_RATE = _chunkPV42JITTcjs.MIXER_PICKUP_RATE; exports.MIXING_MODELS = _chunkPV42JITTcjs.MIXING_MODELS; exports.MixerStroke = _chunkPV42JITTcjs.MixerStroke; exports.PIGMENT_BANDS = _chunkCRMAXIUVcjs.PIGMENT_BANDS; exports.PIGMENT_LAMBDA_MIN = _chunkCRMAXIUVcjs.PIGMENT_LAMBDA_MIN; exports.PIGMENT_LAMBDA_STEP = _chunkCRMAXIUVcjs.PIGMENT_LAMBDA_STEP; exports.PIGMENT_WAVELENGTHS = _chunkCRMAXIUVcjs.PIGMENT_WAVELENGTHS; exports.StrokeCoverage = _chunkPV42JITTcjs.StrokeCoverage; exports.applyStrokeToTile = _chunkPV42JITTcjs.applyStrokeToTile; exports.cleanMixer = _chunkPV42JITTcjs.cleanMixer; exports.coverageTileCoord = _chunkPV42JITTcjs.coverageTileCoord; exports.createPigment = _chunkCRMAXIUVcjs.createPigment; exports.createPigmentTools = _chunkPV42JITTcjs.createPigmentTools; exports.dabCoverage = _chunkPV42JITTcjs.dabCoverage; exports.dabRect = _chunkPV42JITTcjs.dabRect; exports.lerpPigment = _chunkCRMAXIUVcjs.lerpPigment; exports.lerpPigmentInto = _chunkCRMAXIUVcjs.lerpPigmentInto; exports.loadMixer = _chunkPV42JITTcjs.loadMixer; exports.mixPigments = _chunkCRMAXIUVcjs.mixPigments; exports.normalizeBrush = _chunkPV42JITTcjs.normalizeBrush; exports.normalizeMixer = _chunkPV42JITTcjs.normalizeMixer; exports.rasterizeDab = _chunkPV42JITTcjs.rasterizeDab; exports.reflectanceToRgb = _chunkCRMAXIUVcjs.reflectanceToRgb; exports.rgbToReflectance = _chunkCRMAXIUVcjs.rgbToReflectance; exports.setPigmentColor = _chunkCRMAXIUVcjs.setPigmentColor; exports.smoothPoints = _chunkPV42JITTcjs.smoothPoints; exports.tipFalloff = _chunkPV42JITTcjs.tipFalloff; exports.tipReach = _chunkPV42JITTcjs.tipReach; exports.tipShape = _chunkPV42JITTcjs.tipShape; exports.walkDabs = _chunkPV42JITTcjs.walkDabs;
 //# sourceMappingURL=index.cjs.map

package/dist/paint/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/paint/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,gkEAAC","file":"/home/runner/work/editor/editor/packages/core/dist/paint/index.cjs"}
+{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/paint/index.cjs"],"names":[],"mappings":"AAAA,0GAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,gkEAAC","file":"/home/runner/work/editor/editor/packages/core/dist/paint/index.cjs"}