@lucablockltd/ultimate-packaging 1.0.3 → 1.2.0

package/dist/index.js

@@ -413,6 +413,7 @@ var AUTO_LAYOUT_THEME_CONFIG = {
 };
 
 // src/config.ts
+var DEFAULT_FONT_DIMENSION_SIZE = 4.2;
 var globalConfig = {};
 function configurePackaging(config) {
   globalConfig = config;
@@ -420,6 +421,9 @@ function configurePackaging(config) {
 function getModelTheme() {
   return { ...MODEL_THEME_CONFIG, ...globalConfig.modelTheme };
 }
+function getFontDimensionSize() {
+  return globalConfig.fontDimensionSize ?? DEFAULT_FONT_DIMENSION_SIZE;
+}
 function getAutoLayoutTheme() {
   return { ...AUTO_LAYOUT_THEME_CONFIG, ...globalConfig.autoLayoutTheme };
 }
@@ -1011,7 +1015,7 @@ var UNIT_FACTOR = {
   in: 1 / 25.4
 };
 var PX_PER_MM = 96 / 25.4;
-function renderDimension(dim, i) {
+function renderDimension(dim, i, fs) {
   const { x1, y1, x2, y2, label, orientation, offset } = dim;
   const tick = 1.5;
   if (orientation === "horizontal") {
@@ -1027,7 +1031,7 @@ function renderDimension(dim, i) {
           x: midX,
           y: y - 1.5,
           textAnchor: "middle",
-          fontSize: 3.5,
+          fontSize: fs,
           fontFamily: "sans-serif",
           fill: "#000",
           children: label
@@ -1048,7 +1052,7 @@ function renderDimension(dim, i) {
         y: midY - 1,
         textAnchor: "middle",
         dominantBaseline: "central",
-        fontSize: 3.5,
+        fontSize: fs,
         fontFamily: "sans-serif",
         fill: "#000",
         transform: `rotate(-90, ${x - 1.5}, ${midY})`,
@@ -1157,7 +1161,7 @@ var DIE_LINE_BECF_1010A = react.forwardRef(
     const svgChildren = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
       /* @__PURE__ */ jsxRuntime.jsx("g", { id: "crease", children: dieline.crease.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorFoldLine, strokeWidth: 0.5, strokeDasharray: "2,1" }, `c-${i}`)) }),
       /* @__PURE__ */ jsxRuntime.jsx("g", { id: "cut", children: dieline.cut.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorDieLine, strokeWidth: 0.5 }, `t-${i}`)) }),
-      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map(renderDimension) })
+      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map((d, i) => renderDimension(d, i, getFontDimensionSize())) })
     ] });
     if (renderAs === "group") {
       return /* @__PURE__ */ jsxRuntime.jsx("g", { children: svgChildren });
@@ -1659,7 +1663,7 @@ var UNIT_FACTOR2 = {
   in: 1 / 25.4
 };
 var PX_PER_MM2 = 96 / 25.4;
-function renderDimension2(dim, i) {
+function renderDimension2(dim, i, fs) {
   const { x1, y1, x2, y2, label, orientation, offset } = dim;
   const tick = 1.5;
   if (orientation === "horizontal") {
@@ -1675,7 +1679,7 @@ function renderDimension2(dim, i) {
           x: midX,
           y: y - 1.5,
           textAnchor: "middle",
-          fontSize: 4.2,
+          fontSize: fs,
           fontFamily: "sans-serif",
           fill: "#000",
           children: label
@@ -1696,7 +1700,7 @@ function renderDimension2(dim, i) {
         y: midY - 1,
         textAnchor: "middle",
         dominantBaseline: "central",
-        fontSize: 4.2,
+        fontSize: fs,
         fontFamily: "sans-serif",
         fill: "#000",
         transform: `rotate(-90, ${x - 1.5}, ${midY})`,
@@ -1805,7 +1809,7 @@ var DIE_LINE_BECF_1030A = react.forwardRef(
     const svgChildren = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
       /* @__PURE__ */ jsxRuntime.jsx("g", { id: "crease", children: dieline.crease.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorFoldLine, strokeWidth: 0.5, strokeDasharray: "2,1" }, `c-${i}`)) }),
       /* @__PURE__ */ jsxRuntime.jsx("g", { id: "cut", children: dieline.cut.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorDieLine, strokeWidth: 0.5 }, `t-${i}`)) }),
-      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map(renderDimension2) })
+      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map((d, i) => renderDimension2(d, i, getFontDimensionSize())) })
     ] });
     if (renderAs === "group") {
       return /* @__PURE__ */ jsxRuntime.jsx("g", { children: svgChildren });
@@ -2310,7 +2314,7 @@ var UNIT_FACTOR3 = {
   in: 1 / 25.4
 };
 var PX_PER_MM3 = 96 / 25.4;
-function renderDimension3(dim, i) {
+function renderDimension3(dim, i, fs) {
   const { x1, y1, x2, y2, label, orientation, offset } = dim;
   const tick = 1.5;
   if (orientation === "horizontal") {
@@ -2326,7 +2330,7 @@ function renderDimension3(dim, i) {
           x: midX,
           y: y - 1.5,
           textAnchor: "middle",
-          fontSize: 4.2,
+          fontSize: fs,
           fontFamily: "sans-serif",
           fill: "#000",
           children: label
@@ -2347,7 +2351,7 @@ function renderDimension3(dim, i) {
         y: midY - 1,
         textAnchor: "middle",
         dominantBaseline: "central",
-        fontSize: 4.2,
+        fontSize: fs,
         fontFamily: "sans-serif",
         fill: "#000",
         transform: `rotate(-90, ${x - 1.5}, ${midY})`,
@@ -2456,7 +2460,7 @@ var DIE_LINE_BECF_1040A = react.forwardRef(
     const svgChildren = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
       /* @__PURE__ */ jsxRuntime.jsx("g", { id: "crease", children: dieline.crease.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorFoldLine, strokeWidth: 0.5, strokeDasharray: "2,1" }, `c-${i}`)) }),
       /* @__PURE__ */ jsxRuntime.jsx("g", { id: "cut", children: dieline.cut.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorDieLine, strokeWidth: 0.5 }, `t-${i}`)) }),
-      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map(renderDimension3) })
+      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map((d, i) => renderDimension3(d, i, getFontDimensionSize())) })
     ] });
     if (renderAs === "group") {
       return /* @__PURE__ */ jsxRuntime.jsx("g", { children: svgChildren });
@@ -2873,7 +2877,7 @@ var UNIT_FACTOR4 = {
   in: 1 / 25.4
 };
 var PX_PER_MM4 = 96 / 25.4;
-function renderDimension4(dim, i) {
+function renderDimension4(dim, i, fs) {
   const { x1, y1, x2, y2, label, orientation, offset } = dim;
   const tick = 1.5;
   if (orientation === "horizontal") {
@@ -2889,7 +2893,7 @@ function renderDimension4(dim, i) {
           x: midX,
           y: y - 1.5,
           textAnchor: "middle",
-          fontSize: 4.2,
+          fontSize: fs,
           fontFamily: "sans-serif",
           fill: "#000",
           children: label
@@ -2910,7 +2914,7 @@ function renderDimension4(dim, i) {
         y: midY - 1,
         textAnchor: "middle",
         dominantBaseline: "central",
-        fontSize: 4.2,
+        fontSize: fs,
         fontFamily: "sans-serif",
         fill: "#000",
         transform: `rotate(-90, ${x - 1.5}, ${midY})`,
@@ -3018,7 +3022,7 @@ var DIE_LINE_BECF_11D01 = react.forwardRef(
     const svgChildren = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
       /* @__PURE__ */ jsxRuntime.jsx("g", { id: "crease", children: dieline.crease.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorFoldLine, strokeWidth: 0.5, strokeDasharray: "2,1" }, `c-${i}`)) }),
       /* @__PURE__ */ jsxRuntime.jsx("g", { id: "cut", children: dieline.cut.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorDieLine, strokeWidth: 0.5 }, `t-${i}`)) }),
-      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map(renderDimension4) })
+      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map((d, i) => renderDimension4(d, i, getFontDimensionSize())) })
     ] });
     if (renderAs === "group") {
       return /* @__PURE__ */ jsxRuntime.jsx("g", { children: svgChildren });
@@ -3132,369 +3136,1761 @@ var MODEL_BECF_11D01 = react.forwardRef(
   }
 );
 
-// src/utils/autoLayout/rasterize.ts
-function rasterizePolygon(points, resolution) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const p of points) {
-    if (p.x < minX) minX = p.x;
-    if (p.y < minY) minY = p.y;
-    if (p.x > maxX) maxX = p.x;
-    if (p.y > maxY) maxY = p.y;
-  }
-  const offsetX = Math.floor(minX / resolution);
-  const offsetY = Math.floor(minY / resolution);
-  const w = Math.ceil((maxX - offsetX * resolution) / resolution) + 1;
-  const h = Math.ceil((maxY - offsetY * resolution) / resolution) + 1;
-  const data = new Uint8Array(w * h);
-  for (let gy = 0; gy < h; gy++) {
-    const worldY = (offsetY + gy) * resolution + resolution / 2;
-    const crossings = [];
-    for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
-      const yi = points[i].y, yj = points[j].y;
-      if (yi <= worldY && yj > worldY || yj <= worldY && yi > worldY) {
-        const t = (worldY - yi) / (yj - yi);
-        crossings.push(points[i].x + t * (points[j].x - points[i].x));
-      }
-    }
-    crossings.sort((a, b) => a - b);
-    for (let c = 0; c < crossings.length - 1; c += 2) {
-      const startGx = Math.max(0, Math.floor((crossings[c] - offsetX * resolution) / resolution));
-      const endGx = Math.min(w - 1, Math.ceil((crossings[c + 1] - offsetX * resolution) / resolution));
-      for (let gx = startGx; gx <= endGx; gx++) {
-        data[gy * w + gx] = 1;
-      }
-    }
-  }
-  return { data, width: w, height: h, offsetX, offsetY };
+// src/components/dieline/bags-pillows/becf-12101/generate.ts
+var DIP = 15;
+var ROPE_R = 3;
+var ROPE_Y = 20;
+var D_MAX = 40;
+function calcD(c, b) {
+  return Math.min(c - 2 - b / 2, D_MAX);
+}
+function calcKulak(b) {
+  if (b <= 13) return b - 1;
+  if (b <= 99) return 13;
+  if (b <= 249) return 20;
+  if (b <= 499) return 25;
+  return 30;
+}
+function calcX(a) {
+  return Math.min(a / 2, 110);
+}
+function getAutoCalcValues(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD(C, B);
+  const kulak = glueArea ?? calcKulak(B);
+  const X = calcX(A);
+  return { d: D, kulak, dip: DIP, ropeR: ROPE_R, ropeY: ROPE_Y, ropeX: X };
+}
+function line5(x1, y1, x2, y2) {
+  return `M${x1} ${y1} L${x2} ${y2}`;
 }
-function canPlace(paperGrid, paperW, paperH, piece, px, py) {
-  for (let y = 0; y < piece.height; y++) {
-    const paperY = py + y;
-    if (paperY < 0 || paperY >= paperH) {
-      for (let x = 0; x < piece.width; x++) {
-        if (piece.data[y * piece.width + x]) return false;
-      }
+function circlePath(cx, cy, r) {
+  return `M${cx - r} ${cy} A${r} ${r} 0 0 1 ${cx + r} ${cy} A${r} ${r} 0 0 1 ${cx - r} ${cy}`;
+}
+function generateBecf12101(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD(C, B);
+  const kulak = glueArea ?? calcKulak(B);
+  const X = calcX(A);
+  const xFront = kulak;
+  const xSide1 = kulak + A;
+  const xSide1Mid = kulak + A + B / 2;
+  const xBack = kulak + A + B;
+  const xSide2 = kulak + 2 * A + B;
+  const xSide2Mid = kulak + 2 * A + B + B / 2;
+  const xEnd = kulak + 2 * A + 2 * B - 2;
+  const yFoldTop = D;
+  const yFoldBottomStart = D + C - B / 2;
+  const yFoldBottom = D + C;
+  const yBottomFlap = D + C + B / 2;
+  const yEnd = D + C + B / 2 + DIP;
+  const totalWidth = xEnd;
+  const totalHeight = yEnd;
+  const cut = [];
+  const crease = [];
+  cut.push(line5(0, 0, totalWidth, 0));
+  cut.push(line5(totalWidth, 0, totalWidth, totalHeight));
+  cut.push(line5(totalWidth, totalHeight, 0, totalHeight));
+  cut.push(line5(0, totalHeight, 0, 0));
+  cut.push(line5(kulak + B / 2, yBottomFlap, kulak + B / 2, yEnd));
+  cut.push(line5(kulak + A - B / 2, yBottomFlap, kulak + A - B / 2, yEnd));
+  cut.push(line5(kulak + A + B + B / 2, yBottomFlap, kulak + A + B + B / 2, yEnd));
+  cut.push(line5(kulak + 2 * A + B - B / 2, yBottomFlap, kulak + 2 * A + B - B / 2, yEnd));
+  const frontCx = kulak + A / 2;
+  const backCx = kulak + A + B + A / 2;
+  const ropeTopY = yFoldTop - ROPE_Y;
+  const ropeBotY = yFoldTop + ROPE_Y;
+  cut.push(circlePath(frontCx - X / 2, ropeTopY, ROPE_R));
+  cut.push(circlePath(frontCx - X / 2, ropeBotY, ROPE_R));
+  cut.push(circlePath(frontCx + X / 2, ropeTopY, ROPE_R));
+  cut.push(circlePath(frontCx + X / 2, ropeBotY, ROPE_R));
+  cut.push(circlePath(backCx - X / 2, ropeTopY, ROPE_R));
+  cut.push(circlePath(backCx - X / 2, ropeBotY, ROPE_R));
+  cut.push(circlePath(backCx + X / 2, ropeTopY, ROPE_R));
+  cut.push(circlePath(backCx + X / 2, ropeBotY, ROPE_R));
+  crease.push(line5(0, yFoldTop, totalWidth, yFoldTop));
+  crease.push(line5(0, yFoldBottomStart, totalWidth, yFoldBottomStart));
+  crease.push(line5(0, yFoldBottom, totalWidth, yFoldBottom));
+  crease.push(line5(xFront, 0, xFront, totalHeight));
+  crease.push(line5(xSide1, 0, xSide1, totalHeight));
+  crease.push(line5(xSide1Mid, 0, xSide1Mid, totalHeight));
+  crease.push(line5(xBack, 0, xBack, totalHeight));
+  crease.push(line5(xSide2, 0, xSide2, totalHeight));
+  crease.push(line5(xSide2Mid, 0, xSide2Mid, totalHeight));
+  crease.push(line5(0, yFoldBottom - kulak, kulak + B / 2, yBottomFlap));
+  crease.push(line5(kulak + A - B / 2, yBottomFlap, xSide1Mid, yFoldBottomStart));
+  crease.push(line5(xSide1Mid, yFoldBottomStart, kulak + A + B + B / 2, yBottomFlap));
+  crease.push(line5(kulak + 2 * A + B - B / 2, yBottomFlap, xSide2Mid, yFoldBottomStart));
+  crease.push(line5(xSide2Mid, yFoldBottomStart, xEnd, D + C - 2));
+  return { cut, crease, viewBox: { width: totalWidth, height: totalHeight } };
+}
+function generateOuterContour5(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD(C, B);
+  const kulak = glueArea ?? calcKulak(B);
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = D + C + B / 2 + DIP;
+  return [
+    { x: 0, y: 0 },
+    { x: totalWidth, y: 0 },
+    { x: totalWidth, y: totalHeight },
+    { x: 0, y: totalHeight }
+  ];
+}
+function offsetContour5(points, distance) {
+  const n = points.length;
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    const prev = points[(i - 1 + n) % n];
+    const curr = points[i];
+    const next = points[(i + 1) % n];
+    const e1x = curr.x - prev.x;
+    const e1y = curr.y - prev.y;
+    const e2x = next.x - curr.x;
+    const e2y = next.y - curr.y;
+    const len1 = Math.sqrt(e1x * e1x + e1y * e1y);
+    const len2 = Math.sqrt(e2x * e2x + e2y * e2y);
+    if (len1 === 0 || len2 === 0) {
+      result.push(curr);
       continue;
     }
-    for (let x = 0; x < piece.width; x++) {
-      if (!piece.data[y * piece.width + x]) continue;
-      const paperX = px + x;
-      if (paperX < 0 || paperX >= paperW) return false;
-      if (paperGrid[paperY * paperW + paperX]) return false;
+    const n1x = e1y / len1;
+    const n1y = -e1x / len1;
+    const n2x = e2y / len2;
+    const n2y = -e2x / len2;
+    const ax = n1x + n2x;
+    const ay = n1y + n2y;
+    const aLen = Math.sqrt(ax * ax + ay * ay);
+    if (aLen < 1e-3) {
+      result.push({ x: curr.x + n1x * distance, y: curr.y + n1y * distance });
+      continue;
     }
+    const nx = ax / aLen;
+    const ny = ay / aLen;
+    const dot = n1x * nx + n1y * ny;
+    const d = distance / Math.max(dot, 0.1);
+    result.push({ x: curr.x + nx * d, y: curr.y + ny * d });
   }
-  return true;
+  return result;
 }
-function placePiece(paperGrid, paperW, piece, px, py) {
-  for (let y = 0; y < piece.height; y++) {
-    for (let x = 0; x < piece.width; x++) {
-      if (piece.data[y * piece.width + x]) {
-        paperGrid[(py + y) * paperW + (px + x)] = 1;
-      }
-    }
+function contourToPath5(points) {
+  if (points.length === 0) return "";
+  let d = `M${points[0].x} ${points[0].y}`;
+  for (let i = 1; i < points.length; i++) {
+    d += ` L${points[i].x} ${points[i].y}`;
   }
+  d += " Z";
+  return d;
 }
-
-// src/utils/autoLayout/calculate/shared.ts
-var RESOLUTION = 1;
-function resolveGripperSide(paperWidth, paperHeight) {
-  if (paperWidth >= paperHeight) return "bottom";
-  return "left";
-}
-function computeUsableBounds(paperWidth, paperHeight, gripperSide, spacing, griper, colorbarDepth) {
-  switch (gripperSide) {
-    case "bottom":
-      return {
-        top: colorbarDepth + spacing,
-        bottom: paperHeight - griper,
-        left: spacing,
-        right: paperWidth - spacing
-      };
-    case "top":
-      return {
-        top: griper,
-        bottom: paperHeight - colorbarDepth - spacing,
-        left: spacing,
-        right: paperWidth - spacing
-      };
-    case "left":
-      return {
-        top: spacing,
-        bottom: paperHeight - spacing,
-        left: griper,
-        right: paperWidth - colorbarDepth - spacing
-      };
-    case "right":
-      return {
-        top: spacing,
-        bottom: paperHeight - spacing,
-        left: colorbarDepth + spacing,
-        right: paperWidth - griper
-      };
-  }
+function generateDimensions5(attr, unit) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD(C, B);
+  const kulak = glueArea ?? calcKulak(B);
+  const factor = unit === "cm" ? 0.1 : unit === "in" ? 1 / 25.4 : 1;
+  const suffix = unit;
+  const fmt = (v) => `${(v * factor).toFixed(2)} ${suffix}`;
+  const xFront = kulak;
+  const xSide1 = kulak + A;
+  const xBack = kulak + A + B;
+  const yFoldTop = D;
+  const yFoldBottom = D + C;
+  const yEnd = D + C + B / 2 + DIP;
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = yEnd;
+  const bottomSection = B / 2 + DIP;
+  return [
+    // Overall dimensions (outside)
+    {
+      x1: 0,
+      y1: 0,
+      x2: totalWidth,
+      y2: 0,
+      label: `Overall Width : ${fmt(totalWidth)}`,
+      orientation: "horizontal",
+      offset: -12
+    },
+    {
+      x1: 0,
+      y1: 0,
+      x2: 0,
+      y2: totalHeight,
+      label: `Overall Height : ${fmt(totalHeight)}`,
+      orientation: "vertical",
+      offset: -12
+    },
+    // Height (C) — body area (centered on back panel)
+    {
+      x1: xBack + A * 0.6,
+      y1: yFoldTop,
+      x2: xBack + A * 0.6,
+      y2: yFoldBottom,
+      label: fmt(C),
+      orientation: "vertical",
+      offset: -10
+    },
+    // Top flap (D) (centered on back panel)
+    {
+      x1: xBack + A * 0.6,
+      y1: 0,
+      x2: xBack + A * 0.6,
+      y2: yFoldTop,
+      label: fmt(D),
+      orientation: "vertical",
+      offset: -10
+    },
+    // Bottom section (B/2 + _dip) (centered on back panel)
+    {
+      x1: xBack + A * 0.6,
+      y1: yFoldBottom,
+      x2: xBack + A * 0.6,
+      y2: yEnd,
+      label: fmt(bottomSection),
+      orientation: "vertical",
+      offset: -10
+    },
+    // Length (A) — front panel (centered vertically on body)
+    {
+      x1: xFront,
+      y1: yFoldTop + C * 0.65,
+      x2: xSide1,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(A),
+      orientation: "horizontal",
+      offset: -20
+    },
+    // Width (B) — side panel (centered vertically on body)
+    {
+      x1: xSide1,
+      y1: yFoldTop + C * 0.65,
+      x2: xBack,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(B),
+      orientation: "horizontal",
+      offset: -20
+    },
+    // Glue Area (kulak) — left glue flap width
+    {
+      x1: 0,
+      y1: yFoldTop + C * 0.65,
+      x2: xFront,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(kulak),
+      orientation: "horizontal",
+      offset: -20
+    }
+  ];
 }
-function normalizePoints(points, degrees) {
-  const rad = degrees * Math.PI / 180;
-  const cos = Math.cos(rad);
-  const sin = Math.sin(rad);
-  const rotated = points.map((p) => ({
-    x: p.x * cos - p.y * sin,
-    y: p.x * sin + p.y * cos
-  }));
-  let minX = Infinity, minY = Infinity;
-  for (const p of rotated) {
-    if (p.x < minX) minX = p.x;
-    if (p.y < minY) minY = p.y;
+var MODEL_ID5 = "BECF-12101";
+var UNIT_FACTOR5 = {
+  mm: 1,
+  cm: 0.1,
+  in: 1 / 25.4
+};
+var PX_PER_MM5 = 96 / 25.4;
+function renderDimension5(dim, i, fs) {
+  const { x1, y1, x2, y2, label, orientation, offset } = dim;
+  const tick = 1.5;
+  if (orientation === "horizontal") {
+    const y = y1 + offset;
+    const midX = (x1 + x2) / 2;
+    return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1, y1: y, x2, y2: y, stroke: "#000", strokeWidth: 0.2 }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1, y1: y - tick, x2: x1, y2: y + tick, stroke: "#000", strokeWidth: 0.3 }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: x2, y1: y - tick, x2, y2: y + tick, stroke: "#000", strokeWidth: 0.3 }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "text",
+        {
+          x: midX,
+          y: y - 1.5,
+          textAnchor: "middle",
+          fontSize: fs,
+          fontFamily: "sans-serif",
+          fill: "#000",
+          children: label
+        }
+      )
+    ] }, `dim-${i}`);
   }
-  return rotated.map((p) => ({ x: p.x - minX, y: p.y - minY }));
+  const x = x1 + offset;
+  const midY = (y1 + y2) / 2;
+  return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: x, y1, x2: x, y2, stroke: "#000", strokeWidth: 0.2 }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: x - tick, y1, x2: x + tick, y2: y1, stroke: "#000", strokeWidth: 0.3 }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: x - tick, y1: y2, x2: x + tick, y2, stroke: "#000", strokeWidth: 0.3 }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "text",
+      {
+        x: x - 1.5,
+        y: midY - 1,
+        textAnchor: "middle",
+        dominantBaseline: "central",
+        fontSize: fs,
+        fontFamily: "sans-serif",
+        fill: "#000",
+        transform: `rotate(-90, ${x - 1.5}, ${midY})`,
+        children: label
+      }
+    )
+  ] }, `dim-${i}`);
 }
