@pooder/kit 6.1.2 → 6.2.1

package/dist/index.mjs

@@ -400,6 +400,7 @@ var WHITE_INK_OBJECT_LAYER_ID = "white-ink.user";
 var WHITE_INK_COVER_LAYER_ID = "white-ink.cover";
 var WHITE_INK_OVERLAY_LAYER_ID = "white-ink.overlay";
 var DIELINE_LAYER_ID = "dieline-overlay";
+var FEATURE_DIELINE_LAYER_ID = "feature-dieline-overlay";
 var FEATURE_OVERLAY_LAYER_ID = "feature-overlay";
 var RULER_LAYER_ID = "ruler-overlay";
 var FILM_LAYER_ID = "overlay";
@@ -541,6 +542,18 @@ function normalizeFitMode2(value, fallback) {
   }
   return fallback;
 }
+function normalizeRegionUnit(value, fallback) {
+  if (value === "px" || value === "normalized") {
+    return value;
+  }
+  return fallback;
+}
+function normalizeRegistrationFrame(value, fallback) {
+  if (value === "trim" || value === "cut" || value === "bleed" || value === "focus" || value === "viewport") {
+    return value;
+  }
+  return fallback;
+}
 function normalizeAnchor(value, fallback) {
   if (typeof value !== "string") return fallback;
   const trimmed = value.trim();
@@ -551,6 +564,63 @@ function normalizeOrder(value, fallback) {
   if (!Number.isFinite(numeric)) return fallback;
   return numeric;
 }
+function normalizeRegionValue(value, fallback) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+function normalizeRegistrationRegion(raw, fallback) {
+  if (!raw || typeof raw !== "object") {
+    return fallback ? { ...fallback } : void 0;
+  }
+  const input = raw;
+  const base = fallback || {
+    left: 0,
+    top: 0,
+    width: 1,
+    height: 1,
+    unit: "normalized"
+  };
+  return {
+    left: normalizeRegionValue(input.left, base.left),
+    top: normalizeRegionValue(input.top, base.top),
+    width: normalizeRegionValue(input.width, base.width),
+    height: normalizeRegionValue(input.height, base.height),
+    unit: normalizeRegionUnit(input.unit, base.unit)
+  };
+}
+function normalizeRegistration(raw, fallback) {
+  if (!raw || typeof raw !== "object") {
+    return fallback ? {
+      sourceRegion: fallback.sourceRegion ? { ...fallback.sourceRegion } : void 0,
+      targetFrame: fallback.targetFrame,
+      fit: fallback.fit
+    } : void 0;
+  }
+  const input = raw;
+  const normalized = {
+    sourceRegion: normalizeRegistrationRegion(
+      input.sourceRegion,
+      fallback == null ? void 0 : fallback.sourceRegion
+    ),
+    targetFrame: normalizeRegistrationFrame(
+      input.targetFrame,
+      (fallback == null ? void 0 : fallback.targetFrame) || "trim"
+    ),
+    fit: normalizeFitMode2(input.fit, (fallback == null ? void 0 : fallback.fit) || "stretch")
+  };
+  if (!normalized.sourceRegion) {
+    return void 0;
+  }
+  return normalized;
+}
+function cloneRegistration(registration) {
+  if (!registration) return void 0;
+  return {
+    sourceRegion: registration.sourceRegion ? { ...registration.sourceRegion } : void 0,
+    targetFrame: registration.targetFrame,
+    fit: registration.fit
+  };
+}
 function normalizeLayer(raw, index, fallback) {
   const fallbackLayer = fallback || {
     id: `layer-${index + 1}`,
@@ -564,7 +634,10 @@ function normalizeLayer(raw, index, fallback) {
     src: ""
   };
   if (!raw || typeof raw !== "object") {
-    return { ...fallbackLayer };
+    return {
+      ...fallbackLayer,
+      registration: cloneRegistration(fallbackLayer.registration)
+    };
   }
   const input = raw;
   const kind = normalizeLayerKind(input.kind, fallbackLayer.kind);
@@ -578,7 +651,8 @@ function normalizeLayer(raw, index, fallback) {
     enabled: typeof input.enabled === "boolean" ? input.enabled : fallbackLayer.enabled,
     exportable: typeof input.exportable === "boolean" ? input.exportable : fallbackLayer.exportable,
     color: kind === "color" ? typeof input.color === "string" ? input.color : typeof fallbackLayer.color === "string" ? fallbackLayer.color : "#ffffff" : void 0,
-    src: kind === "image" ? typeof input.src === "string" ? input.src.trim() : typeof fallbackLayer.src === "string" ? fallbackLayer.src : "" : void 0
+    src: kind === "image" ? typeof input.src === "string" ? input.src.trim() : typeof fallbackLayer.src === "string" ? fallbackLayer.src : "" : void 0,
+    registration: kind === "image" ? normalizeRegistration(input.registration, fallbackLayer.registration) : void 0
   };
 }
 function normalizeConfig(raw) {
@@ -608,7 +682,10 @@ function normalizeConfig(raw) {
 function cloneConfig(config) {
   return {
     version: config.version,
-    layers: (config.layers || []).map((layer) => ({ ...layer }))
+    layers: (config.layers || []).map((layer) => ({
+      ...layer,
+      registration: cloneRegistration(layer.registration)
+    }))
   };
 }
 function mergeConfig(base, patch) {
@@ -859,6 +936,41 @@ var BackgroundTool = class {
       height: layout.trimRect.height
     };
   }
+  resolveTargetFrameRect(frame) {
+    if (frame === "viewport") {
+      return this.getViewportRect();
+    }
+    const layout = this.resolveSceneLayout();
+    if (!layout) {
+      return frame === "focus" ? this.getViewportRect() : null;
+    }
+    switch (frame) {
+      case "trim":
+      case "focus":
+        return {
+          left: layout.trimRect.left,
+          top: layout.trimRect.top,
+          width: layout.trimRect.width,
+          height: layout.trimRect.height
+        };
+      case "cut":
+        return {
+          left: layout.cutRect.left,
+          top: layout.cutRect.top,
+          width: layout.cutRect.width,
+          height: layout.cutRect.height
+        };
+      case "bleed":
+        return {
+          left: layout.bleedRect.left,
+          top: layout.bleedRect.top,
+          width: layout.bleedRect.width,
+          height: layout.bleedRect.height
+        };
+      default:
+        return null;
+    }
+  }
   resolveAnchorRect(anchor) {
     if (anchor === "focus") {
       return this.resolveFocusRect() || this.getViewportRect();
@@ -891,6 +1003,53 @@ var BackgroundTool = class {
       scaleY: scale
     };
   }
+  resolveRegistrationRegion(region, sourceSize) {
+    const sourceWidth = Math.max(1, Number(sourceSize.width || 0));
+    const sourceHeight = Math.max(1, Number(sourceSize.height || 0));
+    const width = region.unit === "normalized" ? region.width * sourceWidth : region.width;
+    const height = region.unit === "normalized" ? region.height * sourceHeight : region.height;
+    const left = region.unit === "normalized" ? region.left * sourceWidth : region.left;
+    const top = region.unit === "normalized" ? region.top * sourceHeight : region.top;
+    if (!Number.isFinite(left) || !Number.isFinite(top) || !Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+      return null;
+    }
+    return { left, top, width, height };
+  }
+  resolveRegistrationPlacement(layer, sourceSize) {
+    const registration = layer.registration;
+    if (!(registration == null ? void 0 : registration.sourceRegion)) return null;
+    const targetRect = this.resolveTargetFrameRect(
+      registration.targetFrame || "trim"
+    );
+    if (!targetRect) return null;
+    const sourceRegion = this.resolveRegistrationRegion(
+      registration.sourceRegion,
+      sourceSize
+    );
+    if (!sourceRegion) return null;
+    const fit = registration.fit || "stretch";
+    const baseScaleX = targetRect.width / sourceRegion.width;
+    const baseScaleY = targetRect.height / sourceRegion.height;
+    if (fit === "stretch") {
+      return {
+        left: targetRect.left - sourceRegion.left * baseScaleX,
+        top: targetRect.top - sourceRegion.top * baseScaleY,
+        scaleX: baseScaleX,
+        scaleY: baseScaleY
+      };
+    }
+    const uniformScale = fit === "contain" ? Math.min(baseScaleX, baseScaleY) : Math.max(baseScaleX, baseScaleY);
+    const alignedWidth = sourceRegion.width * uniformScale;
+    const alignedHeight = sourceRegion.height * uniformScale;
+    const offsetLeft = targetRect.left + (targetRect.width - alignedWidth) / 2;
+    const offsetTop = targetRect.top + (targetRect.height - alignedHeight) / 2;
+    return {
+      left: offsetLeft - sourceRegion.left * uniformScale,
+      top: offsetTop - sourceRegion.top * uniformScale,
+      scaleX: uniformScale,
+      scaleY: uniformScale
+    };
+  }
   buildColorLayerSpec(layer) {
     const rect = this.resolveAnchorRect(layer.anchor);
     return {
@@ -924,8 +1083,11 @@ var BackgroundTool = class {
     if (!src) return [];
     const sourceSize = this.sourceSizeCache.getSourceSize(src);
     if (!sourceSize) return [];
-    const rect = this.resolveAnchorRect(layer.anchor);
-    const placement = this.resolveImagePlacement(rect, sourceSize, layer.fit);
+    const placement = this.resolveRegistrationPlacement(layer, sourceSize) || this.resolveImagePlacement(
+      this.resolveAnchorRect(layer.anchor),
+      sourceSize,
+      layer.fit
+    );
     return [
       {
         id: `background.layer.${layer.id}.image`,
@@ -1025,7 +1187,6 @@ import {
   Canvas as FabricCanvas,
   Control,
   Image as FabricImage2,
-  Path as FabricPath,
   Pattern,
   Point,
   controlsUtils
@@ -2000,8 +2161,6 @@ var IMAGE_DEFAULT_CONTROL_CAPABILITIES = [
   "scale"
 ];
 var IMAGE_MOVE_SNAP_THRESHOLD_PX = 6;
-var IMAGE_MOVE_SNAP_RELEASE_THRESHOLD_PX = 10;
-var IMAGE_SNAP_GUIDE_LAYER_ID = "image.snapGuide";
 var IMAGE_CONTROL_DESCRIPTORS = [
   {
     key: "tl",
@@ -2048,13 +2207,15 @@ var ImageTool = class {
     this.overlaySpecs = [];
     this.activeSnapX = null;
     this.activeSnapY = null;
+    this.movingImageId = null;
+    this.hasRenderedSnapGuides = false;
     this.subscriptions = new SubscriptionBag();
     this.imageControlsByCapabilityKey = /* @__PURE__ */ new Map();
     this.onToolActivated = (event) => {
       const before = this.isToolActive;
       this.syncToolActiveFromWorkbench(event.id);
       if (!this.isToolActive) {
-        this.clearSnapGuides();
+        this.endMoveSnapInteraction();
         this.setImageFocus(null, {
           syncCanvasSelection: true,
           skipRender: true
@@ -2105,7 +2266,7 @@ var ImageTool = class {
       this.updateImages();
     };
     this.onSelectionCleared = () => {
-      this.clearSnapGuides();
+      this.endMoveSnapInteraction();
       this.setImageFocus(null, {
         syncCanvasSelection: false,
         skipRender: true
@@ -2114,7 +2275,8 @@ var ImageTool = class {
       this.updateImages();
     };
     this.onSceneLayoutChanged = () => {
-      this.updateSnapGuideVisuals();
+      var _a;
+      (_a = this.canvasService) == null ? void 0 : _a.requestRenderAll();
       this.updateImages();
     };
     this.onSceneGeometryChanged = () => {
@@ -2127,11 +2289,12 @@ var ImageTool = class {
       const id = (_a = target == null ? void 0 : target.data) == null ? void 0 : _a.id;
       const layerId = (_b = target == null ? void 0 : target.data) == null ? void 0 : _b.layerId;
       if (typeof id !== "string" || layerId !== IMAGE_OBJECT_LAYER_ID) return;
+      if (this.movingImageId === id) {
+        this.applyMoveSnapToTarget(target);
+      }
       const frame = this.getFrameRect();
+      this.endMoveSnapInteraction();
       if (!frame.width || !frame.height) return;
-      const matches = this.computeMoveSnapMatches(target, frame);
-      this.applySnapMatchesToTarget(target, matches);
-      this.clearSnapGuides();
       const center = target.getCenterPoint ? target.getCenterPoint() : new Point((_c = target.left) != null ? _c : 0, (_d = target.top) != null ? _d : 0);
       const centerScene = this.canvasService ? this.canvasService.toScenePoint({ x: center.x, y: center.y }) : { x: center.x, y: center.y };
       const objectScale = Number.isFinite(target == null ? void 0 : target.scaleX) ? target.scaleX : 1;
@@ -2272,7 +2435,7 @@ var ImageTool = class {
     this.imageSpecs = [];
     this.overlaySpecs = [];
     this.imageControlsByCapabilityKey.clear();
-    this.clearSnapGuides();
+    this.endMoveSnapInteraction();
     this.unbindCanvasInteractionHandlers();
     this.clearRenderedImages();
     (_b = this.renderProducerDisposable) == null ? void 0 : _b.dispose();
@@ -2285,21 +2448,61 @@ var ImageTool = class {
   }
   bindCanvasInteractionHandlers() {
     if (!this.canvasService || this.canvasObjectMovingHandler) return;
+    this.canvasMouseUpHandler = (e) => {
+      var _a;
+      const target = this.getActiveImageTarget(e == null ? void 0 : e.target);
+      if (target && typeof ((_a = target == null ? void 0 : target.data) == null ? void 0 : _a.id) === "string" && target.data.id === this.movingImageId) {
+        this.applyMoveSnapToTarget(target);
+      }
+      this.endMoveSnapInteraction();
+    };
     this.canvasObjectMovingHandler = (e) => {
       this.handleCanvasObjectMoving(e);
     };
+    this.canvasBeforeRenderHandler = () => {
+      this.handleCanvasBeforeRender();
+    };
+    this.canvasAfterRenderHandler = () => {
+      this.handleCanvasAfterRender();
+    };
+    this.canvasService.canvas.on("mouse:up", this.canvasMouseUpHandler);
     this.canvasService.canvas.on(
       "object:moving",
       this.canvasObjectMovingHandler
     );
+    this.canvasService.canvas.on(
+      "before:render",
+      this.canvasBeforeRenderHandler
+    );
+    this.canvasService.canvas.on("after:render", this.canvasAfterRenderHandler);
   }
   unbindCanvasInteractionHandlers() {
-    if (!this.canvasService || !this.canvasObjectMovingHandler) return;
-    this.canvasService.canvas.off(
-      "object:moving",
-      this.canvasObjectMovingHandler
-    );
+    if (!this.canvasService) return;
+    if (this.canvasMouseUpHandler) {
+      this.canvasService.canvas.off("mouse:up", this.canvasMouseUpHandler);
+    }
+    if (this.canvasObjectMovingHandler) {
+      this.canvasService.canvas.off(
+        "object:moving",
+        this.canvasObjectMovingHandler
+      );
+    }
+    if (this.canvasBeforeRenderHandler) {
+      this.canvasService.canvas.off(
+        "before:render",
+        this.canvasBeforeRenderHandler
+      );
+    }
+    if (this.canvasAfterRenderHandler) {
+      this.canvasService.canvas.off(
+        "after:render",
+        this.canvasAfterRenderHandler
+      );
+    }
+    this.canvasMouseUpHandler = void 0;
     this.canvasObjectMovingHandler = void 0;
+    this.canvasBeforeRenderHandler = void 0;
+    this.canvasAfterRenderHandler = void 0;
   }
   getActiveImageTarget(target) {
     var _a, _b;
@@ -2328,20 +2531,11 @@ var ImageTool = class {
     if (!this.canvasService) return px;
     return this.canvasService.toSceneLength(px);
   }
-  pickSnapMatch(candidates, previous) {
+  pickSnapMatch(candidates) {
     if (!candidates.length) return null;
     const snapThreshold = this.getSnapThresholdScene(
       IMAGE_MOVE_SNAP_THRESHOLD_PX
     );
-    const releaseThreshold = this.getSnapThresholdScene(
-      IMAGE_MOVE_SNAP_RELEASE_THRESHOLD_PX
-    );
-    if (previous) {
-      const sticky = candidates.find((candidate) => {
-        return candidate.lineId === previous.lineId && Math.abs(candidate.deltaScene) <= releaseThreshold;
-      });
-      if (sticky) return sticky;
-    }
     let best = null;
     candidates.forEach((candidate) => {
       if (Math.abs(candidate.deltaScene) > snapThreshold) return;
@@ -2351,8 +2545,7 @@ var ImageTool = class {
     });
     return best;
   }
-  computeMoveSnapMatches(target, frame) {
-    const bounds = this.getTargetBoundsScene(target);
+  computeMoveSnapMatches(bounds, frame) {
     if (!bounds || frame.width <= 0 || frame.height <= 0) {
       return { x: null, y: null };
     }
@@ -2403,8 +2596,8 @@ var ImageTool = class {
       }
     ];
     return {
-      x: this.pickSnapMatch(xCandidates, this.activeSnapX),
-      y: this.pickSnapMatch(yCandidates, this.activeSnapY)
+      x: this.pickSnapMatch(xCandidates),
+      y: this.pickSnapMatch(yCandidates)
     };
   }
   areSnapMatchesEqual(a, b) {
@@ -2413,136 +2606,123 @@ var ImageTool = class {
     return a.lineId === b.lineId && a.axis === b.axis && a.kind === b.kind;
   }
   updateSnapMatchState(nextX, nextY) {
+    var _a;
     const changed = !this.areSnapMatchesEqual(this.activeSnapX, nextX) || !this.areSnapMatchesEqual(this.activeSnapY, nextY);
     this.activeSnapX = nextX;
     this.activeSnapY = nextY;
     if (changed) {
-      this.updateSnapGuideVisuals();
+      (_a = this.canvasService) == null ? void 0 : _a.requestRenderAll();
     }
   }
-  clearSnapGuides() {
+  clearSnapPreview() {
     var _a;
     this.activeSnapX = null;
     this.activeSnapY = null;
-    this.removeSnapGuideObject("x");
-    this.removeSnapGuideObject("y");
+    this.hasRenderedSnapGuides = false;
     (_a = this.canvasService) == null ? void 0 : _a.requestRenderAll();
   }
-  removeSnapGuideObject(axis) {
+  endMoveSnapInteraction() {
+    this.movingImageId = null;
+    this.clearSnapPreview();
+  }
+  applyMoveSnapToTarget(target) {
+    var _a, _b, _c, _d;
+    if (!this.canvasService) {
+      return { x: null, y: null };
+    }
+    const frame = this.getFrameRect();
+    if (frame.width <= 0 || frame.height <= 0) {
+      return { x: null, y: null };
+    }
+    const bounds = this.getTargetBoundsScene(target);
+    const matches = this.computeMoveSnapMatches(bounds, frame);
+    const deltaScreenX = this.canvasService.toScreenLength(
+      (_b = (_a = matches.x) == null ? void 0 : _a.deltaScene) != null ? _b : 0
+    );
+    const deltaScreenY = this.canvasService.toScreenLength(
+      (_d = (_c = matches.y) == null ? void 0 : _c.deltaScene) != null ? _d : 0
+    );
+    if (deltaScreenX || deltaScreenY) {
+      target.set({
+        left: Number(target.left || 0) + deltaScreenX,
+        top: Number(target.top || 0) + deltaScreenY
+      });
+      target.setCoords();
+    }
+    return matches;
+  }
+  handleCanvasBeforeRender() {
     if (!this.canvasService) return;
-    const canvas = this.canvasService.canvas;
-    const current = axis === "x" ? this.snapGuideXObject : this.snapGuideYObject;
-    if (!current) return;
-    canvas.remove(current);
-    if (axis === "x") {
-      this.snapGuideXObject = void 0;
+    if (!this.hasRenderedSnapGuides && !this.activeSnapX && !this.activeSnapY) {
       return;
     }
-    this.snapGuideYObject = void 0;
+    this.canvasService.canvas.clearContext(
+      this.canvasService.canvas.contextTop
+    );
+    this.hasRenderedSnapGuides = false;
   }
-  createOrUpdateSnapGuideObject(axis, pathData) {
+  drawSnapGuideLine(from, to) {
     if (!this.canvasService) return;
-    const canvas = this.canvasService.canvas;
+    const ctx = this.canvasService.canvas.contextTop;
+    if (!ctx) return;
     const color = this.getConfig("image.control.borderColor", "#1677ff") || "#1677ff";
-    const strokeWidth = 1;
-    this.removeSnapGuideObject(axis);
-    const created = new FabricPath(pathData, {
-      originX: "left",
-      originY: "top",
-      fill: "rgba(0,0,0,0)",
-      stroke: color,
-      strokeWidth,
-      selectable: false,
-      evented: false,
-      excludeFromExport: true,
-      objectCaching: false,
-      data: {
-        id: `${IMAGE_SNAP_GUIDE_LAYER_ID}.${axis}`,
-        layerId: IMAGE_SNAP_GUIDE_LAYER_ID,
-        type: "image-snap-guide"
-      }
-    });
-    created.setCoords();
-    canvas.add(created);
-    canvas.bringObjectToFront(created);
-    if (axis === "x") {
-      this.snapGuideXObject = created;
-      return;
-    }
-    this.snapGuideYObject = created;
+    ctx.save();
+    ctx.strokeStyle = color;
+    ctx.lineWidth = 1;
+    ctx.beginPath();
+    ctx.moveTo(from.x, from.y);
+    ctx.lineTo(to.x, to.y);
+    ctx.stroke();
+    ctx.restore();
   }
-  updateSnapGuideVisuals() {
+  handleCanvasAfterRender() {
     if (!this.canvasService || !this.isImageEditingVisible()) {
-      this.removeSnapGuideObject("x");
-      this.removeSnapGuideObject("y");
       return;
     }
     const frame = this.getFrameRect();
     if (frame.width <= 0 || frame.height <= 0) {
-      this.removeSnapGuideObject("x");
-      this.removeSnapGuideObject("y");
       return;
     }
     const frameScreen = this.getFrameRectScreen(frame);
+    let drew = false;
     if (this.activeSnapX) {
       const x = this.canvasService.toScreenPoint({
         x: this.activeSnapX.lineScene,
         y: frame.top
       }).x;
-      this.createOrUpdateSnapGuideObject(
-        "x",
-        `M ${x} ${frameScreen.top} L ${x} ${frameScreen.top + frameScreen.height}`
+      this.drawSnapGuideLine(
+        { x, y: frameScreen.top },
+        { x, y: frameScreen.top + frameScreen.height }
       );
-    } else {
-      this.removeSnapGuideObject("x");
+      drew = true;
     }
     if (this.activeSnapY) {
       const y = this.canvasService.toScreenPoint({
         x: frame.left,
         y: this.activeSnapY.lineScene
       }).y;
-      this.createOrUpdateSnapGuideObject(
-        "y",
-        `M ${frameScreen.left} ${y} L ${frameScreen.left + frameScreen.width} ${y}`
+      this.drawSnapGuideLine(
+        { x: frameScreen.left, y },
+        { x: frameScreen.left + frameScreen.width, y }
       );
-    } else {
-      this.removeSnapGuideObject("y");
+      drew = true;
     }
-    this.canvasService.requestRenderAll();
+    this.hasRenderedSnapGuides = drew;
   }
   handleCanvasObjectMoving(e) {
-    var _a, _b, _c, _d;
+    var _a;
     const target = this.getActiveImageTarget(e == null ? void 0 : e.target);
     if (!target || !this.canvasService) return;
+    this.movingImageId = typeof ((_a = target == null ? void 0 : target.data) == null ? void 0 : _a.id) === "string" ? target.data.id : null;
     const frame = this.getFrameRect();
     if (frame.width <= 0 || frame.height <= 0) {
-      this.clearSnapGuides();
+      this.endMoveSnapInteraction();
       return;
     }
-    const matches = this.computeMoveSnapMatches(target, frame);
-    const deltaX = (_b = (_a = matches.x) == null ? void 0 : _a.deltaScene) != null ? _b : 0;
-    const deltaY = (_d = (_c = matches.y) == null ? void 0 : _c.deltaScene) != null ? _d : 0;
-    if (deltaX || deltaY) {
-      target.set({
-        left: Number(target.left || 0) + this.canvasService.toScreenLength(deltaX),
-        top: Number(target.top || 0) + this.canvasService.toScreenLength(deltaY)
-      });
-      target.setCoords();
-    }
+    const rawBounds = this.getTargetBoundsScene(target);
+    const matches = this.computeMoveSnapMatches(rawBounds, frame);
     this.updateSnapMatchState(matches.x, matches.y);
   }
-  applySnapMatchesToTarget(target, matches) {
-    var _a, _b, _c, _d;
-    if (!this.canvasService || !target) return;
-    const deltaX = (_b = (_a = matches.x) == null ? void 0 : _a.deltaScene) != null ? _b : 0;
-    const deltaY = (_d = (_c = matches.y) == null ? void 0 : _c.deltaScene) != null ? _d : 0;
-    if (!deltaX && !deltaY) return;
-    target.set({
-      left: Number(target.left || 0) + this.canvasService.toScreenLength(deltaX),
-      top: Number(target.top || 0) + this.canvasService.toScreenLength(deltaY)
-    });
-    target.setCoords();
-  }
   syncToolActiveFromWorkbench(fallbackId) {
     var _a;
     const wb = (_a = this.context) == null ? void 0 : _a.services.get("WorkbenchService");
@@ -3166,33 +3346,9 @@ var ImageTool = class {
             originY: "top",
             fill: hatchFill,
             opacity: patternFill ? 1 : 0.8,
-            stroke: null,
-            fillRule: "evenodd",
-            selectable: false,
-            evented: false,
-            excludeFromExport: true,
-            objectCaching: false
-          }
-        },
-        {
-          id: "image.cropShapePath",
-          type: "path",
-          data: { id: "image.cropShapePath", zIndex: 6 },
-          layout: {
-            reference: "custom",
-            referenceRect: frameRect,
-            alignX: "start",
-            alignY: "start",
-            offsetX: shapeBounds.x,
-            offsetY: shapeBounds.y
-          },
-          props: {
-            pathData: shapePathData,
-            originX: "left",
-            originY: "top",
-            fill: "rgba(0,0,0,0)",
             stroke: "rgba(255, 0, 0, 0.9)",
             strokeWidth: (_b = (_a = this.canvasService) == null ? void 0 : _a.toSceneLength(1)) != null ? _b : 1,
+            fillRule: "evenodd",
             selectable: false,
             evented: false,
             excludeFromExport: true,
@@ -3529,7 +3685,6 @@ var ImageTool = class {
       isImageSelectionActive: this.isImageSelectionActive,
       focusedImageId: this.focusedImageId
     });
-    this.updateSnapGuideVisuals();
     this.canvasService.requestRenderAll();
   }
   clampNormalized(value) {
@@ -4330,225 +4485,668 @@ function createDielineConfigurations(state) {
   ];
 }
 
-// src/extensions/dieline/DielineTool.ts
-var DielineTool = class {
-  constructor(options) {
-    this.id = "pooder.kit.dieline";
-    this.metadata = {
-      name: "DielineTool"
-    };
-    this.state = {
-      shape: DEFAULT_DIELINE_SHAPE,
-      shapeStyle: { ...DEFAULT_DIELINE_SHAPE_STYLE },
-      width: 500,
-      height: 500,
-      radius: 0,
-      offset: 0,
-      padding: 140,
-      mainLine: {
-        width: 2.7,
-        color: "#FF0000",
-        dashLength: 5,
-        style: "solid"
-      },
-      offsetLine: {
-        width: 2.7,
-        color: "#FF0000",
-        dashLength: 5,
-        style: "solid"
-      },
-      insideColor: "rgba(0,0,0,0)",
-      showBleedLines: true,
-      features: []
-    };
-    this.specs = [];
-    this.effects = [];
-    this.renderSeq = 0;
-    this.onCanvasResized = () => {
-      this.updateDieline();
-    };
-    if (options) {
-      if (options.mainLine) {
-        Object.assign(this.state.mainLine, options.mainLine);
-        delete options.mainLine;
-      }
-      if (options.offsetLine) {
-        Object.assign(this.state.offsetLine, options.offsetLine);
-        delete options.offsetLine;
-      }
-      if (options.shapeStyle) {
-        this.state.shapeStyle = normalizeShapeStyle(
-          options.shapeStyle,
-          this.state.shapeStyle
-        );
-        delete options.shapeStyle;
-      }
-      Object.assign(this.state, options);
-      this.state.shape = normalizeDielineShape(options.shape, this.state.shape);
+// src/extensions/dieline/model.ts
+function createDefaultDielineState() {
+  return {
+    shape: DEFAULT_DIELINE_SHAPE,
+    shapeStyle: { ...DEFAULT_DIELINE_SHAPE_STYLE },
+    width: 500,
+    height: 500,
+    radius: 0,
+    offset: 0,
+    padding: 140,
+    mainLine: {
+      width: 2.7,
+      color: "#FF0000",
+      dashLength: 5,
+      style: "solid"
+    },
+    offsetLine: {
+      width: 2.7,
+      color: "#FF0000",
+      dashLength: 5,
+      style: "solid"
+    },
+    insideColor: "rgba(0,0,0,0)",
+    showBleedLines: true,
+    features: []
+  };
+}
+function readDielineState(configService, fallback) {
+  const base = createDefaultDielineState();
+  if (fallback) {
+    Object.assign(base, fallback);
+    if (fallback.mainLine) {
+      base.mainLine = { ...base.mainLine, ...fallback.mainLine };
     }
-  }
-  activate(context) {
-    var _a;
-    this.context = context;
-    this.canvasService = context.services.get("CanvasService");
-    if (!this.canvasService) {
-      console.warn("CanvasService not found for DielineTool");
-      return;
+    if (fallback.offsetLine) {
+      base.offsetLine = { ...base.offsetLine, ...fallback.offsetLine };
     }
-    (_a = this.renderProducerDisposable) == null ? void 0 : _a.dispose();
-    this.renderProducerDisposable = this.canvasService.registerRenderProducer(
-      this.id,
-      () => ({
-        passes: [
-          {
-            id: DIELINE_LAYER_ID,
-            stack: 700,
-            order: 0,
-            replace: true,
-            visibility: {
-              op: "not",
-              expr: {
-                op: "activeToolIn",
-                ids: ["pooder.kit.image", "pooder.kit.white-ink"]
-              }
-            },
-            effects: this.effects,
-            objects: this.specs
-          }
-        ]
-      }),
-      { priority: 250 }
-    );
-    const configService = context.services.get(
-      "ConfigurationService"
-    );
-    if (configService) {
-      const s = this.state;
-      const sizeState = readSizeState(configService);
-      s.shape = normalizeDielineShape(
-        configService.get("dieline.shape", s.shape),
-        s.shape
-      );
-      s.shapeStyle = normalizeShapeStyle(
-        configService.get("dieline.shapeStyle", s.shapeStyle),
-        s.shapeStyle
-      );
-      s.width = sizeState.actualWidthMm;
-      s.height = sizeState.actualHeightMm;
-      s.radius = parseLengthToMm(
-        configService.get("dieline.radius", s.radius),
-        "mm"
-      );
-      s.padding = sizeState.viewPadding;
-      s.offset = sizeState.cutMode === "outset" ? sizeState.cutMarginMm : sizeState.cutMode === "inset" ? -sizeState.cutMarginMm : 0;
-      s.mainLine.width = configService.get(
-        "dieline.strokeWidth",
-        s.mainLine.width
-      );
-      s.mainLine.color = configService.get(
-        "dieline.strokeColor",
-        s.mainLine.color
-      );
-      s.mainLine.dashLength = configService.get(
+    if (fallback.shapeStyle) {
+      base.shapeStyle = normalizeShapeStyle(fallback.shapeStyle, base.shapeStyle);
+    }
+  }
+  const sizeState = readSizeState(configService);
+  const sourceWidth = Number(configService.get("dieline.customSourceWidthPx", 0));
+  const sourceHeight = Number(
+    configService.get("dieline.customSourceHeightPx", 0)
+  );
+  return {
+    ...base,
+    shape: normalizeDielineShape(
+      configService.get("dieline.shape", base.shape),
+      base.shape
+    ),
+    shapeStyle: normalizeShapeStyle(
+      configService.get("dieline.shapeStyle", base.shapeStyle),
+      base.shapeStyle
+    ),
+    width: sizeState.actualWidthMm,
+    height: sizeState.actualHeightMm,
+    radius: parseLengthToMm(configService.get("dieline.radius", base.radius), "mm"),
+    padding: sizeState.viewPadding,
+    offset: sizeState.cutMode === "outset" ? sizeState.cutMarginMm : sizeState.cutMode === "inset" ? -sizeState.cutMarginMm : 0,
+    mainLine: {
+      width: configService.get("dieline.strokeWidth", base.mainLine.width),
+      color: configService.get("dieline.strokeColor", base.mainLine.color),
+      dashLength: configService.get(
         "dieline.dashLength",
-        s.mainLine.dashLength
-      );
-      s.mainLine.style = configService.get("dieline.style", s.mainLine.style);
-      s.offsetLine.width = configService.get(
+        base.mainLine.dashLength
+      ),
+      style: configService.get("dieline.style", base.mainLine.style)
+    },
+    offsetLine: {
+      width: configService.get(
         "dieline.offsetStrokeWidth",
-        s.offsetLine.width
-      );
-      s.offsetLine.color = configService.get(
+        base.offsetLine.width
+      ),
+      color: configService.get(
         "dieline.offsetStrokeColor",
-        s.offsetLine.color
-      );
-      s.offsetLine.dashLength = configService.get(
+        base.offsetLine.color
+      ),
+      dashLength: configService.get(
         "dieline.offsetDashLength",
-        s.offsetLine.dashLength
-      );
-      s.offsetLine.style = configService.get(
-        "dieline.offsetStyle",
-        s.offsetLine.style
-      );
-      s.insideColor = configService.get("dieline.insideColor", s.insideColor);
-      s.showBleedLines = configService.get(
-        "dieline.showBleedLines",
-        s.showBleedLines
-      );
-      s.features = configService.get("dieline.features", s.features);
-      s.pathData = configService.get("dieline.pathData", s.pathData);
-      const sourceWidth = Number(
-        configService.get("dieline.customSourceWidthPx", 0)
-      );
-      const sourceHeight = Number(
-        configService.get("dieline.customSourceHeightPx", 0)
-      );
-      s.customSourceWidthPx = Number.isFinite(sourceWidth) && sourceWidth > 0 ? sourceWidth : void 0;
-      s.customSourceHeightPx = Number.isFinite(sourceHeight) && sourceHeight > 0 ? sourceHeight : void 0;
-      configService.onAnyChange((e) => {
-        if (e.key.startsWith("size.")) {
-          const nextSize = readSizeState(configService);
-          s.width = nextSize.actualWidthMm;
-          s.height = nextSize.actualHeightMm;
-          s.padding = nextSize.viewPadding;
-          s.offset = nextSize.cutMode === "outset" ? nextSize.cutMarginMm : nextSize.cutMode === "inset" ? -nextSize.cutMarginMm : 0;
-          this.updateDieline();
-          return;
+        base.offsetLine.dashLength
+      ),
+      style: configService.get("dieline.offsetStyle", base.offsetLine.style)
+    },
+    insideColor: configService.get("dieline.insideColor", base.insideColor),
+    showBleedLines: configService.get(
+      "dieline.showBleedLines",
+      base.showBleedLines
+    ),
+    features: configService.get("dieline.features", base.features),
+    pathData: configService.get("dieline.pathData", base.pathData),
+    customSourceWidthPx: Number.isFinite(sourceWidth) && sourceWidth > 0 ? sourceWidth : void 0,
+    customSourceHeightPx: Number.isFinite(sourceHeight) && sourceHeight > 0 ? sourceHeight : void 0
+  };
+}
+
+// src/extensions/constraints.ts
+var ConstraintRegistry = class {
+  static register(type, handler) {
+    this.handlers.set(type, handler);
+  }
+  static apply(x, y, feature, context, constraints) {
+    const list = constraints || feature.constraints;
+    if (!list || list.length === 0) {
+      return { x, y };
+    }
+    let currentX = x;
+    let currentY = y;
+    for (const constraint of list) {
+      const handler = this.handlers.get(constraint.type);
+      if (handler) {
+        const result = handler(currentX, currentY, feature, context, constraint.params || {});
+        currentX = result.x;
+        currentY = result.y;
+      }
+    }
+    return { x: currentX, y: currentY };
+  }
+};
+ConstraintRegistry.handlers = /* @__PURE__ */ new Map();
+var pathConstraint = (x, y, feature, context, params) => {
+  const { dielineWidth, dielineHeight, geometry } = context;
+  if (!geometry) return { x, y };
+  const minX = geometry.x - geometry.width / 2;
+  const minY = geometry.y - geometry.height / 2;
+  const absX = minX + x * geometry.width;
+  const absY = minY + y * geometry.height;
+  const nearest = getNearestPointOnDieline(
+    { x: absX, y: absY },
+    geometry
+  );
+  let finalX = nearest.x;
+  let finalY = nearest.y;
+  const hasOffsetParams = params.minOffset !== void 0 || params.maxOffset !== void 0;
+  if (hasOffsetParams && nearest.normal) {
+    const dx = absX - nearest.x;
+    const dy = absY - nearest.y;
+    const nx2 = nearest.normal.x;
+    const ny2 = nearest.normal.y;
+    const dist = dx * nx2 + dy * ny2;
+    const scale = dielineWidth > 0 ? geometry.width / dielineWidth : 1;
+    const rawMin = params.minOffset !== void 0 ? params.minOffset : 0;
+    const rawMax = params.maxOffset !== void 0 ? params.maxOffset : 0;
+    const minOffset = rawMin * scale;
+    const maxOffset = rawMax * scale;
+    const clampedDist = Math.max(minOffset, Math.min(dist, maxOffset));
+    finalX = nearest.x + nx2 * clampedDist;
+    finalY = nearest.y + ny2 * clampedDist;
+  }
+  const nx = geometry.width > 0 ? (finalX - minX) / geometry.width : 0.5;
+  const ny = geometry.height > 0 ? (finalY - minY) / geometry.height : 0.5;
+  return { x: nx, y: ny };
+};
+var edgeConstraint = (x, y, feature, context, params) => {
+  const { dielineWidth, dielineHeight } = context;
+  const allowedEdges = params.allowedEdges || [
+    "top",
+    "bottom",
+    "left",
+    "right"
+  ];
+  const confine = params.confine || false;
+  const offset = params.offset || 0;
+  const distances = [];
+  if (allowedEdges.includes("top"))
+    distances.push({ edge: "top", dist: y * dielineHeight });
+  if (allowedEdges.includes("bottom"))
+    distances.push({ edge: "bottom", dist: (1 - y) * dielineHeight });
+  if (allowedEdges.includes("left"))
+    distances.push({ edge: "left", dist: x * dielineWidth });
+  if (allowedEdges.includes("right"))
+    distances.push({ edge: "right", dist: (1 - x) * dielineWidth });
+  if (distances.length === 0) return { x, y };
+  distances.sort((a, b) => a.dist - b.dist);
+  const nearest = distances[0].edge;
+  let newX = x;
+  let newY = y;
+  const fw = feature.width || 0;
+  const fh = feature.height || 0;
+  switch (nearest) {
+    case "top":
+      newY = 0 + offset / dielineHeight;
+      if (confine) {
+        const minX = fw / 2 / dielineWidth;
+        const maxX = 1 - minX;
+        newX = Math.max(minX, Math.min(newX, maxX));
+      }
+      break;
+    case "bottom":
+      newY = 1 - offset / dielineHeight;
+      if (confine) {
+        const minX = fw / 2 / dielineWidth;
+        const maxX = 1 - minX;
+        newX = Math.max(minX, Math.min(newX, maxX));
+      }
+      break;
+    case "left":
+      newX = 0 + offset / dielineWidth;
+      if (confine) {
+        const minY = fh / 2 / dielineHeight;
+        const maxY = 1 - minY;
+        newY = Math.max(minY, Math.min(newY, maxY));
+      }
+      break;
+    case "right":
+      newX = 1 - offset / dielineWidth;
+      if (confine) {
+        const minY = fh / 2 / dielineHeight;
+        const maxY = 1 - minY;
+        newY = Math.max(minY, Math.min(newY, maxY));
+      }
+      break;
+  }
+  return { x: newX, y: newY };
+};
+var internalConstraint = (x, y, feature, context, params) => {
+  const { dielineWidth, dielineHeight } = context;
+  const margin = params.margin || 0;
+  const fw = feature.width || 0;
+  const fh = feature.height || 0;
+  const minX = (margin + fw / 2) / dielineWidth;
+  const maxX = 1 - (margin + fw / 2) / dielineWidth;
+  const minY = (margin + fh / 2) / dielineHeight;
+  const maxY = 1 - (margin + fh / 2) / dielineHeight;
+  const clampedX = minX > maxX ? 0.5 : Math.max(minX, Math.min(x, maxX));
+  const clampedY = minY > maxY ? 0.5 : Math.max(minY, Math.min(y, maxY));
+  return { x: clampedX, y: clampedY };
+};
+var tangentBottomConstraint = (x, y, feature, context, params) => {
+  const { dielineWidth, dielineHeight } = context;
+  const gap = params.gap || 0;
+  const confineX = params.confineX !== false;
+  const extentY = feature.shape === "circle" ? feature.radius || 0 : (feature.height || 0) / 2;
+  const newY = 1 + (extentY + gap) / dielineHeight;
+  let newX = x;
+  if (confineX) {
+    const extentX = feature.shape === "circle" ? feature.radius || 0 : (feature.width || 0) / 2;
+    const minX = extentX / dielineWidth;
+    const maxX = 1 - extentX / dielineWidth;
+    newX = minX > maxX ? 0.5 : Math.max(minX, Math.min(newX, maxX));
+  }
+  return { x: newX, y: newY };
+};
+var lowestTangentConstraint = (x, y, feature, context, params) => {
+  const { dielineWidth, dielineHeight, geometry } = context;
+  if (!geometry) return { x, y };
+  const lowest = getLowestPointOnDieline(geometry);
+  const minY = geometry.y - geometry.height / 2;
+  const normY = (lowest.y - minY) / geometry.height;
+  const gap = params.gap || 0;
+  const confineX = params.confineX !== false;
+  const extentY = feature.shape === "circle" ? feature.radius || 0 : (feature.height || 0) / 2;
+  const newY = normY + (extentY + gap) / dielineHeight;
+  let newX = x;
+  if (confineX) {
+    const extentX = feature.shape === "circle" ? feature.radius || 0 : (feature.width || 0) / 2;
+    const minX = extentX / dielineWidth;
+    const maxX = 1 - extentX / dielineWidth;
+    newX = minX > maxX ? 0.5 : Math.max(minX, Math.min(newX, maxX));
+  }
+  return { x: newX, y: newY };
+};
+ConstraintRegistry.register("path", pathConstraint);
+ConstraintRegistry.register("edge", edgeConstraint);
+ConstraintRegistry.register("internal", internalConstraint);
+ConstraintRegistry.register("tangent-bottom", tangentBottomConstraint);
+ConstraintRegistry.register("lowest-tangent", lowestTangentConstraint);
+
+// src/extensions/featureCoordinates.ts
+function resolveFeaturePosition2(feature, geometry) {
+  const { x, y, width, height } = geometry;
+  const left = x - width / 2;
+  const top = y - height / 2;
+  return {
+    x: left + feature.x * width,
+    y: top + feature.y * height
+  };
+}
+function normalizePointInGeometry(point, geometry) {
+  const left = geometry.x - geometry.width / 2;
+  const top = geometry.y - geometry.height / 2;
+  return {
+    x: geometry.width > 0 ? (point.x - left) / geometry.width : 0.5,
+    y: geometry.height > 0 ? (point.y - top) / geometry.height : 0.5
+  };
+}
+
+// src/extensions/featurePlacement.ts
+function scaleFeatureForRender(feature, scale, x, y) {
+  return {
+    ...feature,
+    x,
+    y,
+    width: feature.width !== void 0 ? feature.width * scale : void 0,
+    height: feature.height !== void 0 ? feature.height * scale : void 0,
+    radius: feature.radius !== void 0 ? feature.radius * scale : void 0
+  };
+}
+function resolveFeaturePlacements(features, geometry) {
+  const dielineWidth = geometry.scale > 0 ? geometry.width / geometry.scale : geometry.width;
+  const dielineHeight = geometry.scale > 0 ? geometry.height / geometry.scale : geometry.height;
+  return (features || []).map((feature) => {
+    var _a;
+    const activeConstraints = (_a = feature.constraints) == null ? void 0 : _a.filter(
+      (constraint) => !constraint.validateOnly
+    );
+    const constrained = ConstraintRegistry.apply(
+      feature.x,
+      feature.y,
+      feature,
+      {
+        dielineWidth,
+        dielineHeight,
+        geometry
+      },
+      activeConstraints
+    );
+    const center = resolveFeaturePosition2(
+      {
+        ...feature,
+        x: constrained.x,
+        y: constrained.y
+      },
+      geometry
+    );
+    return {
+      feature,
+      normalizedX: constrained.x,
+      normalizedY: constrained.y,
+      centerX: center.x,
+      centerY: center.y
+    };
+  });
+}
+function projectPlacedFeatures(placements, geometry, scale) {
+  return placements.map((placement) => {
+    const normalized = normalizePointInGeometry(
+      { x: placement.centerX, y: placement.centerY },
+      geometry
+    );
+    return scaleFeatureForRender(
+      placement.feature,
+      scale,
+      normalized.x,
+      normalized.y
+    );
+  });
+}
+
+// src/extensions/dieline/renderBuilder.ts
+var DEFAULT_IDS = {
+  inside: "dieline.inside",
+  bleedZone: "dieline.bleed-zone",
+  offsetBorder: "dieline.offset-border",
+  border: "dieline.border",
+  clip: "dieline.clip.image",
+  clipSource: "dieline.effect.clip-path"
+};
+function buildDielineRenderBundle(options) {
+  const ids = { ...DEFAULT_IDS, ...options.ids || {} };
+  const {
+    state,
+    sceneLayout,
+    canvasWidth,
+    canvasHeight,
+    hasImages,
+    createHatchPattern,
+    includeImageClipEffect = true,
+    clipTargetPassIds = [IMAGE_OBJECT_LAYER_ID],
+    clipVisibility
+  } = options;
+  const { shape, shapeStyle, radius, mainLine, offsetLine, insideColor } = state;
+  const scale = sceneLayout.scale;
+  const cx = sceneLayout.trimRect.centerX;
+  const cy = sceneLayout.trimRect.centerY;
+  const visualWidth = sceneLayout.trimRect.width;
+  const visualHeight = sceneLayout.trimRect.height;
+  const visualRadius = radius * scale;
+  const cutW = sceneLayout.cutRect.width;
+  const cutH = sceneLayout.cutRect.height;
+  const visualOffset = (cutW - visualWidth) / 2;
+  const cutR = visualRadius === 0 ? 0 : Math.max(0, visualRadius + visualOffset);
+  const placements = resolveFeaturePlacements(state.features || [], {
+    shape,
+    shapeStyle,
+    pathData: state.pathData,
+    customSourceWidthPx: state.customSourceWidthPx,
+    customSourceHeightPx: state.customSourceHeightPx,
+    canvasWidth,
+    canvasHeight,
+    x: cx,
+    y: cy,
+    width: visualWidth,
+    height: visualHeight,
+    radius: visualRadius,
+    scale
+  });
+  const absoluteFeatures = projectPlacedFeatures(
+    placements,
+    {
+      x: cx,
+      y: cy,
+      width: visualWidth,
+      height: visualHeight
+    },
+    scale
+  );
+  const cutFeatures = projectPlacedFeatures(
+    placements.filter((placement) => !placement.feature.skipCut),
+    {
+      x: cx,
+      y: cy,
+      width: cutW,
+      height: cutH
+    },
+    scale
+  );
+  const common = {
+    shape,
+    shapeStyle,
+    pathData: state.pathData,
+    customSourceWidthPx: state.customSourceWidthPx,
+    customSourceHeightPx: state.customSourceHeightPx,
+    canvasWidth,
+    canvasHeight
+  };
+  const specs = [];
+  if (insideColor && insideColor !== "transparent" && insideColor !== "rgba(0,0,0,0)" && !hasImages) {
+    specs.push({
+      id: ids.inside,
+      type: "path",
+      space: "screen",
+      data: { id: ids.inside, type: "dieline" },
+      props: {
+        pathData: generateDielinePath({
+          ...common,
+          width: cutW,
+          height: cutH,
+          radius: cutR,
+          x: cx,
+          y: cy,
+          features: cutFeatures
+        }),
+        fill: insideColor,
+        stroke: null,
+        selectable: false,
+        evented: false,
+        originX: "left",
+        originY: "top"
+      }
+    });
+  }
+  if (Math.abs(visualOffset) > 1e-4) {
+    const trimPathInput = {
+      ...common,
+      width: visualWidth,
+      height: visualHeight,
+      radius: visualRadius,
+      x: cx,
+      y: cy,
+      features: cutFeatures
+    };
+    const cutPathInput = {
+      ...common,
+      width: cutW,
+      height: cutH,
+      radius: cutR,
+      x: cx,
+      y: cy,
+      features: cutFeatures
+    };
+    if (state.showBleedLines !== false) {
+      const pattern = createHatchPattern == null ? void 0 : createHatchPattern(mainLine.color);
+      if (pattern) {
+        specs.push({
+          id: ids.bleedZone,
+          type: "path",
+          space: "screen",
+          data: { id: ids.bleedZone, type: "dieline" },
+          props: {
+            pathData: generateBleedZonePath(
+              trimPathInput,
+              cutPathInput,
+              visualOffset
+            ),
+            fill: pattern,
+            stroke: null,
+            selectable: false,
+            evented: false,
+            objectCaching: false,
+            originX: "left",
+            originY: "top"
+          }
+        });
+      }
+    }
+    specs.push({
+      id: ids.offsetBorder,
+      type: "path",
+      space: "screen",
+      data: { id: ids.offsetBorder, type: "dieline" },
+      props: {
+        pathData: generateDielinePath(cutPathInput),
+        fill: null,
+        stroke: offsetLine.style === "hidden" ? null : offsetLine.color,
+        strokeWidth: offsetLine.width,
+        strokeDashArray: offsetLine.style === "dashed" ? [offsetLine.dashLength, offsetLine.dashLength] : void 0,
+        selectable: false,
+        evented: false,
+        originX: "left",
+        originY: "top"
+      }
+    });
+  }
+  specs.push({
+    id: ids.border,
+    type: "path",
+    space: "screen",
+    data: { id: ids.border, type: "dieline" },
+    props: {
+      pathData: generateDielinePath({
+        ...common,
+        width: visualWidth,
+        height: visualHeight,
+        radius: visualRadius,
+        x: cx,
+        y: cy,
+        features: absoluteFeatures
+      }),
+      fill: "transparent",
+      stroke: mainLine.style === "hidden" ? null : mainLine.color,
+      strokeWidth: mainLine.width,
+      strokeDashArray: mainLine.style === "dashed" ? [mainLine.dashLength, mainLine.dashLength] : void 0,
+      selectable: false,
+      evented: false,
+      originX: "left",
+      originY: "top"
+    }
+  });
+  if (!includeImageClipEffect) {
+    return { specs, effects: [] };
+  }
+  const clipPathData = generateDielinePath({
+    ...common,
+    width: cutW,
+    height: cutH,
+    radius: cutR,
+    x: cx,
+    y: cy,
+    features: cutFeatures
+  });
+  if (!clipPathData) {
+    return { specs, effects: [] };
+  }
+  return {
+    specs,
+    effects: [
+      {
+        type: "clipPath",
+        id: ids.clip,
+        visibility: clipVisibility,
+        targetPassIds: clipTargetPassIds,
+        source: {
+          id: ids.clipSource,
+          type: "path",
+          space: "screen",
+          data: {
+            id: ids.clipSource,
+            type: "dieline-effect",
+            effect: "clipPath"
+          },
+          props: {
+            pathData: clipPathData,
+            fill: "#000000",
+            stroke: null,
+            originX: "left",
+            originY: "top",
+            selectable: false,
+            evented: false,
+            excludeFromExport: true
+          }
         }
-        if (e.key.startsWith("dieline.")) {
-          switch (e.key) {
-            case "dieline.shape":
-              s.shape = normalizeDielineShape(e.value, s.shape);
-              break;
-            case "dieline.shapeStyle":
-              s.shapeStyle = normalizeShapeStyle(e.value, s.shapeStyle);
-              break;
-            case "dieline.radius":
-              s.radius = parseLengthToMm(e.value, "mm");
-              break;
-            case "dieline.strokeWidth":
-              s.mainLine.width = e.value;
-              break;
-            case "dieline.strokeColor":
-              s.mainLine.color = e.value;
-              break;
-            case "dieline.dashLength":
-              s.mainLine.dashLength = e.value;
-              break;
-            case "dieline.style":
-              s.mainLine.style = e.value;
-              break;
-            case "dieline.offsetStrokeWidth":
-              s.offsetLine.width = e.value;
-              break;
-            case "dieline.offsetStrokeColor":
-              s.offsetLine.color = e.value;
-              break;
-            case "dieline.offsetDashLength":
-              s.offsetLine.dashLength = e.value;
-              break;
-            case "dieline.offsetStyle":
-              s.offsetLine.style = e.value;
-              break;
-            case "dieline.insideColor":
-              s.insideColor = e.value;
-              break;
-            case "dieline.showBleedLines":
-              s.showBleedLines = e.value;
-              break;
-            case "dieline.features":
-              s.features = e.value;
-              break;
-            case "dieline.pathData":
-              s.pathData = e.value;
-              break;
-            case "dieline.customSourceWidthPx":
-              s.customSourceWidthPx = Number.isFinite(Number(e.value)) && Number(e.value) > 0 ? Number(e.value) : void 0;
-              break;
-            case "dieline.customSourceHeightPx":
-              s.customSourceHeightPx = Number.isFinite(Number(e.value)) && Number(e.value) > 0 ? Number(e.value) : void 0;
-              break;
+      }
+    ]
+  };
+}
+
+// src/extensions/dieline/DielineTool.ts
+var DielineTool = class {
+  constructor(options) {
+    this.id = "pooder.kit.dieline";
+    this.metadata = {
+      name: "DielineTool"
+    };
+    this.state = createDefaultDielineState();
+    this.specs = [];
+    this.effects = [];
+    this.renderSeq = 0;
+    this.onCanvasResized = () => {
+      this.updateDieline();
+    };
+    if (options) {
+      if (options.mainLine) {
+        Object.assign(this.state.mainLine, options.mainLine);
+        delete options.mainLine;
+      }
+      if (options.offsetLine) {
+        Object.assign(this.state.offsetLine, options.offsetLine);
+        delete options.offsetLine;
+      }
+      if (options.shapeStyle) {
+        this.state.shapeStyle = normalizeShapeStyle(
+          options.shapeStyle,
+          this.state.shapeStyle
+        );
+        delete options.shapeStyle;
+      }
+      Object.assign(this.state, options);
+      this.state.shape = normalizeDielineShape(options.shape, this.state.shape);
+    }
+  }
+  activate(context) {
+    var _a;
+    this.context = context;
+    this.canvasService = context.services.get("CanvasService");
+    if (!this.canvasService) {
+      console.warn("CanvasService not found for DielineTool");
+      return;
+    }
+    (_a = this.renderProducerDisposable) == null ? void 0 : _a.dispose();
+    this.renderProducerDisposable = this.canvasService.registerRenderProducer(
+      this.id,
+      () => ({
+        passes: [
+          {
+            id: DIELINE_LAYER_ID,
+            stack: 700,
+            order: 0,
+            replace: true,
+            visibility: {
+              op: "not",
+              expr: {
+                op: "activeToolIn",
+                ids: ["pooder.kit.image", "pooder.kit.white-ink"]
+              }
+            },
+            effects: this.effects,
+            objects: this.specs
           }
+        ]
+      }),
+      { priority: 250 }
+    );
+    const configService = context.services.get(
+      "ConfigurationService"
+    );
+    if (configService) {
+      Object.assign(this.state, readDielineState(configService, this.state));
+      configService.onAnyChange((e) => {
+        if (e.key.startsWith("size.") || e.key.startsWith("dieline.")) {
+          Object.assign(this.state, readDielineState(configService, this.state));
           this.updateDieline();
         }
       });
@@ -4598,293 +5196,55 @@ var DielineTool = class {
     const ctx = canvas.getContext("2d");
     if (ctx) {
       ctx.clearRect(0, 0, size, size);
-      ctx.strokeStyle = color;
-      ctx.lineWidth = 1;
-      ctx.beginPath();
-      ctx.moveTo(0, size);
-      ctx.lineTo(size, 0);
-      ctx.stroke();
-    }
-    return new Pattern2({ source: canvas, repetition: "repeat" });
-  }
-  getConfigService() {
-    var _a;
-    return (_a = this.context) == null ? void 0 : _a.services.get(
-      "ConfigurationService"
-    );
-  }
-  hasImageItems() {
-    const configService = this.getConfigService();
-    if (!configService) return false;
-    const items = configService.get("image.items", []);
-    return Array.isArray(items) && items.length > 0;
-  }
-  syncSizeState(configService) {
-    const sizeState = readSizeState(configService);
-    this.state.width = sizeState.actualWidthMm;
-    this.state.height = sizeState.actualHeightMm;
-    this.state.padding = sizeState.viewPadding;
-    this.state.offset = sizeState.cutMode === "outset" ? sizeState.cutMarginMm : sizeState.cutMode === "inset" ? -sizeState.cutMarginMm : 0;
-  }
-  buildDielineSpecs(sceneLayout) {
-    var _a, _b;
-    const {
-      shape,
-      shapeStyle,
-      radius,
-      mainLine,
-      offsetLine,
-      insideColor,
-      showBleedLines,
-      features
-    } = this.state;
-    const hasImages = this.hasImageItems();
-    const canvasW = sceneLayout.canvasWidth || ((_a = this.canvasService) == null ? void 0 : _a.canvas.width) || 800;
-    const canvasH = sceneLayout.canvasHeight || ((_b = this.canvasService) == null ? void 0 : _b.canvas.height) || 600;
-    const scale = sceneLayout.scale;
-    const cx = sceneLayout.trimRect.centerX;
-    const cy = sceneLayout.trimRect.centerY;
-    const visualWidth = sceneLayout.trimRect.width;
-    const visualHeight = sceneLayout.trimRect.height;
-    const visualRadius = radius * scale;
-    const cutW = sceneLayout.cutRect.width;
-    const cutH = sceneLayout.cutRect.height;
-    const visualOffset = (cutW - visualWidth) / 2;
-    const cutR = visualRadius === 0 ? 0 : Math.max(0, visualRadius + visualOffset);
-    const absoluteFeatures = (features || []).map((f) => ({
-      ...f,
-      x: f.x,
-      y: f.y,
-      width: (f.width || 0) * scale,
-      height: (f.height || 0) * scale,
-      radius: (f.radius || 0) * scale
-    }));
-    const cutFeatures = absoluteFeatures.filter((f) => !f.skipCut);
-    const specs = [];
-    if (insideColor && insideColor !== "transparent" && insideColor !== "rgba(0,0,0,0)" && !hasImages) {
-      const productPathData = generateDielinePath({
-        shape,
-        width: cutW,
-        height: cutH,
-        radius: cutR,
-        x: cx,
-        y: cy,
-        features: cutFeatures,
-        shapeStyle,
-        pathData: this.state.pathData,
-        customSourceWidthPx: this.state.customSourceWidthPx,
-        customSourceHeightPx: this.state.customSourceHeightPx,
-        canvasWidth: canvasW,
-        canvasHeight: canvasH
-      });
-      specs.push({
-        id: "dieline.inside",
-        type: "path",
-        space: "screen",
-        data: { id: "dieline.inside", type: "dieline" },
-        props: {
-          pathData: productPathData,
-          fill: insideColor,
-          stroke: null,
-          selectable: false,
-          evented: false,
-          originX: "left",
-          originY: "top"
-        }
-      });
-    }
-    if (Math.abs(visualOffset) > 1e-4) {
-      const bleedPathData = generateBleedZonePath(
-        {
-          shape,
-          width: visualWidth,
-          height: visualHeight,
-          radius: visualRadius,
-          x: cx,
-          y: cy,
-          features: cutFeatures,
-          shapeStyle,
-          pathData: this.state.pathData,
-          customSourceWidthPx: this.state.customSourceWidthPx,
-          customSourceHeightPx: this.state.customSourceHeightPx,
-          canvasWidth: canvasW,
-          canvasHeight: canvasH
-        },
-        {
-          shape,
-          width: cutW,
-          height: cutH,
-          radius: cutR,
-          x: cx,
-          y: cy,
-          features: cutFeatures,
-          shapeStyle,
-          pathData: this.state.pathData,
-          customSourceWidthPx: this.state.customSourceWidthPx,
-          customSourceHeightPx: this.state.customSourceHeightPx,
-          canvasWidth: canvasW,
-          canvasHeight: canvasH
-        },
-        visualOffset
-      );
-      if (showBleedLines !== false) {
-        const pattern = this.createHatchPattern(mainLine.color);
-        if (pattern) {
-          specs.push({
-            id: "dieline.bleed-zone",
-            type: "path",
-            space: "screen",
-            data: { id: "dieline.bleed-zone", type: "dieline" },
-            props: {
-              pathData: bleedPathData,
-              fill: pattern,
-              stroke: null,
-              selectable: false,
-              evented: false,
-              objectCaching: false,
-              originX: "left",
-              originY: "top"
-            }
-          });
-        }
-      }
-      const offsetPathData = generateDielinePath({
-        shape,
-        width: cutW,
-        height: cutH,
-        radius: cutR,
-        x: cx,
-        y: cy,
-        features: cutFeatures,
-        shapeStyle,
-        pathData: this.state.pathData,
-        customSourceWidthPx: this.state.customSourceWidthPx,
-        customSourceHeightPx: this.state.customSourceHeightPx,
-        canvasWidth: canvasW,
-        canvasHeight: canvasH
-      });
-      specs.push({
-        id: "dieline.offset-border",
-        type: "path",
-        space: "screen",
-        data: { id: "dieline.offset-border", type: "dieline" },
-        props: {
-          pathData: offsetPathData,
-          fill: null,
-          stroke: offsetLine.style === "hidden" ? null : offsetLine.color,
-          strokeWidth: offsetLine.width,
-          strokeDashArray: offsetLine.style === "dashed" ? [offsetLine.dashLength, offsetLine.dashLength] : void 0,
-          selectable: false,
-          evented: false,
-          originX: "left",
-          originY: "top"
-        }
-      });
-    }
-    const borderPathData = generateDielinePath({
-      shape,
-      width: visualWidth,
-      height: visualHeight,
-      radius: visualRadius,
-      x: cx,
-      y: cy,
-      features: absoluteFeatures,
-      shapeStyle,
-      pathData: this.state.pathData,
-      customSourceWidthPx: this.state.customSourceWidthPx,
-      customSourceHeightPx: this.state.customSourceHeightPx,
-      canvasWidth: canvasW,
-      canvasHeight: canvasH
-    });
-    specs.push({
-      id: "dieline.border",
-      type: "path",
-      space: "screen",
-      data: { id: "dieline.border", type: "dieline" },
-      props: {
-        pathData: borderPathData,
-        fill: "transparent",
-        stroke: mainLine.style === "hidden" ? null : mainLine.color,
-        strokeWidth: mainLine.width,
-        strokeDashArray: mainLine.style === "dashed" ? [mainLine.dashLength, mainLine.dashLength] : void 0,
-        selectable: false,
-        evented: false,
-        originX: "left",
-        originY: "top"
-      }
-    });
-    return specs;
-  }
-  buildImageClipEffects(sceneLayout) {
-    var _a, _b;
-    const { shape, shapeStyle, radius, features } = this.state;
-    const canvasW = sceneLayout.canvasWidth || ((_a = this.canvasService) == null ? void 0 : _a.canvas.width) || 800;
-    const canvasH = sceneLayout.canvasHeight || ((_b = this.canvasService) == null ? void 0 : _b.canvas.height) || 600;
-    const scale = sceneLayout.scale;
-    const cx = sceneLayout.trimRect.centerX;
-    const cy = sceneLayout.trimRect.centerY;
-    const visualWidth = sceneLayout.trimRect.width;
-    const visualRadius = radius * scale;
-    const cutW = sceneLayout.cutRect.width;
-    const cutH = sceneLayout.cutRect.height;
-    const visualOffset = (cutW - visualWidth) / 2;
-    const cutR = visualRadius === 0 ? 0 : Math.max(0, visualRadius + visualOffset);
-    const absoluteFeatures = (features || []).map((f) => ({
-      ...f,
-      x: f.x,
-      y: f.y,
-      width: (f.width || 0) * scale,
-      height: (f.height || 0) * scale,
-      radius: (f.radius || 0) * scale
-    }));
-    const cutFeatures = absoluteFeatures.filter((f) => !f.skipCut);
-    const clipPathData = generateDielinePath({
-      shape,
-      width: cutW,
-      height: cutH,
-      radius: cutR,
-      x: cx,
-      y: cy,
-      features: cutFeatures,
-      shapeStyle,
-      pathData: this.state.pathData,
-      customSourceWidthPx: this.state.customSourceWidthPx,
-      customSourceHeightPx: this.state.customSourceHeightPx,
-      canvasWidth: canvasW,
-      canvasHeight: canvasH
-    });
-    if (!clipPathData) return [];
-    return [
-      {
-        type: "clipPath",
-        id: "dieline.clip.image",
-        visibility: {
-          op: "not",
-          expr: { op: "anySessionActive" }
-        },
-        targetPassIds: [IMAGE_OBJECT_LAYER_ID],
-        source: {
-          id: "dieline.effect.clip-path",
-          type: "path",
-          space: "screen",
-          data: {
-            id: "dieline.effect.clip-path",
-            type: "dieline-effect",
-            effect: "clipPath"
-          },
-          props: {
-            pathData: clipPathData,
-            fill: "#000000",
-            stroke: null,
-            originX: "left",
-            originY: "top",
-            selectable: false,
-            evented: false,
-            excludeFromExport: true
-          }
-        }
+      ctx.strokeStyle = color;
+      ctx.lineWidth = 1;
+      ctx.beginPath();
+      ctx.moveTo(0, size);
+      ctx.lineTo(size, 0);
+      ctx.stroke();
+    }
+    return new Pattern2({ source: canvas, repetition: "repeat" });
+  }
+  getConfigService() {
+    var _a;
+    return (_a = this.context) == null ? void 0 : _a.services.get(
+      "ConfigurationService"
+    );
+  }
+  hasImageItems() {
+    const configService = this.getConfigService();
+    if (!configService) return false;
+    const items = configService.get("image.items", []);
+    return Array.isArray(items) && items.length > 0;
+  }
+  buildDielineSpecs(sceneLayout) {
+    var _a, _b;
+    const hasImages = this.hasImageItems();
+    return buildDielineRenderBundle({
+      state: this.state,
+      sceneLayout,
+      canvasWidth: sceneLayout.canvasWidth || ((_a = this.canvasService) == null ? void 0 : _a.canvas.width) || 800,
+      canvasHeight: sceneLayout.canvasHeight || ((_b = this.canvasService) == null ? void 0 : _b.canvas.height) || 600,
+      hasImages,
+      createHatchPattern: (color) => this.createHatchPattern(color),
+      includeImageClipEffect: false
+    }).specs;
+  }
+  buildImageClipEffects(sceneLayout) {
+    var _a, _b;
+    return buildDielineRenderBundle({
+      state: this.state,
+      sceneLayout,
+      canvasWidth: sceneLayout.canvasWidth || ((_a = this.canvasService) == null ? void 0 : _a.canvas.width) || 800,
+      canvasHeight: sceneLayout.canvasHeight || ((_b = this.canvasService) == null ? void 0 : _b.canvas.height) || 600,
+      hasImages: this.hasImageItems(),
+      includeImageClipEffect: true,
+      clipTargetPassIds: [IMAGE_OBJECT_LAYER_ID],
+      clipVisibility: {
+        op: "not",
+        expr: { op: "anySessionActive" }
       }
-    ];
+    }).effects;
   }
   updateDieline(_emitEvent = true) {
     void this.updateDielineAsync();
@@ -4894,7 +5254,7 @@ var DielineTool = class {
     const configService = this.getConfigService();
     if (!configService) return;
     const seq = ++this.renderSeq;
-    this.syncSizeState(configService);
+    Object.assign(this.state, readDielineState(configService, this.state));
     const sceneLayout = computeSceneLayout(
       this.canvasService,
       readSizeState(configService)
@@ -4949,7 +5309,7 @@ var DielineTool = class {
       );
       return null;
     }
-    this.syncSizeState(configService);
+    this.state = readDielineState(configService, this.state);
     const sceneLayout = computeSceneLayout(
       this.canvasService,
       readSizeState(configService)
@@ -4971,15 +5331,31 @@ var DielineTool = class {
     const visualRadius = radius * scale;
     const visualOffset = (cutW - sceneLayout.trimRect.width) / 2;
     const cutR = visualRadius === 0 ? 0 : Math.max(0, visualRadius + visualOffset);
-    const absoluteFeatures = (features || []).map((f) => ({
-      ...f,
-      x: f.x,
-      y: f.y,
-      width: (f.width || 0) * scale,
-      height: (f.height || 0) * scale,
-      radius: (f.radius || 0) * scale
-    }));
-    const cutFeatures = absoluteFeatures.filter((f) => !f.skipCut);
+    const placements = resolveFeaturePlacements(features || [], {
+      shape,
+      shapeStyle,
+      pathData,
+      customSourceWidthPx: this.state.customSourceWidthPx,
+      customSourceHeightPx: this.state.customSourceHeightPx,
+      canvasWidth: canvasW,
+      canvasHeight: canvasH,
+      x: cx,
+      y: cy,
+      width: sceneLayout.trimRect.width,
+      height: sceneLayout.trimRect.height,
+      radius: visualRadius,
+      scale
+    });
+    const cutFeatures = projectPlacedFeatures(
+      placements.filter((placement) => !placement.feature.skipCut),
+      {
+        x: cx,
+        y: cy,
+        width: cutW,
+        height: cutH
+      },
+      scale
+    );
     const generatedPathData = generateDielinePath({
       shape,
       width: cutW,
@@ -4998,283 +5374,112 @@ var DielineTool = class {
     const clipPath = new Path(generatedPathData, {
       originX: "center",
       originY: "center",
-      left: cx,
-      top: cy,
-      absolutePositioned: true
-    });
-    const pathOffsetX = Number((_a = clipPath == null ? void 0 : clipPath.pathOffset) == null ? void 0 : _a.x);
-    const pathOffsetY = Number((_b = clipPath == null ? void 0 : clipPath.pathOffset) == null ? void 0 : _b.y);
-    const centerX = Number.isFinite(pathOffsetX) ? pathOffsetX : cx;
-    const centerY = Number.isFinite(pathOffsetY) ? pathOffsetY : cy;
-    clipPath.set({
-      originX: "center",
-      originY: "center",
-      left: centerX,
-      top: centerY,
-      absolutePositioned: true
-    });
-    clipPath.setCoords();
-    const pathBounds = clipPath.getBoundingRect();
-    if (!Number.isFinite(pathBounds.left) || !Number.isFinite(pathBounds.top) || !Number.isFinite(pathBounds.width) || !Number.isFinite(pathBounds.height) || pathBounds.width <= 0 || pathBounds.height <= 0) {
-      console.warn(
-        "[DielineTool] exportCutImage returned null: invalid-cut-bounds",
-        {
-          bounds: pathBounds
-        }
-      );
-      return null;
-    }
-    const exportBounds = pathBounds;
-    const sourceImages = this.canvasService.canvas.getObjects().filter((obj) => {
-      var _a2;
-      return ((_a2 = obj == null ? void 0 : obj.data) == null ? void 0 : _a2.layerId) === IMAGE_OBJECT_LAYER_ID;
-    });
-    if (!sourceImages.length) {
-      console.warn(
-        "[DielineTool] exportCutImage returned null: no-image-objects-on-canvas"
-      );
-      return null;
-    }
-    const sourceCanvasWidth = Number(
-      this.canvasService.canvas.width || sceneLayout.canvasWidth || canvasW
-    );
-    const sourceCanvasHeight = Number(
-      this.canvasService.canvas.height || sceneLayout.canvasHeight || canvasH
-    );
-    const el = document.createElement("canvas");
-    const exportCanvas = new FabricCanvas2(el, {
-      renderOnAddRemove: false,
-      selection: false,
-      enableRetinaScaling: false,
-      preserveObjectStacking: true
-    });
-    exportCanvas.setDimensions({
-      width: Math.max(1, sourceCanvasWidth),
-      height: Math.max(1, sourceCanvasHeight)
-    });
-    try {
-      for (const source of sourceImages) {
-        const clone = await source.clone();
-        clone.set({
-          selectable: false,
-          evented: false
-        });
-        clone.setCoords();
-        exportCanvas.add(clone);
-      }
-      exportCanvas.clipPath = clipPath;
-      exportCanvas.renderAll();
-      const dataUrl = exportCanvas.toDataURL({
-        format: "png",
-        multiplier: 2,
-        left: exportBounds.left,
-        top: exportBounds.top,
-        width: exportBounds.width,
-        height: exportBounds.height
-      });
-      if (debug) {
-        console.info("[DielineTool] exportCutImage success", {
-          sourceCount: sourceImages.length,
-          bounds: exportBounds,
-          rawPathBounds: pathBounds,
-          pathOffset: {
-            x: Number.isFinite(pathOffsetX) ? pathOffsetX : null,
-            y: Number.isFinite(pathOffsetY) ? pathOffsetY : null
-          },
-          clipPathCenter: {
-            x: centerX,
-            y: centerY
-          },
-          cutRect: sceneLayout.cutRect,
-          canvasSize: {
-            width: Math.max(1, sourceCanvasWidth),
-            height: Math.max(1, sourceCanvasHeight)
-          }
-        });
-      }
-      return dataUrl;
-    } finally {
-      exportCanvas.dispose();
-    }
-  }
-};
-
-// src/extensions/feature/FeatureTool.ts
-import {
-  ContributionPointIds as ContributionPointIds5
-} from "@pooder/core";
-
-// src/extensions/constraints.ts
-var ConstraintRegistry = class {
-  static register(type, handler) {
-    this.handlers.set(type, handler);
-  }
-  static apply(x, y, feature, context, constraints) {
-    const list = constraints || feature.constraints;
-    if (!list || list.length === 0) {
-      return { x, y };
-    }
-    let currentX = x;
-    let currentY = y;
-    for (const constraint of list) {
-      const handler = this.handlers.get(constraint.type);
-      if (handler) {
-        const result = handler(currentX, currentY, feature, context, constraint.params || {});
-        currentX = result.x;
-        currentY = result.y;
-      }
-    }
-    return { x: currentX, y: currentY };
-  }
-};
-ConstraintRegistry.handlers = /* @__PURE__ */ new Map();
-var pathConstraint = (x, y, feature, context, params) => {
-  const { dielineWidth, dielineHeight, geometry } = context;
-  if (!geometry) return { x, y };
-  const minX = geometry.x - geometry.width / 2;
-  const minY = geometry.y - geometry.height / 2;
-  const absX = minX + x * geometry.width;
-  const absY = minY + y * geometry.height;
-  const nearest = getNearestPointOnDieline(
-    { x: absX, y: absY },
-    geometry
-  );
-  let finalX = nearest.x;
-  let finalY = nearest.y;
-  const hasOffsetParams = params.minOffset !== void 0 || params.maxOffset !== void 0;
-  if (hasOffsetParams && nearest.normal) {
-    const dx = absX - nearest.x;
-    const dy = absY - nearest.y;
-    const nx2 = nearest.normal.x;
-    const ny2 = nearest.normal.y;
-    const dist = dx * nx2 + dy * ny2;
-    const scale = dielineWidth > 0 ? geometry.width / dielineWidth : 1;
-    const rawMin = params.minOffset !== void 0 ? params.minOffset : 0;
-    const rawMax = params.maxOffset !== void 0 ? params.maxOffset : 0;
-    const minOffset = rawMin * scale;
-    const maxOffset = rawMax * scale;
-    const clampedDist = Math.max(minOffset, Math.min(dist, maxOffset));
-    finalX = nearest.x + nx2 * clampedDist;
-    finalY = nearest.y + ny2 * clampedDist;
-  }
-  const nx = geometry.width > 0 ? (finalX - minX) / geometry.width : 0.5;
-  const ny = geometry.height > 0 ? (finalY - minY) / geometry.height : 0.5;
-  return { x: nx, y: ny };
-};
-var edgeConstraint = (x, y, feature, context, params) => {
-  const { dielineWidth, dielineHeight } = context;
-  const allowedEdges = params.allowedEdges || [
-    "top",
-    "bottom",
-    "left",
-    "right"
-  ];
-  const confine = params.confine || false;
-  const offset = params.offset || 0;
-  const distances = [];
-  if (allowedEdges.includes("top"))
-    distances.push({ edge: "top", dist: y * dielineHeight });
-  if (allowedEdges.includes("bottom"))
-    distances.push({ edge: "bottom", dist: (1 - y) * dielineHeight });
-  if (allowedEdges.includes("left"))
-    distances.push({ edge: "left", dist: x * dielineWidth });
-  if (allowedEdges.includes("right"))
-    distances.push({ edge: "right", dist: (1 - x) * dielineWidth });
-  if (distances.length === 0) return { x, y };
-  distances.sort((a, b) => a.dist - b.dist);
-  const nearest = distances[0].edge;
-  let newX = x;
-  let newY = y;
-  const fw = feature.width || 0;
-  const fh = feature.height || 0;
-  switch (nearest) {
-    case "top":
-      newY = 0 + offset / dielineHeight;
-      if (confine) {
-        const minX = fw / 2 / dielineWidth;
-        const maxX = 1 - minX;
-        newX = Math.max(minX, Math.min(newX, maxX));
-      }
-      break;
-    case "bottom":
-      newY = 1 - offset / dielineHeight;
-      if (confine) {
-        const minX = fw / 2 / dielineWidth;
-        const maxX = 1 - minX;
-        newX = Math.max(minX, Math.min(newX, maxX));
-      }
-      break;
-    case "left":
-      newX = 0 + offset / dielineWidth;
-      if (confine) {
-        const minY = fh / 2 / dielineHeight;
-        const maxY = 1 - minY;
-        newY = Math.max(minY, Math.min(newY, maxY));
+      left: cx,
+      top: cy,
+      absolutePositioned: true
+    });
+    const pathOffsetX = Number((_a = clipPath == null ? void 0 : clipPath.pathOffset) == null ? void 0 : _a.x);
+    const pathOffsetY = Number((_b = clipPath == null ? void 0 : clipPath.pathOffset) == null ? void 0 : _b.y);
+    const centerX = Number.isFinite(pathOffsetX) ? pathOffsetX : cx;
+    const centerY = Number.isFinite(pathOffsetY) ? pathOffsetY : cy;
+    clipPath.set({
+      originX: "center",
+      originY: "center",
+      left: centerX,
+      top: centerY,
+      absolutePositioned: true
+    });
+    clipPath.setCoords();
+    const pathBounds = clipPath.getBoundingRect();
+    if (!Number.isFinite(pathBounds.left) || !Number.isFinite(pathBounds.top) || !Number.isFinite(pathBounds.width) || !Number.isFinite(pathBounds.height) || pathBounds.width <= 0 || pathBounds.height <= 0) {
+      console.warn(
+        "[DielineTool] exportCutImage returned null: invalid-cut-bounds",
+        {
+          bounds: pathBounds
+        }
+      );
+      return null;
+    }
+    const exportBounds = pathBounds;
+    const sourceImages = this.canvasService.canvas.getObjects().filter((obj) => {
+      var _a2;
+      return ((_a2 = obj == null ? void 0 : obj.data) == null ? void 0 : _a2.layerId) === IMAGE_OBJECT_LAYER_ID;
+    });
+    if (!sourceImages.length) {
+      console.warn(
+        "[DielineTool] exportCutImage returned null: no-image-objects-on-canvas"
+      );
+      return null;
+    }
+    const sourceCanvasWidth = Number(
+      this.canvasService.canvas.width || sceneLayout.canvasWidth || canvasW
+    );
+    const sourceCanvasHeight = Number(
+      this.canvasService.canvas.height || sceneLayout.canvasHeight || canvasH
+    );
+    const el = document.createElement("canvas");
+    const exportCanvas = new FabricCanvas2(el, {
+      renderOnAddRemove: false,
+      selection: false,
+      enableRetinaScaling: false,
+      preserveObjectStacking: true
+    });
+    exportCanvas.setDimensions({
+      width: Math.max(1, sourceCanvasWidth),
+      height: Math.max(1, sourceCanvasHeight)
+    });
+    try {
+      for (const source of sourceImages) {
+        const clone = await source.clone();
+        clone.set({
+          selectable: false,
+          evented: false
+        });
+        clone.setCoords();
+        exportCanvas.add(clone);
       }
-      break;
-    case "right":
-      newX = 1 - offset / dielineWidth;
-      if (confine) {
-        const minY = fh / 2 / dielineHeight;
-        const maxY = 1 - minY;
-        newY = Math.max(minY, Math.min(newY, maxY));
+      exportCanvas.clipPath = clipPath;
+      exportCanvas.renderAll();
+      const dataUrl = exportCanvas.toDataURL({
+        format: "png",
+        multiplier: 2,
+        left: exportBounds.left,
+        top: exportBounds.top,
+        width: exportBounds.width,
+        height: exportBounds.height
+      });
+      if (debug) {
+        console.info("[DielineTool] exportCutImage success", {
+          sourceCount: sourceImages.length,
+          bounds: exportBounds,
+          rawPathBounds: pathBounds,
+          pathOffset: {
+            x: Number.isFinite(pathOffsetX) ? pathOffsetX : null,
+            y: Number.isFinite(pathOffsetY) ? pathOffsetY : null
+          },
+          clipPathCenter: {
+            x: centerX,
+            y: centerY
+          },
+          cutRect: sceneLayout.cutRect,
+          canvasSize: {
+            width: Math.max(1, sourceCanvasWidth),
+            height: Math.max(1, sourceCanvasHeight)
+          }
+        });
       }
-      break;
-  }
-  return { x: newX, y: newY };
-};
-var internalConstraint = (x, y, feature, context, params) => {
-  const { dielineWidth, dielineHeight } = context;
-  const margin = params.margin || 0;
-  const fw = feature.width || 0;
-  const fh = feature.height || 0;
-  const minX = (margin + fw / 2) / dielineWidth;
-  const maxX = 1 - (margin + fw / 2) / dielineWidth;
-  const minY = (margin + fh / 2) / dielineHeight;
-  const maxY = 1 - (margin + fh / 2) / dielineHeight;
-  const clampedX = minX > maxX ? 0.5 : Math.max(minX, Math.min(x, maxX));
-  const clampedY = minY > maxY ? 0.5 : Math.max(minY, Math.min(y, maxY));
-  return { x: clampedX, y: clampedY };
-};
-var tangentBottomConstraint = (x, y, feature, context, params) => {
-  const { dielineWidth, dielineHeight } = context;
-  const gap = params.gap || 0;
-  const confineX = params.confineX !== false;
-  const extentY = feature.shape === "circle" ? feature.radius || 0 : (feature.height || 0) / 2;
-  const newY = 1 + (extentY + gap) / dielineHeight;
-  let newX = x;
-  if (confineX) {
-    const extentX = feature.shape === "circle" ? feature.radius || 0 : (feature.width || 0) / 2;
-    const minX = extentX / dielineWidth;
-    const maxX = 1 - extentX / dielineWidth;
-    newX = minX > maxX ? 0.5 : Math.max(minX, Math.min(newX, maxX));
-  }
-  return { x: newX, y: newY };
-};
-var lowestTangentConstraint = (x, y, feature, context, params) => {
-  const { dielineWidth, dielineHeight, geometry } = context;
-  if (!geometry) return { x, y };
-  const lowest = getLowestPointOnDieline(geometry);
-  const minY = geometry.y - geometry.height / 2;
-  const normY = (lowest.y - minY) / geometry.height;
-  const gap = params.gap || 0;
-  const confineX = params.confineX !== false;
-  const extentY = feature.shape === "circle" ? feature.radius || 0 : (feature.height || 0) / 2;
-  const newY = normY + (extentY + gap) / dielineHeight;
-  let newX = x;
-  if (confineX) {
-    const extentX = feature.shape === "circle" ? feature.radius || 0 : (feature.width || 0) / 2;
-    const minX = extentX / dielineWidth;
-    const maxX = 1 - extentX / dielineWidth;
-    newX = minX > maxX ? 0.5 : Math.max(minX, Math.min(newX, maxX));
+      return dataUrl;
+    } finally {
+      exportCanvas.dispose();
+    }
   }
-  return { x: newX, y: newY };
 };
-ConstraintRegistry.register("path", pathConstraint);
-ConstraintRegistry.register("edge", edgeConstraint);
-ConstraintRegistry.register("internal", internalConstraint);
-ConstraintRegistry.register("tangent-bottom", tangentBottomConstraint);
-ConstraintRegistry.register("lowest-tangent", lowestTangentConstraint);
+
+// src/extensions/feature/FeatureTool.ts
+import {
+  ContributionPointIds as ContributionPointIds5
+} from "@pooder/core";
+import { Pattern as Pattern3 } from "fabric";
 
 // src/extensions/featureComplete.ts
 function validateFeaturesStrict(features, context) {
@@ -5317,7 +5522,9 @@ var FeatureTool = class {
     this.isFeatureSessionActive = false;
     this.sessionOriginalFeatures = null;
     this.hasWorkingChanges = false;
-    this.specs = [];
+    this.markerSpecs = [];
+    this.sessionDielineSpecs = [];
+    this.sessionDielineEffects = [];
     this.renderSeq = 0;
     this.subscriptions = new SubscriptionBag();
     this.handleMoving = null;
@@ -5327,7 +5534,7 @@ var FeatureTool = class {
     this.onToolActivated = (event) => {
       this.isToolActive = event.id === this.id;
       if (!this.isToolActive) {
-        this.restoreSessionFeaturesToConfig();
+        this.suspendFeatureSession();
       }
       this.updateVisibility();
     };
@@ -5347,16 +5554,38 @@ var FeatureTool = class {
     (_a = this.renderProducerDisposable) == null ? void 0 : _a.dispose();
     this.renderProducerDisposable = this.canvasService.registerRenderProducer(
       this.id,
-      () => ({
-        passes: [
+      () => {
+        const passes = [
           {
             id: FEATURE_OVERLAY_LAYER_ID,
             stack: 880,
             order: 0,
-            objects: this.specs
+            replace: true,
+            objects: this.markerSpecs
           }
-        ]
-      }),
+        ];
+        if (this.isSessionVisible()) {
+          passes.push(
+            {
+              id: DIELINE_LAYER_ID,
+              stack: 700,
+              order: 0,
+              replace: false,
+              visibility: { op: "const", value: false },
+              objects: []
+            },
+            {
+              id: FEATURE_DIELINE_LAYER_ID,
+              stack: 705,
+              order: 0,
+              replace: true,
+              effects: this.sessionDielineEffects,
+              objects: this.sessionDielineSpecs
+            }
+          );
+        }
+        return { passes };
+      },
       { priority: 350 }
     );
     const configService = context.services.get(
@@ -5371,12 +5600,22 @@ var FeatureTool = class {
         (e) => {
           if (this.isUpdatingConfig) return;
           if (e.key === "dieline.features") {
-            if (this.isFeatureSessionActive) return;
+            if (this.isFeatureSessionActive && this.hasFeatureSessionDraft()) {
+              return;
+            }
+            if (this.hasFeatureSessionDraft()) {
+              this.clearFeatureSessionState();
+            }
             const next = e.value || [];
             this.workingFeatures = this.cloneFeatures(next);
             this.hasWorkingChanges = false;
             this.redraw();
             this.emitWorkingChange();
+            return;
+          }
+          if (e.key.startsWith("size.") || e.key.startsWith("dieline.")) {
+            void this.refreshGeometry();
+            this.redraw({ enforceConstraints: true });
           }
         }
       );
@@ -5392,7 +5631,8 @@ var FeatureTool = class {
   deactivate(context) {
     var _a;
     this.subscriptions.disposeAll();
-    this.restoreSessionFeaturesToConfig();
+    this.restoreCommittedFeaturesToConfig();
+    this.clearFeatureSessionState();
     (_a = this.dirtyTrackerDisposable) == null ? void 0 : _a.dispose();
     this.dirtyTrackerDisposable = void 0;
     this.teardown();
@@ -5402,6 +5642,9 @@ var FeatureTool = class {
   updateVisibility() {
     this.redraw();
   }
+  isSessionVisible() {
+    return this.isToolActive && this.isFeatureSessionActive;
+  }
   contribute() {
     return {
       [ContributionPointIds5.TOOLS]: [
@@ -5428,15 +5671,16 @@ var FeatureTool = class {
             if (this.isFeatureSessionActive) {
               return { ok: true };
             }
-            const original = this.getCommittedFeatures();
-            this.sessionOriginalFeatures = this.cloneFeatures(original);
+            if (!this.hasFeatureSessionDraft()) {
+              const original = this.getCommittedFeatures();
+              this.sessionOriginalFeatures = this.cloneFeatures(original);
+              this.setWorkingFeatures(this.cloneFeatures(original));
+              this.hasWorkingChanges = false;
+            }
             this.isFeatureSessionActive = true;
             await this.refreshGeometry();
-            this.setWorkingFeatures(this.cloneFeatures(original));
-            this.hasWorkingChanges = false;
             this.redraw();
             this.emitWorkingChange();
-            this.updateCommittedFeatures([]);
             return { ok: true };
           }
         },
@@ -5472,25 +5716,6 @@ var FeatureTool = class {
             return true;
           }
         },
-        {
-          command: "getWorkingFeatures",
-          title: "Get Working Features",
-          handler: () => {
-            return this.cloneFeatures(this.workingFeatures);
-          }
-        },
-        {
-          command: "setWorkingFeatures",
-          title: "Set Working Features",
-          handler: async (features) => {
-            await this.refreshGeometry();
-            this.setWorkingFeatures(this.cloneFeatures(features || []));
-            this.hasWorkingChanges = true;
-            this.redraw();
-            this.emitWorkingChange();
-            return { ok: true };
-          }
-        },
         {
           command: "rollbackFeatureSession",
           title: "Rollback Feature Session",
@@ -5557,17 +5782,24 @@ var FeatureTool = class {
       this.isUpdatingConfig = false;
     }
   }
+  hasFeatureSessionDraft() {
+    return Array.isArray(this.sessionOriginalFeatures);
+  }
   clearFeatureSessionState() {
     this.isFeatureSessionActive = false;
     this.sessionOriginalFeatures = null;
   }
-  restoreSessionFeaturesToConfig() {
-    if (!this.isFeatureSessionActive) return;
+  restoreCommittedFeaturesToConfig() {
+    if (!this.hasFeatureSessionDraft()) return;
     const original = this.cloneFeatures(
       this.sessionOriginalFeatures || this.getCommittedFeatures()
     );
     this.updateCommittedFeatures(original);
-    this.clearFeatureSessionState();
+  }
+  suspendFeatureSession() {
+    if (!this.isFeatureSessionActive) return;
+    this.restoreCommittedFeaturesToConfig();
+    this.isFeatureSessionActive = false;
   }
   emitWorkingChange() {
     var _a;
@@ -5589,7 +5821,7 @@ var FeatureTool = class {
   }
   async resetWorkingFeaturesFromSource() {
     const next = this.cloneFeatures(
-      this.isFeatureSessionActive && this.sessionOriginalFeatures ? this.sessionOriginalFeatures : this.getCommittedFeatures()
+      this.sessionOriginalFeatures || this.getCommittedFeatures()
     );
     await this.refreshGeometry();
     this.setWorkingFeatures(next);
@@ -5813,11 +6045,35 @@ var FeatureTool = class {
       this.handleSceneGeometryChange = null;
     }
     this.renderSeq += 1;
-    this.specs = [];
+    this.markerSpecs = [];
+    this.sessionDielineSpecs = [];
+    this.sessionDielineEffects = [];
     (_a = this.renderProducerDisposable) == null ? void 0 : _a.dispose();
     this.renderProducerDisposable = void 0;
     void this.canvasService.flushRenderFromProducers();
   }
+  createHatchPattern(color = "rgba(0, 0, 0, 0.3)") {
+    if (typeof document === "undefined") {
+      return void 0;
+    }
+    const size = 20;
+    const canvas = document.createElement("canvas");
+    canvas.width = size;
+    canvas.height = size;
+    const ctx = canvas.getContext("2d");
+    if (ctx) {
+      ctx.clearRect(0, 0, size, size);
+      ctx.strokeStyle = color;
+      ctx.lineWidth = 1;
+      ctx.beginPath();
+      ctx.moveTo(0, size);
+      ctx.lineTo(size, 0);
+      ctx.stroke();
+    }
+    return new Pattern3({
+      source: canvas
+    });
+  }
   getDraggableMarkerTarget(target) {
     var _a, _b;
     if (!this.isFeatureSessionActive || !this.isToolActive) return null;
@@ -5893,6 +6149,7 @@ var FeatureTool = class {
     next[index] = updatedFeature;
     this.setWorkingFeatures(next);
     this.hasWorkingChanges = true;
+    this.redraw();
     this.emitWorkingChange();
   }
   syncGroupFromCanvas(target) {
@@ -5931,6 +6188,7 @@ var FeatureTool = class {
     if (!changed) return;
     this.setWorkingFeatures(next);
     this.hasWorkingChanges = true;
+    this.redraw();
     this.emitWorkingChange();
   }
   redraw(options = {}) {
@@ -5939,7 +6197,10 @@ var FeatureTool = class {
   async redrawAsync(options = {}) {
     if (!this.canvasService) return;
     const seq = ++this.renderSeq;
-    this.specs = this.buildFeatureSpecs();
+    this.markerSpecs = this.buildMarkerSpecs();
+    const sessionRender = this.buildSessionDielineRender();
+    this.sessionDielineSpecs = sessionRender.specs;
+    this.sessionDielineEffects = sessionRender.effects;
     if (seq !== this.renderSeq) return;
     await this.canvasService.flushRenderFromProducers();
     if (seq !== this.renderSeq) return;
@@ -5947,15 +6208,77 @@ var FeatureTool = class {
       this.enforceConstraints();
     }
   }
-  buildFeatureSpecs() {
+  buildSessionDielineRender() {
+    if (!this.isSessionVisible() || !this.canvasService) {
+      return { specs: [], effects: [] };
+    }
+    const configService = this.getConfigService();
+    if (!configService) {
+      return { specs: [], effects: [] };
+    }
+    const sceneLayout = computeSceneLayout(
+      this.canvasService,
+      readSizeState(configService)
+    );
+    if (!sceneLayout) {
+      return { specs: [], effects: [] };
+    }
+    const state = readDielineState(configService);
+    state.features = this.cloneFeatures(this.workingFeatures);
+    return buildDielineRenderBundle({
+      state,
+      sceneLayout,
+      canvasWidth: sceneLayout.canvasWidth || this.canvasService.canvas.width || 800,
+      canvasHeight: sceneLayout.canvasHeight || this.canvasService.canvas.height || 600,
+      hasImages: this.hasImageItems(),
+      createHatchPattern: (color) => this.createHatchPattern(color),
+      clipTargetPassIds: [IMAGE_OBJECT_LAYER_ID],
+      clipVisibility: { op: "const", value: true },
+      ids: {
+        inside: "feature.session.dieline.inside",
+        bleedZone: "feature.session.dieline.bleed-zone",
+        offsetBorder: "feature.session.dieline.offset-border",
+        border: "feature.session.dieline.border",
+        clip: "feature.session.dieline.clip.image",
+        clipSource: "feature.session.dieline.effect.clip-path"
+      }
+    });
+  }
+  hasImageItems() {
+    const configService = this.getConfigService();
+    if (!configService) return false;
+    const items = configService.get("image.items", []);
+    return Array.isArray(items) && items.length > 0;
+  }
+  buildMarkerSpecs() {
     if (!this.isFeatureSessionActive || !this.currentGeometry || this.workingFeatures.length === 0) {
       return [];
     }
     const groups = /* @__PURE__ */ new Map();
     const singles = [];
-    this.workingFeatures.forEach((feature, index) => {
+    const placements = resolveFeaturePlacements(
+      this.workingFeatures,
+      {
+        shape: this.currentGeometry.shape,
+        shapeStyle: this.currentGeometry.shapeStyle,
+        pathData: this.currentGeometry.pathData,
+        customSourceWidthPx: this.currentGeometry.customSourceWidthPx,
+        customSourceHeightPx: this.currentGeometry.customSourceHeightPx,
+        x: this.currentGeometry.x,
+        y: this.currentGeometry.y,
+        width: this.currentGeometry.width,
+        height: this.currentGeometry.height,
+        radius: this.currentGeometry.radius,
+        scale: this.currentGeometry.scale || 1
+      }
+    );
+    placements.forEach((placement, index) => {
+      const feature = placement.feature;
       const geometry = this.getGeometryForFeature(this.currentGeometry, feature);
-      const position = resolveFeaturePosition(feature, geometry);
+      const position = {
+        x: placement.centerX,
+        y: placement.centerY
+      };
       const scale = geometry.scale || 1;
       const marker = {
         feature,
@@ -6532,11 +6855,12 @@ var EXTENSION_LINE_LENGTH = 5;
 var MIN_ARROW_SIZE = 4;
 var THICKNESS_TO_STROKE_WIDTH_RATIO = 20;
 var DEFAULT_THICKNESS = 20;
-var DEFAULT_GAP = 45;
+var DEFAULT_GAP = 65;
 var DEFAULT_FONT_SIZE = 10;
 var DEFAULT_BACKGROUND_COLOR = "#f0f0f0";
 var DEFAULT_TEXT_COLOR = "#333333";
 var DEFAULT_LINE_COLOR = "#999999";
+var RULER_DEBUG_KEY = "ruler.debug";
 var RULER_THICKNESS_MIN = 10;
 var RULER_THICKNESS_MAX = 100;
 var RULER_GAP_MIN = 0;
@@ -6555,6 +6879,7 @@ var RulerTool = class {
     this.textColor = DEFAULT_TEXT_COLOR;
     this.lineColor = DEFAULT_LINE_COLOR;
     this.fontSize = DEFAULT_FONT_SIZE;
+    this.debugEnabled = false;
     this.renderSeq = 0;
     this.numericProps = /* @__PURE__ */ new Set(["thickness", "gap", "fontSize"]);
     this.specs = [];
@@ -6603,7 +6928,14 @@ var RulerTool = class {
       this.syncConfig(configService);
       configService.onAnyChange((e) => {
         let shouldUpdate = false;
-        if (e.key.startsWith("ruler.")) {
+        if (e.key === RULER_DEBUG_KEY) {
+          this.debugEnabled = e.value === true;
+          this.log("config:update", {
+            key: e.key,
+            raw: e.value,
+            normalized: this.debugEnabled
+          });
+        } else if (e.key.startsWith("ruler.")) {
           const prop = e.key.split(".")[1];
           if (prop && prop in this) {
             if (this.numericProps.has(prop)) {
@@ -6690,6 +7022,12 @@ var RulerTool = class {
           min: RULER_FONT_SIZE_MIN,
           max: RULER_FONT_SIZE_MAX,
           default: DEFAULT_FONT_SIZE
+        },
+        {
+          id: RULER_DEBUG_KEY,
+          type: "boolean",
+          label: "Ruler Debug Log",
+          default: false
         }
       ],
       [ContributionPointIds8.COMMANDS]: [
@@ -6726,7 +7064,11 @@ var RulerTool = class {
       ]
     };
   }
+  isDebugEnabled() {
+    return this.debugEnabled;
+  }
   log(step, payload) {
+    if (!this.isDebugEnabled()) return;
     if (payload) {
       console.debug(`[RulerTool] ${step}`, payload);
       return;
@@ -6755,6 +7097,7 @@ var RulerTool = class {
       configService.get("ruler.fontSize", this.fontSize),
       DEFAULT_FONT_SIZE
     );
+    this.debugEnabled = configService.get(RULER_DEBUG_KEY, this.debugEnabled) === true;
     this.log("config:loaded", {
       thickness: this.thickness,
       gap: this.gap,
@@ -9534,11 +9877,13 @@ export {
   WhiteInkTool,
   getCoverScale as computeImageCoverScale,
   getCoverScale as computeWhiteInkCoverScale,
+  createDefaultDielineState,
   createDielineCommands,
   createDielineConfigurations,
   createImageCommands,
   createImageConfigurations,
   createWhiteInkCommands,
   createWhiteInkConfigurations,
-  evaluateVisibilityExpr
+  evaluateVisibilityExpr,
+  readDielineState
 };