@pixerate/editor 0.111.0 → 0.113.0

package/dist/paint/index.cjs

@@ -1,4 +1,34 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../chunk-FTBZPI77.cjs');
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk4KLT7ZYScjs = require('../chunk-4KLT7ZYS.cjs');
 
 
 
@@ -102,5 +132,34 @@ var _chunkXIOMMGPDcjs = require('../chunk-XIOMMGPD.cjs');
 
 
 
-exports.CoverageMap = _chunk7VOHOPLWcjs.CoverageMap; exports.DEFAULT_BLENDER = _chunk7VOHOPLWcjs.DEFAULT_BLENDER; exports.DEFAULT_BRUSH = _chunk7VOHOPLWcjs.DEFAULT_BRUSH; exports.DEFAULT_MIXER = _chunk7VOHOPLWcjs.DEFAULT_MIXER; exports.DEFAULT_SMUDGE = _chunk7VOHOPLWcjs.DEFAULT_SMUDGE; exports.DabWalker = _chunk7VOHOPLWcjs.DabWalker; exports.EMPTY_MIXER_LOAD = _chunk7VOHOPLWcjs.EMPTY_MIXER_LOAD; exports.MAX_BRUSH_SIZE = _chunk7VOHOPLWcjs.MAX_BRUSH_SIZE; exports.MIXER_DRAIN = _chunk7VOHOPLWcjs.MIXER_DRAIN; exports.MIXER_PICKUP_RATE = _chunk7VOHOPLWcjs.MIXER_PICKUP_RATE; exports.MIXING_MODELS = _chunk7VOHOPLWcjs.MIXING_MODELS; exports.MixerStroke = _chunk7VOHOPLWcjs.MixerStroke; exports.PIGMENT_BANDS = _chunkXIOMMGPDcjs.PIGMENT_BANDS; exports.PIGMENT_LAMBDA_MIN = _chunkXIOMMGPDcjs.PIGMENT_LAMBDA_MIN; exports.PIGMENT_LAMBDA_STEP = _chunkXIOMMGPDcjs.PIGMENT_LAMBDA_STEP; exports.PIGMENT_WAVELENGTHS = _chunkXIOMMGPDcjs.PIGMENT_WAVELENGTHS; exports.PaintExchange = _chunk7VOHOPLWcjs.PaintExchange; exports.SmudgeTip = _chunk7VOHOPLWcjs.SmudgeTip; exports.StrokeCoverage = _chunk7VOHOPLWcjs.StrokeCoverage; exports.TileMedium = _chunk7VOHOPLWcjs.TileMedium; exports.applyStrokeToTile = _chunk7VOHOPLWcjs.applyStrokeToTile; exports.blendRadius = _chunk7VOHOPLWcjs.blendRadius; exports.blenderDab = _chunk7VOHOPLWcjs.blenderDab; exports.cleanMixer = _chunk7VOHOPLWcjs.cleanMixer; exports.coverageTileCoord = _chunk7VOHOPLWcjs.coverageTileCoord; exports.createBlenderScratch = _chunk7VOHOPLWcjs.createBlenderScratch; exports.createPigment = _chunkXIOMMGPDcjs.createPigment; exports.createPigmentTools = _chunk7VOHOPLWcjs.createPigmentTools; exports.dabCoverage = _chunk7VOHOPLWcjs.dabCoverage; exports.dabRect = _chunk7VOHOPLWcjs.dabRect; exports.exchangeRates = _chunk7VOHOPLWcjs.exchangeRates; exports.lerpPigment = _chunkXIOMMGPDcjs.lerpPigment; exports.lerpPigmentInto = _chunkXIOMMGPDcjs.lerpPigmentInto; exports.loadMixer = _chunk7VOHOPLWcjs.loadMixer; exports.mixPigments = _chunkXIOMMGPDcjs.mixPigments; exports.mixerRates = _chunk7VOHOPLWcjs.mixerRates; exports.normalizeBlender = _chunk7VOHOPLWcjs.normalizeBlender; exports.normalizeBrush = _chunk7VOHOPLWcjs.normalizeBrush; exports.normalizeMixer = _chunk7VOHOPLWcjs.normalizeMixer; exports.normalizeSmudge = _chunk7VOHOPLWcjs.normalizeSmudge; exports.rasterizeDab = _chunk7VOHOPLWcjs.rasterizeDab; exports.reflectanceToRgb = _chunkXIOMMGPDcjs.reflectanceToRgb; exports.rgbToReflectance = _chunkXIOMMGPDcjs.rgbToReflectance; exports.setPigmentColor = _chunkXIOMMGPDcjs.setPigmentColor; exports.smoothPoints = _chunk7VOHOPLWcjs.smoothPoints; exports.tipFalloff = _chunk7VOHOPLWcjs.tipFalloff; exports.tipReach = _chunk7VOHOPLWcjs.tipReach; exports.tipShape = _chunk7VOHOPLWcjs.tipShape; exports.walkDabs = _chunk7VOHOPLWcjs.walkDabs;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CoverageMap = _chunk7VOHOPLWcjs.CoverageMap; exports.DEFAULT_BLENDER = _chunk7VOHOPLWcjs.DEFAULT_BLENDER; exports.DEFAULT_BRUSH = _chunk7VOHOPLWcjs.DEFAULT_BRUSH; exports.DEFAULT_MIXER = _chunk7VOHOPLWcjs.DEFAULT_MIXER; exports.DEFAULT_RETOUCH = _chunk4KLT7ZYScjs.DEFAULT_RETOUCH; exports.DEFAULT_SMUDGE = _chunk7VOHOPLWcjs.DEFAULT_SMUDGE; exports.DabWalker = _chunk7VOHOPLWcjs.DabWalker; exports.EMPTY_MIXER_LOAD = _chunk7VOHOPLWcjs.EMPTY_MIXER_LOAD; exports.MAX_BRUSH_SIZE = _chunk7VOHOPLWcjs.MAX_BRUSH_SIZE; exports.MIXER_DRAIN = _chunk7VOHOPLWcjs.MIXER_DRAIN; exports.MIXER_PICKUP_RATE = _chunk7VOHOPLWcjs.MIXER_PICKUP_RATE; exports.MIXING_MODELS = _chunk7VOHOPLWcjs.MIXING_MODELS; exports.MixerStroke = _chunk7VOHOPLWcjs.MixerStroke; exports.PIGMENT_BANDS = _chunkXIOMMGPDcjs.PIGMENT_BANDS; exports.PIGMENT_LAMBDA_MIN = _chunkXIOMMGPDcjs.PIGMENT_LAMBDA_MIN; exports.PIGMENT_LAMBDA_STEP = _chunkXIOMMGPDcjs.PIGMENT_LAMBDA_STEP; exports.PIGMENT_WAVELENGTHS = _chunkXIOMMGPDcjs.PIGMENT_WAVELENGTHS; exports.PaintExchange = _chunk7VOHOPLWcjs.PaintExchange; exports.RETOUCH_SAMPLES = _chunk4KLT7ZYScjs.RETOUCH_SAMPLES; exports.RegionPixelSource = _chunk4KLT7ZYScjs.RegionPixelSource; exports.RetouchDabStroke = _chunk4KLT7ZYScjs.RetouchDabStroke; exports.SPOT_HEAL_TYPES = _chunk4KLT7ZYScjs.SPOT_HEAL_TYPES; exports.SmudgeTip = _chunk7VOHOPLWcjs.SmudgeTip; exports.StrokeCoverage = _chunk7VOHOPLWcjs.StrokeCoverage; exports.TONE_RANGES = _chunk4KLT7ZYScjs.TONE_RANGES; exports.TileMedium = _chunk7VOHOPLWcjs.TileMedium; exports.TilePixelSource = _chunk4KLT7ZYScjs.TilePixelSource; exports.applyRetouchToTile = _chunk4KLT7ZYScjs.applyRetouchToTile; exports.applyStrokeToTile = _chunk7VOHOPLWcjs.applyStrokeToTile; exports.bestOffset = _chunk4KLT7ZYScjs.bestOffset; exports.blendRadius = _chunk7VOHOPLWcjs.blendRadius; exports.blenderDab = _chunk7VOHOPLWcjs.blenderDab; exports.cleanMixer = _chunk7VOHOPLWcjs.cleanMixer; exports.coverageTileCoord = _chunk7VOHOPLWcjs.coverageTileCoord; exports.createBlenderScratch = _chunk7VOHOPLWcjs.createBlenderScratch; exports.createPigment = _chunkXIOMMGPDcjs.createPigment; exports.createPigmentTools = _chunk7VOHOPLWcjs.createPigmentTools; exports.dabCoverage = _chunk7VOHOPLWcjs.dabCoverage; exports.dabRect = _chunk7VOHOPLWcjs.dabRect; exports.dilateMask = _chunk4KLT7ZYScjs.dilateMask; exports.dodgeBurn = _chunk4KLT7ZYScjs.dodgeBurn; exports.dodgeBurnCurve = _chunk4KLT7ZYScjs.dodgeBurnCurve; exports.exchangeRates = _chunk7VOHOPLWcjs.exchangeRates; exports.healPixels = _chunk4KLT7ZYScjs.healPixels; exports.lerpPigment = _chunkXIOMMGPDcjs.lerpPigment; exports.lerpPigmentInto = _chunkXIOMMGPDcjs.lerpPigmentInto; exports.loadMixer = _chunk7VOHOPLWcjs.loadMixer; exports.luma = _chunk4KLT7ZYScjs.luma; exports.maskBounds = _chunk4KLT7ZYScjs.maskBounds; exports.membraneFill = _chunk4KLT7ZYScjs.membraneFill; exports.mixPigments = _chunkXIOMMGPDcjs.mixPigments; exports.mixerRates = _chunk7VOHOPLWcjs.mixerRates; exports.normalizeBlender = _chunk7VOHOPLWcjs.normalizeBlender; exports.normalizeBrush = _chunk7VOHOPLWcjs.normalizeBrush; exports.normalizeMixer = _chunk7VOHOPLWcjs.normalizeMixer; exports.normalizeRetouch = _chunk4KLT7ZYScjs.normalizeRetouch; exports.normalizeSmudge = _chunk7VOHOPLWcjs.normalizeSmudge; exports.perDabStrength = _chunk4KLT7ZYScjs.perDabStrength; exports.rasterizeDab = _chunk7VOHOPLWcjs.rasterizeDab; exports.readSourceRegion = _chunk4KLT7ZYScjs.readSourceRegion; exports.reflectanceToRgb = _chunkXIOMMGPDcjs.reflectanceToRgb; exports.rgbToReflectance = _chunkXIOMMGPDcjs.rgbToReflectance; exports.rgbaViewOfGrey = _chunk4KLT7ZYScjs.rgbaViewOfGrey; exports.saturationOf = _chunk4KLT7ZYScjs.saturationOf; exports.seamlessClone = _chunk4KLT7ZYScjs.seamlessClone; exports.setPigmentColor = _chunkXIOMMGPDcjs.setPigmentColor; exports.smoothPoints = _chunk7VOHOPLWcjs.smoothPoints; exports.smudgeEffect = _chunk4KLT7ZYScjs.smudgeEffect; exports.solveMembrane = _chunk4KLT7ZYScjs.solveMembrane; exports.sponge = _chunk4KLT7ZYScjs.sponge; exports.spongeEffect = _chunk4KLT7ZYScjs.spongeEffect; exports.spotHealPixels = _chunk4KLT7ZYScjs.spotHealPixels; exports.spotHealWindow = _chunk4KLT7ZYScjs.spotHealWindow; exports.tipFalloff = _chunk7VOHOPLWcjs.tipFalloff; exports.tipReach = _chunk7VOHOPLWcjs.tipReach; exports.tipShape = _chunk7VOHOPLWcjs.tipShape; exports.toneOf = _chunk4KLT7ZYScjs.toneOf; exports.walkDabs = _chunk7VOHOPLWcjs.walkDabs;
 //# sourceMappingURL=index.cjs.map

