GridFlock STL Generation Service Feasibility Study¶

interface GridFlockParameters {
  // Core dimensions
  bedSize: { x: number; y: number }; // Printer bed size (e.g., 250x220)
  plateSize: { x: number; y: number }; // Grid plate dimensions
  doHalfX: boolean; // Half cells in X direction
  doHalfY: boolean; // Half cells in Y direction
  solidBase: number; // Base thickness (mm)
  bottomChamfer: [number, number, number, number]; // N, E, S, W chamfers

  // Magnets
  magnets: boolean;
  magnetStyle: 'glue-from-top' | 'press-fit';
  magnetFrameStyle: 'solid' | 'round-corners';
  magnetDiameter: number; // Default: 6mm
  magnetHeight: number; // Default: 2mm
  magnetTop: number; // Wall above magnet
  magnetBottom: number; // Floor below magnet

  // Connectors - Intersection Puzzle
  connectorIntersectionPuzzle: boolean;

  // Connectors - Edge Puzzle
  connectorEdgePuzzle: boolean;
  edgePuzzleCount: number;
  edgePuzzleDim: { x: number; y: number; z: number };
  edgePuzzleDimC: { x: number; y: number; z: number };
  edgePuzzleGap: number;
  edgePuzzleMagnetBorder: boolean;
  edgePuzzleMagnetBorderWidth: number;
  edgePuzzleHeightFemale: number;
  edgePuzzleHeightMaleDelta: number;

  // Numbering
  numbering: boolean;
  numberDepth: number;
  numberSize: number;
  numberFont: string;
  numberSqueezeSize: number;

  // Plate wall
  plateWallThickness: [number, number, number, number]; // N, E, S, W
  plateWallHeight: [number, number]; // Above, below

  // Vertical screws
  verticalScrewDiameter: number;
  verticalScrewCountersinkTop: [number, number];
  verticalScrewPlateCorners: boolean;
  verticalScrewPlateCornerInset: number;
  verticalScrewPlateEdges: boolean;
  verticalScrewSegmentCorners: boolean;
  verticalScrewSegmentCornerInset: number;
  verticalScrewSegmentEdges: boolean;
  verticalScrewOther: boolean;

  // Thumbscrews
  thumbscrews: boolean;
  thumbscrewDiameter: number;

  // Advanced
  plateCornerRadius: number; // Default: 4mm
  edgeAdjust: [number, number, number, number]; // N, E, S, W padding
  yRowCountFirst: [number, number]; // Odd, even columns
  testPattern: 'none' | 'half' | 'padding' | 'numbering' | 'wall';
}

