@pixerate/editor 0.272.1 → 0.273.0

package/dist/chunk-YH6SKC7P.cjs

@@ -0,0 +1,557 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/raster/fill.ts
+var INF = 1e12;
+function squaredDistanceTransform(binary, w, h) {
+  const n = w * h;
+  const dist = new Float64Array(n);
+  let hasZero = false;
+  for (let i = 0; i < n; i++) {
+    if (binary[i] === 0) {
+      dist[i] = 0;
+      hasZero = true;
+    } else {
+      dist[i] = INF;
+    }
+  }
+  if (!hasZero) return dist;
+  const maxDim = Math.max(w, h);
+  const f = new Float64Array(maxDim);
+  const d = new Float64Array(maxDim);
+  const v = new Int32Array(maxDim);
+  const z = new Float64Array(maxDim + 1);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) f[y] = dist[y * w + x];
+    edt1d(f, d, v, z, h);
+    for (let y = 0; y < h; y++) dist[y * w + x] = d[y];
+  }
+  for (let y = 0; y < h; y++) {
+    const row = y * w;
+    for (let x = 0; x < w; x++) f[x] = dist[row + x];
+    edt1d(f, d, v, z, w);
+    for (let x = 0; x < w; x++) dist[row + x] = d[x];
+  }
+  return dist;
+}
+function edt1d(f, d, v, z, n) {
+  let k = 0;
+  v[0] = 0;
+  z[0] = -INF;
+  z[1] = INF;
+  for (let q = 1; q < n; q++) {
+    const fq = f[q] + q * q;
+    let s = (fq - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);
+    while (s <= z[k]) {
+      k--;
+      s = (fq - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);
+    }
+    k++;
+    v[k] = q;
+    z[k] = s;
+    z[k + 1] = INF;
+  }
+  k = 0;
+  for (let q = 0; q < n; q++) {
+    while (z[k + 1] < q) k++;
+    const dx = q - v[k];
+    d[q] = dx * dx + f[v[k]];
+  }
+}
+function pixelMatches(data, p, sr, sg, sb, sa, tol) {
+  const a = data[p + 3];
+  if (sa === 0 && a === 0) return true;
+  return Math.abs(data[p] - sr) <= tol && Math.abs(data[p + 1] - sg) <= tol && Math.abs(data[p + 2] - sb) <= tol && Math.abs(a - sa) <= tol;
+}
+function floodOneSeed(reference, w, h, sx, sy, tol, closeGap, expand, queue) {
+  const n = w * h;
+  const marks = new Uint8Array(n);
+  if (sx < 0 || sy < 0 || sx >= w || sy >= h) return marks;
+  const sp = (sy * w + sx) * 4;
+  const sr = reference[sp];
+  const sg = reference[sp + 1];
+  const sb = reference[sp + 2];
+  const sa = reference[sp + 3];
+  const open = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    if (pixelMatches(reference, i * 4, sr, sg, sb, sa, tol)) open[i] = 1;
+  }
+  const start = sy * w + sx;
+  open[start] = 1;
+  if (closeGap <= 0) {
+    let head = 0;
+    let tail = 0;
+    marks[start] = 1;
+    queue[tail++] = start;
+    while (head < tail) {
+      const cur = queue[head++];
+      const cx = cur % w;
+      const cy = (cur - cx) / w;
+      if (cx > 0) {
+        const nb = cur - 1;
+        if (open[nb] === 1 && marks[nb] === 0) {
+          marks[nb] = 1;
+          queue[tail++] = nb;
+        }
+      }
+      if (cx + 1 < w) {
+        const nb = cur + 1;
+        if (open[nb] === 1 && marks[nb] === 0) {
+          marks[nb] = 1;
+          queue[tail++] = nb;
+        }
+      }
+      if (cy > 0) {
+        const nb = cur - w;
+        if (open[nb] === 1 && marks[nb] === 0) {
+          marks[nb] = 1;
+          queue[tail++] = nb;
+        }
+      }
+      if (cy + 1 < h) {
+        const nb = cur + w;
+        if (open[nb] === 1 && marks[nb] === 0) {
+          marks[nb] = 1;
+          queue[tail++] = nb;
+        }
+      }
+    }
+  } else {
+    const distSq = squaredDistanceTransform(open, w, h);
+    const r = (closeGap + 1) * 0.5;
+    const rSq = r * r;
+    const maxClimb = Math.ceil(r) + 2;
+    let coreSeed = start;
+    let head = 0;
+    let tail = 0;
+    marks[start] = 1;
+    queue[tail++] = start;
+    for (let step = 0; step < maxClimb && distSq[coreSeed] <= rSq; step++) {
+      const cx = coreSeed % w;
+      const cy = (coreSeed - cx) / w;
+      let best = coreSeed;
+      let bestD = distSq[coreSeed];
+      if (cx > 0 && open[coreSeed - 1] === 1 && distSq[coreSeed - 1] > bestD) {
+        best = coreSeed - 1;
+        bestD = distSq[best];
+      }
+      if (cx + 1 < w && open[coreSeed + 1] === 1 && distSq[coreSeed + 1] > bestD) {
+        best = coreSeed + 1;
+        bestD = distSq[best];
+      }
+      if (cy > 0 && open[coreSeed - w] === 1 && distSq[coreSeed - w] > bestD) {
+        best = coreSeed - w;
+        bestD = distSq[best];
+      }
+      if (cy + 1 < h && open[coreSeed + w] === 1 && distSq[coreSeed + w] > bestD) {
+        best = coreSeed + w;
+        bestD = distSq[best];
+      }
+      if (best === coreSeed) break;
+      coreSeed = best;
+      if (marks[coreSeed] === 0) {
+        marks[coreSeed] = 1;
+        queue[tail++] = coreSeed;
+      }
+    }
+    if (distSq[coreSeed] > rSq) {
+      let scan = 0;
+      while (scan < tail) {
+        const cur = queue[scan++];
+        if (distSq[cur] <= rSq) continue;
+        const cx = cur % w;
+        const cy = (cur - cx) / w;
+        if (cx > 0) {
+          const nb = cur - 1;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] > rSq) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+        if (cx + 1 < w) {
+          const nb = cur + 1;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] > rSq) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+        if (cy > 0) {
+          const nb = cur - w;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] > rSq) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+        if (cy + 1 < h) {
+          const nb = cur + w;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] > rSq) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+      }
+      while (head < tail) {
+        const cur = queue[head++];
+        const curD = distSq[cur];
+        const cx = cur % w;
+        const cy = (cur - cx) / w;
+        if (cx > 0) {
+          const nb = cur - 1;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] <= rSq && distSq[nb] <= curD) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+        if (cx + 1 < w) {
+          const nb = cur + 1;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] <= rSq && distSq[nb] <= curD) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+        if (cy > 0) {
+          const nb = cur - w;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] <= rSq && distSq[nb] <= curD) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+        if (cy + 1 < h) {
+          const nb = cur + w;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] <= rSq && distSq[nb] <= curD) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+      }
+    } else {
+      const maxLocal = Math.max(64, closeGap * closeGap * 8);
+      while (head < tail && tail < maxLocal) {
+        const cur = queue[head++];
+        const cx = cur % w;
+        const cy = (cur - cx) / w;
+        if (cx > 0) {
+          const nb = cur - 1;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] <= rSq) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+        if (cx + 1 < w) {
+          const nb = cur + 1;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] <= rSq) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+        if (cy > 0) {
+          const nb = cur - w;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] <= rSq) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+        if (cy + 1 < h) {
+          const nb = cur + w;
+          if (open[nb] === 1 && marks[nb] === 0 && distSq[nb] <= rSq) {
+            marks[nb] = 1;
+            queue[tail++] = nb;
+          }
+        }
+      }
+    }
+  }
+  if (expand !== 0) {
+    let any = false;
+    for (let i = 0; i < n; i++) {
+      if (marks[i] === 1) {
+        any = true;
+        break;
+      }
+    }
+    if (any) {
+      const expSq = expand * expand;
+      if (expand > 0) {
+        const inv = new Uint8Array(n);
+        for (let i = 0; i < n; i++) inv[i] = marks[i] === 1 ? 0 : 1;
+        const dSq = squaredDistanceTransform(inv, w, h);
+        for (let i = 0; i < n; i++) marks[i] = dSq[i] <= expSq ? 1 : 0;
+      } else {
+        const dSq = squaredDistanceTransform(marks, w, h);
+        for (let i = 0; i < n; i++) marks[i] = dSq[i] > expSq ? 1 : 0;
+      }
+    }
+  }
+  return marks;
+}
+function summarizeMarks(marks, w, h) {
+  let minX = w;
+  let minY = h;
+  let maxX = -1;
+  let maxY = -1;
+  let pixelCount = 0;
+  let leaked = false;
+  for (let y = 0; y < h; y++) {
+    const row = y * w;
+    for (let x = 0; x < w; x++) {
+      if (marks[row + x] === 1) {
+        pixelCount++;
+        if (x < minX) minX = x;
+        if (y < minY) minY = y;
+        if (x > maxX) maxX = x;
+        if (y > maxY) maxY = y;
+        if (x === 0 || y === 0 || x === w - 1 || y === h - 1) leaked = true;
+      }
+    }
+  }
+  const bounds = pixelCount > 0 ? { x: minX, y: minY, width: maxX - minX + 1, height: maxY - minY + 1 } : null;
+  return { bounds, pixelCount, leaked };
+}
+function fillRegionMask(reference, width, height, options) {
+  const n = width * height;
+  const tol = Math.max(0, Math.min(255, _nullishCoalesce(options.tolerance, () => ( 32))));
+  const closeGap = Math.max(0, Math.min(32, _nullishCoalesce(options.closeGap, () => ( 0))));
+  const expand = Math.max(-16, Math.min(16, _nullishCoalesce(options.expand, () => ( 0))));
+  const antialias = _nullishCoalesce(options.antialias, () => ( true));
+  const combined = new Uint8Array(n);
+  const queue = new Int32Array(n);
+  const regions = [];
+  for (const pt of options.points) {
+    const sx = Math.floor(pt.x);
+    const sy = Math.floor(pt.y);
+    const seedMarks = floodOneSeed(reference, width, height, sx, sy, tol, closeGap, expand, queue);
+    const summary = summarizeMarks(seedMarks, width, height);
+    regions.push({
+      point: { x: pt.x, y: pt.y },
+      bounds: summary.bounds,
+      pixelCount: summary.pixelCount,
+      leaked: summary.leaked
+    });
+    for (let i = 0; i < n; i++) {
+      if (seedMarks[i] === 1) combined[i] = 1;
+    }
+  }
+  const total = summarizeMarks(combined, width, height);
+  const mask = new Float32Array(n);
+  if (total.bounds) {
+    const x0 = total.bounds.x;
+    const y0 = total.bounds.y;
+    const x1 = x0 + total.bounds.width;
+    const y1 = y0 + total.bounds.height;
+    for (let y = y0; y < y1; y++) {
+      const row = y * width;
+      for (let x = x0; x < x1; x++) {
+        const idx = row + x;
+        if (combined[idx] !== 1) continue;
+        if (!antialias) {
+          mask[idx] = 1;
+          continue;
+        }
+        let sum = 0;
+        let edge = false;
+        for (let dy = -1; dy <= 1; dy++) {
+          const ny = y + dy;
+          for (let dx = -1; dx <= 1; dx++) {
+            const nx = x + dx;
+            const v = nx < 0 || ny < 0 || nx >= width || ny >= height ? 1 : combined[ny * width + nx];
+            if (v === 0) edge = true;
+            sum += v;
+          }
+        }
+        mask[idx] = edge ? 0.5 + 0.5 * (sum / 9) : 1;
+      }
+    }
+  }
+  return {
+    mask,
+    bounds: total.bounds,
+    pixelCount: total.pixelCount,
+    leaked: total.leaked,
+    regions
+  };
+}
+function findUnfilledRegionsMask(reference, width, height, options = {}) {
+  const n = width * height;
+  if (n <= 0) return [];
+  const tol = Math.max(0, Math.min(255, _nullishCoalesce(options.tolerance, () => ( 32))));
+  const closeGap = Math.max(0, Math.min(32, _nullishCoalesce(options.closeGap, () => ( 0))));
+  const minArea = Math.max(1, Math.floor(_nullishCoalesce(options.minArea, () => ( 16))));
+  const includeEdge = _nullishCoalesce(options.includeEdge, () => ( false));
+  const maxRegions = Math.max(1, Math.floor(_nullishCoalesce(options.maxRegions, () => ( 100))));
+  const target = options.target;
+  let hasTransparent = false;
+  for (let i = 0; i < n; i++) {
+    if (reference[i * 4 + 3] <= tol) {
+      hasTransparent = true;
+      break;
+    }
+  }
+  const br = reference[0];
+  const bg = reference[1];
+  const bb = reference[2];
+  const ba = reference[3];
+  const openRef = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    const isRefOpen = hasTransparent ? reference[p + 3] <= tol : pixelMatches(reference, p, br, bg, bb, ba, tol);
+    if (isRefOpen) openRef[i] = 1;
+  }
+  const unfilled = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    if (openRef[i] === 1 && (!target || target[i * 4 + 3] <= tol)) {
+      unfilled[i] = 1;
+    }
+  }
+  const distSq = squaredDistanceTransform(openRef, width, height);
+  const r = closeGap > 0 ? (closeGap + 1) * 0.5 : 0;
+  const rSq = r * r;
+  const labels = new Int32Array(n);
+  const queue = new Int32Array(n);
+  let nextLabel = 0;
+  let coreTail = 0;
+  for (let i = 0; i < n; i++) {
+    if (unfilled[i] !== 1 || labels[i] !== 0 || distSq[i] <= rSq) continue;
+    const label = ++nextLabel;
+    labels[i] = label;
+    let head = coreTail;
+    queue[coreTail++] = i;
+    while (head < coreTail) {
+      const cur = queue[head++];
+      const cx = cur % width;
+      const cy = (cur - cx) / width;
+      if (cx > 0) {
+        const nb = cur - 1;
+        if (unfilled[nb] === 1 && labels[nb] === 0 && distSq[nb] > rSq) {
+          labels[nb] = label;
+          queue[coreTail++] = nb;
+        }
+      }
+      if (cx + 1 < width) {
+        const nb = cur + 1;
+        if (unfilled[nb] === 1 && labels[nb] === 0 && distSq[nb] > rSq) {
+          labels[nb] = label;
+          queue[coreTail++] = nb;
+        }
+      }
+      if (cy > 0) {
+        const nb = cur - width;
+        if (unfilled[nb] === 1 && labels[nb] === 0 && distSq[nb] > rSq) {
+          labels[nb] = label;
+          queue[coreTail++] = nb;
+        }
+      }
+      if (cy + 1 < height) {
+        const nb = cur + width;
+        if (unfilled[nb] === 1 && labels[nb] === 0 && distSq[nb] > rSq) {
+          labels[nb] = label;
+          queue[coreTail++] = nb;
+        }
+      }
+    }
+  }
+  if (closeGap > 0 && nextLabel > 0) {
+    let head = 0;
+    let tail = coreTail;
+    while (head < tail) {
+      const cur = queue[head++];
+      const label = labels[cur];
+      const curD = distSq[cur];
+      const cx = cur % width;
+      const cy = (cur - cx) / width;
+      if (cx > 0) {
+        const nb = cur - 1;
+        if (unfilled[nb] === 1 && labels[nb] === 0 && distSq[nb] <= rSq && distSq[nb] <= curD) {
+          labels[nb] = label;
+          queue[tail++] = nb;
+        }
+      }
+      if (cx + 1 < width) {
+        const nb = cur + 1;
+        if (unfilled[nb] === 1 && labels[nb] === 0 && distSq[nb] <= rSq && distSq[nb] <= curD) {
+          labels[nb] = label;
+          queue[tail++] = nb;
+        }
+      }
+      if (cy > 0) {
+        const nb = cur - width;
+        if (unfilled[nb] === 1 && labels[nb] === 0 && distSq[nb] <= rSq && distSq[nb] <= curD) {
+          labels[nb] = label;
+          queue[tail++] = nb;
+        }
+      }
+      if (cy + 1 < height) {
+        const nb = cur + width;
+        if (unfilled[nb] === 1 && labels[nb] === 0 && distSq[nb] <= rSq && distSq[nb] <= curD) {
+          labels[nb] = label;
+          queue[tail++] = nb;
+        }
+      }
+    }
+  }
+  if (nextLabel === 0) return [];
+  const counts = new Int32Array(nextLabel + 1);
+  const sumX = new Float64Array(nextLabel + 1);
+  const sumY = new Float64Array(nextLabel + 1);
+  const minX = new Int32Array(nextLabel + 1).fill(width);
+  const minY = new Int32Array(nextLabel + 1).fill(height);
+  const maxX = new Int32Array(nextLabel + 1).fill(-1);
+  const maxY = new Int32Array(nextLabel + 1).fill(-1);
+  const edge = new Uint8Array(nextLabel + 1);
+  const bestIdx = new Int32Array(nextLabel + 1).fill(-1);
+  const bestDist = new Float64Array(nextLabel + 1).fill(-1);
+  for (let y = 0; y < height; y++) {
+    const row = y * width;
+    for (let x = 0; x < width; x++) {
+      const idx = row + x;
+      const l = labels[idx];
+      if (l === 0) continue;
+      counts[l]++;
+      sumX[l] += x;
+      sumY[l] += y;
+      if (x < minX[l]) minX[l] = x;
+      if (y < minY[l]) minY[l] = y;
+      if (x > maxX[l]) maxX[l] = x;
+      if (y > maxY[l]) maxY[l] = y;
+      if (x === 0 || y === 0 || x === width - 1 || y === height - 1) edge[l] = 1;
+      const d = distSq[idx];
+      if (d > bestDist[l]) {
+        bestDist[l] = d;
+        bestIdx[l] = idx;
+      }
+    }
+  }
+  const out = [];
+  for (let l = 1; l <= nextLabel; l++) {
+    const count = counts[l];
+    if (count < minArea) continue;
+    const touchesEdge = edge[l] === 1;
+    if (!includeEdge && touchesEdge) continue;
+    const cx = Math.round(sumX[l] / count);
+    const cy = Math.round(sumY[l] / count);
+    const cIdx = cy * width + cx;
+    let px = cx;
+    let py = cy;
+    if (cx < 0 || cy < 0 || cx >= width || cy >= height || labels[cIdx] !== l || distSq[cIdx] <= rSq) {
+      const bi = bestIdx[l];
+      px = bi % width;
+      py = (bi - px) / width;
+    }
+    out.push({
+      point: { x: px, y: py },
+      centroid: { x: cx, y: cy },
+      bounds: {
+        x: minX[l],
+        y: minY[l],
+        width: maxX[l] - minX[l] + 1,
+        height: maxY[l] - minY[l] + 1
+      },
+      pixelCount: count,
+      touchesEdge
+    });
+  }
+  out.sort((a, b) => b.pixelCount - a.pixelCount || a.bounds.y - b.bounds.y || a.bounds.x - b.bounds.x);
+  return out.slice(0, maxRegions);
+}
+
+
+
+
+
+exports.squaredDistanceTransform = squaredDistanceTransform; exports.fillRegionMask = fillRegionMask; exports.findUnfilledRegionsMask = findUnfilledRegionsMask;

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

