@pixerate/editor 0.243.0 → 0.245.0

package/dist/paint/wet/model.d.ts

@@ -22,6 +22,10 @@
  *   `S = Σ cᵢSᵢ`) and transparent washes multiply like glazes. A colour becomes `K` and `S` with the
  *   same two-flux formulas as the shipped pigment model (`K/S = (1 − R)² / 2R`).
  *
+ * - **Light** (light paint, a fifth mass channel) rides with the pigment: suspended and settled,
+ *   advected, bled, settled and lifted exactly as pigment is, so a glowing wash flows, pools at
+ *   its edges, granulates and blooms with its colour.
+ *
  * `stepCellsTs` in `kernel.ts` is the specification of one step, in exact f32 arithmetic. The
  * WebAssembly SIMD kernel (`assembly/wet.ts`) is a lane-for-lane port of it and gives the same bits,
  * so the simulation is deterministic across browsers, kernels and worker counts.
@@ -33,19 +37,25 @@ export declare const SLOT_SIDE = 258;
 /** Floats per plane of a slot. */
 export declare const PLANE: number;
 export declare const PLANE_BYTES: number;
-/** Planes in each ping-ponged set: f0..f8, depth, velocity, paper water, 4 pigment channels, edge. */
-export declare const SET_PLANES = 18;
+/**
+ * Planes in each ping-ponged set: f0..f8, depth, velocity, paper water, 4 pigment channels,
+ * suspended light, edge.
+ */
+export declare const SET_PLANES = 19;
 export declare const P_RHO = 9;
 export declare const P_UX = 10;
 export declare const P_UY = 11;
 /** Water held in the paper. */
 export declare const P_SW = 12;
-/** Suspended pigment: K red, K green, K blue, S. */
+/** Suspended pigment: K red, K green, K blue, S; then suspended light (`P_P0 + 4`). */
 export declare const P_P0 = 13;
+/** Suspended light paint: light carried by the water, moving exactly as pigment mass does. */
+export declare const P_L: number;
 /** Edge: 1 at the wet front, fading over a few cells into the wet area (0 where dry). */
-export declare const P_EDGE = 17;
+export declare const P_EDGE = 18;
 /** Single (not ping-ponged) planes, after the two sets. */
 export declare const P_D0: number;
+export declare const P_DL: number;
 export declare const P_H: number;
 export declare const P_FX: number;
 export declare const P_FY: number;
@@ -53,6 +63,11 @@ export declare const SLOT_PLANES: number;
 export declare const SLOT_BYTES: number;
 /** Pigment channels per cell. */
 export declare const PIGMENT_CHANNELS = 4;
+/**
+ * Mass channels per cell: the 4 pigment channels and light. Light is a property of the paint, so
+ * the step advects, bleeds, settles and lifts it with the same flux and rates as pigment.
+ */
+export declare const MASS_CHANNELS = 5;
 /** D2Q9 lattice velocities: 0 rest, 1–4 axis (E, S, W, N in screen space), 5–8 diagonals. */
 export declare const EX: readonly [0, 1, 0, -1, 0, 1, -1, -1, 1];
 export declare const EY: readonly [0, 0, 1, 0, -1, 1, 1, -1, -1];

package/dist/paint/wet/world.d.cts

@@ -17,6 +17,10 @@
  * - **Display.** Each lane has a `base` surface: the layer's pixels under the wet paint. `display`
  *   gives the base with every live tile shaded (`filmPixel`), as an ordinary RGBA surface for the
  *   compositor. Tiles that dry are baked into the base and their slots freed.
+ * - **Light paint.** Light is a fifth mass channel (suspended and settled), moving exactly as
+ *   pigment does. A lane's `light` surface (one channel, see `paint-editor/light.ts`) is the
+ *   light under the wet paint; `lightDisplay` shades the live light over it and drying bakes it
+ *   in, as the colour is.
  * - **Engine B (WebGPU).** With a GPU engine attached (`attachGpu`) and at least `gpuMinTiles` live
  *   tiles, the GPU keeps a mirror of the slots: each edit uploads the rows it changed, each batch
  *   runs on the GPU too, and `displayGpu` shades every stale tile there at once. In lead mode
