@lucablockltd/ultimate-packaging 1.2.0 → 1.3.0

package/dist/index.js

@@ -3761,13 +3761,48 @@ 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;
+  const xFront = kulak;
+  const xSide1 = kulak + A;
+  const xBack = kulak + A + B;
+  const xSide2 = kulak + 2 * A + B;
+  const xEnd = kulak + 2 * A + 2 * B - 2;
+  const yFoldBottom = D + C;
+  const yNotchStart = yFoldBottom + NOTCH_Y;
+  const yEnd = D + C + B / 2 + DIP2;
   return [
+    // Top edge
     { x: 0, y: 0 },
-    { x: totalWidth, y: 0 },
-    { x: totalWidth, y: totalHeight },
-    { x: 0, y: totalHeight }
+    { x: xEnd, y: 0 },
+    // Right edge (stops at yFoldBottom)
+    { x: xEnd, y: yFoldBottom },
+    // xEnd V-notch (left side only — last boundary)
+    { x: xEnd - NOTCH_X, y: yNotchStart },
+    { x: xEnd - NOTCH_X, y: yEnd },
+    // Bottom segment → xSide2 notch
+    { x: xSide2 + NOTCH_X, y: yEnd },
+    { x: xSide2 + NOTCH_X, y: yNotchStart },
+    { x: xSide2, y: yFoldBottom },
+    { x: xSide2 - NOTCH_X, y: yNotchStart },
+    { x: xSide2 - NOTCH_X, y: yEnd },
+    // Bottom segment → xBack notch
+    { x: xBack + NOTCH_X, y: yEnd },
+    { x: xBack + NOTCH_X, y: yNotchStart },
+    { x: xBack, y: yFoldBottom },
+    { x: xBack - NOTCH_X, y: yNotchStart },
+    { x: xBack - NOTCH_X, y: yEnd },
+    // Bottom segment → xSide1 notch
+    { x: xSide1 + NOTCH_X, y: yEnd },
+    { x: xSide1 + NOTCH_X, y: yNotchStart },
+    { x: xSide1, y: yFoldBottom },
+    { x: xSide1 - NOTCH_X, y: yNotchStart },
+    { x: xSide1 - NOTCH_X, y: yEnd },
+    // Bottom segment → xFront notch (right side only — first boundary)
+    { x: xFront + NOTCH_X, y: yEnd },
+    { x: xFront + NOTCH_X, y: yNotchStart },
+    { x: xFront, y: yFoldBottom },
+    // Glue flap diagonal
+    { x: 0, y: yFoldBottom - kulak }
+    // Left edge back to top
   ];
 }
 function offsetContour6(points, distance) {
@@ -4187,194 +4222,1257 @@ var MODEL_BECF_12109 = 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 };
-}
-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;
+// src/components/dieline/bags-pillows/becf-c-12101/generate.ts
+var DIP3 = 15;
+var RIBBON_HALF_W = 9;
+var RIBBON_DX = 2;
+var RIBBON_DY = 2;
+var D_MAX3 = 40;
+function calcD3(c, b) {
+  return Math.min(c - 2 - b / 2, D_MAX3);
+}
+function calcKulak3(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 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 calcX3(a) {
+  return Math.min(a / 2, 110);
 }
-
-// src/utils/autoLayout/calculate/shared.ts
-var RESOLUTION = 1;
-function resolveGripperSide(paperWidth, paperHeight) {
-  if (paperWidth >= paperHeight) return "bottom";
-  return "left";
+function getAutoCalcValues3(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD3(C, B);
+  const kulak = glueArea ?? calcKulak3(B);
+  const X = calcX3(A);
+  return { d: D, kulak, dip: DIP3, ribbonHW: RIBBON_HALF_W, ribbonDX: RIBBON_DX, ribbonDY: RIBBON_DY, ribbonX: X };
 }
-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 line7(x1, y1, x2, y2) {
+  return `M${x1} ${y1} L${x2} ${y2}`;
 }
-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 generateBecfC12101(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD3(C, B);
+  const kulak = glueArea ?? calcKulak3(B);
+  const X = calcX3(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 + DIP3;
+  const totalWidth = xEnd;
+  const totalHeight = yEnd;
+  const cut = [];
+  const crease = [];
+  cut.push(line7(0, 0, totalWidth, 0));
+  cut.push(line7(totalWidth, 0, totalWidth, totalHeight));
+  cut.push(line7(totalWidth, totalHeight, 0, totalHeight));
+  cut.push(line7(0, totalHeight, 0, 0));
+  cut.push(line7(kulak + B / 2, yBottomFlap, kulak + B / 2, yEnd));
+  cut.push(line7(kulak + A - B / 2, yBottomFlap, kulak + A - B / 2, yEnd));
+  cut.push(line7(kulak + A + B + B / 2, yBottomFlap, kulak + A + B + B / 2, yEnd));
+  cut.push(line7(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 yNotchTop = yFoldTop - RIBBON_DY / 2;
+  const yNotchBot = yFoldTop + RIBBON_DY / 2;
+  function addRibbonNotch(cx) {
+    cut.push(line7(cx - RIBBON_HALF_W, yNotchBot, cx + RIBBON_HALF_W, yNotchBot));
+    cut.push(line7(cx - RIBBON_HALF_W - RIBBON_DX, yNotchTop, cx - RIBBON_HALF_W, yNotchBot));
+    cut.push(line7(cx + RIBBON_HALF_W + RIBBON_DX, yNotchTop, cx + RIBBON_HALF_W, yNotchBot));
+  }
+  addRibbonNotch(frontCx - X / 2);
+  addRibbonNotch(frontCx + X / 2);
+  addRibbonNotch(backCx - X / 2);
+  addRibbonNotch(backCx + X / 2);
+  crease.push(line7(0, yFoldTop, totalWidth, yFoldTop));
+  crease.push(line7(0, yFoldBottomStart, totalWidth, yFoldBottomStart));
+  crease.push(line7(0, yFoldBottom, totalWidth, yFoldBottom));
+  crease.push(line7(xFront, 0, xFront, totalHeight));
+  crease.push(line7(xSide1, 0, xSide1, totalHeight));
+  crease.push(line7(xSide1Mid, 0, xSide1Mid, totalHeight));
+  crease.push(line7(xBack, 0, xBack, totalHeight));
+  crease.push(line7(xSide2, 0, xSide2, totalHeight));
+  crease.push(line7(xSide2Mid, 0, xSide2Mid, totalHeight));
+  crease.push(line7(0, yFoldBottom - kulak, kulak + B / 2, yBottomFlap));
+  crease.push(line7(kulak + A - B / 2, yBottomFlap, xSide1Mid, yFoldBottomStart));
+  crease.push(line7(xSide1Mid, yFoldBottomStart, kulak + A + B + B / 2, yBottomFlap));
+  crease.push(line7(kulak + 2 * A + B - B / 2, yBottomFlap, xSide2Mid, yFoldBottomStart));
+  crease.push(line7(xSide2Mid, yFoldBottomStart, xEnd, D + C - 2));
+  return { cut, crease, viewBox: { width: totalWidth, height: totalHeight } };
 }
-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;
-  }
-  return { dx: dlMinX - ocMinX, dy: dlMinY - ocMinY };
+function generateOuterContour7(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD3(C, B);
+  const kulak = glueArea ?? calcKulak3(B);
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = D + C + B / 2 + DIP3;
+  return [
+    { x: 0, y: 0 },
+    { x: totalWidth, y: 0 },
+    { x: totalWidth, y: totalHeight },
+    { x: 0, y: totalHeight }
+  ];
 }
-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
-          });
-        }
-      }
+function offsetContour7(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;
     }
