@lucablockltd/ultimate-packaging 1.1.0 → 1.2.0

package/dist/AGENTS_README.md

@@ -69,18 +69,186 @@ const pdf = await ref.current.exportDimension();
 ## 2. Auto-Layout (Pack Dielines on Paper)
 
 Use `AUTO_LAYOUT` to automatically arrange dieline pieces on paper sheets.
+The engine calculates the optimal rotation and grid placement to maximize pieces per sheet.
 
-```tsx
-import { AUTO_LAYOUT, calculateAutoLayout } from "@lucablockltd/ultimate-packaging";
-import type {
-  AutoLayoutRef,
-  AutoLayoutConfig,
-  AutoLayoutResult,
+### AutoLayoutConfig — Full Reference
+
+`AutoLayoutConfig` has **3 required fields** and **5 optional print-setting fields**.
+If you omit any optional field, the system uses a sensible default automatically.
+
+```typescript
+interface AutoLayoutConfig {
+  // ─── REQUIRED ───────────────────────────────────────────────
+  papers: AutoLayoutPaper[];  // At least 1 paper size to test
+  model: AutoLayoutModel;     // Which box/bag model and its dimensions
+  quantity: number;            // Total pieces needed (e.g. 1000)
+
+  // ─── OPTIONAL (print settings) ──────────────────────────────
+  // You can omit ALL of these — the system will use defaults.
+  layoutDistance?: number;     // default: 3   — mm gap between piece cut-lines
+  spacing?: number;            // default: 5   — mm margin from paper edges
+  griper?: number;             // default: 10  — mm machine gripper zone
+  colorbarHeight?: number;     // default: 5   — mm height of color test strip
+  isShowColorbar?: boolean;    // default: true — whether to show colorbar
+}
+```
+
+#### Required Field #1: `papers` — Paper sizes to test
+
+An array of paper sizes. The engine will calculate layout for EVERY paper and rank them by efficiency.
+Each paper needs 4 fields — all required:
+
+```typescript
+interface AutoLayoutPaper {
+  paperId: string;      // Unique ID (any string, e.g. "1", "paper-a4", "custom-1")
+  paperName: string;    // Display name (e.g. "20x28\"", "A4", "25x36\"")
+  paperWidth: number;   // Width in millimeters
+  paperHeight: number;  // Height in millimeters
+}
+```
+
+**Common paper sizes (inches → mm, multiply by 25.4):**
+
+| Name     | Inches   | paperWidth (mm) | paperHeight (mm) |
+| -------- | -------- | --------------- | ----------------- |
+| 20x28"   | 20 × 28  | 508             | 711.2             |
+| 25x36"   | 25 × 36  | 635             | 914.4             |
+| 25x12"   | 25 × 12  | 635             | 304.8             |
+| 23x35"   | 23 × 35  | 584.2           | 889               |
+
+**Example:**
+
+```typescript
+const papers: AutoLayoutPaper[] = [
+  { paperId: "1", paperName: '20x28"', paperWidth: 508, paperHeight: 711.2 },
+  { paperId: "2", paperName: '25x36"', paperWidth: 635, paperHeight: 914.4 },
+];
+```
+
+#### Required Field #2: `model` — Which packaging model and its dimensions
+
+```typescript
+interface AutoLayoutModel {
+  modelId: string;                    // Must be one of the supported model IDs (see below)
+  attributes: Record<string, number>; // Dimensions in mm — different per model
+}
+```
+
+**Supported `modelId` values and their required `attributes`:**
+
+| modelId      | Type                    | Required attributes                                              |
+| ------------ | ----------------------- | ---------------------------------------------------------------- |
+| `BECF-1010A` | Tuck End Box Type A     | `length`, `width`, `height`, `glueArea`, `dustFlap`, `tuckFlap`  |
+| `BECF-1030A` | Tuck End Box Type C     | `length`, `width`, `height`, `glueArea`, `dustFlap`, `tuckFlap`  |
+| `BECF-1040A` | Tuck End Box Type B     | `length`, `width`, `height`, `glueArea`, `dustFlap`, `tuckFlap`  |
+| `BECF-11D01` | Standard Box            | `length`, `width`, `height`, `flapHeight`, `glueArea`            |
+| `BECF-12101` | Carton Bag / Shopping Bag Type A | `length`, `width`, `height`, `glueArea`               |
+| `BECF-12109` | Carton Bag / Shopping Bag Type B | `length`, `width`, `height`, `glueArea`               |
+
+**Example — Tuck End Box:**
+
+```typescript
+const model: AutoLayoutModel = {
+  modelId: "BECF-1010A",
+  attributes: {
+    length: 60,     // box length (mm)
+    width: 25,      // box width (mm)
+    height: 100,    // box height (mm)
+    glueArea: 15,   // glue flap width (mm)
+    dustFlap: 15,   // dust flap extension (mm)
+    tuckFlap: 15,   // tuck flap height (mm)
+  },
+};
+```
+
+**Example — Standard Box:**
+
+```typescript
+const model: AutoLayoutModel = {
+  modelId: "BECF-11D01",
+  attributes: {
+    length: 100,
+    width: 50,
+    height: 150,
+    flapHeight: 50,
+    glueArea: 13,
+  },
+};
+```
+
+**Example — Carton Bag:**
+
+```typescript
+const model: AutoLayoutModel = {
+  modelId: "BECF-12101",
+  attributes: {
+    length: 100,    // A — front/back panel width (mm)
+    width: 50,      // B — side panel / gusset (mm)
+    height: 150,    // C — bag body height (mm)
+    glueArea: 13,   // glue flap width (mm)
+  },
+};
+```
+
+**Tip:** You can use pre-defined default attributes instead of hardcoding:
+
+```typescript
+import {
+  BECF_1010A_DEFAULT_ATTRIBUTES,
+  BECF_12101_DEFAULT_ATTRIBUTES,
 } from "@lucablockltd/ultimate-packaging";
 