package/dist/paint/index.cjs.map

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

package/dist/paint/index.d.cts

@@ -1,4 +1,4 @@
-export { j as BlenderScratch, b as BlenderSettings, B as BrushSettings, C as CoverageMap, k as DEFAULT_BLENDER, l as DEFAULT_BRUSH, m as DEFAULT_MIXER, n as DEFAULT_SMUDGE, D as Dab, o as DabWalker, E as EMPTY_MIXER_LOAD, p as ExchangeRates, e as MAX_BRUSH_SIZE, q as MIXER_DRAIN, r as MIXER_PICKUP_RATE, s as MIXING_MODELS, d as MixerLoad, M as MixerSettings, h as MixerStroke, g as MixerTarget, a as MixingModel, t as PaintExchange, u as PaintMedium, v as PaintSample, P as PaintTileTarget, R as RgbTriple, w as SmudgeDab, S as SmudgeSettings, x as SmudgeTip, i as StrokeApply, f as StrokeCoverage, c as StrokePoint, T as TileMedium, y as TileMediumOptions, z as applyStrokeToTile, A as blendRadius, F as blenderDab, G as cleanMixer, H as coverageTileCoord, I as createBlenderScratch, J as dabCoverage, K as dabRect, L as exchangeRates, N as loadMixer, O as mixerRates, Q as normalizeBlender, U as normalizeBrush, V as normalizeMixer, W as normalizeSmudge, X as rasterizeDab, Y as smoothPoints, Z as tipFalloff, _ as tipReach, $ as tipShape, a0 as walkDabs } from '../blending-aOE6Y3UE.cjs';
+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-CEIKR22W.cjs';
 export { h as PIGMENT_BANDS, j as PIGMENT_LAMBDA_MIN, k as PIGMENT_LAMBDA_STEP, l as PIGMENT_WAVELENGTHS, P as Pigment, m as PigmentOptions, n as PigmentRgb, D as createPigment, I as lerpPigment, J as lerpPigmentInto, N as mixPigments, X as reflectanceToRgb, Y as rgbToReflectance, _ as setPigmentColor } from '../surface-C8RRg_Bh.cjs';
 import { A as AgentTool } from '../registry-BqA1AZt0.cjs';
 import '../schema-Di0CS6Pe.cjs';
