Initial crossword addition and arcade redesign

src/app/api/arcade/import/preview/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import { ArcadeImportError } from "@/lib/arcade/connectionsImport";
+import { ArcadeImportError } from "@/lib/arcade/arcadeImport";
 import { arcadePreviewRequestSchema } from "@/lib/validation/arcadeSchemas";
 import * as arcadeService from "@/services/arcadeService";
 
@@ -9,7 +9,7 @@ export async function POST(request: NextRequest) {
     return NextResponse.json({ error: "A game type and raw JSON are required." }, { status: 400 });
   }
   try {
-    return NextResponse.json(arcadeService.previewArcadeImport(parsed.data.rawJson));
+    return NextResponse.json(arcadeService.previewArcadeImport(parsed.data.gameType, parsed.data.rawJson));
   } catch (error) {
     if (error instanceof ArcadeImportError) {
       return NextResponse.json({ error: error.message, details: error.details }, { status: 400 });

src/app/api/arcade/packs/[id]/attempts/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import { arcadeAttemptCreateSchema } from "@/lib/validation/arcadeSchemas";
+import { arcadeAttemptCreateSchema, crosswordAttemptCreateSchema } from "@/lib/validation/arcadeSchemas";
 import * as arcadeService from "@/services/arcadeService";
 
 export async function GET(
@@ -17,12 +17,19 @@ export async function POST(
   context: RouteContext<"/api/arcade/packs/[id]/attempts">
 ) {
   const { id } = await context.params;
-  const parsed = arcadeAttemptCreateSchema.safeParse(await request.json().catch(() => null));
+  const pack = await arcadeService.getArcadePack(id);
+  if (!pack) return NextResponse.json({ error: "Arcade pack not found" }, { status: 404 });
+  const body = await request.json().catch(() => null);
+  const parsed = pack.gameType === "crossword"
+    ? crosswordAttemptCreateSchema.safeParse(body)
+    : arcadeAttemptCreateSchema.safeParse(body);
   if (!parsed.success) {
     return NextResponse.json({ error: "Invalid completed attempt", details: parsed.error.issues }, { status: 400 });
   }
   try {
-    const attempt = await arcadeService.createArcadeAttempt(id, parsed.data);
+    const attempt = pack.gameType === "crossword"
+      ? await arcadeService.createCrosswordAttempt(id, parsed.data as Parameters<typeof arcadeService.createCrosswordAttempt>[1])
+      : await arcadeService.createArcadeAttempt(id, parsed.data as Parameters<typeof arcadeService.createArcadeAttempt>[1]);
     return attempt
       ? NextResponse.json(attempt, { status: 201 })
       : NextResponse.json({ error: "Arcade pack not found" }, { status: 404 });

src/app/api/arcade/packs/[id]/layout/route.ts

@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from "next/server";
+import { generateCrosswordLayout } from "@/lib/arcade/crosswordEngine";
+import type { CrosswordSize } from "@/types/arcade";
+import { getArcadePack } from "@/services/arcadeService";
+
+const CROSSWORD_SIZES = new Set<CrosswordSize>(["mini", "standard", "large", "extra-large"]);
+
+export async function GET(
+  request: NextRequest,
+  context: { params: Promise<{ id: string }> }
+) {
+  const { id } = await context.params;
+  const sizeValue = request.nextUrl.searchParams.get("size") ?? "standard";
+  if (!CROSSWORD_SIZES.has(sizeValue as CrosswordSize)) {
+    return NextResponse.json({ error: "A valid Crossword size is required." }, { status: 400 });
+  }
+  const pack = await getArcadePack(id);
+  if (!pack || pack.gameType !== "crossword" || pack.normalized.type !== "crossword") {
+    return NextResponse.json({ error: "Crossword pack not found" }, { status: 404 });
+  }
+  const size = sizeValue as CrosswordSize;
+  return NextResponse.json(generateCrosswordLayout(pack.normalized, size, `crossword-hub-preview-v1:${id}:${size}`));
+}

src/app/api/arcade/packs/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import { ArcadeImportError } from "@/lib/arcade/connectionsImport";
+import { ArcadeImportError } from "@/lib/arcade/arcadeImport";
 import { arcadePackCreateSchema } from "@/lib/validation/arcadeSchemas";
 import * as arcadeService from "@/services/arcadeService";
 
@@ -7,7 +7,7 @@ export async function GET(request: NextRequest) {
   const params = new URL(request.url).searchParams;
   const classId = params.get("classId");
   const gameType = params.get("gameType");
-  if (!classId || gameType !== "connections") {
+  if (!classId || (gameType !== "connections" && gameType !== "crossword")) {
     return NextResponse.json({ error: "Valid classId and gameType values are required." }, { status: 400 });
   }
   return NextResponse.json(await arcadeService.listArcadePacks(classId, gameType));

src/app/api/settings/llm-instructions/route.ts

@@ -3,7 +3,7 @@ import * as settingsService from "@/services/settingsService";
 
 function getInstructionType(request: NextRequest): settingsService.LlmInstructionType | null {
   const type = new URL(request.url).searchParams.get("type") ?? "flashcards";
-  return type === "flashcards" || type === "quizzes" || type === "connections" ? type : null;
+  return type === "flashcards" || type === "quizzes" || type === "connections" || type === "crossword" ? type : null;
 }
 
 export async function GET(request: NextRequest) {