@lucablockltd/ultimate-packaging 1.3.0 → 1.4.0

package/dist/index.js

@@ -446,12 +446,14 @@ var BaseCanvas = react.forwardRef(
     const svgRef = react.useRef(null);
     const dragRef = react.useRef(null);
     const hasInitialFit = react.useRef(false);
+    const frozenViewBox = react.useRef(null);
     const [zoom, setZoom] = react.useState(1);
     const [panX, setPanX] = react.useState(0);
     const [panY, setPanY] = react.useState(0);
     const [dragging, setDragging] = react.useState(false);
-    const vbWidth = initialViewBox.width / zoom;
-    const vbHeight = initialViewBox.height / zoom;
+    const refVB = frozenViewBox.current ?? initialViewBox;
+    const vbWidth = refVB.width / zoom;
+    const vbHeight = refVB.height / zoom;
     const centerX = initialViewBox.x + initialViewBox.width / 2;
     const centerY = initialViewBox.y + initialViewBox.height / 2;
     const vbX = centerX - vbWidth / 2 - panX;
@@ -459,10 +461,11 @@ var BaseCanvas = react.forwardRef(
     const fitView = react.useCallback(() => {
       const container = containerRef.current;
       if (!container) return;
+      frozenViewBox.current = { ...initialViewBox };
       setZoom(clamp(fitPadding, minZoom, maxZoom));
       setPanX(0);
       setPanY(0);
-    }, [initialViewBox.width, initialViewBox.height, fitPadding, minZoom, maxZoom]);
+    }, [initialViewBox.x, initialViewBox.y, initialViewBox.width, initialViewBox.height, fitPadding, minZoom, maxZoom]);
     const resetView = react.useCallback(() => {
       fitView();
     }, [fitView]);
@@ -476,10 +479,6 @@ var BaseCanvas = react.forwardRef(
       hasInitialFit.current = true;
       fitView();
     }, [fitView]);