@@ -9,4 +9,31 @@ import '../schema-Di0CS6Pe.cjs';
  */
 declare function createPigmentTools(): AgentTool[];
 
-export { createPigmentTools };
+/**
+ * Solves `Δv = 0` on the `unknown` pixels, with the known pixels of `v` as Dirichlet values
+ * (neighbours off the grid are ignored: a free boundary). `v` holds the known values on entry and
+ * the solution on exit.
+ */
+declare function solveMembrane(w: number, h: number, unknown: ArrayLike<boolean | number>, v: Float32Array): void;
+/**
+ * Seamless cloning: `dst` outside `mask`; inside, `src` plus the membrane that removes the
+ * mismatch at the mask's edge. So the result keeps the source's texture and takes the
+ * destination's colour and light. `src` and `dst` are interleaved `w × h × ch`; leave a one-pixel
+ * unmasked margin for a fully fixed boundary.
+ */
+declare function seamlessClone(w: number, h: number, ch: number, src: ArrayLike<number>, dst: ArrayLike<number>, mask: ArrayLike<boolean | number>): Float32Array;
+/** Membrane fill (no source texture): the known pixels interpolated smoothly into `hole`. */
+declare function membraneFill(w: number, h: number, ch: number, img: ArrayLike<number>, hole: ArrayLike<boolean | number>): Float32Array;
+/** A mask grown by `r` pixels (square structuring element). */
+declare function dilateMask(w: number, h: number, mask: ArrayLike<boolean | number>, r: number): Uint8Array;
+/** Bounding box [x0, y0, x1, y1) of the set cells, or null. */
+declare function maskBounds(w: number, h: number, mask: ArrayLike<boolean | number>): [number, number, number, number] | null;
+/**
+ * Proximity match: the translation `(dx, dy)` (within `maxRadius`) whose pixels best match the
+ * ring of `ring` pixels around the hole (sum of squared differences), so `img[p + (dx, dy)]` can
+ * fill `p` in the hole. The source window must lie on the grid and hold no hole pixels. Nearer
+ * sources win ties. Returns null when no translation fits.
+ */
+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 };

