@pixerate/editor 0.206.0 → 0.208.0

package/dist/image-editor/index.js

@@ -3,6 +3,56 @@ import {
   parseOpenTypeFont,
   traceField
 } from "../chunk-5OC22IEO.js";
+import {
+  ColorGmm,
+  DEFAULT_REFINE_EDGE_PARAMS,
+  GAMMA,
+  GUIDED_FILTER_EPS,
+  GridGraph,
+  REFINE_EDIT_KINDS,
+  SelectionWorkerClient,
+  UNITS,
+  WORK_SIZE,
+  applyRefineEdits,
+  boxBlur,
+  boxMean,
+  brushStrokeMask,
+  decontaminateColors,
+  deserializeMask,
+  edgeWidth,
+  ellipsePoints,
+  ellipseSelection,
+  findSky,
+  findSubject,
+  focusArea,
+  grabCutLabels,
+  guidePlanes,
+  guidedFilterColor,
+  keepMainPieces,
+  normalizeRect,
+  normalizeRefineEdgeParams,
+  otsuThreshold,
+  polygonCoverage,
+  polygonCoverageBox,
+  polygonSelection,
+  quickSelectStroke,
+  rectSelection,
+  refineCoverage,
+  refineEdgeHalo,
+  refineSelection,
+  runSelectionJob,
+  selectObjectIn,
+  serializeMask,
+  slicSuperpixels,
+  smoothnessWeights,
+  softMaskToSelection,
+  startSelectionWorker,
+  superpixelSaliency,
+  upscaleRegion,
+  workImage,
+  workLuma,
+  workPlanes
+} from "../chunk-DWYQPL2A.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -20,7 +70,6 @@ import {
   DEFAULT_MITER_LIMIT,
   DEFAULT_TRANSFORM_VALUES,
   DEVELOP_FILTER_ID,
-  EMPTY_DISTANCE,
   FREE_TRANSFORM_MODES,
   HUE_RANGE_LABELS,
   IDENTITY_MATRIX3,