-    if (placements.length > bestCandidate.producedPerSheet) {
-      bestCandidate = { rotation: deg, placements, producedPerSheet: placements.length };
-      bestGridPositions = gridPositions;
-      bestBitmapW = pieceBitmap.width;
-      bestBitmapH = pieceBitmap.height;
+    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 });
   }
-  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;
+  return result;
+}
+function contourToPath7(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 generateDimensions7(attr, unit) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD3(C, B);
+  const kulak = glueArea ?? calcKulak3(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 + DIP3;
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = yEnd;
+  const bottomSection = B / 2 + DIP3;
+  return [
+    {
+      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
+    },
+    {
+      x1: xBack + A * 0.6,
+      y1: yFoldTop,
+      x2: xBack + A * 0.6,
+      y2: yFoldBottom,
+      label: fmt(C),
+      orientation: "vertical",
+      offset: -10
+    },
+    {
+      x1: xBack + A * 0.6,
+      y1: 0,
+      x2: xBack + A * 0.6,
+      y2: yFoldTop,
+      label: fmt(D),
+      orientation: "vertical",
+      offset: -10
+    },
+    {
+      x1: xBack + A * 0.6,
+      y1: yFoldBottom,
+      x2: xBack + A * 0.6,
+      y2: yEnd,
+      label: fmt(bottomSection),
+      orientation: "vertical",
+      offset: -10
+    },
+    {
+      x1: xFront,
+      y1: yFoldTop + C * 0.65,
+      x2: xSide1,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(A),
+      orientation: "horizontal",
+      offset: -20
+    },
+    {
+      x1: xSide1,
+      y1: yFoldTop + C * 0.65,
+      x2: xBack,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(B),
+      orientation: "horizontal",
+      offset: -20
+    },
+    {
+      x1: 0,
+      y1: yFoldTop + C * 0.65,
+      x2: xFront,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(kulak),
+      orientation: "horizontal",
+      offset: -20
+    }
+  ];
+}
+var MODEL_ID7 = "BECF-C-12101";
+var UNIT_FACTOR7 = {
+  mm: 1,
+  cm: 0.1,
+  in: 1 / 25.4
+};
+var PX_PER_MM7 = 96 / 25.4;
+function renderDimension7(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_C_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(() => generateBecfC12101(attributes), [attributes]);
+    const dimensions = react.useMemo(
+      () => generateDimensions7(attributes, unit),
+      [attributes, unit]
+    );
+    const factor = UNIT_FACTOR7[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 = getAutoCalcValues3(attributes);
+        return {
+          getAttributes: () => ({
+            modelId: MODEL_ID7,
+            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,
+            ribbonHW: auto.ribbonHW * factor,
+            ribbonDX: auto.ribbonDX * factor,
+            ribbonDY: auto.ribbonDY * factor,
+            ribbonX: auto.ribbonX * 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_MM7);
+              canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM7);
+            } 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 = generateDimensions7(attributes, unit);
+            return exportDimensionPdf({
+              modelId: MODEL_ID7,
+              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) => renderDimension7(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_C_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(() => generateBecfC12101(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_MM7);
+          canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM7);
+        } 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_C_12101, { ref: dieLineRef, ...props, renderAs: "group" })
+      }
+    );
+  }
+);
+var MODEL_BECF_C_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_C_12101, { ref, ...props });
+        case "3D":
+          return null;
+        case "AUTO_LAYOUT":
+          return /* @__PURE__ */ jsxRuntime.jsx(DIE_LINE_BECF_C_12101, { ref, ...props });
+        default:
+          return null;
+      }
+    })() });
+  }
+);
+
+// src/components/dieline/bags-pillows/becf-c-12109/generate.ts
+var DIP4 = 13;
+var RIBBON_HALF_W2 = 9;
+var RIBBON_DX2 = 2;
+var RIBBON_DY2 = 2;
+var D_MAX4 = 40;
+var NOTCH_X2 = 3;
+var NOTCH_Y2 = 5;
+function calcD4(c, b) {
+  return Math.min(c - 2 - b / 2, D_MAX4);
+}
+function calcKulak4(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 calcX4(a) {
+  return a / 2;
+}
+function getAutoCalcValues4(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD4(C, B);
+  const kulak = glueArea ?? calcKulak4(B);
+  const X = calcX4(A);
+  return { d: D, kulak, dip: DIP4, ribbonHW: RIBBON_HALF_W2, ribbonDX: RIBBON_DX2, ribbonDY: RIBBON_DY2, ribbonX: X };
+}
+function line8(x1, y1, x2, y2) {
+  return `M${x1} ${y1} L${x2} ${y2}`;
+}
+function generateBecfC12109(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD4(C, B);
+  const kulak = glueArea ?? calcKulak4(B);
+  const X = calcX4(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_Y2;
+  const yEnd = D + C + B / 2 + DIP4;
+  const totalWidth = xEnd;
+  const totalHeight = yEnd;
+  const cut = [];
+  const crease = [];
+  cut.push(line8(0, 0, 0, yFoldBottom - kulak));
+  cut.push(line8(0, 0, totalWidth, 0));
+  cut.push(line8(totalWidth, 0, totalWidth, yFoldBottom));
+  cut.push(line8(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(line8(xb - NOTCH_X2, yNotchStart, xb - NOTCH_X2, totalHeight));
+      cut.push(line8(xb - NOTCH_X2, yNotchStart, xb, yFoldBottom));
+    }
+    if (!isLast) {
+      cut.push(line8(xb + NOTCH_X2, yNotchStart, xb + NOTCH_X2, totalHeight));
+      cut.push(line8(xb + NOTCH_X2, yNotchStart, xb, yFoldBottom));
+    }
+  }
+  cut.push(line8(xFront + NOTCH_X2, totalHeight, xSide1 - NOTCH_X2, totalHeight));
+  cut.push(line8(xSide1 + NOTCH_X2, totalHeight, xBack - NOTCH_X2, totalHeight));
+  cut.push(line8(xBack + NOTCH_X2, totalHeight, xSide2 - NOTCH_X2, totalHeight));
+  cut.push(line8(xSide2 + NOTCH_X2, totalHeight, xEnd - NOTCH_X2, totalHeight));
+  const frontCx = kulak + A / 2;
+  const backCx = kulak + A + B + A / 2;
+  const yRibbonTop = yFoldTop - RIBBON_DY2 / 2;
+  const yRibbonBot = yFoldTop + RIBBON_DY2 / 2;
+  function addRibbonNotch(cx) {
+    cut.push(line8(cx - RIBBON_HALF_W2, yRibbonBot, cx + RIBBON_HALF_W2, yRibbonBot));
+    cut.push(line8(cx - RIBBON_HALF_W2 - RIBBON_DX2, yRibbonTop, cx - RIBBON_HALF_W2, yRibbonBot));
+    cut.push(line8(cx + RIBBON_HALF_W2 + RIBBON_DX2, yRibbonTop, cx + RIBBON_HALF_W2, yRibbonBot));
+  }
+  addRibbonNotch(frontCx - X / 2);
+  addRibbonNotch(frontCx + X / 2);
+  addRibbonNotch(backCx - X / 2);
+  addRibbonNotch(backCx + X / 2);
+  crease.push(line8(0, yFoldTop, totalWidth, yFoldTop));
+  crease.push(line8(0, yFoldBottomStart, totalWidth, yFoldBottomStart));
+  crease.push(line8(kulak, yFoldBottom, xEnd, yFoldBottom));
+  crease.push(line8(xFront, 0, xFront, yFoldBottom));
+  crease.push(line8(xSide1, 0, xSide1, yFoldBottom));
+  crease.push(line8(xBack, 0, xBack, yFoldBottom));
+  crease.push(line8(xSide2, 0, xSide2, yFoldBottom));
+  crease.push(line8(xSide1Mid, 0, xSide1Mid, totalHeight));
+  crease.push(line8(xSide2Mid, 0, xSide2Mid, totalHeight));
+  crease.push(line8(xBack, yFoldBottom, xSide1Mid, yFoldBottomStart));
+  crease.push(line8(xSide1Mid, yFoldBottomStart, xSide1, yFoldBottom));
+  crease.push(line8(xSide2Mid, yFoldBottomStart, xSide2, yFoldBottom));
+  crease.push(line8(xSide2Mid, yFoldBottomStart, xEnd, D + C - 2));
+  return { cut, crease, viewBox: { width: totalWidth, height: totalHeight } };
+}
+function generateOuterContour8(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD4(C, B);
+  const kulak = glueArea ?? calcKulak4(B);
+  const xFront = kulak;
+  const xSide1 = kulak + A;
+  const xBack = kulak + A + B;
+  const xSide2 = kulak + 2 * A + B;
+  const xEnd = kulak + 2 * A + 2 * B - 2;
+  const yFoldBottom = D + C;
+  const yNotchStart = yFoldBottom + NOTCH_Y2;
+  const yEnd = D + C + B / 2 + DIP4;
+  return [
+    { x: 0, y: 0 },
+    { x: xEnd, y: 0 },
+    { x: xEnd, y: yFoldBottom },
+    { x: xEnd - NOTCH_X2, y: yNotchStart },
+    { x: xEnd - NOTCH_X2, y: yEnd },
+    { x: xSide2 + NOTCH_X2, y: yEnd },
+    { x: xSide2 + NOTCH_X2, y: yNotchStart },
+    { x: xSide2, y: yFoldBottom },
+    { x: xSide2 - NOTCH_X2, y: yNotchStart },
+    { x: xSide2 - NOTCH_X2, y: yEnd },
+    { x: xBack + NOTCH_X2, y: yEnd },
+    { x: xBack + NOTCH_X2, y: yNotchStart },
+    { x: xBack, y: yFoldBottom },
+    { x: xBack - NOTCH_X2, y: yNotchStart },
+    { x: xBack - NOTCH_X2, y: yEnd },
+    { x: xSide1 + NOTCH_X2, y: yEnd },
+    { x: xSide1 + NOTCH_X2, y: yNotchStart },
+    { x: xSide1, y: yFoldBottom },
+    { x: xSide1 - NOTCH_X2, y: yNotchStart },
+    { x: xSide1 - NOTCH_X2, y: yEnd },
+    { x: xFront + NOTCH_X2, y: yEnd },
+    { x: xFront + NOTCH_X2, y: yNotchStart },
+    { x: xFront, y: yFoldBottom },
+    { x: 0, y: yFoldBottom - kulak }
+  ];
+}
+function offsetContour8(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 contourToPath8(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 generateDimensions8(attr, unit) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD4(C, B);
+  const kulak = glueArea ?? calcKulak4(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 + DIP4;
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = yEnd;
+  const bottomSection = B / 2 + DIP4;
+  return [
+    {
+      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
+    },
+    {
+      x1: xBack + A * 0.6,
+      y1: yFoldTop,
+      x2: xBack + A * 0.6,
+      y2: yFoldBottom,
+      label: fmt(C),
+      orientation: "vertical",
+      offset: -10
+    },
+    {
+      x1: xBack + A * 0.6,
+      y1: 0,
+      x2: xBack + A * 0.6,
+      y2: yFoldTop,
+      label: fmt(D),
+      orientation: "vertical",
+      offset: -10
+    },
+    {
+      x1: xBack + A * 0.6,
+      y1: yFoldBottom,
+      x2: xBack + A * 0.6,
+      y2: yEnd,
+      label: fmt(bottomSection),
+      orientation: "vertical",
+      offset: -10
+    },
+    {
+      x1: xFront,
+      y1: yFoldTop + C * 0.65,
+      x2: xSide1,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(A),
+      orientation: "horizontal",
+      offset: -20
+    },
+    {
+      x1: xSide1,
+      y1: yFoldTop + C * 0.65,
+      x2: xBack,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(B),
+      orientation: "horizontal",
+      offset: -20
+    },
+    {
+      x1: 0,
+      y1: yFoldTop + C * 0.65,
+      x2: xFront,
+      y2: yFoldTop + C * 0.65,
+      label: fmt(kulak),
+      orientation: "horizontal",
+      offset: -20
+    }
+  ];
+}
+var MODEL_ID8 = "BECF-C-12109";
+var UNIT_FACTOR8 = {
+  mm: 1,
+  cm: 0.1,
+  in: 1 / 25.4
+};
+var PX_PER_MM8 = 96 / 25.4;
+function renderDimension8(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_C_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(() => generateBecfC12109(attributes), [attributes]);
+    const dimensions = react.useMemo(
+      () => generateDimensions8(attributes, unit),
+      [attributes, unit]
+    );
+    const factor = UNIT_FACTOR8[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 = getAutoCalcValues4(attributes);
+        return {
+          getAttributes: () => ({
+            modelId: MODEL_ID8,
+            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,
+            ribbonHW: auto.ribbonHW * factor,
+            ribbonDX: auto.ribbonDX * factor,
+            ribbonDY: auto.ribbonDY * factor,
+            ribbonX: auto.ribbonX * 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_MM8);
+              canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM8);
+            } 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 = generateDimensions8(attributes, unit);
+            return exportDimensionPdf({
+              modelId: MODEL_ID8,
+              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) => renderDimension8(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_C_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(() => generateBecfC12109(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_MM8);
+          canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM8);
+        } 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_C_12109, { ref: dieLineRef, ...props, renderAs: "group" })
+      }
+    );
+  }
+);
+var MODEL_BECF_C_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_C_12109, { ref, ...props });
+        case "3D":
+          return null;
+        case "AUTO_LAYOUT":
+          return /* @__PURE__ */ jsxRuntime.jsx(DIE_LINE_BECF_C_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;
+  }
+  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;
@@ -4384,52 +5482,378 @@ function computeLayoutForPaperDefault(contourPoints, dielineW, dielineH, paperWi
       p.y += offsetY;
     }
   }