package/dist/paint/index.d.ts

@@ -1,4 +1,4 @@
-export { j as BlenderScratch, b as BlenderSettings, B as BrushSettings, C as CoverageMap, k as DEFAULT_BLENDER, l as DEFAULT_BRUSH, m as DEFAULT_MIXER, n as DEFAULT_SMUDGE, D as Dab, o as DabWalker, E as EMPTY_MIXER_LOAD, p as ExchangeRates, e as MAX_BRUSH_SIZE, q as MIXER_DRAIN, r as MIXER_PICKUP_RATE, s as MIXING_MODELS, d as MixerLoad, M as MixerSettings, h as MixerStroke, g as MixerTarget, a as MixingModel, t as PaintExchange, u as PaintMedium, v as PaintSample, P as PaintTileTarget, R as RgbTriple, w as SmudgeDab, S as SmudgeSettings, x as SmudgeTip, i as StrokeApply, f as StrokeCoverage, c as StrokePoint, T as TileMedium, y as TileMediumOptions, z as applyStrokeToTile, A as blendRadius, F as blenderDab, G as cleanMixer, H as coverageTileCoord, I as createBlenderScratch, J as dabCoverage, K as dabRect, L as exchangeRates, N as loadMixer, O as mixerRates, Q as normalizeBlender, U as normalizeBrush, V as normalizeMixer, W as normalizeSmudge, X as rasterizeDab, Y as smoothPoints, Z as tipFalloff, _ as tipReach, $ as tipShape, a0 as walkDabs } from '../blending-DXl06NSx.js';
+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-BXmeSCaB.js';
 export { h as PIGMENT_BANDS, j as PIGMENT_LAMBDA_MIN, k as PIGMENT_LAMBDA_STEP, l as PIGMENT_WAVELENGTHS, P as Pigment, m as PigmentOptions, n as PigmentRgb, D as createPigment, I as lerpPigment, J as lerpPigmentInto, N as mixPigments, X as reflectanceToRgb, Y as rgbToReflectance, _ as setPigmentColor } from '../surface-C8RRg_Bh.js';
 import { A as AgentTool } from '../registry-D-4fit9C.js';
 import '../schema-Di0CS6Pe.js';
