@pixerate/editor 0.112.0 → 0.114.0

package/dist/raster/index.js

@@ -1,7 +1,9 @@
 import {
+  BIT_DEPTHS,
   CURVE_LUT_SIZE,
   DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
+  DeepCompositor,
   INTERPOLATIONS,
   LAYER_EFFECT_KINDS,
   LayerEffectError,
@@ -12,9 +14,7 @@ import {
   RasterCompositor,
   STROKE_CHAMFER_MAX,
   TransformTooLargeError,
-  ZlibError,
   activeEffectItems,
-  adler32,
   base64ToBytes,
   blendTile,
   buildEffectMaps,
@@ -25,12 +25,14 @@ import {
   compositeLayerEffects,
   compositeSurfaceOver,
   contourLut,
+  convertSurfaceDepth,
   curveLut,
   decodePng,
+  deepBytes,
+  deepTile,
   defaultEffectGradient,
   defaultLayerEffect,
-  deflate,
-  deflateRaw,
+  depthOf,
   effectColorHex,
   effectFillColors,
   effectReach,
@@ -45,9 +47,8 @@ import {
   gradientT,
   hasActiveEffects,
   hashNoise,
-  inflate,
-  inflateRaw,
   insertLayer,
+  isBitDepth,
   isInterpolation,
   isLayerEffectKind,
   isLayerLocked,
@@ -63,16 +64,33 @@ import {
   parseEffectColor,
   patchEffectMaps,
   pngDataUrl,
+  proxyOf,
+  readDeepRegion,
   reduceSurface,
   renderLayerEffects,
   scaleLayerEffect,
+  srgbDecode,
+  srgbEncode,
+  surfaceDepth,
+  surfaceFromDeepPixels,
+  tileSamples,
+  tileSamples16,
+  tileSamples32,
+  to16From32,
+  to16From8,
+  to32From16,
+  to32From8,
+  to8From16,
+  to8From32,
   transformSurface,
   transformedBounds,
   validateEffectGradient,
   validateLayerEffect,
   validateLayerEffects,
-  warpSurface
-} from "../chunk-LQEEDHOP.js";
+  warpSurface,
+  workingToSamples,
+  writeDeepRegion
+} from "../chunk-C6C5PDKU.js";
 import "../chunk-GX332W2C.js";
 import {
   BLEND_MODES,
@@ -116,12 +134,22 @@ import {
   translateSurface,
   uniformTile,
   writeRegion
-} from "../chunk-HNS7UHCM.js";
+} from "../chunk-XK5LZKBD.js";
+import {
+  ZlibError,
+  adler32,
+  deflate,
+  deflateRaw,
+  inflate,
+  inflateRaw
+} from "../chunk-6FCKOS2B.js";
 export {
+  BIT_DEPTHS,
   BLEND_MODES,
   CURVE_LUT_SIZE,
   DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
+  DeepCompositor,
   INTERPOLATIONS,
   LAYER_EFFECT_KINDS,
   LayerEffectError,
@@ -159,12 +187,16 @@ export {
   compositeSurfaceOver,
   contentBounds,
   contourLut,
+  convertSurfaceDepth,
   curveLut,
   decodePng,
+  deepBytes,
+  deepTile,
   defaultEffectGradient,
   defaultLayerEffect,
   deflate,
   deflateRaw,
+  depthOf,
   effectColorHex,
   effectFillColors,
   effectReach,
@@ -185,6 +217,7 @@ export {
   inflate,
   inflateRaw,
   insertLayer,
+  isBitDepth,
   isBlendMode,
   isInterpolation,
   isLayerEffectKind,
@@ -208,6 +241,8 @@ export {
   patchEffectMaps,
   pigment8,
   pngDataUrl,
+  proxyOf,
+  readDeepRegion,
   readPixel,
   readRegion,
   reduceSurface,
@@ -215,14 +250,27 @@ export {
   scaleLayerEffect,
   setLum,
   solidSurface,
+  srgbDecode,
+  srgbEncode,
   standardBlendMode,
   surfaceBytes,
+  surfaceDepth,
+  surfaceFromDeepPixels,
   surfaceFromPixels,
   surfacesEqual,
   tileCoord,
   tileKey,
   tileRect,
+  tileSamples,
+  tileSamples16,
+  tileSamples32,
   tilesInRect,
+  to16From32,
+  to16From8,
+  to32From16,
+  to32From8,
+  to8From16,
+  to8From32,
   transformSurface,
   transformedBounds,
   translateSurface,
@@ -231,6 +279,8 @@ export {
   validateLayerEffect,
   validateLayerEffects,
   warpSurface,
+  workingToSamples,
+  writeDeepRegion,
   writeRegion
 };
 //# sourceMappingURL=index.js.map

package/dist/{render-BEriFuqK.d.cts → render-B1K_OoLy.d.cts}

@@ -1,4 +1,4 @@
-import { B as BlendMode, R as RasterRect, a as TiledSurface, M as MaskSurface, b as PixelSurface, T as TileKey } from './surface-C8RRg_Bh.cjs';
+import { a as BlendMode, R as RasterRect, j as TiledSurface, M as MaskSurface, c as PixelSurface, i as TileKey, h as Tile } from './surface-Cn30xIV6.cjs';
 import { H as Homography, V as Vec2 } from './types-CwMPoRMU.cjs';
 
 /**
@@ -832,6 +832,91 @@ declare class RasterCompositor<L extends CompositorLayer = CompositorLayer, S ex
 /** Tiles that differ between two surfaces (by tile identity), as tile keys. */
 declare function changedTiles(a: TiledSurface, b: TiledSurface): TileKey[];
 
+/**
+ * High bit depth tiles: 16-bit and 32-bit float samples alongside the 8-bit tile data.
+ *
+ * A tile may carry `deep` samples next to its `data`:
+ *
+ * - `Uint16Array`: 16 bits per channel, 0..65535, the same sRGB encoding and straight alpha as
+ *   the 8-bit data (`data = round(deep / 257)`).
+ * - `Float32Array`: 32-bit float per channel in **linear light** (sRGB primaries), straight
+ *   alpha, as Photoshop's 32-bit mode; colour may exceed 1 (`data` is the clamped sRGB encoding).
+ *
+ * `data` is always the 8-bit rendering of `deep`, so every 8-bit consumer (the compositor, the
+ * viewport, brushes, filters, the paint editor) keeps working unchanged and at full speed: it
+ * simply sees the 8-bit picture. A tile without `deep` holds 8-bit pixels; read at a higher depth
+ * (`tileSamples16` / `tileSamples32`) they are converted exactly as a bit-depth conversion would.
+ * Writers that only produce 8-bit data drop `deep` for the tiles they rewrite (those tiles become
+ * 8-bit precise), and writers that understand depth build tiles with `deepTile`.
+ *
+ * Masks (one channel) are coverage, not colour: their float samples are never linearised.
+ */
+
+/** Bits per channel: 8, 16 or 32 (float). */
+type BitDepth = 8 | 16 | 32;
+declare const BIT_DEPTHS: readonly BitDepth[];
+declare const isBitDepth: (v: unknown) => v is BitDepth;
+/** Deep samples of a tile: 16-bit encoded, or 32-bit linear float. */
+type DeepSamples = Uint16Array | Float32Array;
+/** sRGB-encoded 0..1 to linear light. */
+declare function srgbDecode(v: number): number;
+/** Linear light to sRGB-encoded (values above 1 extend the curve; below 0 clamp to 0). */
+declare function srgbEncode(v: number): number;
+/** 8-bit samples to 16-bit (`v × 257`, exact both ways). */
+declare function to16From8(data: ArrayLike<number>, out?: Uint16Array<ArrayBuffer>): Uint16Array;
+/** 8-bit samples to 32-bit float (colour linearised; alpha and masks as is). */
+declare function to32From8(data: ArrayLike<number>, channels: 1 | 4, out?: Float32Array<ArrayBuffer>): Float32Array;
+/** 16-bit samples to 32-bit float. */
+declare function to32From16(data: ArrayLike<number>, channels: 1 | 4, out?: Float32Array<ArrayBuffer>): Float32Array;
+/** 32-bit float samples to 16-bit (colour encoded and clamped to 0..1). */
+declare function to16From32(data: ArrayLike<number>, channels: 1 | 4, out?: Uint16Array<ArrayBuffer>): Uint16Array;
+/** 16-bit samples to 8-bit (rounded). */
+declare function to8From16(data: ArrayLike<number>, out?: Uint8ClampedArray<ArrayBuffer>): Uint8ClampedArray;
+/** 32-bit float samples to 8-bit (colour encoded and clamped). */
+declare function to8From32(data: ArrayLike<number>, channels: 1 | 4, out?: Uint8ClampedArray<ArrayBuffer>): Uint8ClampedArray;
+/** The 8-bit rendering of deep samples. */
+declare function proxyOf(deep: DeepSamples, channels: 1 | 4, out?: Uint8ClampedArray<ArrayBuffer>): Uint8ClampedArray;
+/** The bit depth deep samples hold. */
+declare const depthOf: (deep: DeepSamples) => 16 | 32;
+/**
+ * A stored tile from deep samples (`TILE × TILE × channels`): `null` when it renders as the
+ * surface default and holds nothing finer, an 8-bit tile when 8 bits hold it exactly (16-bit
+ * samples that are multiples of 257), else a tile with `deep` and its 8-bit rendering.
+ */
+declare function deepTile(deep: DeepSamples, channels: 1 | 4, defaultValue?: number): Tile | null;
+/** 16-bit samples of a tile (`undefined`: the default tile), converting 8-bit or float data. */
+declare function tileSamples16(tile: Tile | undefined, channels: 1 | 4, defaultValue?: number): Uint16Array;
+/** 32-bit float samples of a tile (`undefined`: the default tile), converting 8- or 16-bit data. */
+declare function tileSamples32(tile: Tile | undefined, channels: 1 | 4, defaultValue?: number): Float32Array;
+/** Deep samples of a tile at `depth` (16 or 32). */
+declare function tileSamples(tile: Tile | undefined, channels: 1 | 4, depth: 16 | 32, defaultValue?: number): DeepSamples;
+/** The deepest samples any tile of a surface holds: 8, 16 or 32. */
+declare function surfaceDepth(surface: TiledSurface): BitDepth;
+/** Copies `rect` of a surface at `depth` into a new buffer (`rect.width × rect.height × channels`). */
+declare function readDeepRegion(surface: TiledSurface, rect: RasterRect, depth: 16): Uint16Array;
+declare function readDeepRegion(surface: TiledSurface, rect: RasterRect, depth: 32): Float32Array;
+declare function readDeepRegion(surface: TiledSurface, rect: RasterRect, depth: 16 | 32): DeepSamples;
+/**
+ * Writes `rect.width × rect.height` interleaved deep samples at `rect` and returns the new
+ * surface. Partly covered tiles keep their other pixels, converted to the samples' depth.
+ */
+declare function writeDeepRegion(surface: TiledSurface, rect: RasterRect, samples: DeepSamples): TiledSurface;
+/** A surface holding `width × height` deep samples placed at (`x`, `y`). */
+declare function surfaceFromDeepPixels(pixels: {
+    width: number;
+    height: number;
+    data: DeepSamples;
+}, channels?: 1 | 4, x?: number, y?: number, defaultValue?: number): TiledSurface;
+/**
+ * The surface converted to `depth`: 8 drops every tile's deep samples (keeping their 8-bit
+ * rendering); 16 or 32 converts the deep samples tiles already hold. Tiles without deep samples
+ * are left alone (they read at any depth by conversion), so going up from 8 bits costs nothing.
+ * Returns the same surface when nothing changes.
+ */
+declare function convertSurfaceDepth(surface: TiledSurface, depth: BitDepth): TiledSurface;
+/** Bytes held by deep samples (in addition to `surfaceBytes`). */
+declare function deepBytes(surface: TiledSurface): number;
+
 /**
  * CPU renderer for layer effects.
  *
@@ -966,4 +1051,4 @@ declare function renderLayerEffects(effects: LayerEffects, layer: {
     fillOpacity?: number;
 }, backdrop: Uint8ClampedArray, canvas: EffectRect, ctx: EffectContext): void;
 
-export { type StrokeEffect as $, type EffectRect as A, type BevelContour as B, type CompositorLayer as C, DEFAULT_GLOBAL_LIGHT as D, type EffectFill as E, type GlowTechnique as F, type GroupBlendMode as G, type GradientColorStop as H, type Interpolation as I, type GradientOpacityStop as J, type GradientOverlayEffect as K, type LayerLocks as L, type GradientStyle as M, INTERPOLATIONS as N, type InnerGlowEffect as O, type InnerShadowEffect as P, LAYER_EFFECT_KINDS as Q, type RasterLayer as R, LayerEffectError as S, MAX_EFFECT_REACH as T, MAX_TRANSFORM_PIXELS as U, type OuterGlowEffect as V, type PatternOverlayEffect as W, PatternPlacement as X, PatternTile as Y, type ResampleOptions as Z, type SatinEffect as _, type RasterGroupLayer as a, type StrokePosition as a0, TransformTooLargeError as a1, blendTile as a2, builtinPattern as a3, builtinPatternIds as a4, changedTiles as a5, compositeSurfaceOver as a6, defaultEffectGradient as a7, defaultLayerEffect as a8, effectColorHex as a9, validateLayerEffect as aA, validateLayerEffects as aB, warpSurface as aC, type CompositorProfile as aD, type EffectCompositeInput as aE, type EffectMaps as aF, type GroupIn as aG, type PixelFilterSpec as aH, type RasterNode as aI, STROKE_CHAMFER_MAX as aJ, activeEffectItems as aK, buildEffectMaps as aL, compositeLayerEffects as aM, contourLut as aN, effectFillColors as aO, effectsAreLocal as aP, gradientT as aQ, patchEffectMaps as aR, effectReach as aa, effectsFingerprint as ab, effectsMargin as ac, effectsScale as ad, findLayer as ae, flattenLayers as af, hasActiveEffects as ag, hashNoise as ah, insertLayer as ai, isInterpolation as aj, isLayerEffectKind as ak, isLayerLocked as al, keysWeight as am, layerEffectFields as an, layerEffectLabel as ao, mapLayer as ap, mergeLayerEffect as aq, newEffectId as ar, normalizeLayerEffects as as, parseEffectColor as at, reduceSurface as au, renderLayerEffects as av, scaleLayerEffect as aw, transformSurface as ax, transformedBounds as ay, validateEffectGradient as az, type RasterPixelLayer as b, RasterCompositor as c, type RasterSources as d, type RasterLayerBase as e, type RasterMask as f, type GlobalLight as g, type EffectPattern as h, type LayerLocation as i, type LayerEffect as j, type LayerEffects as k, type CompositorOptions as l, type LayerEffectKind as m, type EffectContext as n, type BevelEmbossEffect as o, type BevelStyle as p, type BevelTechnique as q, type BevelTexture as r, type ColorOverlayEffect as s, type CompositeCallOptions as t, type CompositeStats as u, type ContourPoint as v, type DropShadowEffect as w, type EffectContour as x, type EffectGradient as y, type EffectPatternRef as z };
+export { type PixelFilterSpec as $, type GradientOverlayEffect as A, BIT_DEPTHS as B, type CompositorLayer as C, DEFAULT_GLOBAL_LIGHT as D, type EffectCompositeInput as E, type GradientStyle as F, type GlobalLight as G, type GroupBlendMode as H, type GroupIn as I, INTERPOLATIONS as J, type InnerGlowEffect as K, type InnerShadowEffect as L, type Interpolation as M, LAYER_EFFECT_KINDS as N, type LayerEffect as O, LayerEffectError as P, type LayerEffectKind as Q, type RasterSources as R, type LayerEffects as S, type LayerLocation as T, type LayerLocks as U, MAX_EFFECT_REACH as V, MAX_TRANSFORM_PIXELS as W, type OuterGlowEffect as X, type PatternOverlayEffect as Y, PatternPlacement as Z, PatternTile as _, RasterCompositor as a, tileSamples16 as a$, type RasterGroupLayer as a0, type RasterLayer as a1, type RasterLayerBase as a2, type RasterMask as a3, type RasterNode as a4, type RasterPixelLayer as a5, type ResampleOptions as a6, STROKE_CHAMFER_MAX as a7, type SatinEffect as a8, type StrokeEffect as a9, gradientT as aA, hasActiveEffects as aB, hashNoise as aC, insertLayer as aD, isBitDepth as aE, isInterpolation as aF, isLayerEffectKind as aG, isLayerLocked as aH, keysWeight as aI, layerEffectFields as aJ, layerEffectLabel as aK, mapLayer as aL, mergeLayerEffect as aM, newEffectId as aN, normalizeLayerEffects as aO, parseEffectColor as aP, patchEffectMaps as aQ, proxyOf as aR, readDeepRegion as aS, reduceSurface as aT, renderLayerEffects as aU, scaleLayerEffect as aV, srgbDecode as aW, srgbEncode as aX, surfaceDepth as aY, surfaceFromDeepPixels as aZ, tileSamples as a_, type StrokePosition as aa, TransformTooLargeError as ab, activeEffectItems as ac, blendTile as ad, buildEffectMaps as ae, builtinPattern as af, builtinPatternIds as ag, changedTiles as ah, compositeLayerEffects as ai, compositeSurfaceOver as aj, contourLut as ak, convertSurfaceDepth as al, deepBytes as am, deepTile as an, defaultEffectGradient as ao, defaultLayerEffect as ap, depthOf as aq, effectColorHex as ar, effectFillColors as as, effectReach as at, effectsAreLocal as au, effectsFingerprint as av, effectsMargin as aw, effectsScale as ax, findLayer as ay, flattenLayers as az, type CompositorProfile as b, tileSamples32 as b0, to16From32 as b1, to16From8 as b2, to32From16 as b3, to32From8 as b4, to8From16 as b5, to8From32 as b6, transformSurface as b7, transformedBounds as b8, validateEffectGradient as b9, validateLayerEffect as ba, validateLayerEffects as bb, warpSurface as bc, writeDeepRegion as bd, type BevelContour as c, type BevelEmbossEffect as d, type BevelStyle as e, type BevelTechnique as f, type BevelTexture as g, type BitDepth as h, type ColorOverlayEffect as i, type CompositeCallOptions as j, type CompositeStats as k, type CompositorOptions as l, type ContourPoint as m, type DeepSamples as n, type DropShadowEffect as o, type EffectContext as p, type EffectContour as q, type EffectFill as r, type EffectGradient as s, type EffectMaps as t, type EffectPattern as u, type EffectPatternRef as v, type EffectRect as w, type GlowTechnique as x, type GradientColorStop as y, type GradientOpacityStop as z };

package/dist/{render-tjzKaik-.d.ts → render-CrmHOgpo.d.ts}

@@ -1,4 +1,4 @@
-import { B as BlendMode, R as RasterRect, a as TiledSurface, M as MaskSurface, b as PixelSurface, T as TileKey } from './surface-C8RRg_Bh.js';
+import { a as BlendMode, R as RasterRect, j as TiledSurface, M as MaskSurface, c as PixelSurface, i as TileKey, h as Tile } from './surface-Cn30xIV6.js';
 import { H as Homography, V as Vec2 } from './types-CwMPoRMU.js';
 
 /**
@@ -832,6 +832,91 @@ declare class RasterCompositor<L extends CompositorLayer = CompositorLayer, S ex
 /** Tiles that differ between two surfaces (by tile identity), as tile keys. */
 declare function changedTiles(a: TiledSurface, b: TiledSurface): TileKey[];
 
+/**
+ * High bit depth tiles: 16-bit and 32-bit float samples alongside the 8-bit tile data.
+ *
+ * A tile may carry `deep` samples next to its `data`:
+ *
+ * - `Uint16Array`: 16 bits per channel, 0..65535, the same sRGB encoding and straight alpha as
+ *   the 8-bit data (`data = round(deep / 257)`).
+ * - `Float32Array`: 32-bit float per channel in **linear light** (sRGB primaries), straight
+ *   alpha, as Photoshop's 32-bit mode; colour may exceed 1 (`data` is the clamped sRGB encoding).
+ *
+ * `data` is always the 8-bit rendering of `deep`, so every 8-bit consumer (the compositor, the
+ * viewport, brushes, filters, the paint editor) keeps working unchanged and at full speed: it
+ * simply sees the 8-bit picture. A tile without `deep` holds 8-bit pixels; read at a higher depth
+ * (`tileSamples16` / `tileSamples32`) they are converted exactly as a bit-depth conversion would.
+ * Writers that only produce 8-bit data drop `deep` for the tiles they rewrite (those tiles become
+ * 8-bit precise), and writers that understand depth build tiles with `deepTile`.
+ *
+ * Masks (one channel) are coverage, not colour: their float samples are never linearised.
+ */
+
+/** Bits per channel: 8, 16 or 32 (float). */
+type BitDepth = 8 | 16 | 32;
+declare const BIT_DEPTHS: readonly BitDepth[];
+declare const isBitDepth: (v: unknown) => v is BitDepth;
+/** Deep samples of a tile: 16-bit encoded, or 32-bit linear float. */
+type DeepSamples = Uint16Array | Float32Array;
+/** sRGB-encoded 0..1 to linear light. */
+declare function srgbDecode(v: number): number;
+/** Linear light to sRGB-encoded (values above 1 extend the curve; below 0 clamp to 0). */
+declare function srgbEncode(v: number): number;
+/** 8-bit samples to 16-bit (`v × 257`, exact both ways). */
+declare function to16From8(data: ArrayLike<number>, out?: Uint16Array<ArrayBuffer>): Uint16Array;
+/** 8-bit samples to 32-bit float (colour linearised; alpha and masks as is). */
+declare function to32From8(data: ArrayLike<number>, channels: 1 | 4, out?: Float32Array<ArrayBuffer>): Float32Array;
+/** 16-bit samples to 32-bit float. */
+declare function to32From16(data: ArrayLike<number>, channels: 1 | 4, out?: Float32Array<ArrayBuffer>): Float32Array;
+/** 32-bit float samples to 16-bit (colour encoded and clamped to 0..1). */
+declare function to16From32(data: ArrayLike<number>, channels: 1 | 4, out?: Uint16Array<ArrayBuffer>): Uint16Array;
+/** 16-bit samples to 8-bit (rounded). */
+declare function to8From16(data: ArrayLike<number>, out?: Uint8ClampedArray<ArrayBuffer>): Uint8ClampedArray;
+/** 32-bit float samples to 8-bit (colour encoded and clamped). */
+declare function to8From32(data: ArrayLike<number>, channels: 1 | 4, out?: Uint8ClampedArray<ArrayBuffer>): Uint8ClampedArray;
+/** The 8-bit rendering of deep samples. */
+declare function proxyOf(deep: DeepSamples, channels: 1 | 4, out?: Uint8ClampedArray<ArrayBuffer>): Uint8ClampedArray;
+/** The bit depth deep samples hold. */
+declare const depthOf: (deep: DeepSamples) => 16 | 32;
+/**
+ * A stored tile from deep samples (`TILE × TILE × channels`): `null` when it renders as the
+ * surface default and holds nothing finer, an 8-bit tile when 8 bits hold it exactly (16-bit
+ * samples that are multiples of 257), else a tile with `deep` and its 8-bit rendering.
+ */
+declare function deepTile(deep: DeepSamples, channels: 1 | 4, defaultValue?: number): Tile | null;
+/** 16-bit samples of a tile (`undefined`: the default tile), converting 8-bit or float data. */
+declare function tileSamples16(tile: Tile | undefined, channels: 1 | 4, defaultValue?: number): Uint16Array;
+/** 32-bit float samples of a tile (`undefined`: the default tile), converting 8- or 16-bit data. */
+declare function tileSamples32(tile: Tile | undefined, channels: 1 | 4, defaultValue?: number): Float32Array;
+/** Deep samples of a tile at `depth` (16 or 32). */
+declare function tileSamples(tile: Tile | undefined, channels: 1 | 4, depth: 16 | 32, defaultValue?: number): DeepSamples;
+/** The deepest samples any tile of a surface holds: 8, 16 or 32. */
+declare function surfaceDepth(surface: TiledSurface): BitDepth;
+/** Copies `rect` of a surface at `depth` into a new buffer (`rect.width × rect.height × channels`). */
+declare function readDeepRegion(surface: TiledSurface, rect: RasterRect, depth: 16): Uint16Array;
+declare function readDeepRegion(surface: TiledSurface, rect: RasterRect, depth: 32): Float32Array;
+declare function readDeepRegion(surface: TiledSurface, rect: RasterRect, depth: 16 | 32): DeepSamples;
+/**
+ * Writes `rect.width × rect.height` interleaved deep samples at `rect` and returns the new
+ * surface. Partly covered tiles keep their other pixels, converted to the samples' depth.
+ */
+declare function writeDeepRegion(surface: TiledSurface, rect: RasterRect, samples: DeepSamples): TiledSurface;
+/** A surface holding `width × height` deep samples placed at (`x`, `y`). */
+declare function surfaceFromDeepPixels(pixels: {
+    width: number;
+    height: number;
+    data: DeepSamples;
+}, channels?: 1 | 4, x?: number, y?: number, defaultValue?: number): TiledSurface;
+/**
+ * The surface converted to `depth`: 8 drops every tile's deep samples (keeping their 8-bit
+ * rendering); 16 or 32 converts the deep samples tiles already hold. Tiles without deep samples
+ * are left alone (they read at any depth by conversion), so going up from 8 bits costs nothing.
+ * Returns the same surface when nothing changes.
+ */
+declare function convertSurfaceDepth(surface: TiledSurface, depth: BitDepth): TiledSurface;
+/** Bytes held by deep samples (in addition to `surfaceBytes`). */
+declare function deepBytes(surface: TiledSurface): number;
+
 /**
  * CPU renderer for layer effects.
  *
@@ -966,4 +1051,4 @@ declare function renderLayerEffects(effects: LayerEffects, layer: {
     fillOpacity?: number;
 }, backdrop: Uint8ClampedArray, canvas: EffectRect, ctx: EffectContext): void;
 
-export { type StrokeEffect as $, type EffectRect as A, type BevelContour as B, type CompositorLayer as C, DEFAULT_GLOBAL_LIGHT as D, type EffectFill as E, type GlowTechnique as F, type GroupBlendMode as G, type GradientColorStop as H, type Interpolation as I, type GradientOpacityStop as J, type GradientOverlayEffect as K, type LayerLocks as L, type GradientStyle as M, INTERPOLATIONS as N, type InnerGlowEffect as O, type InnerShadowEffect as P, LAYER_EFFECT_KINDS as Q, type RasterLayer as R, LayerEffectError as S, MAX_EFFECT_REACH as T, MAX_TRANSFORM_PIXELS as U, type OuterGlowEffect as V, type PatternOverlayEffect as W, PatternPlacement as X, PatternTile as Y, type ResampleOptions as Z, type SatinEffect as _, type RasterGroupLayer as a, type StrokePosition as a0, TransformTooLargeError as a1, blendTile as a2, builtinPattern as a3, builtinPatternIds as a4, changedTiles as a5, compositeSurfaceOver as a6, defaultEffectGradient as a7, defaultLayerEffect as a8, effectColorHex as a9, validateLayerEffect as aA, validateLayerEffects as aB, warpSurface as aC, type CompositorProfile as aD, type EffectCompositeInput as aE, type EffectMaps as aF, type GroupIn as aG, type PixelFilterSpec as aH, type RasterNode as aI, STROKE_CHAMFER_MAX as aJ, activeEffectItems as aK, buildEffectMaps as aL, compositeLayerEffects as aM, contourLut as aN, effectFillColors as aO, effectsAreLocal as aP, gradientT as aQ, patchEffectMaps as aR, effectReach as aa, effectsFingerprint as ab, effectsMargin as ac, effectsScale as ad, findLayer as ae, flattenLayers as af, hasActiveEffects as ag, hashNoise as ah, insertLayer as ai, isInterpolation as aj, isLayerEffectKind as ak, isLayerLocked as al, keysWeight as am, layerEffectFields as an, layerEffectLabel as ao, mapLayer as ap, mergeLayerEffect as aq, newEffectId as ar, normalizeLayerEffects as as, parseEffectColor as at, reduceSurface as au, renderLayerEffects as av, scaleLayerEffect as aw, transformSurface as ax, transformedBounds as ay, validateEffectGradient as az, type RasterPixelLayer as b, RasterCompositor as c, type RasterSources as d, type RasterLayerBase as e, type RasterMask as f, type GlobalLight as g, type EffectPattern as h, type LayerLocation as i, type LayerEffect as j, type LayerEffects as k, type CompositorOptions as l, type LayerEffectKind as m, type EffectContext as n, type BevelEmbossEffect as o, type BevelStyle as p, type BevelTechnique as q, type BevelTexture as r, type ColorOverlayEffect as s, type CompositeCallOptions as t, type CompositeStats as u, type ContourPoint as v, type DropShadowEffect as w, type EffectContour as x, type EffectGradient as y, type EffectPatternRef as z };
+export { type PixelFilterSpec as $, type GradientOverlayEffect as A, BIT_DEPTHS as B, type CompositorLayer as C, DEFAULT_GLOBAL_LIGHT as D, type EffectCompositeInput as E, type GradientStyle as F, type GlobalLight as G, type GroupBlendMode as H, type GroupIn as I, INTERPOLATIONS as J, type InnerGlowEffect as K, type InnerShadowEffect as L, type Interpolation as M, LAYER_EFFECT_KINDS as N, type LayerEffect as O, LayerEffectError as P, type LayerEffectKind as Q, type RasterSources as R, type LayerEffects as S, type LayerLocation as T, type LayerLocks as U, MAX_EFFECT_REACH as V, MAX_TRANSFORM_PIXELS as W, type OuterGlowEffect as X, type PatternOverlayEffect as Y, PatternPlacement as Z, PatternTile as _, RasterCompositor as a, tileSamples16 as a$, type RasterGroupLayer as a0, type RasterLayer as a1, type RasterLayerBase as a2, type RasterMask as a3, type RasterNode as a4, type RasterPixelLayer as a5, type ResampleOptions as a6, STROKE_CHAMFER_MAX as a7, type SatinEffect as a8, type StrokeEffect as a9, gradientT as aA, hasActiveEffects as aB, hashNoise as aC, insertLayer as aD, isBitDepth as aE, isInterpolation as aF, isLayerEffectKind as aG, isLayerLocked as aH, keysWeight as aI, layerEffectFields as aJ, layerEffectLabel as aK, mapLayer as aL, mergeLayerEffect as aM, newEffectId as aN, normalizeLayerEffects as aO, parseEffectColor as aP, patchEffectMaps as aQ, proxyOf as aR, readDeepRegion as aS, reduceSurface as aT, renderLayerEffects as aU, scaleLayerEffect as aV, srgbDecode as aW, srgbEncode as aX, surfaceDepth as aY, surfaceFromDeepPixels as aZ, tileSamples as a_, type StrokePosition as aa, TransformTooLargeError as ab, activeEffectItems as ac, blendTile as ad, buildEffectMaps as ae, builtinPattern as af, builtinPatternIds as ag, changedTiles as ah, compositeLayerEffects as ai, compositeSurfaceOver as aj, contourLut as ak, convertSurfaceDepth as al, deepBytes as am, deepTile as an, defaultEffectGradient as ao, defaultLayerEffect as ap, depthOf as aq, effectColorHex as ar, effectFillColors as as, effectReach as at, effectsAreLocal as au, effectsFingerprint as av, effectsMargin as aw, effectsScale as ax, findLayer as ay, flattenLayers as az, type CompositorProfile as b, tileSamples32 as b0, to16From32 as b1, to16From8 as b2, to32From16 as b3, to32From8 as b4, to8From16 as b5, to8From32 as b6, transformSurface as b7, transformedBounds as b8, validateEffectGradient as b9, validateLayerEffect as ba, validateLayerEffects as bb, warpSurface as bc, writeDeepRegion as bd, type BevelContour as c, type BevelEmbossEffect as d, type BevelStyle as e, type BevelTechnique as f, type BevelTexture as g, type BitDepth as h, type ColorOverlayEffect as i, type CompositeCallOptions as j, type CompositeStats as k, type CompositorOptions as l, type ContourPoint as m, type DeepSamples as n, type DropShadowEffect as o, type EffectContext as p, type EffectContour as q, type EffectFill as r, type EffectGradient as s, type EffectMaps as t, type EffectPattern as u, type EffectPatternRef as v, type EffectRect as w, type GlowTechnique as x, type GradientColorStop as y, type GradientOpacityStop as z };

package/dist/{blending-aOE6Y3UE.d.cts → retouch-Bxkuc0KH.d.cts}

@@ -1,4 +1,4 @@
-import { B as BlendMode, R as RasterRect, T as TileKey, P as Pigment } from './surface-C8RRg_Bh.cjs';
+import { a as BlendMode, R as RasterRect, i as TileKey, Y as Pigment } from './surface-Cn30xIV6.cjs';
 
 /**
  * The brush engine (a subset of photocraft's `crates/paint`): a computed round tip with size,
@@ -483,4 +483,221 @@ declare class SmudgeTip {
     dab(medium: TileMedium, d: SmudgeDab, rect: RasterRect, cov: ArrayLike<number>): void;
 }
 
-export { tipShape as $, blendRadius as A, type BrushSettings as B, CoverageMap as C, type Dab as D, EMPTY_MIXER_LOAD as E, blenderDab as F, cleanMixer as G, coverageTileCoord as H, createBlenderScratch as I, dabCoverage as J, dabRect as K, exchangeRates as L, type MixerSettings as M, loadMixer as N, mixerRates as O, type PaintTileTarget as P, normalizeBlender as Q, type RgbTriple as R, type SmudgeSettings as S, TileMedium as T, normalizeBrush as U, normalizeMixer as V, normalizeSmudge as W, rasterizeDab as X, smoothPoints as Y, tipFalloff as Z, tipReach as _, type MixingModel as a, walkDabs as a0, type BlenderSettings as b, type StrokePoint as c, type MixerLoad as d, MAX_BRUSH_SIZE as e, StrokeCoverage as f, type MixerTarget as g, MixerStroke as h, type StrokeApply as i, type BlenderScratch as j, DEFAULT_BLENDER as k, DEFAULT_BRUSH as l, DEFAULT_MIXER as m, DEFAULT_SMUDGE as n, DabWalker as o, type ExchangeRates as p, MIXER_DRAIN as q, MIXER_PICKUP_RATE as r, MIXING_MODELS as s, PaintExchange as t, type PaintMedium as u, type PaintSample as v, type SmudgeDab as w, SmudgeTip as x, type TileMediumOptions as y, applyStrokeToTile as z };
+/**
+ * The retouching tools on the shared brush engine: Clone Stamp, Healing Brush, Spot Healing
+ * Brush, Smudge, Dodge, Burn and Sponge. Two stroke shapes cover them all:
+ *
+ * - **Accumulate, then composite** (Clone Stamp, Dodge, Burn; the Healing tools' result): the
+ *   stroke's dabs build up one `CoverageMap` (flow builds towards the dab's opacity ceiling), and
+ *   per-pixel paint taken from the pre-stroke state (a cloned source, a toned copy of the pixel,
+ *   a healed patch) is composited through it with `applyRetouchToTile`. Pixels painted earlier in
+ *   the stroke are never sampled again, and overlapping dabs never exceed the stroke's opacity.
+ * - **Sequential dabs** (Smudge, Sponge): `RetouchDabStroke` runs each dab in order over live
+ *   tiles, so dab n sees what dab n − 1 did.
+ *
+ * The Healing Brush clones while it is drawn and, when the stroke ends, replaces the clone with a
+ * seamless clone (`healPixels`, Poisson blending): the source's texture with the colour and light
+ * of the pixels around the stroke. The Spot Healing Brush finds its own source (`spotHealPixels`).
+ *
+ * Tone curves (`dodgeBurnCurve`, `dodgeBurn`, `sponge`) are photocraft's, made to behave like
+ * Photoshop's tools: the chosen range moves most, black and white stay put for midtones, and
+ * Protect Tones works on luma so hue and saturation are kept. Data in, pixels out; no DOM.
+ */
+
+/** The tonal range Dodge and Burn work on most. */
+type ToneRange = 'shadows' | 'midtones' | 'highlights';
+declare const TONE_RANGES: readonly ToneRange[];
+/** Rec. 601 luma of straight RGB (0..1). */
+declare function luma(r: number, g: number, b: number): number;
+/** The dodge (or burn) transfer of one value `v` (0..1) at exposure `e` (0..1). */
+declare function dodgeBurnCurve(v: number, e: number, range: ToneRange, burn: boolean): number;
+/**
+ * Dodge (or burn) straight RGB `c` (0..1, written in place) at exposure `e`. With `protectTones`
+ * the curve moves luma and the colour is scaled to it (hue and saturation kept); otherwise each
+ * channel goes through the curve.
+ */
+declare function dodgeBurn(c: number[], e: number, range: ToneRange, burn: boolean, protectTones: boolean): number[];
+/** HSV saturation (chroma / max) of straight RGB. */
+declare function saturationOf(r: number, g: number, b: number): number;
+/**
+ * Sponge: moves straight RGB `c` (written in place) away from (`saturate`) or towards its luma
+ * grey by `amount` (0..1). `vibrance` damps it where it would clip: saturating touches already
+ * saturated colours less, desaturating touches near-greys less. Gamut-compressed, never clipped.
+ */
+declare function sponge(c: number[], amount: number, saturate: boolean, vibrance: boolean): number[];
+/** Per-dab strength so that one pass over a point totals about `e`, whatever the spacing. */
+declare function perDabStrength(e: number, spacing: number): number;
+/** Which pixels the Clone Stamp and the Healing tools sample. */
+type RetouchSample = 'current' | 'current-below' | 'all';
+declare const RETOUCH_SAMPLES: readonly RetouchSample[];
+/** How the Spot Healing Brush finds its source. */
+type SpotHealType = 'proximity-match' | 'smooth';
+declare const SPOT_HEAL_TYPES: readonly SpotHealType[];
+/** The retouching tools' options. */
+interface RetouchSettings {
+    /** Clone / heal: keep the source offset from stroke to stroke (default true); off, every stroke starts at the source point. */
+    aligned: boolean;
+    /** Clone / heal / spot heal: what is sampled (default `current`: the target layer). */
+    sample: RetouchSample;
+    /** Spot heal: `proximity-match` (default: the best matching patch nearby) or `smooth` (a smooth fill from the edges). */
+    spotType: SpotHealType;
+    /** Dodge / burn: the tonal range (default `midtones`). */
+    range: ToneRange;
+    /** Dodge / burn: exposure 0..1 (default 0.5). */
+    exposure: number;
+    /** Dodge / burn: tone luma only, keeping hue and saturation (default true). */
+    protectTones: boolean;
+    /** Sponge: `desaturate` (default) or `saturate`. */
+    spongeMode: 'desaturate' | 'saturate';
+    /** Sponge: damp the change where colours would clip (default true). */
+    vibrance: boolean;
+    /** Smudge: how strongly the finger carries and lays paint, 0..1 (default 0.5). */
+    strength: number;
+}
+declare const DEFAULT_RETOUCH: Readonly<RetouchSettings>;
+/** Retouch settings with every field valid (missing or invalid fields from `base`). */
+declare function normalizeRetouch(raw?: Partial<RetouchSettings>, base?: RetouchSettings): RetouchSettings;
+/** Pixels a retouching stroke samples, by document pixel. */
+interface PixelSource {
+    /** Straight RGBA 0..255 of document pixel (x, y) into `out`; false (and `out` zeroed) where there is nothing. */
+    sample(x: number, y: number, out: number[]): boolean;
+}
+/**
+ * A source over raster tiles (layer pixels, a mask, or composite tiles): `readTile` gives tile
+ * (tx, ty) in source space or `null` when it is empty; source pixel = document pixel − `offset`.
+ * One-channel tiles read as grey (alpha 255). Tiles are cached, so make one per stroke.
+ */
+declare class TilePixelSource implements PixelSource {
+    private readonly readTile;
+    readonly channels: 1 | 4;
+    readonly offset: {
+        x: number;
+        y: number;
+    };
+    private readonly cache;
+    private lastKey;
+    private last;
+    constructor(readTile: (tx: number, ty: number) => Uint8ClampedArray | null, channels: 1 | 4, offset?: {
+        x: number;
+        y: number;
+    });
+    sample(x: number, y: number, out: number[]): boolean;
+}
+/** A source over a region of float RGBA pixels (0..255), e.g. a healed patch. */
+declare class RegionPixelSource implements PixelSource {
+    readonly rect: RasterRect;
+    readonly data: Float32Array;
+    constructor(rect: RasterRect, data: Float32Array);
+    sample(x: number, y: number, out: number[]): boolean;
+}
+/** `rect` of a source, shifted by (dx, dy), as float RGBA 0..255 (`rect.width × rect.height × 4`). */
+declare function readSourceRegion(source: PixelSource, rect: RasterRect, dx?: number, dy?: number): Float32Array;
+/** What a coverage-based retouching stroke lays through its coverage. */
+type RetouchPaint = 
+/** Source pixels at document pixel + (dx, dy) (Clone Stamp, a healed patch). */
+{
+    kind: 'source';
+    source: PixelSource;
+    dx: number;
+    dy: number;
+}
+/** The target pixel itself, toned (Dodge, Burn): `tone` edits straight RGB 0..1 in place. */
+ | {
+    kind: 'tone';
+    tone: (rgb: number[]) => void;
+}
+/** A flat colour (the Spot Healing Brush's trail while it is drawn), RGBA 0..255. */
+ | {
+    kind: 'color';
+    color: readonly [number, number, number, number];
+};
+/** How a coverage-based retouching stroke composites. */
+interface RetouchApply {
+    /** Stroke opacity 0..1. */
+    opacity: number;
+    /** Blend mode for source paint (default normal). */
+    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 `paint` through the stroke's coverage over `tileData` (target tile (tx, ty) as it was
+ * before the stroke, layer space; RGBA, or one byte per pixel for masks) and returns the new tile.
+ * With `into` (the previous result) and `region` (document space), only `region` is recomputed.
+ * Tone paint keeps alpha; source and colour paint composite with `blend` (source-over by
+ * default), keeping alpha on a locked layer.
+ */
+declare function applyRetouchToTile(coverage: CoverageMap, tileData: Uint8ClampedArray, channels: 1 | 4, tx: number, ty: number, paint: RetouchPaint, s: RetouchApply, options?: {
+    into?: Uint8ClampedArray;
+    region?: RasterRect;
+}): Uint8ClampedArray;
+/** The tone function of a Dodge or Burn stroke. */
+declare function toneOf(tool: 'dodge' | 'burn', settings: Pick<RetouchSettings, 'exposure' | 'range' | 'protectTones'>): (rgb: number[]) => void;
+/**
+ * Heals `src` into `dst` over `mask` (all `w × h`, RGBA floats 0..255): a seamless clone solved
+ * only over the mask's bounds plus a one-pixel fixed ring; elsewhere the result is `dst`.
+ */
+declare function healPixels(w: number, h: number, src: Float32Array, dst: Float32Array, mask: ArrayLike<boolean | number>): Float32Array;
+/**
+ * Spot healing: fills `hole` (`w × h`) of `img` (RGBA floats 0..255) with no given source, then
+ * heals the fill into its surroundings. `proximity-match` copies the best matching nearby patch
+ * (falling back to `smooth` when none fits); `smooth` interpolates the edges inwards. `size` is
+ * the brush diameter in pixels. Returns the healed pixels over the whole grid.
+ */
+declare function spotHealPixels(w: number, h: number, img: Float32Array, hole: ArrayLike<boolean | number>, size: number, type: SpotHealType, 
+/** Told the patch offset it copied (`null`: a smooth fill). */
+onOffset?: (offset: [number, number] | null) => void): Float32Array;
+/** The window a Spot Healing stroke over `bounds` looks for texture in: the bounds grown by their size, on the canvas. */
+declare function spotHealWindow(bounds: RasterRect, canvas: {
+    width: number;
+    height: number;
+}): RasterRect;
+/**
+ * One dab of a sequential retouching stroke: `cov` is the tip's pure coverage over `rect`
+ * (document space, 0..1); `d.alpha` is the flow and `d.opacity` the pressure opacity.
+ */
+type RetouchDabEffect = (medium: TileMedium, d: Dab, rect: RasterRect, cov: Float32Array) => void;
+/**
+ * A stroke whose dabs edit live tiles in order (Smudge, Sponge). Feed points with `push` (any
+ * chunks give the same dabs), end with `finish`; each returns the document rectangles it touched.
+ */
+declare class RetouchDabStroke {
+    readonly brush: BrushSettings;
+    private readonly effect;
+    dabCount: number;
+    bounds: RasterRect | null;
+    private readonly walker;
+    private readonly medium;
+    private smoothPos;
+    private buf;
+    constructor(brush: BrushSettings, target: PaintTileTarget, effect: RetouchDabEffect);
+    push(points: readonly StrokePoint[]): RasterRect[];
+    finish(last?: StrokePoint): RasterRect[];
+    private smooth;
+    private paint;
+}
+/** The Smudge's per-dab effect: a `SmudgeTip` whose strength carries and lays the paint. */
+declare function smudgeEffect(brush: BrushSettings, strength: number, mixing?: SmudgeSettings['mixing']): RetouchDabEffect;
+/** The Sponge's per-dab effect: each dab moves saturation by about half its flow, compounding over passes. */
+declare function spongeEffect(brush: BrushSettings, saturate: boolean, vibrance: boolean): RetouchDabEffect;
+/**
+ * An RGBA view of one-channel tiles (masks), for the sequential-dab tools: reads expand grey to
+ * opaque RGB, writes land in RGBA copies, and `flush` writes their red channel back through
+ * `target.writeTile`. Alpha is locked, so a mask's values are all a dab changes.
+ */
+declare function rgbaViewOfGrey(target: PaintTileTarget): {
+    target: PaintTileTarget;
+    flush(): void;
+};
+
+export { cleanMixer as $, type PixelSource as A, type BrushSettings as B, CoverageMap as C, type Dab as D, EMPTY_MIXER_LOAD as E, RETOUCH_SAMPLES as F, RegionPixelSource as G, type RetouchDabEffect as H, RetouchDabStroke as I, type RetouchSample as J, SPOT_HEAL_TYPES as K, type SmudgeDab as L, type MixerSettings as M, SmudgeTip as N, type SpotHealType as O, type PaintTileTarget as P, TileMedium as Q, type RgbTriple as R, type SmudgeSettings as S, TONE_RANGES as T, type TileMediumOptions as U, TilePixelSource as V, type ToneRange as W, applyRetouchToTile as X, applyStrokeToTile as Y, blendRadius as Z, blenderDab as _, type MixingModel as a, coverageTileCoord as a0, createBlenderScratch as a1, dabCoverage as a2, dabRect as a3, dodgeBurn as a4, dodgeBurnCurve as a5, exchangeRates as a6, healPixels as a7, loadMixer as a8, luma as a9, mixerRates as aa, normalizeBlender as ab, normalizeBrush as ac, normalizeMixer as ad, normalizeRetouch as ae, normalizeSmudge as af, perDabStrength as ag, rasterizeDab as ah, readSourceRegion as ai, rgbaViewOfGrey as aj, saturationOf as ak, smoothPoints as al, smudgeEffect as am, sponge as an, spongeEffect as ao, spotHealPixels as ap, spotHealWindow as aq, tipFalloff as ar, tipReach as as, tipShape as at, toneOf as au, walkDabs as av, type BlenderSettings as b, type StrokePoint as c, type MixerLoad as d, MAX_BRUSH_SIZE as e, type RetouchSettings as f, StrokeCoverage as g, type MixerTarget as h, MixerStroke as i, type RetouchApply as j, type RetouchPaint as k, type StrokeApply as l, type BlenderScratch as m, DEFAULT_BLENDER as n, DEFAULT_BRUSH as o, DEFAULT_MIXER as p, DEFAULT_RETOUCH as q, DEFAULT_SMUDGE as r, DabWalker as s, type ExchangeRates as t, MIXER_DRAIN as u, MIXER_PICKUP_RATE as v, MIXING_MODELS as w, PaintExchange as x, type PaintMedium as y, type PaintSample as z };