-const ref = useRef<AutoLayoutRef>(null);
-const [result, setResult] = useState<AutoLayoutResult | null>(null);
+const model: AutoLayoutModel = {
+  modelId: "BECF-1010A",
+  attributes: { ...BECF_1010A_DEFAULT_ATTRIBUTES },
+};
+```
+
+#### Required Field #3: `quantity` — Total pieces needed
+
+A positive integer. The engine calculates how many sheets are needed to produce this quantity.
+
+```typescript
+quantity: 1000  // need 1000 pieces total
+```
+
+#### Optional Print Settings (all have defaults)
+
+These 5 fields control the printing press layout. **You can omit any or all of them.**
 
+| Field            | Type      | Default | What it does                                                                                     |
+| ---------------- | --------- | ------- | ------------------------------------------------------------------------------------------------ |
+| `layoutDistance` | `number`  | `3`     | Gap between piece cut-lines in mm. Creates an offset contour around each piece (half on each side). Set to `0` for pieces touching edge-to-edge. |
+| `spacing`        | `number`  | `5`     | Margin from all paper edges in mm. Reserved border where no pieces are placed.                   |
+| `griper`         | `number`  | `10`    | Machine gripper zone depth in mm. Area reserved for the printing press feed mechanism. Placed on the bottom edge (landscape) or left edge (portrait). |
+| `colorbarHeight` | `number`  | `5`     | Height of the color test strip in mm. A row of colored squares for print registration, placed on the opposite side of the gripper. |
+| `isShowColorbar` | `boolean` | `true`  | Whether to show the colorbar. If `false`, `colorbarHeight` is ignored and that space becomes usable for pieces. |
+
+### Minimal Config Example (only required fields)
+
+This is the **simplest possible config** — all print settings use defaults:
+
+```tsx
+const config: AutoLayoutConfig = {
+  papers: [
+    { paperId: "1", paperName: '20x28"', paperWidth: 508, paperHeight: 711.2 },
+  ],
+  model: {
+    modelId: "BECF-1010A",
+    attributes: { length: 60, width: 25, height: 100, glueArea: 15, dustFlap: 15, tuckFlap: 15 },
+  },
+  quantity: 1000,
+  // layoutDistance → defaults to 3
+  // spacing       → defaults to 5
+  // griper        → defaults to 10
+  // colorbarHeight → defaults to 5
+  // isShowColorbar → defaults to true
+};
+```
+
+### Full Config Example (all fields explicit)
+
+```tsx
 const config: AutoLayoutConfig = {
   papers: [
     { paperId: "1", paperName: '20x28"', paperWidth: 508, paperHeight: 711.2 },
@@ -98,52 +266,153 @@ const config: AutoLayoutConfig = {
     },
   },
   quantity: 1000,
-  layoutDistance: 3, // mm gap between pieces (offset contour)
-  spacing: 5, // mm margin on sides
-  griper: 10, // mm machine gripper zone
-  colorbarHeight: 5, // mm colorbar strip height
+  layoutDistance: 3,
+  spacing: 5,
+  griper: 10,
+  colorbarHeight: 5,
   isShowColorbar: true,
 };
