@pixerate/editor 0.115.0 → 0.117.0

package/dist/paint/index.d.cts

@@ -1,5 +1,7 @@
-export { m as BlenderScratch, b as BlenderSettings, B as BrushSettings, C as CoverageMap, n as DEFAULT_BLENDER, o as DEFAULT_BRUSH, p as DEFAULT_MIXER, q as DEFAULT_RETOUCH, r as DEFAULT_SMUDGE, D as Dab, s as DabWalker, E as EMPTY_MIXER_LOAD, t as ExchangeRates, e as MAX_BRUSH_SIZE, u as MIXER_DRAIN, v as MIXER_PICKUP_RATE, w as MIXING_MODELS, d as MixerLoad, M as MixerSettings, i as MixerStroke, h as MixerTarget, a as MixingModel, x as PaintExchange, y as PaintMedium, z as PaintSample, P as PaintTileTarget, A as PixelSource, F as RETOUCH_SAMPLES, G as RegionPixelSource, j as RetouchApply, H as RetouchDabEffect, I as RetouchDabStroke, k as RetouchPaint, J as RetouchSample, f as RetouchSettings, R as RgbTriple, K as SPOT_HEAL_TYPES, L as SmudgeDab, S as SmudgeSettings, N as SmudgeTip, O as SpotHealType, l as StrokeApply, g as StrokeCoverage, c as StrokePoint, T as TONE_RANGES, Q as TileMedium, U as TileMediumOptions, V as TilePixelSource, W as ToneRange, X as applyRetouchToTile, Y as applyStrokeToTile, Z as blendRadius, _ as blenderDab, $ as cleanMixer, a0 as coverageTileCoord, a1 as createBlenderScratch, a2 as dabCoverage, a3 as dabRect, a4 as dodgeBurn, a5 as dodgeBurnCurve, a6 as exchangeRates, a7 as healPixels, a8 as loadMixer, a9 as luma, aa as mixerRates, ab as normalizeBlender, ac as normalizeBrush, ad as normalizeMixer, ae as normalizeRetouch, af as normalizeSmudge, ag as perDabStrength, ah as rasterizeDab, ai as readSourceRegion, aj as rgbaViewOfGrey, ak as saturationOf, al as smoothPoints, am as smudgeEffect, an as sponge, ao as spongeEffect, ap as spotHealPixels, aq as spotHealWindow, ar as tipFalloff, as as tipReach, at as tipShape, au as toneOf, av as walkDabs } from '../retouch-Bxkuc0KH.cjs';
-export { Z as PIGMENT_BANDS, _ as PIGMENT_LAMBDA_MIN, $ as PIGMENT_LAMBDA_STEP, a0 as PIGMENT_WAVELENGTHS, Y as Pigment, a1 as PigmentOptions, a2 as PigmentRgb, a3 as createPigment, a4 as lerpPigment, a5 as lerpPigmentInto, a6 as mixPigments, a7 as reflectanceToRgb, a8 as rgbToReflectance, a9 as setPigmentColor } from '../surface-Cn30xIV6.cjs';
+import { at as PaintMedium, W as WetWorld, au as PaintSample, n as RgbTriple, B as BrushSettings, C as CoverageMap, D as Dab } from '../flow-4-OC-UkQ.cjs';
+export { F as BlenderScratch, i as BlenderSettings, G as DEFAULT_BLENDER, H as DEFAULT_BRUSH, s as DEFAULT_FLOW, I as DEFAULT_MIXER, J as DEFAULT_RETOUCH, K as DEFAULT_SMUDGE, L as DEFAULT_WET_PAPER, t as DEFAULT_WET_PARAMS, N as DRY_EPS, O as DabWalker, Q as EMPTY_MIXER_LOAD, U as EX, V as EY, X as ExchangeRates, Y as FLAG_ALIVE, Z as FLAG_BOTTOM, _ as FLAG_LEFT, $ as FLAG_RIGHT, a0 as FLAG_TOP, a1 as FLAG_WET, a2 as FLAT, a3 as FREE_INTERVAL, a4 as MAX_BATCH, u as MAX_BRUSH_SIZE, a5 as MAX_TILT_ACCEL, a6 as MAX_WET_LANES, a7 as MAX_WET_SLOTS, a8 as MIXER_DRAIN, a9 as MIXER_PICKUP_RATE, aa as MIXING_MODELS, a as MixerLoad, M as MixerSettings, c as MixerStroke, b as MixerTarget, h as MixingModel, ab as OPP, ac as PAPER_CAPACITY, ad as PARAM, ae as PARAM_FLOATS, af as PIGMENT_CHANNELS, ag as PLANE, ah as PLANE_BYTES, ai as P_D0, aj as P_EDGE, ak as P_FX, al as P_FY, am as P_H, an as P_P0, ao as P_RHO, ap as P_SW, aq as P_UX, ar as P_UY, as as PaintExchange, P as PaintTileTarget, av as PixelSource, aw as RETOUCH_SAMPLES, ax as RegionPixelSource, d as RetouchApply, ay as RetouchDabEffect, az as RetouchDabStroke, f as RetouchPaint, aA as RetouchSample, R as RetouchSettings, aB as SET_PLANES, aC as SLOT_BYTES, aD as SLOT_PLANES, aE as SLOT_SIDE, aF as SPOT_HEAL_TYPES, aG as STRIP, aH as SmudgeDab, j as SmudgeSettings, aI as SmudgeTip, aJ as SpotHealType, g as StrokeApply, S as StrokeCoverage, e as StrokePoint, aK as TONE_RANGES, T as TileMedium, aL as TileMediumOptions, aM as TilePixelSource, aN as ToneRange, aO as U_MAX, aP as W9, v as WET_FLOW_KINDS, w as WET_PARAM_KEYS, aQ as WET_TILE, p as WetBackendInfo, aR as WetFlowField, x as WetFlowKind, m as WetFlowSpec, aS as WetKernelKind, aT as WetLaneOptions, aU as WetLaneStats, aV as WetPaper, r as WetPaperInput, l as WetParams, q as WetSnapshot, y as WetSupport, k as WetTilt, aW as WetWorkerLayout, aX as WetWorkerPool, aY as WetWorldError, o as WetWorldOptions, aZ as applyRetouchToTile, a_ as applyStrokeToDeepTile, a$ as applyStrokeToTile, b0 as applyToneToDeepTile, b1 as blendRadius, b2 as blenderDab, b3 as canShareMemory, b4 as cleanMixer, b5 as coverageTileCoord, b6 as createBlenderScratch, b7 as dabCoverage, b8 as dabRect, b9 as dodgeBurn, ba as dodgeBurnCurve, bb as dsincos, bc as edgeBits, bd as exchangeRates, be as flowField, bf as healPixels, bg as latticeViscosity, bh as loadMixer, bi as loadWetKernel, bj as luma, bk as mixerRates, bl as normalizeBlender, bm as normalizeBrush, z as normalizeFlow, bn as normalizeMixer, bo as normalizeRetouch, bp as normalizeSmudge, bq as normalizeTilt, A as normalizeWetParams, br as packWetParams, bs as perDabStrength, bt as rasterizeDab, bu as readSourceRegion, bv as rgbaViewOfGrey, bw as saturationOf, bx as smoothPoints, by as smudgeEffect, bz as sponge, bA as spongeEffect, bB as spotHealPixels, bC as spotHealWindow, bD as tipFalloff, bE as tipReach, bF as tipShape, bG as toneOf, bH as walkDabs, bI as wetSimdSupported, E as wetSupport } from '../flow-4-OC-UkQ.cjs';
+import { R as RasterRect, Y as Pigment, a as BlendMode, j as TiledSurface } from '../surface-Cn30xIV6.cjs';
+export { Z as PIGMENT_BANDS, _ as PIGMENT_LAMBDA_MIN, $ as PIGMENT_LAMBDA_STEP, a0 as PIGMENT_WAVELENGTHS, a1 as PigmentOptions, a2 as PigmentRgb, a3 as createPigment, a4 as lerpPigment, a5 as lerpPigmentInto, a6 as mixPigments, a7 as reflectanceToRgb, a8 as rgbToReflectance, a9 as setPigmentColor } from '../surface-Cn30xIV6.cjs';
 import { A as AgentTool } from '../registry-BqA1AZt0.cjs';
 import '../schema-Di0CS6Pe.cjs';
 