@@ -18,6 +18,7 @@ import { type LayerLocks } from '../raster/layers.cjs';
 import { type LayerEffect, type LayerEffectKind, type LayerEffects } from '../raster/effects/model.cjs';
 import type { EffectPattern } from '../raster/effects/patterns.cjs';
 import { TiledSurface, type RasterRect, type Tile } from '../raster/surface.cjs';
+import { type FillRegionPoint, type FillRegionSummary, type UnfilledRegion } from '../raster/fill.cjs';
 import { type PaintBrushInput, type PaintBrush } from './brushes.cjs';
 import { type BrushLibrary, type BrushLibraryFile } from '../brushes/library.cjs';
 import { type BrushPatch, type UnsettableBrushFacet } from '../brushes/patch.cjs';
@@ -297,6 +298,75 @@ export interface FillLayerOptions {
     pressure?: number;
     blend?: BlendMode;
 }
+export type FillReference = 'layer' | 'all' | 'composite' | (string & {});
+export interface FillRegionOptions {
+    /** Seed x in document pixels (pass `x` and `y`, or `points`). */
+    x?: number;
+    /** Seed y in document pixels (pass `x` and `y`, or `points`). */
+    y?: number;
+    /** Multiple seed points in document pixels (filled together as one undo step). */
+    points?: ReadonlyArray<FillRegionPoint>;
+    /** Target layer id from `listLayers` (default the active layer). */
+    layerId?: string;
+    /**
+     * Which pixels define the region boundaries:
+     * - `'layer'` (default): the target layer itself.
+     * - `'all'` or `'composite'`: all visible layers composited (without paper).
+     * - a layer id from `listLayers`: that layer (e.g. an ink line-art layer above a flats layer).
+     */
+    reference?: FillReference;
+    /** Fill colour #rrggbb (default the editor's paint colour). */
+    color?: string;
+    /** Opacity 0..1 (default 1). */
+    opacity?: number;
+    /** Blend mode (default `'normal'`). */
+    blend?: BlendMode;
+    /** Alias for `blend`. */
+    blendMode?: BlendMode;
+    /** Colour/alpha similarity tolerance 0..255 (default 32). */
+    tolerance?: number;
+    /** Close small gaps in line art up to this width in pixels, 0..32 (default 0). */
+    closeGap?: number;
+    /** Expand (> 0, bleed under lines) or contract (< 0) the filled region in pixels, -16..16 (default 0). */
+    expand?: number;
+    /** Soften boundary edges (default true). */
+    antialias?: boolean;
+    /** Paper grain response 0..1 (default 0: flat fill). */
+    grain?: number;
+    /** With grain: pressure 0..1, how far the fill reaches into the valleys (default 0.5). */
+    pressure?: number;
+    /** Pour a wet watercolour wash into the region on the layer's wet layer (default false). */
+    wet?: boolean;
+}
+export interface FillRegionResult {
+    layerId: string;
+    bounds: RasterRect | null;
+    pixelCount: number;
+    leaked: boolean;
+    regions: FillRegionSummary[];
+    wet?: boolean;
+}
+export interface FindUnfilledRegionsOptions {
+    /** Target layer id from `listLayers` (when given, regions already painted on it are excluded). */
+    layerId?: string;
+    /**
+     * Which pixels define the line-art barriers:
+     * - `'all'` or `'composite'` (default): all visible layers composited (without paper).
+     * - `'layer'`: the target (or active) layer itself.
+     * - a layer id from `listLayers`: that layer (e.g. an ink line-art layer).
+     */
+    reference?: FillReference;
+    /** Alpha/colour threshold 0..255 above which a reference pixel is treated as line art (default 32). */
+    tolerance?: number;
+    /** Close small gaps in line art up to this width in pixels, 0..32 (default 0). */
+    closeGap?: number;
+    /** Ignore regions smaller than this many pixels (default 16). */
+    minArea?: number;
+    /** Include regions that touch the canvas border (default false: only enclosed shapes). */
+    includeEdge?: boolean;
+    /** Maximum number of regions to return, sorted largest first (default 100). */
+    maxRegions?: number;
+}
 /** Pixels to add on each side of the canvas (whole numbers, 0 or more; missing = 0). */
 export interface PaintCanvasExtension {
     left?: number;
@@ -653,6 +723,22 @@ export declare class PaintEditorController {
         layerId: string;
         bounds: RasterRect;
     };
+    /**
+     * Flood-fills one or more contiguous regions on a pixel layer (one undo step), sampling boundaries
+     * from the layer itself (`reference: 'layer'`), all visible layers (`'all'` / `'composite'`), or a
+     * specific reference layer id (e.g. an ink line-art layer above a flats layer). Closes line-art gaps
+     * up to `closeGap` px and expands (`> 0`, bleeding under lines) or contracts (`< 0`) by `expand` px.
+     * With `wet: true`, pours a watercolour wash into the region on the layer's wet layer.
+     */
+    fillRegion(options: FillRegionOptions): FillRegionResult;
+    /**
+     * Finds enclosed unfilled regions from a reference layer or the visible composite (without paper),
+     * closing line-art gaps up to `closeGap` px and returning each region's interior seed `point`,
+     * `centroid`, `bounds`, `pixelCount`, and `touchesEdge` flag.
+     */
+    findUnfilledRegions(options?: FindUnfilledRegionsOptions): {
+        regions: UnfilledRegion[];
+    };
     private applyCoverage;
     /** The registered effects provider, or `null`. */
     get effectsProvider(): EffectProvider | null;