+```
+
+### Using the AUTO_LAYOUT Component (React)
+
+```tsx
+import { AUTO_LAYOUT } from "@lucablockltd/ultimate-packaging";
+import type {
+  AutoLayoutRef,
+  AutoLayoutConfig,
+  AutoLayoutResult,
+} from "@lucablockltd/ultimate-packaging";
+
+const ref = useRef<AutoLayoutRef>(null);
+const [result, setResult] = useState<AutoLayoutResult | null>(null);
 
 <AUTO_LAYOUT ref={ref} config={config} onResult={setResult} />;
 ```
 
 ### AUTO_LAYOUT Props
 
-| Prop               | Type                                         | Required | Description                                                                                                       |
-| ------------------ | -------------------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
-| `config`           | `AutoLayoutConfig \| null`                   | YES      | Layout configuration (null = no render)                                                                           |
-| `onResult`         | `(result: AutoLayoutResult \| null) => void` | no       | Called when layout is calculated                                                                                  |
-| `onModifiedPapers` | `(papers: AutoLayoutPaperResult[]) => void`  | no       | Called when user modifies layout manually                                                                         |
-| `isShowSummary`    | `boolean`                                    | no       | Show/hide summary panel (default: `true`)                                                                         |
-| `isShowAction`     | `AutoLayoutAction[]`                         | no       | Which action buttons to show. If omitted, all are shown. Values: `"EXPORT_SHEET"`, `"EXPORT_PDF"`, `"MODIFY_LAYOUT"` |
+| Prop               | Type                                         | Required | Default          | Description                                                                                                       |
+| ------------------ | -------------------------------------------- | -------- | ---------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `config`           | `AutoLayoutConfig \| null`                   | YES      | —                | Layout configuration. Pass `null` to clear/hide the layout.                                                       |
+| `onResult`         | `(result: AutoLayoutResult \| null) => void` | no       | —                | Callback fired when layout calculation completes. Receives the full result object.                                |
+| `onModifiedPapers` | `(papers: AutoLayoutPaperResult[]) => void`  | no       | —                | Callback fired when user manually drags/modifies piece positions on the layout.                                   |
+| `isShowSummary`    | `boolean`                                    | no       | `true`           | Show/hide the summary stats panel above each paper (pieces/sheet, waste %, etc.)                                  |
+| `isShowAction`     | `AutoLayoutAction[]`                         | no       | all actions shown | Which action buttons to show. Values: `"EXPORT_SHEET"`, `"EXPORT_PDF"`, `"MODIFY_LAYOUT"`. Omit to show all.     |
 
 ### AUTO_LAYOUT Ref Methods
 
+Access these via `ref.current` after the component mounts:
+
 ```tsx
-// Get calculation result
-ref.current.getResult(); // → AutoLayoutResult
+const ref = useRef<AutoLayoutRef>(null);
+
+// 1. Get the full calculation result
+const result = ref.current.getResult();
+// → AutoLayoutResult | null
+
+// 2. Export a specific paper's layout as PNG image
+const pngBlob = await ref.current.exportImage(0); // 0 = first paper index
+// → Blob (image/png)
 