-    react.useEffect(() => {
-      if (!hasInitialFit.current) return;
-      fitView();
-    }, [initialViewBox.width, initialViewBox.height, fitView]);
     react.useEffect(() => {
       const container = containerRef.current;
       if (!container) return;
@@ -491,12 +490,13 @@ var BaseCanvas = react.forwardRef(
         const cursorXRatio = (e.clientX - rect.left) / rect.width;
         const cursorYRatio = (e.clientY - rect.top) / rect.height;
         const zoomFactor = Math.exp(-e.deltaY * 2e-3);
+        const currentRefVB = frozenViewBox.current ?? initialViewBox;
         setZoom((prevZoom) => {
           const nextZoom = clamp(prevZoom * zoomFactor, minZoom, maxZoom);
-          const prevW = initialViewBox.width / prevZoom;
-          const prevH = initialViewBox.height / prevZoom;
-          const nextW = initialViewBox.width / nextZoom;
-          const nextH = initialViewBox.height / nextZoom;
+          const prevW = currentRefVB.width / prevZoom;
+          const prevH = currentRefVB.height / prevZoom;
+          const nextW = currentRefVB.width / nextZoom;
+          const nextH = currentRefVB.height / nextZoom;
           const dx = (prevW - nextW) * (cursorXRatio - 0.5);
           const dy = (prevH - nextH) * (cursorYRatio - 0.5);
           setPanX((prev) => prev + dx);
@@ -506,7 +506,7 @@ var BaseCanvas = react.forwardRef(
       };
       container.addEventListener("wheel", handleWheel, { passive: false });
       return () => container.removeEventListener("wheel", handleWheel);
-    }, [initialViewBox.width, initialViewBox.height, minZoom, maxZoom]);
+    }, [initialViewBox, minZoom, maxZoom]);
     const onPointerDown = (e) => {
       dragRef.current = { pointerId: e.pointerId, x: e.clientX, y: e.clientY };
       setDragging(true);
@@ -5285,249 +5285,1895 @@ var MODEL_BECF_C_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 };
+// src/components/dieline/bags-pillows/becf-b-12101/generate.ts
+var DIP5 = 15;
+function calcKulak5(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 canPlace(paperGrid, paperW, paperH, piece, px, py) {
-  for (let y = 0; y < piece.height; y++) {
-    const paperY = py + y;
-    if (paperY < 0 || paperY >= paperH) {
-      for (let x = 0; x < piece.width; x++) {
-        if (piece.data[y * piece.width + x]) return false;
-      }
+function getAutoCalcValues5(attr) {
+  const { width: B, glueArea } = attr;
+  const kulak = glueArea ?? calcKulak5(B);
+  return { kulak, dip: DIP5 };
+}
+function line9(x1, y1, x2, y2) {
+  return `M${x1} ${y1} L${x2} ${y2}`;
+}
+function generateBecfB12101(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const kulak = glueArea ?? calcKulak5(B);
+  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 yFoldBottomStart = C - B / 2;
+  const yFoldBottom = C;
+  const yBottomFlap = C + B / 2;
+  const yEnd = C + B / 2 + DIP5;
+  const totalWidth = xEnd;
+  const totalHeight = yEnd;
+  const cut = [];
+  const crease = [];
+  cut.push(line9(0, 0, totalWidth, 0));
+  cut.push(line9(totalWidth, 0, totalWidth, totalHeight));
+  cut.push(line9(totalWidth, totalHeight, 0, totalHeight));
+  cut.push(line9(0, totalHeight, 0, 0));
+  cut.push(line9(kulak + B / 2, yBottomFlap, kulak + B / 2, yEnd));
+  cut.push(line9(kulak + A - B / 2, yBottomFlap, kulak + A - B / 2, yEnd));
+  cut.push(line9(kulak + A + B + B / 2, yBottomFlap, kulak + A + B + B / 2, yEnd));
+  cut.push(line9(kulak + 2 * A + B - B / 2, yBottomFlap, kulak + 2 * A + B - B / 2, yEnd));
+  crease.push(line9(0, yFoldBottomStart, totalWidth, yFoldBottomStart));
+  crease.push(line9(0, yFoldBottom, totalWidth, yFoldBottom));
+  crease.push(line9(xFront, 0, xFront, totalHeight));
+  crease.push(line9(xSide1, 0, xSide1, totalHeight));
+  crease.push(line9(xSide1Mid, 0, xSide1Mid, totalHeight));
+  crease.push(line9(xBack, 0, xBack, totalHeight));
+  crease.push(line9(xSide2, 0, xSide2, totalHeight));
+  crease.push(line9(xSide2Mid, 0, xSide2Mid, totalHeight));
+  crease.push(line9(0, yFoldBottom - kulak, kulak + B / 2, yBottomFlap));
+  crease.push(line9(kulak + A - B / 2, yBottomFlap, xSide1Mid, yFoldBottomStart));
+  crease.push(line9(xSide1Mid, yFoldBottomStart, kulak + A + B + B / 2, yBottomFlap));
+  crease.push(line9(kulak + 2 * A + B - B / 2, yBottomFlap, xSide2Mid, yFoldBottomStart));
+  crease.push(line9(xSide2Mid, yFoldBottomStart, xEnd, C - 2));
+  return { cut, crease, viewBox: { width: totalWidth, height: totalHeight } };
+}
+function generateOuterContour9(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const kulak = glueArea ?? calcKulak5(B);
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = C + B / 2 + DIP5;
+  return [
+    { x: 0, y: 0 },
+    { x: totalWidth, y: 0 },
+    { x: totalWidth, y: totalHeight },
+    { x: 0, y: totalHeight }
+  ];
+}
+function offsetContour9(points, distance) {
+  const n = points.length;
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    const prev = points[(i - 1 + n) % n];
+    const curr = points[i];
+    const next = points[(i + 1) % n];
+    const e1x = curr.x - prev.x;
+    const e1y = curr.y - prev.y;
+    const e2x = next.x - curr.x;
+    const e2y = next.y - curr.y;
+    const len1 = Math.sqrt(e1x * e1x + e1y * e1y);
+    const len2 = Math.sqrt(e2x * e2x + e2y * e2y);
+    if (len1 === 0 || len2 === 0) {
+      result.push(curr);
       continue;
     }
-    for (let x = 0; x < piece.width; x++) {
-      if (!piece.data[y * piece.width + x]) continue;
-      const paperX = px + x;
-      if (paperX < 0 || paperX >= paperW) return false;
-      if (paperGrid[paperY * paperW + paperX]) return false;
+    const n1x = e1y / len1;
+    const n1y = -e1x / len1;
+    const n2x = e2y / len2;
+    const n2y = -e2x / len2;
+    const ax = n1x + n2x;
+    const ay = n1y + n2y;
+    const aLen = Math.sqrt(ax * ax + ay * ay);
+    if (aLen < 1e-3) {
+      result.push({ x: curr.x + n1x * distance, y: curr.y + n1y * distance });
+      continue;
     }
+    const nx = ax / aLen;
+    const ny = ay / aLen;
+    const dot = n1x * nx + n1y * ny;
+    const d = distance / Math.max(dot, 0.1);
+    result.push({ x: curr.x + nx * d, y: curr.y + ny * d });
   }
-  return true;
+  return result;
 }
-function placePiece(paperGrid, paperW, piece, px, py) {
-  for (let y = 0; y < piece.height; y++) {
-    for (let x = 0; x < piece.width; x++) {
-      if (piece.data[y * piece.width + x]) {
-        paperGrid[(py + y) * paperW + (px + x)] = 1;
-      }
-    }
+function contourToPath9(points) {
+  if (points.length === 0) return "";
+  let d = `M${points[0].x} ${points[0].y}`;
+  for (let i = 1; i < points.length; i++) {
+    d += ` L${points[i].x} ${points[i].y}`;
   }
+  d += " Z";
+  return d;
 }
-
-// src/utils/autoLayout/calculate/shared.ts
-var RESOLUTION = 1;
-function resolveGripperSide(paperWidth, paperHeight) {
-  if (paperWidth >= paperHeight) return "bottom";
-  return "left";
+function generateDimensions9(attr, unit) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const kulak = glueArea ?? calcKulak5(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 yFoldBottom = C;
+  const yEnd = C + B / 2 + DIP5;
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = yEnd;
+  const bottomSection = B / 2 + DIP5;
+  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
+    },
+    // Height (C) — body area
+    {
+      x1: xBack + A * 0.6,
+      y1: 0,
+      x2: xBack + A * 0.6,
+      y2: yFoldBottom,
+      label: fmt(C),
+      orientation: "vertical",
+      offset: -10
+    },
+    // Bottom section (B/2 + DIP)
+    {
+      x1: xBack + A * 0.6,
+      y1: yFoldBottom,
+      x2: xBack + A * 0.6,
+      y2: yEnd,
+      label: fmt(bottomSection),
+      orientation: "vertical",
+      offset: -10
+    },
+    // Length (A)
+    {
+      x1: xFront,
+      y1: C * 0.65,
+      x2: xSide1,
+      y2: C * 0.65,
+      label: fmt(A),
+      orientation: "horizontal",
+      offset: -20
+    },
+    // Width (B)
+    {
+      x1: xSide1,
+      y1: C * 0.65,
+      x2: xBack,
+      y2: C * 0.65,
+      label: fmt(B),
+      orientation: "horizontal",
+      offset: -20
+    },
+    // Glue Area (kulak)
+    {
+      x1: 0,
+      y1: C * 0.65,
+      x2: xFront,
+      y2: C * 0.65,
+      label: fmt(kulak),
+      orientation: "horizontal",
+      offset: -20
+    }
+  ];
 }
-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
-      };
+var MODEL_ID9 = "BECF-B-12101";
+var UNIT_FACTOR9 = {
+  mm: 1,
+  cm: 0.1,
+  in: 1 / 25.4
+};
+var PX_PER_MM9 = 96 / 25.4;
+function renderDimension9(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}`);
 }
-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
+var DIE_LINE_BECF_B_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(() => generateBecfB12101(attributes), [attributes]);
+    const dimensions = react.useMemo(() => generateDimensions9(attributes, unit), [attributes, unit]);
+    const factor = UNIT_FACTOR9[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) {
+        clone.querySelector("#dimensions")?.remove();
+      }
+      return new XMLSerializer().serializeToString(clone);
+    }, []);
+    react.useImperativeHandle(ref, () => {
+      const auto = getAutoCalcValues5(attributes);
+      return {
+        getAttributes: () => ({
+          modelId: MODEL_ID9,
+          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,
+          kulak: auto.kulak * factor,
+          dip: auto.dip * 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_MM9);
+            canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM9);
+          } 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 = generateDimensions9(attributes, unit);
+          return exportDimensionPdf({ modelId: MODEL_ID9, 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) => renderDimension9(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_B_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(() => generateBecfB12101(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) {
+        clone.querySelector("#dimensions")?.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_MM9);
+          canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM9);
+        } 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_B_12101, { ref: dieLineRef, ...props, renderAs: "group" }) });
+  }
+);
+var MODEL_BECF_B_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_B_12101, { ref, ...props });
+        case "3D":
+          return null;
+        case "AUTO_LAYOUT":
+          return /* @__PURE__ */ jsxRuntime.jsx(DIE_LINE_BECF_B_12101, { ref, ...props });
+        default:
+          return null;
+      }
+    })() });
+  }
+);
+
+// src/components/dieline/bags-pillows/becf-b-12109/generate.ts
+var DIP6 = 13;
+var NOTCH_X3 = 3;
+var NOTCH_Y3 = 5;
+function calcKulak6(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 getAutoCalcValues6(attr) {
+  const { width: B, glueArea } = attr;
+  const kulak = glueArea ?? calcKulak6(B);
+  return { kulak, dip: DIP6 };
+}
+function line10(x1, y1, x2, y2) {
+  return `M${x1} ${y1} L${x2} ${y2}`;
+}
+function generateBecfB12109(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const kulak = glueArea ?? calcKulak6(B);
+  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 yFoldBottomStart = C - B / 2;
+  const yFoldBottom = C;
+  const yNotchStart = yFoldBottom + NOTCH_Y3;
+  const yEnd = C + B / 2 + DIP6;
+  const totalWidth = xEnd;
+  const totalHeight = yEnd;
+  const cut = [];
+  const crease = [];
+  cut.push(line10(0, 0, 0, yFoldBottom - kulak));
+  cut.push(line10(0, 0, totalWidth, 0));
+  cut.push(line10(totalWidth, 0, totalWidth, yFoldBottom));
+  cut.push(line10(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(line10(xb - NOTCH_X3, yNotchStart, xb - NOTCH_X3, totalHeight));
+      cut.push(line10(xb - NOTCH_X3, yNotchStart, xb, yFoldBottom));
+    }
+    if (!isLast) {
+      cut.push(line10(xb + NOTCH_X3, yNotchStart, xb + NOTCH_X3, totalHeight));
+      cut.push(line10(xb + NOTCH_X3, yNotchStart, xb, yFoldBottom));
+    }
+  }
+  cut.push(line10(xFront + NOTCH_X3, totalHeight, xSide1 - NOTCH_X3, totalHeight));
+  cut.push(line10(xSide1 + NOTCH_X3, totalHeight, xBack - NOTCH_X3, totalHeight));
+  cut.push(line10(xBack + NOTCH_X3, totalHeight, xSide2 - NOTCH_X3, totalHeight));
+  cut.push(line10(xSide2 + NOTCH_X3, totalHeight, xEnd - NOTCH_X3, totalHeight));
+  crease.push(line10(0, yFoldBottomStart, totalWidth, yFoldBottomStart));
+  crease.push(line10(kulak, yFoldBottom, xEnd, yFoldBottom));
+  crease.push(line10(xFront, 0, xFront, yFoldBottom));
+  crease.push(line10(xSide1, 0, xSide1, yFoldBottom));
+  crease.push(line10(xBack, 0, xBack, yFoldBottom));
+  crease.push(line10(xSide2, 0, xSide2, yFoldBottom));
+  crease.push(line10(xSide1Mid, 0, xSide1Mid, totalHeight));
+  crease.push(line10(xSide2Mid, 0, xSide2Mid, totalHeight));
+  crease.push(line10(xBack, yFoldBottom, xSide1Mid, yFoldBottomStart));
+  crease.push(line10(xSide1Mid, yFoldBottomStart, xSide1, yFoldBottom));
+  crease.push(line10(xSide2Mid, yFoldBottomStart, xSide2, yFoldBottom));
+  crease.push(line10(xSide2Mid, yFoldBottomStart, xEnd, C - 2));
+  return { cut, crease, viewBox: { width: totalWidth, height: totalHeight } };
+}
+function generateOuterContour10(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const kulak = glueArea ?? calcKulak6(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 = C;
+  const yNotchStart = yFoldBottom + NOTCH_Y3;
+  const yEnd = C + B / 2 + DIP6;
+  return [
+    { x: 0, y: 0 },
+    { x: xEnd, y: 0 },
+    { x: xEnd, y: yFoldBottom },
+    { x: xEnd - NOTCH_X3, y: yNotchStart },
+    { x: xEnd - NOTCH_X3, y: yEnd },
+    { x: xSide2 + NOTCH_X3, y: yEnd },
+    { x: xSide2 + NOTCH_X3, y: yNotchStart },
+    { x: xSide2, y: yFoldBottom },
+    { x: xSide2 - NOTCH_X3, y: yNotchStart },
+    { x: xSide2 - NOTCH_X3, y: yEnd },
+    { x: xBack + NOTCH_X3, y: yEnd },
+    { x: xBack + NOTCH_X3, y: yNotchStart },
+    { x: xBack, y: yFoldBottom },
+    { x: xBack - NOTCH_X3, y: yNotchStart },
+    { x: xBack - NOTCH_X3, y: yEnd },
+    { x: xSide1 + NOTCH_X3, y: yEnd },
+    { x: xSide1 + NOTCH_X3, y: yNotchStart },
+    { x: xSide1, y: yFoldBottom },
+    { x: xSide1 - NOTCH_X3, y: yNotchStart },
+    { x: xSide1 - NOTCH_X3, y: yEnd },
+    { x: xFront + NOTCH_X3, y: yEnd },
+    { x: xFront + NOTCH_X3, y: yNotchStart },
+    { x: xFront, y: yFoldBottom },
+    { x: 0, y: yFoldBottom - kulak }
+  ];
+}
+function offsetContour10(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 contourToPath10(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 generateDimensions10(attr, unit) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const kulak = glueArea ?? calcKulak6(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 yFoldBottom = C;
+  const yEnd = C + B / 2 + DIP6;
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = yEnd;
+  const bottomSection = B / 2 + DIP6;
+  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: 0,
+      x2: xBack + A * 0.6,
+      y2: yFoldBottom,
+      label: fmt(C),
+      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: C * 0.65,
+      x2: xSide1,
+      y2: C * 0.65,
+      label: fmt(A),
+      orientation: "horizontal",
+      offset: -20
+    },
+    {
+      x1: xSide1,
+      y1: C * 0.65,
+      x2: xBack,
+      y2: C * 0.65,
+      label: fmt(B),
+      orientation: "horizontal",
+      offset: -20
+    },
+    {
+      x1: 0,
+      y1: C * 0.65,
+      x2: xFront,
+      y2: C * 0.65,
+      label: fmt(kulak),
+      orientation: "horizontal",
+      offset: -20
+    }
+  ];
+}
+var MODEL_ID10 = "BECF-B-12109";
+var UNIT_FACTOR10 = {
+  mm: 1,
+  cm: 0.1,
+  in: 1 / 25.4
+};
+var PX_PER_MM10 = 96 / 25.4;
+function renderDimension10(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_B_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(() => generateBecfB12109(attributes), [attributes]);
+    const dimensions = react.useMemo(() => generateDimensions10(attributes, unit), [attributes, unit]);
+    const factor = UNIT_FACTOR10[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) {
+        clone.querySelector("#dimensions")?.remove();
+      }
+      return new XMLSerializer().serializeToString(clone);
+    }, []);
+    react.useImperativeHandle(ref, () => {
+      const auto = getAutoCalcValues6(attributes);
+      return {
+        getAttributes: () => ({
+          modelId: MODEL_ID10,
+          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,
+          kulak: auto.kulak * factor,
+          dip: auto.dip * 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_MM10);
+            canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM10);
+          } 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 = generateDimensions10(attributes, unit);
+          return exportDimensionPdf({ modelId: MODEL_ID10, 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) => renderDimension10(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_B_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(() => generateBecfB12109(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) {
+        clone.querySelector("#dimensions")?.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_MM10);
+          canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM10);
+        } 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_B_12109, { ref: dieLineRef, ...props, renderAs: "group" }) });
+  }
+);
+var MODEL_BECF_B_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_B_12109, { ref, ...props });
+        case "3D":
+          return null;
+        case "AUTO_LAYOUT":
+          return /* @__PURE__ */ jsxRuntime.jsx(DIE_LINE_BECF_B_12109, { ref, ...props });
+        default:
+          return null;
+      }
+    })() });
+  }
+);
+
+// src/components/dieline/snap-lock-boxes/becf-10a0a/generate.ts
+var MT5 = 0.5;
+var ARC_R4 = 5;
+var SNAP_R = 3;
+var TAPER = Math.tan(15 * Math.PI / 180);
+var TAB_W = 8;
+var CORNER = 3;
+var NOTCH = 10;
+function calcKulak7(b) {
+  if (b < 100) return 13;
+  if (b < 250) return 15;
+  if (b < 500) return 20;
+  return 25;
+}
+function calcDil(a, b, c) {
+  const base = Math.max(15, Math.min(30, (a + b + 50) / 20));
+  return Math.max(9, Math.min(a / 2, b - 1, c / 2, base));
+}
+function calcDip(b) {
+  if (b <= 22) return 9;
+  if (b <= 28) return Math.floor((b - 4) / 2);
+  if (b <= 77) return 12;
+  if (b <= 120) return Math.floor(b / 6);
+  if (b <= 167) return 20;
+  if (b <= 199) return Math.floor(b / 8);
+  if (b < 300) return 30;
+  if (b < 400) return 35;
+  return 40;
+}
+function generateBecf10a0a(attr) {
+  const { length: A, width: B, height: C } = attr;
+  const kulak = calcKulak7(B);
+  const dil = calcDil(A, B, C);
+  const dip = calcDip(B);
+  const glueTaper = kulak * TAPER;
+  const tuckH = B / 2 + ARC_R4;
+  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 - 0.5;
+  const yTop = 0;
+  const yTuckTop = dil - 1;
+  const yLockCrease = dil;
+  const yTuckFlapTop = B + dil - 1 - tuckH;
+  const yFoldTop = B + dil - 1;
+  const yFoldBottom = yFoldTop + C;
+  const yFoldBottomB2 = yFoldBottom + B / 2;
+  const ySideBottom = yFoldBottom + A / 4 + dip + SNAP_R;
+  const yBottom = yFoldBottom + B / 2 + dip + SNAP_R;
+  const totalWidth = xEnd;
+  const totalHeight = yBottom;
+  const cut = [];
+  const crease = [];
+  crease.push(
+    line11(xFront, yFoldTop, xFront, yFoldBottom),
+    line11(xSide1, yFoldTop, xSide1, yFoldBottom),
+    line11(xBack, yFoldTop, xBack, yFoldBottom),
+    line11(xSide2, yFoldTop, xSide2, yFoldBottom)
+  );
+  crease.push(
+    line11(xFront, yFoldBottom, xSide1, yFoldBottom),
+    line11(xSide1, yFoldBottom, xBack, yFoldBottom),
+    line11(xBack, yFoldBottom, xSide2, yFoldBottom),
+    line11(xSide2, yFoldBottom, xEnd, yFoldBottom)
+  );
+  crease.push(
+    line11(xBack, yFoldTop, xSide1 + MT5, yFoldTop),
+    // Side1 panel
+    line11(xBack, yFoldTop - MT5, xSide2, yFoldTop - MT5),
+    // Back panel (MT offset)
+    line11(xSide2, yFoldTop, xEnd, yFoldTop)
+    // Side2 panel
+  );
+  crease.push(
+    line11(xBack + NOTCH, yLockCrease, xSide2 - NOTCH, yLockCrease)
+  );
+  cut.push(
+    line11(xSide1, yFoldTop, xFront, yFoldTop),
+    line11(xSide1, yFoldTop, xSide1 + MT5, yFoldTop)
+  );
+  cut.push(
+    `M${xFront} ${yFoldBottom} L${0} ${yFoldBottom - glueTaper} L${0} ${yFoldTop + glueTaper} L${xFront} ${yFoldTop}`
+  );
+  cut.push(line11(xEnd, yFoldTop, xEnd, yFoldBottom));
+  cut.push(...lockTab(xBack, xSide2, yTop, yTuckTop, yLockCrease, yFoldTop));
+  cut.push(...side1TuckFlap(xSide1, xBack, yFoldTop, yTuckFlapTop, tuckH));
+  cut.push(...side2TuckFlap(xSide2, xEnd, yFoldTop, yTuckFlapTop, tuckH));
+  cut.push(...frontPanelBottom(xFront, xSide1, A, yFoldBottom, yFoldBottomB2, yBottom, dip));
+  cut.push(...backPanelBottom(xBack, xSide2, A, yFoldBottom, yFoldBottomB2, yBottom, ySideBottom, dip));
+  cut.push(...side1Bottom(xSide1, xBack, B, A, yFoldBottom, ySideBottom, dip));
+  cut.push(...side2Bottom(xSide2, xEnd, B, A, yFoldBottom, ySideBottom, dip));
+  return { cut, crease, viewBox: { width: totalWidth, height: totalHeight } };
+}
+function line11(x1, y1, x2, y2) {
+  return `M${x1} ${y1} L${x2} ${y2}`;
+}
+function lockTab(xBack, xSide2, yTop, yTuckTop, yLockCrease, yFoldTop) {
+  const paths = [];
+  paths.push(line11(xBack, yFoldTop, xBack, yTuckTop));
+  paths.push(line11(xSide2, yTuckTop, xSide2, yFoldTop));
+  paths.push(line11(xBack, yTuckTop, xBack + NOTCH, yTuckTop));
+  paths.push(line11(xSide2 - NOTCH, yTuckTop, xSide2, yTuckTop));
+  paths.push(line11(xBack + NOTCH, yTuckTop, xBack + NOTCH, yLockCrease));
+  paths.push(line11(xSide2 - NOTCH, yLockCrease, xSide2 - NOTCH, yTuckTop));
+  paths.push(line11(xBack + MT5, yTuckTop, xBack + MT5, ARC_R4));
+  paths.push(line11(xSide2 - MT5, yTuckTop, xSide2 - MT5, ARC_R4));
+  paths.push(line11(xBack + MT5 + ARC_R4, yTop, xSide2 - MT5 - ARC_R4, yTop));
+  paths.push(
+    `M${xBack + MT5 + ARC_R4} ${yTop} A${ARC_R4} ${ARC_R4} 0 0 0 ${xBack + MT5} ${ARC_R4}`
+  );
+  paths.push(
+    `M${xSide2 - MT5} ${ARC_R4} A${ARC_R4} ${ARC_R4} 0 0 0 ${xSide2 - MT5 - ARC_R4} ${yTop}`
+  );
+  return paths;
+}
+function side1TuckFlap(xSide1, xBack, yFoldTop, yTuckFlapTop, tuckH) {
+  const slopeV = tuckH - TAB_W - CORNER;
+  const slopeH = slopeV * TAPER;
+  const leftTargetX = xSide1 + MT5 + CORNER + slopeH;
+  const rightTargetX = xBack - ARC_R4;
+  const leftPath = `M${xSide1 + MT5} ${yFoldTop} L${xSide1 + MT5} ${yFoldTop - TAB_W} L${xSide1 + MT5 + CORNER} ${yFoldTop - TAB_W - CORNER} L${leftTargetX} ${yTuckFlapTop}`;
+  const topRight = `M${leftTargetX} ${yTuckFlapTop} L${rightTargetX} ${yTuckFlapTop} L${xBack - CORNER} ${yFoldTop - CORNER} L${xBack} ${yFoldTop}`;
+  return [leftPath, topRight];
+}
+function side2TuckFlap(xSide2, xEnd, yFoldTop, yTuckFlapTop, tuckH) {
+  const slopeV = tuckH - TAB_W - CORNER;
+  const slopeH = slopeV * TAPER;
+  const leftTargetX = xSide2 + ARC_R4;
+  const rightTargetX = xEnd - CORNER - slopeH;
+  const leftTop = `M${xSide2} ${yFoldTop} L${xSide2 + CORNER} ${yFoldTop - CORNER} L${leftTargetX} ${yTuckFlapTop} L${rightTargetX} ${yTuckFlapTop}`;
+  const rightPath = `M${rightTargetX} ${yTuckFlapTop} L${xEnd - CORNER} ${yFoldTop - TAB_W - CORNER} L${xEnd} ${yFoldTop - TAB_W} L${xEnd} ${yFoldTop}`;
+  return [leftTop, rightPath];
+}
+function frontPanelBottom(xFront, xSide1, A, yFoldBottom, yFoldBottomB2, yBottom, dip) {
+  const paths = [];
+  paths.push(line11(xFront, yFoldBottom, xFront, yBottom));
+  paths.push(line11(xSide1, yBottom, xSide1, yFoldBottom));
+  const notchHalfTop = A / 4 + MT5;
+  const notchTaperH = (dip + SNAP_R) * TAPER;
+  const center = xFront + A / 2;
+  const nlt = center - notchHalfTop;
+  const nrt = center + notchHalfTop;
+  const nlb = nlt + notchTaperH;
+  const nrb = nrt - notchTaperH;
+  paths.push(line11(xFront, yBottom, nlb, yBottom));
+  paths.push(line11(nlb, yBottom, nlt, yFoldBottomB2));
+  paths.push(line11(nlt, yFoldBottomB2, nrt, yFoldBottomB2));
+  paths.push(line11(nrt, yFoldBottomB2, nrb, yBottom));
+  paths.push(line11(nrb, yBottom, xSide1, yBottom));
+  return paths;
+}
+function backPanelBottom(xBack, xSide2, A, yFoldBottom, yFoldBottomB2, yBottom, ySideBottom, dip) {
+  const paths = [];
+  const diagH = A / 4;
+  paths.push(line11(xBack, yFoldBottom, xBack, ySideBottom));
+  paths.push(line11(xSide2, ySideBottom, xSide2, yFoldBottom));
+  paths.push(line11(xBack, yFoldBottom, xBack + diagH, yFoldBottomB2));
+  paths.push(line11(xSide2, yFoldBottom, xSide2 - diagH, yFoldBottomB2));
+  paths.push(line11(xBack + diagH, yFoldBottomB2, xBack + diagH, yFoldBottomB2 + dip));
+  paths.push(line11(xSide2 - diagH, yFoldBottomB2 + dip, xSide2 - diagH, yFoldBottomB2));
+  paths.push(
+    `M${xBack + diagH} ${yFoldBottomB2 + dip} A${SNAP_R} ${SNAP_R} 0 0 0 ${xBack + diagH + SNAP_R} ${yBottom}`
+  );
+  paths.push(
+    `M${xSide2 - diagH - SNAP_R} ${yBottom} A${SNAP_R} ${SNAP_R} 0 0 0 ${xSide2 - diagH} ${yFoldBottomB2 + dip}`
+  );
+  paths.push(line11(xBack + diagH + SNAP_R, yBottom, xSide2 - diagH - SNAP_R, yBottom));
+  return paths;
+}
+function side1Bottom(xSide1, xBack, B, A, yFoldBottom, ySideBottom, dip) {
+  const paths = [];
+  const diagEndX = xSide1 + B / 2;
+  const diagEndY = yFoldBottom + A / 4;
+  const taperV = dip + SNAP_R;
+  const taperH = taperV * TAPER;
+  paths.push(line11(xSide1, yFoldBottom, diagEndX, diagEndY));
+  paths.push(line11(diagEndX, diagEndY, diagEndX - taperH, ySideBottom));
+  paths.push(line11(diagEndX - taperH, ySideBottom, xBack, ySideBottom));
+  return paths;
+}
+function side2Bottom(xSide2, xEnd, B, A, yFoldBottom, ySideBottom, dip) {
+  const paths = [];
+  const diagEndX = xSide2 + B / 2;
+  const diagEndY = yFoldBottom + A / 4;
+  const taperV = dip + SNAP_R;
+  const taperH = taperV * TAPER;
+  paths.push(line11(xEnd, yFoldBottom, diagEndX, diagEndY));
+  paths.push(line11(diagEndX, diagEndY, diagEndX + taperH, ySideBottom));
+  paths.push(line11(diagEndX + taperH, ySideBottom, xSide2, ySideBottom));
+  return paths;
+}
+function generateDimensions11(attr, unit) {
+  const { length: A, width: B, height: C } = attr;
+  const kulak = calcKulak7(B);
+  const dil = calcDil(A, B, C);
+  const dip = calcDip(B);
+  const xFront = kulak;
+  const xSide1 = kulak + A;
+  const xSide2 = kulak + 2 * A + B;
+  const xEnd = kulak + 2 * A + 2 * B - 0.5;
+  const yFoldTop = B + dil - 1;
+  const yFoldBottom = yFoldTop + C;
+  const yBottom = yFoldBottom + B / 2 + dip + SNAP_R;
+  const totalWidth = xEnd;
+  const totalHeight = yBottom;
+  const factor = unit === "cm" ? 0.1 : unit === "in" ? 1 / 25.4 : 1;
+  const suffix = unit;
+  const fmt = (v) => `${(v * factor).toFixed(2)} ${suffix}`;
+  return [
+    {
+      x1: 0,
+      y1: 0,
+      x2: 0,
+      y2: totalHeight,
+      label: `Overall Height : ${fmt(totalHeight)}`,
+      orientation: "vertical",
+      offset: -12
+    },
+    {
+      x1: 0,
+      y1: 0,
+      x2: totalWidth,
+      y2: 0,
+      label: `Overall Width : ${fmt(totalWidth)}`,
+      orientation: "horizontal",
+      offset: -12
+    },
+    {
+      x1: xSide2,
+      y1: yFoldTop,
+      x2: xSide2,
+      y2: yFoldBottom,
+      label: fmt(C),
+      orientation: "vertical",
+      offset: -14
+    },
+    {
+      x1: xFront,
+      y1: yFoldBottom,
+      x2: xSide1,
+      y2: yFoldBottom,
+      label: fmt(A),
+      orientation: "horizontal",
+      offset: -20
+    },
+    {
+      x1: xSide1,
+      y1: yFoldBottom,
+      x2: xSide1 + B,
+      y2: yFoldBottom,
+      label: fmt(B),
+      orientation: "horizontal",
+      offset: -20
+    }
+  ];
+}
+var MODEL_ID11 = "BECF-10A0A";
+var UNIT_FACTOR11 = {
+  mm: 1,
+  cm: 0.1,
+  in: 1 / 25.4
+};
+var PX_PER_MM11 = 96 / 25.4;
+function renderDimension11(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_10A0A = react.forwardRef(
+  ({
+    attributes,
+    unit = "mm",
+    isShowDimensions = false,
+    renderAs = "svg"
+  }, ref) => {
+    const theme = react.useMemo(
+      () => getModelTheme(),
+      []
+    );
+    const svgRef = react.useRef(null);
+    const dieline = react.useMemo(() => generateBecf10a0a(attributes), [attributes]);
+    const dimensions = react.useMemo(
+      () => generateDimensions11(attributes, unit),
+      [attributes, unit]
+    );
+    const factor = UNIT_FACTOR11[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 { length: A, width: B, height: C } = attributes;
+        const kulak = calcKulak7(B);
+        const dil = calcDil(A, B, C);
+        const dip = calcDip(B);
+        const flap = Math.min(A / 2, B / 2 + dil / 2 - 0.5);
+        return {
+          getAttributes: () => ({
+            modelId: MODEL_ID11,
+            overallWidth: dieline.viewBox.width * factor,
+            overallHeight: dieline.viewBox.height * factor,
+            length: A * factor,
+            width: B * factor,
+            height: C * factor,
+            kulak: kulak * factor,
+            dil: dil * factor,
+            flap: flap * factor,
+            dip: dip * 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_MM11);
+              canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM11);
+            } 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 = generateDimensions11(attributes, unit);
+            return exportDimensionPdf({
+              modelId: MODEL_ID11,
+              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) => renderDimension11(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_10A0A = 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(() => generateBecf10a0a(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_MM11);
+          canvas.height = Math.round(dieline.viewBox.height * PX_PER_MM11);
+        } 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_10A0A, { ref: dieLineRef, ...props, renderAs: "group" })
+      }
+    );
+  }
+);
+var MODEL_BECF_10A0A = 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_10A0A, { ref, ...props });
+        case "3D":
+          return null;
+        case "AUTO_LAYOUT":
+          return /* @__PURE__ */ jsxRuntime.jsx(DIE_LINE_BECF_10A0A, { 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;
+  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;
+    const offsetY = ((usableH - groupH) / 2 - (gridMinY - usableTop)) * RESOLUTION;
+    for (const p of bestCandidate.placements) {
+      p.x += offsetX;
+      p.y += offsetY;
+    }
+  }
+  return bestCandidate;
+}
+
+// src/utils/autoLayout/calculate/tuck-end-boxes/becf-1010a/index.ts
+var SAMPLE_STEP = 0.1;
+function buildProfile(points) {
+  let maxX = 0, maxY = 0;
+  for (const p of points) {
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  const width = maxX, height = maxY;
+  const nY = Math.ceil(height / SAMPLE_STEP) + 1;
+  const nX = Math.ceil(width / SAMPLE_STEP) + 1;
+  const rightX = new Float64Array(nY).fill(-Infinity);
+  const leftX = new Float64Array(nY).fill(Infinity);
+  const bottomY = new Float64Array(nX).fill(-Infinity);
+  const topY = new Float64Array(nX).fill(Infinity);
+  const nPts = points.length;
+  for (let iy = 0; iy < nY; iy++) {
+    const y = iy * SAMPLE_STEP;
+    for (let j = 0, k = nPts - 1; j < nPts; k = j++) {
+      const yj = points[j].y, yk = points[k].y;
+      if (yj <= y && yk > y || yk <= y && yj > y) {
+        const t = (y - yj) / (yk - yj);
+        const x = points[j].x + t * (points[k].x - points[j].x);
+        if (x > rightX[iy]) rightX[iy] = x;
+        if (x < leftX[iy]) leftX[iy] = x;
+      }
+    }
+  }
+  for (let ix = 0; ix < nX; ix++) {
+    const x = ix * SAMPLE_STEP;
+    for (let j = 0, k = nPts - 1; j < nPts; k = j++) {
+      const xj = points[j].x, xk = points[k].x;
+      if (xj <= x && xk > x || xk <= x && xj > x) {
+        const t = (x - xj) / (xk - xj);
+        const y = points[j].y + t * (points[k].y - points[j].y);
+        if (y > bottomY[ix]) bottomY[ix] = y;
+        if (y < topY[ix]) topY[ix] = y;
+      }
+    }
+  }
+  return { width, height, nY, nX, rightX, leftX, bottomY, topY };
+}
+function prepareRotation(contourPoints, dielineW, dielineH, deg) {
+  const rotated = normalizePoints(contourPoints, deg);
+  return {
+    profile: buildProfile(rotated),
+    bbOffset: computeDielineBBOffset(contourPoints, dielineW, dielineH, deg),
+    deg
+  };
+}
+function findMinStepX(a, b, dyMm) {
+  const dySamples = Math.round(dyMm / SAMPLE_STEP);
+  let maxOverlap = -Infinity;
+  for (let ia = 0; ia < a.nY; ia++) {
+    const ib = ia - dySamples;
+    if (ib < 0 || ib >= b.nY) continue;
+    if (a.rightX[ia] === -Infinity || b.leftX[ib] === Infinity) continue;
+    const overlap = a.rightX[ia] - b.leftX[ib];
+    if (overlap > maxOverlap) maxOverlap = overlap;
+  }
+  return maxOverlap <= -Infinity ? 0 : maxOverlap;
+}
+function findMinStepY(a, b, dxMm) {
+  const dxSamples = Math.round(dxMm / SAMPLE_STEP);
+  let maxOverlap = -Infinity;
+  for (let ia = 0; ia < a.nX; ia++) {
+    const ib = ia - dxSamples;
+    if (ib < 0 || ib >= b.nX) continue;
+    if (a.bottomY[ia] === -Infinity || b.topY[ib] === Infinity) continue;
+    const overlap = a.bottomY[ia] - b.topY[ib];
+    if (overlap > maxOverlap) maxOverlap = overlap;
+  }
+  return maxOverlap <= -Infinity ? 0 : maxOverlap;
+}
+function findMinStepY_multi(profA, stepX_A, profB, offsetX) {
+  const reach = Math.max(profA.width, profB.width);
+  let maxStep = 0;
+  const nMin = Math.floor((offsetX - reach) / stepX_A);
+  const nMax = Math.ceil((offsetX + reach) / stepX_A);
+  for (let n = nMin; n <= nMax; n++) {
+    const s = findMinStepY(profA, profB, offsetX - n * stepX_A);
+    if (s > maxStep) maxStep = s;
+  }
+  return maxStep;
+}
+function emptyResult() {
+  return { placements: [], count: 0, minX: 0, minY: 0, maxX: 0, maxY: 0 };
+}
+function singleRotGrid(rd, bounds) {
+  const p = rd.profile;
+  const stepX = findMinStepX(p, p, 0);
+  const stepY = findMinStepY(p, p, 0);
+  if (stepX <= 0 || stepY <= 0) return emptyResult();
+  const cols = Math.max(0, Math.floor((bounds.right - bounds.left - p.width) / stepX) + 1);
+  const rows = Math.max(0, Math.floor((bounds.bottom - bounds.top - p.height) / stepY) + 1);
+  if (cols === 0 || rows === 0) return emptyResult();
+  const placements = [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const ox = bounds.left + c * stepX;
+      const oy = bounds.top + r * stepY;
+      placements.push({ x: ox + rd.bbOffset.dx, y: oy + rd.bbOffset.dy, rotation: rd.deg });
+      if (ox < minX) minX = ox;
+      if (oy < minY) minY = oy;
+      if (ox + p.width > maxX) maxX = ox + p.width;
+      if (oy + p.height > maxY) maxY = oy + p.height;
+    }
+  }
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
+}
+function dualRotGrid(rdA, rdB, offsetX, bounds) {
+  const pA = rdA.profile, pB = rdB.profile;
+  const stepX_A = findMinStepX(pA, pA, 0);
+  const stepX_B = findMinStepX(pB, pB, 0);
+  if (stepX_A <= 0 || stepX_B <= 0) return emptyResult();
+  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;
   }
-  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;
+  centerLayout(best, bounds);
+  return {
+    rotation: best.placements[0]?.rotation ?? 0,
+    placements: best.placements,
+    producedPerSheet: best.count
+  };
+}
+
+// src/utils/autoLayout/calculate/tuck-end-boxes/becf-1030a/index.ts
+function prepareRotation2(contourPoints, dielineW, dielineH, deg) {
+  const rotated = normalizePoints(contourPoints, deg);
+  return {
+    profile: buildProfile(rotated),
+    bbOffset: computeDielineBBOffset(contourPoints, dielineW, dielineH, deg),
+    deg
+  };
+}
+function 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 { dx: dlMinX - ocMinX, dy: dlMinY - ocMinY };
+  return maxStep;
 }
-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 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;
         }
       }
-    }
-    if (placements.length > bestCandidate.producedPerSheet) {
-      bestCandidate = { rotation: deg, placements, producedPerSheet: placements.length };
-      bestGridPositions = gridPositions;
-      bestBitmapW = pieceBitmap.width;
-      bestBitmapH = pieceBitmap.height;
+      break;
     }
   }
-  if (bestCandidate.placements.length > 0) {
-    let gridMinX = Infinity;
-    let gridMinY = Infinity;
-    let gridMaxX = -Infinity;
-    let gridMaxY = -Infinity;
-    for (const { px, py } of bestGridPositions) {
-      if (px < gridMinX) gridMinX = px;
-      if (py < gridMinY) gridMinY = py;
-      if (px + bestBitmapW > gridMaxX) gridMaxX = px + bestBitmapW;
-      if (py + bestBitmapH > gridMaxY) gridMaxY = py + bestBitmapH;
-    }
-    const groupW = gridMaxX - gridMinX;
-    const groupH = gridMaxY - gridMinY;
-    const usableW = usableRight - usableLeft;
-    const usableH = usableBottom - usableTop;
-    const offsetX = ((usableW - groupW) / 2 - (gridMinX - usableLeft)) * RESOLUTION;
-    const offsetY = ((usableH - groupH) / 2 - (gridMinY - usableTop)) * RESOLUTION;
-    for (const p of bestCandidate.placements) {
-      p.x += offsetX;
-      p.y += offsetY;
+  for (const 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 bestCandidate;
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-
-// 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;
+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 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;
-      }
+  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 (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 [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),
@@ -5535,128 +7181,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();
-  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 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;
-    }
-    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;
+  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;
+    }
   }
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-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],
@@ -5664,7 +7358,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;
@@ -5673,10 +7367,40 @@ function computeLayoutForPaper(contourPoints, dielineW, dielineH, _paperWidth, _
       results.push(dualRotGrid(rdB, rdA, off, bounds));
     }
   }
-  let best = results[0];
+  for (const [a, b] of allPairs) {
+    results.push(pairGrid2(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid2(rd.get(b), rd.get(a), bounds));
+  }
+  for (const [a, b] of allPairs) {
+    results.push(verticalPairGrid(rd.get(a), rd.get(b), bounds));
+    results.push(verticalPairGrid(rd.get(b), rd.get(a), bounds));
+  }
+  const singleResults = [];
+  const multiResults = [];
   for (const r of results) {
-    if (r.count > best.count) best = r;
+    if (r.count === 0) continue;
+    const rotations = new Set(r.placements.map((p) => p.rotation));
+    if (rotations.size > 1) {
+      multiResults.push(r);
+    } else {
+      singleResults.push(r);
+    }
+  }
+  function pickBest(arr) {
+    let b = arr[0] ?? emptyResult();
+    let bArea = (b.maxX - b.minX) * (b.maxY - b.minY);
+    for (const r of arr) {
+      const area = (r.maxX - r.minX) * (r.maxY - r.minY);
+      if (r.count > b.count || r.count === b.count && area < bArea) {
+        b = r;
+        bArea = area;
+      }
+    }
+    return b;
   }
+  const bestSingle = pickBest(singleResults);
+  const bestMulti = pickBest(multiResults);
+  const best = bestMulti.count >= bestSingle.count && bestMulti.count > 0 ? bestMulti : bestSingle;
   centerLayout(best, bounds);
   return {
     rotation: best.placements[0]?.rotation ?? 0,
@@ -5685,8 +7409,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),
@@ -5694,36 +7418,19 @@ function prepareRotation2(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 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();
   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 pairStepX = gapAB + findMinStepX(pB, pA, 0);
+  const pairStepY = Math.max(
+    findMinStepY(pA, pA, 0),
+    findMinStepY(pA, pB, gapAB),
+    findMinStepY(pB, pA, -gapAB),
+    findMinStepY(pB, pB, 0)
   );
-  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;
@@ -5787,11 +7494,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) {
@@ -5815,8 +7522,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 = [];
@@ -5852,8 +7559,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),
@@ -5861,38 +7568,20 @@ function prepareRotation3(contourPoints, dielineW, dielineH, deg) {
     deg
   };
 }
-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;
-  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 = Math.max(
-    gapAB + findMinStepX(pB, pA, 0),
-    findMinStepX(pA, pA, 0),
-    findMinStepX(pB, pB, 0)
+  const pairStepX = gapAB + findMinStepX(pB, pA, 0);
+  const pairStepY = Math.max(
+    findMinStepY(pA, pA, 0),
+    findMinStepY(pA, pB, gapAB),
+    findMinStepY(pB, pA, -gapAB),
+    findMinStepY(pB, pB, 0)
   );
-  if (pairStepX <= 0) return emptyResult();
-  const pairStepY = findPairRowStepY2(pA, pB, gapAB, pairStepX);
-  if (pairStepY <= 0) return emptyResult();
+  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);
@@ -5904,127 +7593,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 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 gapRight = bounds.right - pairsRightEdge;
   const gapBottom = bounds.bottom - pairsBottomEdge;
-  for (const rdExtra of [rdA, rdB]) {
+  const extraRotations = [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;
-      }
-    }
-    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);
-  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;
-  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;
+    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 (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 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) {
@@ -6048,12 +7672,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 = [];
@@ -6089,8 +7709,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),
@@ -6098,7 +7718,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();
@@ -6174,11 +7794,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) {
@@ -6202,8 +7822,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 = [];
@@ -6239,8 +7859,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),
@@ -6248,7 +7868,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();
@@ -6324,11 +7944,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) {
@@ -6352,8 +7972,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 = [];
@@ -6389,8 +8009,8 @@ function computeLayoutForPaper5(contourPoints, dielineW, dielineH, _paperWidth,
   };
 }
 
-// src/utils/autoLayout/calculate/bags-pillows/becf-c-12101/index.ts
-function prepareRotation6(contourPoints, dielineW, dielineH, deg) {
+// src/utils/autoLayout/calculate/bags-pillows/becf-b-12101/index.ts
+function prepareRotation8(contourPoints, dielineW, dielineH, deg) {
   const rotated = normalizePoints(contourPoints, deg);
   return {
     profile: buildProfile(rotated),
@@ -6398,7 +8018,7 @@ function prepareRotation6(contourPoints, dielineW, dielineH, deg) {
     deg
   };
 }
-function pairGrid5(rdA, rdB, bounds) {
+function pairGrid7(rdA, rdB, bounds) {
   const pA = rdA.profile, pB = rdB.profile;
   const gapAB = findMinStepX(pA, pB, 0);
   if (gapAB <= 0) return emptyResult();
@@ -6423,28 +8043,23 @@ function pairGrid5(rdA, rdB, bounds) {
     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;
+      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 oxB = baseX + gapAB;
-      const oyB = baseY;
-      placements.push({ x: oxB + rdB.bbOffset.dx, y: oyB + rdB.bbOffset.dy, rotation: rdB.deg });
+      placements.push({ x: oxB + rdB.bbOffset.dx, y: baseY + 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;
+      if (baseY + pB.height > maxY) maxY = baseY + 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) {
+  for (const rdExtra of [rdA, rdB]) {
     const pe = rdExtra.profile;
     if (pe.width <= gapRight) {
       for (let r = 0; r < pairRows; r++) {
@@ -6458,7 +8073,7 @@ function pairGrid5(rdA, rdB, bounds) {
       break;
     }
   }
-  for (const rdExtra of extraRotations) {
+  for (const rdExtra of [rdA, rdB]) {
     const pe = rdExtra.profile;
     if (pe.height <= gapBottom) {
       for (let c = 0; c < pairCols; c++) {
@@ -6474,24 +8089,13 @@ function pairGrid5(rdA, rdB, bounds) {
   }
   return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-function computeLayoutForPaper6(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+function computeLayoutForPaper8(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, prepareRotation6(contourPoints, dielineW, dielineH, deg));
-  }
+  for (const deg of rots) rd.set(deg, prepareRotation8(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 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);
@@ -6502,19 +8106,15 @@ function computeLayoutForPaper6(contourPoints, dielineW, dielineH, _paperWidth,
     }
   }
   for (const [a, b] of allPairs) {
-    results.push(pairGrid5(rd.get(a), rd.get(b), bounds));
-    results.push(pairGrid5(rd.get(b), rd.get(a), bounds));
+    results.push(pairGrid7(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid7(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);
-    }
+    (rotations.size > 1 ? multiResults : singleResults).push(r);
   }
   function pickBest(arr) {
     let b = arr[0] ?? emptyResult();
@@ -6532,15 +8132,11 @@ function computeLayoutForPaper6(contourPoints, dielineW, dielineH, _paperWidth,
   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
-  };
+  return { rotation: best.placements[0]?.rotation ?? 0, placements: best.placements, producedPerSheet: best.count };
 }
 
-// src/utils/autoLayout/calculate/bags-pillows/becf-c-12109/index.ts
-function prepareRotation7(contourPoints, dielineW, dielineH, deg) {
+// src/utils/autoLayout/calculate/bags-pillows/becf-b-12109/index.ts
+function prepareRotation9(contourPoints, dielineW, dielineH, deg) {
   const rotated = normalizePoints(contourPoints, deg);
   return {
     profile: buildProfile(rotated),
@@ -6548,7 +8144,7 @@ function prepareRotation7(contourPoints, dielineW, dielineH, deg) {
     deg
   };
 }
-function pairGrid6(rdA, rdB, bounds) {
+function pairGrid8(rdA, rdB, bounds) {
   const pA = rdA.profile, pB = rdB.profile;
   const gapAB = findMinStepX(pA, pB, 0);
   if (gapAB <= 0) return emptyResult();
@@ -6573,28 +8169,23 @@ function pairGrid6(rdA, rdB, bounds) {
     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;
+      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 oxB = baseX + gapAB;
-      const oyB = baseY;
-      placements.push({ x: oxB + rdB.bbOffset.dx, y: oyB + rdB.bbOffset.dy, rotation: rdB.deg });
+      placements.push({ x: oxB + rdB.bbOffset.dx, y: baseY + 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;
+      if (baseY + pB.height > maxY) maxY = baseY + 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) {
+  for (const rdExtra of [rdA, rdB]) {
     const pe = rdExtra.profile;
     if (pe.width <= gapRight) {
       for (let r = 0; r < pairRows; r++) {
@@ -6608,7 +8199,7 @@ function pairGrid6(rdA, rdB, bounds) {
       break;
     }
   }
-  for (const rdExtra of extraRotations) {
+  for (const rdExtra of [rdA, rdB]) {
     const pe = rdExtra.profile;
     if (pe.height <= gapBottom) {
       for (let c = 0; c < pairCols; c++) {
@@ -6624,24 +8215,13 @@ function pairGrid6(rdA, rdB, bounds) {
   }
   return { placements, count: placements.length, minX, minY, maxX, maxY };
 }
-function computeLayoutForPaper7(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+function computeLayoutForPaper9(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, prepareRotation7(contourPoints, dielineW, dielineH, deg));
-  }
+  for (const deg of rots) rd.set(deg, prepareRotation9(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 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);
@@ -6652,19 +8232,15 @@ function computeLayoutForPaper7(contourPoints, dielineW, dielineH, _paperWidth,
     }
   }
   for (const [a, b] of allPairs) {
-    results.push(pairGrid6(rd.get(a), rd.get(b), bounds));
-    results.push(pairGrid6(rd.get(b), rd.get(a), bounds));
+    results.push(pairGrid8(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid8(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);
-    }
+    (rotations.size > 1 ? multiResults : singleResults).push(r);
   }
   function pickBest(arr) {
     let b = arr[0] ?? emptyResult();
@@ -6682,11 +8258,7 @@ function computeLayoutForPaper7(contourPoints, dielineW, dielineH, _paperWidth,
   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
-  };
+  return { rotation: best.placements[0]?.rotation ?? 0, placements: best.placements, producedPerSheet: best.count };
 }
 
 // src/utils/autoLayout/calculate/index.ts
@@ -6748,6 +8320,22 @@ function resolveModelFunctions(modelId, attrs) {
         offsetContour: offsetContour8
       };
     }
+    case "BECF-B-12101": {
+      const a = attrs;
+      return {
+        contour: generateOuterContour9(a),
+        dieline: generateBecfB12101(a),
+        offsetContour: offsetContour9
+      };
+    }
+    case "BECF-B-12109": {
+      const a = attrs;
+      return {
+        contour: generateOuterContour10(a),
+        dieline: generateBecfB12109(a),
+        offsetContour: offsetContour10
+      };
+    }
     case "BECF-1010A":
     default: {
       const a = attrs;
@@ -6775,6 +8363,10 @@ function resolveLayoutCalculator(modelId) {
       return computeLayoutForPaper6;
     case "BECF-C-12109":
       return computeLayoutForPaper7;
+    case "BECF-B-12101":
+      return computeLayoutForPaper8;
+    case "BECF-B-12109":
+      return computeLayoutForPaper9;
     default:
       return computeLayoutForPaperDefault;
   }
@@ -6788,11 +8380,11 @@ function calculateAutoLayout(rawConfig) {
     colorbarHeight: rawConfig.colorbarHeight ?? 5,
     isShowColorbar: rawConfig.isShowColorbar ?? true
   };
-  const { contour, dieline, offsetContour: offsetContour9 } = resolveModelFunctions(
+  const { contour, dieline, offsetContour: offsetContour11 } = resolveModelFunctions(
     config.model.modelId,
     config.model.attributes
   );
-  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour9(contour, config.layoutDistance / 2) : contour;
+  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour11(contour, config.layoutDistance / 2) : contour;
   const cbDepth = config.isShowColorbar ? config.colorbarHeight : 0;
   const computeLayout = resolveLayoutCalculator(config.model.modelId);
   const paperResults = [];
@@ -7153,6 +8745,46 @@ function renderDieLine(modelId, attrs) {
           renderAs: "group"
         }
       );
+    case "BECF-12109":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        DIE_LINE_BECF_12109,
+        {
+          attributes: 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-B-12101":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        DIE_LINE_BECF_B_12101,
+        {
+          attributes: attrs,
+          renderAs: "group"
+        }
+      );
+    case "BECF-B-12109":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        DIE_LINE_BECF_B_12109,
+        {
+          attributes: attrs,
+          renderAs: "group"
+        }
+      );
     case "BECF-1010A":
     default:
       return /* @__PURE__ */ jsxRuntime.jsx(
@@ -7765,6 +9397,28 @@ function resolveModel(modelId, attrs, layoutDistance) {
         generateContour: (a) => generateOuterContour8(a)
       };
     }
+    case "BECF-B-12101": {
+      const typedAttrs = attrs;
+      const contour = generateOuterContour9(typedAttrs);
+      return {
+        dieline: generateBecfB12101(typedAttrs),
+        contourPath: contourToPath9(contour),
+        offsetContourPoints: layoutDistance > 0 ? offsetContour9(contour, layoutDistance / 2) : contour,
+        generate: (a) => generateBecfB12101(a),
+        generateContour: (a) => generateOuterContour9(a)
+      };
+    }
+    case "BECF-B-12109": {
+      const typedAttrs = attrs;
+      const contour = generateOuterContour10(typedAttrs);
+      return {
+        dieline: generateBecfB12109(typedAttrs),
+        contourPath: contourToPath10(contour),
+        offsetContourPoints: layoutDistance > 0 ? offsetContour10(contour, layoutDistance / 2) : contour,
+        generate: (a) => generateBecfB12109(a),
+        generateContour: (a) => generateOuterContour10(a)
+      };
+    }
     case "BECF-1010A":
     default: {
       const typedAttrs = attrs;
@@ -7838,6 +9492,22 @@ function renderDieLine2(modelId, attrs) {
             renderAs: "group"
           }
         );
+      case "BECF-B-12101":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          DIE_LINE_BECF_B_12101,
+          {
+            attributes: attrs,
+            renderAs: "group"
+          }
+        );
+      case "BECF-B-12109":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          DIE_LINE_BECF_B_12109,
+          {
+            attributes: attrs,
+            renderAs: "group"
+          }
+        );
       case "BECF-1010A":
       default:
         return /* @__PURE__ */ jsxRuntime.jsx(
@@ -7851,7 +9521,7 @@ function renderDieLine2(modelId, attrs) {
   })();
 }
 var PAPER_GAP = 20;
-var PX_PER_MM9 = 96 / 25.4;
+var PX_PER_MM12 = 96 / 25.4;
 var RESULT_PANEL_HEIGHT = 55;
 var RESULT_GAP = 5;
 function getOpposite2(side) {
@@ -8028,8 +9698,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_MM9)));
-      svg.setAttribute("height", String(Math.round(vh * PX_PER_MM9)));
+      svg.setAttribute("width", String(Math.round(vw * PX_PER_MM12)));
+      svg.setAttribute("height", String(Math.round(vh * PX_PER_MM12)));
       const bg = document.createElementNS(svgNs, "rect");
       bg.setAttribute("width", String(vw));
       bg.setAttribute("height", String(vh));
@@ -8062,8 +9732,8 @@ var AUTO_LAYOUT = react.forwardRef(
         img.src = url;
       });
       const canvas = document.createElement("canvas");
-      canvas.width = Math.round(vw * PX_PER_MM9);
-      canvas.height = Math.round(vh * PX_PER_MM9);
+      canvas.width = Math.round(vw * PX_PER_MM12);
+      canvas.height = Math.round(vh * PX_PER_MM12);
       const ctx = canvas.getContext("2d");
       ctx.fillStyle = "#ffffff";
       ctx.fillRect(0, 0, canvas.width, canvas.height);
@@ -8087,8 +9757,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_MM9)));
-      svg.setAttribute("height", String(Math.round(paperResult.paperHeight * PX_PER_MM9)));
+      svg.setAttribute("width", String(Math.round(paperResult.paperWidth * PX_PER_MM12)));
+      svg.setAttribute("height", String(Math.round(paperResult.paperHeight * PX_PER_MM12)));
       const bg = document.createElementNS(svgNs, "rect");
       bg.setAttribute("width", String(paperResult.paperWidth));
       bg.setAttribute("height", String(paperResult.paperHeight));
@@ -8192,8 +9862,8 @@ var AUTO_LAYOUT = react.forwardRef(
         img.src = url;
       });
       const canvas = document.createElement("canvas");
-      canvas.width = Math.round(paperResult.paperWidth * PX_PER_MM9);
-      canvas.height = Math.round(paperResult.paperHeight * PX_PER_MM9);
+      canvas.width = Math.round(paperResult.paperWidth * PX_PER_MM12);
+      canvas.height = Math.round(paperResult.paperHeight * PX_PER_MM12);
       const ctx = canvas.getContext("2d");
       ctx.fillStyle = theme.colorPaperFill;
       ctx.fillRect(0, 0, canvas.width, canvas.height);
@@ -8702,6 +10372,16 @@ var DIE_LINE_LAYOUT = react.forwardRef(
         return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_12101, { ref, ...props });
       case "BECF-12109":
         return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_12109, { ref, ...props });
+      case "BECF-C-12101":
+        return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_C_12101, { ref, ...props });
+      case "BECF-C-12109":
+        return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_C_12109, { ref, ...props });
+      case "BECF-B-12101":
+        return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_B_12101, { ref, ...props });
+      case "BECF-B-12109":
+        return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_B_12109, { ref, ...props });
+      case "BECF-10A0A":
+        return /* @__PURE__ */ jsxRuntime.jsx(MODEL_BECF_10A0A, { ref, ...props });
       default:
         return null;
     }
@@ -8770,7 +10450,42 @@ var BECF_C_12109_DEFAULT_ATTRIBUTES = {
   glueArea: 13
 };
 
+// src/statics/bags-pillows/becf-b-12101/DEFAULT_ATTRIBUTES.ts
+var BECF_B_12101_DEFAULT_ATTRIBUTES = {
+  length: 100,
+  width: 50,
+  height: 150,
+  glueArea: 13
+};
+
+// src/statics/bags-pillows/becf-b-12109/DEFAULT_ATTRIBUTES.ts
+var BECF_B_12109_DEFAULT_ATTRIBUTES = {
+  length: 100,
+  width: 50,
+  height: 150,
+  glueArea: 13
+};
+
+// src/statics/snap-lock-boxes/becf-10a0a/DEFAULT_ATTRIBUTES.ts
+var BECF_10A0A_DEFAULT_ATTRIBUTES = {
+  length: 150,
+  width: 50,
+  height: 150
+};
+
 // src/statics/modelList.ts
+var MODEL_DEFAULT_ATTRIBUTES = {
+  "BECF-1010A": { ...BECF_1010A_DEFAULT_ATTRIBUTES },
+  "BECF-1040A": { ...BECF_1040A_DEFAULT_ATTRIBUTES },
+  "BECF-1030A": { ...BECF_1030A_DEFAULT_ATTRIBUTES },
+  "BECF-12101": { ...BECF_12101_DEFAULT_ATTRIBUTES },
+  "BECF-12109": { ...BECF_12109_DEFAULT_ATTRIBUTES },
+  "BECF-B-12101": { ...BECF_B_12101_DEFAULT_ATTRIBUTES },
+  "BECF-B-12109": { ...BECF_B_12109_DEFAULT_ATTRIBUTES },
+  "BECF-C-12101": { ...BECF_C_12101_DEFAULT_ATTRIBUTES },
+  "BECF-C-12109": { ...BECF_C_12109_DEFAULT_ATTRIBUTES },
+  "BECF-10A0A": { ...BECF_10A0A_DEFAULT_ATTRIBUTES }
+};
 var modelList = [
   {
     id: "BECF-1010A",
@@ -8814,6 +10529,20 @@ var modelList = [
     dimension: ["DIE_LINE"],
     attributes: { ...BECF_12109_DEFAULT_ATTRIBUTES }
   },
+  {
+    id: "BECF-B-12101",
+    nameEN: "SHOPPING BAGS TYPE B",
+    nameTH: "\u0E16\u0E38\u0E07\u0E2B\u0E39\u0E40\u0E01\u0E25\u0E35\u0E22\u0E27\u0E01\u0E23\u0E30\u0E14\u0E32\u0E29 B",
+    dimension: ["DIE_LINE"],
+    attributes: { ...BECF_B_12101_DEFAULT_ATTRIBUTES }
+  },
+  {
+    id: "BECF-B-12109",
+    nameEN: "SHOPPING BAGS TYPE B1",
+    nameTH: "\u0E16\u0E38\u0E07\u0E2B\u0E39\u0E40\u0E01\u0E25\u0E35\u0E22\u0E27\u0E01\u0E23\u0E30\u0E14\u0E32\u0E29 B1",
+    dimension: ["DIE_LINE"],
+    attributes: { ...BECF_B_12109_DEFAULT_ATTRIBUTES }
+  },
   {
     id: "BECF-C-12101",
     nameEN: "SHOPPING BAGS TYPE C",
@@ -8827,6 +10556,13 @@ var modelList = [
     nameTH: "\u0E16\u0E38\u0E07\u0E2B\u0E39\u0E23\u0E34\u0E1A\u0E1A\u0E34\u0E49\u0E19 C1",
     dimension: ["DIE_LINE"],
     attributes: { ...BECF_C_12109_DEFAULT_ATTRIBUTES }
+  },
+  {
+    id: "BECF-10A0A",
+    nameEN: "SNAP LOCK BOTTOM BOX",
+    nameTH: "\u0E01\u0E25\u0E48\u0E2D\u0E07\u0E01\u0E49\u0E19\u0E25\u0E47\u0E2D\u0E04",
+    dimension: ["DIE_LINE"],
+    attributes: { ...BECF_10A0A_DEFAULT_ATTRIBUTES }
   }
 ];
 
@@ -8844,9 +10580,12 @@ exports.AUTO_LAYOUT_THEME_CONFIG = AUTO_LAYOUT_THEME_CONFIG;
 exports.BECF_1010A_DEFAULT_ATTRIBUTES = BECF_1010A_DEFAULT_ATTRIBUTES;
 exports.BECF_1030A_DEFAULT_ATTRIBUTES = BECF_1030A_DEFAULT_ATTRIBUTES;
 exports.BECF_1040A_DEFAULT_ATTRIBUTES = BECF_1040A_DEFAULT_ATTRIBUTES;
+exports.BECF_10A0A_DEFAULT_ATTRIBUTES = BECF_10A0A_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_B_12101_DEFAULT_ATTRIBUTES = BECF_B_12101_DEFAULT_ATTRIBUTES;
+exports.BECF_B_12109_DEFAULT_ATTRIBUTES = BECF_B_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;
@@ -8855,11 +10594,15 @@ exports.Gripper = Gripper;
 exports.MODEL_BECF_1010A = MODEL_BECF_1010A;
 exports.MODEL_BECF_1030A = MODEL_BECF_1030A;
 exports.MODEL_BECF_1040A = MODEL_BECF_1040A;
+exports.MODEL_BECF_10A0A = MODEL_BECF_10A0A;
 exports.MODEL_BECF_11D01 = MODEL_BECF_11D01;
 exports.MODEL_BECF_12101 = MODEL_BECF_12101;
 exports.MODEL_BECF_12109 = MODEL_BECF_12109;
+exports.MODEL_BECF_B_12101 = MODEL_BECF_B_12101;
+exports.MODEL_BECF_B_12109 = MODEL_BECF_B_12109;
 exports.MODEL_BECF_C_12101 = MODEL_BECF_C_12101;
 exports.MODEL_BECF_C_12109 = MODEL_BECF_C_12109;
+exports.MODEL_DEFAULT_ATTRIBUTES = MODEL_DEFAULT_ATTRIBUTES;
 exports.MODEL_THEME_CONFIG = MODEL_THEME_CONFIG;
 exports.appendColorbarToSvg = appendColorbarToSvg;
 exports.appendGripperToSvg = appendGripperToSvg;