-  return bestCandidate;
+  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();
+  let stepY_AB = findMinStepY_multi(pA, stepX_A, pB, offsetX);
+  let stepY_BA = findMinStepY_multi(pB, stepX_B, pA, -offsetX);
+  if (stepY_AB + stepY_BA <= 0) return emptyResult();
+  const minAA = findMinStepY_multi(pA, stepX_A, pA, 0);
+  const minBB = findMinStepY_multi(pB, stepX_B, pB, 0);
+  const cycle = stepY_AB + stepY_BA;
+  const neededCycle = Math.max(cycle, minAA, minBB);
+  if (neededCycle > cycle) {
+    const scale = neededCycle / cycle;
+    stepY_AB *= scale;
+    stepY_BA *= scale;
+  }
+  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-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-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 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 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 = Math.max(
+    gapAB + findMinStepX(pB, pA, 0),
+    findMinStepX(pA, pA, 0),
+    findMinStepX(pB, pB, 0)
+  );
+  const pairStepY = findPairRowStepY(pA, pB, gapAB, pairStepX);
+  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;
+    }
+  }
+  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;
     }
   }
-  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;
+  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;
+    }
+  }
+  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));
+    }
+  }
+  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);
+    }
+  }
+  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;
   }
-  return { width, height, nY, nX, rightX, leftX, bottomY, topY };
+  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
+  };
 }