@@ -39,8 +88,6 @@ import {
   PATTERN_BLOCK_KEYS,
   PSD_BLEND_KEYS,
   PsdError,
-  SELECTION_MODES,
-  SELECTION_MODIFY_OPS,
   SHAPE_OPERATIONS,
   SHAPE_RENDER_MARGIN,
   SMART_RENDER_MARGIN,
@@ -89,7 +136,6 @@ import {
   backgroundLayer,
   blackWhiteGray,
   blurFilter,
-  borderCoverage,
   boxPointOf,
   bradfordAdaptation,
   buildLayerMaskPlanes,
@@ -98,21 +144,16 @@ import {
   canvasToImagePoint,
   clampCropToImage,
   colorBalanceChannel,
-  combineSelections,
   compileAdjustmentLayer,
   componentPath,
   componentsCoverage,
   compositeDeep,
-  computeSelectionBounds,
   contentsBox,
   contentsSurface,
-  contractCoverage,
   convertToSmartObject,
   copySmartObject,
   cornersFromMatrix,
-  coverageToByte,
   createAdjustmentLayer,
-  createSelectionMask,
   createShapeLayer,
   createTypeLayer,
   curveLutFromLevels,
@@ -122,7 +163,6 @@ import {
   decodeMergedImage,
   decodePlanes,
   decodePngDataUrl,
-  decodeSelectionRle,
   defaultActiveLayerId,
   defaultAdjustmentParams,
   defaultShapeName,
@@ -133,39 +173,31 @@ import {
   deserializeLayer,
   deserializeLayers,
   deserializePatterns,
-  deserializeSelection,
   developFilter,
   developFromAdjustments,
   developTarget,
-  distanceTransform,
   documentContents,
   duplicateLayer,
   effectiveLayerMask,
   encodeDeepSurface,
   encodeRle,
-  encodeSelectionRle,
   encodeSurface,
   evaluateAdjustmentLayers,
-  expandCoverage,
   exportPsd,
-  featherCoverage,
   filterMaskCoverage,
   flattenPath,
   flipCorners,
   followLayerMove,
-  fullSelection,
   geometryHomography,
   getAnnotationBounds,
   getCropCursor,
   getRotatedSize,
   getViewportMetrics,
   getViewportProjection,
-  greyMorphology,
   groupLayers,
   hasResampledLegacyMask,
   hasSurface,
   hasWarp,
-  hashMaskContent,
   hexToRgb,
   hitTestAnnotation,
   hitTestCrop,
@@ -180,7 +212,6 @@ import {
   importPsd,
   instancesOf,
   invertMatrix3,
-  invertSelection,
   isActiveFilter,
   isActiveVectorMask,
   isAdjustmentKind,
@@ -191,8 +222,6 @@ import {
   isPaintableLayer,
   isQuarterTurnSwapped,
   isRenderedLayer,
-  isSelectionEmpty,
-  isSelectionMode,
   isSmartSurfaceIncomplete,
   isSpatialFilter,
   isTransformAnchor,
@@ -220,7 +249,6 @@ import {
   matrixFromCorners,
   matrixFromParams,
   mergeShapeComponents,
-  modifySelection,
   moveLayer,
   moveSmartFilter,
   mulMatrix3,
@@ -249,7 +277,6 @@ import {
   parseLfx2,
   parseLrfx,
   parsePatternBlock,
-  parseSelectionMode,
   parseVersionedDescriptor,
   patchParagraphStyle,
   patchTextStyle,
@@ -295,7 +322,6 @@ import {
   rerender,
   rerenderShape,
   rerenderText,
-  resizeSelection,
   resolveExternalAssets,
   resolveVectorMasks,
   rgbToGray,
@@ -304,21 +330,12 @@ import {
   runLayerFiltersFloat,
   sampleLut,
   sampleToneLut,
-  selectionArea,
-  selectionFromCoverage,
-  selectionFromPixels,
-  selectionFromRegion,
-  selectionFromTiles,
-  selectionToCoverage,
-  selectionToPixels,
-  selectionValueAt,
   serializeContents,
   serializeEffects,
   serializeLayer,
   serializeLayers,
   serializeLayersExternal,
   serializePatterns,
-  serializeSelection,
   setLayerEffects,
   setLayerEffectsEnabled,
   setLayerMask,
@@ -332,10 +349,8 @@ import {
   shapeLayers,
   shapeOutline,
   shapeRenderClip,
-  shiftCoverage,
   smartContentsFile,
   smartObjectLayers,
-  smoothCoverage,
   srgbToLinear,
   tempTintToXy,
   temperatureToKelvin,
@@ -386,10 +401,47 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-ZIDUPSP4.js";
+} from "../chunk-KFIOEOCQ.js";
 import {
   parseCssColor
 } from "../chunk-3CI7FRMK.js";
+import {
+  EMPTY_DISTANCE,
+  SELECTION_MODES,
+  SELECTION_MODIFY_OPS,
+  borderCoverage,
+  combineSelections,
+  computeSelectionBounds,
+  contractCoverage,
+  coverageToByte,
+  createSelectionMask,
+  decodeSelectionRle,
+  deserializeSelection,
+  distanceTransform,
+  encodeSelectionRle,
+  expandCoverage,
+  featherCoverage,
+  fullSelection,
+  greyMorphology,
+  hashMaskContent,
+  invertSelection,
+  isSelectionEmpty,
+  isSelectionMode,
+  modifySelection,
+  parseSelectionMode,
+  resizeSelection,
+  selectionArea,
+  selectionFromCoverage,
+  selectionFromPixels,
+  selectionFromRegion,
+  selectionFromTiles,
+  selectionToCoverage,
+  selectionToPixels,
+  selectionValueAt,
+  serializeSelection,
+  shiftCoverage,
+  smoothCoverage
+} from "../chunk-L3G23N5Y.js";
 import {
   EffectRendererPool
 } from "../chunk-EHLOCVWB.js";
@@ -398,7 +450,6 @@ import {
 } from "../chunk-5ED73EC6.js";
 import {
   DEFAULT_GLOBAL_LIGHT,
-  DIRECT_GAUSSIAN_MAX_SIGMA,
   INTERPOLATIONS,
   LAYER_EFFECT_KINDS,
   LayerEffectError,
@@ -422,7 +473,6 @@ import {
   effectsScale,
   findLayer,
   flattenLayers,
-  gaussianBlur,
   hasActiveEffects,
   hashNoise,
   insertLayer,
@@ -447,7 +497,7 @@ import {
   validateLayerEffects,
   warpSurface,
   workingToSamples
-} from "../chunk-NQMP3CWF.js";
+} from "../chunk-YBJXCQTR.js";
 import {
   applyHomography,
   boxQuad,
@@ -457,6 +507,10 @@ import {
   multiplyHomographies,
   rectToQuad
 } from "../chunk-OHKOFKBY.js";
+import {
+  DIRECT_GAUSSIAN_MAX_SIGMA,
+  gaussianBlur
+} from "../chunk-ZIF4UJJ6.js";
 import {
   DEFAULT_RETOUCH,
   IDENTITY_CLONE_TRANSFORM,
@@ -495,7 +549,7 @@ import {
   spotHealPixels,
   spotHealWindow,
   toneOf
-} from "../chunk-EL5PAHNP.js";
+} from "../chunk-USQCKRZG.js";
 import {
   BODY_SCATTER,
   DEFAULT_FLOW,
@@ -586,7 +640,7 @@ import {
   wetGpuSupport,
   wetSimdSupported,
   wetSupport
-} from "../chunk-36OKQDCF.js";
+} from "../chunk-WJ2RBZMM.js";
 import {
   BUILTIN_PROFILES,
   CmsError,
@@ -646,8 +700,8 @@ import {
   warpMeshParamAt,
   warpMeshRows,
   warpPresetMesh
-} from "../chunk-GHCXLQ47.js";
-import "../chunk-YXKLVD56.js";
+} from "../chunk-NDMXB4PR.js";
+import "../chunk-F7YA3MMC.js";
 import "../chunk-M6DNZNVY.js";
 import {
   bezierPathToSvg
@@ -758,7 +812,7 @@ import {
   tipShape,
   updatePaintGradientStop,
   walkDabs
-} from "../chunk-2N2QPO3H.js";
+} from "../chunk-2PBZBRP5.js";
 import {
   BRUSHSTROKE_MAX_SCALE,
   BRUSHSTROKE_MIN_SCALE,
@@ -773,10 +827,6 @@ import {
   PIGMENT_LAMBDA_STEP,
   PIGMENT_WAVELENGTHS,
   SHADOW_AMBIENT,
-  SurfaceDraft,
-  TILE,
-  TILE_SHIFT,
-  TiledSurface,
   base64ToBytes,
   blendChannel,
   blendImageData,
@@ -785,18 +835,13 @@ import {
   blendRgb,
   bytesToBase64,
   canvasCompositeOperation,
-  collectTiles,
-  contentBounds,
   convertSurfaceDepth,
   createPigment,
   decodePng,
   deepBytes,
   deepTile,
   depthOf,
-  emptySurface,
   encodePng,
-  fillRect,
-  finishTile,
   isBitDepth,
   isBlendMode,
   isPainterlyBlendMode,
@@ -809,45 +854,56 @@ import {
   mixPigmentRgb,
   mixPigments,
   normalizeBlendMode,
-  packRgba,
   parseDataUrl,
   pigment8,
   pngDataUrl,
   proxyOf,
   readDeepRegion,
-  readPixel,
-  readRegion,
   reflectanceToRgb,
   rgbToReflectance,
   setLum,
   setPigmentColor,
-  solidSurface,
   srgbDecode,
   srgbEncode,
   standardBlendMode,
-  surfaceBytes,
   surfaceDepth,
   surfaceFromDeepPixels,
-  surfaceFromPixels,
-  surfacesEqual,
-  tileCoord,
-  tileKey,
-  tileRect,
   tileSamples,
   tileSamples16,
   tileSamples32,
-  tilesInRect,
   to16From32,
   to16From8,
   to32From16,
   to32From8,
   to8From16,
   to8From32,
+  writeDeepRegion
+} from "../chunk-42TWUPNJ.js";
+import {
+  SurfaceDraft,
+  TILE,
+  TILE_SHIFT,
+  TiledSurface,
+  collectTiles,
+  contentBounds,
+  emptySurface,
+  fillRect,
+  finishTile,
+  packRgba,
+  readPixel,
+  readRegion,
+  solidSurface,
+  surfaceBytes,
+  surfaceFromPixels,
+  surfacesEqual,
+  tileCoord,
+  tileKey,
+  tileRect,
+  tilesInRect,
   translateSurface,
   uniformTile,
-  writeDeepRegion,
   writeRegion
-} from "../chunk-H367YTXI.js";
+} from "../chunk-HVVR5PZW.js";
 import {
   ZlibError,
   adler32,
@@ -2751,1647 +2807,56 @@ function liveWire(map, from, to, band) {
       const lx = dx / step;
       const ly = dy / step;
       const dp = Math.min(1, Math.abs(dirX[p] * lx + dirY[p] * ly));
-      const dq = Math.min(1, Math.abs(dirX[q] * lx + dirY[q] * ly));
-      const fD = (Math.acos(dp) + Math.acos(dq)) / Math.PI;
-      const fG = 1 - strength[q] * scale;
-      const fZ = 1 - zero[q];
-      const cost = (W_ZERO * fZ + W_GRADIENT * fG + W_DIRECTION * fD + 0.01) * step;
-      const nd = d + cost;
-      if (nd < dist[q]) {
-        dist[q] = nd;
-        prev[q] = p;
-        heap.push(q, nd);
-      }
-    }
-  }
-  if (prev[goal] < 0) return [{ x: ax + 0.5, y: ay + 0.5 }, { x: bx + 0.5, y: by + 0.5 }];
-  const path = [];
-  for (let p = goal; p >= 0; p = prev[p]) {
-    const x = p % w;
-    path.push({ x: rx0 + x + 0.5, y: ry0 + (p - x) / w + 0.5 });
-  }
-  return path.reverse();
-}
-function simplifyPixelPath(points) {
-  if (points.length < 3) return points.slice();
-  const out = [points[0]];
-  for (let i = 1; i < points.length - 1; i++) {
-    const a = out[out.length - 1];
-    const b = points[i];
-    const c = points[i + 1];
-    const cross = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
-    if (Math.abs(cross) > 1e-9) out.push(b);
-  }
-  out.push(points[points.length - 1]);
-  return out;
-}
-function snapPolygonToEdges(pixels, points, options = {}) {
-  const map = pixels instanceof EdgeMap ? pixels : new EdgeMap(pixels, options);
-  const width = options.width ?? 10;
-  const snapped = points.map((p) => snapToEdge(map, p, width));
-  const out = [];
-  for (let i = 0; i < snapped.length; i++) {
-    const a = snapped[i];
-    const b = snapped[(i + 1) % snapped.length];
-    const seg = liveWire(map, a, b, Math.max(2 * width, 16, Math.hypot(b.x - a.x, b.y - a.y) / 4));
-    out.push(...seg.slice(0, -1));
-  }
-  return simplifyPixelPath(out);
-}
-function magneticAnchorSpacing(frequency = 57) {
-  const f = Math.min(100, Math.max(0, frequency));
-  return 8 + (100 - f);
-}
-
-// src/image-editor/selection/segment/maxflow.ts
-var TERMINAL = -2;
-var NONE = -1;
-var FREE = 0;
-var SOURCE = 1;
-var SINK = 2;
-var GridGraph = class {
-  width;
-  height;
-  /** Residual capacity of the edge leaving node `p` in direction `d`, at `p * 4 + d`. */
-  cap;
-  /** Net terminal capacity: above 0 to the source, below 0 to the sink. */
-  tr;
-  tree;
-  constructor(width, height) {
-    this.width = width;
-    this.height = height;
-    const n = width * height;
-    this.cap = new Float64Array(n * 4);
-    this.tr = new Float64Array(n);
-    this.tree = new Uint8Array(n);
-  }
-  /** Sets the capacity of the edge between `p` and its neighbour in direction `d`, both ways. */
-  setEdge(p, d, capacity) {
-    const q = d === 0 ? p + 1 : p + this.width;
-    this.cap[p * 4 + d] = capacity;
-    this.cap[q * 4 + (d ^ 2)] = capacity;
-  }
-  /** Adds `source` (cost of putting `p` on the sink side) and `sink` (the other way) to `p`. */
-  addTerminal(p, source, sink) {
-    this.tr[p] += source - sink;
-  }
-  /** Whether `p` is on the source side of the minimum cut (after {@link maxflow}). */
-  inSource(p) {
-    return this.tree[p] === SOURCE;
-  }
-  /** Runs max-flow and returns the flow (the cut's cost, less the constant terminal parts). */
-  maxflow() {
-    const { width: w, height: h, cap, tr, tree } = this;
-    const n = w * h;
-    const nb = (p, d) => {
-      const x = p % w;
-      if (d === 0) return x < w - 1 ? p + 1 : -1;
-      if (d === 1) return p + w < n ? p + w : -1;
-      if (d === 2) return x > 0 ? p - 1 : -1;
-      return p - w >= 0 ? p - w : -1;
-    };
-    const parent = new Int8Array(n).fill(NONE);
-    const ts = new Int32Array(n);
-    const dist = new Int32Array(n);
-    const queue = new Int32Array(n + 1);
-    const queued = new Uint8Array(n);
-    let qHead = 0;
-    let qTail = 0;
-    const activate = (p) => {
-      if (queued[p]) return;
-      queued[p] = 1;
-      queue[qTail] = p;
-      qTail = qTail === n ? 0 : qTail + 1;
-    };
-    const nextActive = () => {
-      while (qHead !== qTail) {
-        const p = queue[qHead];
-        qHead = qHead === n ? 0 : qHead + 1;
-        queued[p] = 0;
-        if (tree[p] !== FREE) return p;
-      }
-      return -1;
-    };
-    let orphans = new Int32Array(64);
-    let orphanCount = 0;
-    const orphan = (p) => {
-      parent[p] = NONE;
-      if (orphanCount === orphans.length) {
-        const grown = new Int32Array(orphans.length * 2);
-        grown.set(orphans);
-        orphans = grown;
-      }
-      orphans[orphanCount++] = p;
-    };
-    tree.fill(FREE);
-    for (let p = 0; p < n; p++) {
-      if (tr[p] > 0) tree[p] = SOURCE;
-      else if (tr[p] < 0) tree[p] = SINK;
-      else continue;
-      parent[p] = TERMINAL;
-      dist[p] = 1;
-      activate(p);
-    }
-    let flow = 0;
-    let time = 0;
-    let current = -1;
-    for (; ; ) {
-      if (current < 0 || tree[current] === FREE) {
-        current = nextActive();
-        if (current < 0) break;
-      }
-      const p = current;
-      const side = tree[p];
-      let s = -1;
-      let t = -1;
-      let dir = 0;
-      for (let d = 0; d < 4; d++) {
-        const q = nb(p, d);
-        if (q < 0) continue;
-        if (side === SOURCE ? cap[p * 4 + d] <= 0 : cap[q * 4 + (d ^ 2)] <= 0) continue;
-        if (tree[q] === FREE) {
-          tree[q] = side;
-          parent[q] = d ^ 2;
-          ts[q] = ts[p];
-          dist[q] = dist[p] + 1;
-          activate(q);
-        } else if (tree[q] !== side) {
-          if (side === SOURCE) {
-            s = p;
-            t = q;
-            dir = d;
-          } else {
-            s = q;
-            t = p;
-            dir = d ^ 2;
-          }
-          break;
-        } else if (ts[q] <= ts[p] && dist[q] > dist[p]) {
-          parent[q] = d ^ 2;
-          ts[q] = ts[p];
-          dist[q] = dist[p] + 1;
-        }
-      }
-      if (s < 0) {
-        current = -1;
-        continue;
-      }
-      time++;
-      let f = cap[s * 4 + dir];
-      for (let x = s; ; ) {
-        const a = parent[x];
-        if (a === TERMINAL) {
-          f = Math.min(f, tr[x]);
-          break;
-        }
-        const up = nb(x, a);
-        f = Math.min(f, cap[up * 4 + (a ^ 2)]);
-        x = up;
-      }
-      for (let x = t; ; ) {
-        const a = parent[x];
-        if (a === TERMINAL) {
-          f = Math.min(f, -tr[x]);
-          break;
-        }
-        f = Math.min(f, cap[x * 4 + a]);
-        x = nb(x, a);
-      }
-      cap[s * 4 + dir] -= f;
-      cap[t * 4 + (dir ^ 2)] += f;
-      for (let x = s; ; ) {
-        const a = parent[x];
-        if (a === TERMINAL) {
-          tr[x] -= f;
-          if (tr[x] <= 0) orphan(x);
-          break;
-        }
-        const up = nb(x, a);
-        cap[up * 4 + (a ^ 2)] -= f;
-        cap[x * 4 + a] += f;
-        if (cap[up * 4 + (a ^ 2)] <= 0) orphan(x);
-        x = up;
-      }
-      for (let x = t; ; ) {
-        const a = parent[x];
-        if (a === TERMINAL) {
-          tr[x] += f;
-          if (tr[x] >= 0) orphan(x);
-          break;
-        }
-        const up = nb(x, a);
-        cap[x * 4 + a] -= f;
-        cap[up * 4 + (a ^ 2)] += f;
-        if (cap[x * 4 + a] <= 0) orphan(x);
-        x = up;
-      }
-      flow += f;
-      while (orphanCount) {
-        const o = orphans[--orphanCount];
-        const oSide = tree[o];
-        let best = NONE;
-        let bestDist = Infinity;
-        for (let d = 0; d < 4; d++) {
-          const q = nb(o, d);
-          if (q < 0 || tree[q] !== oSide) continue;
-          if (oSide === SOURCE ? cap[q * 4 + (d ^ 2)] <= 0 : cap[o * 4 + d] <= 0) continue;
-          let k = 0;
-          let x = q;
-          for (; ; ) {
-            if (ts[x] === time) {
-              k += dist[x];
-              break;
-            }
-            const a = parent[x];
-            k++;
-            if (a === TERMINAL) {
-              ts[x] = time;
-              dist[x] = 1;
-              break;
-            }
-            if (a === NONE) {
-              k = Infinity;
-              break;
-            }
-            x = nb(x, a);
-          }
-          if (k === Infinity) continue;
-          if (k < bestDist) {
-            bestDist = k;
-            best = d;
-          }
-          for (let y = q, dd = k; ts[y] !== time; y = nb(y, parent[y]), dd--) {
-            ts[y] = time;
-            dist[y] = dd;
-          }
-        }
-        if (best !== NONE) {
-          parent[o] = best;
-          ts[o] = time;
-          dist[o] = bestDist + 1;
-          continue;
-        }
-        for (let d = 0; d < 4; d++) {
-          const q = nb(o, d);
-          if (q < 0 || tree[q] !== oSide) continue;
-          if (oSide === SOURCE ? cap[q * 4 + (d ^ 2)] > 0 : cap[o * 4 + d] > 0) activate(q);
-          const a = parent[q];
-          if (a !== TERMINAL && a !== NONE && nb(q, a) === o) orphan(q);
-        }
-        tree[o] = FREE;
-      }
-    }
-    return flow;
-  }
-};
-
-// src/image-editor/selection/segment/work.ts
-var WORK_SIZE = 512;
-var workCache = /* @__PURE__ */ new WeakMap();
-function workImage(pixels, maxSide = WORK_SIZE) {
-  const sizes = workCache.get(pixels.data);
-  const cached = sizes?.get(maxSide);
-  if (cached && cached.sourceWidth === pixels.width && cached.sourceHeight === pixels.height) return cached;
-  const { width: W, height: H, data } = pixels;
-  const scale = Math.min(1, maxSide / Math.max(W, H));
-  const w = Math.max(1, Math.round(W * scale));
-  const h = Math.max(1, Math.round(H * scale));
-  const sum = new Float64Array(w * h * 3);
-  const count = new Float64Array(w * h);
-  const xs = new Int32Array(W);
-  for (let x = 0; x < W; x++) xs[x] = Math.min(w - 1, Math.floor(x * w / W));
-  for (let y = 0; y < H; y++) {
-    const row = Math.min(h - 1, Math.floor(y * h / H)) * w;
-    for (let x = 0, p = y * W * 4; x < W; x++, p += 4) {
-      const o = row + xs[x];
-      const a = data[p + 3] / 255;
-      const k = o * 3;
-      sum[k] += data[p] * a + 255 * (1 - a);
-      sum[k + 1] += data[p + 1] * a + 255 * (1 - a);
-      sum[k + 2] += data[p + 2] * a + 255 * (1 - a);
-      count[o]++;
-    }
-  }
-  const rgb = new Float32Array(w * h * 3);
-  for (let i = 0; i < w * h; i++) {
-    const c = count[i] || 1;
-    rgb[i * 3] = sum[i * 3] / c;
-    rgb[i * 3 + 1] = sum[i * 3 + 1] / c;
-    rgb[i * 3 + 2] = sum[i * 3 + 2] / c;
-  }
-  const work = { sourceWidth: W, sourceHeight: H, width: w, height: h, scale: w / W, rgb };
-  if (sizes) sizes.set(maxSide, work);
-  else workCache.set(pixels.data, /* @__PURE__ */ new Map([[maxSide, work]]));
-  return work;
-}
-var GAMMA = 50;
-var UNITS = 64;
-function smoothnessWeights(work, roi) {
-  const { width: w, rgb } = work;
-  const { x: rx, y: ry, width: rw, height: rh } = roi;
-  const right = new Float64Array(rw * rh);
-  const down = new Float64Array(rw * rh);
-  let sumSq = 0;
-  let pairs = 0;
-  for (let y = 0; y < rh; y++) {
-    for (let x = 0; x < rw; x++) {
-      const p = y * rw + x;
-      const c = ((ry + y) * w + rx + x) * 3;
-      if (x + 1 < rw) {
-        right[p] = (rgb[c] - rgb[c + 3]) ** 2 + (rgb[c + 1] - rgb[c + 4]) ** 2 + (rgb[c + 2] - rgb[c + 5]) ** 2;
-        sumSq += right[p];
-        pairs++;
-      }
-      if (y + 1 < rh) {
-        const k = c + w * 3;
-        down[p] = (rgb[c] - rgb[k]) ** 2 + (rgb[c + 1] - rgb[k + 1]) ** 2 + (rgb[c + 2] - rgb[k + 2]) ** 2;
-        sumSq += down[p];
-        pairs++;
-      }
-    }
-  }
-  const beta = 1 / (2 * Math.max(1e-6, sumSq / Math.max(1, pairs)));
-  for (let p = 0; p < right.length; p++) {
-    right[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * right[p]));
-    down[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * down[p]));
-  }
-  return { right, down };
-}
-function boxBlur(src, w, h, passes) {
-  let a = src;
-  for (let k = 0; k < passes; k++) {
-    const b = new Float32Array(a.length);
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        let s = 0;
-        let c = 0;
-        for (let j = Math.max(0, y - 1); j <= Math.min(h - 1, y + 1); j++) {
-          for (let i = Math.max(0, x - 1); i <= Math.min(w - 1, x + 1); i++) {
-            s += a[j * w + i];
-            c++;
-          }
-        }
-        b[y * w + x] = s / c;
-      }
-    }
-    a = b;
-  }
-  return a;
-}
-function upscaleRegion(work, pixels, roi, label, enhance) {
-  const { sourceWidth: W, sourceHeight: H, scale, rgb, width: ww } = work;
-  const { x: rx, y: ry, width: rw, height: rh } = roi;
-  let soft = Float32Array.from(label);
-  if (enhance) {
-    soft = boxBlur(soft, rw, rh, 2);
-    for (let i = 0; i < soft.length; i++) soft[i] = Math.min(1, Math.max(0, (soft[i] - 0.5) * 3 + 0.5));
-  }
-  const X0 = Math.max(0, Math.floor(rx / scale));
-  const Y0 = Math.max(0, Math.floor(ry / scale));
-  const X1 = Math.min(W, Math.ceil((rx + rw) / scale));
-  const Y1 = Math.min(H, Math.ceil((ry + rh) / scale));
-  const RW = X1 - X0;
-  const RH = Y1 - Y0;
-  const out = new Uint8Array(RW * RH);
-  const at = (x, y) => soft[Math.min(rh - 1, Math.max(0, y)) * rw + Math.min(rw - 1, Math.max(0, x))];
-  const data = pixels.data;
-  const colOf = new Int32Array(RW);
-  const fxOf = new Float32Array(RW);
-  for (let X = 0; X < RW; X++) {
-    const u = (X0 + X + 0.5) * scale - 0.5 - rx;
-    colOf[X] = Math.floor(u);
-    fxOf[X] = u - colOf[X];
-  }
-  const cellState = (i, j) => {
-    const a = at(i, j), b = at(i + 1, j), c = at(i, j + 1), d = at(i + 1, j + 1);
-    if (a === 1 && b === 1 && c === 1 && d === 1) return 1;
-    if (a === 0 && b === 0 && c === 0 && d === 0) return 0;
-    return 2;
-  };
-  for (let Y = 0; Y < RH; Y++) {
-    const v = (Y0 + Y + 0.5) * scale - 0.5 - ry;
-    const j = Math.floor(v);
-    const fy = v - j;
-    for (let X = 0; X < RW; X++) {
-      const i = colOf[X];
-      const state = cellState(i, j);
-      if (state !== 2) {
-        let end = X + 1;
-        while (end < RW && colOf[end] === i) end++;
-        if (state === 1) out.fill(255, Y * RW + X, Y * RW + end);
-        X = end - 1;
-        continue;
-      }
-      const fx = fxOf[X];
-      const m = (at(i, j) * (1 - fx) + at(i + 1, j) * fx) * (1 - fy) + (at(i, j + 1) * (1 - fx) + at(i + 1, j + 1) * fx) * fy;
-      if (m <= 1e-3 || m >= 0.999) {
-        out[Y * RW + X] = m >= 0.999 ? 255 : 0;
-        continue;
-      }
-      let fr = 0, fg = 0, fb = 0, fn = 0, br = 0, bg = 0, bb = 0, bn = 0;
-      for (let jj = j - 1; jj <= j + 2; jj++) {
-        for (let ii = i - 1; ii <= i + 2; ii++) {
-          if (ii < 0 || jj < 0 || ii >= rw || jj >= rh) continue;
-          const k = ((ry + jj) * ww + rx + ii) * 3;
-          if (soft[jj * rw + ii] >= 0.5) {
-            fr += rgb[k];
-            fg += rgb[k + 1];
-            fb += rgb[k + 2];
-            fn++;
-          } else {
-            br += rgb[k];
-            bg += rgb[k + 1];
-            bb += rgb[k + 2];
-            bn++;
-          }
-        }
-      }
-      let alpha = m;
-      if (fn && bn) {
-        fr /= fn;
-        fg /= fn;
-        fb /= fn;
-        br /= bn;
-        bg /= bn;
-        bb /= bn;
-        const dr = fr - br, dg = fg - bg, db = fb - bb;
-        const len2 = dr * dr + dg * dg + db * db;
-        if (len2 > 400) {
-          const p = ((Y0 + Y) * W + X0 + X) * 4;
-          const a = data[p + 3] / 255;
-          const cr = data[p] * a + 255 * (1 - a) - br;
-          const cg = data[p + 1] * a + 255 * (1 - a) - bg;
-          const cb = data[p + 2] * a + 255 * (1 - a) - bb;
-          const proj = Math.min(1, Math.max(0, (cr * dr + cg * dg + cb * db) / len2));
-          alpha = Math.min(1, Math.max(0, proj * 0.75 + m * 0.25));
-        } else alpha = Math.min(1, Math.max(0, (m - 0.5) * 2 + 0.5));
-      }
-      out[Y * RW + X] = Math.round(alpha * 255);
-    }
-  }
-  return selectionFromRegion(W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
-}
-
-// src/image-editor/selection/segment/quick.ts
-var BINS = 16;
-var binOf = (rgb, i) => (Math.min(BINS - 1, rgb[i * 3] >> 4) * BINS + Math.min(BINS - 1, rgb[i * 3 + 1] >> 4)) * BINS + Math.min(BINS - 1, rgb[i * 3 + 2] >> 4);
-function costTable(hist, total) {
-  let a = hist;
-  for (const stride of [1, BINS, BINS * BINS]) {
-    const b = new Float64Array(a.length);
-    for (let i = 0; i < a.length; i++) {
-      const pos = Math.floor(i / stride) % BINS;
-      const lo = pos > 0 ? a[i - stride] : a[i];
-      const hi = pos < BINS - 1 ? a[i + stride] : a[i];
-      b[i] = (lo + 2 * a[i] + hi) / 4;
-    }
-    a = b;
-  }
-  const out = new Float64Array(a.length);
-  const floor = 1e-4;
-  const denom = Math.max(1, total) * (1 + floor * a.length);
-  for (let i = 0; i < a.length; i++) out[i] = -Math.log((a[i] + floor * Math.max(1, total)) / denom);
-  return out;
-}
-function strokePixels(points, r, w, h) {
-  const mask = new Uint8Array(w * h);
-  const list = [];
-  const add2 = (g) => {
-    if (!mask[g]) {
-      mask[g] = 1;
-      list.push(g);
-    }
-  };
-  const segs = points.length === 1 ? [[points[0], points[0]]] : points.slice(1).map((p, i) => [points[i], p]);
-  for (const [a, b] of segs) {
-    const x0 = Math.max(0, Math.floor(Math.min(a.x, b.x) - r));
-    const x1 = Math.min(w - 1, Math.ceil(Math.max(a.x, b.x) + r));
-    const y0 = Math.max(0, Math.floor(Math.min(a.y, b.y) - r));
-    const y1 = Math.min(h - 1, Math.ceil(Math.max(a.y, b.y) + r));
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const len2 = dx * dx + dy * dy;
-    for (let y = y0; y <= y1; y++) {
-      for (let x = x0; x <= x1; x++) {
-        const px2 = x + 0.5 - a.x;
-        const py = y + 0.5 - a.y;
-        const t = len2 > 0 ? Math.min(1, Math.max(0, (px2 * dx + py * dy) / len2)) : 0;
-        if ((px2 - t * dx) ** 2 + (py - t * dy) ** 2 <= r * r) add2(y * w + x);
-      }
-    }
-  }
-  if (!list.length) {
-    for (const p of points) add2(Math.min(h - 1, Math.max(0, Math.floor(p.y))) * w + Math.min(w - 1, Math.max(0, Math.floor(p.x))));
-  }
-  return { mask, list };
-}
-function segmentStroke(work, stroke, grown, start) {
-  const { width: w, height: h, rgb } = work;
-  let roi = start;
-  for (; ; ) {
-    const { x: rx, y: ry, width: rw, height: rh } = roi;
-    const n = rw * rh;
-    const fgHist = new Float64Array(BINS ** 3);
-    const bgHist = new Float64Array(BINS ** 3);
-    let fgN = 0;
-    let bgN = 0;
-    const atImageEdge = { l: rx === 0, t: ry === 0, r: rx + rw === w, b: ry + rh === h };
-    for (let y = 0; y < rh; y++) {
-      for (let x = 0; x < rw; x++) {
-        const g = (ry + y) * w + (rx + x);
-        const bin = binOf(rgb, g);
-        bgHist[bin]++;
-        bgN++;
-        if (stroke.mask[g] || grown?.[g]) {
-          fgHist[bin]++;
-          fgN++;
-        }
-      }
-    }
-    const fgCost = costTable(fgHist, fgN);
-    const bgCost = costTable(bgHist, bgN);
-    const { right, down } = smoothnessWeights(work, roi);
-    const graph = new GridGraph(rw, rh);
-    const HARD = 1e9;
-    for (let y = 0; y < rh; y++) {
-      for (let x = 0; x < rw; x++) {
-        const p = y * rw + x;
-        const g = (ry + y) * w + rx + x;
-        if (stroke.mask[g]) graph.addTerminal(p, HARD, 0);
-        else {
-          const bin = binOf(rgb, g);
-          graph.addTerminal(p, Math.round(bgCost[bin] * UNITS), Math.round(fgCost[bin] * UNITS));
-        }
-        if (x + 1 < rw) graph.setEdge(p, 0, right[p]);
-        if (y + 1 < rh) graph.setEdge(p, 1, down[p]);
-      }
-    }
-    graph.maxflow();
-    const label = new Uint8Array(n);
-    const stack = [];
-    for (const g of stroke.list) {
-      const x = g % w - rx;
-      const y = Math.floor(g / w) - ry;
-      if (x < 0 || y < 0 || x >= rw || y >= rh) continue;
-      const p = y * rw + x;
-      if (!label[p]) {
-        label[p] = 1;
-        stack.push(p);
-      }
-    }
-    while (stack.length) {
-      const p = stack.pop();
-      const x = p % rw;
-      for (const q of [x + 1 < rw ? p + 1 : -1, x > 0 ? p - 1 : -1, p + rw < n ? p + rw : -1, p - rw]) {
-        if (q >= 0 && !label[q] && graph.inSource(q)) {
-          label[q] = 1;
-          stack.push(q);
-        }
-      }
-    }
-    let touches = false;
-    for (let y = 0; y < rh; y++) {
-      for (let x = 0; x < rw; x++) {
-        const p = y * rw + x;
-        if (!label[p]) continue;
-        if (!atImageEdge.l && x === 0 || !atImageEdge.t && y === 0 || !atImageEdge.r && x === rw - 1 || !atImageEdge.b && y === rh - 1) touches = true;
-      }
-    }
-    if (!touches || atImageEdge.l && atImageEdge.t && atImageEdge.r && atImageEdge.b) return { roi, label };
-    const nx = Math.max(0, rx - Math.ceil(rw / 2));
-    const ny = Math.max(0, ry - Math.ceil(rh / 2));
-    roi = { x: nx, y: ny, width: Math.min(w, rx + rw + Math.ceil(rw / 2)) - nx, height: Math.min(h, ry + rh + Math.ceil(rh / 2)) - ny };
-    if (roi.width * roi.height * 2.5 > w * h) roi = { x: 0, y: 0, width: w, height: h };
-  }
-}
-function quickSelectStroke(pixels, stroke, options = {}) {
-  if (!stroke.length) throw new Error("A stroke needs at least one point.");
-  const work = workImage(pixels);
-  const { width: w, height: h, scale } = work;
-  const r = Math.max(0.5, (options.size ?? 30) / 2 * scale);
-  const pts = stroke.map((p) => ({ x: p.x * scale, y: p.y * scale }));
-  const seeds = strokePixels(pts, r, w, h);
-  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
-  for (const p of pts) {
-    x0 = Math.min(x0, p.x);
-    y0 = Math.min(y0, p.y);
-    x1 = Math.max(x1, p.x);
-    y1 = Math.max(y1, p.y);
-  }
-  const margin = Math.max(24, 4 * r);
-  const rx = Math.max(0, Math.floor(x0 - margin));
-  const ry = Math.max(0, Math.floor(y0 - margin));
-  const roi = { x: rx, y: ry, width: Math.min(w, Math.ceil(x1 + margin)) - rx, height: Math.min(h, Math.ceil(y1 + margin)) - ry };
-  let grown = null;
-  const sel = options.grow ? options.selection : null;
-  if (sel?.bounds) {
-    grown = new Uint8Array(w * h);
-    const b = sel.bounds;
-    for (let y = Math.max(0, Math.floor(b.y * scale)); y < Math.min(h, Math.ceil((b.y + b.height) * scale)); y++) {
-      for (let x = Math.max(0, Math.floor(b.x * scale)); x < Math.min(w, Math.ceil((b.x + b.width) * scale)); x++) {
-        if (selectionValueAt(sel, Math.min(sel.width - 1, Math.floor((x + 0.5) / scale)), Math.min(sel.height - 1, Math.floor((y + 0.5) / scale))) >= 0.5) grown[y * w + x] = 1;
-      }
-    }
-  }
-  const { roi: done, label } = segmentStroke(work, seeds, grown, roi);
-  return upscaleRegion(work, pixels, done, label, options.enhanceEdge ?? false);
-}
-
-// src/image-editor/selection/segment/grabcut.ts
-var K = 5;
-var ColorGmm = class {
-  logWeight = new Float64Array(K);
-  mean = new Float64Array(K * 3);
-  /** Inverse covariances, row-major 3 × 3. */
-  inv = new Float64Array(K * 9);
-  /** ln(weight) − ½ ln((2π)³ |Σ|) per component; −∞ for an empty one. */
-  logNorm = new Float64Array(K).fill(-Infinity);
-  /** Fits the components to the pixels `ids` of `rgb`, each in component `comp[id]`. */
-  fit(rgb, ids, comp) {
-    const n = new Float64Array(K);
-    const sum = new Float64Array(K * 3);
-    const prod = new Float64Array(K * 9);
-    for (let t = 0; t < ids.length; t++) {
-      const i = ids[t];
-      const k = comp[i];
-      const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
-      n[k]++;
-      for (let a = 0; a < 3; a++) {
-        sum[k * 3 + a] += c[a];
-        for (let b = 0; b < 3; b++) prod[k * 9 + a * 3 + b] += c[a] * c[b];
-      }
-    }
-    const total = ids.length || 1;
-    for (let k = 0; k < K; k++) {
-      if (!n[k]) {
-        this.logNorm[k] = -Infinity;
-        continue;
-      }
-      const m = [sum[k * 3] / n[k], sum[k * 3 + 1] / n[k], sum[k * 3 + 2] / n[k]];
-      const cov = new Float64Array(9);
-      for (let a = 0; a < 3; a++) {
-        for (let b = 0; b < 3; b++) cov[a * 3 + b] = prod[k * 9 + a * 3 + b] / n[k] - m[a] * m[b];
-        cov[a * 4] += 4;
-      }
-      const det = cov[0] * (cov[4] * cov[8] - cov[5] * cov[7]) - cov[1] * (cov[3] * cov[8] - cov[5] * cov[6]) + cov[2] * (cov[3] * cov[7] - cov[4] * cov[6]);
-      const d = Math.max(det, 1e-6);
-      const inv = [
-        (cov[4] * cov[8] - cov[5] * cov[7]) / d,
-        (cov[2] * cov[7] - cov[1] * cov[8]) / d,
-        (cov[1] * cov[5] - cov[2] * cov[4]) / d,
-        (cov[5] * cov[6] - cov[3] * cov[8]) / d,
-        (cov[0] * cov[8] - cov[2] * cov[6]) / d,
-        (cov[2] * cov[3] - cov[0] * cov[5]) / d,
-        (cov[3] * cov[7] - cov[4] * cov[6]) / d,
-        (cov[1] * cov[6] - cov[0] * cov[7]) / d,
-        (cov[0] * cov[4] - cov[1] * cov[3]) / d
-      ];
-      this.mean.set(m, k * 3);
-      this.inv.set(inv, k * 9);
-      this.logWeight[k] = Math.log(n[k] / total);
-      this.logNorm[k] = this.logWeight[k] - 0.5 * Math.log(Math.pow(2 * Math.PI, 3) * d);
-    }
-  }
-  /** ln p(colour | component k), up to the shared constant. */
-  componentLog(k, r, g, b) {
-    const ln = this.logNorm[k];
-    if (ln === -Infinity) return -Infinity;
-    const dr = r - this.mean[k * 3];
-    const dg = g - this.mean[k * 3 + 1];
-    const db = b - this.mean[k * 3 + 2];
-    const v = this.inv;
-    const o = k * 9;
-    const q = dr * (v[o] * dr + v[o + 1] * dg + v[o + 2] * db) + dg * (v[o + 3] * dr + v[o + 4] * dg + v[o + 5] * db) + db * (v[o + 6] * dr + v[o + 7] * dg + v[o + 8] * db);
-    return ln - 0.5 * q;
-  }
-  /** −ln p(colour) under the mixture (large for colours the model hasn't seen). */
-  cost(r, g, b) {
-    let best = -Infinity;
-    const logs = new Array(K);
-    for (let k = 0; k < K; k++) {
-      logs[k] = this.componentLog(k, r, g, b);
-      if (logs[k] > best) best = logs[k];
-    }
-    if (best === -Infinity) return 50;
-    let s = 0;
-    for (let k = 0; k < K; k++) if (logs[k] > -Infinity) s += Math.exp(logs[k] - best);
-    return Math.min(50, -(best + Math.log(s)));
-  }
-  /** The component most likely to have produced the colour. */
-  nearest(r, g, b) {
-    let best = 0;
-    let bestLog = -Infinity;
-    for (let k = 0; k < K; k++) {
-      const l = this.componentLog(k, r, g, b);
-      if (l > bestLog) {
-        bestLog = l;
-        best = k;
-      }
-    }
-    return best;
-  }
-};
-function initialComponents(rgb, ids, comp) {
-  if (!ids.length) return;
-  const step = Math.max(1, Math.floor(ids.length / 6e3));
-  const sample = [];
-  for (let t = 0; t < ids.length; t += step) sample.push(ids[t]);
-  const centres = [];
-  const dist2 = (i, c) => (rgb[i * 3] - c[0]) ** 2 + (rgb[i * 3 + 1] - c[1]) ** 2 + (rgb[i * 3 + 2] - c[2]) ** 2;
-  centres.push([rgb[sample[0] * 3], rgb[sample[0] * 3 + 1], rgb[sample[0] * 3 + 2]]);
-  const near = sample.map((i) => dist2(i, centres[0]));
-  while (centres.length < K) {
-    let far = 0;
-    for (let t = 1; t < sample.length; t++) if (near[t] > near[far]) far = t;
-    const i = sample[far];
-    const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
-    centres.push(c);
-    for (let t = 0; t < sample.length; t++) near[t] = Math.min(near[t], dist2(sample[t], c));
-  }
-  const closest = (i) => {
-    let best = 0;
-    for (let k = 1; k < K; k++) if (dist2(i, centres[k]) < dist2(i, centres[best])) best = k;
-    return best;
-  };
-  for (let round6 = 0; round6 < 6; round6++) {
-    const sum = Array.from({ length: K }, () => [0, 0, 0, 0]);
-    for (const i of sample) {
-      const s = sum[closest(i)];
-      s[0] += rgb[i * 3];
-      s[1] += rgb[i * 3 + 1];
-      s[2] += rgb[i * 3 + 2];
-      s[3]++;
-    }
-    for (let k = 0; k < K; k++) if (sum[k][3]) centres[k] = [sum[k][0] / sum[k][3], sum[k][1] / sum[k][3], sum[k][2] / sum[k][3]];
-  }
-  for (const i of ids) comp[i] = closest(i);
-}
-function grabCutLabels(work, setup, iterations) {
-  const { width: w, rgb } = work;
-  const { roi, hardBg, hardFg } = setup;
-  const { x: rx, y: ry, width: rw, height: rh } = roi;
-  const n = rw * rh;
-  const label = setup.initial.slice();
-  const global = new Int32Array(n);
-  for (let y = 0; y < rh; y++) for (let x = 0; x < rw; x++) global[y * rw + x] = (ry + y) * w + rx + x;
-  const comp = new Uint8Array(w * work.height);
-  const fg = new ColorGmm();
-  const bg = new ColorGmm();
-  const { right, down } = smoothnessWeights(work, roi);
-  const HARD = 1e9;
-  for (let iter = 0; iter < iterations; iter++) {
-    const fgIds = [];
-    const bgIds = [];
-    for (let p = 0; p < n; p++) (label[p] ? fgIds : bgIds).push(global[p]);
-    if (!fgIds.length) return label;
-    if (iter === 0) {
-      initialComponents(rgb, fgIds, comp);
-      initialComponents(rgb, bgIds, comp);
-    } else {
-      for (const i of fgIds) comp[i] = fg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
-      for (const i of bgIds) comp[i] = bg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
-    }
-    fg.fit(rgb, fgIds, comp);
-    bg.fit(rgb, bgIds, comp);
-    const graph = new GridGraph(rw, rh);
-    for (let p = 0; p < n; p++) {
-      if (hardBg[p]) graph.addTerminal(p, 0, HARD);
-      else if (hardFg?.[p]) graph.addTerminal(p, HARD, 0);
-      else {
-        const i = global[p] * 3;
-        graph.addTerminal(p, Math.round(bg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS), Math.round(fg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS));
-      }
-      if (p % rw + 1 < rw) graph.setEdge(p, 0, right[p]);
-      if (p + rw < n) graph.setEdge(p, 1, down[p]);
-    }
-    graph.maxflow();
-    let changed = 0;
-    for (let p = 0; p < n; p++) {
-      const v = graph.inSource(p) ? 1 : 0;
-      if (v !== label[p]) changed++;
-      label[p] = v;
-    }
-    if (changed <= n * 1e-3) break;
-  }
-  return label;
-}
-function keepMainPieces(label, rw, rh, seed) {
-  const n = rw * rh;
-  const piece = new Int32Array(n).fill(-1);
-  const sizes = [];
-  const stack = [];
-  for (let s = 0; s < n; s++) {
-    if (!label[s] || piece[s] >= 0) continue;
-    const id = sizes.length;
-    let size = 0;
-    piece[s] = id;
-    stack.push(s);
-    while (stack.length) {
-      const p = stack.pop();
-      size++;
-      const x = p % rw;
-      for (const q of [x + 1 < rw ? p + 1 : -1, x > 0 ? p - 1 : -1, p + rw < n ? p + rw : -1, p - rw]) {
-        if (q >= 0 && label[q] && piece[q] < 0) {
-          piece[q] = id;
-          stack.push(q);
-        }
-      }
-    }
-    sizes.push(size);
-  }
-  if (!sizes.length) return;
-  const largest = Math.max(...sizes);
-  const keep = (id) => seed !== null && piece[seed] >= 0 ? id === piece[seed] : sizes[id] * 5 >= largest;
-  for (let p = 0; p < n; p++) if (label[p] && !keep(piece[p])) label[p] = 0;
-}
-function selectObjectIn(pixels, target, options = {}) {
-  const work = workImage(pixels);
-  const { width: w, height: h, scale } = work;
-  const iterations = Math.max(1, Math.round(options.iterations ?? 5));
-  const enhance = options.enhanceEdge ?? false;
-  if ("rect" in target) {
-    const r = target.rect;
-    const bx0 = Math.max(0, Math.floor(r.x * scale));
-    const by0 = Math.max(0, Math.floor(r.y * scale));
-    const bx1 = Math.min(w, Math.ceil((r.x + r.width) * scale));
-    const by1 = Math.min(h, Math.ceil((r.y + r.height) * scale));
-    if (bx1 - bx0 < 2 || by1 - by0 < 2) return createSelectionMask(pixels.width, pixels.height);
-    const m = Math.max(8, Math.round(0.25 * Math.max(bx1 - bx0, by1 - by0)));
-    const rx = Math.max(0, bx0 - m);
-    const ry = Math.max(0, by0 - m);
-    const roi = { x: rx, y: ry, width: Math.min(w, bx1 + m) - rx, height: Math.min(h, by1 + m) - ry };
-    const n = roi.width * roi.height;
-    const initial = new Uint8Array(n);
-    const hardBg = new Uint8Array(n);
-    for (let y = 0; y < roi.height; y++) {
-      for (let x = 0; x < roi.width; x++) {
-        const gx = rx + x;
-        const gy = ry + y;
-        const inside = gx >= bx0 && gx < bx1 && gy >= by0 && gy < by1;
-        initial[y * roi.width + x] = inside ? 1 : 0;
-        hardBg[y * roi.width + x] = inside ? 0 : 1;
-      }
-    }
-    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg: null }, iterations);
-    keepMainPieces(label, roi.width, roi.height, null);
-    return upscaleRegion(work, pixels, roi, label, enhance);
-  }
-  const px2 = Math.min(w - 1, Math.max(0, Math.floor(target.point.x * scale)));
-  const py = Math.min(h - 1, Math.max(0, Math.floor(target.point.y * scale)));
-  let half = Math.max(24, Math.round(0.3 * Math.max(w, h)));
-  for (; ; ) {
-    const rx = Math.max(0, px2 - half);
-    const ry = Math.max(0, py - half);
-    const roi = { x: rx, y: ry, width: Math.min(w, px2 + half + 1) - rx, height: Math.min(h, py + half + 1) - ry };
-    const whole = roi.width === w && roi.height === h;
-    const band = Math.max(4, Math.round(0.15 * half));
-    const n = roi.width * roi.height;
-    const initial = new Uint8Array(n);
-    const hardBg = new Uint8Array(n);
-    const hardFg = new Uint8Array(n);
-    const inBand = (x, y) => rx > 0 && x < band || ry > 0 && y < band || rx + roi.width < w && x >= roi.width - band || ry + roi.height < h && y >= roi.height - band;
-    for (let y = 0; y < roi.height; y++) {
-      for (let x = 0; x < roi.width; x++) {
-        const p = y * roi.width + x;
-        if (inBand(x, y)) hardBg[p] = 1;
-        else initial[p] = 1;
-        if (Math.hypot(rx + x - px2, ry + y - py) <= 1.5) hardFg[p] = 1;
-      }
-    }
-    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, iterations);
-    keepMainPieces(label, roi.width, roi.height, (py - ry) * roi.width + (px2 - rx));
-    let touches = false;
-    for (let y = 0; y < roi.height && !touches; y++) {
-      for (let x = 0; x < roi.width; x++) {
-        if (label[y * roi.width + x] && (inBand(x - 1, y) || inBand(x + 1, y) || inBand(x, y - 1) || inBand(x, y + 1))) {
-          touches = true;
-          break;
-        }
-      }
-    }
-    if (!touches || whole) return upscaleRegion(work, pixels, roi, label, enhance);
-    half = Math.round(half * 1.6);
-  }
-}
-
-// src/image-editor/selection/segment/subject.ts
-function toLab(r, g, b) {
-  const lin = (v) => {
-    v /= 255;
-    return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
-  };
-  const R = lin(r);
-  const G = lin(g);
-  const B = lin(b);
-  const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
-  const x = f((0.4124 * R + 0.3576 * G + 0.1805 * B) / 0.95047);
-  const y = f(0.2126 * R + 0.7152 * G + 0.0722 * B);
-  const z = f((0.0193 * R + 0.1192 * G + 0.9505 * B) / 1.08883);
-  return [116 * y - 16, 500 * (x - y), 200 * (y - z)];
-}
-function slicSuperpixels(work, target = 400, compactness = 10, rounds = 5) {
-  const { width: w, height: h, rgb } = work;
-  const n = w * h;
-  const lab2 = new Float32Array(n * 3);
-  for (let i = 0; i < n; i++) lab2.set(toLab(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]), i * 3);
-  const S = Math.max(2, Math.round(Math.sqrt(n / target)));
-  const seeds = [];
-  for (let y = Math.floor(S / 2); y < h; y += S) {
-    for (let x = Math.floor(S / 2); x < w; x += S) {
-      const i = y * w + x;
-      seeds.push([lab2[i * 3], lab2[i * 3 + 1], lab2[i * 3 + 2], x, y]);
-    }
-  }
-  const k = seeds.length;
-  const label = new Int32Array(n).fill(-1);
-  const best = new Float64Array(n);
-  const m2 = (compactness / S) ** 2;
-  for (let round6 = 0; round6 < rounds; round6++) {
-    best.fill(Infinity);
-    for (let c = 0; c < k; c++) {
-      const [L, A, B, cx, cy] = seeds[c];
-      const x0 = Math.max(0, Math.floor(cx - S));
-      const x1 = Math.min(w - 1, Math.ceil(cx + S));
-      const y0 = Math.max(0, Math.floor(cy - S));
-      const y1 = Math.min(h - 1, Math.ceil(cy + S));
-      for (let y = y0; y <= y1; y++) {
-        for (let x = x0; x <= x1; x++) {
-          const i = y * w + x;
-          const d = (lab2[i * 3] - L) ** 2 + (lab2[i * 3 + 1] - A) ** 2 + (lab2[i * 3 + 2] - B) ** 2 + m2 * ((x - cx) ** 2 + (y - cy) ** 2);
-          if (d < best[i]) {
-            best[i] = d;
-            label[i] = c;
-          }
-        }
-      }
-    }
-    const sum = new Float64Array(k * 6);
-    for (let i = 0; i < n; i++) {
-      const c = label[i];
-      sum[c * 6] += lab2[i * 3];
-      sum[c * 6 + 1] += lab2[i * 3 + 1];
-      sum[c * 6 + 2] += lab2[i * 3 + 2];
-      sum[c * 6 + 3] += i % w;
-      sum[c * 6 + 4] += Math.floor(i / w);
-      sum[c * 6 + 5]++;
-    }
-    for (let c = 0; c < k; c++) {
-      const s = sum[c * 6 + 5];
-      if (s) seeds[c] = [sum[c * 6] / s, sum[c * 6 + 1] / s, sum[c * 6 + 2] / s, sum[c * 6 + 3] / s, sum[c * 6 + 4] / s];
-    }
-  }
-  const remap = new Int32Array(k).fill(-1);
-  let count = 0;
-  for (let i = 0; i < n; i++) if (remap[label[i]] < 0) remap[label[i]] = count++;
-  const meanLab = new Float64Array(count * 3);
-  const centre = new Float64Array(count * 2);
-  const size = new Int32Array(count);
-  for (let i = 0; i < n; i++) {
-    const c = label[i] = remap[label[i]];
-    meanLab[c * 3] += lab2[i * 3];
-    meanLab[c * 3 + 1] += lab2[i * 3 + 1];
-    meanLab[c * 3 + 2] += lab2[i * 3 + 2];
-    centre[c * 2] += i % w;
-    centre[c * 2 + 1] += Math.floor(i / w);
-    size[c]++;
-  }
-  for (let c = 0; c < count; c++) {
-    for (let j = 0; j < 3; j++) meanLab[c * 3 + j] /= size[c];
-    centre[c * 2] /= size[c];
-    centre[c * 2 + 1] /= size[c];
-  }
-  return { label, count, lab: meanLab, centre, size };
-}
-function superpixelSaliency(sp, width, height) {
-  const { count, lab: lab2, centre, size, label } = sp;
-  const dist = (a, b) => Math.hypot(lab2[a * 3] - lab2[b * 3], lab2[a * 3 + 1] - lab2[b * 3 + 1], lab2[a * 3 + 2] - lab2[b * 3 + 2]);
-  const onBorder = new Uint8Array(count);
-  for (let x = 0; x < width; x++) {
-    onBorder[label[x]] = 1;
-    onBorder[label[(height - 1) * width + x]] = 1;
-  }
-  for (let y = 0; y < height; y++) {
-    onBorder[label[y * width]] = 1;
-    onBorder[label[y * width + width - 1]] = 1;
-  }
-  const border = [];
-  for (let c = 0; c < count; c++) if (onBorder[c]) border.push(c);
-  const diag = Math.hypot(width, height);
-  const unlikeBorder = new Float64Array(count);
-  const contrast = new Float64Array(count);
-  const centreBias = new Float64Array(count);
-  for (let i = 0; i < count; i++) {
-    const ds = border.map((j) => dist(i, j)).sort((a, b) => a - b);
-    unlikeBorder[i] = ds.length ? ds[Math.floor(ds.length * 0.25)] : 0;
-    let s = 0;
-    let wsum = 0;
-    for (let j = 0; j < count; j++) {
-      if (j === i) continue;
-      const dx = (centre[i * 2] - centre[j * 2]) / diag;
-      const dy = (centre[i * 2 + 1] - centre[j * 2 + 1]) / diag;
-      const wgt = size[j] * Math.exp(-(dx * dx + dy * dy) / (2 * 0.25 * 0.25));
-      s += wgt * dist(i, j);
-      wsum += wgt;
-    }
-    contrast[i] = wsum ? s / wsum : 0;
-    const cx = centre[i * 2] / width - 0.5;
-    const cy = centre[i * 2 + 1] / height - 0.5;
-    centreBias[i] = 0.4 + 0.6 * Math.exp(-(cx * cx + cy * cy) / (2 * 0.3 * 0.3));
-  }
-  let farthest = 0;
-  for (const v of unlikeBorder) farthest = Math.max(farthest, v);
-  if (farthest < 6) return new Float64Array(count);
-  const norm = (a) => {
-    let max = 0;
-    for (const v of a) max = Math.max(max, v);
-    if (max > 0) for (let i = 0; i < a.length; i++) a[i] /= max;
-  };
-  norm(unlikeBorder);
-  norm(contrast);
-  const out = new Float64Array(count);
-  for (let i = 0; i < count; i++) out[i] = unlikeBorder[i] * (0.3 + 0.7 * contrast[i]) * centreBias[i];
-  norm(out);
-  return out;
-}
-function otsuThreshold(values, weights) {
-  const BINS2 = 64;
-  const hist = new Float64Array(BINS2);
-  let total = 0;
-  for (let i = 0; i < values.length; i++) {
-    hist[Math.min(BINS2 - 1, Math.floor(values[i] * BINS2))] += weights[i];
-    total += weights[i];
-  }
-  let sumAll = 0;
-  for (let b = 0; b < BINS2; b++) sumAll += b * hist[b];
-  let wB = 0;
-  let sumB = 0;
-  let best = 0;
-  let bestT = 0.5;
-  for (let b = 0; b < BINS2 - 1; b++) {
-    wB += hist[b];
-    if (!wB) continue;
-    const wF = total - wB;
-    if (!wF) break;
-    sumB += b * hist[b];
-    const between = wB * wF * (sumB / wB - (sumAll - sumB) / wF) ** 2;
-    if (between > best) {
-      best = between;
-      bestT = (b + 1) / BINS2;
-    }
-  }
-  return bestT;
-}
-function findSubject(pixels, options = {}) {
-  const work = workImage(pixels);
-  const { width: w, height: h } = work;
-  const sp = slicSuperpixels(work);
-  const sal = superpixelSaliency(sp, w, h);
-  const t = otsuThreshold(sal, sp.size);
-  const n = w * h;
-  const initial = new Uint8Array(n);
-  const hardBg = new Uint8Array(n);
-  const hardFg = new Uint8Array(n);
-  const strong = t + 0.6 * (1 - t);
-  for (let i = 0; i < n; i++) {
-    const s = sal[sp.label[i]];
-    if (s >= t) initial[i] = 1;
-    if (s >= strong) hardFg[i] = 1;
-  }
-  for (let x = 0; x < w; x++) {
-    for (const y of [0, h - 1]) if (sal[sp.label[y * w + x]] < t * 0.5) hardBg[y * w + x] = 1;
-  }
-  for (let y = 0; y < h; y++) {
-    for (const x of [0, w - 1]) if (sal[sp.label[y * w + x]] < t * 0.5) hardBg[y * w + x] = 1;
-  }
-  const empty = (reason) => ({ selection: createSelectionMask(pixels.width, pixels.height), reason });
-  let guessed = 0;
-  for (let i = 0; i < n; i++) guessed += initial[i];
-  if (!guessed || guessed > n * 0.95) return empty("Nothing stands out from the background.");
-  const roi = { x: 0, y: 0, width: w, height: h };
-  const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, 5);
-  keepMainPieces(label, w, h, null);
-  let kept = 0;
-  for (let i = 0; i < n; i++) kept += label[i];
-  if (kept < n * 2e-3) return empty("Nothing stands out from the background.");
-  if (kept > n * 0.97) return empty("The whole image looks like one subject; select it with select_all instead.");
-  return { selection: upscaleRegion(work, pixels, roi, label, options.enhanceEdge ?? false) };
-}
-
-// src/image-editor/selection/refine.ts
-var DEFAULT_REFINE_EDGE_PARAMS = {
-  radius: 0,
-  smartRadius: false,
-  smooth: 0,
-  feather: 0,
-  contrast: 0,
-  shiftEdge: 0
-};
-var GUIDED_FILTER_EPS = 1e-4;
-var fin = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
-function normalizeRefineEdgeParams(p = {}) {
-  return {
-    radius: Math.min(250, Math.max(0, fin(p.radius, 0))),
-    smartRadius: p.smartRadius === true,
-    smooth: Math.min(100, Math.max(0, fin(p.smooth, 0))),
-    feather: Math.min(1e3, Math.max(0, fin(p.feather, 0))),
-    contrast: Math.min(100, Math.max(0, fin(p.contrast, 0))),
-    shiftEdge: Math.min(100, Math.max(-100, fin(p.shiftEdge, 0)))
-  };
-}
-var gfRadius = (p) => Math.min(64, Math.max(1, Math.ceil(p.radius)));
-var smoothSigma = (p) => p.smooth / 100 * 4;
-var featherSigma = (p) => p.feather / 2;
-function shiftAmount(p) {
-  const px2 = p.shiftEdge / 100 * Math.max(p.radius, 4);
-  return Number.isFinite(px2) ? Math.min(64, Math.max(-64, px2)) : 0;
-}
-function refineEdgeHalo(params = {}) {
-  const p = normalizeRefineEdgeParams(params);
-  const g = gfRadius(p);
-  const edge = p.radius > 0 ? Math.max(Math.ceil(p.radius), 2 * g + (p.smartRadius ? g + 1 : 0)) : 0;
-  return edge + Math.ceil(3 * smoothSigma(p)) + Math.ceil(3 * featherSigma(p)) + Math.ceil(Math.abs(shiftAmount(p))) + 2;
-}
-function boxMean(src, w, h, r) {
-  const tmp = new Float32Array(w * h);
-  const pre = new Float64Array(Math.max(w, h) + 1);
-  for (let y = 0; y < h; y++) {
-    const row = y * w;
-    for (let x = 0; x < w; x++) pre[x + 1] = pre[x] + src[row + x];
-    for (let x = 0; x < w; x++) {
-      const lo = Math.max(0, x - r);
-      const hi = Math.min(w, x + r + 1);
-      tmp[row + x] = (pre[hi] - pre[lo]) / (hi - lo);
-    }
-  }
-  const out = new Float32Array(w * h);
-  for (let x = 0; x < w; x++) {
-    for (let y = 0; y < h; y++) pre[y + 1] = pre[y] + tmp[y * w + x];
-    for (let y = 0; y < h; y++) {
-      const lo = Math.max(0, y - r);
-      const hi = Math.min(h, y + r + 1);
-      out[y * w + x] = (pre[hi] - pre[lo]) / (hi - lo);
-    }
-  }
-  return out;
-}
-function guidedFilterColor(guide, p, w, h, r, eps = GUIDED_FILTER_EPS) {
-  const n = w * h;
-  const [c0, c1, c2] = guide;
-  const prod = (a, b2) => {
-    const o = new Float32Array(n);
-    for (let i = 0; i < n; i++) o[i] = a[i] * b2[i];
-    return o;
-  };
-  const m0 = boxMean(c0, w, h, r);
-  const m1 = boxMean(c1, w, h, r);
-  const m2 = boxMean(c2, w, h, r);
-  const mp = boxMean(p, w, h, r);
-  const mip0 = boxMean(prod(c0, p), w, h, r);
-  const mip1 = boxMean(prod(c1, p), w, h, r);
-  const mip2 = boxMean(prod(c2, p), w, h, r);
-  const s00 = boxMean(prod(c0, c0), w, h, r);
-  const s01 = boxMean(prod(c0, c1), w, h, r);
-  const s02 = boxMean(prod(c0, c2), w, h, r);
-  const s11 = boxMean(prod(c1, c1), w, h, r);
-  const s12 = boxMean(prod(c1, c2), w, h, r);
-  const s22 = boxMean(prod(c2, c2), w, h, r);
-  const a0 = new Float32Array(n);
-  const a1 = new Float32Array(n);
-  const a2 = new Float32Array(n);
-  const b = new Float32Array(n);
-  for (let i = 0; i < n; i++) {
-    const u0 = m0[i], u1 = m1[i], u2 = m2[i], up = mp[i];
-    const rr = s00[i] - u0 * u0 + eps;
-    const rg = s01[i] - u0 * u1;
-    const rb = s02[i] - u0 * u2;
-    const gg = s11[i] - u1 * u1 + eps;
-    const gb = s12[i] - u1 * u2;
-    const bb = s22[i] - u2 * u2 + eps;
-    const v0 = mip0[i] - u0 * up;
-    const v1 = mip1[i] - u1 * up;
-    const v2 = mip2[i] - u2 * up;
-    const i00 = gg * bb - gb * gb;
-    const i01 = gb * rb - rg * bb;
-    const i02 = rg * gb - gg * rb;
-    const i11 = rr * bb - rb * rb;
-    const i12 = rb * rg - rr * gb;
-    const i22 = rr * gg - rg * rg;
-    const det = rr * i00 + rg * i01 + rb * i02;
-    let x0 = 0, x1 = 0, x2 = 0;
-    if (Math.abs(det) >= 1e-30) {
-      x0 = (i00 * v0 + i01 * v1 + i02 * v2) / det;
-      x1 = (i01 * v0 + i11 * v1 + i12 * v2) / det;
-      x2 = (i02 * v0 + i12 * v1 + i22 * v2) / det;
-    }
-    a0[i] = x0;
-    a1[i] = x1;
-    a2[i] = x2;
-    b[i] = up - x0 * u0 - x1 * u1 - x2 * u2;
-  }
-  const ma0 = boxMean(a0, w, h, r);
-  const ma1 = boxMean(a1, w, h, r);
-  const ma2 = boxMean(a2, w, h, r);
-  const mb = boxMean(b, w, h, r);
-  const out = new Float32Array(n);
-  for (let i = 0; i < n; i++) out[i] = ma0[i] * c0[i] + ma1[i] * c1[i] + ma2[i] * c2[i] + mb[i];
-  return out;
-}
-function edgeWidth(guide, w, h, r) {
-  const n = w * h;
-  const y = new Float32Array(n);
-  for (let i = 0; i < n; i++) y[i] = 0.299 * guide[0][i] + 0.587 * guide[1][i] + 0.114 * guide[2][i];
-  const g = new Float32Array(n);
-  for (let yy = 0; yy < h; yy++) {
-    for (let xx = 0; xx < w; xx++) {
-      const gx = (y[yy * w + Math.min(w - 1, xx + 1)] - y[yy * w + Math.max(0, xx - 1)]) / 2;
-      const gy = (y[Math.min(h - 1, yy + 1) * w + xx] - y[Math.max(0, yy - 1) * w + xx]) / 2;
-      g[yy * w + xx] = Math.sqrt(gx * gx + gy * gy);
-    }
-  }
-  const gm = greyMorphology(g, w, h, r, true);
-  const hi = greyMorphology(y, w, h, r, true);
-  const lo = greyMorphology(y, w, h, r, false);
-  const out = new Float32Array(n);
-  for (let i = 0; i < n; i++) out[i] = (hi[i] - lo[i]) / Math.max(gm[i], 1e-4);
-  return out;
-}
-function refineCoverage(guide, m, w, h, params = {}, band = null) {
-  const p = normalizeRefineEdgeParams(params);
-  let a = Float32Array.from(m);
-  if ((p.radius > 0 || band) && guide) {
-    const n = w * h;
-    const boundary = new Uint8Array(n);
-    let any = false;
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        const i = y * w + x;
-        const v = m[i] >= 0.5;
-        const diff = x > 0 && m[i - 1] >= 0.5 !== v || x + 1 < w && m[i + 1] >= 0.5 !== v || y > 0 && m[i - w] >= 0.5 !== v || y + 1 < h && m[i + w] >= 0.5 !== v;
-        if (diff) {
-          boundary[i] = 1;
-          any = true;
-        }
-      }
-    }
-    if (any || band) {
-      const dist = distanceTransform(boundary, w, h);
-      const r = band ? Math.max(4, gfRadius(p)) : gfRadius(p);
-      const q = guidedFilterColor(guide, m, w, h, r);
-      const widths = p.smartRadius ? edgeWidth(guide, w, h, r) : null;
-      for (let i = 0; i < n; i++) {
-        const reff = widths ? Math.min(Math.max(p.radius, 1.5), Math.max(1.5, widths[i])) : p.radius;
-        const edge = p.radius > 0 ? Math.min(1, Math.max(0, reff + 1 - dist[i])) : 0;
-        const wgt = band ? Math.max(edge, Math.min(1, Math.max(0, band[i]))) : edge;
-        if (wgt > 0) {
-          const qi = Math.min(1, Math.max(0, q[i]));
-          a[i] = m[i] + (qi - m[i]) * wgt;
-        }
+      const dq = Math.min(1, Math.abs(dirX[q] * lx + dirY[q] * ly));
+      const fD = (Math.acos(dp) + Math.acos(dq)) / Math.PI;
+      const fG = 1 - strength[q] * scale;
+      const fZ = 1 - zero[q];
+      const cost = (W_ZERO * fZ + W_GRADIENT * fG + W_DIRECTION * fD + 0.01) * step;
+      const nd = d + cost;
+      if (nd < dist[q]) {
+        dist[q] = nd;
+        prev[q] = p;
+        heap.push(q, nd);
       }
     }
   }
-  const ss = smoothSigma(p);
-  if (ss >= 0.3) {
-    a = gaussianBlur(a, w, h, ss, "clamp");
-    const gain = 1 + ss;
-    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
-  }
-  a = gaussianBlur(a, w, h, featherSigma(p), "clamp");
-  if (p.contrast > 0) {
-    const gain = 1 / (1 - 0.99 * p.contrast / 100);
-    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  if (prev[goal] < 0) return [{ x: ax + 0.5, y: ay + 0.5 }, { x: bx + 0.5, y: by + 0.5 }];
+  const path = [];
+  for (let p = goal; p >= 0; p = prev[p]) {
+    const x = p % w;
+    path.push({ x: rx0 + x + 0.5, y: ry0 + (p - x) / w + 0.5 });
   }
-  const amount = shiftAmount(p);
-  if (Math.abs(amount) >= 1e-4) a = shiftCoverage(a, w, h, amount);
-  return a;
+  return path.reverse();
 }
-function guidePlanes(pixels, win) {
-  const box = win ?? { x: 0, y: 0, width: pixels.width, height: pixels.height };
-  const n = box.width * box.height;
-  const r = new Float32Array(n);
-  const g = new Float32Array(n);
-  const b = new Float32Array(n);
-  const d = pixels.data;
-  for (let y = 0; y < box.height; y++) {
-    for (let x = 0; x < box.width; x++) {
-      const i = y * box.width + x;
-      const p = ((box.y + y) * pixels.width + box.x + x) * 4;
-      r[i] = d[p] / 255;
-      g[i] = d[p + 1] / 255;
-      b[i] = d[p + 2] / 255;
-    }
-  }
-  return [r, g, b];
-}
-function refineSelection(pixels, mask, params = {}, refineBrush = null) {
-  const p = normalizeRefineEdgeParams(params);
-  if (pixels && (pixels.width !== mask.width || pixels.height !== mask.height)) {
-    throw new Error("Refine Edge needs pixels the size of the selection");
-  }
-  if (!mask.bounds) return mask;
-  const brush = refineBrush?.bounds ? refineBrush : null;
-  const halo = refineEdgeHalo(p) + (brush ? 2 * Math.max(4, gfRadius(p)) : 0);
-  const b = brush ? {
-    x: Math.min(mask.bounds.x, brush.bounds.x),
-    y: Math.min(mask.bounds.y, brush.bounds.y),
-    r: Math.max(mask.bounds.x + mask.bounds.width, brush.bounds.x + brush.bounds.width),
-    btm: Math.max(mask.bounds.y + mask.bounds.height, brush.bounds.y + brush.bounds.height)
-  } : { x: mask.bounds.x, y: mask.bounds.y, r: mask.bounds.x + mask.bounds.width, btm: mask.bounds.y + mask.bounds.height };
-  const x0 = Math.max(0, b.x - halo);
-  const y0 = Math.max(0, b.y - halo);
-  const x1 = Math.min(mask.width, b.r + halo);
-  const y1 = Math.min(mask.height, b.btm + halo);
-  const ww = x1 - x0;
-  const wh = y1 - y0;
-  const m = new Float32Array(ww * wh);
-  for (let y = 0; y < wh; y++) {
-    const src = (y0 + y) * mask.width + x0;
-    for (let x = 0; x < ww; x++) m[y * ww + x] = mask.data[src + x] / 255;
-  }
-  const guide = pixels && (p.radius > 0 || brush) ? guidePlanes(pixels, { x: x0, y: y0, width: ww, height: wh }) : null;
-  let band = null;
-  if (brush) {
-    band = new Float32Array(ww * wh);
-    const bd = brush.data;
-    for (let y = 0; y < wh; y++) {
-      const src = (y0 + y) * mask.width + x0;
-      for (let x = 0; x < ww; x++) band[y * ww + x] = bd[src + x] / 255;
-    }
-  }
-  const refined = refineCoverage(guide, m, ww, wh, p, band);
-  const out = new Uint8Array(mask.width * mask.height);
-  for (let y = 0; y < wh; y++) {
-    const dst = (y0 + y) * mask.width + x0;
-    for (let x = 0; x < ww; x++) out[dst + x] = coverageToByte(refined[y * ww + x]);
-  }
-  return createSelectionMask(mask.width, mask.height, out);
-}
-function decontaminateColors(rgba, coverage, w, h, amount, radius = 8) {
-  const out = Uint8ClampedArray.from(rgba);
-  const n = w * h;
-  const k = Math.min(1, Math.max(0, amount));
-  if (k === 0) return out;
-  const r = Math.max(2, Math.round(radius));
-  const fgW = new Float32Array(n);
-  const bgW = new Float32Array(n);
-  for (let i = 0; i < n; i++) {
-    fgW[i] = coverage[i] >= 250 ? 1 : 0;
-    bgW[i] = coverage[i] <= 5 ? 1 : 0;
-  }
-  const meanOf = (weights, radiusPx) => {
-    const wm = boxMean(weights, w, h, radiusPx);
-    const planes = [0, 1, 2].map((c) => {
-      const v = new Float32Array(n);
-      for (let i = 0; i < n; i++) v[i] = rgba[i * 4 + c] * weights[i];
-      const m = boxMean(v, w, h, radiusPx);
-      for (let i = 0; i < n; i++) m[i] = wm[i] > 1e-6 ? m[i] / wm[i] : NaN;
-      return m;
-    });
-    return { weight: wm, planes };
-  };
-  const fg = meanOf(fgW, r);
-  const fgWide = meanOf(fgW, r * 3);
-  const bg = meanOf(bgW, r);
-  for (let i = 0; i < n; i++) {
-    const c = coverage[i];
-    if (c <= 5 || c >= 250) continue;
-    const a = c / 255;
-    for (let ch = 0; ch < 3; ch++) {
-      const C = rgba[i * 4 + ch];
-      const B = bg.planes[ch][i];
-      const Fm = Number.isNaN(fg.planes[ch][i]) ? fgWide.planes[ch][i] : fg.planes[ch][i];
-      let F;
-      if (a >= 0.5 && !Number.isNaN(B)) F = (C - (1 - a) * B) / a;
-      else if (!Number.isNaN(Fm)) F = Fm;
-      else F = C;
-      out[i * 4 + ch] = Math.round(C + k * (Math.min(255, Math.max(0, F)) - C));
-    }
+function simplifyPixelPath(points) {
+  if (points.length < 3) return points.slice();
+  const out = [points[0]];
+  for (let i = 1; i < points.length - 1; i++) {
+    const a = out[out.length - 1];
+    const b = points[i];
+    const c = points[i + 1];
+    const cross = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+    if (Math.abs(cross) > 1e-9) out.push(b);
   }
+  out.push(points[points.length - 1]);
   return out;
 }
-
-// src/image-editor/selection/segment/guided.ts
-function workPlanes(work) {
-  const n = work.width * work.height;
-  const planes = [new Float32Array(n), new Float32Array(n), new Float32Array(n)];
-  for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) planes[c][i] = work.rgb[i * 3 + c] / 255;
-  return planes;
-}
-function workLuma(work) {
-  const n = work.width * work.height;
-  const out = new Float32Array(n);
-  const { rgb } = work;
-  for (let i = 0; i < n; i++) out[i] = (0.299 * rgb[i * 3] + 0.587 * rgb[i * 3 + 1] + 0.114 * rgb[i * 3 + 2]) / 255;
-  return out;
-}
-function softMaskToSelection(work, mask) {
-  const { sourceWidth: W, sourceHeight: H, width: w, height: h, scale } = work;
-  const out = new Uint8Array(W * H);
-  const col = new Int32Array(W);
-  const fx = new Float32Array(W);
-  for (let X = 0; X < W; X++) {
-    const u = Math.min(w - 1, Math.max(0, (X + 0.5) * scale - 0.5));
-    col[X] = Math.min(w - 2, Math.floor(u));
-    fx[X] = u - col[X];
-    if (w === 1) {
-      col[X] = 0;
-      fx[X] = 0;
-    }
-  }
-  for (let Y = 0; Y < H; Y++) {
-    const v = Math.min(h - 1, Math.max(0, (Y + 0.5) * scale - 0.5));
-    const j = h === 1 ? 0 : Math.min(h - 2, Math.floor(v));
-    const fy = h === 1 ? 0 : v - j;
-    const r0 = j * w;
-    const r1 = h === 1 ? r0 : r0 + w;
-    for (let X = 0; X < W; X++) {
-      const i = col[X];
-      const i1 = w === 1 ? i : i + 1;
-      const t = fx[X];
-      const m = (mask[r0 + i] * (1 - t) + mask[r0 + i1] * t) * (1 - fy) + (mask[r1 + i] * (1 - t) + mask[r1 + i1] * t) * fy;
-      out[Y * W + X] = Math.round(Math.min(1, Math.max(0, m)) * 255);
-    }
-  }
-  return selectionFromRegion(W, H, { x: 0, y: 0, width: W, height: H }, out);
-}
-
-// src/image-editor/selection/segment/focus.ts
-var FOCUS_SIZE = 1024;
-function estimateNoise(luma2, w, h) {
-  if (w < 3 || h < 3) return 0;
-  let sum = 0;
-  for (let y = 1; y < h - 1; y++) {
-    for (let x = 1; x < w - 1; x++) {
-      const i = y * w + x;
-      const v = luma2[i - w - 1] - 2 * luma2[i - w] + luma2[i - w + 1] - 2 * luma2[i - 1] + 4 * luma2[i] - 2 * luma2[i + 1] + luma2[i + w - 1] - 2 * luma2[i + w] + luma2[i + w + 1];
-      sum += Math.abs(v);
-    }
+function snapPolygonToEdges(pixels, points, options = {}) {
+  const map = pixels instanceof EdgeMap ? pixels : new EdgeMap(pixels, options);
+  const width = options.width ?? 10;
+  const snapped = points.map((p) => snapToEdge(map, p, width));
+  const out = [];
+  for (let i = 0; i < snapped.length; i++) {
+    const a = snapped[i];
+    const b = snapped[(i + 1) % snapped.length];
+    const seg = liveWire(map, a, b, Math.max(2 * width, 16, Math.hypot(b.x - a.x, b.y - a.y) / 4));
+    out.push(...seg.slice(0, -1));
   }
-  return Math.sqrt(Math.PI / 2) * sum / (6 * (w - 2) * (h - 2));
-}
-function focusArea(pixels, options = {}) {
-  const work = workImage(pixels, FOCUS_SIZE);
-  const { width: w, height: h, scale } = work;
-  const n = w * h;
-  const luma2 = workLuma(work);
-  const sigma = estimateNoise(luma2, w, h);
-  const noise = Math.min(100, Math.max(0, options.noise ?? 0));
-  const floor = 2 * sigma * (1 + noise / 25);
-  const detail = new Float32Array(n);
-  for (let y = 1; y < h - 1; y++) {
-    for (let x = 1; x < w - 1; x++) {
-      const i = y * w + x;
-      const lap = Math.abs(4 * luma2[i] - luma2[i - 1] - luma2[i + 1] - luma2[i - w] - luma2[i + w]);
-      const d = Math.max(0, lap - floor);
-      detail[i] = d * d;
-    }
-  }
-  const r = Math.max(2, Math.round(0.012 * Math.max(w, h)));
-  const energy = boxMean(detail, w, h, r);
-  const sharp = new Float32Array(n);
-  for (let i = 0; i < n; i++) sharp[i] = Math.log1p(Math.sqrt(energy[i]) * 400);
-  const sorted = Float32Array.from(sharp).sort();
-  const top = sorted[Math.floor(n * 0.995)] || 1;
-  for (let i = 0; i < n; i++) sharp[i] = Math.min(1, sharp[i] / top);
-  const ones = new Float32Array(n).fill(1);
-  const otsu = otsuThreshold(sharp, ones);
-  const range = Math.min(100, Math.max(0, options.range ?? 50));
-  const t = Math.min(0.98, otsu * Math.pow(2, (50 - range) / 25));
-  let mask = new Float32Array(n);
-  for (let i = 0; i < n; i++) mask[i] = sharp[i] >= t ? 1 : 0;
-  const c = 2 * r;
-  const grown = boxMean(mask, w, h, c);
-  for (let i = 0; i < n; i++) grown[i] = grown[i] > 1e-3 ? 1 : 0;
-  const shrunk = boxMean(grown, w, h, c);
-  for (let i = 0; i < n; i++) mask[i] = shrunk[i] >= 0.999 ? 1 : 0;
-  const pulled = boxMean(mask, w, h, Math.max(1, Math.round(r / 2)));
-  for (let i = 0; i < n; i++) mask[i] = pulled[i] >= 0.999 ? 1 : 0;
-  const softness = Math.max(0, options.softness ?? 4) * scale;
-  if (softness > 0) {
-    const fitted = guidedFilterColor(workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
-    for (let i = 0; i < n; i++) mask[i] = Math.min(1, Math.max(0, fitted[i]));
-  }
-  return { selection: softMaskToSelection(work, mask), noiseLevel: Math.round(sigma * 255 * 10) / 10 };
+  return simplifyPixelPath(out);
 }
-
-// src/image-editor/selection/segment/sky.ts
-var SKY_SIZE = 768;
-function lab(r, g, b) {
-  const lin = (v) => {
-    v /= 255;
-    return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
-  };
-  const R = lin(r);
-  const G = lin(g);
-  const B = lin(b);
-  const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
-  const x = f((0.4124 * R + 0.3576 * G + 0.1805 * B) / 0.95047);
-  const y = f(0.2126 * R + 0.7152 * G + 0.0722 * B);
-  const z = f((0.0193 * R + 0.1192 * G + 0.9505 * B) / 1.08883);
-  return [116 * y - 16, 500 * (x - y), 200 * (y - z)];
-}
-var sigmoid = (v) => 1 / (1 + Math.exp(-v));
-function findSky(pixels, options = {}) {
-  const work = workImage(pixels, SKY_SIZE);
-  const { width: w, height: h, rgb, scale } = work;
-  const n = w * h;
-  const L = new Float32Array(n);
-  const A = new Float32Array(n);
-  const B = new Float32Array(n);
-  for (let i = 0; i < n; i++) {
-    const [l, a, b] = lab(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
-    L[i] = l;
-    A[i] = a;
-    B[i] = b;
-  }
-  const luma2 = boxMean(workLuma(work), w, h, 1);
-  const grad = new Float32Array(n);
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      const i = y * w + x;
-      const gx = x + 1 < w ? luma2[i + 1] - luma2[i] : 0;
-      const gy = y + 1 < h ? luma2[i + w] - luma2[i] : 0;
-      grad[i] = Math.hypot(gx, gy);
-    }
-  }
-  const roughR = Math.max(1, Math.round(6e-3 * Math.max(w, h)));
-  const rough = boxMean(grad, w, h, roughR);
-  const score = new Float32Array(n);
-  for (let i = 0; i < n; i++) {
-    const chroma = Math.hypot(A[i], B[i]);
-    const blue = sigmoid((-B[i] - 6) / 4) * sigmoid((L[i] - 35) / 6);
-    const grey = sigmoid((L[i] - 68) / 5) * sigmoid((18 - chroma) / 4);
-    const smooth = Math.exp(-rough[i] / 0.02);
-    const y = Math.floor(i / w) / h;
-    const high = 1 - 0.35 * y;
-    score[i] = Math.max(blue, grey) * smooth * high;
-  }
-  const threshold = Math.min(100, Math.max(0, options.threshold ?? 50));
-  const t = 0.55 - (threshold - 50) * 6e-3;
-  const sky = new Uint8Array(n);
-  const stack = [];
-  const seedRows = Math.max(1, Math.round(h * 0.04));
-  for (let y = 0; y < seedRows; y++) {
-    for (let x = 0; x < w; x++) {
-      const i = y * w + x;
-      if (score[i] >= t) {
-        sky[i] = 1;
-        stack.push(i);
-      }
-    }
-  }
-  if (!stack.length) return { selection: createSelectionMask(pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
-  const low = t * 0.7;
-  while (stack.length) {
-    const p = stack.pop();
-    const x = p % w;
-    for (const q of [x + 1 < w ? p + 1 : -1, x > 0 ? p - 1 : -1, p + w < n ? p + w : -1, p - w]) {
-      if (q < 0 || sky[q] || score[q] < low) continue;
-      if (Math.hypot(L[q] - L[p], A[q] - A[p], B[q] - B[p]) > 6) continue;
-      sky[q] = 1;
-      stack.push(q);
-    }
-  }
-  let count = 0;
-  const mean = [0, 0, 0];
-  for (let i = 0; i < n; i++) {
-    if (!sky[i]) continue;
-    mean[0] += L[i];
-    mean[1] += A[i];
-    mean[2] += B[i];
-    count++;
-  }
-  for (let k = 0; k < 3; k++) mean[k] /= count;
-  let spread = 0;
-  for (let i = 0; i < n; i++) if (sky[i]) spread += (L[i] - mean[0]) ** 2 + (A[i] - mean[1]) ** 2 + (B[i] - mean[2]) ** 2;
-  const limit = Math.max(8, 2.5 * Math.sqrt(spread / count));
-  for (let i = 0; i < n; i++) {
-    if (sky[i] || score[i] < t) continue;
-    if (Math.hypot(L[i] - mean[0], A[i] - mean[1], B[i] - mean[2]) <= limit) sky[i] = 1;
-  }
-  let front = [];
-  for (let i = 0; i < n; i++) if (sky[i]) front.push(i);
-  for (let step = 0; step <= roughR + 1 && front.length; step++) {
-    const next = [];
-    for (const p of front) {
-      const x = p % w;
-      for (const q of [x + 1 < w ? p + 1 : -1, x > 0 ? p - 1 : -1, p + w < n ? p + w : -1, p - w]) {
-        if (q < 0 || sky[q]) continue;
-        if (Math.hypot(L[q] - mean[0], A[q] - mean[1], B[q] - mean[2]) > limit) continue;
-        sky[q] = 1;
-        next.push(q);
-      }
-    }
-    front = next;
-  }
-  if (count < n * 5e-3) return { selection: createSelectionMask(pixels.width, pixels.height), reason: "No sky was found along the top of the image." };
-  let mask = Float32Array.from(sky);
-  const softness = Math.max(0, options.softness ?? 4) * scale;
-  if (softness > 0) {
-    const fitted = guidedFilterColor(workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
-    mask = new Float32Array(n);
-    for (let i = 0; i < n; i++) mask[i] = Math.min(1, Math.max(0, fitted[i]));
-  }
-  return { selection: softMaskToSelection(work, mask) };
+function magneticAnchorSpacing(frequency = 57) {
+  const f = Math.min(100, Math.max(0, frequency));
+  return 8 + (100 - f);
 }
 
 // src/image-editor/layers/shape-type-ui.ts
@@ -4843,123 +3308,6 @@ var TypeToolGesture = class {
   }
 };
 
-// src/image-editor/selection/shapes.ts
-function polygonCoverage(points, width, height, antiAlias = true) {
-  const { box, coverage } = polygonCoverageBox(points, width, height, antiAlias);
-  if (!box || box.width === width && box.height === height) return box ? coverage : new Float32Array(width * height);
-  const m = new Float32Array(width * height);
-  for (let y = 0; y < box.height; y++) m.set(coverage.subarray(y * box.width, (y + 1) * box.width), (box.y + y) * width + box.x);
-  return m;
-}
-function polygonCoverageBox(points, width, height, antiAlias = true) {
-  const none = { box: null, coverage: new Float32Array(0) };
-  if (points.length < 3 || width <= 0 || height <= 0) return none;
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const p of points) {
-    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) continue;
-    minX = Math.min(minX, p.x);
-    minY = Math.min(minY, p.y);
-    maxX = Math.max(maxX, p.x);
-    maxY = Math.max(maxY, p.y);
-  }
-  const bx0 = Math.max(0, Math.floor(minX));
-  const by0 = Math.max(0, Math.floor(minY));
-  const bx1 = Math.min(width, Math.ceil(maxX));
-  const by1 = Math.min(height, Math.ceil(maxY));
-  if (!(bx1 > bx0 && by1 > by0)) return none;
-  const bw = bx1 - bx0;
-  const m = new Float32Array(bw * (by1 - by0));
-  const sub2 = antiAlias ? 4 : 1;
-  const edges = [];
-  for (let i = 0; i < points.length; i++) {
-    const a = points[i];
-    const b = points[(i + 1) % points.length];
-    if (![a.x, a.y, b.x, b.y].every(Number.isFinite)) continue;
-    if (a.y < b.y) edges.push({ top: a.y, bottom: b.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
-    else if (b.y < a.y) edges.push({ top: b.y, bottom: a.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
-  }
-  edges.sort((p, q) => p.top - q.top);
-  let next = 0;
-  let active = [];
-  const xs = [];
-  for (let py = by0; py < by1; py++) {
-    const row = (py - by0) * bw - bx0;
-    for (let s = 0; s < sub2; s++) {
-      const y = py + (s + 0.5) / sub2;
-      while (next < edges.length && edges[next].top <= y) active.push(edges[next++]);
-      if (active.length) active = active.filter((e) => e.bottom > y);
-      if (!active.length) continue;
-      xs.length = 0;
-      for (const e of active) {
-        if (e.top <= y) xs.push(e.ax + (y - e.ay) / (e.by - e.ay) * (e.bx - e.ax));
-      }
-      xs.sort((a, b) => a - b);
-      for (let k = 0; k + 1 < xs.length; k += 2) {
-        const x0 = Math.max(0, xs[k]);
-        const x1 = Math.min(width, xs[k + 1]);
-        if (x1 <= x0) continue;
-        const c0 = Math.floor(x0);
-        const c1 = Math.min(width, Math.ceil(x1));
-        for (let cx = c0; cx < c1; cx++) {
-          let cov;
-          if (antiAlias) cov = Math.min(cx + 1, x1) - Math.max(cx, x0);
-          else {
-            const c = cx + 0.5;
-            cov = c >= x0 && c < x1 ? 1 : 0;
-          }
-          if (cov > 0) m[row + cx] += cov / sub2;
-        }
-      }
-    }
-  }
-  for (let i = 0; i < m.length; i++) if (m[i] > 1) m[i] = 1;
-  return { box: { x: bx0, y: by0, width: bw, height: by1 - by0 }, coverage: m };
-}
-function polygonSelection(width, height, points, options = {}) {
-  const { box, coverage } = polygonCoverageBox(points, width, height, options.antiAlias ?? true);
-  if (!box) return createSelectionMask(width, height);
-  const out = new Uint8Array(coverage.length);
-  for (let i = 0; i < out.length; i++) out[i] = coverageToByte(coverage[i]);
-  return selectionFromRegion(width, height, box, out);
-}
-function normalizeRect(rect) {
-  const x = rect.width < 0 ? rect.x + rect.width : rect.x;
-  const y = rect.height < 0 ? rect.y + rect.height : rect.y;
-  return { x, y, width: Math.abs(rect.width), height: Math.abs(rect.height) };
-}
-function rectSelection(width, height, rect, options = {}) {
-  const r = normalizeRect(rect);
-  const pts = [
-    { x: r.x, y: r.y },
-    { x: r.x + r.width, y: r.y },
-    { x: r.x + r.width, y: r.y + r.height },
-    { x: r.x, y: r.y + r.height }
-  ];
-  return polygonSelection(width, height, pts, options);
-}
-function ellipsePoints(rect) {
-  const r = normalizeRect(rect);
-  const rx = r.width / 2;
-  const ry = r.height / 2;
-  const cx = r.x + rx;
-  const cy = r.y + ry;
-  const rmax = Math.max(rx, ry, 0.5);
-  const step = Math.sqrt(0.4 / rmax);
-  const n = Math.min(4096, Math.max(16, Math.ceil(2 * Math.PI / step)));
-  const pts = [];
-  for (let i = 0; i < n; i++) {
-    const t = i / n * 2 * Math.PI;
-    pts.push({ x: cx + rx * Math.cos(t), y: cy + ry * Math.sin(t) });
-  }
-  return pts;
-}
-function ellipseSelection(width, height, rect, options = {}) {
-  return polygonSelection(width, height, ellipsePoints(rect), options);
-}
-
 // src/image-editor/selection/wand.ts
 function checkPixels(p) {
   const n = p.width * p.height;
@@ -5319,66 +3667,6 @@ function segmentsToSelection(width, height, results) {
   return out;
 }
 
-// src/image-editor/selection/refine-edits.ts
-var REFINE_EDIT_KINDS = ["quick-select", "brush", "refine-brush"];
-function brushStrokeMask(width, height, points, size, hardness = 1) {
-  const r = Math.max(0.5, size / 2);
-  const solid = r * Math.min(1, Math.max(0, hardness));
-  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
-  for (const p of points) {
-    x0 = Math.min(x0, p.x);
-    y0 = Math.min(y0, p.y);
-    x1 = Math.max(x1, p.x);
-    y1 = Math.max(y1, p.y);
-  }
-  const bx = Math.max(0, Math.floor(x0 - r - 1));
-  const by = Math.max(0, Math.floor(y0 - r - 1));
-  const bw = Math.min(width, Math.ceil(x1 + r + 1)) - bx;
-  const bh = Math.min(height, Math.ceil(y1 + r + 1)) - by;
-  if (!(bw > 0 && bh > 0)) return createSelectionMask(width, height);
-  const out = new Uint8Array(bw * bh);
-  const segs = points.length === 1 ? [[points[0], points[0]]] : points.slice(1).map((p, i) => [points[i], p]);
-  for (let y = 0; y < bh; y++) {
-    for (let x = 0; x < bw; x++) {
-      const px2 = bx + x + 0.5;
-      const py = by + y + 0.5;
-      let d = Infinity;
-      for (const [a, b] of segs) {
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        const len2 = dx * dx + dy * dy;
-        const t = len2 > 0 ? Math.min(1, Math.max(0, ((px2 - a.x) * dx + (py - a.y) * dy) / len2)) : 0;
-        d = Math.min(d, Math.hypot(px2 - a.x - t * dx, py - a.y - t * dy));
-      }
-      let v = d <= solid ? 1 : solid >= r ? 0 : 1 - (d - solid) / (r - solid);
-      v = Math.min(v, Math.min(1, Math.max(0, r + 0.5 - d)));
-      out[y * bw + x] = Math.round(Math.max(0, v) * 255);
-    }
-  }
-  return selectionFromRegion(width, height, { x: bx, y: by, width: bw, height: bh }, out);
-}
-function applyRefineEdits(pixels, selection, edits, width, height) {
-  let sel = selection?.bounds ? selection : null;
-  let band = null;
-  for (const e of edits) {
-    if (!e.points.length) throw new Error(`A ${e.kind} stroke needs at least one point.`);
-    if (e.kind === "refine-brush") {
-      band = combineSelections(band, brushStrokeMask(width, height, e.points, e.size ?? 40), "add");
-      continue;
-    }
-    const mode = e.mode ?? "add";
-    let region;
-    if (e.kind === "quick-select") {
-      if (!pixels) throw new Error("Quick Selection strokes need the image pixels.");
-      region = quickSelectStroke(pixels, e.points, { size: e.size, selection: sel, grow: mode === "add" });
-    } else {
-      region = brushStrokeMask(width, height, e.points, e.size ?? 20, e.hardness ?? 1);
-    }
-    sel = combineSelections(sel, region, mode);
-  }
-  return { selection: sel, refineBrush: band };
-}
-
 // src/image-editor/selection/stroke.ts
 function selectionRing(sel, width, location) {
   const half = location === "center" ? width / 2 : width;
@@ -6183,10 +4471,10 @@ function colorModePlanes(doc, mode) {
   }
   const t = Transform.create(src, builtinProfile("lab-d50"), { intent: "relative", bpc: false });
   return (rgba, n) => {
-    const lab2 = new Uint8Array(n * 4);
-    t.convert8(rgba, 4, lab2, 4, false);
+    const lab = new Uint8Array(n * 4);
+    t.convert8(rgba, 4, lab, 4, false);
     const planes = [0, 1, 2].map(() => new Uint8Array(n));
-    for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) planes[c][i] = lab2[i * 4 + c];
+    for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) planes[c][i] = lab[i * 4 + c];
     return planes;
   };
 }
@@ -6814,6 +5102,7 @@ var ImageEditorController = class {
   compositor = new LayerCompositor();
   /** The segmentation provider behind `selectSubject` (see `setSegmentationProvider`). */
   segmentation = null;
+  selectionWorker = null;
   /** The effects provider slot (see `setEffectsProvider`). */
   effects = new EffectsSlot();
   /** Renders provider effects: effect smart filter results and effect layers. */
@@ -6824,6 +5113,7 @@ var ImageEditorController = class {
     this.effectsEngine.subscribe(() => this.queueEffectRefresh("incomplete"));
     if (options.effects) this.effects.set(options.effects);
     if (options.segmentation) this.segmentation = options.segmentation;
+    if (options.selectionWorker) this.selectionWorker = new SelectionWorkerClient(options.selectionWorker);
     this.maxHistoryDepth = options.maxHistoryDepth ?? 50;
     if (options.textShaper !== void 0) this.textShaperValue = options.textShaper;
     this.maxHistoryBytes = options.maxHistoryBytes ?? 512 * 1024 * 1024;
@@ -7013,6 +5303,30 @@ var ImageEditorController = class {
   get segmentationProvider() {
     return this.segmentation;
   }
+  /**
+   * Runs the long selections in a Web Worker made by `factory` (or with `null`, on the page again).
+   * A worker that is cancelled or fails is replaced by a fresh one on the next job.
+   */
+  setSelectionWorker(factory) {
+    this.selectionWorker?.terminate();
+    this.selectionWorker = factory ? new SelectionWorkerClient(factory) : null;
+  }
+  /** Whether the long selections run in a worker. */
+  get hasSelectionWorker() {
+    return this.selectionWorker !== null;
+  }
+  /**
+   * Runs a long selection job on `pixels`: in the worker when there is one, else here (which
+   * blocks the page until it is done). `signal` cancels it (rejecting with an `AbortError`);
+   * `onProgress` hears its stages. The document is not changed.
+   */
+  async runSelectionJob(job, pixels, options = {}) {
+    options.signal?.throwIfAborted();
+    if (this.selectionWorker) return this.selectionWorker.run(job, pixels, options);
+    const result = runSelectionJob(job, pixels, options.onProgress);
+    options.signal?.throwIfAborted();
+    return result;
+  }
   /** Registers (or with `null` removes) the segmentation provider. Not an edit: no undo step. */
   setSegmentationProvider(provider) {
     if (this.segmentation === provider) return;
@@ -10183,11 +8497,22 @@ var ImageEditorController = class {
     const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
     const mode = options.mode ?? "replace";
     let sel = this.state.selection ?? null;
-    strokes.forEach((stroke, i) => {
+    for (let i = 0; i < strokes.length; i++) {
       const m = mode === "replace" && i > 0 ? "add" : mode;
-      const region = quickSelectStroke(pixels, stroke, { size: options.size, selection: sel, grow: m === "add", enhanceEdge: options.enhanceEdge });
-      sel = combineSelections(sel, region, m);
-    });
+      const job = {
+        op: "quick",
+        stroke: strokes[i],
+        size: options.size,
+        grow: m === "add",
+        enhanceEdge: options.enhanceEdge,
+        selection: m === "add" && sel?.bounds ? serializeMask(sel) : null
+      };
+      const { mask } = await this.runSelectionJob(job, pixels, {
+        signal: options.signal,
+        onProgress: options.onProgress && ((f, stage) => options.onProgress((i + f) / strokes.length, stage))
+      });
+      sel = combineSelections(sel, mask, m);
+    }
     this.setSelection(sel, "replace");
     return this.state.selection ?? null;
   }
@@ -10256,7 +8581,7 @@ var ImageEditorController = class {
       }
     }
     const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
-    const region = selectObjectIn(pixels, target, { enhanceEdge: options.enhanceEdge });
+    const { mask: region } = await this.runSelectionJob({ op: "object", target, enhanceEdge: options.enhanceEdge }, pixels, options);
     this.setSelection(region, options.mode ?? "replace");
     return { selection: this.state.selection ?? null, method: "grabcut" };
   }
@@ -10267,7 +8592,11 @@ var ImageEditorController = class {
    */
   async selectFocusArea(options = {}) {
     const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
-    const { selection, noiseLevel } = focusArea(pixels, options);
+    const { mask: selection, noiseLevel = 0 } = await this.runSelectionJob(
+      { op: "focus", options: { range: options.range, noise: options.noise, softness: options.softness } },
+      pixels,
+      options
+    );
     this.setSelection(selection, options.mode ?? "replace");
     return { selection: this.state.selection ?? null, noiseLevel };
   }
@@ -10286,7 +8615,7 @@ var ImageEditorController = class {
       return { selection: this.state.selection ?? null, method: "model" };
     }
     const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
-    const { selection, reason } = findSky(pixels, options);
+    const { mask: selection, reason } = await this.runSelectionJob({ op: "sky", options: { threshold: options.threshold, softness: options.softness } }, pixels, options);
     if (!selection.bounds) return { selection: this.state.selection ?? null, method: "classical", note: reason };
     this.setSelection(selection, options.mode ?? "replace");
     return { selection: this.state.selection ?? null, method: "classical" };
@@ -10569,7 +8898,7 @@ var ImageEditorController = class {
     if (!provider) {
       const pixels = await this.requirePixels({});
       options.signal?.throwIfAborted();
-      const { selection, reason } = findSubject(pixels, { enhanceEdge: options.enhanceEdge });
+      const { mask: selection, reason } = await this.runSelectionJob({ op: "subject", enhanceEdge: options.enhanceEdge }, pixels, options);
       if (selection.bounds) this.shapeCommand(selection, options);
       const unused = target.trim() ? ` "${target.trim()}" was not used to choose it.` : "";
       return {
@@ -11892,7 +10221,7 @@ var ImageEditorController = class {
     }
     if (src.colorSpace !== "rgb") throw new LayerOperationError("Colours are given as #rrggbb, so the source profile must be RGB.");
     const t = Transform.create(src, dst, { intent: options.intent ?? "relative", bpc: options.bpc ?? true });
-    const toLab2 = Transform.create(src, builtinProfile("lab-d50"), { intent: "relative", bpc: false });
+    const toLab = Transform.create(src, builtinProfile("lab-d50"), { intent: "relative", bpc: false });
     return colors.map((input) => {
       const m = /^#?([0-9a-f]{6})$/i.exec(input.trim());
       if (!m) throw new LayerOperationError(`Invalid colour "${input}"; use #rrggbb.`);
@@ -11902,9 +10231,9 @@ var ImageEditorController = class {
       t.eval(rgb, out);
       const values = Array.from(out.subarray(0, t.outputs), (v) => Math.round(Math.min(1, Math.max(0, v)) * 1e4) / 1e4);
       const l = new Float32Array(3);
-      toLab2.eval(rgb, l);
-      const lab2 = [Math.round(l[0] * 1e4) / 100, Math.round((l[1] * 255 - 128) * 100) / 100, Math.round((l[2] * 255 - 128) * 100) / 100];
-      const res = { input, values, lab: lab2 };
+      toLab.eval(rgb, l);
+      const lab = [Math.round(l[0] * 1e4) / 100, Math.round((l[1] * 255 - 128) * 100) / 100, Math.round((l[2] * 255 - 128) * 100) / 100];
+      const res = { input, values, lab };
       if (dst.colorSpace === "rgb") res.hex = `#${values.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("")}`;
       return res;
     });
@@ -13709,13 +12038,25 @@ function createImageSelectionTools(controller) {
           items: {
             type: "object",
             properties: {
-              kind: { type: "string", enum: ["quick-select", "brush", "refine-brush"], description: "quick-select grows to edges; brush paints directly; refine-brush marks soft detail (hair) for the edge to be re-estimated." },
-              points: { type: "array", minItems: 1, items: pointSchema, description: "The stroke path in natural image pixels (one point is a dab)." },
+              kind: {
+                type: "string",
+                enum: ["quick-select", "brush", "refine-brush", "lasso", "object"],
+                description: "quick-select grows to edges; brush paints directly; refine-brush marks soft detail (hair) for the edge to be re-estimated; lasso adds or removes a polygon; object adds or removes the object in rect or under point."
+              },
+              points: { type: "array", minItems: 1, items: pointSchema, description: "The stroke path (or lasso outline, 3+ points) in natural image pixels; one point is a dab. Not for object." },
+              rect: {
+                type: "object",
+                properties: rectProperties,
+                required: ["x", "y", "width", "height"],
+                additionalProperties: false,
+                description: "object: a box around the object, in natural image pixels."
+              },
+              point: { ...pointSchema, description: "object: a point on the object, in natural image pixels." },
               size: { type: "number", minimum: 1, maximum: 2500, description: "Brush diameter in natural image pixels (default 30 quick-select, 20 brush, 40 refine-brush)." },
-              mode: { type: "string", enum: ["add", "subtract"], description: "quick-select and brush: add (default) or subtract." },
+              mode: { type: "string", enum: ["add", "subtract"], description: "quick-select, brush, lasso and object: add (default) or subtract." },
               hardness: { type: "number", minimum: 0, maximum: 1, description: "brush: the solid share of the radius, 0..1 (default 1)." }
             },
-            required: ["kind", "points"],
+            required: ["kind"],
             additionalProperties: false
           }
         },
@@ -13725,8 +12066,13 @@ function createImageSelectionTools(controller) {
     },
     annotations: writeAnnotations("Refine the selection edge"),
     handler: async (params) => {
-      const edits = Array.isArray(params.edits) ? params.edits.map((e) => ({ ...e, points: (e.points ?? []).map((p) => ({ x: num2(p?.x, NaN), y: num2(p?.y, NaN) })) })) : [];
+      const edits = Array.isArray(params.edits) ? params.edits.map((e) => e.kind === "object" ? { ...e } : { ...e, points: (e.points ?? []).map((p) => ({ x: num2(p?.x, NaN), y: num2(p?.y, NaN) })) }) : [];
       for (const e of edits) {
+        if (e.kind === "object") {
+          if (!e.rect === !e.point) throw new Error("An object edit takes rect (a box around the object) or point (on it).");
+          continue;
+        }
+        if (!e.points.length) throw new Error(`A ${e.kind} edit needs points.`);
         if (!e.points.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) throw new Error("Each edit needs points of { x, y } in natural image pixels.");
         if (e.kind === "refine-brush" && e.mode !== void 0) throw new Error("refine-brush strokes have no mode; they mark where the edge is re-estimated.");
       }
@@ -13920,7 +12266,7 @@ function createImageSelectionTools(controller) {
       additionalProperties: false
     },
     annotations: writeAnnotations("Quick Selection"),
-    handler: async (args) => {
+    handler: async (args, context) => {
       const strokes = Array.isArray(args.strokes) ? args.strokes.map((s) => Array.isArray(s) ? s.map((p) => ({ x: num2(p?.x, NaN), y: num2(p?.y, NaN) })) : []) : [];
       if (!strokes.length || strokes.some((s) => !s.length || !s.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y)))) {
         throw new Error("strokes needs at least one stroke of { x, y } points in natural image pixels.");
@@ -13929,7 +12275,8 @@ function createImageSelectionTools(controller) {
         size: args.size === void 0 ? void 0 : num2(args.size, 30),
         mode: parseSelectionMode(args.mode),
         sampleAllLayers: args.sampleAllLayers,
-        enhanceEdge: args.enhanceEdge
+        enhanceEdge: args.enhanceEdge,
+        signal: context?.signal
       });
       return summary(controller);
     }
@@ -13957,7 +12304,7 @@ function createImageSelectionTools(controller) {
       additionalProperties: false
     },
     annotations: { ...writeAnnotations("Object Selection"), openWorldHint: true },
-    handler: async (args) => {
+    handler: async (args, context) => {
       const rect = args.rect;
       const point = args.point;
       if (!rect && !point) throw new Error("Pass rect (a box around the object) or point (a point on it).");
@@ -13966,7 +12313,8 @@ function createImageSelectionTools(controller) {
         mode: parseSelectionMode(args.mode),
         sampleAllLayers: args.sampleAllLayers,
         enhanceEdge: args.enhanceEdge,
-        useModel: args.useModel
+        useModel: args.useModel,
+        signal: context?.signal
       };
       const { method } = rect ? await controller.selectObject({ rect: { x: num2(rect.x, NaN), y: num2(rect.y, NaN), width: num2(rect.width, NaN), height: num2(rect.height, NaN) } }, options) : await controller.selectObject({ point: { x: num2(point.x, NaN), y: num2(point.y, NaN) } }, options);
       return { ...summary(controller), method };
@@ -13988,13 +12336,14 @@ function createImageSelectionTools(controller) {
       additionalProperties: false
     },
     annotations: writeAnnotations("Select the focus area", true),
-    handler: async (args) => {
+    handler: async (args, context) => {
       const { noiseLevel } = await controller.selectFocusArea({
         range: args.range === void 0 ? void 0 : num2(args.range, 50),
         noise: args.noise === void 0 ? void 0 : num2(args.noise, 0),
         softness: args.softness === void 0 ? void 0 : num2(args.softness, 4),
         mode: parseSelectionMode(args.mode),
-        sampleAllLayers: args.sampleAllLayers
+        sampleAllLayers: args.sampleAllLayers,
+        signal: context?.signal
       });
       return { ...summary(controller), noiseLevel };
     }
@@ -14015,13 +12364,14 @@ function createImageSelectionTools(controller) {
       additionalProperties: false
     },
     annotations: { ...writeAnnotations("Select the sky", true), openWorldHint: true },
-    handler: async (args) => {
+    handler: async (args, context) => {
       const { note, method } = await controller.selectSky({
         threshold: args.threshold === void 0 ? void 0 : num2(args.threshold, 50),
         softness: args.softness === void 0 ? void 0 : num2(args.softness, 4),
         mode: parseSelectionMode(args.mode),
         sampleAllLayers: args.sampleAllLayers,
-        useModel: args.useModel
+        useModel: args.useModel,
+        signal: context?.signal
       });
       return { ...summary(controller), method, ...note ? { note } : {} };
     }
@@ -17033,7 +15383,7 @@ function checkSource(controller, source) {
   }
   return p;
 }
-var SOURCE2 = {
+var SOURCE = {
   type: "object",
   description: "Source point in document pixels (an Alt-click). Given, it replaces the clone source and the offset starts afresh at this stroke; missing, the current clone source is used (set_clone_source).",
   properties: { x: { type: "number", description: "Source x in px." }, y: { type: "number", description: "Source y in px." } },
@@ -17057,7 +15407,7 @@ function createImageRetouchTools(controller) {
       type: "object",
       properties: {
         points: POINTS,
-        source: SOURCE2,
+        source: SOURCE,
         aligned: { type: "boolean", description: "Keep the offset for the next strokes (default the current option, true)." },
         sample: SAMPLE,
         brush: BRUSH2,
@@ -17077,7 +15427,7 @@ function createImageRetouchTools(controller) {
       type: "object",
       properties: {
         points: POINTS,
-        source: SOURCE2,
+        source: SOURCE,
         aligned: { type: "boolean", description: "Keep the offset for the next strokes (default the current option, true)." },
         sample: SAMPLE,
         brush: BRUSH2,
@@ -19127,6 +17477,415 @@ function downloadMaskImage(controller, source, name = "mask") {
   return { fileName, width, height };
 }
 
+// src/image-editor/selection/select-and-mask.ts
+var SELECT_AND_MASK_VIEWS = [
+  { id: "onion-skin", label: "Onion Skin", key: "o", opacity: 0.5 },
+  { id: "marching-ants", label: "Marching Ants", key: "m", opacity: 1 },
+  { id: "overlay", label: "Overlay", key: "v", opacity: 0.5 },
+  { id: "on-black", label: "On Black", key: "a", opacity: 1 },
+  { id: "on-white", label: "On White", key: "t", opacity: 1 },
+  { id: "black-white", label: "Black & White", key: "k", opacity: 1 },
+  { id: "on-layers", label: "On Layers", key: "y", opacity: 1 }
+];
+var SELECT_AND_MASK_TOOLS = [
+  { id: "quick-select", label: "Quick Selection", key: "w" },
+  { id: "refine-brush", label: "Refine Edge Brush", key: "r" },
+  { id: "brush", label: "Brush", key: "b" },
+  { id: "object", label: "Object Selection", key: "q" },
+  { id: "lasso", label: "Lasso", key: "l" },
+  { id: "hand", label: "Hand", key: "h" },
+  { id: "zoom", label: "Zoom", key: "z" }
+];
+var DEFAULT_SELECT_AND_MASK_SETTINGS = {
+  params: { ...DEFAULT_REFINE_EDGE_PARAMS },
+  output: "selection",
+  decontaminate: 0,
+  refineMode: "color",
+  view: "onion-skin",
+  opacity: 0.5,
+  showEdge: false,
+  showOriginal: false,
+  realTime: true,
+  highQuality: false,
+  remember: false,
+  tool: "quick-select",
+  brushSize: 30,
+  brushMode: "add"
+};
+var PREVIEW_SIZE = 1024;
+var remembered = null;
+function scalePixels(pixels, w, h) {
+  if (w === pixels.width && h === pixels.height) return pixels;
+  const { width: W, height: H, data } = pixels;
+  const sum = new Float64Array(w * h * 4);
+  const count = new Float64Array(w * h);
+  for (let y = 0; y < H; y++) {
+    const row = Math.min(h - 1, Math.floor(y * h / H)) * w;
+    for (let x = 0; x < W; x++) {
+      const o = row + Math.min(w - 1, Math.floor(x * w / W));
+      const p = (y * W + x) * 4;
+      for (let c = 0; c < 4; c++) sum[o * 4 + c] += data[p + c];
+      count[o]++;
+    }
+  }
+  const out = new Uint8ClampedArray(w * h * 4);
+  for (let i = 0; i < w * h; i++) for (let c = 0; c < 4; c++) out[i * 4 + c] = sum[i * 4 + c] / (count[i] || 1);
+  return { width: w, height: h, data: out };
+}
+function scaleEdit(edit, s) {
+  const pt = (p) => ({ x: p.x * s, y: p.y * s });
+  if (edit.kind === "object") {
+    return { ...edit, rect: edit.rect && { x: edit.rect.x * s, y: edit.rect.y * s, width: edit.rect.width * s, height: edit.rect.height * s }, point: edit.point && pt(edit.point) };
+  }
+  const scaled = { ...edit, points: edit.points.map(pt) };
+  if ("size" in edit && edit.size !== void 0) scaled.size = Math.max(1, edit.size * s);
+  return scaled;
+}
+function scaleParams(p, s) {
+  return { ...p, radius: p.radius * s, feather: p.feather * s };
+}
+var SelectAndMaskSession = class {
+  constructor(controller) {
+    this.controller = controller;
+    this.base = controller.getSelection();
+    this.settingsValue = remembered ? { ...remembered, params: { ...remembered.params }, showOriginal: false } : { ...DEFAULT_SELECT_AND_MASK_SETTINGS, params: { ...DEFAULT_SELECT_AND_MASK_SETTINGS.params } };
+  }
+  controller;
+  settingsValue;
+  editsList = [];
+  /** The edit being painted, shown in the preview but not yet in `edits`. */
+  live = null;
+  dragStart = null;
+  pixels = null;
+  previewPixels = null;
+  base;
+  previewMask = null;
+  baseMask = null;
+  listeners = /* @__PURE__ */ new Set();
+  /** Why the preview could not be made (no pixels), for the UI. */
+  error = null;
+  /** A note for the UI, such as object aware refinement applying only on OK. */
+  note = null;
+  /** Bumped each time the preview changes, so a UI can redraw. */
+  revision = 0;
+  /** True while the worker computes a preview. */
+  computing = false;
+  dirty = false;
+  get settings() {
+    return this.settingsValue;
+  }
+  get edits() {
+    return this.editsList;
+  }
+  /** Reads the image and makes the first preview. Resolves to false when the pixels are unavailable. */
+  async open() {
+    try {
+      this.pixels = await this.controller.getSamplePixels({});
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+    if (!this.pixels) {
+      this.error ??= "The image pixels are not available, so Select and Mask cannot preview.";
+      this.emit();
+      return false;
+    }
+    this.rescale();
+    this.recompute();
+    return true;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit() {
+    this.revision++;
+    for (const l of this.listeners) l();
+  }
+  /** Preview size and the scale from natural pixels to it. */
+  get previewSize() {
+    const p = this.previewPixels;
+    if (!p || !this.pixels) return { width: 0, height: 0, scale: 1 };
+    return { width: p.width, height: p.height, scale: p.width / this.pixels.width };
+  }
+  /** Changes settings; the preview follows. Choosing a view also sets its usual opacity. */
+  update(changes) {
+    const next = { ...this.settingsValue, ...changes, params: { ...this.settingsValue.params, ...changes.params ?? {} } };
+    if (changes.view && changes.view !== this.settingsValue.view && changes.opacity === void 0) {
+      next.opacity = SELECT_AND_MASK_VIEWS.find((v) => v.id === changes.view).opacity;
+    }
+    const rescale = next.highQuality !== this.settingsValue.highQuality;
+    this.settingsValue = next;
+    if (rescale) this.rescale();
+    this.recompute();
+  }
+  rescale() {
+    const px2 = this.pixels;
+    if (!px2) return;
+    const s = this.settingsValue.highQuality ? 1 : Math.min(1, PREVIEW_SIZE / Math.max(px2.width, px2.height));
+    const w = Math.max(1, Math.round(px2.width * s));
+    const h = Math.max(1, Math.round(px2.height * s));
+    this.previewPixels = scalePixels(px2, w, h);
+    this.baseMask = this.base?.bounds ? s === 1 ? this.base : resizeSelection(this.base, w, h) : null;
+  }
+  /**
+   * Recomputes the preview mask from the base selection, the strokes and the settings: at once on
+   * the page, or in the worker, where one job runs at a time and the newest state follows it.
+   */
+  recompute() {
+    const px2 = this.previewPixels;
+    if (!px2) return;
+    this.note = this.settingsValue.refineMode === "object" ? "Object aware refinement asks the segmentation model on OK; the preview refines by colour." : null;
+    if (this.controller.hasSelectionWorker) {
+      void this.recomputeInWorker();
+      return;
+    }
+    const { scale } = this.previewSize;
+    const edits = [...this.editsList, ...this.live ? [this.live] : []].map((e) => scaleEdit(e, scale));
+    try {
+      const { selection, refineBrush } = applyRefineEdits(px2, this.baseMask, edits, px2.width, px2.height);
+      this.previewMask = selection?.bounds ? refineSelection(px2, selection, scaleParams(this.settingsValue.params, scale), refineBrush) : null;
+      this.error = null;
+    } catch (err) {
+      this.previewMask = null;
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+    this.emit();
+  }
+  async recomputeInWorker() {
+    if (this.computing) {
+      this.dirty = true;
+      return;
+    }
+    this.computing = true;
+    do {
+      this.dirty = false;
+      const px2 = this.previewPixels;
+      const { scale } = this.previewSize;
+      const edits = [...this.editsList, ...this.live ? [this.live] : []].map((e) => scaleEdit(e, scale));
+      try {
+        const { mask } = await this.controller.runSelectionJob(
+          { op: "refine-preview", base: this.baseMask ? serializeMask(this.baseMask) : null, edits, params: scaleParams(this.settingsValue.params, scale) },
+          px2
+        );
+        this.previewMask = mask.bounds ? mask : null;
+        this.error = null;
+      } catch (err) {
+        this.previewMask = null;
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+      this.emit();
+    } while (this.dirty);
+    this.computing = false;
+    this.emit();
+  }
+  /** Resolves once no preview is being computed (immediately without a worker). */
+  async idle() {
+    while (this.computing) await new Promise((r) => setTimeout(r, 5));
+  }
+  /** Coverage 0..1 of the preview at (x, y) in preview pixels (for tests and hover readouts). */
+  coverageAt(x, y) {
+    const m = this.settingsValue.showOriginal ? this.baseMask : this.previewMask;
+    if (!m) return 0;
+    const xi = Math.floor(x);
+    const yi = Math.floor(y);
+    if (xi < 0 || yi < 0 || xi >= m.width || yi >= m.height) return 0;
+    return m.data[yi * m.width + xi] / 255;
+  }
+  /** The preview drawn in the current view mode: RGBA at {@link previewSize}. */
+  render() {
+    const px2 = this.previewPixels;
+    if (!px2) return new Uint8ClampedArray(0);
+    const { width: w, height: h } = px2;
+    const n = w * h;
+    const s = this.settingsValue;
+    const mask = (s.showOriginal ? this.baseMask : this.previewMask) ?? createSelectionMask(w, h);
+    const m = mask.data;
+    const out = new Uint8ClampedArray(n * 4);
+    const k = Math.min(1, Math.max(0, s.opacity));
+    let edgeBand = null;
+    if (s.showEdge) {
+      edgeBand = new Uint8Array(n);
+      const r = Math.max(1, Math.round(Math.max(s.params.radius, 2) * this.previewSize.scale));
+      for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+          const v = m[y * w + x];
+          if (v <= 3 || v >= 252) continue;
+          for (let j = Math.max(0, y - r); j <= Math.min(h - 1, y + r); j++) edgeBand.fill(1, j * w + Math.max(0, x - r), j * w + Math.min(w, x + r + 1));
+        }
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      const a = m[i] / 255;
+      const p = i * 4;
+      const r = px2.data[p];
+      const g = px2.data[p + 1];
+      const b = px2.data[p + 2];
+      let o;
+      const x = i % w;
+      const y = (i - x) / w;
+      const checker = ((x >> 3) + (y >> 3)) % 2 ? 204 : 255;
+      const hide = (1 - a) * k;
+      switch (s.view) {
+        case "black-white":
+          o = [m[i], m[i], m[i]];
+          break;
+        case "overlay":
+          o = [r + (255 - r) * hide, g * (1 - hide), b * (1 - hide)];
+          break;
+        case "on-black":
+          o = [r * (1 - hide), g * (1 - hide), b * (1 - hide)];
+          break;
+        case "on-white":
+          o = [r + (255 - r) * hide, g + (255 - g) * hide, b + (255 - b) * hide];
+          break;
+        case "marching-ants": {
+          o = [r, g, b];
+          const inside = m[i] >= 128;
+          const edge = x > 0 && m[i - 1] >= 128 !== inside || x + 1 < w && m[i + 1] >= 128 !== inside || y > 0 && m[i - w] >= 128 !== inside || y + 1 < h && m[i + w] >= 128 !== inside;
+          if (edge) {
+            const v = (x + y >> 2) % 2 ? 0 : 255;
+            o = [v, v, v];
+          }
+          break;
+        }
+        default:
+          o = [r + (checker - r) * hide, g + (checker - g) * hide, b + (checker - b) * hide];
+      }
+      if (edgeBand && !edgeBand[i]) o = [o[0] * 0.15, o[1] * 0.15, o[2] * 0.15];
+      out[p] = o[0];
+      out[p + 1] = o[1];
+      out[p + 2] = o[2];
+      out[p + 3] = 255;
+    }
+    return out;
+  }
+  /**
+   * Pointer down at `point` (natural pixels) with the current tool: starts a stroke (Quick
+   * Selection, brushes, lasso) or a box (Object Selection). Alt (or the subtract mode) removes.
+   * Hand and Zoom are the UI's own; they return false here.
+   */
+  begin(point, modifiers = {}) {
+    const s = this.settingsValue;
+    const mode = modifiers.altKey ? s.brushMode === "add" ? "subtract" : "add" : s.brushMode;
+    this.dragStart = point;
+    switch (s.tool) {
+      case "quick-select":
+        this.live = { kind: "quick-select", points: [point], size: s.brushSize, mode };
+        break;
+      case "brush":
+        this.live = { kind: "brush", points: [point], size: s.brushSize, mode };
+        break;
+      case "refine-brush":
+        this.live = { kind: "refine-brush", points: [point], size: s.brushSize };
+        break;
+      case "lasso":
+        this.live = { kind: "lasso", points: [point], mode };
+        break;
+      case "object":
+        this.live = { kind: "object", point, mode };
+        break;
+      default:
+        this.dragStart = null;
+        return false;
+    }
+    if (s.realTime && s.tool !== "lasso" && s.tool !== "object") this.recompute();
+    return true;
+  }
+  /** Pointer move while a stroke is down. */
+  move(point) {
+    const live = this.live;
+    if (!live || !this.dragStart) return;
+    if (live.kind === "object") {
+      const a = this.dragStart;
+      const rect = { x: Math.min(a.x, point.x), y: Math.min(a.y, point.y), width: Math.abs(point.x - a.x), height: Math.abs(point.y - a.y) };
+      this.live = rect.width >= 4 && rect.height >= 4 ? { kind: "object", rect, mode: live.mode } : { kind: "object", point: a, mode: live.mode };
+      return;
+    }
+    const last = live.points[live.points.length - 1];
+    if (Math.hypot(point.x - last.x, point.y - last.y) < 1) return;
+    live.points.push(point);
+    if (this.settingsValue.realTime && live.kind !== "lasso") this.recompute();
+  }
+  /** Pointer up: the stroke becomes an edit (one step of the workspace's own undo). */
+  end() {
+    const live = this.live;
+    this.live = null;
+    this.dragStart = null;
+    if (!live) return;
+    if (live.kind === "lasso" && live.points.length < 3) return;
+    this.editsList.push(live);
+    this.recompute();
+  }
+  /** Removes the last stroke (Ctrl/⌘+Z in the workspace). Returns false when there is none. */
+  undoEdit() {
+    if (!this.editsList.length) return false;
+    this.editsList.pop();
+    this.recompute();
+    return true;
+  }
+  /** Clears the strokes and goes back to the default settings (Reset). */
+  reset() {
+    this.editsList.length = 0;
+    this.settingsValue = { ...DEFAULT_SELECT_AND_MASK_SETTINGS, params: { ...DEFAULT_SELECT_AND_MASK_SETTINGS.params }, tool: this.settingsValue.tool };
+    this.rescale();
+    this.recompute();
+  }
+  /**
+   * Photoshop's keys in the workspace: a view letter, F (next view), X (all views off and on:
+   * Show Original), J (Show Edge), P (Show Original), a tool letter, [ and ] (brush size).
+   * Returns true when the key was used.
+   */
+  handleKey(key) {
+    const k = key.toLowerCase();
+    const view = SELECT_AND_MASK_VIEWS.find((v) => v.key === k);
+    if (view) {
+      this.update({ view: view.id });
+      return true;
+    }
+    const tool = SELECT_AND_MASK_TOOLS.find((t) => t.key === k);
+    if (tool) {
+      this.update({ tool: tool.id });
+      return true;
+    }
+    if (k === "f") {
+      const i = SELECT_AND_MASK_VIEWS.findIndex((v) => v.id === this.settingsValue.view);
+      this.update({ view: SELECT_AND_MASK_VIEWS[(i + 1) % SELECT_AND_MASK_VIEWS.length].id });
+      return true;
+    }
+    if (k === "p" || k === "x") {
+      this.update({ showOriginal: !this.settingsValue.showOriginal });
+      return true;
+    }
+    if (k === "j") {
+      this.update({ showEdge: !this.settingsValue.showEdge });
+      return true;
+    }
+    if (k === "[" || k === "]") {
+      const size = this.settingsValue.brushSize;
+      this.settingsValue = { ...this.settingsValue, brushSize: Math.max(1, Math.round(k === "]" ? size * 1.25 : size / 1.25)) };
+      this.emit();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * OK: applies the strokes and settings to the image as one undo step (the same call an agent
+   * makes) and remembers the settings when asked to.
+   */
+  async commit() {
+    const s = this.settingsValue;
+    remembered = s.remember ? { ...s, params: { ...s.params } } : null;
+    return this.controller.refineSelectionTo(s.params, s.output, {
+      edits: [...this.editsList],
+      decontaminate: s.output === "new-layer" || s.output === "new-layer-with-mask" ? s.decontaminate : 0,
+      refineMode: s.refineMode
+    });
+  }
+};
+function forgetSelectAndMaskSettings() {
+  remembered = null;
+}
+
 // src/image-editor/mosaic-filter.ts
 function resolveMosaicRegionBounds(region, imgWidth, imgHeight) {
   if (imgWidth <= 0 || imgHeight <= 0 || region.width <= 0 || region.height <= 0) {
@@ -20826,6 +19585,7 @@ export {
   DEFAULT_REFINE_EDGE_PARAMS,
   DEFAULT_RETOUCH,
   DEFAULT_SELECTION_TOOL_OPTIONS,
+  DEFAULT_SELECT_AND_MASK_SETTINGS,
   DEFAULT_SHAPE_TOOL_OPTIONS,
   DEFAULT_SMUDGE,
   DEFAULT_TEXT_STYLE,
@@ -20943,6 +19703,7 @@ export {
   PIGMENT_WAVELENGTHS,
   PLANE,
   PLANE_BYTES,
+  PREVIEW_SIZE,
   PROOF_PROFILE_OPTIONS,
   PSD_BLEND_KEYS,
   PSD_FILE_ACCEPT,
@@ -20980,6 +19741,8 @@ export {
   SELECTION_MODE_LABELS,
   SELECTION_MODIFY_OPS,
   SELECTION_TOOLS,
+  SELECT_AND_MASK_TOOLS,
+  SELECT_AND_MASK_VIEWS,
   SET_PLANES,
   SHADOW_AMBIENT,
   SHAPE_KIND_LABELS,
@@ -20993,7 +19756,9 @@ export {
   SRGB_TO_LINEAR,
   STRIP,
   SUPPORTED_ADJUSTMENT_KEYS,
+  SelectAndMaskSession,
   SelectionGesture,
+  SelectionWorkerClient,
   ShapeDrawGesture,
   SmudgeTip,
   StrokeCoverage,
@@ -21243,6 +20008,7 @@ export {
   deserializeEffects,
   deserializeLayer,
   deserializeLayers,
+  deserializeMask,
   deserializePatterns,
   deserializeSelection,
   developFilter,
@@ -21314,6 +20080,7 @@ export {
   focusArea,
   followLayerMove,
   fontOf,
+  forgetSelectAndMaskSettings,
   formatControlValue,
   fullSelection,
   gaussianBlur,
@@ -21663,6 +20430,7 @@ export {
   runLayerFilters,
   runLayerFiltersFloat,
   runLayerMenuAction,
+  runSelectionJob,
   sameCanvasViewport,
   sampleLut,
   sampleToneLut,
@@ -21696,6 +20464,7 @@ export {
   serializeLayer,
   serializeLayers,
   serializeLayersExternal,
+  serializeMask,
   serializePatterns,
   serializeSelection,
   setCloneTransformValue,
@@ -21747,6 +20516,7 @@ export {
   srgbToLinear,
   standardBlendMode,
   startMarchingAnts,
+  startSelectionWorker,
   stepSlotTs,
   strokeGrainCatch,
   styleAt,