┌─────────────────────────────────────────────────────────────────┐
│                    GridFlock Technology Stack                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    GridFlock Core                        │   │
│  │                 (TypeScript/JSCAD)                       │   │
│  ├─────────────────────────────────────────────────────────┤   │
│  │                                                         │   │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │   │
│  │  │  Plate      │  │  Connector  │  │   Magnet    │    │   │
│  │  │  Generator  │  │  Systems    │  │   System    │    │   │
│  │  └─────────────┘  └─────────────┘  └─────────────┘    │   │
│  │                                                         │   │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │   │
│  │  │  Numbering  │  │   Screws    │  │   Walls     │    │   │
│  │  │  System     │  │   System    │  │   System    │    │   │
│  │  └─────────────┘  └─────────────┘  └─────────────┘    │   │
│  │                                                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                            │                                    │
│                     ┌──────▼──────┐                            │
│                     │   JSCAD     │                            │
│                     │ @jscad/*    │                            │
│                     └──────┬──────┘                            │
│                            │                                    │
│                     ┌──────▼──────┐                            │
│                     │ STL Export  │                            │
│                     │ Binary/ASCII│                            │
│                     └─────────────┘                            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

interface IntersectionPuzzleParams {
  connectorIntersectionPuzzle: boolean; // Enable GRIPS-like connectors
}

interface EdgePuzzleParams {
  connectorEdgePuzzle: boolean; // Enable edge connectors
  edgePuzzleCount: number; // Connectors per cell edge
  edgePuzzleDim: [number, number, number]; // Male connector size [x, y, z]
  edgePuzzleDimC: [number, number, number]; // Bridge dimensions
  edgePuzzleGap: number; // Tolerance/clearance (tune for printer)
  edgePuzzleMagnetBorder: boolean; // Add border when magnets enabled
  edgePuzzleMagnetBorderWidth: number; // Border width
  edgePuzzleHeightFemale: number; // Socket height
  edgePuzzleHeightMaleDelta: number; // Male-female height difference
}

interface BedSizedPlateParams {
  bedSize: [number, number]; // e.g., [250, 220] for Prusa Core One
  plateSize: [number, number]; // Target grid size
  doHalfX: boolean; // Squeeze in half cells if space allows
  doHalfY: boolean; // Squeeze in half cells if space allows
  edgeAdjust: [number, number, number, number]; // Fine-tune edges [N, E, S, W]
}

const params = {
  bedSize: [256, 256],
  plateSize: [6, 6], // 6×6 = 252mm (fits with margin)
  doHalfX: false,
  doHalfY: false,
  connectorIntersectionPuzzle: true, // Click together!
  magnets: true,
  numbering: true, // "Plate 1", "Plate 2", etc.
};

// GridFlock worker service
import { primitives, booleans, transforms } from '@jscad/modeling';
import { serialize } from '@jscad/stl-serializer';

// Import GridFlock generator (forked/modified for server use)
import { generateGridFlockPlate } from './gridflock-core';

interface GenerationRequest {
  bedSize: [number, number];
  plateSize: [number, number];
  magnets: boolean;
  magnetDiameter: number;
  connectorIntersectionPuzzle: boolean;
  connectorEdgePuzzle: boolean;
  edgePuzzleGap: number;
  numbering: boolean;
  plateIndex: number; // For segment numbering
}

export async function generatePlateSTL(params: GenerationRequest): Promise<Buffer> {
  // Generate the JSCAD geometry
  const geometry = generateGridFlockPlate(params);

  // Serialize to binary STL
  const stlData = serialize({ binary: true }, geometry);

  return Buffer.from(stlData[0]);
}

// Example: Generate a set of 4 plates for a large surface
export async function generatePlateSet(
  bedSize: [number, number],
  totalSize: [number, number],
  options: Partial<GenerationRequest>
): Promise<Map<string, Buffer>> {
  const plates = new Map<string, Buffer>();

  // Calculate how many plates needed
  const platesX = Math.ceil(totalSize[0] / bedSize[0]);
  const platesY = Math.ceil(totalSize[1] / bedSize[1]);

  for (let x = 0; x < platesX; x++) {
    for (let y = 0; y < platesY; y++) {
      const plateIndex = y * platesX + x + 1;
      const stl = await generatePlateSTL({
        bedSize,
        plateSize: [6, 6], // Max that fits on bed
        magnets: true,
        magnetDiameter: 6,
        connectorIntersectionPuzzle: true,
        connectorEdgePuzzle: false,
        edgePuzzleGap: 0.15,
        numbering: true,
        plateIndex,
        ...options,
      });

      plates.set(`plate_${plateIndex}.stl`, stl);
    }
  }

  return plates;
}

FROM node:22-alpine

WORKDIR /app

# Install JSCAD packages
COPY package.json pnpm-lock.yaml ./
RUN corepack enable && pnpm install --frozen-lockfile

# Copy GridFlock source
COPY . .

# No additional CAD software needed!
# Container size: ~150MB (vs 500MB+ for OpenSCAD)

CMD ["node", "dist/worker.js"]

┌─────────────────────────────────────────────────────────────────┐
│                    Modular Plate Assembly                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Customer wants: 12×12 grid (~504mm × 504mm) for workbench     │
│  Printer bed: 250mm × 220mm (Prusa MK4)                         │
│                                                                 │
│  Solution: 4 modular plates that click together                 │
│                                                                 │
│  ┌─────────────┬─────────────┐                                 │
│  │   Plate 1   │   Plate 2   │                                 │
│  │   (6×5)     │   (6×5)     │   ◄── Puzzle connectors         │
│  │     ↔       │     ↔       │       join plates seamlessly     │
│  ├─────────────┼─────────────┤                                 │
│  │   Plate 3   │   Plate 4   │                                 │
│  │   (6×5)     │   (6×5)     │                                 │
│  │     ↔       │     ↔       │                                 │
│  └─────────────┴─────────────┘                                 │
│                                                                 │
│  Numbered plates + matching connectors = easy assembly          │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

// POST /api/v1/gridflock/plate-sets
interface PlateSetRequest {
  // Target configuration
  targetGridSize: [number, number]; // e.g., [12, 12] for 12×12 grid
  printerBedSize: [number, number]; // e.g., [250, 220]

  // Options
  magnets: boolean;
  magnetDiameter: number;
  connectorType: 'intersection' | 'edge';
  connectorTolerance: number; // Tune for specific printer

  // Output
  includeAssemblyGuide: boolean; // Generate PDF with layout
}

interface PlateSetResponse {
  jobId: string;
  plates: Array<{
    index: number;
    gridSize: [number, number];
    position: [number, number]; // Position in final assembly
    filename: string;
  }>;
  totalPlates: number;
  estimatedTime: number;
}

# Request a 12×12 grid for a 250×220 printer
curl -X POST https://api.forma.example/api/v1/gridflock/plate-sets \
  -H "Content-Type: application/json" \
  -d '{
    "targetGridSize": [12, 12],
    "printerBedSize": [250, 220],
    "magnets": true,
    "connectorType": "intersection",
    "connectorTolerance": 0.15,
    "includeAssemblyGuide": true
  }'

# Response
{
  "jobId": "abc123",
  "plates": [
    { "index": 1, "gridSize": [6, 6], "position": [0, 0], "filename": "plate_1_6x6.stl" },
    { "index": 2, "gridSize": [6, 6], "position": [1, 0], "filename": "plate_2_6x6.stl" },
    { "index": 3, "gridSize": [6, 6], "position": [0, 1], "filename": "plate_3_6x6.stl" },
    { "index": 4, "gridSize": [6, 6], "position": [1, 1], "filename": "plate_4_6x6.stl" }
  ],
  "totalPlates": 4,
  "estimatedTime": 45
}

const PRINTER_PROFILES = {
  // Bambu Lab
  'bambu-a1-mini': { bedSize: [180, 180], maxGridSize: [4, 4] },
  'bambu-a1': { bedSize: [256, 256], maxGridSize: [6, 6] },
  'bambu-p1s': { bedSize: [256, 256], maxGridSize: [6, 6] },
  'bambu-x1c': { bedSize: [256, 256], maxGridSize: [6, 6] },

  // Prusa
  'prusa-mini': { bedSize: [180, 180], maxGridSize: [4, 4] },
  'prusa-mk4': { bedSize: [250, 210], maxGridSize: [5, 5] },
  'prusa-xl-single': { bedSize: [360, 360], maxGridSize: [8, 8] },
  'prusa-core-one': { bedSize: [250, 220], maxGridSize: [5, 5] },

  // Creality
  'ender-3-v3': { bedSize: [220, 220], maxGridSize: [5, 5] },
  'ender-3-s1': { bedSize: [220, 220], maxGridSize: [5, 5] },
  k1: { bedSize: [220, 220], maxGridSize: [5, 5] },
  'k1-max': { bedSize: [300, 300], maxGridSize: [7, 7] },

  // Voron
  'voron-0': { bedSize: [120, 120], maxGridSize: [2, 2] },
  'voron-2.4-250': { bedSize: [250, 250], maxGridSize: [5, 5] },
  'voron-2.4-300': { bedSize: [300, 300], maxGridSize: [7, 7] },
  'voron-2.4-350': { bedSize: [350, 350], maxGridSize: [8, 8] },
};

interface AssemblyGuide {
  layout: {
    totalSize: [number, number]; // Final dimensions in mm
    gridSize: [number, number]; // Total grid units
    plateCount: number;
  };
  plates: Array<{
    index: number;
    position: { row: number; col: number };
    neighbors: {
      north?: number;
      east?: number;
      south?: number;
      west?: number;
    };
  }>;
  instructions: string[]; // Step-by-step assembly
  printSettings: {
    material: string;
    layerHeight: number;
    infill: number;
    supports: boolean;
  };
}

┌─────────────────────────────────────────────────────────────────┐
│                    Forma 3D Connect API                         │
│                       (NestJS)                                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │  Orders      │  │  Products    │  │  GridFlock   │         │
│  │  Controller  │  │  Controller  │  │  Controller  │         │
│  └──────┬───────┘  └──────────────┘  └──────┬───────┘         │
│         │                                    │                  │
│  ┌──────▼──────────────────────────────────▼───────┐          │
│  │              STL Generation Service              │          │
│  │                                                  │          │
│  │  ┌────────────┐  ┌────────────┐  ┌──────────┐  │          │
│  │  │ Baseplate  │  │    Bin     │  │Accessory │  │          │
│  │  │ Generator  │  │ Generator  │  │Generator │  │          │
│  │  └────────────┘  └────────────┘  └──────────┘  │          │
│  └──────────────────────────────────────────────────┘          │
│                            │                                    │
│                     ┌──────▼──────┐                            │
│                     │  GridFlock  │                            │
│                     │   (JSCAD)   │                            │
│                     └─────────────┘                            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                           Architecture                                   │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  ┌─────────────────┐          ┌─────────────────┐                      │
│  │    Web App      │          │    PWA/Mobile   │                      │
│  │   (React 19)    │          │                 │                      │
│  └────────┬────────┘          └────────┬────────┘                      │
│           │                            │                                │
│           └──────────┬─────────────────┘                               │
│                      │                                                  │
│           ┌──────────▼──────────┐                                      │
│           │    API Gateway      │                                      │
│           │    (NestJS API)     │                                      │
│           └──────────┬──────────┘                                      │
│                      │                                                  │
│      ┌───────────────┼───────────────┐                                 │
│      │               │               │                                  │
│  ┌───▼───┐      ┌───▼───┐      ┌───▼────┐                             │
│  │Orders │      │Products│      │GridFlock│                            │
│  │Service│      │Service │      │Service  │◄── NEW                     │
│  └───┬───┘      └───┬───┘      └───┬────┘                             │
│      │               │               │                                  │
│      │               │         ┌─────▼─────┐                           │
│      │               │         │   Queue   │                           │
│      │               │         │(BullMQ/   │                           │
│      │               │         │ RabbitMQ) │                           │
│      │               │         └─────┬─────┘                           │
│      │               │               │                                  │
│      │               │         ┌─────▼─────┐                           │
│      │               │         │  Workers  │                           │
│      │               │         │(GridFlock/│                           │
│      │               │         │  JSCAD)   │                           │
│      │               │         └─────┬─────┘                           │
│      │               │               │                                  │
│  ┌───▼───────────────▼───────────────▼───┐                             │
│  │              PostgreSQL               │                             │
│  │         (Prisma + GridFlock schema)   │                             │
│  └───────────────────┬───────────────────┘                             │
│                      │                                                  │
│              ┌───────▼───────┐                                         │
│              │  Object Store │                                         │
│              │ (S3/MinIO for │                                         │
│              │  STL files)   │                                         │
│              └───────────────┘                                         │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    Serverless Architecture                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────┐                                              │
│  │   NestJS     │─────────┐                                    │
│  │     API      │         │                                    │
│  └──────────────┘         │                                    │
│                           ▼                                    │
│                  ┌──────────────┐                              │
│                  │   AWS SQS    │                              │
│                  │   or         │                              │
│                  │ Cloud Tasks  │                              │
│                  └──────┬───────┘                              │
│                         │                                       │
│           ┌─────────────┼─────────────┐                        │
│           │             │             │                         │
│     ┌─────▼─────┐ ┌─────▼─────┐ ┌─────▼─────┐                 │
│     │ Lambda/   │ │ Lambda/   │ │ Lambda/   │                 │
│     │ Cloud Run │ │ Cloud Run │ │ Cloud Run │                 │
│     │ (Worker)  │ │ (Worker)  │ │ (Worker)  │                 │
│     └─────┬─────┘ └─────┬─────┘ └─────┬─────┘                 │
│           │             │             │                         │
│           └─────────────┼─────────────┘                        │
│                         ▼                                       │
│                  ┌──────────────┐                              │
│                  │     S3       │                              │
│                  │  (STL files) │                              │
│                  └──────────────┘                              │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

openapi: 3.0.3
info:
  title: GridFlock STL Generation API
  version: 1.0.0
  description: API for generating Gridfinity-compatible STL files

paths:
  /api/v1/gridflock/baseplates:
    post:
      summary: Generate a baseplate STL
      tags: [Baseplates]
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BaseplateRequest'
      responses:
        '202':
          description: Generation job accepted
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/JobResponse'

  /api/v1/gridflock/baseplates/sync:
    post:
      summary: Generate baseplate STL synchronously (small models only)
      tags: [Baseplates]
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BaseplateRequest'
      responses:
        '200':
          description: STL file
          content:
            model/stl:
              schema:
                type: string
                format: binary

  /api/v1/gridflock/jobs/{jobId}:
    get:
      summary: Get job status
      tags: [Jobs]
      parameters:
        - name: jobId
          in: path
          required: true
          schema:
            type: string
            format: uuid
      responses:
        '200':
          description: Job status
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/JobStatus'

  /api/v1/gridflock/jobs/{jobId}/download:
    get:
      summary: Download generated STL
      tags: [Jobs]
      parameters:
        - name: jobId
          in: path
          required: true
          schema:
            type: string
            format: uuid
      responses:
        '200':
          description: STL file download
          content:
            model/stl:
              schema:
                type: string
                format: binary
        '202':
          description: Job still processing
        '404':
          description: Job not found

  /api/v1/gridflock/presets:
    get:
      summary: List available presets
      tags: [Presets]
      responses:
        '200':
          description: List of presets
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Preset'

components:
  schemas:
    BaseplateRequest:
      type: object
      required:
        - gridX
        - gridY
      properties:
        gridX:
          type: integer
          minimum: 1
          maximum: 20
          description: Number of grid units in X direction
        gridY:
          type: integer
          minimum: 1
          maximum: 20
          description: Number of grid units in Y direction
        magnets:
          type: boolean
          default: true
        magnetDiameter:
          type: number
          default: 6.0
        magnetDepth:
          type: number
          default: 2.0
        magnetStyle:
          type: string
          enum: [glue-from-top, press-fit]
          default: press-fit
        screwHoles:
          type: boolean
          default: false
        connectorType:
          type: string
          enum: [none, intersection-puzzle, edge-puzzle]
          default: none
        halfCells:
          type: object
          properties:
            x: { type: boolean }
            y: { type: boolean }
        baseThickness:
          type: number
          default: 5.0
        quality:
          type: string
          enum: [draft, normal, high]
          default: normal
        callbackUrl:
          type: string
          format: uri
          description: Webhook URL for completion notification

    JobResponse:
      type: object
      properties:
        jobId:
          type: string
          format: uuid
        status:
          type: string
          enum: [queued, processing, completed, failed]
        estimatedTime:
          type: integer
          description: Estimated completion time in seconds
        position:
          type: integer
          description: Position in queue

    JobStatus:
      type: object
      properties:
        jobId:
          type: string
          format: uuid
        status:
          type: string
          enum: [queued, processing, completed, failed]
        progress:
          type: number
          minimum: 0
          maximum: 100
        downloadUrl:
          type: string
          format: uri
        expiresAt:
          type: string
          format: date-time
        error:
          type: string

    Preset:
      type: object
      properties:
        id:
          type: string
        name:
          type: string
        description:
          type: string
        parameters:
          $ref: '#/components/schemas/BaseplateRequest'

// apps/api/src/gridflock/gridflock.controller.ts
import { Controller, Post, Get, Body, Param, Res, HttpStatus } from '@nestjs/common';
import { Response } from 'express';
import { GridflockService } from './gridflock.service';
import { CreateBaseplateDto } from './dto/create-baseplate.dto';

@Controller('api/v1/gridflock')
export class GridflockController {
  constructor(private readonly gridflockService: GridflockService) {}

  @Post('baseplates')
  async createBaseplate(@Body() dto: CreateBaseplateDto) {
    const job = await this.gridflockService.queueGeneration(dto);
    return {
      jobId: job.id,
      status: 'queued',
      estimatedTime: this.gridflockService.estimateTime(dto),
      position: job.position,
    };
  }

  @Post('baseplates/sync')
  async createBaseplateSyc(@Body() dto: CreateBaseplateDto, @Res() res: Response) {
    // Only allow small models synchronously
    if (dto.gridX * dto.gridY > 16) {
      return res.status(HttpStatus.BAD_REQUEST).json({
        error: 'Model too large for synchronous generation. Use async endpoint.',
      });
    }

    const stlBuffer = await this.gridflockService.generateSync(dto);

    res.set({
      'Content-Type': 'model/stl',
      'Content-Disposition': `attachment; filename="baseplate_${dto.gridX}x${dto.gridY}.stl"`,
    });
    res.send(stlBuffer);
  }

  @Get('jobs/:jobId')
  async getJobStatus(@Param('jobId') jobId: string) {
    return this.gridflockService.getJobStatus(jobId);
  }

  @Get('jobs/:jobId/download')
  async downloadStl(@Param('jobId') jobId: string, @Res() res: Response) {
    const job = await this.gridflockService.getJob(jobId);

    if (job.status === 'processing' || job.status === 'queued') {
      return res.status(HttpStatus.ACCEPTED).json({
        status: job.status,
        message: 'Job still processing',
      });
    }

    if (job.status === 'failed') {
      return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
        error: job.error,
      });
    }

    const stlBuffer = await this.gridflockService.getStlFile(job);

    res.set({
      'Content-Type': 'model/stl',
      'Content-Disposition': `attachment; filename="${job.filename}"`,
    });
    res.send(stlBuffer);
  }

  @Get('presets')
  async getPresets() {
    return this.gridflockService.getPresets();
  }
}

// apps/gridflock-worker/src/worker.ts
import { Process, Processor } from '@nestjs/bull';
import { Job } from 'bull';
import { S3Service } from './s3.service';
import { generateGridFlockPlate, GridFlockParams } from '@forma/gridflock-core';
import { serialize } from '@jscad/stl-serializer';

interface GenerationJob {
  jobId: string;
  type: 'baseplate' | 'bin' | 'accessory';
  parameters: GridFlockParams;
}

@Processor('gridflock-generation')
export class GridflockWorker {
  constructor(private readonly s3Service: S3Service) {}

  @Process('generate-stl')
  async handleGeneration(job: Job<GenerationJob>) {
    const { jobId, type, parameters } = job.data;

    try {
      await job.progress(10);

      // Generate JSCAD geometry using GridFlock
      const geometry = generateGridFlockPlate({
        bedSize: parameters.bedSize,
        plateSize: parameters.plateSize,
        magnets: parameters.magnets ?? true,
        magnetDiameter: parameters.magnetDiameter ?? 6,
        magnetHeight: parameters.magnetHeight ?? 2,
        connectorIntersectionPuzzle: parameters.connectorIntersectionPuzzle ?? true,
        connectorEdgePuzzle: parameters.connectorEdgePuzzle ?? false,
        edgePuzzleGap: parameters.edgePuzzleGap ?? 0.15,
        numbering: parameters.numbering ?? true,
        numberIndex: parameters.plateIndex ?? 1,
        doHalfX: parameters.doHalfX ?? false,
        doHalfY: parameters.doHalfY ?? false,
      });

      await job.progress(60);

      // Serialize to binary STL (no file system needed!)
      const stlData = serialize({ binary: true }, geometry);
      const stlBuffer = Buffer.from(stlData[0]);

      await job.progress(80);

      // Upload directly to S3 from memory
      const s3Key = `stl/${jobId}.stl`;
      await this.s3Service.uploadBuffer(stlBuffer, s3Key, 'model/stl');

      await job.progress(100);

      return {
        success: true,
        s3Key,
        filename: this.generateFilename(parameters),
        fileSize: stlBuffer.length,
      };
    } catch (error) {
      throw new Error(`STL generation failed: ${error.message}`);
    }
  }

  private generateFilename(params: GridFlockParams): string {
    const { plateSize, connectorIntersectionPuzzle, connectorEdgePuzzle } = params;
    const connector = connectorIntersectionPuzzle
      ? 'puzzle'
      : connectorEdgePuzzle
        ? 'edge'
        : 'plain';
    return `gridflock_${plateSize[0]}x${plateSize[1]}_${connector}.stl`;
  }
}

// libs/gridflock-core/src/index.ts
import { primitives, booleans, transforms, geometries } from '@jscad/modeling';

export interface GridFlockParams {
  bedSize: [number, number];
  plateSize: [number, number];
  magnets: boolean;
  magnetDiameter: number;
  magnetHeight: number;
  magnetStyle: 'glue-from-top' | 'press-fit';
  connectorIntersectionPuzzle: boolean;
  connectorEdgePuzzle: boolean;
  edgePuzzleGap: number;
  edgePuzzleCount: number;
  numbering: boolean;
  numberIndex: number;
  doHalfX: boolean;
  doHalfY: boolean;
  solidBase: number;
}

const GRID_SIZE = 42; // Gridfinity standard: 42mm per unit

export function generateGridFlockPlate(params: Partial<GridFlockParams>): geometries.Geom3 {
  const config: GridFlockParams = {
    bedSize: [250, 220],
    plateSize: [5, 5],
    magnets: true,
    magnetDiameter: 6,
    magnetHeight: 2,
    magnetStyle: 'press-fit',
    connectorIntersectionPuzzle: true,
    connectorEdgePuzzle: false,
    edgePuzzleGap: 0.15,
    edgePuzzleCount: 2,
    numbering: true,
    numberIndex: 1,
    doHalfX: false,
    doHalfY: false,
    solidBase: 4,
    ...params,
  };

  // Calculate plate dimensions
  const width = config.plateSize[0] * GRID_SIZE;
  const depth = config.plateSize[1] * GRID_SIZE;

  // Create base plate
  let plate = createBasePlate(width, depth, config.solidBase);

  // Add grid cell pattern
  plate = addGridCells(plate, config);

  // Add magnet holes
  if (config.magnets) {
    plate = addMagnetHoles(plate, config);
  }

  // Add connectors
  if (config.connectorIntersectionPuzzle) {
    plate = addIntersectionPuzzle(plate, config);
  }
  if (config.connectorEdgePuzzle) {
    plate = addEdgePuzzle(plate, config);
  }

  // Add numbering
  if (config.numbering) {
    plate = addNumbering(plate, config);
  }

  return plate;
}

function createBasePlate(width: number, depth: number, height: number): geometries.Geom3 {
  return primitives.roundedCuboid({
    size: [width, depth, height],
    roundRadius: 4, // Gridfinity standard corner radius
    segments: 16,
  });
}

function addGridCells(plate: geometries.Geom3, config: GridFlockParams): geometries.Geom3 {
  // Create grid cell indents for Gridfinity bin compatibility
  const cellSize = GRID_SIZE - 0.5; // Slight clearance
  const cellDepth = 2.5; // Standard indent depth

  for (let x = 0; x < config.plateSize[0]; x++) {
    for (let y = 0; y < config.plateSize[1]; y++) {
      const centerX = (x + 0.5) * GRID_SIZE - (config.plateSize[0] * GRID_SIZE) / 2;
      const centerY = (y + 0.5) * GRID_SIZE - (config.plateSize[1] * GRID_SIZE) / 2;

      const cell = primitives.roundedCuboid({
        size: [cellSize, cellSize, cellDepth * 2],
        roundRadius: 1.5,
        segments: 8,
      });

      const positionedCell = transforms.translate([centerX, centerY, config.solidBase / 2], cell);

      plate = booleans.subtract(plate, positionedCell);
    }
  }

  return plate;
}

function addMagnetHoles(plate: geometries.Geom3, config: GridFlockParams): geometries.Geom3 {
  // Add magnet holes at each grid intersection
  for (let x = 0; x <= config.plateSize[0]; x++) {
    for (let y = 0; y <= config.plateSize[1]; y++) {
      const holeX = x * GRID_SIZE - (config.plateSize[0] * GRID_SIZE) / 2;
      const holeY = y * GRID_SIZE - (config.plateSize[1] * GRID_SIZE) / 2;

      const magnetHole = primitives.cylinder({
        radius: config.magnetDiameter / 2,
        height: config.magnetHeight + 0.5, // Slight extra depth
        segments: 32,
      });

      const positionedHole = transforms.translate(
        [holeX, holeY, -config.solidBase / 2 + config.magnetHeight / 2],
        magnetHole
      );

      plate = booleans.subtract(plate, positionedHole);
    }
  }

  return plate;
}

function addIntersectionPuzzle(plate: geometries.Geom3, config: GridFlockParams): geometries.Geom3 {
  // GRIPS-like puzzle connectors at cell intersections
  // Implementation based on GridFlock intersection puzzle system
  // ... (full implementation from GridFlock source)
  return plate;
}

function addEdgePuzzle(plate: geometries.Geom3, config: GridFlockParams): geometries.Geom3 {
  // Edge puzzle connectors along plate edges
  // ... (full implementation from GridFlock source)
  return plate;
}

function addNumbering(plate: geometries.Geom3, config: GridFlockParams): geometries.Geom3 {
  // Embossed plate number for assembly guidance
  // ... (full implementation from GridFlock source)
  return plate;
}

export { GridFlockParams };

version: '3.8'

services:
  api:
    build:
      context: .
      dockerfile: apps/api/Dockerfile
    ports:
      - '3000:3000'
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@db:5432/forma
      - REDIS_URL=redis://redis:6379
      - S3_ENDPOINT=http://minio:9000
      - S3_BUCKET=gridflock-stl
    depends_on:
      - db
      - redis
      - minio

  gridflock-worker:
    build:
      context: .
      dockerfile: apps/gridflock-worker/Dockerfile
    environment:
      - REDIS_URL=redis://redis:6379
      - S3_ENDPOINT=http://minio:9000
      - S3_BUCKET=gridflock-stl
    volumes:
      - ./models:/app/models:ro
    depends_on:
      - redis
      - minio
    deploy:
      replicas: 2 # Scale workers as needed

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=forma
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    volumes:
      - redisdata:/data

  minio:
    image: minio/minio
    command: server /data --console-address ":9001"
    environment:
      - MINIO_ROOT_USER=minioadmin
      - MINIO_ROOT_PASSWORD=minioadmin
    ports:
      - '9000:9000'
      - '9001:9001'
    volumes:
      - miniodata:/data

volumes:
  pgdata:
  redisdata:
  miniodata:

# apps/gridflock-worker/Dockerfile
FROM node:22-alpine

# Create app directory
WORKDIR /app

# Install pnpm
RUN corepack enable && corepack prepare pnpm@latest --activate

# Copy package files
COPY package.json pnpm-lock.yaml ./
COPY apps/gridflock-worker/package.json ./apps/gridflock-worker/

# Install dependencies (includes @jscad/* packages)
RUN pnpm install --frozen-lockfile --prod

# Copy worker code and GridFlock source
COPY apps/gridflock-worker/dist ./apps/gridflock-worker/dist
COPY libs/gridflock-core/dist ./libs/gridflock-core/dist

# No GUI, no virtual framebuffer needed - pure Node.js!
# Container size: ~150MB

ENV NODE_ENV=production

CMD ["node", "apps/gridflock-worker/dist/main.js"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gridflock-worker
  namespace: forma
spec:
  replicas: 3
  selector:
    matchLabels:
      app: gridflock-worker
  template:
    metadata:
      labels:
        app: gridflock-worker
    spec:
      containers:
        - name: worker
          image: forma/gridflock-worker:latest
          resources:
            requests:
              memory: '2Gi'
              cpu: '1000m'
            limits:
              memory: '4Gi'
              cpu: '2000m'
          env:
            - name: REDIS_URL
              valueFrom:
                secretKeyRef:
                  name: forma-secrets
                  key: redis-url
            - name: S3_ENDPOINT
              value: 'http://minio.forma.svc:9000'
          volumeMounts:
            - name: models
              mountPath: /app/models
              readOnly: true
            - name: tmp
              mountPath: /tmp
      volumes:
        - name: models
          configMap:
            name: gridfinity-models
        - name: tmp
          emptyDir:
            sizeLimit: 1Gi
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: gridflock-worker-hpa
  namespace: forma
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: gridflock-worker
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70

// prisma/schema.prisma additions

model GridflockJob {
  id          String   @id @default(uuid())
  type        GridflockType
  status      JobStatus
  parameters  Json

  // Result
  s3Key       String?
  filename    String?
  fileSize    Int?

  // Tracking
  progress    Int      @default(0)
  error       String?

  // Timing
  createdAt   DateTime @default(now())
  startedAt   DateTime?
  completedAt DateTime?
  expiresAt   DateTime?

  // Relations
  orderId     String?
  order       Order?   @relation(fields: [orderId], references: [id])

  userId      String?
  user        User?    @relation(fields: [userId], references: [id])

  @@index([status])
  @@index([userId])
  @@index([createdAt])
}

model GridflockPreset {
  id          String   @id @default(uuid())
  name        String
  description String?
  parameters  Json
  isPublic    Boolean  @default(false)

  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt

  createdById String?
  createdBy   User?    @relation(fields: [createdById], references: [id])

  @@unique([name, createdById])
}

enum GridflockType {
  BASEPLATE
  BIN
  ACCESSORY
}

enum JobStatus {
  QUEUED
  PROCESSING
  COMPLETED
  FAILED
  EXPIRED
}

// Integration with existing order system
export class OrderService {
  async createOrder(dto: CreateOrderDto) {
    const order = await this.prisma.order.create({
      data: {
        ...dto,
        items: {
          create: dto.items.map((item) => ({
            ...item,
            // If item is a GridFlock product, queue STL generation
            gridflockJobId: item.isGridflock ? await this.queueGridflockGeneration(item) : null,
          })),
        },
      },
    });

    return order;
  }

  private async queueGridflockGeneration(item: OrderItem): Promise<string> {
    const job = await this.gridflockService.queueGeneration({
      type: item.gridflockType,
      parameters: item.gridflockParameters,
      orderId: item.orderId,
      priority: 'normal',
    });

    return job.id;
  }
}

┌──────────────────────────────────────────────────────────────┐
│                    Customer Journey                           │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  1. Configure Grid        2. Preview 3D        3. Checkout  │
│  ┌──────────────┐        ┌──────────────┐     ┌───────────┐ │
│  │ Grid Size    │───────▶│  WebGL/Three │────▶│  Pay for: │ │
│  │ Magnets      │        │  Preview     │     │  • STL    │ │
│  │ Connectors   │        │              │     │  • Print  │ │
│  │ Options...   │        │              │     │  • Both   │ │
│  └──────────────┘        └──────────────┘     └───────────┘ │
│                                                              │
└──────────────────────────────────────────────────────────────┘

https://gridflock.yawk.at/#H4sIAAAAAAAAA6tWKkktLlGyUlAqS8wpTgUAAAD//w==

# Add JSCAD packages to the monorepo
pnpm add @jscad/modeling @jscad/stl-serializer

# Key packages:
# @jscad/modeling - CSG operations, primitives, transforms
# @jscad/stl-serializer - Export to STL format

# Verify installation
node -e "console.log(require('@jscad/modeling').primitives)"

interface GridFlockFullParams {
  // === Core Dimensions ===
  bedSize: [number, number]; // Printer bed [x, y] in mm
  plateSize: [number, number]; // Grid units [x, y]
  doHalfX: boolean; // Half cells in X
  doHalfY: boolean; // Half cells in Y
  solidBase: number; // Base thickness (mm)
  bottomChamfer: [number, number, number, number]; // [N, E, S, W]

  // === Magnets ===
  magnets: boolean;
  magnetStyle: 'glue-from-top' | 'press-fit';
  magnetFrameStyle: 'solid' | 'round-corners';
  magnetDiameter: number; // Default: 6mm
  magnetHeight: number; // Default: 2mm
  magnetTop: number; // Wall above magnet
  magnetBottom: number; // Floor below magnet

  // === Intersection Puzzle (GRIPS-like) ===
  connectorIntersectionPuzzle: boolean;

  // === Edge Puzzle ===
  connectorEdgePuzzle: boolean;
  edgePuzzleCount: number; // Connectors per edge
  edgePuzzleDim: [number, number, number]; // Male size [x, y, z]
  edgePuzzleDimC: [number, number, number]; // Bridge size
  edgePuzzleGap: number; // Tolerance (tune for printer!)
  edgePuzzleMagnetBorder: boolean;
  edgePuzzleMagnetBorderWidth: number;
  edgePuzzleHeightFemale: number;
  edgePuzzleHeightMaleDelta: number;

  // === Numbering ===
  numbering: boolean;
  numberDepth: number; // Emboss depth
  numberSize: number; // Font size
  numberFont: string;

  // === Plate Wall ===
  plateWallThickness: [number, number, number, number]; // [N, E, S, W]
  plateWallHeight: [number, number]; // [above, below]

  // === Screws ===
  verticalScrewDiameter: number;
  verticalScrewCountersinkTop: [number, number];
  verticalScrewPlateCorners: boolean;
  verticalScrewPlateEdges: boolean;

  // === Thumbscrews ===
  thumbscrews: boolean;
  thumbscrewDiameter: number;

  // === Advanced ===
  plateCornerRadius: number; // Default: 4mm
  edgeAdjust: [number, number, number, number]; // Fine-tune edges
}

import * as THREE from 'three';
import { STLLoader } from 'three/examples/jsm/loaders/STLLoader';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';

export function createGridPreview(container: HTMLElement, stlUrl: string) {
  const scene = new THREE.Scene();
  scene.background = new THREE.Color(0xf0f0f0);

  const camera = new THREE.PerspectiveCamera(
    75,
    container.clientWidth / container.clientHeight,
    0.1,
    1000
  );
  camera.position.set(100, 100, 100);

  const renderer = new THREE.WebGLRenderer({ antialias: true });
  renderer.setSize(container.clientWidth, container.clientHeight);
  container.appendChild(renderer.domElement);

  const controls = new OrbitControls(camera, renderer.domElement);
  controls.enableDamping = true;

  // Lighting
  const ambientLight = new THREE.AmbientLight(0x404040);
  scene.add(ambientLight);

  const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
  directionalLight.position.set(1, 1, 1);
  scene.add(directionalLight);

  // Load STL
  const loader = new STLLoader();
  loader.load(stlUrl, (geometry) => {
    const material = new THREE.MeshPhongMaterial({
      color: 0x00ff00,
      specular: 0x111111,
      shininess: 200,
    });
    const mesh = new THREE.Mesh(geometry, material);

    // Center the model
    geometry.computeBoundingBox();
    const center = new THREE.Vector3();
    geometry.boundingBox!.getCenter(center);
    mesh.position.sub(center);

    scene.add(mesh);
  });

  function animate() {
    requestAnimationFrame(animate);
    controls.update();
    renderer.render(scene, camera);
  }

  animate();
}