@@ -30,8 +34,8 @@ import { type WetWorkerLayout } from './wasm.cjs';
 import type { WetGpuEngine } from './gpu.cjs';
 /** Wet layers a world can hold at once. */
 export declare const MAX_WET_LANES = 8;
-/** Tile slots at most (about 3.8 GB, inside wasm32's 4 GB). Water reaching a tile past this is lost. */
-export declare const MAX_WET_SLOTS = 352;
+/** Tile slots at most (about 3.75 GB, inside wasm32's 4 GB). Water reaching a tile past this is lost. */
+export declare const MAX_WET_SLOTS = 328;
 /** A flow map: a vector per document pixel, in cells per step² at strength 1. */
 export type WetFlowField = (x: number, y: number) => readonly [number, number];
 /** The paper as the simulation reads it. */
@@ -62,6 +66,8 @@ export interface WetLaneOptions {
     flow?: WetFlowField | null;
     /** Flow map strength (default 1 when a flow map is given). */
     flowStrength?: number;
+    /** The layer's light paint under the wet paint (one channel; default none). */
+    light?: TiledSurface | null;
 }
 /** Totals for one wet layer. */
 export interface WetLaneStats {
@@ -87,6 +93,8 @@ export interface WetSnapshot {
         flow: WetFlowField | null;
         flowStrength: number;
         base: TiledSurface;
+        light?: TiledSurface;
+        lit?: boolean;
     }>;
     /** Per active key: the current set and the deposit planes; and its last flags. */
     readonly slots: ReadonlyMap<number, {
@@ -177,6 +185,12 @@ export declare class WetWorld {
     getBase(id: string): TiledSurface;
     /** Replaces the pixels under a layer's wet paint. */
     setBase(id: string, base: TiledSurface): void;
+    /** The light paint under a layer's wet paint (one channel). */
+    getLight(id: string): TiledSurface;
+    /** Whether a layer has light paint, under its wet paint or in it. */
+    isLit(id: string): boolean;
+    /** Replaces the light paint under a layer's wet paint. */
+    setLight(id: string, light: TiledSurface): void;
     private pack;
     private touchAll;
     private laneIndexOf;
@@ -247,10 +261,10 @@ export declare class WetWorld {
     private addWaterAt;
     /**
      * Lays paint: `water` depth and pigment mass `pigment` (K r, g, b, S) per unit of coverage, or
-     * per pixel from `field` (4 values per pixel of `rect`). Pigment without water lands straight in
-     * the paper (settled).
+     * per pixel from `field` (4 values per pixel of `rect`), and `light` (light paint mass) per unit
+     * of coverage. Pigment and light without water land straight in the paper (settled).
      */
-    paint(id: string, rect: RasterRect, cov: ArrayLike<number> | null, water: number, pigment: ArrayLike<number> | null, field?: ArrayLike<number> | null): void;
+    paint(id: string, rect: RasterRect, cov: ArrayLike<number> | null, water: number, pigment: ArrayLike<number> | null, field?: ArrayLike<number> | null, light?: number): void;
     /** Damp paper: fills the paper's water towards its capacity by `amount` (0..1) × coverage, plus a thin film of surface water. */
     wetPaper(id: string, rect: RasterRect, cov: ArrayLike<number> | null, amount: number): void;
     /**
@@ -261,16 +275,17 @@ export declare class WetWorld {
     remove(id: string, rect: RasterRect, cov: ArrayLike<number> | null, water: number, suspended: number, settled: number, paperWater?: number): void;
     /** Pushes the water: adds velocity (`ux`, `uy` cells per step, each at most 0.1) × coverage. */
     push(id: string, rect: RasterRect, cov: ArrayLike<number> | null, ux: number, uy: number): void;
-    /** Blends wet paint: each wet cell's suspended pigment moves `strength` × coverage towards the footprint's mean. */
+    /** Blends wet paint: each wet cell's suspended pigment (and light) moves `strength` × coverage towards the footprint's mean. */
     blend(id: string, rect: RasterRect, cov: ArrayLike<number> | null, strength: number): void;
     /**
      * Drags wet paint by (`dx`, `dy`) cells: each footprint cell takes `strength` × coverage of the
-     * water and suspended pigment of the cell it came from (a smudge through wet paint).
+     * water and suspended pigment (and light) of the cell it came from (a smudge through wet paint).
      */
     drag(id: string, rect: RasterRect, cov: ArrayLike<number> | null, dx: number, dy: number, strength: number): void;
     /**
      * Re-wetting: lifts `amount` × coverage of the dried paint in the layer's pixels (`base`) back into
-     * the paper as settled pigment, so water can move it again. Only where there is surface water.
+     * the paper as settled pigment, so water can move it again, and the same share of its light
+     * paint (`light`) as settled light. Only where there is surface water.
      */
     rewet(id: string, rect: RasterRect, cov: ArrayLike<number> | null, amount: number, paper: readonly [number, number, number]): void;
     /**
@@ -284,6 +299,8 @@ export declare class WetWorld {
      * Returns whether any pixel changed.
      */
     private bakeKey;
+    /** `shadeSlot` for light paint: one channel over a light tile (see `shadeLightTile`); `null` when nothing would change. */
+    private shadeLightSlot;
     /**
      * Shades one slot over a base tile. `display`: the wet look (suspended + settled, wet paper a
      * little darker); `bake`: settled pigment only; `bake-all`: suspended and settled (dry now).
@@ -292,6 +309,8 @@ export declare class WetWorld {
     private shadeSlot;
     /** The layer's pixels with all its wet paint dried where it is (the bake of "dry on save"); changes nothing. */
     bakedSurface(id: string): TiledSurface;
+    /** The layer's light paint with all its wet paint dried where it is (`bakedSurface` for light); changes nothing. */
+    bakedLight(id: string): TiledSurface;
     /**
      * Sums over a footprint of a lane, weighted by coverage: `weight` (coverage), `water` (surface
      * depth), `wet` (coverage of wet cells), `pigment` (suspended, 4 channels), `settled` (4 channels).
@@ -323,6 +342,12 @@ export declare class WetWorld {
         changed: RasterRect[];
         pending: number;
     };
+    /**
+     * The layer's light paint with its live light shaded in (`null` when the layer has none): the
+     * light under the wet paint with each live tile's light over it. Like `display`, every stale
+     * tile is reshaded (light tiles are cheap: one channel, no colour maths).
+     */
+    lightDisplay(id: string): TiledSurface | null;
     /**
      * The water as an overlay tile (RGBA, blue, alpha from surface depth and damp paper) for a
      * document tile, or `null` where nothing is wet.
@@ -388,6 +413,7 @@ export declare class WetWorld {
 /** A layer's base and flow map in a moved snapshot (see `moveWetSnapshot`). */
 export interface WetSnapshotLaneMove {
     base?: TiledSurface;
+    light?: TiledSurface;
     flow?: WetFlowField | null;
 }
 /**

package/dist/paint/wet/world.d.ts

@@ -17,6 +17,10 @@
  * - **Display.** Each lane has a `base` surface: the layer's pixels under the wet paint. `display`
  *   gives the base with every live tile shaded (`filmPixel`), as an ordinary RGBA surface for the
  *   compositor. Tiles that dry are baked into the base and their slots freed.
+ * - **Light paint.** Light is a fifth mass channel (suspended and settled), moving exactly as
+ *   pigment does. A lane's `light` surface (one channel, see `paint-editor/light.ts`) is the
+ *   light under the wet paint; `lightDisplay` shades the live light over it and drying bakes it
+ *   in, as the colour is.
  * - **Engine B (WebGPU).** With a GPU engine attached (`attachGpu`) and at least `gpuMinTiles` live
  *   tiles, the GPU keeps a mirror of the slots: each edit uploads the rows it changed, each batch
  *   runs on the GPU too, and `displayGpu` shades every stale tile there at once. In lead mode
@@ -30,8 +34,8 @@ import { type WetWorkerLayout } from './wasm.js';
 import type { WetGpuEngine } from './gpu.js';
 /** Wet layers a world can hold at once. */
 export declare const MAX_WET_LANES = 8;
-/** Tile slots at most (about 3.8 GB, inside wasm32's 4 GB). Water reaching a tile past this is lost. */
-export declare const MAX_WET_SLOTS = 352;
+/** Tile slots at most (about 3.75 GB, inside wasm32's 4 GB). Water reaching a tile past this is lost. */
+export declare const MAX_WET_SLOTS = 328;
 /** A flow map: a vector per document pixel, in cells per step² at strength 1. */
 export type WetFlowField = (x: number, y: number) => readonly [number, number];
 /** The paper as the simulation reads it. */
@@ -62,6 +66,8 @@ export interface WetLaneOptions {
     flow?: WetFlowField | null;
     /** Flow map strength (default 1 when a flow map is given). */
     flowStrength?: number;
+    /** The layer's light paint under the wet paint (one channel; default none). */
+    light?: TiledSurface | null;
 }
 /** Totals for one wet layer. */
 export interface WetLaneStats {
@@ -87,6 +93,8 @@ export interface WetSnapshot {
         flow: WetFlowField | null;
         flowStrength: number;
         base: TiledSurface;
+        light?: TiledSurface;
+        lit?: boolean;
     }>;
     /** Per active key: the current set and the deposit planes; and its last flags. */
     readonly slots: ReadonlyMap<number, {
@@ -177,6 +185,12 @@ export declare class WetWorld {
     getBase(id: string): TiledSurface;
     /** Replaces the pixels under a layer's wet paint. */
     setBase(id: string, base: TiledSurface): void;
+    /** The light paint under a layer's wet paint (one channel). */
+    getLight(id: string): TiledSurface;
+    /** Whether a layer has light paint, under its wet paint or in it. */
+    isLit(id: string): boolean;
+    /** Replaces the light paint under a layer's wet paint. */
+    setLight(id: string, light: TiledSurface): void;
     private pack;
     private touchAll;
     private laneIndexOf;
@@ -247,10 +261,10 @@ export declare class WetWorld {
     private addWaterAt;
     /**
      * Lays paint: `water` depth and pigment mass `pigment` (K r, g, b, S) per unit of coverage, or
-     * per pixel from `field` (4 values per pixel of `rect`). Pigment without water lands straight in
-     * the paper (settled).
+     * per pixel from `field` (4 values per pixel of `rect`), and `light` (light paint mass) per unit
+     * of coverage. Pigment and light without water land straight in the paper (settled).
      */
-    paint(id: string, rect: RasterRect, cov: ArrayLike<number> | null, water: number, pigment: ArrayLike<number> | null, field?: ArrayLike<number> | null): void;
+    paint(id: string, rect: RasterRect, cov: ArrayLike<number> | null, water: number, pigment: ArrayLike<number> | null, field?: ArrayLike<number> | null, light?: number): void;
     /** Damp paper: fills the paper's water towards its capacity by `amount` (0..1) × coverage, plus a thin film of surface water. */
     wetPaper(id: string, rect: RasterRect, cov: ArrayLike<number> | null, amount: number): void;
     /**
@@ -261,16 +275,17 @@ export declare class WetWorld {
     remove(id: string, rect: RasterRect, cov: ArrayLike<number> | null, water: number, suspended: number, settled: number, paperWater?: number): void;
     /** Pushes the water: adds velocity (`ux`, `uy` cells per step, each at most 0.1) × coverage. */
     push(id: string, rect: RasterRect, cov: ArrayLike<number> | null, ux: number, uy: number): void;
-    /** Blends wet paint: each wet cell's suspended pigment moves `strength` × coverage towards the footprint's mean. */
+    /** Blends wet paint: each wet cell's suspended pigment (and light) moves `strength` × coverage towards the footprint's mean. */
     blend(id: string, rect: RasterRect, cov: ArrayLike<number> | null, strength: number): void;
     /**
      * Drags wet paint by (`dx`, `dy`) cells: each footprint cell takes `strength` × coverage of the
-     * water and suspended pigment of the cell it came from (a smudge through wet paint).
+     * water and suspended pigment (and light) of the cell it came from (a smudge through wet paint).
      */
     drag(id: string, rect: RasterRect, cov: ArrayLike<number> | null, dx: number, dy: number, strength: number): void;
     /**
      * Re-wetting: lifts `amount` × coverage of the dried paint in the layer's pixels (`base`) back into
-     * the paper as settled pigment, so water can move it again. Only where there is surface water.
+     * the paper as settled pigment, so water can move it again, and the same share of its light
+     * paint (`light`) as settled light. Only where there is surface water.
      */
     rewet(id: string, rect: RasterRect, cov: ArrayLike<number> | null, amount: number, paper: readonly [number, number, number]): void;
     /**
@@ -284,6 +299,8 @@ export declare class WetWorld {
      * Returns whether any pixel changed.
      */
     private bakeKey;
+    /** `shadeSlot` for light paint: one channel over a light tile (see `shadeLightTile`); `null` when nothing would change. */
+    private shadeLightSlot;
     /**
      * Shades one slot over a base tile. `display`: the wet look (suspended + settled, wet paper a
      * little darker); `bake`: settled pigment only; `bake-all`: suspended and settled (dry now).
@@ -292,6 +309,8 @@ export declare class WetWorld {
     private shadeSlot;
     /** The layer's pixels with all its wet paint dried where it is (the bake of "dry on save"); changes nothing. */
     bakedSurface(id: string): TiledSurface;
+    /** The layer's light paint with all its wet paint dried where it is (`bakedSurface` for light); changes nothing. */
+    bakedLight(id: string): TiledSurface;
     /**
      * Sums over a footprint of a lane, weighted by coverage: `weight` (coverage), `water` (surface
      * depth), `wet` (coverage of wet cells), `pigment` (suspended, 4 channels), `settled` (4 channels).
@@ -323,6 +342,12 @@ export declare class WetWorld {
         changed: RasterRect[];
         pending: number;
     };
+    /**
+     * The layer's light paint with its live light shaded in (`null` when the layer has none): the
+     * light under the wet paint with each live tile's light over it. Like `display`, every stale
+     * tile is reshaded (light tiles are cheap: one channel, no colour maths).
+     */
+    lightDisplay(id: string): TiledSurface | null;
     /**
      * The water as an overlay tile (RGBA, blue, alpha from surface depth and damp paper) for a
      * document tile, or `null` where nothing is wet.
@@ -388,6 +413,7 @@ export declare class WetWorld {
 /** A layer's base and flow map in a moved snapshot (see `moveWetSnapshot`). */
 export interface WetSnapshotLaneMove {
     base?: TiledSurface;
+    light?: TiledSurface;
     flow?: WetFlowField | null;
 }
 /**

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

@@ -0,0 +1,77 @@
+/**
+ * Backlit paper: the paper as a light source behind the paint (a lightbox, stained glass). The
+ * light that makes it through the paint is drawn as one Linear Dodge (Add) layer, "Backlight", at
+ * the top of the stack (opaque pixels whose colour is the light added, so the sRGB blend adds
+ * exactly that; the linear light value is added as is, an approximation of adding light) (it shines through everything, so nothing composited above it may cover
+ * it), with a soft spill where it comes through paint, so a lit glaze lights its surroundings.
+ *
+ * Per pixel, the light starts as `backlight × backlightColor` (linear), a little stronger in the
+ * paper's valleys (thinner paper, by its grain depth), and passes through each visible pixel layer
+ * from the bottom up:
+ *
+ * - **Paint as a film over the paper.** A layer pixel (colour `c`, alpha `a`) over the paper `p`
+ *   shows `e = a·c + (1 − a)·p`. Its transmission is `T = min(1, e / p)` per channel (linear):
+ *   exact for a transparent glaze, whose film over the paper is `T·p` (the wet bake writes
+ *   watercolour that way). Alpha above the least the colour needs over the paper
+ *   (`aMin`, as `film.ts` computes it) is hiding: `hide = (a − aMin) / (1 − aMin)`, and the light
+ *   through is `(1 − hide)·T`. The wet bake writes gouache and oil with their hiding in alpha, and
+ *   opaque dry paint (alpha 1) hides by this rule too, so glazes glow in their own colour and
+ *   opaque paint blocks the light.
+ * - **Thick paint** blocks the light by its height; impasto clarity (material A) lets some through.
+ * - **Layer opacity** mixes towards no change. Blend modes are not modelled (every layer is read
+ *   as a film); over other layers rather than the paper the film rule is an approximation.
+ *
+ * Exact for watercolour straight over the paper; approximate for stacks of layers and for blend
+ * modes. Changing the backlight never repaints: it is a few numbers on the paper.
+ */
+import { TiledSurface } from '../raster/surface.cjs';
+import { type LightSpill } from './light.cjs';
+import { type PaperGrain, type PaperSettings } from './paper.cjs';
+import type { ThickChannels } from './thick.cjs';
+/** Default backlight colour: warm white, like a lightbox. */
+export declare const DEFAULT_BACKLIGHT_COLOR = "#fff1d6";
+/** Spill of the light that comes through paint (px, strength), at backlight 1. */
+export declare const BACKLIGHT_SPILL: Readonly<LightSpill>;
+/** One visible pixel layer as the backlight reads it, bottom first. */
+export interface BacklitLayer {
+    surface: TiledSurface;
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** Effective opacity (its groups' opacities multiplied in). */
+    opacity: number;
+    thick?: ThickChannels;
+}
+/** The paper's backlight (0 when it has none). */
+export declare function backlightOf(paper: PaperSettings): number;
+/**
+ * Computes and caches the backlight per 256 px document tile: a tile is recomputed only when one of
+ * the layer tiles over it (or the paper, or the layer list) changed.
+ */
+export declare class BacklightCache {
+    private tiles;
+    private key;
+    private spillOf;
+    private out;
+    /**
+     * The backlight layer's pixels for `layers` (bottom first) on `paper` over a `width` × `height`
+     * canvas, or `null` when the paper has no backlight. `spillFrom` is the committed painting (the
+     * spill is drawn from it, so a stroke in progress does not redo the blur every frame).
+     */
+    surface(paper: PaperSettings, grain: PaperGrain, width: number, height: number, layers: readonly BacklitLayer[], spillFrom: BacklightCache | null): {
+        light: TiledSurface;
+        color: TiledSurface;
+        painted: TiledSurface;
+    } | null;
+    /**
+     * The full Backlight layer: the light through the paint (`current`) plus the spill of the light
+     * through the committed paint (`committed`), both Linear Dodge. Cached on their tiles.
+     */
+    layer(current: {
+        light: TiledSurface;
+    }, committed: {
+        color: TiledSurface;
+        painted: TiledSurface;
+    } | null, amount: number): TiledSurface;
+}

package/dist/paint-editor/backlight.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Backlit paper: the paper as a light source behind the paint (a lightbox, stained glass). The
+ * light that makes it through the paint is drawn as one Linear Dodge (Add) layer, "Backlight", at
+ * the top of the stack (opaque pixels whose colour is the light added, so the sRGB blend adds
+ * exactly that; the linear light value is added as is, an approximation of adding light) (it shines through everything, so nothing composited above it may cover
+ * it), with a soft spill where it comes through paint, so a lit glaze lights its surroundings.
+ *
+ * Per pixel, the light starts as `backlight × backlightColor` (linear), a little stronger in the
+ * paper's valleys (thinner paper, by its grain depth), and passes through each visible pixel layer
+ * from the bottom up:
+ *
+ * - **Paint as a film over the paper.** A layer pixel (colour `c`, alpha `a`) over the paper `p`
+ *   shows `e = a·c + (1 − a)·p`. Its transmission is `T = min(1, e / p)` per channel (linear):
+ *   exact for a transparent glaze, whose film over the paper is `T·p` (the wet bake writes
+ *   watercolour that way). Alpha above the least the colour needs over the paper
+ *   (`aMin`, as `film.ts` computes it) is hiding: `hide = (a − aMin) / (1 − aMin)`, and the light
+ *   through is `(1 − hide)·T`. The wet bake writes gouache and oil with their hiding in alpha, and
+ *   opaque dry paint (alpha 1) hides by this rule too, so glazes glow in their own colour and
+ *   opaque paint blocks the light.
+ * - **Thick paint** blocks the light by its height; impasto clarity (material A) lets some through.
+ * - **Layer opacity** mixes towards no change. Blend modes are not modelled (every layer is read
+ *   as a film); over other layers rather than the paper the film rule is an approximation.
+ *
+ * Exact for watercolour straight over the paper; approximate for stacks of layers and for blend
+ * modes. Changing the backlight never repaints: it is a few numbers on the paper.
+ */
+import { TiledSurface } from '../raster/surface.js';
+import { type LightSpill } from './light.js';
+import { type PaperGrain, type PaperSettings } from './paper.js';
+import type { ThickChannels } from './thick.js';
+/** Default backlight colour: warm white, like a lightbox. */
+export declare const DEFAULT_BACKLIGHT_COLOR = "#fff1d6";
+/** Spill of the light that comes through paint (px, strength), at backlight 1. */
+export declare const BACKLIGHT_SPILL: Readonly<LightSpill>;
+/** One visible pixel layer as the backlight reads it, bottom first. */
+export interface BacklitLayer {
+    surface: TiledSurface;
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** Effective opacity (its groups' opacities multiplied in). */
+    opacity: number;
+    thick?: ThickChannels;
+}
+/** The paper's backlight (0 when it has none). */
+export declare function backlightOf(paper: PaperSettings): number;
+/**
+ * Computes and caches the backlight per 256 px document tile: a tile is recomputed only when one of
+ * the layer tiles over it (or the paper, or the layer list) changed.
+ */
+export declare class BacklightCache {
+    private tiles;
+    private key;
+    private spillOf;
+    private out;
+    /**
+     * The backlight layer's pixels for `layers` (bottom first) on `paper` over a `width` × `height`
+     * canvas, or `null` when the paper has no backlight. `spillFrom` is the committed painting (the
+     * spill is drawn from it, so a stroke in progress does not redo the blur every frame).
+     */
+    surface(paper: PaperSettings, grain: PaperGrain, width: number, height: number, layers: readonly BacklitLayer[], spillFrom: BacklightCache | null): {
+        light: TiledSurface;
+        color: TiledSurface;
+        painted: TiledSurface;
+    } | null;
+    /**
+     * The full Backlight layer: the light through the paint (`current`) plus the spill of the light
+     * through the committed paint (`committed`), both Linear Dodge. Cached on their tiles.
+     */
+    layer(current: {
+        light: TiledSurface;
+    }, committed: {
+        color: TiledSurface;
+        painted: TiledSurface;
+    } | null, amount: number): TiledSurface;
+}

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

@@ -318,6 +318,9 @@ export declare class PaintEditorController {
     /** Light paint: each layer's spill settings (saved with the document, not undo steps; missing = the defaults). */
     private lightSpills;
     private readonly lightCaches;
+    /** Backlit paper: the light through the paint as drawn (live strokes too), and as committed (its spill). */
+    private readonly backlightView;
+    private readonly backlightCommitted;
     /** Live effect paint: playing and the frame rate cap (editor state), and the time the view shows. */
     private effectPlaybackState;
     private effectTime;
@@ -917,6 +920,14 @@ export declare class PaintEditorController {
      * progress does not redraw the blur every frame).
      */
     private lightLayers;
+    /** Visible pixel layers bottom first, as the backlight reads them (group opacities multiplied in). */
+    private backlitLayers;
+    /**
+     * Backlit paper: the light that makes it through `base` (the layers as drawn), with the spill of
+     * the light through the committed painting, as a Linear Dodge (Add) layer for the top of the
+     * stack; `null` when the paper has no backlight.
+     */
+    private backlightLayer;
     private renderLayers;
     /**
      * Composites the viewport stack (paper, view-only underlays, layers with the live stroke) tile by

package/dist/paint-editor/controller.d.ts

@@ -318,6 +318,9 @@ export declare class PaintEditorController {
     /** Light paint: each layer's spill settings (saved with the document, not undo steps; missing = the defaults). */
     private lightSpills;
     private readonly lightCaches;
+    /** Backlit paper: the light through the paint as drawn (live strokes too), and as committed (its spill). */
+    private readonly backlightView;
+    private readonly backlightCommitted;
     /** Live effect paint: playing and the frame rate cap (editor state), and the time the view shows. */
     private effectPlaybackState;
     private effectTime;
@@ -917,6 +920,14 @@ export declare class PaintEditorController {
      * progress does not redraw the blur every frame).
      */
     private lightLayers;
+    /** Visible pixel layers bottom first, as the backlight reads them (group opacities multiplied in). */
+    private backlitLayers;
+    /**
+     * Backlit paper: the light that makes it through `base` (the layers as drawn), with the spill of
+     * the light through the committed painting, as a Linear Dodge (Add) layer for the top of the
+     * stack; `null` when the paper has no backlight.
+     */
+    private backlightLayer;
     private renderLayers;
     /**
      * Composites the viewport stack (paper, view-only underlays, layers with the live stroke) tile by