jspsych-tangram 0.0.1

package/src/core/engine/collision/grid-snapping.ts

@@ -0,0 +1,283 @@
+/**
+ * Grid Snapping Engine - PHASE 2 MILESTONE
+ * 
+ * Consolidates duplicate anchor functions from anchors.ts and anchors-mode.ts
+ * into a single, parameterized grid snapping system.
+ */
+
+import type { Blueprint, Poly, Vec, PrimitiveBlueprint } from "../../domain/types";
+import type { CircleLayout, SectorGeom } from "../../domain/layout";
+import { 
+  boundsOfBlueprint, 
+  pointInPolygon, 
+  gridNodesInAABB, 
+  filterNodesToBandAndSector, 
+  filterNodesInPolys
+} from "../geometry";
+import { CONFIG } from "../../config/config";
+
+export interface GridConfig {
+  stepPx: number;
+  snapRadiusPx: number;
+  densitySampleStepPx?: number; // For polyFullyInside sampling
+}
+
+export interface SnapResult {
+  tl: Vec;
+  node: Vec | null;
+  dist: number;
+  accepted: boolean;
+}
+
+/**
+ * GridSnapper handles all anchor-based snapping and node generation
+ */
+export class GridSnapper {
+  private config: GridConfig;
+
+  constructor(config: GridConfig) {
+    this.config = config;
+  }
+
+  // ===== Reference Vertex Management =====
+  
+  /**
+   * Choose a reference vertex (v0 of first poly) for snapping.
+   * Consolidated from both anchors.ts and anchors-mode.ts
+   */
+  referenceVertex(bp: Blueprint): Vec {
+    const poly = ("shape" in bp && bp.shape?.[0]) ? bp.shape[0] : [{x:0,y:0}];
+    return poly[0] ?? { x: 0, y: 0 };
+  }
+
+  // ===== Snapping Operations =====
+
+  /**
+   * Perform nearest-node snapping with configurable snap radius
+   * Consolidated from both files with enhanced configuration
+   */
+  nearestNodeSnap(
+    tl: Vec,
+    bp: Blueprint,
+    primitiveLookup: (k: string) => PrimitiveBlueprint | undefined,
+    nodes: Vec[]
+  ): SnapResult {
+    if (!nodes.length) {
+      return { tl, node: null, dist: Infinity, accepted: false };
+    }
+
+    const bb = boundsOfBlueprint(bp, primitiveLookup);
+    const v0 = this.referenceVertex(bp);
+    const v0World = { x: tl.x + (v0.x - bb.min.x), y: tl.y + (v0.y - bb.min.y) };
+
+    let best: Vec | null = null;
+    let bestD2 = Infinity;
+    
+    for (const n of nodes) {
+      const dx = n.x - v0World.x;
+      const dy = n.y - v0World.y;
+      const d2 = dx * dx + dy * dy;
+      if (d2 < bestD2) { 
+        bestD2 = d2; 
+        best = n; 
+      }
+    }
+
+    const distance = Math.sqrt(bestD2);
+    const accepted = distance <= this.config.snapRadiusPx;
+    
+    const snapped = (best && accepted)
+      ? { x: tl.x + (best.x - v0World.x), y: tl.y + (best.y - v0World.y) }
+      : tl;
+
+    return { 
+      tl: snapped, 
+      node: best, 
+      dist: distance, 
+      accepted 
+    };
+  }
+
+  /**
+   * Back-compatibility shim for existing Board.tsx usage
+   */
+  snapTopLeftToNodes(
+    tl: Vec,
+    bp: Blueprint,
+    primitiveLookup: (k: string) => PrimitiveBlueprint | undefined,
+    nodes: Vec[]
+  ): { x: number; y: number } {
+    const { tl: snapped } = this.nearestNodeSnap(tl, bp, primitiveLookup, nodes);
+    return snapped;
+  }
+
+  // ===== Node Generation =====
+
+  /**
+   * Generate workspace-band grid nodes for a sector
+   * Extracted from anchors-mode.ts
+   */
+  generateWorkspaceNodes(layout: CircleLayout, sector: SectorGeom): Vec[] {
+    const pad = 6;
+    const min = { x: layout.cx - layout.outerR, y: layout.cy - layout.outerR - pad };
+    const max = { x: layout.cx + layout.outerR, y: layout.cy + layout.outerR + pad };
+    const nodes = gridNodesInAABB(min, max);
+    return filterNodesToBandAndSector(nodes, layout, "workspace", sector);
+  }
+
+  /**
+   * Generate silhouette-mask nodes for a sector
+   * Extracted from anchors-mode.ts
+   */
+  generateSilhouetteNodes(layout: CircleLayout, sector: SectorGeom, fittedMask: Poly[]): Vec[] {
+    const pad = 6;
+    const min = { x: layout.cx - layout.outerR, y: layout.cy - layout.outerR - pad };
+    const max = { x: layout.cx + layout.outerR, y: layout.cy + layout.outerR + pad };
+    const nodes = gridNodesInAABB(min, max);
+    const banded = filterNodesToBandAndSector(nodes, layout, "silhouette", sector);
+    return filterNodesInPolys(banded, fittedMask, pointInPolygon);
+  }
+
+  /**
+   * Generate silhouette-band nodes for a sector (no mask filter)
+   * Extracted from anchors-mode.ts
+   */
+  generateSilhouetteBandNodes(layout: CircleLayout, sector: SectorGeom): Vec[] {
+    const pad = 6;
+    const min = { x: layout.cx - layout.outerR, y: layout.cy - layout.outerR - pad };
+    const max = { x: layout.cx + layout.outerR, y: layout.cy + layout.outerR + pad };
+    const nodes = gridNodesInAABB(min, max);
+    return filterNodesToBandAndSector(nodes, layout, "silhouette", sector);
+  }
+
+  // ===== Validation Helpers =====
+
+  /**
+   * Check if point lies inside any silhouette polygon (union semantics)
+   * Private helper used by polyFullyInside
+   */
+  private insideAnySilhouette(pt: Vec, silPolys: Poly[]): boolean {
+    for (const sp of silPolys) {
+      if (pointInPolygon(pt, sp)) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Robust "fully inside" check with configurable sampling density
+   * Consolidated from both files with enhanced configuration
+   */
+  polyFullyInside(
+    piecePolys: Poly[],
+    silhouettePolys: Poly[],
+    customStep?: number
+  ): boolean {
+    // Quick exits
+    if (!piecePolys.length) return true;
+    if (!silhouettePolys.length) return false;
+
+    const step = customStep ?? 
+      this.config.densitySampleStepPx ?? 
+      Math.max(1, Math.round(CONFIG.layout.grid.stepPx / 3));
+
+    for (const poly of piecePolys) {
+      if (poly.length < 2) continue;
+
+      for (let i = 0; i < poly.length; i++) {
+        const a = poly[i];
+        const b = poly[(i + 1) % poly.length];
+        
+        if (!a || !b) continue;
+        
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const len = Math.hypot(dx, dy);
+        const n = Math.max(1, Math.ceil(len / step));
+
+        // Sample all points along the edge, including endpoints
+        for (let k = 0; k <= n; k++) {
+          const t = k / n;
+          const p = { x: a.x + t * dx, y: a.y + t * dy };
+          if (!this.insideAnySilhouette(p, silhouettePolys)) {
+            return false; // One point outside → reject
+          }
+        }
+      }
+    }
+    return true;
+  }
+}
+
+// ===== Factory Functions =====
+
+/**
+ * Create a GridSnapper with default configuration
+ */
+export function createDefaultGridSnapper(): GridSnapper {
+  return new GridSnapper({
+    stepPx: CONFIG.layout.grid.stepPx,
+    snapRadiusPx: CONFIG.game.snapRadiusPx,
+    densitySampleStepPx: Math.max(1, Math.round(CONFIG.layout.grid.stepPx / 3))
+  });
+}
+
+/**
+ * Create a GridSnapper with custom snap radius
+ */
+export function createGridSnapper(snapRadiusPx: number): GridSnapper {
+  return new GridSnapper({
+    stepPx: CONFIG.layout.grid.stepPx,
+    snapRadiusPx,
+    densitySampleStepPx: Math.max(1, Math.round(CONFIG.layout.grid.stepPx / 3))
+  });
+}
+
+// ===== Legacy Compatibility Exports =====
+// These maintain compatibility with existing code while using the new system
+
+export const defaultGridSnapper = createDefaultGridSnapper();
+
+export function referenceVertex(bp: Blueprint): Vec {
+  return defaultGridSnapper.referenceVertex(bp);
+}
+
+export function nearestNodeSnap(
+  tl: Vec,
+  bp: Blueprint,
+  primitiveLookup: (k: string) => PrimitiveBlueprint | undefined,
+  nodes: Vec[]
+): { tl: Vec; node: Vec | null; dist: number } {
+  const result = defaultGridSnapper.nearestNodeSnap(tl, bp, primitiveLookup, nodes);
+  return { tl: result.tl, node: result.node, dist: result.dist };
+}
+
+export function snapTopLeftToNodes(
+  tl: Vec,
+  bp: Blueprint,
+  primitiveLookup: (k: string) => PrimitiveBlueprint | undefined,
+  nodes: Vec[]
+): { x: number; y: number } {
+  return defaultGridSnapper.snapTopLeftToNodes(tl, bp, primitiveLookup, nodes);
+}
+
+export function polyFullyInside(
+  piecePolys: Poly[],
+  silhouettePolys: Poly[],
+  step?: number
+): boolean {
+  return defaultGridSnapper.polyFullyInside(piecePolys, silhouettePolys, step);
+}
+
+export function workspaceNodes(layout: CircleLayout, sector: SectorGeom): Vec[] {
+  return defaultGridSnapper.generateWorkspaceNodes(layout, sector);
+}
+
+export function silhouetteNodes(layout: CircleLayout, sector: SectorGeom, fittedMask: Poly[]): Vec[] {
+  return defaultGridSnapper.generateSilhouetteNodes(layout, sector, fittedMask);
+}
+
+export function silhouetteBandNodes(layout: CircleLayout, sector: SectorGeom): Vec[] {
+  return defaultGridSnapper.generateSilhouetteBandNodes(layout, sector);
+}
+
+export { innerRingNodes } from "../geometry";

package/src/core/engine/collision/index.ts

@@ -0,0 +1,4 @@
+// Central exports for collision detection engine
+export { convexIntersects } from './sat-collision';
+export { GridSnapper, createGridSnapper } from './grid-snapping';
+export { ValidationEngine } from './validation';

package/src/core/engine/collision/sat-collision.ts

@@ -0,0 +1,46 @@
+// Separating Axis Theorem (SAT) collision detection
+import type { Poly } from '@/core/domain/types';
+import { project, polygonAABB } from '../geometry/math';
+
+const SEP_EPS = 1e-6; // allow touching within this tolerance
+
+/** SAT for convex polygons. Edges/vertices touching are allowed (non-overlap). */
+export function convexIntersects(a: Poly, b: Poly): boolean {
+  const polys = [a, b];
+  for (const poly of polys) {
+    for (let i = 0; i < poly.length; i++) {
+      const p0 = poly[i];
+      const p1 = poly[(i + 1) % poly.length];
+      if (!p0 || !p1) continue;
+      const ex = p1.x - p0.x, ey = p1.y - p0.y;
+      const nx = -ey, ny = ex;               // outward normal
+      const pa = project(a, nx, ny);
+      const pb = project(b, nx, ny);
+      // Treat touching (zero overlap) as separated: allow edges/vertices to touch.
+      if (pa.max <= pb.min + SEP_EPS || pb.max <= pa.min + SEP_EPS) return false;
+    }
+  }
+  return true;
+}
+
+/** True if any poly from A overlaps any poly from B (fast AABB short-circuit). */
+export function polysOverlap(aPolys: Poly[], bPolys: Poly[]): boolean {
+  // quick AABB test to skip obvious separations
+  const aabbsA = aPolys.map(polygonAABB);
+  const aabbsB = bPolys.map(polygonAABB);
+
+  for (let i = 0; i < aPolys.length; i++) {
+    for (let j = 0; j < bPolys.length; j++) {
+      const A = aPolys[i], B = bPolys[j];
+      const aa = aabbsA[i], bb = aabbsB[j];
+      if (!aa || !bb) continue;
+      if (aa.maxX <= bb.minX + SEP_EPS || bb.maxX <= aa.minX + SEP_EPS ||
+          aa.maxY <= bb.minY + SEP_EPS || bb.maxY <= aa.minY + SEP_EPS) continue;
+      if (!A || !B) continue;
+      if (convexIntersects(A, B)) return true;
+    }
+  }
+  return false;
+}
+
+export { SEP_EPS };

package/src/core/engine/collision/validation.ts

@@ -0,0 +1,166 @@
+/**
+ * ValidationEngine - Anchor-based validation system
+ *
+ * Provides grid cell-based validation for tangram completion checking.
+ * Uses anchor grid alignment to determine if pieces correctly fill target shapes.
+ */
+
+import type { Poly } from "../../domain/types";
+import { GridSnapper, createGridSnapper } from "./grid-snapping";
+import { anchorsSilhouetteComplete, anchorsWorkspaceComplete } from "../validation/complete";
+
+export interface ValidationConfig {
+  snapRadiusPx: number;
+  densitySampleStepPx?: number;
+}
+
+export interface ValidationResult {
+  completed: boolean;
+  confidence: number; // 0-1 scale
+  details?: {
+    piecesInside: number;
+    totalPieces: number;
+    anchorMatches?: number;
+  };
+}
+
+/**
+ * ValidationEngine handles all collision detection and completion checking
+ * using grid cell-based anchor validation.
+ */
+export class ValidationEngine {
+  private gridSnapper: GridSnapper;
+  private config: ValidationConfig;
+
+  constructor(config: ValidationConfig) {
+    this.config = config;
+    this.gridSnapper = createGridSnapper(config.snapRadiusPx);
+  }
+
+  // ===== Primary Validation Methods =====
+
+  /**
+   * Check if silhouette is complete using anchor-based cell validation.
+   * Uses subset check: silhouette cells ⊆ piece cells
+   */
+  checkSilhouetteComplete(silPolys: Poly[], piecePolys: Poly[]): ValidationResult {
+    const completed = anchorsSilhouetteComplete(silPolys, piecePolys);
+
+    return {
+      completed,
+      confidence: completed ? 1.0 : this.calculatePartialCompletionScore(silPolys, piecePolys),
+      details: {
+        piecesInside: this.countPiecesInside(piecePolys, silPolys),
+        totalPieces: piecePolys.length
+      }
+    };
+  }
+
+  /**
+   * Check if workspace is complete using anchor-based cell validation.
+   * Uses exact match: silhouette cells === piece cells (translation-invariant)
+   */
+  checkWorkspaceComplete(silPolys: Poly[], piecePolys: Poly[]): ValidationResult {
+    const completed = anchorsWorkspaceComplete(silPolys, piecePolys);
+
+    return {
+      completed,
+      confidence: completed ? 1.0 : this.calculatePartialCompletionScore(silPolys, piecePolys),
+      details: {
+        piecesInside: this.countPiecesInside(piecePolys, silPolys),
+        totalPieces: piecePolys.length
+      }
+    };
+  }
+
+  // ===== Geometric Validation =====
+
+  /**
+   * Check if piece polygons are fully inside silhouette polygons
+   * Uses the consolidated GridSnapper polyFullyInside method
+   */
+  checkPiecesFullyInside(piecePolys: Poly[], silhouettePolys: Poly[]): boolean {
+    return this.gridSnapper.polyFullyInside(piecePolys, silhouettePolys);
+  }
+
+  /**
+   * Check if pieces overlap with each other (collision detection)
+   * TODO: Implement SAT collision detection when needed
+   */
+  checkPieceOverlap(_pieces1: Poly[], _pieces2: Poly[]): boolean {
+    // Placeholder - will use SAT collision detection from sat-collision.ts
+    return false;
+  }
+
+  // ===== Helper Methods =====
+
+  /**
+   * Calculate partial completion score for progress tracking
+   * Returns value between 0-1 based on how much is correctly placed
+   */
+  private calculatePartialCompletionScore(silPolys: Poly[], piecePolys: Poly[]): number {
+    if (!piecePolys.length) return 0;
+    
+    const piecesInside = this.countPiecesInside(piecePolys, silPolys);
+    return piecesInside / piecePolys.length;
+  }
+
+  /**
+   * Count how many piece polygons are fully inside silhouette
+   */
+  private countPiecesInside(piecePolys: Poly[], silPolys: Poly[]): number {
+    let count = 0;
+    for (const piece of piecePolys) {
+      if (this.gridSnapper.polyFullyInside([piece], silPolys)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  // ===== Configuration Access =====
+
+  getSnapRadius(): number {
+    return this.config.snapRadiusPx;
+  }
+
+  getGridSnapper(): GridSnapper {
+    return this.gridSnapper;
+  }
+
+  // ===== Static Factory Methods =====
+
+  static create(snapRadiusPx: number): ValidationEngine {
+    return new ValidationEngine({
+      snapRadiusPx,
+    });
+  }
+}
+
+// ===== Default Instance =====
+
+/**
+ * Default validation engine instance for backward compatibility
+ */
+export const defaultValidationEngine = ValidationEngine.create(18); // Default snap radius
+
+// ===== Legacy Compatibility Exports =====
+// These maintain compatibility with existing Board.tsx usage
+
+export function createValidationEngine(snapRadiusPx: number = 18): ValidationEngine {
+  return ValidationEngine.create(snapRadiusPx);
+}
+
+/**
+ * Legacy function that Board.tsx expects - delegates to ValidationEngine
+ */
+export function checkSilhouetteComplete(silPolys: Poly[], piecePolys: Poly[]): boolean {
+  return defaultValidationEngine.checkSilhouetteComplete(silPolys, piecePolys).completed;
+}
+
+/**
+ * Legacy function that Board.tsx expects - delegates to ValidationEngine  
+ */
+export function checkWorkspaceComplete(silPolys: Poly[], piecePolys: Poly[]): boolean {
+  return defaultValidationEngine.checkWorkspaceComplete(silPolys, piecePolys).completed;
+}

package/src/core/engine/geometry/bounds.ts

@@ -0,0 +1,91 @@
+import type { Poly, Vec, PrimitiveBlueprint, CompositeBlueprint, Blueprint } from "@/core/domain/types";
+
+export type AABB = { min: Vec; max: Vec; width: number; height: number };
+
+/** AABB of a single polygon (numeric). */
+export function aabbOf(poly: Poly): { minX: number; minY: number; maxX: number; maxY: number } {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of poly) {
+    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;
+  }
+  return { minX, minY, maxX, maxY };
+}
+
+/** AABB of one or more polygons with width/height and center. */
+export function polysAABB(polys: Poly[]) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const poly of polys) {
+    for (const p of poly) {
+      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 width  = Math.max(1, maxX - minX);
+  const height = Math.max(1, maxY - minY);
+  return { min: { x: minX, y: minY }, max: { x: maxX, y: maxY }, width, height, cx:(minX+maxX)/2, cy:(minY+maxY)/2 };
+}
+
+/** Bounds of multiple polygons at the origin. */
+export function boundsOfShapes(shapes: Poly[]): AABB {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const poly of shapes) {
+    for (const p of poly) {
+      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 width  = Math.max(0, maxX - minX);
+  const height = Math.max(0, maxY - minY);
+  return { min: { x: minX, y: minY }, max: { x: maxX, y: maxY }, width, height };
+}
+
+/** Bounds of a primitive blueprint (uses its canonical shape). */
+export function boundsOfPrimitive(bp: PrimitiveBlueprint): AABB {
+  return boundsOfShapes(bp.shape);
+}
+
+/**
+ * Bounds of a composite blueprint.
+ * If `shape` is provided as precomputed union polygons, we use that.
+ * Otherwise we bound the parts’ primitives at their offsets (loose but safe).
+ */
+export function boundsOfComposite(
+  bp: CompositeBlueprint,
+  primitiveLookup: (kind: string) => PrimitiveBlueprint | undefined
+): AABB {
+  if (bp.shape && bp.shape.length) return boundsOfShapes(bp.shape);
+
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const part of bp.parts) {
+    const prim = primitiveLookup(part.kind);
+    if (!prim) continue;
+    const b = boundsOfPrimitive(prim);
+    const pMinX = part.offset.x + b.min.x;
+    const pMinY = part.offset.y + b.min.y;
+    const pMaxX = part.offset.x + b.max.x;
+    const pMaxY = part.offset.y + b.max.y;
+    if (pMinX < minX) minX = pMinX;
+    if (pMinY < minY) minY = pMinY;
+    if (pMaxX > maxX) maxX = pMaxX;
+    if (pMaxY > maxY) maxY = pMaxY;
+  }
+  const width  = Math.max(0, maxX - minX);
+  const height = Math.max(0, maxY - minY);
+  return { min: { x: minX, y: minY }, max: { x: maxX, y: maxY }, width, height };
+}
+
+/** Unified bounds helper. */
+export function boundsOfBlueprint(
+  bp: Blueprint,
+  primitiveLookup: (kind: string) => PrimitiveBlueprint | undefined
+): AABB {
+  if ("parts" in bp) return boundsOfComposite(bp, primitiveLookup);
+  return boundsOfPrimitive(bp);
+}

package/src/core/engine/geometry/collision.ts

@@ -0,0 +1,64 @@
+/**
+ * SAT (Separating Axis Theorem) collision detection for convex polygons
+ * Extracted from polygon.ts for better organization
+ */
+
+import type { Poly } from '@/core/domain/types';
+import { project } from './math';
+
+const SEP_EPS = 1e-6; // allow touching within this tolerance
+
+/** SAT for convex polygons. Edges/vertices touching are allowed (non-overlap). */
+export function convexIntersects(a: Poly, b: Poly): boolean {
+  const polys = [a, b];
+  for (const poly of polys) {
+    for (let i = 0; i < poly.length; i++) {
+      const p0 = poly[i], p1 = poly[(i + 1) % poly.length];
+      if (!p0 || !p1) continue;
+      const ex = p1.x - p0.x, ey = p1.y - p0.y;
+      const nx = -ey, ny = ex;               // outward normal
+      const pa = project(a, nx, ny);
+      const pb = project(b, nx, ny);
+      // Treat touching (zero overlap) as separated: allow edges/vertices to touch.
+      if (pa.max <= pb.min + SEP_EPS || pb.max <= pa.min + SEP_EPS) return false;
+    }
+  }
+  return true;
+}
+
+/** True if any poly from A overlaps any poly from B (fast AABB short-circuit). */
+export function polysOverlap(aPolys: Poly[], bPolys: Poly[]): boolean {
+  // quick AABB test to skip obvious separations
+  const aabbsA = aPolys.map(p => {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const pt of p) {
+      if (pt.x < minX) minX = pt.x;
+      if (pt.y < minY) minY = pt.y;
+      if (pt.x > maxX) maxX = pt.x;
+      if (pt.y > maxY) maxY = pt.y;
+    }
+    return { minX, minY, maxX, maxY };
+  });
+  const aabbsB = bPolys.map(p => {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const pt of p) {
+      if (pt.x < minX) minX = pt.x;
+      if (pt.y < minY) minY = pt.y;
+      if (pt.x > maxX) maxX = pt.x;
+      if (pt.y > maxY) maxY = pt.y;
+    }
+    return { minX, minY, maxX, maxY };
+  });
+
+  for (let i = 0; i < aPolys.length; i++) {
+    for (let j = 0; j < bPolys.length; j++) {
+      const A = aPolys[i], B = bPolys[j];
+      const aa = aabbsA[i], bb = aabbsB[j];
+      if (!A || !B || !aa || !bb) continue;
+      if (aa.maxX <= bb.minX + SEP_EPS || bb.maxX <= aa.minX + SEP_EPS ||
+          aa.maxY <= bb.minY + SEP_EPS || bb.maxY <= aa.minY + SEP_EPS) continue;
+      if (convexIntersects(A, B)) return true;
+    }
+  }
+  return false;
+}

package/src/core/engine/geometry/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Geometry module barrel exports
+ * Consolidated from 10 files down to 5 for better organization
+ */
+
+// Pure mathematical operations (vectors, polygons)
+export * from "./math";
+
+// SAT collision detection
+export * from "./collision";
+
+// Polygon operations (subdivision, etc.)
+export * from "./polygons";
+
+// Bounding box calculations
+export * from "./bounds";
+
+// Game-specific piece geometry (positioning, placement, grid, anchors)
+export * from "./pieces";