-function prepareRotation(contourPoints, dielineW, dielineH, deg) {
+
+// 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),
@@ -4437,119 +5861,176 @@ function prepareRotation(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);
+function findPairRowStepY2(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;
-  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;
+    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 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();
+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 = Math.max(
+    gapAB + findMinStepX(pB, pA, 0),
+    findMinStepX(pA, pA, 0),
+    findMinStepX(pB, pB, 0)
+  );
+  if (pairStepX <= 0) return emptyResult();
+  const pairStepY = findPairRowStepY2(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 < 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;
+  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;
+    }
+  }
+  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;
+  }
+  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 { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-function dualRotGrid(rdA, rdB, offsetX, bounds) {
+function verticalPairGrid(rdA, rdB, 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 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);
+  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);
+  const vpairStepX = Math.max(stepXAA, stepXAB, stepXBA, stepXBB);
+  if (vpairStepX <= 0) return emptyResult();
+  let vpairStepY = 0;
+  {
+    const reach = Math.max(pA.width, pB.width);
+    const nMin = Math.floor(-reach / vpairStepX) - 1;
+    const nMax = Math.ceil(reach / vpairStepX) + 1;
+    for (let n = nMin; n <= nMax; n++) {
+      const dx = n * vpairStepX;
+      const sAA = findMinStepY(pA, pA, dx);
+      if (sAA > vpairStepY) vpairStepY = sAA;
+      const sAB = findMinStepY(pA, pB, dx) - gapAB_Y;
+      if (sAB > vpairStepY) vpairStepY = sAB;
+      const sBA = findMinStepY(pB, pA, dx) + gapAB_Y;
+      if (sBA > vpairStepY) vpairStepY = sBA;
+      const sBB = findMinStepY(pB, pB, dx);
+      if (sBB > vpairStepY) vpairStepY = sBB;
+    }
+  }
+  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;
-  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;
+  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;
     }