@@ -9,4 +9,31 @@ import '../schema-Di0CS6Pe.js';
  */
 declare function createPigmentTools(): AgentTool[];
 
-export { createPigmentTools };
+/**
+ * Solves `Δv = 0` on the `unknown` pixels, with the known pixels of `v` as Dirichlet values
+ * (neighbours off the grid are ignored: a free boundary). `v` holds the known values on entry and
+ * the solution on exit.
+ */
+declare function solveMembrane(w: number, h: number, unknown: ArrayLike<boolean | number>, v: Float32Array): void;
+/**
+ * Seamless cloning: `dst` outside `mask`; inside, `src` plus the membrane that removes the
+ * mismatch at the mask's edge. So the result keeps the source's texture and takes the
+ * destination's colour and light. `src` and `dst` are interleaved `w × h × ch`; leave a one-pixel
+ * unmasked margin for a fully fixed boundary.
+ */
+declare function seamlessClone(w: number, h: number, ch: number, src: ArrayLike<number>, dst: ArrayLike<number>, mask: ArrayLike<boolean | number>): Float32Array;
+/** Membrane fill (no source texture): the known pixels interpolated smoothly into `hole`. */
+declare function membraneFill(w: number, h: number, ch: number, img: ArrayLike<number>, hole: ArrayLike<boolean | number>): Float32Array;
+/** A mask grown by `r` pixels (square structuring element). */
+declare function dilateMask(w: number, h: number, mask: ArrayLike<boolean | number>, r: number): Uint8Array;
+/** Bounding box [x0, y0, x1, y1) of the set cells, or null. */
+declare function maskBounds(w: number, h: number, mask: ArrayLike<boolean | number>): [number, number, number, number] | null;
+/**
+ * Proximity match: the translation `(dx, dy)` (within `maxRadius`) whose pixels best match the
+ * ring of `ring` pixels around the hole (sum of squared differences), so `img[p + (dx, dy)]` can
+ * fill `p` in the hole. The source window must lie on the grid and hold no hole pixels. Nearer
+ * sources win ties. Returns null when no translation fits.
+ */
+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 };