-function computeDielineBBOffset(offsetContourPoints, dielineW, dielineH, degrees) {
-  const rad = degrees * Math.PI / 180;
-  const cos = Math.cos(rad);
-  const sin = Math.sin(rad);
-  let ocMinX = Infinity, ocMinY = Infinity;
-  for (const p of offsetContourPoints) {
-    const rx = p.x * cos - p.y * sin;
+var DIE_LINE_BECF_12101 = react.forwardRef(
+  ({
+    attributes,
+    unit = "mm",
+    isShowDimensions = false,
+    renderAs = "svg"
+  }, ref) => {
+    const theme = react.useMemo(
+      () => getModelTheme(),
+      []
+    );
+    const svgRef = react.useRef(null);
+    const dieline = react.useMemo(() => generateBecf12101(attributes), [attributes]);
+    const dimensions = react.useMemo(
+      () => generateDimensions5(attributes, unit),
+      [attributes, unit]
+    );
+    const factor = UNIT_FACTOR5[unit] ?? 1;
+    const serializeSvg = react.useCallback(
+      (showDimensions) => {
+        const svg = svgRef.current;
+        if (!svg) throw new Error("SVG not mounted");
+        const clone = svg.cloneNode(true);
+        if (!showDimensions) {
+          const dimGroup = clone.querySelector("#dimensions");
+          dimGroup?.remove();
+        }
+        return new XMLSerializer().serializeToString(clone);
+      },
+      []
+    );
+    react.useImperativeHandle(
+      ref,
+      () => {
+        const auto = getAutoCalcValues(attributes);
+        return {
+          getAttributes: () => ({
+            modelId: MODEL_ID5,
+            overallWidth: dieline.viewBox.width * factor,
+            overallHeight: dieline.viewBox.height * factor,
+            length: attributes.length * factor,
+            width: attributes.width * factor,
+            height: attributes.height * factor,
+            glueArea: auto.kulak * factor,
+            d: auto.d * factor,
+            kulak: auto.kulak * factor,
+            dip: auto.dip * factor,
+            ropeR: auto.ropeR * factor,
+            ropeY: auto.ropeY * factor,
+            ropeX: auto.ropeX * factor
+          }),
+          exportImage: async (options) => {
+            const svgStr = serializeSvg(options.isShowDimension);
+            const blob = new Blob([svgStr], {
+              type: "image/svg+xml;charset=utf-8"
+            });
+            const url = URL.createObjectURL(blob);
+            const img = new Image();
+            await new Promise((resolve, reject) => {
+              img.onload = () => resolve();
+              img.onerror = reject;
+              img.src = url;
+            });
+            const canvas = document.createElement("canvas");
+            if (options.originalSize) {
+              canvas.width = Math.round(dieline.viewBox.width * PX_PER_MM5);
+              canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM5);
+            } else {
+              canvas.width = 1920;
+              canvas.height = 1080;
+            }
+            const ctx = canvas.getContext("2d");
+            ctx.fillStyle = "#ffffff";
+            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+            URL.revokeObjectURL(url);
+            return new Promise((resolve, reject) => {
+              canvas.toBlob(
+                (b) => b ? resolve(b) : reject(new Error("Export failed")),
+                "image/png"
+              );
+            });
+          },
+          exportDimension: async () => {
+            const dimData = generateDimensions5(attributes, unit);
+            return exportDimensionPdf({
+              modelId: MODEL_ID5,
+              dieline,
+              dimensions: dimData,
+              attributes,
+              unit,
+              factor,
+              theme
+            });
+          }
+        };
+      },
+      [attributes, dieline, factor, unit, serializeSvg, theme]
+    );
+    const padding = isShowDimensions ? 15 : 0;
+    const vbX = -padding;
+    const vbY = -padding;
+    const vbW = dieline.viewBox.width + padding * 2;
+    const vbH = dieline.viewBox.height + padding * 2;
+    const svgChildren = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("g", { id: "crease", children: dieline.crease.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorFoldLine, strokeWidth: 0.5, strokeDasharray: "2,1" }, `c-${i}`)) }),
+      /* @__PURE__ */ jsxRuntime.jsx("g", { id: "cut", children: dieline.cut.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorDieLine, strokeWidth: 0.5 }, `t-${i}`)) }),
+      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map((d, i) => renderDimension5(d, i, getFontDimensionSize())) })
+    ] });
+    if (renderAs === "group") {
+      return /* @__PURE__ */ jsxRuntime.jsx("g", { children: svgChildren });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "svg",
+      {
+        ref: svgRef,
+        xmlns: "http://www.w3.org/2000/svg",
+        viewBox: `${vbX} ${vbY} ${vbW} ${vbH}`,
+        preserveAspectRatio: "xMidYMid meet",
+        style: { backgroundColor: theme.colorBackground },
+        children: svgChildren
+      }
+    );
+  }
+);
+var CANVAS_BECF_12101 = react.forwardRef(
+  (props, ref) => {
+    const dieLineRef = react.useRef(null);
+    const canvasRef = react.useRef(null);
+    const {
+      attributes
+    } = props;
+    const theme = react.useMemo(
+      () => getModelTheme(),
+      []
+    );
+    const dieline = react.useMemo(() => generateBecf12101(attributes), [attributes]);
+    const stablePadding = 15;
+    const viewBox = react.useMemo(
+      () => ({
+        x: -stablePadding,
+        y: -stablePadding,
+        width: dieline.viewBox.width + stablePadding * 2,
+        height: dieline.viewBox.height + stablePadding * 2
+      }),
+      [dieline.viewBox.width, dieline.viewBox.height]
+    );
+    const serializeCanvasSvg = react.useCallback((showDimensions) => {
+      const svg = canvasRef.current?.getSvgElement();
+      if (!svg) throw new Error("SVG not mounted");
+      const clone = svg.cloneNode(true);
+      if (!showDimensions) {
+        const dimGroup = clone.querySelector("#dimensions");
+        dimGroup?.remove();
+      }
+      return new XMLSerializer().serializeToString(clone);
+    }, []);
+    react.useImperativeHandle(ref, () => ({
+      getAttributes: () => dieLineRef.current.getAttributes(),
+      exportImage: async (options) => {
+        const svgStr = serializeCanvasSvg(options.isShowDimension);
+        const blob = new Blob([svgStr], { type: "image/svg+xml;charset=utf-8" });
+        const url = URL.createObjectURL(blob);
+        const img = new Image();
+        await new Promise((resolve, reject) => {
+          img.onload = () => resolve();
+          img.onerror = reject;
+          img.src = url;
+        });
+        const canvas = document.createElement("canvas");
+        if (options.originalSize) {
+          canvas.width = Math.round(dieline.viewBox.width * PX_PER_MM5);
+          canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM5);
+        } else {
+          canvas.width = 1920;
+          canvas.height = 1080;
+        }
+        const ctx = canvas.getContext("2d");
+        ctx.fillStyle = "#ffffff";
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+        URL.revokeObjectURL(url);
+        return new Promise((resolve, reject) => {
+          canvas.toBlob(
+            (b) => b ? resolve(b) : reject(new Error("Export failed")),
+            "image/png"
+          );
+        });
+      },
+      exportDimension: () => dieLineRef.current.exportDimension(),
+      resetView: () => canvasRef.current?.resetView(),
+      fitView: () => canvasRef.current?.fitView()
+    }), [serializeCanvasSvg, dieline.viewBox.width, dieline.viewBox.height]);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      BaseCanvas,
+      {
+        ref: canvasRef,
+        viewBox,
+        backgroundColor: theme.colorBackground,
+        children: /* @__PURE__ */ jsxRuntime.jsx(DIE_LINE_BECF_12101, { ref: dieLineRef, ...props, renderAs: "group" })
+      }
+    );
+  }
+);
+var MODEL_BECF_12101 = react.forwardRef(
+  ({ mode = "DIE_LINE", ...props }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: (() => {
+      switch (mode) {
+        case "DIE_LINE":
+          return /* @__PURE__ */ jsxRuntime.jsx(CANVAS_BECF_12101, { ref, ...props });
+        case "3D":
+          return null;
+        case "AUTO_LAYOUT":
+          return /* @__PURE__ */ jsxRuntime.jsx(DIE_LINE_BECF_12101, { ref, ...props });
+        default:
+          return null;
+      }
+    })() });
+  }
+);
+
+// src/components/dieline/bags-pillows/becf-12109/generate.ts
+var DIP2 = 13;
+var ROPE_R2 = 3;
+var ROPE_Y2 = 20;
+var D_MAX2 = 40;
+var NOTCH_X = 3;
+var NOTCH_Y = 5;
+function calcD2(c, b) {
+  return Math.min(c - 2 - b / 2, D_MAX2);
+}
+function calcKulak2(b) {
+  if (b <= 13) return b - 1;
+  if (b <= 99) return 13;
+  if (b <= 249) return 20;
+  if (b <= 499) return 25;
+  return 30;
+}
+function calcX2(a) {
+  return a / 2;
+}
+function getAutoCalcValues2(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD2(C, B);
+  const kulak = glueArea ?? calcKulak2(B);
+  const X = calcX2(A);
+  return { d: D, kulak, dip: DIP2, ropeR: ROPE_R2, ropeY: ROPE_Y2, ropeX: X };
+}
+function line6(x1, y1, x2, y2) {
+  return `M${x1} ${y1} L${x2} ${y2}`;
+}
+function circlePath2(cx, cy, r) {
+  return `M${cx - r} ${cy} A${r} ${r} 0 0 1 ${cx + r} ${cy} A${r} ${r} 0 0 1 ${cx - r} ${cy}`;
+}
+function generateBecf12109(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD2(C, B);
+  const kulak = glueArea ?? calcKulak2(B);
+  const X = calcX2(A);
+  const xFront = kulak;
+  const xSide1 = kulak + A;
+  const xSide1Mid = kulak + A + B / 2;
+  const xBack = kulak + A + B;
+  const xSide2 = kulak + 2 * A + B;
+  const xSide2Mid = kulak + 2 * A + B + B / 2;
+  const xEnd = kulak + 2 * A + 2 * B - 2;
+  const yFoldTop = D;
+  const yFoldBottomStart = D + C - B / 2;
+  const yFoldBottom = D + C;
+  const yNotchStart = yFoldBottom + NOTCH_Y;
+  const yEnd = D + C + B / 2 + DIP2;
+  const totalWidth = xEnd;
+  const totalHeight = yEnd;
+  const cut = [];
+  const crease = [];
+  cut.push(line6(0, 0, 0, yFoldBottom - kulak));
+  cut.push(line6(0, 0, totalWidth, 0));
+  cut.push(line6(totalWidth, 0, totalWidth, yFoldBottom));
+  cut.push(line6(0, yFoldBottom - kulak, kulak, yFoldBottom));
+  const boundaries = [xFront, xSide1, xBack, xSide2, xEnd];
+  for (let i = 0; i < boundaries.length; i++) {
+    const xb = boundaries[i];
+    const isFirst = i === 0;
+    const isLast = i === boundaries.length - 1;
+    if (!isFirst) {
+      cut.push(line6(xb - NOTCH_X, yNotchStart, xb - NOTCH_X, totalHeight));
+      cut.push(line6(xb - NOTCH_X, yNotchStart, xb, yFoldBottom));
+    }
+    if (!isLast) {
+      cut.push(line6(xb + NOTCH_X, yNotchStart, xb + NOTCH_X, totalHeight));
+      cut.push(line6(xb + NOTCH_X, yNotchStart, xb, yFoldBottom));
+    }
+  }
+  cut.push(line6(xFront + NOTCH_X, totalHeight, xSide1 - NOTCH_X, totalHeight));
+  cut.push(line6(xSide1 + NOTCH_X, totalHeight, xBack - NOTCH_X, totalHeight));
+  cut.push(line6(xBack + NOTCH_X, totalHeight, xSide2 - NOTCH_X, totalHeight));
+  cut.push(line6(xSide2 + NOTCH_X, totalHeight, xEnd - NOTCH_X, totalHeight));
+  const frontCx = kulak + A / 2;
+  const backCx = kulak + A + B + A / 2;
+  const ropeTopY = yFoldTop - ROPE_Y2;
+  const ropeBotY = yFoldTop + ROPE_Y2;
+  cut.push(circlePath2(frontCx - X / 2, ropeTopY, ROPE_R2));
+  cut.push(circlePath2(frontCx - X / 2, ropeBotY, ROPE_R2));
+  cut.push(circlePath2(frontCx + X / 2, ropeTopY, ROPE_R2));
+  cut.push(circlePath2(frontCx + X / 2, ropeBotY, ROPE_R2));
+  cut.push(circlePath2(backCx - X / 2, ropeTopY, ROPE_R2));
+  cut.push(circlePath2(backCx - X / 2, ropeBotY, ROPE_R2));
+  cut.push(circlePath2(backCx + X / 2, ropeTopY, ROPE_R2));
+  cut.push(circlePath2(backCx + X / 2, ropeBotY, ROPE_R2));
+  crease.push(line6(0, yFoldTop, totalWidth, yFoldTop));
+  crease.push(line6(0, yFoldBottomStart, totalWidth, yFoldBottomStart));
+  crease.push(line6(kulak, yFoldBottom, xEnd, yFoldBottom));
+  crease.push(line6(xFront, 0, xFront, yFoldBottom));
+  crease.push(line6(xSide1, 0, xSide1, yFoldBottom));
+  crease.push(line6(xBack, 0, xBack, yFoldBottom));
+  crease.push(line6(xSide2, 0, xSide2, yFoldBottom));
+  crease.push(line6(xSide1Mid, 0, xSide1Mid, totalHeight));
+  crease.push(line6(xSide2Mid, 0, xSide2Mid, totalHeight));
+  crease.push(line6(xBack, yFoldBottom, xSide1Mid, yFoldBottomStart));
+  crease.push(line6(xSide1Mid, yFoldBottomStart, xSide1, yFoldBottom));
+  crease.push(line6(xSide2Mid, yFoldBottomStart, xSide2, yFoldBottom));
+  crease.push(line6(xSide2Mid, yFoldBottomStart, xEnd, D + C - 2));
+  return { cut, crease, viewBox: { width: totalWidth, height: totalHeight } };
+}
+function generateOuterContour6(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD2(C, B);
+  const kulak = glueArea ?? calcKulak2(B);
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = D + C + B / 2 + DIP2;
+  return [
+    { x: 0, y: 0 },
+    { x: totalWidth, y: 0 },
+    { x: totalWidth, y: totalHeight },
+    { x: 0, y: totalHeight }
+  ];
+}
+function offsetContour6(points, distance) {
+  const n = points.length;
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    const prev = points[(i - 1 + n) % n];
+    const curr = points[i];
+    const next = points[(i + 1) % n];
+    const e1x = curr.x - prev.x;
+    const e1y = curr.y - prev.y;
+    const e2x = next.x - curr.x;
+    const e2y = next.y - curr.y;
+    const len1 = Math.sqrt(e1x * e1x + e1y * e1y);
+    const len2 = Math.sqrt(e2x * e2x + e2y * e2y);
+    if (len1 === 0 || len2 === 0) {
+      result.push(curr);
+      continue;
+    }
+    const n1x = e1y / len1;
+    const n1y = -e1x / len1;
+    const n2x = e2y / len2;
+    const n2y = -e2x / len2;
+    const ax = n1x + n2x;
+    const ay = n1y + n2y;
+    const aLen = Math.sqrt(ax * ax + ay * ay);
+    if (aLen < 1e-3) {
+      result.push({ x: curr.x + n1x * distance, y: curr.y + n1y * distance });
+      continue;
+    }
+    const nx = ax / aLen;
+    const ny = ay / aLen;
+    const dot = n1x * nx + n1y * ny;
+    const d = distance / Math.max(dot, 0.1);
+    result.push({ x: curr.x + nx * d, y: curr.y + ny * d });
+  }
+  return result;
+}
+function contourToPath6(points) {
+  if (points.length === 0) return "";
+  let d = `M${points[0].x} ${points[0].y}`;
+  for (let i = 1; i < points.length; i++) {
+    d += ` L${points[i].x} ${points[i].y}`;
+  }
+  d += " Z";
+  return d;
+}
+function generateDimensions6(attr, unit) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD2(C, B);
+  const kulak = glueArea ?? calcKulak2(B);
+  const factor = unit === "cm" ? 0.1 : unit === "in" ? 1 / 25.4 : 1;
+  const suffix = unit;
+  const fmt = (v) => `${(v * factor).toFixed(2)} ${suffix}`;
+  const xFront = kulak;
+  const xSide1 = kulak + A;
+  const xBack = kulak + A + B;
+  const yFoldTop = D;
+  const yFoldBottom = D + C;
+  const yEnd = D + C + B / 2 + DIP2;
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = yEnd;
+  const bottomSection = B / 2 + DIP2;
+  return [
+    // Overall dimensions (outside)
+    {
+      x1: 0,
+      y1: 0,
+      x2: totalWidth,
+      y2: 0,
+      label: `Overall Width : ${fmt(totalWidth)}`,
+      orientation: "horizontal",
+      offset: -12
+    },
+    {
+      x1: 0,
+      y1: 0,
+      x2: 0,
+      y2: totalHeight,
+      label: `Overall Height : ${fmt(totalHeight)}`,
+      orientation: "vertical",
+      offset: -12
+    },
+    // Height (C) — body area (centered on back panel)
+    {
+      x1: xBack + A * 0.6,
+      y1: yFoldTop,
+      x2: xBack + A * 0.6,
+      y2: yFoldBottom,
+      label: fmt(C),
+      orientation: "vertical",
+      offset: -10
+    },
+    // Top flap (D) (centered on back panel)
+    {
+      x1: xBack + A * 0.6,
+      y1: 0,
+      x2: xBack + A * 0.6,
+      y2: yFoldTop,
+      label: fmt(D),
+      orientation: "vertical",
+      offset: -10
+    },
+    // Bottom section (B/2 + _dip) (centered on back panel)
+    {
+      x1: xBack + A * 0.6,
+      y1: yFoldBottom,
+      x2: xBack + A * 0.6,
+      y2: yEnd,
+      label: fmt(bottomSection),
+      orientation: "vertical",
+      offset: -10
+    },
+    // Length (A) — front panel (centered vertically on body)
+    {
+      x1: xFront,
+      y1: yFoldTop + C * 0.65,
+      x2: xSide1,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(A),
+      orientation: "horizontal",
+      offset: -20
+    },
+    // Width (B) — side panel (centered vertically on body)
+    {
+      x1: xSide1,
+      y1: yFoldTop + C * 0.65,
+      x2: xBack,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(B),
+      orientation: "horizontal",
+      offset: -20
+    },
+    // Glue Area (kulak) — left glue flap width
+    {
+      x1: 0,
+      y1: yFoldTop + C * 0.65,
+      x2: xFront,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(kulak),
+      orientation: "horizontal",
+      offset: -20
+    }
+  ];
+}
+var MODEL_ID6 = "BECF-12109";
+var UNIT_FACTOR6 = {
+  mm: 1,
+  cm: 0.1,
+  in: 1 / 25.4
+};
+var PX_PER_MM6 = 96 / 25.4;
+function renderDimension6(dim, i, fs) {
+  const { x1, y1, x2, y2, label, orientation, offset } = dim;
+  const tick = 1.5;
+  if (orientation === "horizontal") {
+    const y = y1 + offset;
+    const midX = (x1 + x2) / 2;
+    return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1, y1: y, x2, y2: y, stroke: "#000", strokeWidth: 0.2 }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1, y1: y - tick, x2: x1, y2: y + tick, stroke: "#000", strokeWidth: 0.3 }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: x2, y1: y - tick, x2, y2: y + tick, stroke: "#000", strokeWidth: 0.3 }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "text",
+        {
+          x: midX,
+          y: y - 1.5,
+          textAnchor: "middle",
+          fontSize: fs,
+          fontFamily: "sans-serif",
+          fill: "#000",
+          children: label
+        }
+      )
+    ] }, `dim-${i}`);
+  }
+  const x = x1 + offset;
+  const midY = (y1 + y2) / 2;
+  return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: x, y1, x2: x, y2, stroke: "#000", strokeWidth: 0.2 }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: x - tick, y1, x2: x + tick, y2: y1, stroke: "#000", strokeWidth: 0.3 }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: x - tick, y1: y2, x2: x + tick, y2, stroke: "#000", strokeWidth: 0.3 }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "text",
+      {
+        x: x - 1.5,
+        y: midY - 1,
+        textAnchor: "middle",
+        dominantBaseline: "central",
+        fontSize: fs,
+        fontFamily: "sans-serif",
+        fill: "#000",
+        transform: `rotate(-90, ${x - 1.5}, ${midY})`,
+        children: label
+      }
+    )
+  ] }, `dim-${i}`);
+}
+var DIE_LINE_BECF_12109 = react.forwardRef(
+  ({
+    attributes,
+    unit = "mm",
+    isShowDimensions = false,
+    renderAs = "svg"
+  }, ref) => {
+    const theme = react.useMemo(
+      () => getModelTheme(),
+      []
+    );
+    const svgRef = react.useRef(null);
+    const dieline = react.useMemo(() => generateBecf12109(attributes), [attributes]);
+    const dimensions = react.useMemo(
+      () => generateDimensions6(attributes, unit),
+      [attributes, unit]
+    );
+    const factor = UNIT_FACTOR6[unit] ?? 1;
+    const serializeSvg = react.useCallback(
+      (showDimensions) => {
+        const svg = svgRef.current;
+        if (!svg) throw new Error("SVG not mounted");
+        const clone = svg.cloneNode(true);
+        if (!showDimensions) {
+          const dimGroup = clone.querySelector("#dimensions");
+          dimGroup?.remove();
+        }
+        return new XMLSerializer().serializeToString(clone);
+      },
+      []
+    );
+    react.useImperativeHandle(
+      ref,
+      () => {
+        const auto = getAutoCalcValues2(attributes);
+        return {
+          getAttributes: () => ({
+            modelId: MODEL_ID6,
+            overallWidth: dieline.viewBox.width * factor,
+            overallHeight: dieline.viewBox.height * factor,
+            length: attributes.length * factor,
+            width: attributes.width * factor,
+            height: attributes.height * factor,
+            glueArea: auto.kulak * factor,
+            d: auto.d * factor,
+            kulak: auto.kulak * factor,
+            dip: auto.dip * factor,
+            ropeR: auto.ropeR * factor,
+            ropeY: auto.ropeY * factor,
+            ropeX: auto.ropeX * factor
+          }),
+          exportImage: async (options) => {
+            const svgStr = serializeSvg(options.isShowDimension);
+            const blob = new Blob([svgStr], {
+              type: "image/svg+xml;charset=utf-8"
+            });
+            const url = URL.createObjectURL(blob);
+            const img = new Image();
+            await new Promise((resolve, reject) => {
+              img.onload = () => resolve();
+              img.onerror = reject;
+              img.src = url;
+            });
+            const canvas = document.createElement("canvas");
+            if (options.originalSize) {
+              canvas.width = Math.round(dieline.viewBox.width * PX_PER_MM6);
+              canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM6);
+            } else {
+              canvas.width = 1920;
+              canvas.height = 1080;
+            }
+            const ctx = canvas.getContext("2d");
+            ctx.fillStyle = "#ffffff";
+            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+            URL.revokeObjectURL(url);
+            return new Promise((resolve, reject) => {
+              canvas.toBlob(
+                (b) => b ? resolve(b) : reject(new Error("Export failed")),
+                "image/png"
+              );
+            });
+          },
+          exportDimension: async () => {
+            const dimData = generateDimensions6(attributes, unit);
+            return exportDimensionPdf({
+              modelId: MODEL_ID6,
+              dieline,
+              dimensions: dimData,
+              attributes,
+              unit,
+              factor,
+              theme
+            });
+          }
+        };
+      },
+      [attributes, dieline, factor, unit, serializeSvg, theme]
+    );
+    const padding = isShowDimensions ? 15 : 0;
+    const vbX = -padding;
+    const vbY = -padding;
+    const vbW = dieline.viewBox.width + padding * 2;
+    const vbH = dieline.viewBox.height + padding * 2;
+    const svgChildren = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("g", { id: "crease", children: dieline.crease.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorFoldLine, strokeWidth: 0.5, strokeDasharray: "2,1" }, `c-${i}`)) }),
+      /* @__PURE__ */ jsxRuntime.jsx("g", { id: "cut", children: dieline.cut.map((d, i) => /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: "none", stroke: theme.colorDieLine, strokeWidth: 0.5 }, `t-${i}`)) }),
+      isShowDimensions && /* @__PURE__ */ jsxRuntime.jsx("g", { id: "dimensions", children: dimensions.map((d, i) => renderDimension6(d, i, getFontDimensionSize())) })
+    ] });
+    if (renderAs === "group") {
+      return /* @__PURE__ */ jsxRuntime.jsx("g", { children: svgChildren });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "svg",
+      {
+        ref: svgRef,
+        xmlns: "http://www.w3.org/2000/svg",
+        viewBox: `${vbX} ${vbY} ${vbW} ${vbH}`,
+        preserveAspectRatio: "xMidYMid meet",
+        style: { backgroundColor: theme.colorBackground },
+        children: svgChildren
+      }
+    );
+  }
+);
+var CANVAS_BECF_12109 = react.forwardRef(
+  (props, ref) => {
+    const dieLineRef = react.useRef(null);
+    const canvasRef = react.useRef(null);
+    const {
+      attributes
+    } = props;
+    const theme = react.useMemo(
+      () => getModelTheme(),
+      []
+    );
+    const dieline = react.useMemo(() => generateBecf12109(attributes), [attributes]);
+    const stablePadding = 15;
+    const viewBox = react.useMemo(
+      () => ({
+        x: -stablePadding,
+        y: -stablePadding,
+        width: dieline.viewBox.width + stablePadding * 2,
+        height: dieline.viewBox.height + stablePadding * 2
+      }),
+      [dieline.viewBox.width, dieline.viewBox.height]
+    );
+    const serializeCanvasSvg = react.useCallback((showDimensions) => {
+      const svg = canvasRef.current?.getSvgElement();
+      if (!svg) throw new Error("SVG not mounted");
+      const clone = svg.cloneNode(true);
+      if (!showDimensions) {
+        const dimGroup = clone.querySelector("#dimensions");
+        dimGroup?.remove();
+      }
+      return new XMLSerializer().serializeToString(clone);
+    }, []);
+    react.useImperativeHandle(ref, () => ({
+      getAttributes: () => dieLineRef.current.getAttributes(),
+      exportImage: async (options) => {
+        const svgStr = serializeCanvasSvg(options.isShowDimension);
+        const blob = new Blob([svgStr], { type: "image/svg+xml;charset=utf-8" });
+        const url = URL.createObjectURL(blob);
+        const img = new Image();
+        await new Promise((resolve, reject) => {
+          img.onload = () => resolve();
+          img.onerror = reject;
+          img.src = url;
+        });
+        const canvas = document.createElement("canvas");
+        if (options.originalSize) {
+          canvas.width = Math.round(dieline.viewBox.width * PX_PER_MM6);
+          canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM6);
+        } else {
+          canvas.width = 1920;
+          canvas.height = 1080;
+        }
+        const ctx = canvas.getContext("2d");
+        ctx.fillStyle = "#ffffff";
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+        URL.revokeObjectURL(url);
+        return new Promise((resolve, reject) => {
+          canvas.toBlob(
+            (b) => b ? resolve(b) : reject(new Error("Export failed")),
+            "image/png"
+          );
+        });
+      },
+      exportDimension: () => dieLineRef.current.exportDimension(),
+      resetView: () => canvasRef.current?.resetView(),
+      fitView: () => canvasRef.current?.fitView()
+    }), [serializeCanvasSvg, dieline.viewBox.width, dieline.viewBox.height]);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      BaseCanvas,
+      {
+        ref: canvasRef,
+        viewBox,
+        backgroundColor: theme.colorBackground,
+        children: /* @__PURE__ */ jsxRuntime.jsx(DIE_LINE_BECF_12109, { ref: dieLineRef, ...props, renderAs: "group" })
+      }
+    );
+  }
+);
+var MODEL_BECF_12109 = react.forwardRef(
+  ({ mode = "DIE_LINE", ...props }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: (() => {
+      switch (mode) {
+        case "DIE_LINE":
+          return /* @__PURE__ */ jsxRuntime.jsx(CANVAS_BECF_12109, { ref, ...props });
+        case "3D":
+          return null;
+        case "AUTO_LAYOUT":
+          return /* @__PURE__ */ jsxRuntime.jsx(DIE_LINE_BECF_12109, { ref, ...props });
+        default:
+          return null;
+      }
+    })() });
+  }
+);
+
+// src/utils/autoLayout/rasterize.ts
+function rasterizePolygon(points, resolution) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of points) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  const offsetX = Math.floor(minX / resolution);
+  const offsetY = Math.floor(minY / resolution);
+  const w = Math.ceil((maxX - offsetX * resolution) / resolution) + 1;
+  const h = Math.ceil((maxY - offsetY * resolution) / resolution) + 1;
+  const data = new Uint8Array(w * h);
+  for (let gy = 0; gy < h; gy++) {
+    const worldY = (offsetY + gy) * resolution + resolution / 2;
+    const crossings = [];
+    for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+      const yi = points[i].y, yj = points[j].y;
+      if (yi <= worldY && yj > worldY || yj <= worldY && yi > worldY) {
+        const t = (worldY - yi) / (yj - yi);
+        crossings.push(points[i].x + t * (points[j].x - points[i].x));
+      }
+    }
+    crossings.sort((a, b) => a - b);
+    for (let c = 0; c < crossings.length - 1; c += 2) {
+      const startGx = Math.max(0, Math.floor((crossings[c] - offsetX * resolution) / resolution));
+      const endGx = Math.min(w - 1, Math.ceil((crossings[c + 1] - offsetX * resolution) / resolution));
+      for (let gx = startGx; gx <= endGx; gx++) {
+        data[gy * w + gx] = 1;
+      }
+    }
+  }
+  return { data, width: w, height: h, offsetX, offsetY };
+}
+function canPlace(paperGrid, paperW, paperH, piece, px, py) {
+  for (let y = 0; y < piece.height; y++) {
+    const paperY = py + y;
+    if (paperY < 0 || paperY >= paperH) {
+      for (let x = 0; x < piece.width; x++) {
+        if (piece.data[y * piece.width + x]) return false;
+      }
+      continue;
+    }
+    for (let x = 0; x < piece.width; x++) {
+      if (!piece.data[y * piece.width + x]) continue;
+      const paperX = px + x;
+      if (paperX < 0 || paperX >= paperW) return false;
+      if (paperGrid[paperY * paperW + paperX]) return false;
+    }
+  }
+  return true;
+}
+function placePiece(paperGrid, paperW, piece, px, py) {
+  for (let y = 0; y < piece.height; y++) {
+    for (let x = 0; x < piece.width; x++) {
+      if (piece.data[y * piece.width + x]) {
+        paperGrid[(py + y) * paperW + (px + x)] = 1;
+      }
+    }
+  }
+}
+
+// src/utils/autoLayout/calculate/shared.ts
+var RESOLUTION = 1;
+function resolveGripperSide(paperWidth, paperHeight) {
+  if (paperWidth >= paperHeight) return "bottom";
+  return "left";
+}
+function computeUsableBounds(paperWidth, paperHeight, gripperSide, spacing, griper, colorbarDepth) {
+  switch (gripperSide) {
+    case "bottom":
+      return {
+        top: colorbarDepth + spacing,
+        bottom: paperHeight - griper,
+        left: spacing,
+        right: paperWidth - spacing
+      };
+    case "top":
+      return {
+        top: griper,
+        bottom: paperHeight - colorbarDepth - spacing,
+        left: spacing,
+        right: paperWidth - spacing
+      };
+    case "left":
+      return {
+        top: spacing,
+        bottom: paperHeight - spacing,
+        left: griper,
+        right: paperWidth - colorbarDepth - spacing
+      };
+    case "right":
+      return {
+        top: spacing,
+        bottom: paperHeight - spacing,
+        left: colorbarDepth + spacing,
+        right: paperWidth - griper
+      };
+  }
+}
+function normalizePoints(points, degrees) {
+  const rad = degrees * Math.PI / 180;
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  const rotated = points.map((p) => ({
+    x: p.x * cos - p.y * sin,
+    y: p.x * sin + p.y * cos
+  }));
+  let minX = Infinity, minY = Infinity;
+  for (const p of rotated) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+  }
+  return rotated.map((p) => ({ x: p.x - minX, y: p.y - minY }));
+}
+function computeDielineBBOffset(offsetContourPoints, dielineW, dielineH, degrees) {
+  const rad = degrees * Math.PI / 180;
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  let ocMinX = Infinity, ocMinY = Infinity;
+  for (const p of offsetContourPoints) {
+    const rx = p.x * cos - p.y * sin;
     const ry = p.x * sin + p.y * cos;
     if (rx < ocMinX) ocMinX = rx;
     if (ry < ocMinY) ocMinY = ry;
   }
-  const corners = [[0, 0], [dielineW, 0], [0, dielineH], [dielineW, dielineH]];
-  let dlMinX = Infinity, dlMinY = Infinity;
-  for (const [cx, cy] of corners) {
-    const rx = cx * cos - cy * sin;
-    const ry = cx * sin + cy * cos;
-    if (rx < dlMinX) dlMinX = rx;
-    if (ry < dlMinY) dlMinY = ry;
+  const corners = [[0, 0], [dielineW, 0], [0, dielineH], [dielineW, dielineH]];
+  let dlMinX = Infinity, dlMinY = Infinity;
+  for (const [cx, cy] of corners) {
+    const rx = cx * cos - cy * sin;
+    const ry = cx * sin + cy * cos;
+    if (rx < dlMinX) dlMinX = rx;
+    if (ry < dlMinY) dlMinY = ry;
+  }
+  return { dx: dlMinX - ocMinX, dy: dlMinY - ocMinY };
+}
+function computeLayoutForPaperDefault(contourPoints, dielineW, dielineH, paperWidth, paperHeight, bounds) {
+  const usableLeft = Math.ceil(bounds.left / RESOLUTION);
+  const usableTop = Math.ceil(bounds.top / RESOLUTION);
+  const usableRight = Math.floor(bounds.right / RESOLUTION);
+  const usableBottom = Math.floor(bounds.bottom / RESOLUTION);
+  const paperW = Math.floor(paperWidth / RESOLUTION);
+  const paperH = Math.floor(paperHeight / RESOLUTION);
+  let bestCandidate = { rotation: 0, placements: [], producedPerSheet: 0 };
+  let bestGridPositions = [];
+  let bestBitmapW = 0;
+  let bestBitmapH = 0;
+  for (const deg of [0, 90, 180, 270]) {
+    const rotatedContour = normalizePoints(contourPoints, deg);
+    const pieceBitmap = rasterizePolygon(rotatedContour, RESOLUTION);
+    const bbOffset = computeDielineBBOffset(contourPoints, dielineW, dielineH, deg);
+    const paperGrid = new Uint8Array(paperW * paperH);
+    const placements = [];
+    const gridPositions = [];
+    for (let py = usableTop; py <= usableBottom - pieceBitmap.height; py++) {
+      for (let px = usableLeft; px <= usableRight - pieceBitmap.width; px++) {
+        if (canPlace(paperGrid, paperW, paperH, pieceBitmap, px, py)) {
+          placePiece(paperGrid, paperW, pieceBitmap, px, py);
+          gridPositions.push({ px, py });
+          placements.push({
+            x: px * RESOLUTION + bbOffset.dx,
+            y: py * RESOLUTION + bbOffset.dy,
+            rotation: deg
+          });
+        }
+      }
+    }
+    if (placements.length > bestCandidate.producedPerSheet) {
+      bestCandidate = { rotation: deg, placements, producedPerSheet: placements.length };
+      bestGridPositions = gridPositions;
+      bestBitmapW = pieceBitmap.width;
+      bestBitmapH = pieceBitmap.height;
+    }
+  }
+  if (bestCandidate.placements.length > 0) {
+    let gridMinX = Infinity;
+    let gridMinY = Infinity;
+    let gridMaxX = -Infinity;
+    let gridMaxY = -Infinity;
+    for (const { px, py } of bestGridPositions) {
+      if (px < gridMinX) gridMinX = px;
+      if (py < gridMinY) gridMinY = py;
+      if (px + bestBitmapW > gridMaxX) gridMaxX = px + bestBitmapW;
+      if (py + bestBitmapH > gridMaxY) gridMaxY = py + bestBitmapH;
+    }
+    const groupW = gridMaxX - gridMinX;
+    const groupH = gridMaxY - gridMinY;
+    const usableW = usableRight - usableLeft;
+    const usableH = usableBottom - usableTop;
+    const offsetX = ((usableW - groupW) / 2 - (gridMinX - usableLeft)) * RESOLUTION;
+    const offsetY = ((usableH - groupH) / 2 - (gridMinY - usableTop)) * RESOLUTION;
+    for (const p of bestCandidate.placements) {
+      p.x += offsetX;
+      p.y += offsetY;
+    }
+  }
+  return bestCandidate;
+}
+
+// src/utils/autoLayout/calculate/tuck-end-boxes/becf-1010a/index.ts
+var SAMPLE_STEP = 0.1;
+function buildProfile(points) {
+  let maxX = 0, maxY = 0;
+  for (const p of points) {
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  const width = maxX, height = maxY;
+  const nY = Math.ceil(height / SAMPLE_STEP) + 1;
+  const nX = Math.ceil(width / SAMPLE_STEP) + 1;
+  const rightX = new Float64Array(nY).fill(-Infinity);
+  const leftX = new Float64Array(nY).fill(Infinity);
+  const bottomY = new Float64Array(nX).fill(-Infinity);
+  const topY = new Float64Array(nX).fill(Infinity);
+  const nPts = points.length;
+  for (let iy = 0; iy < nY; iy++) {
+    const y = iy * SAMPLE_STEP;
+    for (let j = 0, k = nPts - 1; j < nPts; k = j++) {
+      const yj = points[j].y, yk = points[k].y;
+      if (yj <= y && yk > y || yk <= y && yj > y) {
+        const t = (y - yj) / (yk - yj);
+        const x = points[j].x + t * (points[k].x - points[j].x);
+        if (x > rightX[iy]) rightX[iy] = x;
+        if (x < leftX[iy]) leftX[iy] = x;
+      }
+    }
+  }
+  for (let ix = 0; ix < nX; ix++) {
+    const x = ix * SAMPLE_STEP;
+    for (let j = 0, k = nPts - 1; j < nPts; k = j++) {
+      const xj = points[j].x, xk = points[k].x;
+      if (xj <= x && xk > x || xk <= x && xj > x) {
+        const t = (x - xj) / (xk - xj);
+        const y = points[j].y + t * (points[k].y - points[j].y);
+        if (y > bottomY[ix]) bottomY[ix] = y;
+        if (y < topY[ix]) topY[ix] = y;
+      }
+    }
+  }
+  return { width, height, nY, nX, rightX, leftX, bottomY, topY };
+}
+function prepareRotation(contourPoints, dielineW, dielineH, deg) {
+  const rotated = normalizePoints(contourPoints, deg);
+  return {
+    profile: buildProfile(rotated),
+    bbOffset: computeDielineBBOffset(contourPoints, dielineW, dielineH, deg),
+    deg
+  };
+}
+function findMinStepX(a, b, dyMm) {
+  const dySamples = Math.round(dyMm / SAMPLE_STEP);
+  let maxOverlap = -Infinity;
+  for (let ia = 0; ia < a.nY; ia++) {
+    const ib = ia - dySamples;
+    if (ib < 0 || ib >= b.nY) continue;
+    if (a.rightX[ia] === -Infinity || b.leftX[ib] === Infinity) continue;
+    const overlap = a.rightX[ia] - b.leftX[ib];
+    if (overlap > maxOverlap) maxOverlap = overlap;
+  }
+  return maxOverlap <= -Infinity ? 0 : maxOverlap;
+}
+function findMinStepY(a, b, dxMm) {
+  const dxSamples = Math.round(dxMm / SAMPLE_STEP);
+  let maxOverlap = -Infinity;
+  for (let ia = 0; ia < a.nX; ia++) {
+    const ib = ia - dxSamples;
+    if (ib < 0 || ib >= b.nX) continue;
+    if (a.bottomY[ia] === -Infinity || b.topY[ib] === Infinity) continue;
+    const overlap = a.bottomY[ia] - b.topY[ib];
+    if (overlap > maxOverlap) maxOverlap = overlap;
+  }
+  return maxOverlap <= -Infinity ? 0 : maxOverlap;
+}
+function findMinStepY_multi(profA, stepX_A, profB, offsetX) {
+  const reach = Math.max(profA.width, profB.width);
+  let maxStep = 0;
+  const nMin = Math.floor((offsetX - reach) / stepX_A);
+  const nMax = Math.ceil((offsetX + reach) / stepX_A);
+  for (let n = nMin; n <= nMax; n++) {
+    const s = findMinStepY(profA, profB, offsetX - n * stepX_A);
+    if (s > maxStep) maxStep = s;
+  }
+  return maxStep;
+}
+function emptyResult() {
+  return { placements: [], count: 0, minX: 0, minY: 0, maxX: 0, maxY: 0 };
+}
+function singleRotGrid(rd, bounds) {
+  const p = rd.profile;
+  const stepX = findMinStepX(p, p, 0);
+  const stepY = findMinStepY(p, p, 0);
+  if (stepX <= 0 || stepY <= 0) return emptyResult();
+  const cols = Math.max(0, Math.floor((bounds.right - bounds.left - p.width) / stepX) + 1);
+  const rows = Math.max(0, Math.floor((bounds.bottom - bounds.top - p.height) / stepY) + 1);
+  if (cols === 0 || rows === 0) return emptyResult();
+  const placements = [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const ox = bounds.left + c * stepX;
+      const oy = bounds.top + r * stepY;
+      placements.push({ x: ox + rd.bbOffset.dx, y: oy + rd.bbOffset.dy, rotation: rd.deg });
+      if (ox < minX) minX = ox;
+      if (oy < minY) minY = oy;
+      if (ox + p.width > maxX) maxX = ox + p.width;
+      if (oy + p.height > maxY) maxY = oy + p.height;
+    }
+  }
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
+}
+function dualRotGrid(rdA, rdB, offsetX, bounds) {
+  const pA = rdA.profile, pB = rdB.profile;
+  const stepX_A = findMinStepX(pA, pA, 0);
+  const stepX_B = findMinStepX(pB, pB, 0);
+  if (stepX_A <= 0 || stepX_B <= 0) return emptyResult();
+  const stepY_AB = findMinStepY_multi(pA, stepX_A, pB, offsetX);
+  const stepY_BA = findMinStepY_multi(pB, stepX_B, pA, -offsetX);
+  if (stepY_AB + stepY_BA <= 0) return emptyResult();
+  const placements = [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let oy = bounds.top;
+  let isRowA = true;
+  while (true) {
+    const rd = isRowA ? rdA : rdB;
+    const p = rd.profile;
+    const stepX = isRowA ? stepX_A : stepX_B;
+    if (oy + p.height > bounds.bottom) break;
+    let sx = isRowA ? bounds.left : bounds.left + offsetX;
+    if (sx < bounds.left) sx += stepX * Math.ceil((bounds.left - sx) / stepX);
+    for (let ox = sx; ox + p.width <= bounds.right; ox += stepX) {
+      placements.push({ x: ox + rd.bbOffset.dx, y: oy + rd.bbOffset.dy, rotation: rd.deg });
+      if (ox < minX) minX = ox;
+      if (oy < minY) minY = oy;
+      if (ox + p.width > maxX) maxX = ox + p.width;
+      if (oy + p.height > maxY) maxY = oy + p.height;
+    }
+    oy += isRowA ? stepY_AB : stepY_BA;
+    isRowA = !isRowA;
+  }
+  if (placements.length === 0) return emptyResult();
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
+}
+function centerLayout(result, bounds) {
+  if (result.count === 0) return;
+  const offX = (bounds.right - bounds.left - (result.maxX - result.minX)) / 2 - (result.minX - bounds.left);
+  const offY = (bounds.bottom - bounds.top - (result.maxY - result.minY)) / 2 - (result.minY - bounds.top);
+  for (const p of result.placements) {
+    p.x += offX;
+    p.y += offY;
+  }
+}
+function computeLayoutForPaper(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+  const rots = [0, 90, 180, 270];
+  const rd = /* @__PURE__ */ new Map();
+  for (const deg of rots) {
+    rd.set(deg, prepareRotation(contourPoints, dielineW, dielineH, deg));
+  }
+  const results = [];
+  for (const deg of rots) {
+    results.push(singleRotGrid(rd.get(deg), bounds));
+  }
+  const pairs = [
+    [0, 180],
+    [90, 270],
+    [0, 90],
+    [0, 270],
+    [90, 180],
+    [180, 270]
+  ];
+  for (const [a, b] of pairs) {
+    const rdA = rd.get(a), rdB = rd.get(b);
+    const stepA = findMinStepX(rdA.profile, rdA.profile, 0);
+    if (stepA <= 0) continue;
+    for (let off = 0; off < stepA; off += 1) {
+      results.push(dualRotGrid(rdA, rdB, off, bounds));
+      results.push(dualRotGrid(rdB, rdA, off, bounds));
+    }
+  }
+  let best = results[0];
+  for (const r of results) {
+    if (r.count > best.count) best = r;
+  }
+  centerLayout(best, bounds);
+  return {
+    rotation: best.placements[0]?.rotation ?? 0,
+    placements: best.placements,
+    producedPerSheet: best.count
+  };
+}
+
+// src/utils/autoLayout/calculate/tuck-end-boxes/becf-1030a/index.ts
+function prepareRotation2(contourPoints, dielineW, dielineH, deg) {
+  const rotated = normalizePoints(contourPoints, deg);
+  return {
+    profile: buildProfile(rotated),
+    bbOffset: computeDielineBBOffset(contourPoints, dielineW, dielineH, deg),
+    deg
+  };
+}
+function pairGrid(rdA, rdB, bounds) {
+  const pA = rdA.profile, pB = rdB.profile;
+  const gapAB = findMinStepX(pA, pB, 0);
+  if (gapAB <= 0) return emptyResult();
+  const pairW = gapAB + pB.width;
+  const pairH = Math.max(pA.height, pB.height);
+  const pairStepX = gapAB + findMinStepX(pB, pA, 0);
+  const pairStepY = Math.max(
+    findMinStepY(pA, pA, 0),
+    findMinStepY(pA, pB, gapAB),
+    findMinStepY(pB, pA, -gapAB),
+    findMinStepY(pB, pB, 0)
+  );
+  if (pairStepX <= 0 || pairStepY <= 0) return emptyResult();
+  const usableW = bounds.right - bounds.left;
+  const usableH = bounds.bottom - bounds.top;
+  const pairCols = Math.max(0, Math.floor((usableW - pairW) / pairStepX) + 1);
+  const pairRows = Math.max(0, Math.floor((usableH - pairH) / pairStepY) + 1);
+  if (pairCols === 0 || pairRows === 0) return emptyResult();
+  const placements = [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let r = 0; r < pairRows; r++) {
+    for (let c = 0; c < pairCols; c++) {
+      const baseX = bounds.left + c * pairStepX;
+      const baseY = bounds.top + r * pairStepY;
+      const oxA = baseX;
+      const oyA = baseY;
+      placements.push({ x: oxA + rdA.bbOffset.dx, y: oyA + rdA.bbOffset.dy, rotation: rdA.deg });
+      if (oxA < minX) minX = oxA;
+      if (oyA < minY) minY = oyA;
+      if (oxA + pA.width > maxX) maxX = oxA + pA.width;
+      if (oyA + pA.height > maxY) maxY = oyA + pA.height;
+      const oxB = baseX + gapAB;
+      const oyB = baseY;
+      placements.push({ x: oxB + rdB.bbOffset.dx, y: oyB + rdB.bbOffset.dy, rotation: rdB.deg });
+      if (oxB < minX) minX = oxB;
+      if (oyB < minY) minY = oyB;
+      if (oxB + pB.width > maxX) maxX = oxB + pB.width;
+      if (oyB + pB.height > maxY) maxY = oyB + pB.height;
+    }
   }
-  return { dx: dlMinX - ocMinX, dy: dlMinY - ocMinY };
-}
-function computeLayoutForPaperDefault(contourPoints, dielineW, dielineH, paperWidth, paperHeight, bounds) {
-  const usableLeft = Math.ceil(bounds.left / RESOLUTION);
-  const usableTop = Math.ceil(bounds.top / RESOLUTION);
-  const usableRight = Math.floor(bounds.right / RESOLUTION);
-  const usableBottom = Math.floor(bounds.bottom / RESOLUTION);
-  const paperW = Math.floor(paperWidth / RESOLUTION);
-  const paperH = Math.floor(paperHeight / RESOLUTION);
-  let bestCandidate = { rotation: 0, placements: [], producedPerSheet: 0 };
-  let bestGridPositions = [];
-  let bestBitmapW = 0;
-  let bestBitmapH = 0;
-  for (const deg of [0, 90, 180, 270]) {
-    const rotatedContour = normalizePoints(contourPoints, deg);
-    const pieceBitmap = rasterizePolygon(rotatedContour, RESOLUTION);
-    const bbOffset = computeDielineBBOffset(contourPoints, dielineW, dielineH, deg);
-    const paperGrid = new Uint8Array(paperW * paperH);
-    const placements = [];
-    const gridPositions = [];
-    for (let py = usableTop; py <= usableBottom - pieceBitmap.height; py++) {
-      for (let px = usableLeft; px <= usableRight - pieceBitmap.width; px++) {
-        if (canPlace(paperGrid, paperW, paperH, pieceBitmap, px, py)) {
-          placePiece(paperGrid, paperW, pieceBitmap, px, py);
-          gridPositions.push({ px, py });
-          placements.push({
-            x: px * RESOLUTION + bbOffset.dx,
-            y: py * RESOLUTION + bbOffset.dy,
-            rotation: deg
-          });
+  const pairsRightEdge = bounds.left + (pairCols - 1) * pairStepX + pairW;
+  const pairsBottomEdge = bounds.top + (pairRows - 1) * pairStepY + pairH;
+  const gapRight = bounds.right - pairsRightEdge;
+  const gapBottom = bounds.bottom - pairsBottomEdge;
+  const extraRotations = [rdA, rdB];
+  for (const rdExtra of extraRotations) {
+    const pe = rdExtra.profile;
+    if (pe.width <= gapRight) {
+      for (let r = 0; r < pairRows; r++) {
+        const ox = pairsRightEdge;
+        const oy = bounds.top + r * pairStepY;
+        if (ox + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
+          placements.push({ x: ox + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
+          if (ox + pe.width > maxX) maxX = ox + pe.width;
         }
       }
+      break;
     }
-    if (placements.length > bestCandidate.producedPerSheet) {
-      bestCandidate = { rotation: deg, placements, producedPerSheet: placements.length };
-      bestGridPositions = gridPositions;
-      bestBitmapW = pieceBitmap.width;
-      bestBitmapH = pieceBitmap.height;
+  }
+  for (const rdExtra of extraRotations) {
+    const pe = rdExtra.profile;
+    if (pe.height <= gapBottom) {
+      for (let c = 0; c < pairCols; c++) {
+        const oxA = bounds.left + c * pairStepX;
+        const oy = pairsBottomEdge;
+        if (oxA + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
+          placements.push({ x: oxA + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
+          if (oy + pe.height > maxY) maxY = oy + pe.height;
+        }
+      }
+      break;
     }
   }
-  if (bestCandidate.placements.length > 0) {
-    let gridMinX = Infinity;
-    let gridMinY = Infinity;
-    let gridMaxX = -Infinity;
-    let gridMaxY = -Infinity;
-    for (const { px, py } of bestGridPositions) {
-      if (px < gridMinX) gridMinX = px;
-      if (py < gridMinY) gridMinY = py;
-      if (px + bestBitmapW > gridMaxX) gridMaxX = px + bestBitmapW;
-      if (py + bestBitmapH > gridMaxY) gridMaxY = py + bestBitmapH;
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
+}
+function computeLayoutForPaper2(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+  const rots = [0, 90, 180, 270];
+  const rd = /* @__PURE__ */ new Map();
+  for (const deg of rots) {
+    rd.set(deg, prepareRotation2(contourPoints, dielineW, dielineH, deg));
+  }
+  const results = [];
+  for (const deg of rots) {
+    results.push(singleRotGrid(rd.get(deg), bounds));
+  }
+  const allPairs = [
+    [0, 180],
+    [90, 270],
+    [0, 90],
+    [0, 270],
+    [90, 180],
+    [180, 270]
+  ];
+  for (const [a, b] of allPairs) {
+    const rdA = rd.get(a), rdB = rd.get(b);
+    const stepA = findMinStepX(rdA.profile, rdA.profile, 0);
+    if (stepA <= 0) continue;
+    for (let off = 0; off < stepA; off += 1) {
+      results.push(dualRotGrid(rdA, rdB, off, bounds));
+      results.push(dualRotGrid(rdB, rdA, off, bounds));
     }
-    const groupW = gridMaxX - gridMinX;
-    const groupH = gridMaxY - gridMinY;
-    const usableW = usableRight - usableLeft;
-    const usableH = usableBottom - usableTop;
-    const offsetX = ((usableW - groupW) / 2 - (gridMinX - usableLeft)) * RESOLUTION;
-    const offsetY = ((usableH - groupH) / 2 - (gridMinY - usableTop)) * RESOLUTION;
-    for (const p of bestCandidate.placements) {
-      p.x += offsetX;
-      p.y += offsetY;
+  }
+  for (const [a, b] of allPairs) {
+    results.push(pairGrid(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid(rd.get(b), rd.get(a), bounds));
+  }
+  const singleResults = [];
+  const multiResults = [];
+  for (const r of results) {
+    if (r.count === 0) continue;
+    const rotations = new Set(r.placements.map((p) => p.rotation));
+    if (rotations.size > 1) {
+      multiResults.push(r);
+    } else {
+      singleResults.push(r);
     }
   }
-  return bestCandidate;
+  function pickBest(arr) {
+    let b = arr[0] ?? emptyResult();
+    let bArea = (b.maxX - b.minX) * (b.maxY - b.minY);
+    for (const r of arr) {
+      const area = (r.maxX - r.minX) * (r.maxY - r.minY);
+      if (r.count > b.count || r.count === b.count && area < bArea) {
+        b = r;
+        bArea = area;
+      }
+    }
+    return b;
+  }
+  const bestSingle = pickBest(singleResults);
+  const bestMulti = pickBest(multiResults);
+  const best = bestMulti.count >= bestSingle.count && bestMulti.count > 0 ? bestMulti : bestSingle;
+  centerLayout(best, bounds);
+  return {
+    rotation: best.placements[0]?.rotation ?? 0,
+    placements: best.placements,
+    producedPerSheet: best.count
+  };
 }
 
-// src/utils/autoLayout/calculate/tuck-end-boxes/becf-1010a/index.ts
-var SAMPLE_STEP = 0.1;
-function buildProfile(points) {
-  let maxX = 0, maxY = 0;
-  for (const p of points) {
-    if (p.x > maxX) maxX = p.x;
-    if (p.y > maxY) maxY = p.y;
+// src/utils/autoLayout/calculate/tuck-end-boxes/becf-1040a/index.ts
+function prepareRotation3(contourPoints, dielineW, dielineH, deg) {
+  const rotated = normalizePoints(contourPoints, deg);
+  return {
+    profile: buildProfile(rotated),
+    bbOffset: computeDielineBBOffset(contourPoints, dielineW, dielineH, deg),
+    deg
+  };
+}
+function findPairRowStepY(pA, pB, gapAB, pairStepX) {
+  const reach = Math.max(pA.width, pB.width) + Math.abs(gapAB);
+  const nMin = Math.floor(-reach / pairStepX) - 1;
+  const nMax = Math.ceil(reach / pairStepX) + 1;
+  let maxStep = 0;
+  for (let n = nMin; n <= nMax; n++) {
+    const dx = n * pairStepX;
+    const s1 = findMinStepY(pA, pA, dx);
+    if (s1 > maxStep) maxStep = s1;
+    const s2 = findMinStepY(pA, pB, dx + gapAB);
+    if (s2 > maxStep) maxStep = s2;
+    const s3 = findMinStepY(pB, pA, dx - gapAB);
+    if (s3 > maxStep) maxStep = s3;
+    const s4 = findMinStepY(pB, pB, dx);
+    if (s4 > maxStep) maxStep = s4;
   }
-  const width = maxX, height = maxY;
-  const nY = Math.ceil(height / SAMPLE_STEP) + 1;
-  const nX = Math.ceil(width / SAMPLE_STEP) + 1;
-  const rightX = new Float64Array(nY).fill(-Infinity);
-  const leftX = new Float64Array(nY).fill(Infinity);
-  const bottomY = new Float64Array(nX).fill(-Infinity);
-  const topY = new Float64Array(nX).fill(Infinity);
-  const nPts = points.length;
-  for (let iy = 0; iy < nY; iy++) {
-    const y = iy * SAMPLE_STEP;
-    for (let j = 0, k = nPts - 1; j < nPts; k = j++) {
-      const yj = points[j].y, yk = points[k].y;
-      if (yj <= y && yk > y || yk <= y && yj > y) {
-        const t = (y - yj) / (yk - yj);
-        const x = points[j].x + t * (points[k].x - points[j].x);
-        if (x > rightX[iy]) rightX[iy] = x;
-        if (x < leftX[iy]) leftX[iy] = x;
-      }
+  return maxStep;
+}
+function pairGrid2(rdA, rdB, bounds) {
+  const pA = rdA.profile, pB = rdB.profile;
+  const gapAB = findMinStepX(pA, pB, 0);
+  if (gapAB <= 0) return emptyResult();
+  const pairW = gapAB + pB.width;
+  const pairH = Math.max(pA.height, pB.height);
+  const pairStepX = gapAB + findMinStepX(pB, pA, 0);
+  if (pairStepX <= 0) return emptyResult();
+  const pairStepY = findPairRowStepY(pA, pB, gapAB, pairStepX);
+  if (pairStepY <= 0) return emptyResult();
+  const usableW = bounds.right - bounds.left;
+  const usableH = bounds.bottom - bounds.top;
+  const pairCols = Math.max(0, Math.floor((usableW - pairW) / pairStepX) + 1);
+  const pairRows = Math.max(0, Math.floor((usableH - pairH) / pairStepY) + 1);
+  if (pairCols === 0 || pairRows === 0) return emptyResult();
+  const placements = [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let r = 0; r < pairRows; r++) {
+    for (let c = 0; c < pairCols; c++) {
+      const baseX = bounds.left + c * pairStepX;
+      const baseY = bounds.top + r * pairStepY;
+      placements.push({ x: baseX + rdA.bbOffset.dx, y: baseY + rdA.bbOffset.dy, rotation: rdA.deg });
+      if (baseX < minX) minX = baseX;
+      if (baseY < minY) minY = baseY;
+      if (baseX + pA.width > maxX) maxX = baseX + pA.width;
+      if (baseY + pA.height > maxY) maxY = baseY + pA.height;
+      const bx = baseX + gapAB;
+      placements.push({ x: bx + rdB.bbOffset.dx, y: baseY + rdB.bbOffset.dy, rotation: rdB.deg });
+      if (bx < minX) minX = bx;
+      if (bx + pB.width > maxX) maxX = bx + pB.width;
+      if (baseY + pB.height > maxY) maxY = baseY + pB.height;
     }
   }
-  for (let ix = 0; ix < nX; ix++) {
-    const x = ix * SAMPLE_STEP;
-    for (let j = 0, k = nPts - 1; j < nPts; k = j++) {
-      const xj = points[j].x, xk = points[k].x;
-      if (xj <= x && xk > x || xk <= x && xj > x) {
-        const t = (x - xj) / (xk - xj);
-        const y = points[j].y + t * (points[k].y - points[j].y);
-        if (y > bottomY[ix]) bottomY[ix] = y;
-        if (y < topY[ix]) topY[ix] = y;
+  const pairsRightEdge = bounds.left + (pairCols - 1) * pairStepX + pairW;
+  const gapRight = bounds.right - pairsRightEdge;
+  for (const rdExtra of [rdA, rdB]) {
+    const pe = rdExtra.profile;
+    if (pe.width > gapRight) continue;
+    const dxFromB = pairsRightEdge - (bounds.left + (pairCols - 1) * pairStepX + gapAB);
+    const dxFromA = pairsRightEdge - bounds.left - (pairCols - 1) * pairStepX;
+    const extraStepY = Math.max(
+      findMinStepY(pA, pe, dxFromA),
+      findMinStepY(pB, pe, dxFromB),
+      findMinStepY(pe, pe, 0)
+    );
+    if (extraStepY <= 0) continue;
+    const effectiveStepY = Math.max(pairStepY, extraStepY);
+    const extraRows = Math.max(0, Math.floor((usableH - pe.height) / effectiveStepY) + 1);
+    for (let r = 0; r < extraRows; r++) {
+      const ox = pairsRightEdge;
+      const oy = bounds.top + r * effectiveStepY;
+      if (ox + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
+        placements.push({ x: ox + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
+        if (ox + pe.width > maxX) maxX = ox + pe.width;
+        if (oy + pe.height > maxY) maxY = oy + pe.height;
       }
     }
+    break;
   }
-  return { width, height, nY, nX, rightX, leftX, bottomY, topY };
-}
-function prepareRotation(contourPoints, dielineW, dielineH, deg) {
-  const rotated = normalizePoints(contourPoints, deg);
-  return {
-    profile: buildProfile(rotated),
-    bbOffset: computeDielineBBOffset(contourPoints, dielineW, dielineH, deg),
-    deg
-  };
-}
-function findMinStepX(a, b, dyMm) {
-  const dySamples = Math.round(dyMm / SAMPLE_STEP);
-  let maxOverlap = -Infinity;
-  for (let ia = 0; ia < a.nY; ia++) {
-    const ib = ia - dySamples;
-    if (ib < 0 || ib >= b.nY) continue;
-    if (a.rightX[ia] === -Infinity || b.leftX[ib] === Infinity) continue;
-    const overlap = a.rightX[ia] - b.leftX[ib];
-    if (overlap > maxOverlap) maxOverlap = overlap;
-  }
-  return maxOverlap <= -Infinity ? 0 : maxOverlap;
-}
-function findMinStepY(a, b, dxMm) {
-  const dxSamples = Math.round(dxMm / SAMPLE_STEP);
-  let maxOverlap = -Infinity;
-  for (let ia = 0; ia < a.nX; ia++) {
-    const ib = ia - dxSamples;
-    if (ib < 0 || ib >= b.nX) continue;
-    if (a.bottomY[ia] === -Infinity || b.topY[ib] === Infinity) continue;
-    const overlap = a.bottomY[ia] - b.topY[ib];
-    if (overlap > maxOverlap) maxOverlap = overlap;
+  const pairsBottomEdge = bounds.top + (pairRows - 1) * pairStepY + pairH;
+  const gapBottom = bounds.bottom - pairsBottomEdge;
+  for (const rdExtra of [rdA, rdB]) {
+    const pe = rdExtra.profile;
+    if (pe.height > gapBottom) continue;
+    const extraStepX = findMinStepX(pe, pe, 0);
+    if (extraStepX <= 0) continue;
+    const dyFromPairRow = pairsBottomEdge - (bounds.top + (pairRows - 1) * pairStepY);
+    const stepFromA = findMinStepY(pA, pe, 0);
+    const stepFromB = findMinStepY(pB, pe, gapAB);
+    if (dyFromPairRow < stepFromA || dyFromPairRow < stepFromB) continue;
+    const extraCols = Math.max(0, Math.floor((usableW - pe.width) / extraStepX) + 1);
+    for (let c = 0; c < extraCols; c++) {
+      const ox = bounds.left + c * extraStepX;
+      const oy = pairsBottomEdge;
+      if (ox + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
+        placements.push({ x: ox + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
+        if (ox + pe.width > maxX) maxX = ox + pe.width;
+        if (oy + pe.height > maxY) maxY = oy + pe.height;
+      }
+    }
+    break;
   }
-  return maxOverlap <= -Infinity ? 0 : maxOverlap;
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-function findMinStepY_multi(profA, stepX_A, profB, offsetX) {
-  const reach = Math.max(profA.width, profB.width);
-  let maxStep = 0;
-  const nMin = Math.floor((offsetX - reach) / stepX_A);
-  const nMax = Math.ceil((offsetX + reach) / stepX_A);
-  for (let n = nMin; n <= nMax; n++) {
-    const s = findMinStepY(profA, profB, offsetX - n * stepX_A);
-    if (s > maxStep) maxStep = s;
+function verticalPairGrid(rdA, rdB, bounds) {
+  const pA = rdA.profile, pB = rdB.profile;
+  const gapAB_Y = findMinStepY(pA, pB, 0);
+  if (gapAB_Y <= 0) return emptyResult();
+  const vpairH = gapAB_Y + pB.height;
+  const vpairW = Math.max(pA.width, pB.width);
+  Math.max(pA.height, pB.height) + Math.abs(gapAB_Y);
+  let vpairStepX = 0;
+  {
+    const stepXAA = findMinStepX(pA, pA, 0);
+    const stepXAB = findMinStepX(pA, pB, -gapAB_Y);
+    const stepXBA = findMinStepX(pB, pA, gapAB_Y);
+    const stepXBB = findMinStepX(pB, pB, 0);
+    vpairStepX = Math.max(stepXAA, stepXAB, stepXBA, stepXBB);
   }
-  return maxStep;
-}
-function emptyResult() {
-  return { placements: [], count: 0, minX: 0, minY: 0, maxX: 0, maxY: 0 };
-}
-function singleRotGrid(rd, bounds) {
-  const p = rd.profile;
-  const stepX = findMinStepX(p, p, 0);
-  const stepY = findMinStepY(p, p, 0);
-  if (stepX <= 0 || stepY <= 0) return emptyResult();
-  const cols = Math.max(0, Math.floor((bounds.right - bounds.left - p.width) / stepX) + 1);
-  const rows = Math.max(0, Math.floor((bounds.bottom - bounds.top - p.height) / stepY) + 1);
+  if (vpairStepX <= 0) return emptyResult();
+  const vpairStepY = gapAB_Y + findMinStepY(pB, pA, 0);
+  if (vpairStepY <= 0) return emptyResult();
+  const usableW = bounds.right - bounds.left;
+  const usableH = bounds.bottom - bounds.top;
+  const cols = Math.max(0, Math.floor((usableW - vpairW) / vpairStepX) + 1);
+  const rows = Math.max(0, Math.floor((usableH - vpairH) / vpairStepY) + 1);
   if (cols === 0 || rows === 0) return emptyResult();
   const placements = [];
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (let r = 0; r < rows; r++) {
     for (let c = 0; c < cols; c++) {
-      const ox = bounds.left + c * stepX;
-      const oy = bounds.top + r * stepY;
-      placements.push({ x: ox + rd.bbOffset.dx, y: oy + rd.bbOffset.dy, rotation: rd.deg });
-      if (ox < minX) minX = ox;
-      if (oy < minY) minY = oy;
-      if (ox + p.width > maxX) maxX = ox + p.width;
-      if (oy + p.height > maxY) maxY = oy + p.height;
-    }
-  }
-  return { placements, count: placements.length, minX, minY, maxX, maxY };
-}
-function dualRotGrid(rdA, rdB, offsetX, bounds) {
-  const pA = rdA.profile, pB = rdB.profile;
-  const stepX_A = findMinStepX(pA, pA, 0);
-  const stepX_B = findMinStepX(pB, pB, 0);
-  if (stepX_A <= 0 || stepX_B <= 0) return emptyResult();
-  const stepY_AB = findMinStepY_multi(pA, stepX_A, pB, offsetX);
-  const stepY_BA = findMinStepY_multi(pB, stepX_B, pA, -offsetX);
-  if (stepY_AB + stepY_BA <= 0) return emptyResult();
-  const placements = [];
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  let oy = bounds.top;
-  let isRowA = true;
-  while (true) {
-    const rd = isRowA ? rdA : rdB;
-    const p = rd.profile;
-    const stepX = isRowA ? stepX_A : stepX_B;
-    if (oy + p.height > bounds.bottom) break;
-    let sx = isRowA ? bounds.left : bounds.left + offsetX;
-    if (sx < bounds.left) sx += stepX * Math.ceil((bounds.left - sx) / stepX);
-    for (let ox = sx; ox + p.width <= bounds.right; ox += stepX) {
-      placements.push({ x: ox + rd.bbOffset.dx, y: oy + rd.bbOffset.dy, rotation: rd.deg });
-      if (ox < minX) minX = ox;
-      if (oy < minY) minY = oy;
-      if (ox + p.width > maxX) maxX = ox + p.width;
-      if (oy + p.height > maxY) maxY = oy + p.height;
+      const baseX = bounds.left + c * vpairStepX;
+      const baseY = bounds.top + r * vpairStepY;
+      placements.push({ x: baseX + rdA.bbOffset.dx, y: baseY + rdA.bbOffset.dy, rotation: rdA.deg });
+      if (baseX < minX) minX = baseX;
+      if (baseY < minY) minY = baseY;
+      if (baseX + pA.width > maxX) maxX = baseX + pA.width;
+      if (baseY + pA.height > maxY) maxY = baseY + pA.height;
+      const by = baseY + gapAB_Y;
+      placements.push({ x: baseX + rdB.bbOffset.dx, y: by + rdB.bbOffset.dy, rotation: rdB.deg });
+      if (by + pB.height > maxY) maxY = by + pB.height;
     }
-    oy += isRowA ? stepY_AB : stepY_BA;
-    isRowA = !isRowA;
   }
-  if (placements.length === 0) return emptyResult();
   return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-function centerLayout(result, bounds) {
-  if (result.count === 0) return;
-  const offX = (bounds.right - bounds.left - (result.maxX - result.minX)) / 2 - (result.minX - bounds.left);
-  const offY = (bounds.bottom - bounds.top - (result.maxY - result.minY)) / 2 - (result.minY - bounds.top);
-  for (const p of result.placements) {
-    p.x += offX;
-    p.y += offY;
-  }
-}
-function computeLayoutForPaper(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+function computeLayoutForPaper3(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
   const rots = [0, 90, 180, 270];
   const rd = /* @__PURE__ */ new Map();
   for (const deg of rots) {
-    rd.set(deg, prepareRotation(contourPoints, dielineW, dielineH, deg));
+    rd.set(deg, prepareRotation3(contourPoints, dielineW, dielineH, deg));
   }
   const results = [];
   for (const deg of rots) {
     results.push(singleRotGrid(rd.get(deg), bounds));
   }
-  const pairs = [
+  const allPairs = [
     [0, 180],
     [90, 270],
     [0, 90],
@@ -3502,7 +4898,7 @@ function computeLayoutForPaper(contourPoints, dielineW, dielineH, _paperWidth, _
     [90, 180],
     [180, 270]
   ];
-  for (const [a, b] of pairs) {
+  for (const [a, b] of allPairs) {
     const rdA = rd.get(a), rdB = rd.get(b);
     const stepA = findMinStepX(rdA.profile, rdA.profile, 0);
     if (stepA <= 0) continue;
@@ -3511,10 +4907,40 @@ function computeLayoutForPaper(contourPoints, dielineW, dielineH, _paperWidth, _
       results.push(dualRotGrid(rdB, rdA, off, bounds));
     }
   }
-  let best = results[0];
+  for (const [a, b] of allPairs) {
+    results.push(pairGrid2(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid2(rd.get(b), rd.get(a), bounds));
+  }
+  for (const [a, b] of allPairs) {
+    results.push(verticalPairGrid(rd.get(a), rd.get(b), bounds));
+    results.push(verticalPairGrid(rd.get(b), rd.get(a), bounds));
+  }
+  const singleResults = [];
+  const multiResults = [];
   for (const r of results) {
-    if (r.count > best.count) best = r;
+    if (r.count === 0) continue;
+    const rotations = new Set(r.placements.map((p) => p.rotation));
+    if (rotations.size > 1) {
+      multiResults.push(r);
+    } else {
+      singleResults.push(r);
+    }
+  }
+  function pickBest(arr) {
+    let b = arr[0] ?? emptyResult();
+    let bArea = (b.maxX - b.minX) * (b.maxY - b.minY);
+    for (const r of arr) {
+      const area = (r.maxX - r.minX) * (r.maxY - r.minY);
+      if (r.count > b.count || r.count === b.count && area < bArea) {
+        b = r;
+        bArea = area;
+      }
+    }
+    return b;
   }
+  const bestSingle = pickBest(singleResults);
+  const bestMulti = pickBest(multiResults);
+  const best = bestMulti.count >= bestSingle.count && bestMulti.count > 0 ? bestMulti : bestSingle;
   centerLayout(best, bounds);
   return {
     rotation: best.placements[0]?.rotation ?? 0,
@@ -3523,8 +4949,8 @@ function computeLayoutForPaper(contourPoints, dielineW, dielineH, _paperWidth, _
   };
 }
 
-// src/utils/autoLayout/calculate/tuck-end-boxes/becf-1030a/index.ts
-function prepareRotation2(contourPoints, dielineW, dielineH, deg) {
+// src/utils/autoLayout/calculate/bags-pillows/becf-12101/index.ts
+function prepareRotation4(contourPoints, dielineW, dielineH, deg) {
   const rotated = normalizePoints(contourPoints, deg);
   return {
     profile: buildProfile(rotated),
@@ -3532,7 +4958,7 @@ function prepareRotation2(contourPoints, dielineW, dielineH, deg) {
     deg
   };
 }
-function pairGrid(rdA, rdB, bounds) {
+function pairGrid3(rdA, rdB, bounds) {
   const pA = rdA.profile, pB = rdB.profile;
   const gapAB = findMinStepX(pA, pB, 0);
   if (gapAB <= 0) return emptyResult();
@@ -3608,11 +5034,11 @@ function pairGrid(rdA, rdB, bounds) {
   }
   return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-function computeLayoutForPaper2(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+function computeLayoutForPaper4(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
   const rots = [0, 90, 180, 270];
   const rd = /* @__PURE__ */ new Map();
   for (const deg of rots) {
-    rd.set(deg, prepareRotation2(contourPoints, dielineW, dielineH, deg));
+    rd.set(deg, prepareRotation4(contourPoints, dielineW, dielineH, deg));
   }
   const results = [];
   for (const deg of rots) {
@@ -3636,8 +5062,8 @@ function computeLayoutForPaper2(contourPoints, dielineW, dielineH, _paperWidth,
     }
   }
   for (const [a, b] of allPairs) {
-    results.push(pairGrid(rd.get(a), rd.get(b), bounds));
-    results.push(pairGrid(rd.get(b), rd.get(a), bounds));
+    results.push(pairGrid3(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid3(rd.get(b), rd.get(a), bounds));
   }
   const singleResults = [];
   const multiResults = [];
@@ -3673,8 +5099,8 @@ function computeLayoutForPaper2(contourPoints, dielineW, dielineH, _paperWidth,
   };
 }
 
-// src/utils/autoLayout/calculate/tuck-end-boxes/becf-1040a/index.ts
-function prepareRotation3(contourPoints, dielineW, dielineH, deg) {
+// src/utils/autoLayout/calculate/bags-pillows/becf-12109/index.ts
+function prepareRotation5(contourPoints, dielineW, dielineH, deg) {
   const rotated = normalizePoints(contourPoints, deg);
   return {
     profile: buildProfile(rotated),
@@ -3682,34 +5108,20 @@ function prepareRotation3(contourPoints, dielineW, dielineH, deg) {
     deg
   };
 }
-function findPairRowStepY(pA, pB, gapAB, pairStepX) {
-  const reach = Math.max(pA.width, pB.width) + Math.abs(gapAB);
-  const nMin = Math.floor(-reach / pairStepX) - 1;
-  const nMax = Math.ceil(reach / pairStepX) + 1;
-  let maxStep = 0;
-  for (let n = nMin; n <= nMax; n++) {
-    const dx = n * pairStepX;
-    const s1 = findMinStepY(pA, pA, dx);
-    if (s1 > maxStep) maxStep = s1;
-    const s2 = findMinStepY(pA, pB, dx + gapAB);
-    if (s2 > maxStep) maxStep = s2;
-    const s3 = findMinStepY(pB, pA, dx - gapAB);
-    if (s3 > maxStep) maxStep = s3;
-    const s4 = findMinStepY(pB, pB, dx);
-    if (s4 > maxStep) maxStep = s4;
-  }
-  return maxStep;
-}
-function pairGrid2(rdA, rdB, bounds) {
+function pairGrid4(rdA, rdB, bounds) {
   const pA = rdA.profile, pB = rdB.profile;
   const gapAB = findMinStepX(pA, pB, 0);
   if (gapAB <= 0) return emptyResult();
   const pairW = gapAB + pB.width;
   const pairH = Math.max(pA.height, pB.height);
   const pairStepX = gapAB + findMinStepX(pB, pA, 0);
-  if (pairStepX <= 0) return emptyResult();
-  const pairStepY = findPairRowStepY(pA, pB, gapAB, pairStepX);
-  if (pairStepY <= 0) return emptyResult();
+  const pairStepY = Math.max(
+    findMinStepY(pA, pA, 0),
+    findMinStepY(pA, pB, gapAB),
+    findMinStepY(pB, pA, -gapAB),
+    findMinStepY(pB, pB, 0)
+  );
+  if (pairStepX <= 0 || pairStepY <= 0) return emptyResult();
   const usableW = bounds.right - bounds.left;
   const usableH = bounds.bottom - bounds.top;
   const pairCols = Math.max(0, Math.floor((usableW - pairW) / pairStepX) + 1);
@@ -3721,115 +5133,62 @@ function pairGrid2(rdA, rdB, bounds) {
     for (let c = 0; c < pairCols; c++) {
       const baseX = bounds.left + c * pairStepX;
       const baseY = bounds.top + r * pairStepY;
-      placements.push({ x: baseX + rdA.bbOffset.dx, y: baseY + rdA.bbOffset.dy, rotation: rdA.deg });
-      if (baseX < minX) minX = baseX;
-      if (baseY < minY) minY = baseY;
-      if (baseX + pA.width > maxX) maxX = baseX + pA.width;
-      if (baseY + pA.height > maxY) maxY = baseY + pA.height;
-      const bx = baseX + gapAB;
-      placements.push({ x: bx + rdB.bbOffset.dx, y: baseY + rdB.bbOffset.dy, rotation: rdB.deg });
-      if (bx < minX) minX = bx;
-      if (bx + pB.width > maxX) maxX = bx + pB.width;
-      if (baseY + pB.height > maxY) maxY = baseY + pB.height;
+      const oxA = baseX;
+      const oyA = baseY;
+      placements.push({ x: oxA + rdA.bbOffset.dx, y: oyA + rdA.bbOffset.dy, rotation: rdA.deg });
+      if (oxA < minX) minX = oxA;
+      if (oyA < minY) minY = oyA;
+      if (oxA + pA.width > maxX) maxX = oxA + pA.width;
+      if (oyA + pA.height > maxY) maxY = oyA + pA.height;
+      const oxB = baseX + gapAB;
+      const oyB = baseY;
+      placements.push({ x: oxB + rdB.bbOffset.dx, y: oyB + rdB.bbOffset.dy, rotation: rdB.deg });
+      if (oxB < minX) minX = oxB;
+      if (oyB < minY) minY = oyB;
+      if (oxB + pB.width > maxX) maxX = oxB + pB.width;
+      if (oyB + pB.height > maxY) maxY = oyB + pB.height;
     }
   }
   const pairsRightEdge = bounds.left + (pairCols - 1) * pairStepX + pairW;
+  const pairsBottomEdge = bounds.top + (pairRows - 1) * pairStepY + pairH;
   const gapRight = bounds.right - pairsRightEdge;
-  for (const rdExtra of [rdA, rdB]) {
+  const gapBottom = bounds.bottom - pairsBottomEdge;
+  const extraRotations = [rdA, rdB];
+  for (const rdExtra of extraRotations) {
     const pe = rdExtra.profile;
-    if (pe.width > gapRight) continue;
-    const dxFromB = pairsRightEdge - (bounds.left + (pairCols - 1) * pairStepX + gapAB);
-    const dxFromA = pairsRightEdge - bounds.left - (pairCols - 1) * pairStepX;
-    const extraStepY = Math.max(
-      findMinStepY(pA, pe, dxFromA),
-      findMinStepY(pB, pe, dxFromB),
-      findMinStepY(pe, pe, 0)
-    );
-    if (extraStepY <= 0) continue;
-    const effectiveStepY = Math.max(pairStepY, extraStepY);
-    const extraRows = Math.max(0, Math.floor((usableH - pe.height) / effectiveStepY) + 1);
-    for (let r = 0; r < extraRows; r++) {
-      const ox = pairsRightEdge;
-      const oy = bounds.top + r * effectiveStepY;
-      if (ox + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
-        placements.push({ x: ox + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
-        if (ox + pe.width > maxX) maxX = ox + pe.width;
-        if (oy + pe.height > maxY) maxY = oy + pe.height;
+    if (pe.width <= gapRight) {
+      for (let r = 0; r < pairRows; r++) {
+        const ox = pairsRightEdge;
+        const oy = bounds.top + r * pairStepY;
+        if (ox + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
+          placements.push({ x: ox + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
+          if (ox + pe.width > maxX) maxX = ox + pe.width;
+        }
       }
+      break;
     }
-    break;
   }
-  const pairsBottomEdge = bounds.top + (pairRows - 1) * pairStepY + pairH;
-  const gapBottom = bounds.bottom - pairsBottomEdge;
-  for (const rdExtra of [rdA, rdB]) {
+  for (const rdExtra of extraRotations) {
     const pe = rdExtra.profile;
-    if (pe.height > gapBottom) continue;
-    const extraStepX = findMinStepX(pe, pe, 0);
-    if (extraStepX <= 0) continue;
-    const dyFromPairRow = pairsBottomEdge - (bounds.top + (pairRows - 1) * pairStepY);
-    const stepFromA = findMinStepY(pA, pe, 0);
-    const stepFromB = findMinStepY(pB, pe, gapAB);
-    if (dyFromPairRow < stepFromA || dyFromPairRow < stepFromB) continue;
-    const extraCols = Math.max(0, Math.floor((usableW - pe.width) / extraStepX) + 1);
-    for (let c = 0; c < extraCols; c++) {
-      const ox = bounds.left + c * extraStepX;
-      const oy = pairsBottomEdge;
-      if (ox + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
-        placements.push({ x: ox + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
-        if (ox + pe.width > maxX) maxX = ox + pe.width;
-        if (oy + pe.height > maxY) maxY = oy + pe.height;
+    if (pe.height <= gapBottom) {
+      for (let c = 0; c < pairCols; c++) {
+        const oxA = bounds.left + c * pairStepX;
+        const oy = pairsBottomEdge;
+        if (oxA + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
+          placements.push({ x: oxA + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
+          if (oy + pe.height > maxY) maxY = oy + pe.height;
+        }
       }
-    }
-    break;
-  }
-  return { placements, count: placements.length, minX, minY, maxX, maxY };
-}
-function verticalPairGrid(rdA, rdB, bounds) {
-  const pA = rdA.profile, pB = rdB.profile;
-  const gapAB_Y = findMinStepY(pA, pB, 0);
-  if (gapAB_Y <= 0) return emptyResult();
-  const vpairH = gapAB_Y + pB.height;
-  const vpairW = Math.max(pA.width, pB.width);
-  Math.max(pA.height, pB.height) + Math.abs(gapAB_Y);
-  let vpairStepX = 0;
-  {
-    const stepXAA = findMinStepX(pA, pA, 0);
-    const stepXAB = findMinStepX(pA, pB, -gapAB_Y);
-    const stepXBA = findMinStepX(pB, pA, gapAB_Y);
-    const stepXBB = findMinStepX(pB, pB, 0);
-    vpairStepX = Math.max(stepXAA, stepXAB, stepXBA, stepXBB);
-  }
-  if (vpairStepX <= 0) return emptyResult();
-  const vpairStepY = gapAB_Y + findMinStepY(pB, pA, 0);
-  if (vpairStepY <= 0) return emptyResult();
-  const usableW = bounds.right - bounds.left;
-  const usableH = bounds.bottom - bounds.top;
-  const cols = Math.max(0, Math.floor((usableW - vpairW) / vpairStepX) + 1);
-  const rows = Math.max(0, Math.floor((usableH - vpairH) / vpairStepY) + 1);
-  if (cols === 0 || rows === 0) return emptyResult();
-  const placements = [];
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (let r = 0; r < rows; r++) {
-    for (let c = 0; c < cols; c++) {
-      const baseX = bounds.left + c * vpairStepX;
-      const baseY = bounds.top + r * vpairStepY;
-      placements.push({ x: baseX + rdA.bbOffset.dx, y: baseY + rdA.bbOffset.dy, rotation: rdA.deg });
-      if (baseX < minX) minX = baseX;
-      if (baseY < minY) minY = baseY;
-      if (baseX + pA.width > maxX) maxX = baseX + pA.width;
-      if (baseY + pA.height > maxY) maxY = baseY + pA.height;
-      const by = baseY + gapAB_Y;
-      placements.push({ x: baseX + rdB.bbOffset.dx, y: by + rdB.bbOffset.dy, rotation: rdB.deg });
-      if (by + pB.height > maxY) maxY = by + pB.height;
+      break;
     }
   }
   return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-function computeLayoutForPaper3(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+function computeLayoutForPaper5(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
   const rots = [0, 90, 180, 270];
   const rd = /* @__PURE__ */ new Map();
   for (const deg of rots) {
-    rd.set(deg, prepareRotation3(contourPoints, dielineW, dielineH, deg));
+    rd.set(deg, prepareRotation5(contourPoints, dielineW, dielineH, deg));
   }
   const results = [];
   for (const deg of rots) {
@@ -3853,12 +5212,8 @@ function computeLayoutForPaper3(contourPoints, dielineW, dielineH, _paperWidth,
     }
   }
   for (const [a, b] of allPairs) {
-    results.push(pairGrid2(rd.get(a), rd.get(b), bounds));
-    results.push(pairGrid2(rd.get(b), rd.get(a), bounds));
-  }
-  for (const [a, b] of allPairs) {
-    results.push(verticalPairGrid(rd.get(a), rd.get(b), bounds));
-    results.push(verticalPairGrid(rd.get(b), rd.get(a), bounds));
+    results.push(pairGrid4(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid4(rd.get(b), rd.get(a), bounds));
   }
   const singleResults = [];
   const multiResults = [];
@@ -3921,6 +5276,22 @@ function resolveModelFunctions(modelId, attrs) {
         offsetContour: offsetContour4
       };
     }
+    case "BECF-12101": {
+      const a = attrs;
+      return {
+        contour: generateOuterContour5(a),
+        dieline: generateBecf12101(a),
+        offsetContour: offsetContour5
+      };
+    }
+    case "BECF-12109": {
+      const a = attrs;
+      return {
+        contour: generateOuterContour6(a),
+        dieline: generateBecf12109(a),
+        offsetContour: offsetContour6
+      };
+    }
     case "BECF-1010A":
     default: {
       const a = attrs;
@@ -3940,16 +5311,28 @@ function resolveLayoutCalculator(modelId) {
       return computeLayoutForPaper2;
     case "BECF-1040A":
       return computeLayoutForPaper3;
+    case "BECF-12101":
+      return computeLayoutForPaper4;
+    case "BECF-12109":
+      return computeLayoutForPaper5;
     default:
       return computeLayoutForPaperDefault;
   }
 }
-function calculateAutoLayout(config) {
-  const { contour, dieline, offsetContour: offsetContour5 } = resolveModelFunctions(
+function calculateAutoLayout(rawConfig) {
+  const config = {
+    ...rawConfig,
+    layoutDistance: rawConfig.layoutDistance ?? 3,
+    spacing: rawConfig.spacing ?? 5,
+    griper: rawConfig.griper ?? 10,
+    colorbarHeight: rawConfig.colorbarHeight ?? 5,
+    isShowColorbar: rawConfig.isShowColorbar ?? true
+  };
+  const { contour, dieline, offsetContour: offsetContour7 } = resolveModelFunctions(
     config.model.modelId,
     config.model.attributes
   );
-  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour5(contour, config.layoutDistance / 2) : contour;
+  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour7(contour, config.layoutDistance / 2) : contour;
   const cbDepth = config.isShowColorbar ? config.colorbarHeight : 0;
   const computeLayout = resolveLayoutCalculator(config.model.modelId);
   const paperResults = [];
@@ -4294,6 +5677,22 @@ function renderDieLine(modelId, attrs) {
           renderAs: "group"
         }
       );
+    case "BECF-11D01":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        DIE_LINE_BECF_11D01,
+        {
+          attributes: attrs,
+          renderAs: "group"
+        }
+      );
+    case "BECF-12101":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        DIE_LINE_BECF_12101,
+        {
+          attributes: attrs,
+          renderAs: "group"
+        }
+      );
     case "BECF-1010A":
     default:
       return /* @__PURE__ */ jsxRuntime.jsx(
@@ -4343,9 +5742,9 @@ function getTransformedContour(normalizedPoints, x, y, rotation) {
   }
   return translatePolygon(rotated, x - rMinX, y - rMinY);
 }
-function checkCollisions(items, normalizedOffsetContour, paperWidth, paperHeight) {
+function checkCollisions(items, shrunkContour, paperWidth, paperHeight) {
   const polys = items.map(
-    (item) => getTransformedContour(normalizedOffsetContour, item.x, item.y, item.rotation)
+    (item) => getTransformedContour(shrunkContour, item.x, item.y, item.rotation)
   );
   return items.map((item, i) => {
     let colliding = false;
@@ -4403,7 +5802,10 @@ function ModifyLayout({
   const [panX, setPanX] = react.useState(0);
   const [panY, setPanY] = react.useState(0);
   const theme = react.useMemo(() => getAutoLayoutTheme(), []);
-  const normalizedOffsetContour = react.useMemo(() => normalizeContour(offsetContourPoints), [offsetContourPoints]);
+  const shrunkContour = react.useMemo(
+    () => normalizeContour(offsetContour(offsetContourPoints, -0.15)),
+    [offsetContourPoints]
+  );
   const pw = paperResult.paperWidth;
   const ph = paperResult.paperHeight;
   const padding = 20;
@@ -4416,7 +5818,7 @@ function ModifyLayout({
   const cbDepth = config.isShowColorbar ? config.colorbarHeight : 0;
   const layoutDistance = config.layoutDistance;
   react.useEffect(() => {
-    setItems((prev) => checkCollisions(prev, normalizedOffsetContour, pw, ph));
+    setItems((prev) => checkCollisions(prev, shrunkContour, pw, ph));
   }, []);
   const itemsRef = react.useRef(items);
   itemsRef.current = items;
@@ -4433,7 +5835,7 @@ function ModifyLayout({
           const updated = prev.map(
             (it) => it.id === dragItemId ? { ...it, x: newX, y: newY } : it
           );
-          return checkCollisions(updated, normalizedOffsetContour, pw, ph);
+          return checkCollisions(updated, shrunkContour, pw, ph);
         });
         return;
       }
@@ -4467,7 +5869,7 @@ function ModifyLayout({
       window.removeEventListener("pointerup", handleMouseUp);
       window.removeEventListener("pointercancel", handleMouseUp);
     };
-  }, [normalizedOffsetContour, pw, ph, zoom, padding]);
+  }, [shrunkContour, pw, ph, zoom, padding]);
   const handleItemMouseDown = react.useCallback((e, itemId) => {
     e.stopPropagation();
     e.preventDefault();
@@ -4506,9 +5908,9 @@ function ModifyLayout({
       const updated = prev.map(
         (it) => it.id === selectedId ? { ...it, rotation: degrees } : it
       );
-      return checkCollisions(updated, normalizedOffsetContour, pw, ph);
+      return checkCollisions(updated, shrunkContour, pw, ph);
     });
-  }, [selectedId, normalizedOffsetContour, pw, ph]);
+  }, [selectedId, shrunkContour, pw, ph]);
   const handleAdd = react.useCallback(() => {
     const newItem = {
       id: `item-${nextItemId++}`,
@@ -4519,17 +5921,17 @@ function ModifyLayout({
     };
     setItems((prev) => {
       const updated = [...prev, newItem];
-      return checkCollisions(updated, normalizedOffsetContour, pw, ph);
+      return checkCollisions(updated, shrunkContour, pw, ph);
     });
     setSelectedId(newItem.id);
-  }, [pw, ph, dielineViewBox, normalizedOffsetContour]);
+  }, [pw, ph, dielineViewBox, shrunkContour]);
   const handleRemove = react.useCallback((itemId) => {
     setItems((prev) => {
       const filtered = prev.filter((it) => it.id !== itemId);
-      return checkCollisions(filtered, normalizedOffsetContour, pw, ph);
+      return checkCollisions(filtered, shrunkContour, pw, ph);
     });
     if (selectedId === itemId) setSelectedId(null);
-  }, [selectedId, normalizedOffsetContour, pw, ph]);
+  }, [selectedId, shrunkContour, pw, ph]);
   const handleSubmit = react.useCallback(() => {
     const validItems = items.filter((it) => !it.isColliding);
     const placements = validItems.map((it) => ({
@@ -4859,6 +6261,28 @@ function resolveModel(modelId, attrs, layoutDistance) {
         generateContour: (a) => generateOuterContour4(a)
       };
     }
+    case "BECF-12101": {
+      const typedAttrs = attrs;
+      const contour = generateOuterContour5(typedAttrs);
+      return {
+        dieline: generateBecf12101(typedAttrs),
+        contourPath: contourToPath5(contour),
+        offsetContourPoints: layoutDistance > 0 ? offsetContour5(contour, layoutDistance / 2) : contour,
+        generate: (a) => generateBecf12101(a),
+        generateContour: (a) => generateOuterContour5(a)
+      };
+    }
+    case "BECF-12109": {
+      const typedAttrs = attrs;
+      const contour = generateOuterContour6(typedAttrs);
+      return {
+        dieline: generateBecf12109(typedAttrs),
+        contourPath: contourToPath6(contour),
+        offsetContourPoints: layoutDistance > 0 ? offsetContour6(contour, layoutDistance / 2) : contour,
+        generate: (a) => generateBecf12109(a),
+        generateContour: (a) => generateOuterContour6(a)
+      };
+    }
     case "BECF-1010A":
     default: {
       const typedAttrs = attrs;
@@ -4900,6 +6324,22 @@ function renderDieLine2(modelId, attrs) {
             renderAs: "group"
           }
         );
+      case "BECF-12101":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          DIE_LINE_BECF_12101,
+          {
+            attributes: attrs,
+            renderAs: "group"
+          }
+        );
+      case "BECF-12109":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          DIE_LINE_BECF_12109,
+          {
+            attributes: attrs,
+            renderAs: "group"
+          }
+        );
       case "BECF-1010A":
       default:
         return /* @__PURE__ */ jsxRuntime.jsx(
@@ -4913,7 +6353,7 @@ function renderDieLine2(modelId, attrs) {
   })();
 }
 var PAPER_GAP = 20;
-var PX_PER_MM5 = 96 / 25.4;
+var PX_PER_MM7 = 96 / 25.4;
 var RESULT_PANEL_HEIGHT = 55;
 var RESULT_GAP = 5;
 function getOpposite2(side) {
@@ -5040,7 +6480,7 @@ function getDielineTransform2(x, y, rotation, w, h) {
   }
 }
 var AUTO_LAYOUT = react.forwardRef(
-  ({ config, onResult, onModifiedPapers }, ref) => {
+  ({ config, onResult, onModifiedPapers, isShowSummary = true, isShowAction }, ref) => {
     const canvasRef = react.useRef(null);
     const [result, setResult] = react.useState(null);
     const [modifiedPapers, setModifiedPapers] = react.useState([]);
@@ -5063,7 +6503,7 @@ var AUTO_LAYOUT = react.forwardRef(
     );
     const modelId = config?.model.modelId ?? "";
     const attrs = config?.model.attributes;
-    const layoutDistance = config?.layoutDistance ?? 0;
+    const layoutDistance = config?.layoutDistance ?? 3;
     const resolved = react.useMemo(
       () => modelId && attrs ? resolveModel(modelId, attrs, layoutDistance) : null,
       [modelId, attrs, layoutDistance]
@@ -5090,8 +6530,8 @@ var AUTO_LAYOUT = react.forwardRef(
       const svg = document.createElementNS(svgNs, "svg");
       svg.setAttribute("xmlns", svgNs);
       svg.setAttribute("viewBox", `0 0 ${vw} ${vh}`);
-      svg.setAttribute("width", String(Math.round(vw * PX_PER_MM5)));
-      svg.setAttribute("height", String(Math.round(vh * PX_PER_MM5)));
+      svg.setAttribute("width", String(Math.round(vw * PX_PER_MM7)));
+      svg.setAttribute("height", String(Math.round(vh * PX_PER_MM7)));
       const bg = document.createElementNS(svgNs, "rect");
       bg.setAttribute("width", String(vw));
       bg.setAttribute("height", String(vh));
@@ -5124,8 +6564,8 @@ var AUTO_LAYOUT = react.forwardRef(
         img.src = url;
       });
       const canvas = document.createElement("canvas");
-      canvas.width = Math.round(vw * PX_PER_MM5);
-      canvas.height = Math.round(vh * PX_PER_MM5);
+      canvas.width = Math.round(vw * PX_PER_MM7);
+      canvas.height = Math.round(vh * PX_PER_MM7);
       const ctx = canvas.getContext("2d");
       ctx.fillStyle = "#ffffff";
       ctx.fillRect(0, 0, canvas.width, canvas.height);
@@ -5144,13 +6584,13 @@ var AUTO_LAYOUT = react.forwardRef(
       if (!paperResult) throw new Error("Invalid paper index");
       const dl = resolved.generate(attrs);
       const cPath = contourToPath(resolved.generateContour(attrs));
-      const dist = config.layoutDistance;
+      const dist = config.layoutDistance ?? 3;
       const svgNs = "http://www.w3.org/2000/svg";
       const svg = document.createElementNS(svgNs, "svg");
       svg.setAttribute("xmlns", svgNs);
       svg.setAttribute("viewBox", `0 0 ${paperResult.paperWidth} ${paperResult.paperHeight}`);
-      svg.setAttribute("width", String(Math.round(paperResult.paperWidth * PX_PER_MM5)));
-      svg.setAttribute("height", String(Math.round(paperResult.paperHeight * PX_PER_MM5)));
+      svg.setAttribute("width", String(Math.round(paperResult.paperWidth * PX_PER_MM7)));
+      svg.setAttribute("height", String(Math.round(paperResult.paperHeight * PX_PER_MM7)));
       const bg = document.createElementNS(svgNs, "rect");
       bg.setAttribute("width", String(paperResult.paperWidth));
       bg.setAttribute("height", String(paperResult.paperHeight));
@@ -5160,12 +6600,16 @@ var AUTO_LAYOUT = react.forwardRef(
       svg.appendChild(bg);
       const gripperSide = paperResult.gripperSide;
       const colorbarSide = getOpposite2(gripperSide);
-      const cbDepth = config.isShowColorbar ? config.colorbarHeight : 0;
-      if (config.isShowColorbar) {
-        appendColorbarToSvg(svg, svgNs, colorbarSide, config.colorbarHeight, paperResult.paperWidth, paperResult.paperHeight);
+      const colorbarHeight = config.colorbarHeight ?? 5;
+      const isShowColorbar = config.isShowColorbar ?? true;
+      const spacing = config.spacing ?? 5;
+      const griper = config.griper ?? 10;
+      const cbDepth = isShowColorbar ? colorbarHeight : 0;
+      if (isShowColorbar) {
+        appendColorbarToSvg(svg, svgNs, colorbarSide, colorbarHeight, paperResult.paperWidth, paperResult.paperHeight);
       }
-      if (config.spacing > 0) {
-        const rects = getSpacingRects2(gripperSide, paperResult.paperWidth, paperResult.paperHeight, config.spacing, config.griper, cbDepth);
+      if (spacing > 0) {
+        const rects = getSpacingRects2(gripperSide, paperResult.paperWidth, paperResult.paperHeight, spacing, griper, cbDepth);
         for (const sr of rects) {
           const r = document.createElementNS(svgNs, "rect");
           r.setAttribute("x", String(sr.x));
@@ -5176,8 +6620,8 @@ var AUTO_LAYOUT = react.forwardRef(
           svg.appendChild(r);
         }
       }
-      if (config.griper > 0) {
-        appendGripperToSvg(svg, svgNs, gripperSide, paperResult.paperWidth, paperResult.paperHeight, config.griper, theme.colorGriper);
+      if (griper > 0) {
+        appendGripperToSvg(svg, svgNs, gripperSide, paperResult.paperWidth, paperResult.paperHeight, griper, theme.colorGriper);
       }
       if (dist > 0) {
         const defs = document.createElementNS(svgNs, "defs");
@@ -5250,8 +6694,8 @@ var AUTO_LAYOUT = react.forwardRef(
         img.src = url;
       });
       const canvas = document.createElement("canvas");
-      canvas.width = Math.round(paperResult.paperWidth * PX_PER_MM5);
-      canvas.height = Math.round(paperResult.paperHeight * PX_PER_MM5);
+      canvas.width = Math.round(paperResult.paperWidth * PX_PER_MM7);
+      canvas.height = Math.round(paperResult.paperHeight * PX_PER_MM7);
       const ctx = canvas.getContext("2d");
       ctx.fillStyle = theme.colorPaperFill;
       ctx.fillRect(0, 0, canvas.width, canvas.height);
@@ -5279,7 +6723,10 @@ var AUTO_LAYOUT = react.forwardRef(
         unit: "mm",
         format: [pw, ph]
       });
-      if (config.isShowColorbar) {
+      const pdfColorbarHeight = config.colorbarHeight ?? 5;
+      const pdfIsShowColorbar = config.isShowColorbar ?? true;
+      const pdfGriper = config.griper ?? 10;
+      if (pdfIsShowColorbar) {
         const BASE_COLORS2 = ["#02FFFF", "#FF00FF", "#FFFF00", "#000000"];
         const FADE_LEVELS2 = [1, 0.8, 0.6, 0.4, 0.2];
         const fadeToWhite2 = (hex, opacity) => {
@@ -5297,7 +6744,7 @@ var AUTO_LAYOUT = react.forwardRef(
         );
         const count = colors.length;
         const isHoriz = colorbarSide === "top" || colorbarSide === "bottom";
-        const cbH = config.colorbarHeight;
+        const cbH = pdfColorbarHeight;
         colors.forEach((c, i) => {
           doc.setFillColor(c.r, c.g, c.b);
           if (isHoriz) {
@@ -5311,7 +6758,7 @@ var AUTO_LAYOUT = react.forwardRef(
           }
         });
       }
-      if (config.griper > 0) {
+      if (pdfGriper > 0) {
         const hexToRgb2 = (hex) => ({
           r: parseInt(hex.slice(1, 3), 16),
           g: parseInt(hex.slice(3, 5), 16),
@@ -5319,7 +6766,7 @@ var AUTO_LAYOUT = react.forwardRef(
         });
         const gc = hexToRgb2(theme.colorGriper);
         doc.setFillColor(gc.r, gc.g, gc.b);
-        const depth = config.griper;
+        const depth = pdfGriper;
         switch (gripperSide) {
           case "bottom":
             doc.rect(0, ph - depth, pw, depth, "F");
@@ -5444,7 +6891,8 @@ var AUTO_LAYOUT = react.forwardRef(
       exportImage,
       exportPdf
     }), [result, getPackedResult, exportDielineImage, exportImage, exportPdf]);
-    const paperOriginY = RESULT_PANEL_HEIGHT + RESULT_GAP;
+    const showAction = (action) => !isShowAction || isShowAction.includes(action);
+    const paperOriginY = isShowSummary ? RESULT_PANEL_HEIGHT + RESULT_GAP : 0;
     const viewBox = react.useMemo(() => {
       if (allPapers.length === 0) {
         return { x: 0, y: 0, width: 400, height: 300 };
@@ -5488,7 +6936,7 @@ var AUTO_LAYOUT = react.forwardRef(
         }
         const gripperSide = paperResult.gripperSide;
         const colorbarSide = getOpposite2(gripperSide);
-        const cbDepth = config.isShowColorbar ? config.colorbarHeight : 0;
+        const cbDepth = config.isShowColorbar ?? true ? config.colorbarHeight ?? 5 : 0;
         const panelW = paperResult.paperWidth;
         const fontSize = Math.min(4, panelW / 30);
         const padX = fontSize * 1.2;
@@ -5512,148 +6960,150 @@ var AUTO_LAYOUT = react.forwardRef(
         curY += gap;
         const exportBtnY = curY;
         return /* @__PURE__ */ jsxRuntime.jsxs("g", { transform: `translate(${offsetX}, 0)`, children: [
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "rect",
-            {
-              x: 0,
-              y: 0,
-              width: panelW,
-              height: RESULT_PANEL_HEIGHT,
-              rx: 2,
-              ry: 2,
-              fill: "#f8fafc",
-              stroke: "#d4dce7",
-              strokeWidth: 0.3
-            }
-          ),
-          /* @__PURE__ */ jsxRuntime.jsx("text", { x: padX, y: titleY, fontSize: fontSize + 1, fontWeight: "bold", fill: "#0f172a", children: paperResult.paperName }),
-          /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: recY, fontSize, fontWeight: "bold", fill: rank === 1 ? "#10b981" : "#475569", children: [
-            "Recommended: #",
-            rank
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: perSheetY, fontSize, fill: "#475569", children: [
-            "Produced per sheet: ",
-            paperResult.producedPerSheet,
-            " pcs"
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: sheetsY, fontSize, fill: "#475569", children: [
-            "Sheets needed: ",
-            paperResult.independentSheets
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: producedY, fontSize, fill: "#475569", children: [
-            "Produced: ",
-            paperResult.independentSheets * paperResult.producedPerSheet,
-            " pcs (excess ",
-            paperResult.independentSheets * paperResult.producedPerSheet - (config?.quantity ?? 0),
-            ")"
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: wasteY, fontSize, fill: "#475569", children: [
-            "Waste per sheet: ",
-            paperResult.wastePercent,
-            "%"
+          isShowSummary && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "rect",
+              {
+                x: 0,
+                y: 0,
+                width: panelW,
+                height: RESULT_PANEL_HEIGHT,
+                rx: 2,
+                ry: 2,
+                fill: "#f8fafc",
+                stroke: "#d4dce7",
+                strokeWidth: 0.3
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx("text", { x: padX, y: titleY, fontSize: fontSize + 1, fontWeight: "bold", fill: "#0f172a", children: paperResult.paperName }),
+            /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: recY, fontSize, fontWeight: "bold", fill: rank === 1 ? "#10b981" : "#475569", children: [
+              "Recommended: #",
+              rank
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: perSheetY, fontSize, fill: "#475569", children: [
+              "Produced per sheet: ",
+              paperResult.producedPerSheet,
+              " pcs"
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: sheetsY, fontSize, fill: "#475569", children: [
+              "Sheets needed: ",
+              paperResult.independentSheets
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: producedY, fontSize, fill: "#475569", children: [
+              "Produced: ",
+              paperResult.independentSheets * paperResult.producedPerSheet,
+              " pcs (excess ",
+              paperResult.independentSheets * paperResult.producedPerSheet - (config?.quantity ?? 0),
+              ")"
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("text", { x: padX, y: wasteY, fontSize, fill: "#475569", children: [
+              "Waste per sheet: ",
+              paperResult.wastePercent,
+              "%"
+            ] }),
+            showAction("EXPORT_SHEET") && /* @__PURE__ */ jsxRuntime.jsxs(
+              "g",
+              {
+                style: { cursor: "pointer" },
+                onPointerDown: (e) => e.stopPropagation(),
+                onClick: () => handleExportImage(paperIdx),
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "rect",
+                    {
+                      x: padX,
+                      y: exportBtnY,
+                      width: exportBtnW,
+                      height: exportBtnH,
+                      rx: 1.5,
+                      ry: 1.5,
+                      fill: "#0f172a"
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "text",
+                    {
+                      x: padX + exportBtnW / 2,
+                      y: exportBtnY + exportBtnH / 2 + fontSize * 0.35,
+                      textAnchor: "middle",
+                      fontSize,
+                      fill: "#fff",
+                      style: { pointerEvents: "none" },
+                      children: "Export Sheet"
+                    }
+                  )
+                ]
+              }
+            ),
+            showAction("EXPORT_PDF") && /* @__PURE__ */ jsxRuntime.jsxs(
+              "g",
+              {
+                style: { cursor: "pointer" },
+                onPointerDown: (e) => e.stopPropagation(),
+                onClick: () => handleExportPdf(paperIdx),
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "rect",
+                    {
+                      x: padX + exportBtnW + fontSize * 2,
+                      y: exportBtnY,
+                      width: exportBtnW,
+                      height: exportBtnH,
+                      rx: 1.5,
+                      ry: 1.5,
+                      fill: "#1e40af"
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "text",
+                    {
+                      x: padX + exportBtnW + fontSize * 2 + exportBtnW / 2,
+                      y: exportBtnY + exportBtnH / 2 + fontSize * 0.35,
+                      textAnchor: "middle",
+                      fontSize,
+                      fill: "#fff",
+                      style: { pointerEvents: "none" },
+                      children: "Export PDF"
+                    }
+                  )
+                ]
+              }
+            ),
+            showAction("MODIFY_LAYOUT") && paperResult.producedPerSheet > 0 && /* @__PURE__ */ jsxRuntime.jsxs(
+              "g",
+              {
+                style: { cursor: "pointer" },
+                onPointerDown: (e) => e.stopPropagation(),
+                onClick: () => setModifyingPaper(paperResult),
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "rect",
+                    {
+                      x: padX + (exportBtnW + fontSize * 2) * 2,
+                      y: exportBtnY,
+                      width: exportBtnW,
+                      height: exportBtnH,
+                      rx: 1.5,
+                      ry: 1.5,
+                      fill: "#7c3aed"
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "text",
+                    {
+                      x: padX + (exportBtnW + fontSize * 2) * 2 + exportBtnW / 2,
+                      y: exportBtnY + exportBtnH / 2 + fontSize * 0.35,
+                      textAnchor: "middle",
+                      fontSize,
+                      fill: "#fff",
+                      style: { pointerEvents: "none" },
+                      children: "Modify Layout"
+                    }
+                  )
+                ]
+              }
+            )
           ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs(
-            "g",
-            {
-              style: { cursor: "pointer" },
-              onPointerDown: (e) => e.stopPropagation(),
-              onClick: () => handleExportImage(paperIdx),
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx(
-                  "rect",
-                  {
-                    x: padX,
-                    y: exportBtnY,
-                    width: exportBtnW,
-                    height: exportBtnH,
-                    rx: 1.5,
-                    ry: 1.5,
-                    fill: "#0f172a"
-                  }
-                ),
-                /* @__PURE__ */ jsxRuntime.jsx(
-                  "text",
-                  {
-                    x: padX + exportBtnW / 2,
-                    y: exportBtnY + exportBtnH / 2 + fontSize * 0.35,
-                    textAnchor: "middle",
-                    fontSize,
-                    fill: "#fff",
-                    style: { pointerEvents: "none" },
-                    children: "Export Sheet"
-                  }
-                )
-              ]
-            }
-          ),
-          /* @__PURE__ */ jsxRuntime.jsxs(
-            "g",
-            {
-              style: { cursor: "pointer" },
-              onPointerDown: (e) => e.stopPropagation(),
-              onClick: () => handleExportPdf(paperIdx),
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx(
-                  "rect",
-                  {
-                    x: padX + exportBtnW + fontSize * 2,
-                    y: exportBtnY,
-                    width: exportBtnW,
-                    height: exportBtnH,
-                    rx: 1.5,
-                    ry: 1.5,
-                    fill: "#1e40af"
-                  }
-                ),
-                /* @__PURE__ */ jsxRuntime.jsx(
-                  "text",
-                  {
-                    x: padX + exportBtnW + fontSize * 2 + exportBtnW / 2,
-                    y: exportBtnY + exportBtnH / 2 + fontSize * 0.35,
-                    textAnchor: "middle",
-                    fontSize,
-                    fill: "#fff",
-                    style: { pointerEvents: "none" },
-                    children: "Export PDF"
-                  }
-                )
-              ]
-            }
-          ),
-          paperResult.producedPerSheet > 0 && /* @__PURE__ */ jsxRuntime.jsxs(
-            "g",
-            {
-              style: { cursor: "pointer" },
-              onPointerDown: (e) => e.stopPropagation(),
-              onClick: () => setModifyingPaper(paperResult),
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx(
-                  "rect",
-                  {
-                    x: padX + (exportBtnW + fontSize * 2) * 2,
-                    y: exportBtnY,
-                    width: exportBtnW,
-                    height: exportBtnH,
-                    rx: 1.5,
-                    ry: 1.5,
-                    fill: "#7c3aed"
-                  }
-                ),
-                /* @__PURE__ */ jsxRuntime.jsx(
-                  "text",
-                  {
-                    x: padX + (exportBtnW + fontSize * 2) * 2 + exportBtnW / 2,
-                    y: exportBtnY + exportBtnH / 2 + fontSize * 0.35,
-                    textAnchor: "middle",
-                    fontSize,
-                    fill: "#fff",
-                    style: { pointerEvents: "none" },
-                    children: "Modify Layout"
-                  }
-                )
-              ]
-            }
-          ),
           /* @__PURE__ */ jsxRuntime.jsxs("g", { transform: `translate(0, ${paperOriginY})`, children: [
             /* @__PURE__ */ jsxRuntime.jsx(
               "rect",
@@ -5665,30 +7115,30 @@ var AUTO_LAYOUT = react.forwardRef(
                 strokeWidth: 0.5
               }
             ),
-            config.isShowColorbar && /* @__PURE__ */ jsxRuntime.jsx(
+            (config.isShowColorbar ?? true) && /* @__PURE__ */ jsxRuntime.jsx(
               Colorbar,
               {
                 side: colorbarSide,
-                colorbarHeight: config.colorbarHeight,
+                colorbarHeight: config.colorbarHeight ?? 5,
                 paperWidth: paperResult.paperWidth,
                 paperHeight: paperResult.paperHeight
               }
             ),
-            config.spacing > 0 && getSpacingRects2(
+            (config.spacing ?? 5) > 0 && getSpacingRects2(
               gripperSide,
               paperResult.paperWidth,
               paperResult.paperHeight,
-              config.spacing,
-              config.griper,
+              config.spacing ?? 5,
+              config.griper ?? 10,
               cbDepth
             ).map((r, i) => /* @__PURE__ */ jsxRuntime.jsx("rect", { x: r.x, y: r.y, width: r.w, height: r.h, fill: theme.colorSpacing }, `sp-${i}`)),
-            config.griper > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+            (config.griper ?? 10) > 0 && /* @__PURE__ */ jsxRuntime.jsx(
               Gripper,
               {
                 side: gripperSide,
                 paperWidth: paperResult.paperWidth,
                 paperHeight: paperResult.paperHeight,
-                depth: config.griper,
+                depth: config.griper ?? 10,
                 fillColor: theme.colorGriper
               }
             ),
@@ -5750,6 +7200,10 @@ var DIE_LINE_LAYOUT = react.forwardRef(
         return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_1040A, { ref, ...props });
       case "BECF-11D01":
         return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_11D01, { ref, ...props });
+      case "BECF-12101":
+        return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_12101, { ref, ...props });
+      case "BECF-12109":
+        return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_12109, { ref, ...props });
       default:
         return null;
     }
@@ -5786,12 +7240,19 @@ var BECF_1040A_DEFAULT_ATTRIBUTES = {
   tuckFlap: 14
 };
 
-// src/statics/standard-boxes/becf-11d01/DEFAULT_ATTRIBUTES.ts
-var BECF_11D01_DEFAULT_ATTRIBUTES = {
+// src/statics/bags-pillows/becf-12101/DEFAULT_ATTRIBUTES.ts
+var BECF_12101_DEFAULT_ATTRIBUTES = {
+  length: 100,
+  width: 50,
+  height: 150,
+  glueArea: 13
+};
+
+// src/statics/bags-pillows/becf-12109/DEFAULT_ATTRIBUTES.ts
+var BECF_12109_DEFAULT_ATTRIBUTES = {
   length: 100,
   width: 50,
   height: 150,
-  flapHeight: 50,
   glueArea: 13
 };
 
@@ -5818,21 +7279,46 @@ var modelList = [
     dimension: ["DIE_LINE"],
     attributes: { ...BECF_1030A_DEFAULT_ATTRIBUTES }
   },
+  // {
+  //   id: "BECF-11D01",
+  //   nameEN: "Standard Box BECF-11D01",
+  //   nameTH: "กล่องทั่วไป BECF-11D01",
+  //   dimension: ["DIE_LINE"],
+  //   attributes: { ...BECF_11D01_DEFAULT_ATTRIBUTES },
+  // },
   {
-    id: "BECF-11D01",
-    nameEN: "Standard Box BECF-11D01",
-    nameTH: "\u0E01\u0E25\u0E48\u0E2D\u0E07\u0E17\u0E31\u0E48\u0E27\u0E44\u0E1B BECF-11D01",
+    id: "BECF-12101",
+    nameEN: "SHOPPING BAGS TYPE A",
+    nameTH: "\u0E16\u0E38\u0E07\u0E23\u0E49\u0E2D\u0E22\u0E40\u0E0A\u0E37\u0E2D\u0E01\u0E40\u0E1B\u0E35\u0E22 \u0E21\u0E31\u0E14\u0E1B\u0E21 A",
     dimension: ["DIE_LINE"],
-    attributes: { ...BECF_11D01_DEFAULT_ATTRIBUTES }
+    attributes: { ...BECF_12101_DEFAULT_ATTRIBUTES }
+  },
+  {
+    id: "BECF-12109",
+    nameEN: "SHOPPING BAGS TYPE B",
+    nameTH: "\u0E16\u0E38\u0E07\u0E23\u0E49\u0E2D\u0E22\u0E40\u0E0A\u0E37\u0E2D\u0E01\u0E40\u0E1B\u0E35\u0E22 \u0E21\u0E31\u0E14\u0E1B\u0E21 B",
+    dimension: ["DIE_LINE"],
+    attributes: { ...BECF_12109_DEFAULT_ATTRIBUTES }
   }
 ];
 
+// src/statics/standard-boxes/becf-11d01/DEFAULT_ATTRIBUTES.ts
+var BECF_11D01_DEFAULT_ATTRIBUTES = {
+  length: 100,
+  width: 50,
+  height: 150,
+  flapHeight: 50,
+  glueArea: 13
+};
+
 exports.AUTO_LAYOUT = AUTO_LAYOUT;
 exports.AUTO_LAYOUT_THEME_CONFIG = AUTO_LAYOUT_THEME_CONFIG;
 exports.BECF_1010A_DEFAULT_ATTRIBUTES = BECF_1010A_DEFAULT_ATTRIBUTES;
 exports.BECF_1030A_DEFAULT_ATTRIBUTES = BECF_1030A_DEFAULT_ATTRIBUTES;
 exports.BECF_1040A_DEFAULT_ATTRIBUTES = BECF_1040A_DEFAULT_ATTRIBUTES;
 exports.BECF_11D01_DEFAULT_ATTRIBUTES = BECF_11D01_DEFAULT_ATTRIBUTES;
+exports.BECF_12101_DEFAULT_ATTRIBUTES = BECF_12101_DEFAULT_ATTRIBUTES;
+exports.BECF_12109_DEFAULT_ATTRIBUTES = BECF_12109_DEFAULT_ATTRIBUTES;
 exports.Colorbar = Colorbar;
 exports.DIE_LINE_LAYOUT = DIE_LINE_LAYOUT;
 exports.Gripper = Gripper;
@@ -5840,6 +7326,8 @@ exports.MODEL_BECF_1010A = MODEL_BECF_1010A;
 exports.MODEL_BECF_1030A = MODEL_BECF_1030A;
 exports.MODEL_BECF_1040A = MODEL_BECF_1040A;
 exports.MODEL_BECF_11D01 = MODEL_BECF_11D01;
+exports.MODEL_BECF_12101 = MODEL_BECF_12101;
+exports.MODEL_BECF_12109 = MODEL_BECF_12109;
 exports.MODEL_THEME_CONFIG = MODEL_THEME_CONFIG;
 exports.appendColorbarToSvg = appendColorbarToSvg;
 exports.appendGripperToSvg = appendGripperToSvg;