@@ -36,4 +38,224 @@ declare function maskBounds(w: number, h: number, mask: ArrayLike<boolean | numb
  */
 declare function bestOffset(w: number, h: number, ch: number, img: ArrayLike<number>, hole: ArrayLike<boolean | number>, ring: number, maxRadius: number): [number, number] | null;
 
-export { bestOffset, createPigmentTools, dilateMask, maskBounds, membraneFill, seamlessClone, solveMembrane };
+/**
+ * How wet-layer pigment looks, and how it bakes into 8-bit pixels.
+ *
+ * A cell carries pigment as Kubelka-Munk absorption `K` per channel (linear R, G, B) and one
+ * scattering `S`, in mass units where `PIGMENT_UNIT` of a colour's pigment is a full-strength wash.
+ * Over what is below it (`below`, linear), the film reflects
+ *
+ *     film = hide·R∞ + (1 − hide)·T·below,   T = e^(−2K), hide = 1 − e^(−HIDE·S),
+ *     R∞ = 1 + K/S − √((K/S)² + 2·K/S)       (the shipped pigment model's two-flux formula)
+ *
+ * so transparent washes (S ≈ 0) multiply like glazes and opaque paint (gouache, oil) hides.
+ *
+ * The bake is a pure function of the f32 state and the 8-bit pixels, computed with deterministic
+ * maths only (`dexp`, `dlog`, `sqrt`, + − × ÷ in f64; never `Math.exp` / `Math.pow`, whose last
+ * bits differ between JavaScript engines), so "dry on save" gives the same pixels everywhere.
+ * The layer pixel is the film expressed as colour plus alpha over the paper colour (exact over the
+ * paper, a normal-blend approximation over other layers), with alpha never below the pixel's own.
+ */
+/** Pigment mass of a full-strength wash of a colour. */
+declare const PIGMENT_UNIT = 0.25;
+/** Hiding per unit of scattering. */
+declare const HIDE = 1.5;
+/** Scattering of fully opaque paint (`body` 1), per `PIGMENT_UNIT` of mass. */
+declare const BODY_SCATTER = 3;
+/**
+ * e^x with + − × ÷ only: x = k·ln2 + r with |r| ≤ ln2/2, then a degree-11 Taylor polynomial
+ * (error below 1e-15). The same bits in every JavaScript engine.
+ */
+declare function dexp(x: number): number;
+/** ln x for x > 0 with + − × ÷ only: x = m·2^e, ln m by the atanh series. */
+declare function dlog(x: number): number;
+/** x^y for x ≥ 0, deterministically. */
+declare function dpow(x: number, y: number): number;
+/** sRGB byte → linear. */
+declare const SRGB_TO_LINEAR: Float64Array<ArrayBuffer>;
+/** sRGB value 0..255 (not necessarily whole) → linear, interpolating the byte table. */
+declare function srgbByteToLinear(v: number): number;
+/** Linear 0..1 → sRGB byte (16384-step table). */
+declare function linearToSrgb8(v: number): number;
+/**
+ * The pigment (K r, g, b, S per unit of mass) of an sRGB colour (0..1) at `body` 0 (a transparent
+ * watercolour: K = −ln R / 2 so a full wash over white shows the colour) .. 1 (opaque paint:
+ * `K/S = (1 − R)² / 2R` at `BODY_SCATTER`).
+ */
+declare function pigmentOf(rgb: readonly [number, number, number] | readonly number[], body: number, out?: Float64Array | number[]): Float64Array | number[];
+/** e^(−x) for x ≥ 0 (deterministic: a table built with `dexp`, interpolated with + − ×). */
+declare function expNeg(x: number): number;
+/** Linear reflectance of a film of pigment `k` (3) and `s` over `below` (linear) into `out`. */
+declare function filmReflectance(k0: number, k1: number, k2: number, s: number, b0: number, b1: number, b2: number, out: Float64Array | number[]): void;
+/** The sRGB colour (0..1) of pigment `k`, `s` over white: what a brush picking it up sees. */
+declare function pigmentColor(k0: number, k1: number, k2: number, s: number, out?: number[]): number[];
+/**
+ * Bakes one pixel: pigment `k0..k2`, `s` laid over layer pixel `px[i..i+3]` (straight sRGB) on paper
+ * `paper` (sRGB bytes). `wet` (0..1) darkens wet paper slightly (display only; 0 for a bake).
+ * Writes the new layer pixel into `out[o..o+3]`.
+ */
+declare function filmPixel(k0: number, k1: number, k2: number, s: number, px: ArrayLike<number>, i: number, paper: ArrayLike<number>, wet: number, out: Uint8ClampedArray, o: number): void;
+/**
+ * The pigment a layer pixel holds over the paper, as a transparent film (`K = −ln(below/paper)/2`,
+ * `S` 0): what re-wetting lifts back into the water. Writes K r, g, b, S into `out`.
+ */
+declare function pixelPigment(px: ArrayLike<number>, i: number, paper: ArrayLike<number>, out: Float64Array | number[]): void;
+/**
+ * `filmPixel` over a whole tile, specialised for speed (same results, pixel for pixel). Reads the
+ * slot's planes from `f`: settled pigment at `d` (4 planes, `plane` floats apart), suspended pigment
+ * at `p` (or −1 to leave it out), surface and paper water at `rho` / `sw` (or −1: no wet darkening).
+ * Cell (x, y) of the tile is at offset `(y + 1)·side + x + 1` of each plane. `src` is the base tile
+ * (or `null` for transparent); writes `out` (a copy of `src` where nothing changes). Returns
+ * whether any pixel was shaded.
+ */
+declare function shadeTile(f: Float32Array, plane: number, side: number, d: number, p: number, rho: number, sw: number, src: Uint8ClampedArray | null, out: Uint8ClampedArray, w: number, h: number, paper: Uint8Array): boolean;
+
+/**
+ * One wet-media step for the 256 × 256 interior of a tile slot, in plain TypeScript: the
+ * specification of the model. Every intermediate is rounded to f32 (`F`) in the same order as the
+ * WebAssembly SIMD kernel (`assembly/wet.ts`), so the two give identical bits: computing an f32
+ * `+ − × ÷ √` in f64 and rounding once is exactly the f32 operation. Keep the two in step; the
+ * kernel test compares them bit for bit.
+ *
+ * A slot is `SLOT_PLANES` planes of 258 × 258 f32 (the tile plus a one-cell halo, filled from the
+ * neighbouring slots after each step). The step reads set `parity` (and the single planes) and
+ * writes the interior of the other set, the deposit planes in place, and returns the tile's flags.
+ *
+ * Per cell x:
+ *  1. Streaming with partial bounce-back: for each direction i, the source is n = x − eᵢ and the
+ *     blocking is b = max(κ(x), κ(n)), κ = blockScale·h. b = 1 off the canvas (h < 0) and where the
+ *     front is pinned: one side dry and the other shallower than the pin threshold
+ *     (pinT + rough·h)·(1 − paperWater/capacity) of the dry side, so damp paper does not pin.
+ *     Off-canvas cells (h < 0, in the halo or past a canvas edge inside a tile) only bounce back.
+ *     Symmetric in x and n, so water is conserved: fᵢ(x) = (1 − b)·f*ᵢ(n) + b·f*ₒₚₚ₍ᵢ₎(x).
+ *  2. Depth and velocity; tilt plus the flow map shift the velocity (u += τ·g), capped at U_MAX.
+ *  3. Absorption into the paper until it holds its capacity, and evaporation (faster in the edge
+ *     band); the collided populations are scaled by the depth ratio.
+ *  4. BGK collision towards the D2Q9 equilibrium.
+ *  5. Pigment (4 channels): upwind flux through the 4 faces with the previous step's velocities,
+ *     plus bleed (diffusion) between wet cells; never below 0.
+ *  6. Deposition (more in valleys and in the edge band) and pickup (more where water arrives);
+ *     where a cell dries, all its suspended pigment settles.
+ *  7. The edge field: max(dry neighbours / 4, 0.99 × the mean of the 4 neighbours' edge), at most
+ *     1, and 0 where the cell is dry.
+ */
+/**
+ * Steps one slot. `f` views the whole memory; `base` is the slot's first float; `prm` is the
+ * lane's packed parameters (`packWetParams`). Returns the tile's flag bits.
+ */
+declare function stepSlotTs(f: Float32Array, base: number, parity: number, prm: Float32Array): number;
+
+/**
+ * The wet layer as a `PaintMedium`: the canvas side of the shared pick-up / mix exchange
+ * (`PaintExchange`), so wet brushes pick up and mix paint the same way the Mixer Brush and the
+ * phase 2 dab brushes do.
+ *
+ * - `sample` sees only wet paint (pigment still suspended in surface water): what a brush can
+ *   lift. Its colour is the suspended pigment's hue at full strength; contact is how much of the
+ *   footprint is wet with pigment in it.
+ * - `deposit` lays water and pigment: the colour becomes Kubelka-Munk pigment (`pigmentOf` at the
+ *   brush's body), at `mass` per unit of coverage, with `water` depth.
+ */
+
+interface WetMediumOptions {
+    /** Water depth laid per unit of coverage (at deposit weight 1). */
+    water: number;
+    /** Pigment mass laid per unit of coverage (at deposit weight 1). */
+    mass: number;
+    /** 0 transparent watercolour .. 1 opaque gouache. */
+    body: number;
+}
+declare class WetMedium implements PaintMedium {
+    readonly world: WetWorld;
+    readonly laneId: string;
+    options: WetMediumOptions;
+    private readonly pig;
+    constructor(world: WetWorld, laneId: string, options: WetMediumOptions);
+    sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null;
+    deposit(rect: RasterRect, cov: ArrayLike<number>, dep: number, paint: Readonly<RgbTriple>, _pigment: Pigment | null, field?: Float32Array | null): void;
+}
+
+/**
+ * A brush stroke along a path: polyline samples, each with an optional pressure and pen tilt, are
+ * walked at the brush's spacing (pressure and tilt interpolated between samples) into dabs, built
+ * up in a coverage map and composited onto a layer. This is what a vector editor calls to draw a
+ * path with a natural-media brush ("brushstrokes on vector paths"): the path is the data, the
+ * pixels are rendered from it.
+ *
+ * - Pressure scales size and / or opacity as the brush says.
+ * - Tilt (`tiltX` / `tiltY` in degrees, or `altitude` / `azimuth` in radians, as Pointer Events give
+ *   them) widens the tip (`tilt.size`), flattens it along the lean (`tilt.roundness`), and with
+ *   `tilt.followAzimuth` turns the tip to the lean, as a pen laid on its side does.
+ * - With `followPath` the tip turns with the path (a calligraphic nib along a curve).
+ *
+ * Deterministic and DOM-free: the same samples and brush give the same pixels everywhere.
+ */
+
+/** One sample of the path (document pixels). */
+interface PathSample {
+    x: number;
+    y: number;
+    /** 0..1 (default 1). */
+    pressure?: number;
+    /** Pointer Events tilt in degrees (−90..90). */
+    tiltX?: number;
+    tiltY?: number;
+    /** Radians above the surface (π/2 upright); overrides tiltX / tiltY. */
+    altitude?: number;
+    /** Radians clockwise from +x: where the pen leans (with altitude). */
+    azimuth?: number;
+}
+interface PathStrokeOptions {
+    brush: Partial<BrushSettings>;
+    /** How tilt shapes the tip (each 0..1; default none). */
+    tilt?: {
+        size?: number;
+        roundness?: number;
+        followAzimuth?: boolean;
+    };
+    /** Turn the tip with the direction of the path (added to the brush angle). */
+    followPath?: boolean;
+    /** Size at zero pressure as a fraction of the full size, when pressure controls size (default 0). */
+    minSize?: number;
+    /** Join the last sample back to the first. */
+    closed?: boolean;
+}
+/** The dabs of a brush stroke along `samples`, with pressure and tilt interpolated between them. */
+declare function pathStrokeDabs(samples: readonly PathSample[], options: PathStrokeOptions): Dab[];
+/** The coverage of a brush stroke along `samples` (build-up towards each dab's opacity) and its bounds. */
+declare function pathStrokeCoverage(samples: readonly PathSample[], options: PathStrokeOptions): {
+    coverage: CoverageMap;
+    bounds: RasterRect | null;
+    dabs: number;
+};
+interface PaintPathOptions extends PathStrokeOptions {
+    /** RGBA 0..255 of the paint. */
+    color: readonly [number, number, number, number];
+    /** `erase` removes paint instead (default `paint`). */
+    mode?: 'paint' | 'erase';
+    /** Blend mode (default the brush's). */
+    blend?: BlendMode;
+    /** Layer offset: layer pixel = document pixel − offset (default 0, 0). */
+    offset?: {
+        x: number;
+        y: number;
+    };
+    lockTransparency?: boolean;
+    /** Where paint may land (canvas-sized coverage 0..255), or none. */
+    selection?: {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+}
+/**
+ * Paints a brush stroke along `samples` onto an RGBA layer surface and returns the new surface
+ * (the input is not changed; untouched tiles are shared) with the bounds it touched.
+ */
+declare function paintPathStroke(surface: TiledSurface, samples: readonly PathSample[], options: PaintPathOptions): {
+    surface: TiledSurface;
+    bounds: RasterRect | null;
+    dabs: number;
+};
+
+export { BODY_SCATTER, BrushSettings, CoverageMap, Dab, HIDE, PIGMENT_UNIT, PaintMedium, type PaintPathOptions, PaintSample, type PathSample, type PathStrokeOptions, Pigment, RgbTriple, SRGB_TO_LINEAR, WetMedium, type WetMediumOptions, WetWorld, bestOffset, createPigmentTools, dexp, dilateMask, dlog, dpow, expNeg, filmPixel, filmReflectance, linearToSrgb8, maskBounds, membraneFill, paintPathStroke, pathStrokeCoverage, pathStrokeDabs, pigmentColor, pigmentOf, pixelPigment, seamlessClone, shadeTile, solveMembrane, srgbByteToLinear, stepSlotTs };

package/dist/paint/index.d.ts

@@ -1,5 +1,7 @@
-export { m as BlenderScratch, b as BlenderSettings, B as BrushSettings, C as CoverageMap, n as DEFAULT_BLENDER, o as DEFAULT_BRUSH, p as DEFAULT_MIXER, q as DEFAULT_RETOUCH, r as DEFAULT_SMUDGE, D as Dab, s as DabWalker, E as EMPTY_MIXER_LOAD, t as ExchangeRates, e as MAX_BRUSH_SIZE, u as MIXER_DRAIN, v as MIXER_PICKUP_RATE, w as MIXING_MODELS, d as MixerLoad, M as MixerSettings, i as MixerStroke, h as MixerTarget, a as MixingModel, x as PaintExchange, y as PaintMedium, z as PaintSample, P as PaintTileTarget, A as PixelSource, F as RETOUCH_SAMPLES, G as RegionPixelSource, j as RetouchApply, H as RetouchDabEffect, I as RetouchDabStroke, k as RetouchPaint, J as RetouchSample, f as RetouchSettings, R as RgbTriple, K as SPOT_HEAL_TYPES, L as SmudgeDab, S as SmudgeSettings, N as SmudgeTip, O as SpotHealType, l as StrokeApply, g as StrokeCoverage, c as StrokePoint, T as TONE_RANGES, Q as TileMedium, U as TileMediumOptions, V as TilePixelSource, W as ToneRange, X as applyRetouchToTile, Y as applyStrokeToTile, Z as blendRadius, _ as blenderDab, $ as cleanMixer, a0 as coverageTileCoord, a1 as createBlenderScratch, a2 as dabCoverage, a3 as dabRect, a4 as dodgeBurn, a5 as dodgeBurnCurve, a6 as exchangeRates, a7 as healPixels, a8 as loadMixer, a9 as luma, aa as mixerRates, ab as normalizeBlender, ac as normalizeBrush, ad as normalizeMixer, ae as normalizeRetouch, af as normalizeSmudge, ag as perDabStrength, ah as rasterizeDab, ai as readSourceRegion, aj as rgbaViewOfGrey, ak as saturationOf, al as smoothPoints, am as smudgeEffect, an as sponge, ao as spongeEffect, ap as spotHealPixels, aq as spotHealWindow, ar as tipFalloff, as as tipReach, at as tipShape, au as toneOf, av as walkDabs } from '../retouch-Do6tBs2H.js';
-export { Z as PIGMENT_BANDS, _ as PIGMENT_LAMBDA_MIN, $ as PIGMENT_LAMBDA_STEP, a0 as PIGMENT_WAVELENGTHS, Y as Pigment, a1 as PigmentOptions, a2 as PigmentRgb, a3 as createPigment, a4 as lerpPigment, a5 as lerpPigmentInto, a6 as mixPigments, a7 as reflectanceToRgb, a8 as rgbToReflectance, a9 as setPigmentColor } from '../surface-Cn30xIV6.js';
+import { at as PaintMedium, W as WetWorld, au as PaintSample, n as RgbTriple, B as BrushSettings, C as CoverageMap, D as Dab } from '../flow-Cb7lkPm8.js';
+export { F as BlenderScratch, i as BlenderSettings, G as DEFAULT_BLENDER, H as DEFAULT_BRUSH, s as DEFAULT_FLOW, I as DEFAULT_MIXER, J as DEFAULT_RETOUCH, K as DEFAULT_SMUDGE, L as DEFAULT_WET_PAPER, t as DEFAULT_WET_PARAMS, N as DRY_EPS, O as DabWalker, Q as EMPTY_MIXER_LOAD, U as EX, V as EY, X as ExchangeRates, Y as FLAG_ALIVE, Z as FLAG_BOTTOM, _ as FLAG_LEFT, $ as FLAG_RIGHT, a0 as FLAG_TOP, a1 as FLAG_WET, a2 as FLAT, a3 as FREE_INTERVAL, a4 as MAX_BATCH, u as MAX_BRUSH_SIZE, a5 as MAX_TILT_ACCEL, a6 as MAX_WET_LANES, a7 as MAX_WET_SLOTS, a8 as MIXER_DRAIN, a9 as MIXER_PICKUP_RATE, aa as MIXING_MODELS, a as MixerLoad, M as MixerSettings, c as MixerStroke, b as MixerTarget, h as MixingModel, ab as OPP, ac as PAPER_CAPACITY, ad as PARAM, ae as PARAM_FLOATS, af as PIGMENT_CHANNELS, ag as PLANE, ah as PLANE_BYTES, ai as P_D0, aj as P_EDGE, ak as P_FX, al as P_FY, am as P_H, an as P_P0, ao as P_RHO, ap as P_SW, aq as P_UX, ar as P_UY, as as PaintExchange, P as PaintTileTarget, av as PixelSource, aw as RETOUCH_SAMPLES, ax as RegionPixelSource, d as RetouchApply, ay as RetouchDabEffect, az as RetouchDabStroke, f as RetouchPaint, aA as RetouchSample, R as RetouchSettings, aB as SET_PLANES, aC as SLOT_BYTES, aD as SLOT_PLANES, aE as SLOT_SIDE, aF as SPOT_HEAL_TYPES, aG as STRIP, aH as SmudgeDab, j as SmudgeSettings, aI as SmudgeTip, aJ as SpotHealType, g as StrokeApply, S as StrokeCoverage, e as StrokePoint, aK as TONE_RANGES, T as TileMedium, aL as TileMediumOptions, aM as TilePixelSource, aN as ToneRange, aO as U_MAX, aP as W9, v as WET_FLOW_KINDS, w as WET_PARAM_KEYS, aQ as WET_TILE, p as WetBackendInfo, aR as WetFlowField, x as WetFlowKind, m as WetFlowSpec, aS as WetKernelKind, aT as WetLaneOptions, aU as WetLaneStats, aV as WetPaper, r as WetPaperInput, l as WetParams, q as WetSnapshot, y as WetSupport, k as WetTilt, aW as WetWorkerLayout, aX as WetWorkerPool, aY as WetWorldError, o as WetWorldOptions, aZ as applyRetouchToTile, a_ as applyStrokeToDeepTile, a$ as applyStrokeToTile, b0 as applyToneToDeepTile, b1 as blendRadius, b2 as blenderDab, b3 as canShareMemory, b4 as cleanMixer, b5 as coverageTileCoord, b6 as createBlenderScratch, b7 as dabCoverage, b8 as dabRect, b9 as dodgeBurn, ba as dodgeBurnCurve, bb as dsincos, bc as edgeBits, bd as exchangeRates, be as flowField, bf as healPixels, bg as latticeViscosity, bh as loadMixer, bi as loadWetKernel, bj as luma, bk as mixerRates, bl as normalizeBlender, bm as normalizeBrush, z as normalizeFlow, bn as normalizeMixer, bo as normalizeRetouch, bp as normalizeSmudge, bq as normalizeTilt, A as normalizeWetParams, br as packWetParams, bs as perDabStrength, bt as rasterizeDab, bu as readSourceRegion, bv as rgbaViewOfGrey, bw as saturationOf, bx as smoothPoints, by as smudgeEffect, bz as sponge, bA as spongeEffect, bB as spotHealPixels, bC as spotHealWindow, bD as tipFalloff, bE as tipReach, bF as tipShape, bG as toneOf, bH as walkDabs, bI as wetSimdSupported, E as wetSupport } from '../flow-Cb7lkPm8.js';
+import { R as RasterRect, Y as Pigment, a as BlendMode, j as TiledSurface } from '../surface-Cn30xIV6.js';
+export { Z as PIGMENT_BANDS, _ as PIGMENT_LAMBDA_MIN, $ as PIGMENT_LAMBDA_STEP, a0 as PIGMENT_WAVELENGTHS, a1 as PigmentOptions, a2 as PigmentRgb, a3 as createPigment, a4 as lerpPigment, a5 as lerpPigmentInto, a6 as mixPigments, a7 as reflectanceToRgb, a8 as rgbToReflectance, a9 as setPigmentColor } from '../surface-Cn30xIV6.js';
 import { A as AgentTool } from '../registry-D-4fit9C.js';
 import '../schema-Di0CS6Pe.js';
 
@@ -36,4 +38,224 @@ declare function maskBounds(w: number, h: number, mask: ArrayLike<boolean | numb
  */
 declare function bestOffset(w: number, h: number, ch: number, img: ArrayLike<number>, hole: ArrayLike<boolean | number>, ring: number, maxRadius: number): [number, number] | null;
 
-export { bestOffset, createPigmentTools, dilateMask, maskBounds, membraneFill, seamlessClone, solveMembrane };
+/**
+ * How wet-layer pigment looks, and how it bakes into 8-bit pixels.
+ *
+ * A cell carries pigment as Kubelka-Munk absorption `K` per channel (linear R, G, B) and one
+ * scattering `S`, in mass units where `PIGMENT_UNIT` of a colour's pigment is a full-strength wash.
+ * Over what is below it (`below`, linear), the film reflects
+ *
+ *     film = hide·R∞ + (1 − hide)·T·below,   T = e^(−2K), hide = 1 − e^(−HIDE·S),
+ *     R∞ = 1 + K/S − √((K/S)² + 2·K/S)       (the shipped pigment model's two-flux formula)
+ *
+ * so transparent washes (S ≈ 0) multiply like glazes and opaque paint (gouache, oil) hides.
+ *
+ * The bake is a pure function of the f32 state and the 8-bit pixels, computed with deterministic
+ * maths only (`dexp`, `dlog`, `sqrt`, + − × ÷ in f64; never `Math.exp` / `Math.pow`, whose last
+ * bits differ between JavaScript engines), so "dry on save" gives the same pixels everywhere.
+ * The layer pixel is the film expressed as colour plus alpha over the paper colour (exact over the
+ * paper, a normal-blend approximation over other layers), with alpha never below the pixel's own.
+ */
+/** Pigment mass of a full-strength wash of a colour. */
+declare const PIGMENT_UNIT = 0.25;
+/** Hiding per unit of scattering. */
+declare const HIDE = 1.5;
+/** Scattering of fully opaque paint (`body` 1), per `PIGMENT_UNIT` of mass. */
+declare const BODY_SCATTER = 3;
+/**
+ * e^x with + − × ÷ only: x = k·ln2 + r with |r| ≤ ln2/2, then a degree-11 Taylor polynomial
+ * (error below 1e-15). The same bits in every JavaScript engine.
+ */
+declare function dexp(x: number): number;
+/** ln x for x > 0 with + − × ÷ only: x = m·2^e, ln m by the atanh series. */
+declare function dlog(x: number): number;
+/** x^y for x ≥ 0, deterministically. */
+declare function dpow(x: number, y: number): number;
+/** sRGB byte → linear. */
+declare const SRGB_TO_LINEAR: Float64Array<ArrayBuffer>;
+/** sRGB value 0..255 (not necessarily whole) → linear, interpolating the byte table. */
+declare function srgbByteToLinear(v: number): number;
+/** Linear 0..1 → sRGB byte (16384-step table). */
+declare function linearToSrgb8(v: number): number;
+/**
+ * The pigment (K r, g, b, S per unit of mass) of an sRGB colour (0..1) at `body` 0 (a transparent
+ * watercolour: K = −ln R / 2 so a full wash over white shows the colour) .. 1 (opaque paint:
+ * `K/S = (1 − R)² / 2R` at `BODY_SCATTER`).
+ */
+declare function pigmentOf(rgb: readonly [number, number, number] | readonly number[], body: number, out?: Float64Array | number[]): Float64Array | number[];
+/** e^(−x) for x ≥ 0 (deterministic: a table built with `dexp`, interpolated with + − ×). */
+declare function expNeg(x: number): number;
+/** Linear reflectance of a film of pigment `k` (3) and `s` over `below` (linear) into `out`. */
+declare function filmReflectance(k0: number, k1: number, k2: number, s: number, b0: number, b1: number, b2: number, out: Float64Array | number[]): void;
+/** The sRGB colour (0..1) of pigment `k`, `s` over white: what a brush picking it up sees. */
+declare function pigmentColor(k0: number, k1: number, k2: number, s: number, out?: number[]): number[];
+/**
+ * Bakes one pixel: pigment `k0..k2`, `s` laid over layer pixel `px[i..i+3]` (straight sRGB) on paper
+ * `paper` (sRGB bytes). `wet` (0..1) darkens wet paper slightly (display only; 0 for a bake).
+ * Writes the new layer pixel into `out[o..o+3]`.
+ */
+declare function filmPixel(k0: number, k1: number, k2: number, s: number, px: ArrayLike<number>, i: number, paper: ArrayLike<number>, wet: number, out: Uint8ClampedArray, o: number): void;
+/**
+ * The pigment a layer pixel holds over the paper, as a transparent film (`K = −ln(below/paper)/2`,
+ * `S` 0): what re-wetting lifts back into the water. Writes K r, g, b, S into `out`.
+ */
+declare function pixelPigment(px: ArrayLike<number>, i: number, paper: ArrayLike<number>, out: Float64Array | number[]): void;
+/**
+ * `filmPixel` over a whole tile, specialised for speed (same results, pixel for pixel). Reads the
+ * slot's planes from `f`: settled pigment at `d` (4 planes, `plane` floats apart), suspended pigment
+ * at `p` (or −1 to leave it out), surface and paper water at `rho` / `sw` (or −1: no wet darkening).
+ * Cell (x, y) of the tile is at offset `(y + 1)·side + x + 1` of each plane. `src` is the base tile
+ * (or `null` for transparent); writes `out` (a copy of `src` where nothing changes). Returns
+ * whether any pixel was shaded.
+ */
+declare function shadeTile(f: Float32Array, plane: number, side: number, d: number, p: number, rho: number, sw: number, src: Uint8ClampedArray | null, out: Uint8ClampedArray, w: number, h: number, paper: Uint8Array): boolean;
+
+/**
+ * One wet-media step for the 256 × 256 interior of a tile slot, in plain TypeScript: the
+ * specification of the model. Every intermediate is rounded to f32 (`F`) in the same order as the
+ * WebAssembly SIMD kernel (`assembly/wet.ts`), so the two give identical bits: computing an f32
+ * `+ − × ÷ √` in f64 and rounding once is exactly the f32 operation. Keep the two in step; the
+ * kernel test compares them bit for bit.
+ *
+ * A slot is `SLOT_PLANES` planes of 258 × 258 f32 (the tile plus a one-cell halo, filled from the
+ * neighbouring slots after each step). The step reads set `parity` (and the single planes) and
+ * writes the interior of the other set, the deposit planes in place, and returns the tile's flags.
+ *
+ * Per cell x:
+ *  1. Streaming with partial bounce-back: for each direction i, the source is n = x − eᵢ and the
+ *     blocking is b = max(κ(x), κ(n)), κ = blockScale·h. b = 1 off the canvas (h < 0) and where the
+ *     front is pinned: one side dry and the other shallower than the pin threshold
+ *     (pinT + rough·h)·(1 − paperWater/capacity) of the dry side, so damp paper does not pin.
+ *     Off-canvas cells (h < 0, in the halo or past a canvas edge inside a tile) only bounce back.
+ *     Symmetric in x and n, so water is conserved: fᵢ(x) = (1 − b)·f*ᵢ(n) + b·f*ₒₚₚ₍ᵢ₎(x).
+ *  2. Depth and velocity; tilt plus the flow map shift the velocity (u += τ·g), capped at U_MAX.
+ *  3. Absorption into the paper until it holds its capacity, and evaporation (faster in the edge
+ *     band); the collided populations are scaled by the depth ratio.
+ *  4. BGK collision towards the D2Q9 equilibrium.
+ *  5. Pigment (4 channels): upwind flux through the 4 faces with the previous step's velocities,
+ *     plus bleed (diffusion) between wet cells; never below 0.
+ *  6. Deposition (more in valleys and in the edge band) and pickup (more where water arrives);
+ *     where a cell dries, all its suspended pigment settles.
+ *  7. The edge field: max(dry neighbours / 4, 0.99 × the mean of the 4 neighbours' edge), at most
+ *     1, and 0 where the cell is dry.
+ */
+/**
+ * Steps one slot. `f` views the whole memory; `base` is the slot's first float; `prm` is the
+ * lane's packed parameters (`packWetParams`). Returns the tile's flag bits.
+ */
+declare function stepSlotTs(f: Float32Array, base: number, parity: number, prm: Float32Array): number;
+
+/**
+ * The wet layer as a `PaintMedium`: the canvas side of the shared pick-up / mix exchange
+ * (`PaintExchange`), so wet brushes pick up and mix paint the same way the Mixer Brush and the
+ * phase 2 dab brushes do.
+ *
+ * - `sample` sees only wet paint (pigment still suspended in surface water): what a brush can
+ *   lift. Its colour is the suspended pigment's hue at full strength; contact is how much of the
+ *   footprint is wet with pigment in it.
+ * - `deposit` lays water and pigment: the colour becomes Kubelka-Munk pigment (`pigmentOf` at the
+ *   brush's body), at `mass` per unit of coverage, with `water` depth.
+ */
+
+interface WetMediumOptions {
+    /** Water depth laid per unit of coverage (at deposit weight 1). */
+    water: number;
+    /** Pigment mass laid per unit of coverage (at deposit weight 1). */
+    mass: number;
+    /** 0 transparent watercolour .. 1 opaque gouache. */
+    body: number;
+}
+declare class WetMedium implements PaintMedium {
+    readonly world: WetWorld;
+    readonly laneId: string;
+    options: WetMediumOptions;
+    private readonly pig;
+    constructor(world: WetWorld, laneId: string, options: WetMediumOptions);
+    sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null;
+    deposit(rect: RasterRect, cov: ArrayLike<number>, dep: number, paint: Readonly<RgbTriple>, _pigment: Pigment | null, field?: Float32Array | null): void;
+}
+
+/**
+ * A brush stroke along a path: polyline samples, each with an optional pressure and pen tilt, are
+ * walked at the brush's spacing (pressure and tilt interpolated between samples) into dabs, built
+ * up in a coverage map and composited onto a layer. This is what a vector editor calls to draw a
+ * path with a natural-media brush ("brushstrokes on vector paths"): the path is the data, the
+ * pixels are rendered from it.
+ *
+ * - Pressure scales size and / or opacity as the brush says.
+ * - Tilt (`tiltX` / `tiltY` in degrees, or `altitude` / `azimuth` in radians, as Pointer Events give
+ *   them) widens the tip (`tilt.size`), flattens it along the lean (`tilt.roundness`), and with
+ *   `tilt.followAzimuth` turns the tip to the lean, as a pen laid on its side does.
+ * - With `followPath` the tip turns with the path (a calligraphic nib along a curve).
+ *
+ * Deterministic and DOM-free: the same samples and brush give the same pixels everywhere.
+ */
+
+/** One sample of the path (document pixels). */
+interface PathSample {
+    x: number;
+    y: number;
+    /** 0..1 (default 1). */
+    pressure?: number;
+    /** Pointer Events tilt in degrees (−90..90). */
+    tiltX?: number;
+    tiltY?: number;
+    /** Radians above the surface (π/2 upright); overrides tiltX / tiltY. */
+    altitude?: number;
+    /** Radians clockwise from +x: where the pen leans (with altitude). */
+    azimuth?: number;
+}
+interface PathStrokeOptions {
+    brush: Partial<BrushSettings>;
+    /** How tilt shapes the tip (each 0..1; default none). */
+    tilt?: {
+        size?: number;
+        roundness?: number;
+        followAzimuth?: boolean;
+    };
+    /** Turn the tip with the direction of the path (added to the brush angle). */
+    followPath?: boolean;
+    /** Size at zero pressure as a fraction of the full size, when pressure controls size (default 0). */
+    minSize?: number;
+    /** Join the last sample back to the first. */
+    closed?: boolean;
+}
+/** The dabs of a brush stroke along `samples`, with pressure and tilt interpolated between them. */
+declare function pathStrokeDabs(samples: readonly PathSample[], options: PathStrokeOptions): Dab[];
+/** The coverage of a brush stroke along `samples` (build-up towards each dab's opacity) and its bounds. */
+declare function pathStrokeCoverage(samples: readonly PathSample[], options: PathStrokeOptions): {
+    coverage: CoverageMap;
+    bounds: RasterRect | null;
+    dabs: number;
+};
+interface PaintPathOptions extends PathStrokeOptions {
+    /** RGBA 0..255 of the paint. */
+    color: readonly [number, number, number, number];
+    /** `erase` removes paint instead (default `paint`). */
+    mode?: 'paint' | 'erase';
+    /** Blend mode (default the brush's). */
+    blend?: BlendMode;
+    /** Layer offset: layer pixel = document pixel − offset (default 0, 0). */
+    offset?: {
+        x: number;
+        y: number;
+    };
+    lockTransparency?: boolean;
+    /** Where paint may land (canvas-sized coverage 0..255), or none. */
+    selection?: {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+}
+/**
+ * Paints a brush stroke along `samples` onto an RGBA layer surface and returns the new surface
+ * (the input is not changed; untouched tiles are shared) with the bounds it touched.
+ */
+declare function paintPathStroke(surface: TiledSurface, samples: readonly PathSample[], options: PaintPathOptions): {
+    surface: TiledSurface;
+    bounds: RasterRect | null;
+    dabs: number;
+};
+
+export { BODY_SCATTER, BrushSettings, CoverageMap, Dab, HIDE, PIGMENT_UNIT, PaintMedium, type PaintPathOptions, PaintSample, type PathSample, type PathStrokeOptions, Pigment, RgbTriple, SRGB_TO_LINEAR, WetMedium, type WetMediumOptions, WetWorld, bestOffset, createPigmentTools, dexp, dilateMask, dlog, dpow, expNeg, filmPixel, filmReflectance, linearToSrgb8, maskBounds, membraneFill, paintPathStroke, pathStrokeCoverage, pathStrokeDabs, pigmentColor, pigmentOf, pixelPigment, seamlessClone, shadeTile, solveMembrane, srgbByteToLinear, stepSlotTs };