-// Export layout image (PNG) for specific paper
-const png = await ref.current.exportImage(0); // paper index 0
+// 3. Export a specific paper's layout as PDF
+const pdfBlob = await ref.current.exportPdf(0);
+// → Blob (application/pdf)
 
-// Export layout as PDF
-const pdf = await ref.current.exportPdf(0);
+// 4. Export the dieline pattern as PNG
+const dielineBlob = await ref.current.exportDielineImage();
+// → Blob (image/png)
 
-// Get packed result with dieline + layout image files
+// 5. Get packed result — includes images as File objects (useful for upload/FormData)
 const packed = await ref.current.getPackedResult(0);
-// → { ...paperResult, quantity, dielineFile: File, layoutFile: File }
+// → AutoLayoutPackedResult {
+//     ...all AutoLayoutPaperResult fields,
+//     quantity: number,
+//     dielineFile: File,  // dieline pattern PNG
+//     layoutFile: File,   // layout arrangement PNG
+//   }
 ```
 
-### Programmatic Calculation (No UI)
+### Programmatic Calculation (No UI / No React)
+
+Use `calculateAutoLayout()` to compute layout without rendering any component.
+Same config, same result — just no visual output.
 
 ```tsx
 import { calculateAutoLayout } from "@lucablockltd/ultimate-packaging";
+import type { AutoLayoutConfig, AutoLayoutResult } from "@lucablockltd/ultimate-packaging";
+
+const config: AutoLayoutConfig = {
+  papers: [
+    { paperId: "A", paperName: '20x28"', paperWidth: 508, paperHeight: 711.2 },
+    { paperId: "B", paperName: '25x36"', paperWidth: 635, paperHeight: 914.4 },
+  ],
+  model: {
+    modelId: "BECF-1010A",
+    attributes: { length: 60, width: 25, height: 100, glueArea: 15, dustFlap: 15, tuckFlap: 15 },
+  },
+  quantity: 1000,
+  // print settings are optional — defaults will be used
+};
 
