@pooder/kit 5.2.0 → 5.3.0

package/dist/index.mjs

@@ -2958,15 +2958,19 @@ function analyzeAlpha(imageData, alphaOpaqueCutoff) {
   };
 }
 function circularMorphology(mask, width, height, radius, op) {
-  const dilate = (m, r) => {
+  const r = Math.max(0, Math.floor(radius));
+  if (r <= 0) {
+    return mask.slice();
+  }
+  const dilateDisk = (m, radiusPx) => {
     const horizontalDist = new Int32Array(width * height);
     for (let y = 0; y < height; y++) {
-      let lastSolid = -r * 2;
+      let lastSolid = -radiusPx * 2;
       for (let x = 0; x < width; x++) {
         if (m[y * width + x]) lastSolid = x;
         horizontalDist[y * width + x] = x - lastSolid;
       }
-      lastSolid = width + r * 2;
+      lastSolid = width + radiusPx * 2;
       for (let x = width - 1; x >= 0; x--) {
         if (m[y * width + x]) lastSolid = x;
         horizontalDist[y * width + x] = Math.min(
@@ -2976,12 +2980,12 @@ function circularMorphology(mask, width, height, radius, op) {
       }
     }
     const result = new Uint8Array(width * height);
-    const r2 = r * r;
+    const r2 = radiusPx * radiusPx;
     for (let x = 0; x < width; x++) {
       for (let y = 0; y < height; y++) {
         let found = false;
-        const minY = Math.max(0, y - r);
-        const maxY = Math.min(height - 1, y + r);
+        const minY = Math.max(0, y - radiusPx);
+        const maxY = Math.min(height - 1, y + radiusPx);
         for (let dy = minY; dy <= maxY; dy++) {
           const dY = dy - y;
           const hDist = horizontalDist[dy * width + x];
@@ -2995,23 +2999,62 @@ function circularMorphology(mask, width, height, radius, op) {
     }
     return result;
   };
-  const erode = (m, r) => {
-    const inverted = new Uint8Array(m.length);
-    for (let i = 0; i < m.length; i++) inverted[i] = m[i] ? 0 : 1;
-    const dilatedInverted = dilate(inverted, r);
-    const result = new Uint8Array(m.length);
-    for (let i = 0; i < m.length; i++) result[i] = dilatedInverted[i] ? 0 : 1;
-    return result;
+  const erodeDiamond = (m, radiusPx) => {
+    if (radiusPx <= 0) return m.slice();
+    let current = m;
+    for (let step = 0; step < radiusPx; step++) {
+      const next = new Uint8Array(width * height);
+      for (let y = 1; y < height - 1; y++) {
+        const row = y * width;
+        for (let x = 1; x < width - 1; x++) {
+          const idx = row + x;
+          if (current[idx] && current[idx - 1] && current[idx + 1] && current[idx - width] && current[idx + width]) {
+            next[idx] = 1;
+          }
+        }
+      }
+      current = next;
+    }
+    return current;
+  };
+  const restoreBridgePixels = (source, eroded) => {
+    const restored = eroded.slice();
+    for (let y = 1; y < height - 1; y++) {
+      const row = y * width;
+      for (let x = 1; x < width - 1; x++) {
+        const idx = row + x;
+        if (!source[idx] || restored[idx]) continue;
+        const up = source[idx - width] === 1;
+        const down = source[idx + width] === 1;
+        const left = source[idx - 1] === 1;
+        const right = source[idx + 1] === 1;
+        const upLeft = source[idx - width - 1] === 1;
+        const upRight = source[idx - width + 1] === 1;
+        const downLeft = source[idx + width - 1] === 1;
+        const downRight = source[idx + width + 1] === 1;
+        const keepsBridge = left && right || up && down || upLeft && downRight || upRight && downLeft;
+        if (keepsBridge) {
+          restored[idx] = 1;
+        }
+      }
+    }
+    return restored;
+  };
+  const erodePreservingBridges = (m, radiusPx) => {
+    const eroded = erodeDiamond(m, radiusPx);
+    return restoreBridgePixels(m, eroded);
   };
   switch (op) {
     case "dilate":
-      return dilate(mask, radius);
+      return dilateDisk(mask, r);
     case "erode":
-      return erode(mask, radius);
-    case "closing":
-      return erode(dilate(mask, radius), radius);
+      return erodePreservingBridges(mask, r);
+    case "closing": {
+      const erodeRadius = Math.max(1, Math.floor(r * 0.65));
+      return erodePreservingBridges(dilateDisk(mask, r), erodeRadius);
+    }
     case "opening":
-      return dilate(erode(mask, radius), radius);
+      return dilateDisk(erodePreservingBridges(mask, r), r);
     default:
       return mask;
   }
@@ -3074,78 +3117,6 @@ function fillHoles(mask, width, height) {
   }
   return filledMask;
 }
-function countForeground(mask) {
-  let c = 0;
-  for (let i = 0; i < mask.length; i++) c += mask[i] ? 1 : 0;
-  return c;
-}
-function isMaskConnected8(mask, width, height) {
-  const total = countForeground(mask);
-  if (total === 0) return true;
-  let start = -1;
-  for (let i = 0; i < mask.length; i++) {
-    if (mask[i]) {
-      start = i;
-      break;
-    }
-  }
-  if (start === -1) return true;
-  const visited = new Uint8Array(mask.length);
-  const queue = [start];
-  visited[start] = 1;
-  let seen = 1;
-  let head = 0;
-  while (head < queue.length) {
-    const idx = queue[head++];
-    const x = idx % width;
-    const y = (idx - x) / width;
-    for (let dy = -1; dy <= 1; dy++) {
-      const ny = y + dy;
-      if (ny < 0 || ny >= height) continue;
-      for (let dx = -1; dx <= 1; dx++) {
-        if (dx === 0 && dy === 0) continue;
-        const nx = x + dx;
-        if (nx < 0 || nx >= width) continue;
-        const nidx = ny * width + nx;
-        if (mask[nidx] && !visited[nidx]) {
-          visited[nidx] = 1;
-          queue.push(nidx);
-          seen++;
-        }
-      }
-    }
-  }
-  return seen === total;
-}
-function findMinimalConnectRadius(mask, width, height, maxRadius) {
-  if (maxRadius <= 0) return 0;
-  if (isMaskConnected8(mask, width, height)) return 0;
-  let low = 0;
-  let high = 1;
-  while (high <= maxRadius) {
-    const closed = circularMorphology(mask, width, height, high, "closing");
-    if (isMaskConnected8(closed, width, height)) break;
-    high *= 2;
-  }
-  if (high > maxRadius) high = maxRadius;
-  if (!isMaskConnected8(
-    circularMorphology(mask, width, height, high, "closing"),
-    width,
-    height
-  )) {
-    return high;
-  }
-  while (low + 1 < high) {
-    const mid = Math.floor((low + high) / 2);
-    const closed = circularMorphology(mask, width, height, mid, "closing");
-    if (isMaskConnected8(closed, width, height)) {
-      high = mid;
-    } else {
-      low = mid;
-    }
-  }
-  return high;
-}
 function polygonSignedArea(points) {
   if (points.length < 3) return 0;
   let sum = 0;
@@ -3169,10 +3140,19 @@ var ImageTracer = class {
     return pathData;
   }
   static async traceWithBounds(imageUrl, options = {}) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const img = await this.loadImage(imageUrl);
     const width = img.width;
     const height = img.height;
+    if (width <= 0 || height <= 0) {
+      const w = (_a = options.scaleToWidth) != null ? _a : 0;
+      const h = (_b = options.scaleToHeight) != null ? _b : 0;
+      return {
+        pathData: `M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z`,
+        baseBounds: { x: 0, y: 0, width: w, height: h },
+        bounds: { x: 0, y: 0, width: w, height: h }
+      };
+    }
     const debug = options.debug === true;
     const debugLog = (message, payload) => {
       if (!debug) return;
@@ -3189,96 +3169,178 @@ var ImageTracer = class {
     if (!ctx) throw new Error("Could not get 2D context");
     ctx.drawImage(img, 0, 0);
     const imageData = ctx.getImageData(0, 0, width, height);
-    const threshold = (_a = options.threshold) != null ? _a : 10;
-    const componentMode = (_b = options.componentMode) != null ? _b : "largest";
-    const minComponentArea = Math.max(0, (_c = options.minComponentArea) != null ? _c : 0);
-    const forceConnected = options.forceConnected === true;
-    const adaptiveRadius = Math.max(
-      5,
-      Math.floor(Math.max(width, height) * 0.02)
+    const threshold = (_c = options.threshold) != null ? _c : 10;
+    const expand = Math.max(0, Math.floor((_d = options.expand) != null ? _d : 0));
+    const simplifyTolerance = (_e = options.simplifyTolerance) != null ? _e : 2.5;
+    const useSmoothing = options.smoothing !== false;
+    const componentMode = "all";
+    const minComponentArea = 0;
+    const maxDim = Math.max(width, height);
+    const maskMode = "auto";
+    const whiteThreshold = 240;
+    const alphaOpaqueCutoff = 250;
+    const preprocessDilateRadius = Math.max(
+      2,
+      Math.floor(Math.max(maxDim * 0.012, expand * 0.35))
+    );
+    const preprocessErodeRadius = Math.max(
+      1,
+      Math.floor(preprocessDilateRadius * 0.65)
+    );
+    const smoothDilateRadius = Math.max(
+      1,
+      Math.floor(preprocessDilateRadius * 0.25)
+    );
+    const smoothErodeRadius = Math.max(1, Math.floor(smoothDilateRadius * 0.8));
+    const connectStartDilateRadius = Math.max(
+      1,
+      Math.floor(Math.max(maxDim * 6e-3, expand * 0.2))
     );
-    const radius = (_d = options.morphologyRadius) != null ? _d : adaptiveRadius;
-    const expand = (_e = options.expand) != null ? _e : 0;
-    const noChannels = options.noChannels !== false;
-    const alphaOpaqueCutoff = (_f = options.alphaOpaqueCutoff) != null ? _f : 250;
-    const resolvedMaskMode = ((_g = options.maskMode) != null ? _g : "auto") === "auto" ? inferMaskMode(imageData, alphaOpaqueCutoff) : options.maskMode;
-    const alphaAnalysis = analyzeAlpha(imageData, alphaOpaqueCutoff);
+    const connectMaxDilateRadius = Math.max(
+      connectStartDilateRadius,
+      Math.floor(Math.max(maxDim * 0.2, expand * 2.5))
+    );
+    const connectErodeRatio = 0.65;
     debugLog("traceWithBounds:start", {
       width,
       height,
       threshold,
-      radius,
       expand,
-      noChannels,
-      maskMode: (_h = options.maskMode) != null ? _h : "auto",
-      resolvedMaskMode,
-      alphaOpaqueCutoff,
-      alpha: {
-        minAlpha: alphaAnalysis.minAlpha,
-        belowOpaqueRatio: Number(alphaAnalysis.belowOpaqueRatio.toFixed(4)),
-        veryTransparentRatio: Number(
-          alphaAnalysis.veryTransparentRatio.toFixed(4)
-        )
-      },
-      componentMode,
-      minComponentArea,
-      forceConnected,
-      simplifyTolerance: (_i = options.simplifyTolerance) != null ? _i : 2.5,
-      smoothing: options.smoothing !== false
+      simplifyTolerance,
+      smoothing: useSmoothing,
+      strategy: {
+        maskMode,
+        whiteThreshold,
+        alphaOpaqueCutoff,
+        fillHoles: true,
+        preprocessDilateRadius,
+        preprocessErodeRadius,
+        smoothDilateRadius,
+        smoothErodeRadius,
+        connectEnabled: true,
+        connectStartDilateRadius,
+        connectMaxDilateRadius,
+        connectErodeRatio
+      }
     });
-    const padding = radius + expand + 2;
+    const padding = Math.max(
+      preprocessDilateRadius,
+      smoothDilateRadius,
+      connectMaxDilateRadius,
+      expand
+    ) + 2;
     const paddedWidth = width + padding * 2;
     const paddedHeight = height + padding * 2;
+    const summarizeMaskContours = (m) => {
+      const summary = this.summarizeAllContours(
+        m,
+        paddedWidth,
+        paddedHeight,
+        minComponentArea
+      );
+      return {
+        rawContourCount: summary.rawCount,
+        selectedContourCount: summary.selectedCount
+      };
+    };
     let mask = createMask(imageData, {
       threshold,
       padding,
       paddedWidth,
       paddedHeight,
-      maskMode: options.maskMode,
-      whiteThreshold: options.whiteThreshold,
+      maskMode,
+      whiteThreshold,
       alphaOpaqueCutoff
     });
-    if (radius > 0) {
-      mask = circularMorphology(mask, paddedWidth, paddedHeight, radius, "closing");
-    }
-    if (noChannels) {
-      mask = fillHoles(mask, paddedWidth, paddedHeight);
+    if (debug) {
+      debugLog(
+        "traceWithBounds:mask:after-create",
+        summarizeMaskContours(mask)
+      );
     }
-    if (radius > 0) {
-      const smoothRadius = Math.max(2, Math.floor(radius * 0.3));
-      mask = circularMorphology(mask, paddedWidth, paddedHeight, smoothRadius, "closing");
+    mask = circularMorphology(
+      mask,
+      paddedWidth,
+      paddedHeight,
+      preprocessDilateRadius,
+      "dilate"
+    );
+    mask = fillHoles(mask, paddedWidth, paddedHeight);
+    mask = circularMorphology(
+      mask,
+      paddedWidth,
+      paddedHeight,
+      preprocessErodeRadius,
+      "erode"
+    );
+    mask = fillHoles(mask, paddedWidth, paddedHeight);
+    if (debug) {
+      debugLog("traceWithBounds:mask:after-preprocess", {
+        dilateRadius: preprocessDilateRadius,
+        erodeRadius: preprocessErodeRadius,
+        ...summarizeMaskContours(mask)
+      });
     }
-    const autoConnectRadiusMax = Math.max(
-      10,
-      Math.floor(Math.max(width, height) * 0.12)
+    mask = circularMorphology(
+      mask,
+      paddedWidth,
+      paddedHeight,
+      smoothDilateRadius,
+      "dilate"
     );
-    const requestedConnectRadiusMax = options.connectRadiusMax;
-    const connectRadiusMax = requestedConnectRadiusMax === void 0 ? autoConnectRadiusMax : requestedConnectRadiusMax > 0 ? requestedConnectRadiusMax : forceConnected ? autoConnectRadiusMax : 0;
-    let rConnect = 0;
-    if (connectRadiusMax > 0) {
-      rConnect = forceConnected ? this.findMinimalMergeRadiusByContourCount(
-        mask,
-        paddedWidth,
-        paddedHeight,
-        connectRadiusMax,
-        minComponentArea
-      ) : findMinimalConnectRadius(
+    mask = fillHoles(mask, paddedWidth, paddedHeight);
+    mask = circularMorphology(
+      mask,
+      paddedWidth,
+      paddedHeight,
+      smoothErodeRadius,
+      "erode"
+    );
+    mask = fillHoles(mask, paddedWidth, paddedHeight);
+    if (debug) {
+      debugLog("traceWithBounds:mask:after-smooth", {
+        dilateRadius: smoothDilateRadius,
+        erodeRadius: smoothErodeRadius,
+        ...summarizeMaskContours(mask)
+      });
+    }
+    const beforeConnectSummary = summarizeMaskContours(mask);
+    if (beforeConnectSummary.selectedContourCount <= 1) {
+      debugLog("traceWithBounds:mask:connect-skipped", {
+        reason: "already-single-component",
+        before: beforeConnectSummary
+      });
+    } else {
+      const connectResult = this.findForceConnectResult(
         mask,
         paddedWidth,
         paddedHeight,
-        connectRadiusMax
+        minComponentArea,
+        connectStartDilateRadius,
+        connectMaxDilateRadius,
+        connectErodeRatio
       );
-      if (rConnect > 0) {
-        mask = circularMorphology(
-          mask,
-          paddedWidth,
-          paddedHeight,
-          rConnect,
-          "closing"
-        );
-        if (noChannels) {
-          mask = fillHoles(mask, paddedWidth, paddedHeight);
-        }
+      if (debug) {
+        debugLog("traceWithBounds:mask:after-connect", {
+          before: beforeConnectSummary,
+          appliedDilateRadius: connectResult.appliedDilateRadius,
+          appliedErodeRadius: connectResult.appliedErodeRadius,
+          reachedSingleComponent: connectResult.reachedSingleComponent,
+          after: {
+            rawContourCount: connectResult.rawContourCount,
+            selectedContourCount: connectResult.selectedContourCount
+          }
+        });
+      }
+      mask = connectResult.mask;
+    }
+    if (debug) {
+      const afterConnectSummary = summarizeMaskContours(mask);
+      if (afterConnectSummary.selectedContourCount > 1) {
+        debugLog("traceWithBounds:mask:connect-warning", {
+          reason: "still-multi-component-after-connect-search",
+          summary: afterConnectSummary
+        });
       }
     }
     const baseMask = mask;
@@ -3293,8 +3355,8 @@ var ImageTracer = class {
       minComponentArea
     );
     if (!baseContours.length) {
-      const w = (_j = options.scaleToWidth) != null ? _j : width;
-      const h = (_k = options.scaleToHeight) != null ? _k : height;
+      const w = (_f = options.scaleToWidth) != null ? _f : width;
+      const h = (_g = options.scaleToHeight) != null ? _g : height;
       debugLog("fallback:no-base-contour", { width: w, height: h });
       return {
         pathData: `M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z`,
@@ -3313,8 +3375,8 @@ var ImageTracer = class {
       )
     ).filter((contour) => contour.length > 2);
     if (!baseUnpaddedContours.length) {
-      const w = (_l = options.scaleToWidth) != null ? _l : width;
-      const h = (_m = options.scaleToHeight) != null ? _m : height;
+      const w = (_h = options.scaleToWidth) != null ? _h : width;
+      const h = (_i = options.scaleToHeight) != null ? _i : height;
       debugLog("fallback:empty-base-contours", { width: w, height: h });
       return {
         pathData: `M 0 0 L ${w} 0 L ${w} ${h} L 0 ${h} Z`,
@@ -3359,14 +3421,10 @@ var ImageTracer = class {
       };
     }
     const expandedUnpaddedContours = expandedContours.map(
-      (contour) => this.clampPointsToImageBounds(
-        contour.map((p) => ({
-          x: p.x - padding,
-          y: p.y - padding
-        })),
-        width,
-        height
-      )
+      (contour) => contour.map((p) => ({
+        x: p.x - padding,
+        y: p.y - padding
+      }))
     ).filter((contour) => contour.length > 2);
     if (!expandedUnpaddedContours.length) {
       debugLog("fallback:empty-expanded-contours", {
@@ -3399,39 +3457,31 @@ var ImageTracer = class {
         options.scaleToHeight,
         baseBounds
       );
-      baseBounds = this.boundsFromPoints(this.flattenContours(baseScaledContours));
+      baseBounds = this.boundsFromPoints(
+        this.flattenContours(baseScaledContours)
+      );
     }
-    const useSmoothing = options.smoothing !== false;
     debugLog("traceWithBounds:contours", {
       baseContourCount: baseContoursRaw.length,
       baseSelectedCount: baseContours.length,
       expandedContourCount: expandedContoursRaw.length,
       expandedSelectedCount: expandedContours.length,
-      connectRadiusMax,
-      appliedConnectRadius: rConnect,
       baseBounds,
       expandedBounds: globalBounds,
       expandedDeltaX: globalBounds.width - baseBounds.width,
       expandedDeltaY: globalBounds.height - baseBounds.height,
+      expandedMayOverflowImageBounds: expand > 0,
       useSmoothing,
       componentMode
     });
     if (useSmoothing) {
       return {
-        pathData: this.contoursToSVGPaper(
-          finalContours,
-          (_n = options.simplifyTolerance) != null ? _n : 2.5
-        ),
+        pathData: this.contoursToSVGPaper(finalContours, simplifyTolerance),
         baseBounds,
         bounds: globalBounds
       };
     } else {
-      const simplifiedContours = finalContours.map(
-        (points) => {
-          var _a2;
-          return this.douglasPeucker(points, (_a2 = options.simplifyTolerance) != null ? _a2 : 2);
-        }
-      ).filter((points) => points.length > 2);
+      const simplifiedContours = finalContours.map((points) => this.douglasPeucker(points, simplifyTolerance)).filter((points) => points.length > 2);
       const pathData = this.contoursToSVG(simplifiedContours) || this.contoursToSVG(finalContours);
       return {
         pathData,
@@ -3494,39 +3544,101 @@ var ImageTracer = class {
     }
     return selected;
   }
-  static countSelectedContours(mask, width, height, minComponentArea) {
-    const contours = this.traceAllContours(mask, width, height);
-    return this.selectContours(contours, "all", minComponentArea).length;
-  }
-  static findMinimalMergeRadiusByContourCount(mask, width, height, maxRadius, minComponentArea) {
-    if (maxRadius <= 0) return 0;
-    if (this.countSelectedContours(mask, width, height, minComponentArea) <= 1) {
-      return 0;
-    }
-    let low = 0;
-    let high = 1;
-    while (high <= maxRadius) {
-      const closed = circularMorphology(mask, width, height, high, "closing");
-      if (this.countSelectedContours(closed, width, height, minComponentArea) <= 1) {
-        break;
-      }
-      high *= 2;
+  static summarizeAllContours(mask, width, height, minComponentArea) {
+    const raw = this.traceAllContours(mask, width, height);
+    const selected = this.selectContours(raw, "all", minComponentArea);
+    return {
+      rawCount: raw.length,
+      selectedCount: selected.length
+    };
+  }
+  static findForceConnectResult(sourceMask, width, height, minComponentArea, startDilateRadius, maxDilateRadius, erodeRatio) {
+    const initial = this.summarizeAllContours(
+      sourceMask,
+      width,
+      height,
+      minComponentArea
+    );
+    if (initial.selectedCount <= 1) {
+      return {
+        mask: sourceMask,
+        appliedDilateRadius: 0,
+        appliedErodeRadius: 0,
+        reachedSingleComponent: true,
+        rawContourCount: initial.rawCount,
+        selectedContourCount: initial.selectedCount
+      };
+    }
+    const normalizedStart = Math.max(1, Math.floor(startDilateRadius));
+    const normalizedMax = Math.max(
+      normalizedStart,
+      Math.floor(maxDilateRadius)
+    );
+    const normalizedErodeRatio = Math.max(0, erodeRatio);
+    const evaluate = (dilateRadius) => {
+      const erodeRadius = Math.max(
+        1,
+        Math.floor(dilateRadius * normalizedErodeRatio)
+      );
+      let mask = sourceMask;
+      mask = circularMorphology(mask, width, height, dilateRadius, "dilate");
+      mask = fillHoles(mask, width, height);
+      mask = circularMorphology(mask, width, height, erodeRadius, "erode");
+      mask = fillHoles(mask, width, height);
+      const summary = this.summarizeAllContours(
+        mask,
+        width,
+        height,
+        minComponentArea
+      );
+      return {
+        dilateRadius,
+        erodeRadius,
+        mask,
+        rawCount: summary.rawCount,
+        selectedCount: summary.selectedCount
+      };
+    };
+    let low = normalizedStart - 1;
+    let high = normalizedStart;
+    let highResult = evaluate(high);
+    while (high < normalizedMax && highResult.selectedCount > 1) {
+      low = high;
+      high = Math.min(
+        normalizedMax,
+        Math.max(high + 1, Math.floor(high * 1.6))
+      );
+      highResult = evaluate(high);
     }
-    if (high > maxRadius) high = maxRadius;
-    const highMask = circularMorphology(mask, width, height, high, "closing");
-    if (this.countSelectedContours(highMask, width, height, minComponentArea) > 1) {
-      return high;
+    if (highResult.selectedCount > 1) {
+      return {
+        mask: highResult.mask,
+        appliedDilateRadius: highResult.dilateRadius,
+        appliedErodeRadius: highResult.erodeRadius,
+        reachedSingleComponent: false,
+        rawContourCount: highResult.rawCount,
+        selectedContourCount: highResult.selectedCount
+      };
     }
+    let best = highResult;
     while (low + 1 < high) {
       const mid = Math.floor((low + high) / 2);
-      const midMask = circularMorphology(mask, width, height, mid, "closing");
-      if (this.countSelectedContours(midMask, width, height, minComponentArea) <= 1) {
+      const midResult = evaluate(mid);
+      if (midResult.selectedCount <= 1) {
+        best = midResult;
         high = mid;
       } else {
         low = mid;
       }
     }
-    return high;
+    return {
+      mask: best.mask,
+      appliedDilateRadius: best.dilateRadius,
+      appliedErodeRadius: best.erodeRadius,
+      reachedSingleComponent: true,
+      rawContourCount: best.rawCount,
+      selectedContourCount: best.selectedCount
+    };
   }
   static selectContours(contours, mode, minComponentArea) {
     if (!contours.length) return [];
@@ -3568,154 +3680,6 @@ var ImageTracer = class {
       height: maxY - minY
     };
   }
-  static createMask(imageData, threshold, padding, paddedWidth, paddedHeight) {
-    const { width, height, data } = imageData;
-    const mask = new Uint8Array(paddedWidth * paddedHeight);
-    let hasTransparency = false;
-    for (let i = 3; i < data.length; i += 4) {
-      if (data[i] < 255) {
-        hasTransparency = true;
-        break;
-      }
-    }
-    for (let y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++) {
-        const srcIdx = (y * width + x) * 4;
-        const r = data[srcIdx];
-        const g = data[srcIdx + 1];
-        const b = data[srcIdx + 2];
-        const a = data[srcIdx + 3];
-        const destIdx = (y + padding) * paddedWidth + (x + padding);
-        if (hasTransparency) {
-          if (a > threshold) {
-            mask[destIdx] = 1;
-          }
-        } else {
-          if (!(r > 240 && g > 240 && b > 240)) {
-            mask[destIdx] = 1;
-          }
-        }
-      }
-    }
-    return mask;
-  }
-  /**
-   * Fast circular morphology using a distance-transform inspired separable approach.
-   * O(N * R) complexity, where R is the radius.
-   */
-  static circularMorphology(mask, width, height, radius, op) {
-    const dilate = (m, r) => {
-      const horizontalDist = new Int32Array(width * height);
-      for (let y = 0; y < height; y++) {
-        let lastSolid = -r * 2;
-        for (let x = 0; x < width; x++) {
-          if (m[y * width + x]) lastSolid = x;
-          horizontalDist[y * width + x] = x - lastSolid;
-        }
-        lastSolid = width + r * 2;
-        for (let x = width - 1; x >= 0; x--) {
-          if (m[y * width + x]) lastSolid = x;
-          horizontalDist[y * width + x] = Math.min(
-            horizontalDist[y * width + x],
-            lastSolid - x
-          );
-        }
-      }
-      const result = new Uint8Array(width * height);
-      const r2 = r * r;
-      for (let x = 0; x < width; x++) {
-        for (let y = 0; y < height; y++) {
-          let found = false;
-          const minY = Math.max(0, y - r);
-          const maxY = Math.min(height - 1, y + r);
-          for (let dy = minY; dy <= maxY; dy++) {
-            const dY = dy - y;
-            const hDist = horizontalDist[dy * width + x];
-            if (hDist * hDist + dY * dY <= r2) {
-              found = true;
-              break;
-            }
-          }
-          if (found) result[y * width + x] = 1;
-        }
-      }
-      return result;
-    };
-    const erode = (m, r) => {
-      const inverted = new Uint8Array(m.length);
-      for (let i = 0; i < m.length; i++) inverted[i] = m[i] ? 0 : 1;
-      const dilatedInverted = dilate(inverted, r);
-      const result = new Uint8Array(m.length);
-      for (let i = 0; i < m.length; i++) result[i] = dilatedInverted[i] ? 0 : 1;
-      return result;
-    };
-    switch (op) {
-      case "dilate":
-        return dilate(mask, radius);
-      case "erode":
-        return erode(mask, radius);
-      case "closing":
-        return erode(dilate(mask, radius), radius);
-      case "opening":
-        return dilate(erode(mask, radius), radius);
-      default:
-        return mask;
-    }
-  }
-  /**
-   * Fills internal holes in the binary mask using flood fill from edges.
-   */
-  static fillHoles(mask, width, height) {
-    const background = new Uint8Array(width * height);
-    const queue = [];
-    for (let x = 0; x < width; x++) {
-      if (mask[x] === 0) {
-        background[x] = 1;
-        queue.push([x, 0]);
-      }
-      const lastRow = (height - 1) * width + x;
-      if (mask[lastRow] === 0) {
-        background[lastRow] = 1;
-        queue.push([x, height - 1]);
-      }
-    }
-    for (let y = 1; y < height - 1; y++) {
-      if (mask[y * width] === 0) {
-        background[y * width] = 1;
-        queue.push([0, y]);
-      }
-      if (mask[y * width + width - 1] === 0) {
-        background[y * width + width - 1] = 1;
-        queue.push([width - 1, y]);
-      }
-    }
-    const dirs = [
-      [0, 1],
-      [0, -1],
-      [1, 0],
-      [-1, 0]
-    ];
-    let head = 0;
-    while (head < queue.length) {
-      const [cx, cy] = queue[head++];
-      for (const [dx, dy] of dirs) {
-        const nx = cx + dx;
-        const ny = cy + dy;
-        if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
-          const nidx = ny * width + nx;
-          if (mask[nidx] === 0 && background[nidx] === 0) {
-            background[nidx] = 1;
-            queue.push([nx, ny]);
-          }
-        }
-      }
-    }
-    const filledMask = new Uint8Array(width * height);
-    for (let i = 0; i < width * height; i++) {
-      filledMask[i] = background[i] === 0 ? 1 : 0;
-    }
-    return filledMask;
-  }
   /**
    * Traces all contours in the mask with optimized start-point detection
    */
@@ -4252,10 +4216,17 @@ var DielineTool = class {
           command: "detectEdge",
           title: "Detect Edge from Image",
           handler: async (imageUrl, options) => {
-            var _a;
+            var _a, _b, _c;
             try {
               const detectOptions = options || {};
               const debug = detectOptions.debug === true;
+              const tracerOptions = {
+                expand: (_a = detectOptions.expand) != null ? _a : 0,
+                smoothing: (_b = detectOptions.smoothing) != null ? _b : true,
+                simplifyTolerance: (_c = detectOptions.simplifyTolerance) != null ? _c : 2,
+                threshold: detectOptions.threshold,
+                debug
+              };
               const loadImage = (url) => {
                 return new Promise((resolve, reject) => {
                   const img2 = new Image();
@@ -4267,7 +4238,7 @@ var DielineTool = class {
               };
               const [img, traced] = await Promise.all([
                 loadImage(imageUrl),
-                ImageTracer.traceWithBounds(imageUrl, detectOptions)
+                ImageTracer.traceWithBounds(imageUrl, tracerOptions)
               ]);
               const { pathData, baseBounds, bounds } = traced;
               if (debug) {
@@ -4278,21 +4249,8 @@ var DielineTool = class {
                   expandedBounds: bounds,
                   currentDielineWidth: s.width,
                   currentDielineHeight: s.height,
-                  options: {
-                    expand: (_a = detectOptions.expand) != null ? _a : 0,
-                    morphologyRadius: detectOptions.morphologyRadius,
-                    connectRadiusMax: detectOptions.connectRadiusMax,
-                    smoothing: detectOptions.smoothing,
-                    simplifyTolerance: detectOptions.simplifyTolerance,
-                    threshold: detectOptions.threshold,
-                    maskMode: detectOptions.maskMode,
-                    whiteThreshold: detectOptions.whiteThreshold,
-                    alphaOpaqueCutoff: detectOptions.alphaOpaqueCutoff,
-                    noChannels: detectOptions.noChannels,
-                    componentMode: detectOptions.componentMode,
-                    minComponentArea: detectOptions.minComponentArea,
-                    forceConnected: detectOptions.forceConnected
-                  }
+                  options: tracerOptions,
+                  strategy: "single-connected-silhouette"
                 });
               }
               return {
@@ -7009,6 +6967,82 @@ var WhiteInkTool = class {
       height
     };
   }
+  getImagePlacementState(id) {
+    const rawItems = this.getConfig("image.items", []);
+    if (!Array.isArray(rawItems) || rawItems.length === 0) return null;
+    const matched = (id ? rawItems.find(
+      (item) => item && typeof item === "object" && typeof item.id === "string" && item.id === id
+    ) : void 0) || rawItems[0];
+    if (!matched || typeof matched !== "object") return null;
+    const sourceUrl = typeof matched.sourceUrl === "string" && matched.sourceUrl.length > 0 ? matched.sourceUrl : typeof matched.url === "string" ? matched.url : "";
+    const committedUrl = typeof matched.committedUrl === "string" ? matched.committedUrl : "";
+    return {
+      id: typeof matched.id === "string" && matched.id.length > 0 ? matched.id : id || "image",
+      sourceUrl,
+      committedUrl,
+      left: Number.isFinite(matched.left) ? Number(matched.left) : 0.5,
+      top: Number.isFinite(matched.top) ? Number(matched.top) : 0.5,
+      scale: Number.isFinite(matched.scale) ? Math.max(0.05, matched.scale) : 1,
+      angle: Number.isFinite(matched.angle) ? matched.angle : 0
+    };
+  }
+  shouldRestoreSnapshotToSource(snapshot, placement) {
+    if (!placement.sourceUrl || !placement.committedUrl) return false;
+    if (placement.sourceUrl === placement.committedUrl) return false;
+    return snapshot.src === placement.committedUrl;
+  }
+  getCoverScale(frame, source) {
+    const frameW = Math.max(1, frame.width);
+    const frameH = Math.max(1, frame.height);
+    const sourceW = Math.max(1, source.width);
+    const sourceH = Math.max(1, source.height);
+    return Math.max(frameW / sourceW, frameH / sourceH);
+  }
+  async ensureSourceSize(sourceUrl) {
+    if (!sourceUrl) return null;
+    const cached = this.getSourceSize(sourceUrl);
+    if (cached) return cached;
+    try {
+      const image = await this.loadImageElement(sourceUrl);
+      const size = this.getElementSize(image);
+      if (!size) return null;
+      this.rememberSourceSize(sourceUrl, size);
+      return {
+        width: size.width,
+        height: size.height
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  async resolveAlignedImageSnapshot(snapshot) {
+    const placement = this.getImagePlacementState(snapshot.id);
+    if (!placement) return snapshot;
+    if (!this.shouldRestoreSnapshotToSource(snapshot, placement)) {
+      return snapshot;
+    }
+    const frame = this.getFrameRect();
+    if (frame.width <= 0 || frame.height <= 0) {
+      return snapshot;
+    }
+    const sourceSize = await this.ensureSourceSize(placement.sourceUrl);
+    if (!sourceSize) return snapshot;
+    const coverScale = this.getCoverScale(frame, sourceSize);
+    return {
+      ...snapshot,
+      src: placement.sourceUrl,
+      element: void 0,
+      left: frame.left + placement.left * frame.width,
+      top: frame.top + placement.top * frame.height,
+      scaleX: coverScale * placement.scale,
+      scaleY: coverScale * placement.scale,
+      angle: placement.angle,
+      originX: "center",
+      originY: "center",
+      width: sourceSize.width,
+      height: sourceSize.height
+    };
+  }
   getImageElementFromObject(obj) {
     if (!obj) return null;
     if (typeof obj.getElement === "function") {
@@ -7381,9 +7415,11 @@ var WhiteInkTool = class {
     let whiteSpecs = [];
     let coverSpecs = [];
     if (previewActive) {
-      const snapshot = this.getImageSnapshot(this.getPrimaryImageObject());
+      const baseSnapshot = this.getImageSnapshot(this.getPrimaryImageObject());
       const item = this.getEffectiveWhiteInkItem(this.resolveRenderItems());
-      if (snapshot && item) {
+      if (baseSnapshot && item) {
+        const snapshot = await this.resolveAlignedImageSnapshot(baseSnapshot);
+        if (seq !== this.renderSeq) return;
         const sources = await this.resolveRenderSources(snapshot, item);
         if (seq !== this.renderSeq) return;
         if (sources == null ? void 0 : sources.whiteSrc) {