package/dist/paint/index.js

@@ -1,4 +1,34 @@
-import "../chunk-VKK5VS2T.js";
+import {
+  DEFAULT_RETOUCH,
+  RETOUCH_SAMPLES,
+  RegionPixelSource,
+  RetouchDabStroke,
+  SPOT_HEAL_TYPES,
+  TONE_RANGES,
+  TilePixelSource,
+  applyRetouchToTile,
+  bestOffset,
+  dilateMask,
+  dodgeBurn,
+  dodgeBurnCurve,
+  healPixels,
+  luma,
+  maskBounds,
+  membraneFill,
+  normalizeRetouch,
+  perDabStrength,
+  readSourceRegion,
+  rgbaViewOfGrey,
+  saturationOf,
+  seamlessClone,
+  smudgeEffect,
+  solveMembrane,
+  sponge,
+  spongeEffect,
+  spotHealPixels,
+  spotHealWindow,
+  toneOf
+} from "../chunk-LPYOIVLA.js";
 import {
   CoverageMap,
   DEFAULT_BLENDER,
@@ -57,6 +87,7 @@ export {
   DEFAULT_BLENDER,
   DEFAULT_BRUSH,
   DEFAULT_MIXER,
+  DEFAULT_RETOUCH,
   DEFAULT_SMUDGE,
   DabWalker,
   EMPTY_MIXER_LOAD,
@@ -70,10 +101,18 @@ export {
   PIGMENT_LAMBDA_STEP,
   PIGMENT_WAVELENGTHS,
   PaintExchange,
+  RETOUCH_SAMPLES,
+  RegionPixelSource,
+  RetouchDabStroke,
+  SPOT_HEAL_TYPES,
   SmudgeTip,
   StrokeCoverage,
+  TONE_RANGES,
   TileMedium,
+  TilePixelSource,
+  applyRetouchToTile,
   applyStrokeToTile,
+  bestOffset,
   blendRadius,
   blenderDab,
   cleanMixer,
@@ -83,24 +122,44 @@ export {
   createPigmentTools,
   dabCoverage,
   dabRect,
+  dilateMask,
+  dodgeBurn,
+  dodgeBurnCurve,
   exchangeRates,
+  healPixels,
   lerpPigment,
   lerpPigmentInto,
   loadMixer,
+  luma,
+  maskBounds,
+  membraneFill,
   mixPigments,
   mixerRates,
   normalizeBlender,
   normalizeBrush,
   normalizeMixer,
+  normalizeRetouch,
   normalizeSmudge,
+  perDabStrength,
   rasterizeDab,
+  readSourceRegion,
   reflectanceToRgb,
   rgbToReflectance,
+  rgbaViewOfGrey,
+  saturationOf,
+  seamlessClone,
   setPigmentColor,
   smoothPoints,
+  smudgeEffect,
+  solveMembrane,
+  sponge,
+  spongeEffect,
+  spotHealPixels,
+  spotHealWindow,
   tipFalloff,
   tipReach,
   tipShape,
+  toneOf,
   walkDabs
 };
 //# sourceMappingURL=index.js.map

package/dist/paint-editor/index.cjs

@@ -4,7 +4,7 @@
 
 
 
-var _chunkPHUMLSCWcjs = require('../chunk-PHUMLSCW.cjs');
+var _chunkYGIMK4NXcjs = require('../chunk-YGIMK4NX.cjs');
 
 
 
@@ -1697,11 +1697,11 @@ function header(state, options) {
   return out;
 }
 function serializePaintDocument(state, options = {}) {
-  const { layers, assets } = _chunkPHUMLSCWcjs.serializeLayers.call(void 0, state.layers);
+  const { layers, assets } = _chunkYGIMK4NXcjs.serializeLayers.call(void 0, state.layers);
   return { ...header(state, options), layers, assets };
 }
 async function serializePaintDocumentExternal(state, store, options = {}) {
-  const { layers, assets } = await _chunkPHUMLSCWcjs.serializeLayersExternal.call(void 0, state.layers, store);
+  const { layers, assets } = await _chunkYGIMK4NXcjs.serializeLayersExternal.call(void 0, state.layers, store);
   return { ...header(state, options), layers, assets };
 }
 function paintLayersOnly(layers, problems) {
@@ -1738,7 +1738,7 @@ function deserializePaintDocument(raw) {
   const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
   const paper = normalizePaper(_nullishCoalesce(r.paper, () => ( {})));
   const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
-  const layers = paintLayersOnly(_chunkPHUMLSCWcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const layers = paintLayersOnly(_chunkYGIMK4NXcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
   const activeLayerId = wanted && _chunkPOGBUYWEcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkPOGBUYWEcjs.flattenLayers.call(void 0, layers), 'access', _33 => _33.filter, 'call', _34 => _34((l) => l.type === "pixel"), 'access', _35 => _35.pop, 'call', _36 => _36(), 'optionalAccess', _37 => _37.id]), () => ( null));
   return { state: { canvas, paper, layers, activeLayerId, strokes: readStrokes(r.strokes, problems) }, extensions: documentExtensions(r), guides: r.guides, swatches: r.swatches, mixingPad: r.mixingPad, problems };
@@ -1747,7 +1747,7 @@ async function deserializePaintDocumentAsync(raw, store) {
   if (!raw || typeof raw !== "object") throw new Error("Not a paint document: expected a JSON object.");
   const r = raw;
   const problems = [];
-  const assets = await _chunkPHUMLSCWcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const assets = await _chunkYGIMK4NXcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
   const loaded = deserializePaintDocument({ ...r, assets });
   return { ...loaded, problems: [...problems, ...loaded.problems] };
 }
@@ -3420,7 +3420,7 @@ var PaintEditorController = (_class10 = class {
       return next.type === "group" ? { ...next, children: toStandard(next.children) } : next;
     });
     const layers = toStandard(this.doc.layers);
-    const result = _chunkPHUMLSCWcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
+    const result = _chunkYGIMK4NXcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
       const label = _nullishCoalesce(_optionalChain([_chunkXIOMMGPDcjs.BLEND_MODES, 'access', _81 => _81.find, 'call', _82 => _82((m) => m.id === mode), 'optionalAccess', _83 => _83.label]), () => ( mode));
       const std = _nullishCoalesce(_optionalChain([_chunkXIOMMGPDcjs.BLEND_MODES, 'access', _84 => _84.find, 'call', _85 => _85((m) => m.id === _chunkXIOMMGPDcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _86 => _86.label]), () => ( _chunkXIOMMGPDcjs.standardBlendMode.call(void 0, mode)));

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

@@ -1,9 +1,9 @@
 import { R as RasterLayer, a as RasterGroupLayer, b as RasterPixelLayer, C as CompositorLayer, c as RasterCompositor, d as RasterSources, L as LayerLocks } from '../render-BEriFuqK.cjs';
-import { B as BrushSettings, M as MixerSettings, a as MixingModel, b as BlenderSettings, S as SmudgeSettings, C as CoverageMap, D as Dab, c as StrokePoint, d as MixerLoad, P as PaintTileTarget, R as RgbTriple } from '../blending-aOE6Y3UE.cjs';
-export { e as MAX_BRUSH_SIZE } from '../blending-aOE6Y3UE.cjs';
+import { B as BrushSettings, M as MixerSettings, a as MixingModel, b as BlenderSettings, S as SmudgeSettings, C as CoverageMap, D as Dab, c as StrokePoint, d as MixerLoad, P as PaintTileTarget, R as RgbTriple } from '../retouch-CEIKR22W.cjs';
+export { e as MAX_BRUSH_SIZE } from '../retouch-CEIKR22W.cjs';
 import { R as RasterRect, a as TiledSurface, B as BlendMode, c as BlendModeInfo } from '../surface-C8RRg_Bh.cjs';
 export { d as BLEND_MODES, e as PAINTERLY_BLEND_MODES, f as Tile, i as isBlendMode, g as isPainterlyBlendMode, s as standardBlendMode } from '../surface-C8RRg_Bh.cjs';
-import { I as ImageEditorAssetStore, S as SerializedLayer, P as PsdExportResult } from '../export-DoDhCszr.cjs';
+import { I as ImageEditorAssetStore, S as SerializedLayer, P as PsdExportResult } from '../export-CEXEzqBf.cjs';
 import { g as PresenceStore, e as PresenceClock, d as PresenceActorInfo, c as PresenceActor, f as PresenceState } from '../presence-Cb6WhcrQ.cjs';
 import { a as AgentToolProvider } from '../registry-BqA1AZt0.cjs';
 import '../types-CwMPoRMU.cjs';

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

@@ -1,9 +1,9 @@
 import { R as RasterLayer, a as RasterGroupLayer, b as RasterPixelLayer, C as CompositorLayer, c as RasterCompositor, d as RasterSources, L as LayerLocks } from '../render-tjzKaik-.js';
-import { B as BrushSettings, M as MixerSettings, a as MixingModel, b as BlenderSettings, S as SmudgeSettings, C as CoverageMap, D as Dab, c as StrokePoint, d as MixerLoad, P as PaintTileTarget, R as RgbTriple } from '../blending-DXl06NSx.js';
-export { e as MAX_BRUSH_SIZE } from '../blending-DXl06NSx.js';
+import { B as BrushSettings, M as MixerSettings, a as MixingModel, b as BlenderSettings, S as SmudgeSettings, C as CoverageMap, D as Dab, c as StrokePoint, d as MixerLoad, P as PaintTileTarget, R as RgbTriple } from '../retouch-BXmeSCaB.js';
+export { e as MAX_BRUSH_SIZE } from '../retouch-BXmeSCaB.js';
 import { R as RasterRect, a as TiledSurface, B as BlendMode, c as BlendModeInfo } from '../surface-C8RRg_Bh.js';
 export { d as BLEND_MODES, e as PAINTERLY_BLEND_MODES, f as Tile, i as isBlendMode, g as isPainterlyBlendMode, s as standardBlendMode } from '../surface-C8RRg_Bh.js';
-import { I as ImageEditorAssetStore, S as SerializedLayer, P as PsdExportResult } from '../export-DBNVwb6h.js';
+import { I as ImageEditorAssetStore, S as SerializedLayer, P as PsdExportResult } from '../export-DIkoK8-r.js';
 import { g as PresenceStore, e as PresenceClock, d as PresenceActorInfo, c as PresenceActor, f as PresenceState } from '../presence-Cb6WhcrQ.js';
 import { a as AgentToolProvider } from '../registry-D-4fit9C.js';
 import '../types-CwMPoRMU.js';

package/dist/paint-editor/index.js

@@ -4,7 +4,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-HHZ6ZJTW.js";
+} from "../chunk-CZOXTEMN.js";
 import {
   RasterCompositor,
   base64ToBytes,

package/dist/{blending-DXl06NSx.d.ts → retouch-BXmeSCaB.d.ts}

@@ -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 };