-const result = calculateAutoLayout(config);
-// → AutoLayoutResult { papers, quantity, totalProduced, totalSheets, remainingNeeded, recommendedPaperId }
+const result: AutoLayoutResult = calculateAutoLayout(config);
+
+// Result structure:
+// result.recommendedPaperId  → "B" (best paper by least total area)
+// result.quantity             → 1000
+// result.totalProduced        → 1008 (may exceed quantity due to full sheets)
+// result.totalSheets          → total sheets across all papers
+// result.remainingNeeded      → 0 (if all produced)
+// result.papers               → AutoLayoutPaperResult[] (one per paper, sorted best-first)
+```
+
+### AutoLayoutResult — Output Reference
+
+```typescript
+interface AutoLayoutResult {
+  papers: AutoLayoutPaperResult[];  // Results per paper size, sorted by efficiency (best first)
+  quantity: number;                  // Original requested quantity
+  totalProduced: number;             // Total pieces produced (may exceed quantity)
+  totalSheets: number;               // Total sheets needed across all papers
+  remainingNeeded: number;           // Shortfall (0 if quantity is met)
+  recommendedPaperId: string | null; // paperId of the most efficient paper (least total area)
+}
+
+interface AutoLayoutPaperResult {
+  paperId: string;              // Matches the input paper's paperId
+  paperName: string;            // Display name
+  paperWidth: number;           // mm
+  paperHeight: number;          // mm
+  producedPerSheet: number;     // How many pieces fit on ONE sheet
+  totalSheets: number;          // Sheets needed for the requested quantity
+  totalProduced: number;        // producedPerSheet × totalSheets
+  excessCount: number;          // Overproduction beyond quantity
+  wastePercent: number;         // Unused paper area percentage (0–100)
+  independentSheets: number;    // Sheets needed if ONLY this paper is used
+  independentTotalArea: number; // Total paper area in mm² if only this paper
+  placements: AutoLayoutPlacement[]; // Position of each piece on the sheet
+  gripperSide: GripperSide;     // Which edge the gripper is on
+}
+
+interface AutoLayoutPlacement {
+  x: number;         // mm from paper left edge
+  y: number;         // mm from paper top edge
+  rotation: number;  // 0 | 90 | 180 | 270 degrees
+}
+
+type GripperSide = "top" | "bottom" | "left" | "right";
+// Automatically determined: landscape paper → "bottom", portrait → "left"
 ```
 
+### Layout Algorithm Summary
+
+1. The engine tries all 4 rotations (0°, 90°, 180°, 270°) for each piece on each paper
+2. For each rotation, it packs pieces in a grid within the **usable bounds**
+3. **Usable bounds** = paper area minus: `spacing` (all edges) + `griper` (one edge) + `colorbarHeight` (opposite edge)
+4. The rotation that fits the **most pieces** wins
+5. Papers are sorted by `independentTotalArea` (ascending) — the paper that uses the least total area to fulfill quantity is ranked #1
+6. `recommendedPaperId` = the #1 ranked paper
+
 ---
 
 ## 3. Available Models & Attributes

package/dist/index.js

@@ -3757,6 +3757,64 @@ function generateBecf12109(attr) {
   crease.push(line6(xSide2Mid, yFoldBottomStart, xEnd, D + C - 2));
   return { cut, crease, viewBox: { width: totalWidth, height: totalHeight } };
 }
+function generateOuterContour6(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD2(C, B);
+  const kulak = glueArea ?? calcKulak2(B);
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = D + C + B / 2 + DIP2;
+  return [
+    { x: 0, y: 0 },
+    { x: totalWidth, y: 0 },
+    { x: totalWidth, y: totalHeight },
+    { x: 0, y: totalHeight }
+  ];
+}
+function offsetContour6(points, distance) {
+  const n = points.length;
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    const prev = points[(i - 1 + n) % n];
+    const curr = points[i];
+    const next = points[(i + 1) % n];
+    const e1x = curr.x - prev.x;
+    const e1y = curr.y - prev.y;
+    const e2x = next.x - curr.x;
+    const e2y = next.y - curr.y;
+    const len1 = Math.sqrt(e1x * e1x + e1y * e1y);
+    const len2 = Math.sqrt(e2x * e2x + e2y * e2y);
+    if (len1 === 0 || len2 === 0) {
+      result.push(curr);
+      continue;
+    }
+    const n1x = e1y / len1;
+    const n1y = -e1x / len1;
+    const n2x = e2y / len2;
+    const n2y = -e2x / len2;
+    const ax = n1x + n2x;
+    const ay = n1y + n2y;
+    const aLen = Math.sqrt(ax * ax + ay * ay);
+    if (aLen < 1e-3) {
+      result.push({ x: curr.x + n1x * distance, y: curr.y + n1y * distance });
+      continue;
+    }
+    const nx = ax / aLen;
+    const ny = ay / aLen;
+    const dot = n1x * nx + n1y * ny;
+    const d = distance / Math.max(dot, 0.1);
+    result.push({ x: curr.x + nx * d, y: curr.y + ny * d });
+  }
+  return result;
+}
+function contourToPath6(points) {
+  if (points.length === 0) return "";
+  let d = `M${points[0].x} ${points[0].y}`;
+  for (let i = 1; i < points.length; i++) {
+    d += ` L${points[i].x} ${points[i].y}`;
+  }
+  d += " Z";
+  return d;
+}
 function generateDimensions6(attr, unit) {
   const { length: A, width: B, height: C, glueArea } = attr;
   const D = calcD2(C, B);
@@ -5041,6 +5099,156 @@ function computeLayoutForPaper4(contourPoints, dielineW, dielineH, _paperWidth,
   };
 }
 
+// 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),
+    bbOffset: computeDielineBBOffset(contourPoints, dielineW, dielineH, deg),
+    deg
+  };
+}
+function pairGrid4(rdA, rdB, bounds) {
+  const pA = rdA.profile, pB = rdB.profile;
+  const gapAB = findMinStepX(pA, pB, 0);
+  if (gapAB <= 0) return emptyResult();
+  const pairW = gapAB + pB.width;
+  const pairH = Math.max(pA.height, pB.height);
+  const pairStepX = gapAB + findMinStepX(pB, pA, 0);
+  const pairStepY = Math.max(
+    findMinStepY(pA, pA, 0),
+    findMinStepY(pA, pB, gapAB),
+    findMinStepY(pB, pA, -gapAB),
+    findMinStepY(pB, pB, 0)
+  );
+  if (pairStepX <= 0 || pairStepY <= 0) return emptyResult();
+  const usableW = bounds.right - bounds.left;
+  const usableH = bounds.bottom - bounds.top;
+  const pairCols = Math.max(0, Math.floor((usableW - pairW) / pairStepX) + 1);
+  const pairRows = Math.max(0, Math.floor((usableH - pairH) / pairStepY) + 1);
+  if (pairCols === 0 || pairRows === 0) return emptyResult();
+  const placements = [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let r = 0; r < pairRows; r++) {
+    for (let c = 0; c < pairCols; c++) {
+      const baseX = bounds.left + c * pairStepX;
+      const baseY = bounds.top + r * pairStepY;
+      const oxA = baseX;
+      const oyA = baseY;
+      placements.push({ x: oxA + rdA.bbOffset.dx, y: oyA + rdA.bbOffset.dy, rotation: rdA.deg });
+      if (oxA < minX) minX = oxA;
+      if (oyA < minY) minY = oyA;
+      if (oxA + pA.width > maxX) maxX = oxA + pA.width;
+      if (oyA + pA.height > maxY) maxY = oyA + pA.height;
+      const oxB = baseX + gapAB;
+      const oyB = baseY;
+      placements.push({ x: oxB + rdB.bbOffset.dx, y: oyB + rdB.bbOffset.dy, rotation: rdB.deg });
+      if (oxB < minX) minX = oxB;
+      if (oyB < minY) minY = oyB;
+      if (oxB + pB.width > maxX) maxX = oxB + pB.width;
+      if (oyB + pB.height > maxY) maxY = oyB + pB.height;
+    }
+  }
+  const pairsRightEdge = bounds.left + (pairCols - 1) * pairStepX + pairW;
+  const pairsBottomEdge = bounds.top + (pairRows - 1) * pairStepY + pairH;
+  const gapRight = bounds.right - pairsRightEdge;
+  const gapBottom = bounds.bottom - pairsBottomEdge;
+  const extraRotations = [rdA, rdB];
+  for (const rdExtra of extraRotations) {
+    const pe = rdExtra.profile;
+    if (pe.width <= gapRight) {
+      for (let r = 0; r < pairRows; r++) {
+        const ox = pairsRightEdge;
+        const oy = bounds.top + r * pairStepY;
+        if (ox + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
+          placements.push({ x: ox + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
+          if (ox + pe.width > maxX) maxX = ox + pe.width;
+        }
+      }
+      break;
+    }
+  }
+  for (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 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, prepareRotation5(contourPoints, dielineW, dielineH, deg));
+  }
+  const results = [];
+  for (const deg of rots) {
+    results.push(singleRotGrid(rd.get(deg), bounds));
+  }
+  const allPairs = [
+    [0, 180],
+    [90, 270],
+    [0, 90],
+    [0, 270],
+    [90, 180],
+    [180, 270]
+  ];
+  for (const [a, b] of allPairs) {
+    const rdA = rd.get(a), rdB = rd.get(b);
+    const stepA = findMinStepX(rdA.profile, rdA.profile, 0);
+    if (stepA <= 0) continue;
+    for (let off = 0; off < stepA; off += 1) {
+      results.push(dualRotGrid(rdA, rdB, off, bounds));
+      results.push(dualRotGrid(rdB, rdA, off, bounds));
+    }
+  }
+  for (const [a, b] of allPairs) {
+    results.push(pairGrid4(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid4(rd.get(b), rd.get(a), bounds));
+  }
+  const singleResults = [];
+  const multiResults = [];
+  for (const r of results) {
+    if (r.count === 0) continue;
+    const rotations = new Set(r.placements.map((p) => p.rotation));
+    if (rotations.size > 1) {
+      multiResults.push(r);
+    } else {
+      singleResults.push(r);
+    }
+  }
+  function pickBest(arr) {
+    let b = arr[0] ?? emptyResult();
+    let bArea = (b.maxX - b.minX) * (b.maxY - b.minY);
+    for (const r of arr) {
+      const area = (r.maxX - r.minX) * (r.maxY - r.minY);
+      if (r.count > b.count || r.count === b.count && area < bArea) {
+        b = r;
+        bArea = area;
+      }
+    }
+    return b;
+  }
+  const bestSingle = pickBest(singleResults);
+  const bestMulti = pickBest(multiResults);
+  const best = bestMulti.count >= bestSingle.count && bestMulti.count > 0 ? bestMulti : bestSingle;
+  centerLayout(best, bounds);
+  return {
+    rotation: best.placements[0]?.rotation ?? 0,
+    placements: best.placements,
+    producedPerSheet: best.count
+  };
+}
+
 // src/utils/autoLayout/calculate/index.ts
 function resolveModelFunctions(modelId, attrs) {
   switch (modelId) {
@@ -5076,6 +5284,14 @@ function resolveModelFunctions(modelId, attrs) {
         offsetContour: offsetContour5
       };
     }
+    case "BECF-12109": {
+      const a = attrs;
+      return {
+        contour: generateOuterContour6(a),
+        dieline: generateBecf12109(a),
+        offsetContour: offsetContour6
+      };
+    }
     case "BECF-1010A":
     default: {
       const a = attrs;
@@ -5097,6 +5313,8 @@ function resolveLayoutCalculator(modelId) {
       return computeLayoutForPaper3;
     case "BECF-12101":
       return computeLayoutForPaper4;
+    case "BECF-12109":
+      return computeLayoutForPaper5;
     default:
       return computeLayoutForPaperDefault;
   }
@@ -5110,11 +5328,11 @@ function calculateAutoLayout(rawConfig) {
     colorbarHeight: rawConfig.colorbarHeight ?? 5,
     isShowColorbar: rawConfig.isShowColorbar ?? true
   };
-  const { contour, dieline, offsetContour: offsetContour6 } = resolveModelFunctions(
+  const { contour, dieline, offsetContour: offsetContour7 } = resolveModelFunctions(
     config.model.modelId,
     config.model.attributes
   );
-  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour6(contour, config.layoutDistance / 2) : contour;
+  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour7(contour, config.layoutDistance / 2) : contour;
   const cbDepth = config.isShowColorbar ? config.colorbarHeight : 0;
   const computeLayout = resolveLayoutCalculator(config.model.modelId);
   const paperResults = [];
@@ -6054,6 +6272,17 @@ function resolveModel(modelId, attrs, layoutDistance) {
         generateContour: (a) => generateOuterContour5(a)
       };
     }
+    case "BECF-12109": {
+      const typedAttrs = attrs;
+      const contour = generateOuterContour6(typedAttrs);
+      return {
+        dieline: generateBecf12109(typedAttrs),
+        contourPath: contourToPath6(contour),
+        offsetContourPoints: layoutDistance > 0 ? offsetContour6(contour, layoutDistance / 2) : contour,
+        generate: (a) => generateBecf12109(a),
+        generateContour: (a) => generateOuterContour6(a)
+      };
+    }
     case "BECF-1010A":
     default: {
       const typedAttrs = attrs;
@@ -6103,6 +6332,14 @@ function renderDieLine2(modelId, attrs) {
             renderAs: "group"
           }
         );
+      case "BECF-12109":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          DIE_LINE_BECF_12109,
+          {
+            attributes: attrs,
+            renderAs: "group"
+          }
+        );
       case "BECF-1010A":
       default:
         return /* @__PURE__ */ jsxRuntime.jsx(