-    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],
@@ -4557,7 +6038,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;
@@ -4566,10 +6047,40 @@ function computeLayoutForPaper(contourPoints, dielineW, dielineH, _paperWidth, _
       results.push(dualRotGrid(rdB, rdA, off, bounds));
     }
   }
-  let best = results[0];
-  for (const r of results) {
-    if (r.count > best.count) best = r;
-  }
+  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 === 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,
@@ -4578,8 +6089,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),
@@ -4587,7 +6098,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();
@@ -4663,11 +6174,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) {
@@ -4691,8 +6202,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 = [];
@@ -4728,8 +6239,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),
@@ -4737,34 +6248,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);
@@ -4776,115 +6273,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) {
@@ -4908,12 +6352,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 = [];
@@ -4949,8 +6389,8 @@ function computeLayoutForPaper3(contourPoints, dielineW, dielineH, _paperWidth,
   };
 }
 
-// src/utils/autoLayout/calculate/bags-pillows/becf-12101/index.ts
-function prepareRotation4(contourPoints, dielineW, dielineH, deg) {
+// src/utils/autoLayout/calculate/bags-pillows/becf-c-12101/index.ts
+function prepareRotation6(contourPoints, dielineW, dielineH, deg) {
   const rotated = normalizePoints(contourPoints, deg);
   return {
     profile: buildProfile(rotated),
@@ -4958,7 +6398,7 @@ function prepareRotation4(contourPoints, dielineW, dielineH, deg) {
     deg
   };
 }
-function pairGrid3(rdA, rdB, bounds) {
+function pairGrid5(rdA, rdB, bounds) {
   const pA = rdA.profile, pB = rdB.profile;
   const gapAB = findMinStepX(pA, pB, 0);
   if (gapAB <= 0) return emptyResult();
@@ -5034,11 +6474,11 @@ function pairGrid3(rdA, rdB, bounds) {
   }
   return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-function computeLayoutForPaper4(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+function computeLayoutForPaper6(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, prepareRotation4(contourPoints, dielineW, dielineH, deg));
+    rd.set(deg, prepareRotation6(contourPoints, dielineW, dielineH, deg));
   }
   const results = [];
   for (const deg of rots) {
@@ -5062,8 +6502,8 @@ function computeLayoutForPaper4(contourPoints, dielineW, dielineH, _paperWidth,
     }
   }
   for (const [a, b] of allPairs) {
-    results.push(pairGrid3(rd.get(a), rd.get(b), bounds));
-    results.push(pairGrid3(rd.get(b), rd.get(a), bounds));
+    results.push(pairGrid5(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid5(rd.get(b), rd.get(a), bounds));
   }
   const singleResults = [];
   const multiResults = [];
@@ -5099,8 +6539,8 @@ function computeLayoutForPaper4(contourPoints, dielineW, dielineH, _paperWidth,
   };
 }
 
-// src/utils/autoLayout/calculate/bags-pillows/becf-12109/index.ts
-function prepareRotation5(contourPoints, dielineW, dielineH, deg) {
+// src/utils/autoLayout/calculate/bags-pillows/becf-c-12109/index.ts
+function prepareRotation7(contourPoints, dielineW, dielineH, deg) {
   const rotated = normalizePoints(contourPoints, deg);
   return {
     profile: buildProfile(rotated),
@@ -5108,7 +6548,7 @@ function prepareRotation5(contourPoints, dielineW, dielineH, deg) {
     deg
   };
 }
-function pairGrid4(rdA, rdB, bounds) {
+function pairGrid6(rdA, rdB, bounds) {
   const pA = rdA.profile, pB = rdB.profile;
   const gapAB = findMinStepX(pA, pB, 0);
   if (gapAB <= 0) return emptyResult();
@@ -5184,11 +6624,11 @@ function pairGrid4(rdA, rdB, bounds) {
   }
   return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-function computeLayoutForPaper5(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+function computeLayoutForPaper7(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, prepareRotation5(contourPoints, dielineW, dielineH, deg));
+    rd.set(deg, prepareRotation7(contourPoints, dielineW, dielineH, deg));
   }
   const results = [];
   for (const deg of rots) {
@@ -5212,8 +6652,8 @@ function computeLayoutForPaper5(contourPoints, dielineW, dielineH, _paperWidth,
     }
   }
   for (const [a, b] of allPairs) {
-    results.push(pairGrid4(rd.get(a), rd.get(b), bounds));
-    results.push(pairGrid4(rd.get(b), rd.get(a), bounds));
+    results.push(pairGrid6(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid6(rd.get(b), rd.get(a), bounds));
   }
   const singleResults = [];
   const multiResults = [];
@@ -5292,6 +6732,22 @@ function resolveModelFunctions(modelId, attrs) {
         offsetContour: offsetContour6
       };
     }
+    case "BECF-C-12101": {
+      const a = attrs;
+      return {
+        contour: generateOuterContour7(a),
+        dieline: generateBecfC12101(a),
+        offsetContour: offsetContour7
+      };
+    }
+    case "BECF-C-12109": {
+      const a = attrs;
+      return {
+        contour: generateOuterContour8(a),
+        dieline: generateBecfC12109(a),
+        offsetContour: offsetContour8
+      };
+    }
     case "BECF-1010A":
     default: {
       const a = attrs;
@@ -5315,6 +6771,10 @@ function resolveLayoutCalculator(modelId) {
       return computeLayoutForPaper4;
     case "BECF-12109":
       return computeLayoutForPaper5;
+    case "BECF-C-12101":
+      return computeLayoutForPaper6;
+    case "BECF-C-12109":
+      return computeLayoutForPaper7;
     default:
       return computeLayoutForPaperDefault;
   }
@@ -5328,11 +6788,11 @@ function calculateAutoLayout(rawConfig) {
     colorbarHeight: rawConfig.colorbarHeight ?? 5,
     isShowColorbar: rawConfig.isShowColorbar ?? true
   };
-  const { contour, dieline, offsetContour: offsetContour7 } = resolveModelFunctions(
+  const { contour, dieline, offsetContour: offsetContour9 } = resolveModelFunctions(
     config.model.modelId,
     config.model.attributes
   );
-  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour7(contour, config.layoutDistance / 2) : contour;
+  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour9(contour, config.layoutDistance / 2) : contour;
   const cbDepth = config.isShowColorbar ? config.colorbarHeight : 0;
   const computeLayout = resolveLayoutCalculator(config.model.modelId);
   const paperResults = [];
@@ -6283,6 +7743,28 @@ function resolveModel(modelId, attrs, layoutDistance) {
         generateContour: (a) => generateOuterContour6(a)
       };
     }
+    case "BECF-C-12101": {
+      const typedAttrs = attrs;
+      const contour = generateOuterContour7(typedAttrs);
+      return {
+        dieline: generateBecfC12101(typedAttrs),
+        contourPath: contourToPath7(contour),
+        offsetContourPoints: layoutDistance > 0 ? offsetContour7(contour, layoutDistance / 2) : contour,
+        generate: (a) => generateBecfC12101(a),
+        generateContour: (a) => generateOuterContour7(a)
+      };
+    }
+    case "BECF-C-12109": {
+      const typedAttrs = attrs;
+      const contour = generateOuterContour8(typedAttrs);
+      return {
+        dieline: generateBecfC12109(typedAttrs),
+        contourPath: contourToPath8(contour),
+        offsetContourPoints: layoutDistance > 0 ? offsetContour8(contour, layoutDistance / 2) : contour,
+        generate: (a) => generateBecfC12109(a),
+        generateContour: (a) => generateOuterContour8(a)
+      };
+    }
     case "BECF-1010A":
     default: {
       const typedAttrs = attrs;
@@ -6340,6 +7822,22 @@ function renderDieLine2(modelId, attrs) {
             renderAs: "group"
           }
         );
+      case "BECF-C-12101":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          DIE_LINE_BECF_C_12101,
+          {
+            attributes: attrs,
+            renderAs: "group"
+          }
+        );
+      case "BECF-C-12109":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          DIE_LINE_BECF_C_12109,
+          {
+            attributes: attrs,
+            renderAs: "group"
+          }
+        );
       case "BECF-1010A":
       default:
         return /* @__PURE__ */ jsxRuntime.jsx(
@@ -6353,7 +7851,7 @@ function renderDieLine2(modelId, attrs) {
   })();
 }
 var PAPER_GAP = 20;
-var PX_PER_MM7 = 96 / 25.4;
+var PX_PER_MM9 = 96 / 25.4;
 var RESULT_PANEL_HEIGHT = 55;
 var RESULT_GAP = 5;
 function getOpposite2(side) {
@@ -6530,8 +8028,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_MM7)));
-      svg.setAttribute("height", String(Math.round(vh * PX_PER_MM7)));
+      svg.setAttribute("width", String(Math.round(vw * PX_PER_MM9)));
+      svg.setAttribute("height", String(Math.round(vh * PX_PER_MM9)));
       const bg = document.createElementNS(svgNs, "rect");
       bg.setAttribute("width", String(vw));
       bg.setAttribute("height", String(vh));
@@ -6564,8 +8062,8 @@ var AUTO_LAYOUT = react.forwardRef(
         img.src = url;
       });
       const canvas = document.createElement("canvas");
-      canvas.width = Math.round(vw * PX_PER_MM7);
-      canvas.height = Math.round(vh * PX_PER_MM7);
+      canvas.width = Math.round(vw * PX_PER_MM9);
+      canvas.height = Math.round(vh * PX_PER_MM9);
       const ctx = canvas.getContext("2d");
       ctx.fillStyle = "#ffffff";
       ctx.fillRect(0, 0, canvas.width, canvas.height);
@@ -6589,8 +8087,8 @@ var AUTO_LAYOUT = react.forwardRef(
       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_MM7)));
-      svg.setAttribute("height", String(Math.round(paperResult.paperHeight * PX_PER_MM7)));
+      svg.setAttribute("width", String(Math.round(paperResult.paperWidth * PX_PER_MM9)));
+      svg.setAttribute("height", String(Math.round(paperResult.paperHeight * PX_PER_MM9)));
       const bg = document.createElementNS(svgNs, "rect");
       bg.setAttribute("width", String(paperResult.paperWidth));
       bg.setAttribute("height", String(paperResult.paperHeight));
@@ -6694,8 +8192,8 @@ var AUTO_LAYOUT = react.forwardRef(
         img.src = url;
       });
       const canvas = document.createElement("canvas");
-      canvas.width = Math.round(paperResult.paperWidth * PX_PER_MM7);
-      canvas.height = Math.round(paperResult.paperHeight * PX_PER_MM7);
+      canvas.width = Math.round(paperResult.paperWidth * PX_PER_MM9);
+      canvas.height = Math.round(paperResult.paperHeight * PX_PER_MM9);
       const ctx = canvas.getContext("2d");
       ctx.fillStyle = theme.colorPaperFill;
       ctx.fillRect(0, 0, canvas.width, canvas.height);
@@ -7256,6 +8754,22 @@ var BECF_12109_DEFAULT_ATTRIBUTES = {
   glueArea: 13
 };
 
+// src/statics/bags-pillows/becf-c-12101/DEFAULT_ATTRIBUTES.ts
+var BECF_C_12101_DEFAULT_ATTRIBUTES = {
+  length: 100,
+  width: 50,
+  height: 150,
+  glueArea: 13
+};
+
+// src/statics/bags-pillows/becf-c-12109/DEFAULT_ATTRIBUTES.ts
+var BECF_C_12109_DEFAULT_ATTRIBUTES = {
+  length: 100,
+  width: 50,
+  height: 150,
+  glueArea: 13
+};
+
 // src/statics/modelList.ts
 var modelList = [
   {
@@ -7295,10 +8809,24 @@ var modelList = [
   },
   {
     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",
+    nameEN: "SHOPPING BAGS TYPE A1",
+    nameTH: "\u0E16\u0E38\u0E07\u0E23\u0E49\u0E2D\u0E22\u0E40\u0E0A\u0E37\u0E2D\u0E01\u0E40\u0E1B\u0E35\u0E22 \u0E21\u0E31\u0E14\u0E1B\u0E21 A1",
     dimension: ["DIE_LINE"],
     attributes: { ...BECF_12109_DEFAULT_ATTRIBUTES }
+  },
+  {
+    id: "BECF-C-12101",
+    nameEN: "SHOPPING BAGS TYPE C",
+    nameTH: "\u0E16\u0E38\u0E07\u0E2B\u0E39\u0E23\u0E34\u0E1A\u0E1A\u0E34\u0E49\u0E19 C",
+    dimension: ["DIE_LINE"],
+    attributes: { ...BECF_C_12101_DEFAULT_ATTRIBUTES }
+  },
+  {
+    id: "BECF-C-12109",
+    nameEN: "SHOPPING BAGS TYPE C1",
+    nameTH: "\u0E16\u0E38\u0E07\u0E2B\u0E39\u0E23\u0E34\u0E1A\u0E1A\u0E34\u0E49\u0E19 C1",
+    dimension: ["DIE_LINE"],
+    attributes: { ...BECF_C_12109_DEFAULT_ATTRIBUTES }
   }
 ];
 
@@ -7319,6 +8847,8 @@ 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.BECF_C_12101_DEFAULT_ATTRIBUTES = BECF_C_12101_DEFAULT_ATTRIBUTES;
+exports.BECF_C_12109_DEFAULT_ATTRIBUTES = BECF_C_12109_DEFAULT_ATTRIBUTES;
 exports.Colorbar = Colorbar;
 exports.DIE_LINE_LAYOUT = DIE_LINE_LAYOUT;
 exports.Gripper = Gripper;
@@ -7328,6 +8858,8 @@ 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_BECF_C_12101 = MODEL_BECF_C_12101;
+exports.MODEL_BECF_C_12109 = MODEL_BECF_C_12109;
 exports.MODEL_THEME_CONFIG = MODEL_THEME_CONFIG;
 exports.appendColorbarToSvg = appendColorbarToSvg;
 exports.appendGripperToSvg = appendGripperToSvg;