chore: preserve app workspace t_61fb4c27_clone

Dockerfile

@@ -7,37 +7,13 @@ RUN if [ ! -f package-lock.json ]; then npm install --package-lock-only; fi && n
 
 COPY . .
 
-# Vite bakes VITE_* values at build time. Pass the public VITE_* values as
+# Vite bakes VITE_* values at build time, so compose must choose the env file
-# build args (docker compose --env-file .env.dev) instead of COPYing an env file;
+# during image build, not only at container runtime.
-# service-host worktrees keep .env.dev as a symlink outside the Docker context.
+ARG ENV_FILE=.env
-ARG VITE_API_BASE
+COPY ${ENV_FILE} .env
-ARG VITE_API_URL
+
-ARG VITE_APP_NAME
+# Run build with production mode
-ARG VITE_APP_HMR_URL
+RUN npm run build -- --mode production
-ARG VITE_DEV
-ARG VITE_FRONTEND_SITE_URL
-ARG VITE_SEARCH_URL
-ARG VITE_SUPABASE_ANON_KEY
-ARG VITE_SUPABASE_URL
-ARG VITE_SUPER_ADMIN_EMAIL
-ARG VITE_TLSYNC_URL
-ARG VITE_WHISPERLIVE_URL
-# Run build with production mode. Keep these as build-step environment values
-# rather than final-image ENV entries; Vite still embeds the public client config
-# into the static bundle, but nginx image metadata does not need them.
-RUN VITE_API_BASE="${VITE_API_BASE}" \
-    VITE_API_URL="${VITE_API_URL}" \
-    VITE_APP_NAME="${VITE_APP_NAME}" \
-    VITE_APP_HMR_URL="${VITE_APP_HMR_URL}" \
-    VITE_DEV="${VITE_DEV}" \
-    VITE_FRONTEND_SITE_URL="${VITE_FRONTEND_SITE_URL}" \
-    VITE_SEARCH_URL="${VITE_SEARCH_URL}" \
-    VITE_SUPABASE_ANON_KEY="${VITE_SUPABASE_ANON_KEY}" \
-    VITE_SUPABASE_URL="${VITE_SUPABASE_URL}" \
-    VITE_SUPER_ADMIN_EMAIL="${VITE_SUPER_ADMIN_EMAIL}" \
-    VITE_TLSYNC_URL="${VITE_TLSYNC_URL}" \
-    VITE_WHISPERLIVE_URL="${VITE_WHISPERLIVE_URL}" \
-    npm run build -- --mode production
 
 FROM nginx:alpine
 # Copy built files
@@ -55,33 +31,6 @@ RUN echo 'server { \
     expires -1; \
     add_header Cache-Control "no-store, no-cache, must-revalidate"; \
     } \
-    location = /health { \
-    proxy_pass http://192.168.0.64:18000/health; \
-    proxy_set_header Host $host; \
-    proxy_set_header X-Real-IP $remote_addr; \
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; \
-    } \
-    location /__ccapi/ { \
-    proxy_pass http://192.168.0.64:18000/; \
-    proxy_set_header Host $host; \
-    proxy_set_header X-Real-IP $remote_addr; \
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; \
-    } \
-    location /__supabase/ { \
-    proxy_pass http://192.168.0.94:8000/; \
-    proxy_set_header Host $host; \
-    proxy_set_header X-Real-IP $remote_addr; \
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; \
-    proxy_set_header Upgrade $http_upgrade; \
-    proxy_set_header Connection "upgrade"; \
-    proxy_http_version 1.1; \
-    } \
-    location /api/ { \
-    proxy_pass http://192.168.0.64:18000/api/; \
-    proxy_set_header Host $host; \
-    proxy_set_header X-Real-IP $remote_addr; \
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; \
-    } \
     location / { \
     try_files $uri $uri/ /index.html; \
     expires 30d; \

docker-compose.dev.yml

@@ -16,28 +16,7 @@ services:
       context: .
       dockerfile: Dockerfile
       args:
-        # app-dev is served by nginx on the app host; browser API calls must stay
+        ENV_FILE: .env.dev
-        # same-origin and pass through Dockerfile's /__ccapi proxy. The proxy
-        # strips that prefix before forwarding, preserving mixed backend routes
-        # such as /api/exam, /me/bootstrap, and /database/timetable.
-        # Supabase is likewise routed same-origin via Dockerfile's /__supabase
-        # proxy -> dev Supabase .94 (no CORS, browser-network-agnostic). The
-        # leading-slash URL is resolved against window.location.origin in
-        # supabaseClient.ts. Provide the matching .94 anon key as a build arg
-        # (VITE_SUPABASE_ANON_KEY) so it pairs with the .94 backend.
-        # .env.dev still points at the LAN API/Supabase for local Vite/dev tooling.
-        VITE_API_BASE: /__ccapi
-        VITE_API_URL: /__ccapi
-        VITE_SUPABASE_URL: /__supabase
-        VITE_APP_NAME: ${VITE_APP_NAME:-Classroom Copilot}
-        VITE_APP_HMR_URL: ${VITE_APP_HMR_URL:-}
-        VITE_DEV: ${VITE_DEV:-false}
-        VITE_FRONTEND_SITE_URL: ${VITE_FRONTEND_SITE_URL:-}
-        VITE_SEARCH_URL: ${VITE_SEARCH_URL:-}
-        VITE_SUPABASE_ANON_KEY: ${VITE_SUPABASE_ANON_KEY:-}
-        VITE_SUPER_ADMIN_EMAIL: ${VITE_SUPER_ADMIN_EMAIL:-}
-        VITE_TLSYNC_URL: ${VITE_TLSYNC_URL:-}
-        VITE_WHISPERLIVE_URL: ${VITE_WHISPERLIVE_URL:-}
     env_file:
       - .env.dev
     ports:

smoke-s4-9c.js

@@ -0,0 +1,60 @@
+const { chromium } = require('playwright');
+const fs = require('fs');
+
+const BASE = process.env.PLAYWRIGHT_BASE_URL || 'http://192.168.0.251:13000';
+const EMAIL = process.env.VITE_TEST_TEACHER_EMAIL || '[email protected]';
+const PASSWORD = process.env.VITE_TEST_TEACHER_PASSWORD || process.env.SEED_TEACHER_PASSWORD;
+const TEMPLATE_ID = process.env.TEMPLATE_ID || '31d92cf3-9bbd-4a7e-b2dc-b37f8b69bc34';
+const OUT = process.env.OUT || '/out';
+
+async function run(mode) {
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({ colorScheme: mode, viewport: { width: 1440, height: 980 } });
+  const page = await context.newPage();
+  const messages = [];
+  page.on('console', msg => messages.push(`${msg.type()}: ${msg.text()}`));
+  page.on('pageerror', err => messages.push(`pageerror: ${err.message}`));
+
+  await page.goto(`${BASE}/login`, { waitUntil: 'domcontentloaded' });
+  if (await page.getByLabel('Email').count()) {
+    if (!PASSWORD) throw new Error('missing password env');
+    await page.getByLabel('Email').fill(EMAIL);
+    await page.getByLabel('Password').fill(PASSWORD);
+    await page.getByRole('button', { name: 'Login' }).click();
+    await page.waitForURL(url => /\/dashboard|\/exam-marker|\/node\//.test(url.pathname), { timeout: 20000 });
+  }
+
+  await page.goto(`${BASE}/exam-marker/${TEMPLATE_ID}/setup`, { waitUntil: 'domcontentloaded' });
+  await page.waitForSelector('[data-testid="exam-template-setup-canvas"]', { timeout: 20000 });
+  await page.waitForTimeout(3500);
+
+  const text = await page.locator('body').innerText();
+  const checks = {
+    hasBoundaryTool: text.includes('Boundary'),
+    hasPartTool: text.includes('Part'),
+    hasResponseTool: text.includes('Response'),
+    hasContextTool: text.includes('Context'),
+    hasQuestionNumberTool: text.includes('Q Number'),
+    hasMarkAreaTool: text.includes('Mark Area'),
+    hasReferenceTool: text.includes('Reference'),
+    hasFurnitureTool: text.includes('Furniture'),
+    hasHintPanel: text.includes('Setup guide') && text.includes('Boundary pairing preview'),
+    hasMultiPageCopy: text.includes('later page') || text.includes('multi-page'),
+    hasPdfStatus: text.includes('PDF backdrop:'),
+    crashOverlay: text.includes('Template setup canvas crashed'),
+  };
+  await page.screenshot({ path: `${OUT}/s4-9c-${mode}.png`, fullPage: true });
+  await browser.close();
+  return { mode, url: `${BASE}/exam-marker/${TEMPLATE_ID}/setup`, checks, consoleMessages: messages };
+}
+
+(async () => {
+  fs.mkdirSync(OUT, { recursive: true });
+  const results = [];
+  for (const mode of ['light', 'dark']) results.push(await run(mode));
+  fs.writeFileSync(`${OUT}/s4-9c-smoke.json`, JSON.stringify(results, null, 2));
+  const failures = results.flatMap(r => Object.entries(r.checks).filter(([k,v]) => k === 'crashOverlay' ? v : !v).map(([k]) => `${r.mode}:${k}`));
+  const consoleErrors = results.flatMap(r => r.consoleMessages.filter(m => /^(error|pageerror):/i.test(m) && !/Failed to load resource/i.test(m)));
+  console.log(JSON.stringify({ results, failures, consoleErrors }, null, 2));
+  if (failures.length || consoleErrors.length) process.exit(1);
+})().catch(err => { console.error(err); process.exit(1); });

src/AppRoutes.admin.test.tsx

@@ -34,10 +34,6 @@ vi.mock('./pages/tldraw/multiplayerUser', () => ({ default: () => <div>Multiplay
 vi.mock('./pages/exam', () => ({
   ExamDashboardPage: () => <div>Exam Marker</div>,
   ExamTemplateSetupPage: () => <div>Exam Template Setup</div>,
-  MarkSchemePage: () => <div>Mark Scheme editor</div>,
-  ExamMarkingPage: () => <div>Exam Marking</div>,
-  ExamResultsPage: () => <div>Exam Results</div>,
-  ResultsWidget: () => <div>Results Widget</div>,
 }));
 vi.mock('./pages/user/calendarPage', () => ({ default: () => <div>Calendar</div> }));
 vi.mock('./pages/user/settingsPage', () => ({ default: () => <div>Settings</div> }));
@@ -129,22 +125,3 @@ describe('/admin route authorization', () => {
     expect(screen.getByText('Platform Admin Page')).toBeInTheDocument();
   });
 });
-
-
-describe('exam-marker routes', () => {
-  beforeEach(() => {
-    mockUseAuth.mockReset();
-  });
-
-  it('renders the mark scheme editor route for authenticated users', () => {
-    mockUseAuth.mockReturnValue(authState({
-      user: { id: 'teacher-1', email: '[email protected]', user_type: 'email_teacher' },
-      user_role: 'email_teacher',
-      accessToken: 'token',
-    }));
-
-    renderAt('/exam-marker/template-123/marks');
-
-    expect(screen.getByText('Mark Scheme editor')).toBeInTheDocument();
-  });
-});

src/AppRoutes.tsx

@@ -7,7 +7,7 @@ import LoginPage from './pages/auth/loginPage';
 import SignupPage from './pages/auth/signupPage';
 import SinglePlayerPage from './pages/tldraw/singlePlayerPage';
 import MultiplayerUser from './pages/tldraw/multiplayerUser';
-import { ExamDashboardPage, ExamMarkingPage, ExamResultsPage, ExamTemplateSetupPage, MarkSchemePage, QuestionBankPage, CorpusPage } from './pages/exam';
+import { ExamDashboardPage, ExamTemplateSetupPage } from './pages/exam';
 import { ErrorBoundary } from './components/ErrorBoundary';
 import CalendarPage from './pages/user/calendarPage';
 import SettingsPage from './pages/user/settingsPage';
@@ -169,7 +169,6 @@ const AppRoutes: React.FC = () => {
             <Route path="/classes" element={<ClassesPage />} />
             <Route path="/my-classes" element={<MyClassesPage />} />
             <Route path="/classes/:classId" element={<ClassDetailPage />} />
-            <Route path="/timetable/classes/:classId" element={<ClassDetailPage />} />
             <Route path="/student-lessons" element={<StudentLessonsPage />} />
             <Route path="/lesson-plans" element={<LessonPlansPage />} />
             <Route path="/lesson-plans/:planId" element={<LessonPlanDetailPage />} />
@@ -184,12 +183,7 @@ const AppRoutes: React.FC = () => {
             <Route path="/search" element={<SearxngPage />} />
             <Route path="/teacher-planner" element={<TeacherPlanner />} />
             <Route path="/exam-marker" element={<ErrorBoundary><ExamDashboardPage /></ErrorBoundary>} />
-            <Route path="/exam-marker/bank" element={<ErrorBoundary><QuestionBankPage /></ErrorBoundary>} />
-            <Route path="/exam-marker/corpus" element={<ErrorBoundary><CorpusPage /></ErrorBoundary>} />
             <Route path="/exam-marker/:templateId/setup" element={<ErrorBoundary><ExamTemplateSetupPage /></ErrorBoundary>} />
-            <Route path="/exam-marker/:templateId/marks" element={<ErrorBoundary><MarkSchemePage /></ErrorBoundary>} />
-            <Route path="/exam-marker/:batchId/mark" element={<ErrorBoundary><ExamMarkingPage /></ErrorBoundary>} />
-            <Route path="/exam-marker/:batchId/results" element={<ErrorBoundary><ExamResultsPage /></ErrorBoundary>} />
             <Route path="/doc-intelligence/:fileId" element={<CCDocumentIntelligence />} />
             <Route path="/morphic" element={<MorphicPage />} />
             <Route path="/tldraw-dev" element={<TLDrawDevPage />} />

src/pages/auth/PlatformAdminPage.tsx

@@ -102,17 +102,6 @@ const PlatformAdminPage: React.FC = () => {
                 </Grid>
             )}
 
-            <Alert severity="warning" sx={{ mb: 3 }}>
-                <Typography variant="subtitle2" sx={{ fontWeight: 700 }}>Destructive reset scope: exam-corpus</Typography>
-                <Typography variant="body2">
-                    The <strong>exam-corpus</strong> reset is not limited to public papers. It wipes the entire
-                    exam-marker subsystem: public corpus/eb_* data, cc.examboards storage, templates, template
-                    layouts, questions, boundaries, response areas, marking batches, student submissions, and
-                    mark entries. Use it only when you intend to rebuild all exam-marker data; it does not reset
-                    schools, users, or timetable data.
-                </Typography>
-            </Alert>
-
             <Typography variant="subtitle2" sx={{ mb: 1 }}>Schools ({loading ? '…' : schools.length})</Typography>
 
             {loading ? (

src/pages/exam/CorpusPage.tsx

@@ -1,156 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { useNavigate } from 'react-router-dom';
-import {
-  Accordion, AccordionDetails, AccordionSummary, Alert, Box, Button, Chip, CircularProgress, Container,
-  Stack, Table, TableBody, TableCell, TableHead, TableRow, Typography,
-} from '@mui/material';
-import ArrowBackIcon from '@mui/icons-material/ArrowBack';
-import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
-import CheckIcon from '@mui/icons-material/Check';
-import RemoveIcon from '@mui/icons-material/Remove';
-
-import { examRepository } from '../../services/exam/examRepository';
-import type { CorpusResponse, CorpusSpec, CorpusDocType } from '../../types/exam.types';
-
-const DOCS: CorpusDocType[] = ['QP', 'MS', 'ER'];
-const DOC_LABEL: Record<CorpusDocType, string> = { QP: 'Question papers', MS: 'Mark schemes', ER: 'Examiner reports' };
-const SCIENCES = new Set(['Biology', 'Chemistry', 'Physics']);
-
-const CorpusPage: React.FC = () => {
-  const navigate = useNavigate();
-  const [corpus, setCorpus] = useState<CorpusResponse | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-  const [board, setBoard] = useState<string | null>(null);
-  const [level, setLevel] = useState<string | null>(null);
-  const [subject, setSubject] = useState<string | null>(null);
-  const [sciencesOnly, setSciencesOnly] = useState(true);
-
-  const load = useCallback(async () => {
-    setLoading(true); setError(null);
-    try { setCorpus(await examRepository.getCorpus()); }
-    catch (e) { setError(e instanceof Error ? e.message : String(e)); }
-    finally { setLoading(false); }
-  }, []);
-  useEffect(() => { void load(); }, [load]);
-
-  const allSpecs = useMemo<CorpusSpec[]>(
-    () => (corpus?.boards ?? []).flatMap((b) => b.specs),
-    [corpus],
-  );
-  const boards = useMemo(() => Array.from(new Set(allSpecs.map((s) => s.board))).sort(), [allSpecs]);
-  const levels = useMemo(() => Array.from(new Set(allSpecs.map((s) => s.level))).sort(), [allSpecs]);
-  const subjects = useMemo(() => Array.from(new Set(allSpecs.map((s) => s.subject))).sort(), [allSpecs]);
-
-  const specs = useMemo(() => allSpecs.filter((s) =>
-    (!board || s.board === board) && (!level || s.level === level) && (!subject || s.subject === subject)
-    && (!sciencesOnly || SCIENCES.has(s.subject))
-  ).sort((a, b) => (a.board + a.level + a.subject + a.spec_code).localeCompare(b.board + b.level + b.subject + b.spec_code)),
-    [allSpecs, board, level, subject, sciencesOnly]);
-
-  const filteredTotals = useMemo(() => specs.reduce((acc, s) => {
-    acc.specs += 1; acc.papers += s.n_papers;
-    DOCS.forEach((d) => { acc[d] += s.counts[d] ?? 0; });
-    return acc;
-  }, { specs: 0, papers: 0, QP: 0, MS: 0, ER: 0 } as Record<string, number>), [specs]);
-
-  return (
-    <Container maxWidth="lg" sx={{ py: 4 }}>
-      <Button size="small" startIcon={<ArrowBackIcon />} onClick={() => navigate('/exam-marker')} sx={{ mb: 1 }}>Exam Marker</Button>
-      <Typography variant="h4" component="h1" fontWeight={700}>Exam bank</Typography>
-      <Typography variant="body2" color="text.secondary" sx={{ mb: 2 }}>
-        The collected past-paper corpus — question papers, mark schemes and examiner reports per specification.
-      </Typography>
-
-      {error && <Alert severity="error" sx={{ mb: 2 }} onClose={() => setError(null)}>{error}</Alert>}
-
-      {loading ? (
-        <Box sx={{ display: 'flex', justifyContent: 'center', py: 6 }}><CircularProgress /></Box>
-      ) : (
-        <>
-          {/* Summary of the current selection */}
-          <Stack direction="row" spacing={1} flexWrap="wrap" useFlexGap sx={{ mb: 2 }}>
-            <Chip color="default" label={`${filteredTotals.specs} specifications`} />
-            <Chip color="default" label={`${filteredTotals.papers} papers`} />
-            <Chip color="primary" variant="outlined" label={`${filteredTotals.QP} question papers`} />
-            <Chip color="success" variant="outlined" label={`${filteredTotals.MS} mark schemes`} />
-            <Chip color="warning" variant="outlined" label={`${filteredTotals.ER} examiner reports`} />
-          </Stack>
-
-          {/* Filters */}
-          <Stack spacing={0.75} sx={{ mb: 2 }}>
-            <Stack direction="row" spacing={0.75} alignItems="center" flexWrap="wrap" useFlexGap>
-              <Chip size="small" color={sciencesOnly ? 'secondary' : 'default'} variant={sciencesOnly ? 'filled' : 'outlined'} label="Sciences only" onClick={() => setSciencesOnly((v) => !v)} />
-              <Box sx={{ width: 12 }} />
-              <Typography variant="caption" color="text.secondary">Board:</Typography>
-              <Chip size="small" label="all" variant={board ? 'outlined' : 'filled'} color={board ? 'default' : 'primary'} onClick={() => setBoard(null)} />
-              {boards.map((b) => <Chip key={b} size="small" label={b} variant={board === b ? 'filled' : 'outlined'} color={board === b ? 'primary' : 'default'} onClick={() => setBoard(b)} />)}
-            </Stack>
-            <Stack direction="row" spacing={0.75} alignItems="center" flexWrap="wrap" useFlexGap>
-              <Typography variant="caption" color="text.secondary">Level:</Typography>
-              <Chip size="small" label="all" variant={level ? 'outlined' : 'filled'} color={level ? 'default' : 'primary'} onClick={() => setLevel(null)} />
-              {levels.map((l) => <Chip key={l} size="small" label={l} variant={level === l ? 'filled' : 'outlined'} color={level === l ? 'primary' : 'default'} onClick={() => setLevel(l)} />)}
-              {!sciencesOnly && (<>
-                <Box sx={{ width: 12 }} />
-                <Typography variant="caption" color="text.secondary">Subject:</Typography>
-                <Chip size="small" label="all" variant={subject ? 'outlined' : 'filled'} color={subject ? 'default' : 'primary'} onClick={() => setSubject(null)} />
-                {subjects.map((s) => <Chip key={s} size="small" label={s} variant={subject === s ? 'filled' : 'outlined'} color={subject === s ? 'primary' : 'default'} onClick={() => setSubject(s)} />)}
-              </>)}
-            </Stack>
-          </Stack>
-
-          {specs.length === 0 ? (
-            <Alert severity="info">No specifications match the current filters.</Alert>
-          ) : specs.map((s) => (
-            <Accordion key={s.spec_code} disableGutters>
-              <AccordionSummary expandIcon={<ExpandMoreIcon />}>
-                <Box sx={{ display: 'flex', alignItems: 'center', gap: 1.5, flexWrap: 'wrap', width: '100%' }}>
-                  <Typography sx={{ fontWeight: 700, minWidth: 260 }}>
-                    {s.level} {s.subject} <Typography component="span" color="text.secondary" variant="body2">· {s.spec_code}</Typography>
-                  </Typography>
-                  <Chip size="small" label={`${s.n_papers} papers`} />
-                  <Box sx={{ flex: 1 }} />
-                  {DOCS.map((d) => (
-                    <Chip key={d} size="small" variant="outlined"
-                      color={s.counts[d] ? (d === 'QP' ? 'primary' : d === 'MS' ? 'success' : 'warning') : 'default'}
-                      label={`${d} ${s.counts[d] ?? 0}`} />
-                  ))}
-                </Box>
-              </AccordionSummary>
-              <AccordionDetails sx={{ p: 0 }}>
-                <Box sx={{ overflowX: 'auto' }}>
-                  <Table size="small">
-                    <TableHead>
-                      <TableRow>
-                        <TableCell>Session</TableCell>
-                        <TableCell>Paper</TableCell>
-                        <TableCell>Tier</TableCell>
-                        {DOCS.map((d) => <TableCell key={d} align="center">{DOC_LABEL[d]}</TableCell>)}
-                      </TableRow>
-                    </TableHead>
-                    <TableBody>
-                      {s.papers.map((p, i) => (
-                        <TableRow key={`${p.paper_code}-${p.session}-${i}`} hover>
-                          <TableCell>{p.session ?? '—'}</TableCell>
-                          <TableCell>{p.paper_code ?? '—'}</TableCell>
-                          <TableCell>{p.tier ?? '—'}</TableCell>
-                          {DOCS.map((d) => (
-                            <TableCell key={d} align="center">
-                              {p.docs[d] ? <CheckIcon fontSize="small" color="success" /> : <RemoveIcon fontSize="small" color="disabled" />}
-                            </TableCell>
-                          ))}
-                        </TableRow>
-                      ))}
-                    </TableBody>
-                  </Table>
-                </Box>
-              </AccordionDetails>
-            </Accordion>
-          ))}
-        </>
-      )}
-    </Container>
-  );
-};
-
-export default CorpusPage;

src/pages/exam/ExamDashboardPage.tsx

@@ -24,9 +24,6 @@ import ArchiveIcon from '@mui/icons-material/Archive';
 import AssignmentIcon from '@mui/icons-material/Assignment';
 import ContentCopyIcon from '@mui/icons-material/ContentCopy';
 import EditIcon from '@mui/icons-material/Edit';
-import GradingIcon from '@mui/icons-material/Grading';
-import PlaylistAddCheckIcon from '@mui/icons-material/PlaylistAddCheck';
-import LibraryBooksIcon from '@mui/icons-material/LibraryBooks';
 
 import { useAuth } from '../../contexts/AuthContext';
 import { examRepository } from '../../services/exam/examRepository';
@@ -235,17 +232,9 @@ const ExamDashboardPage: React.FC = () => {
               Build multiple named templates for the same paper, version them as your setup changes, and archive drafts you no longer need.
             </Typography>
           </Box>
-          <Stack direction="row" spacing={1}>
-            <Button variant="outlined" startIcon={<LibraryBooksIcon />} onClick={() => navigate('/exam-marker/corpus')}>
-              Exam bank
-            </Button>
-            <Button variant="outlined" startIcon={<PlaylistAddCheckIcon />} onClick={() => navigate('/exam-marker/bank')}>
-              Question bank
-            </Button>
           <Button variant="contained" startIcon={<AddIcon />} onClick={openCreate}>
             New template
           </Button>
-          </Stack>
         </Box>
 
         {error && (
@@ -331,16 +320,6 @@ const ExamDashboardPage: React.FC = () => {
                               Updated {new Date(t.updated_at).toLocaleDateString()}
                             </Typography>
                           </Box>
-                          <Stack direction="row" spacing={1} sx={{ pt: 0.5 }}>
-                            <Button
-                              size="small"
-                              variant="outlined"
-                              onClick={(e) => { e.stopPropagation(); navigate(`/exam-marker/${t.id}/marks`); }}
-                              startIcon={<GradingIcon fontSize="small" />}
-                            >
-                              Edit marks
-                            </Button>
-                          </Stack>
                         </Paper>
                       </Grid>
                     );

src/pages/exam/ExamMarkingPage.tsx

@@ -1,280 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { useNavigate, useParams } from 'react-router-dom';
-import { v5 as uuidv5 } from 'uuid';
-import {
-  Alert,
-  Box,
-  Button,
-  Card,
-  CardContent,
-  Chip,
-  CircularProgress,
-  Container,
-  Divider,
-  List,
-  ListItemButton,
-  ListItemText,
-  Stack,
-  TextField,
-  Typography,
-} from '@mui/material';
-import ArrowBackIcon from '@mui/icons-material/ArrowBack';
-import SaveIcon from '@mui/icons-material/Save';
-import TableChartIcon from '@mui/icons-material/TableChart';
-import UploadFileIcon from '@mui/icons-material/UploadFile';
-
-import { examRepository } from '../../services/exam/examRepository';
-import type { BatchQueueResponse, ExamQuestion, ExamTemplateDetail, StudentSubmission } from '../../types/exam.types';
-
-const MARK_NAMESPACE = '3f2dbbeb-9b15-4f99-9b71-8c535f8dc3d0';
-
-function stableMarkId(batchId: string, submissionId: string, questionId: string) {
-  return uuidv5(`${batchId}:${submissionId}:${questionId}`, MARK_NAMESPACE);
-}
-
-const ExamMarkingPage: React.FC = () => {
-  const { batchId } = useParams<{ batchId: string }>();
-  const navigate = useNavigate();
-  const [queue, setQueue] = useState<BatchQueueResponse | null>(null);
-  const [template, setTemplate] = useState<ExamTemplateDetail | null>(null);
-  const [selectedId, setSelectedId] = useState<string | null>(null);
-  const [marks, setMarks] = useState<Record<string, string>>({});
-  const [comments, setComments] = useState<Record<string, string>>({});
-  const [loading, setLoading] = useState(true);
-  const [saving, setSaving] = useState(false);
-  const [message, setMessage] = useState<string | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  const [uploading, setUploading] = useState(false);
-  const fileInputRef = useRef<HTMLInputElement | null>(null);
-
-  const load = useCallback(async () => {
-    if (!batchId) return;
-    setLoading(true);
-    setError(null);
-    try {
-      const nextQueue = await examRepository.getBatchQueue(batchId);
-      setQueue(nextQueue);
-      setTemplate(await examRepository.getTemplate(nextQueue.batch.template_id));
-      setSelectedId((current) => current ?? nextQueue.submissions[0]?.id ?? null);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setLoading(false);
-    }
-  }, [batchId]);
-
-  useEffect(() => {
-    void load();
-  }, [load]);
-
-  const markableQuestions = useMemo(
-    () => (template?.questions ?? []).filter((q) => !q.is_container).sort((a, b) => a.order - b.order),
-    [template],
-  );
-  const onScanFiles = useCallback(async (files: FileList | null) => {
-    if (!batchId || !files || files.length === 0) return;
-    setUploading(true); setError(null); setMessage(null);
-    let ok = 0;
-    const failures: string[] = [];
-    for (const file of Array.from(files)) {
-      try {
-        // 'ordered' assigns each scan to the next not-yet-submitted roster slot; unmatched scans
-        // become an unmatched submission the teacher can reconcile.
-        await examRepository.uploadScan(batchId, file, { matchingMethod: 'ordered' });
-        ok += 1;
-      } catch (e) {
-        failures.push(`${file.name}: ${e instanceof Error ? e.message : String(e)}`);
-      }
-    }
-    setUploading(false);
-    if (fileInputRef.current) fileInputRef.current.value = '';
-    await load();
-    if (ok) setMessage(`Uploaded ${ok} scan${ok === 1 ? '' : 's'}${failures.length ? `, ${failures.length} failed` : ''}`);
-    if (failures.length) setError(failures.join(' · '));
-  }, [batchId, load]);
-
-  const selected = queue?.submissions.find((s) => s.id === selectedId) ?? null;
-
-  const saveSelected = async () => {
-    if (!batchId || !selected) return;
-    setSaving(true);
-    setError(null);
-    setMessage(null);
-    try {
-      const writes = markableQuestions
-        .map((q) => ({ q, raw: marks[q.id], comment: comments[q.id] }))
-        .filter(({ raw, comment }) => raw !== undefined && raw !== '' || !!comment?.trim());
-      for (const { q, raw, comment } of writes) {
-        const awarded = raw === undefined || raw === '' ? 0 : Number(raw);
-        if (Number.isNaN(awarded) || awarded < 0 || awarded > (q.max_marks ?? Number.MAX_SAFE_INTEGER)) {
-          throw new Error(`Invalid mark for ${q.label}`);
-        }
-        await examRepository.upsertMark(stableMarkId(batchId, selected.id, q.id), {
-          submission_id: selected.id,
-          question_id: q.id,
-          awarded_marks: awarded,
-          comment: comment?.trim() || undefined,
-          confirmed: true,
-        });
-      }
-      setMessage(`Saved ${writes.length} mark${writes.length === 1 ? '' : 's'} for ${selected.student_name || selected.student_id || 'student'}.`);
-      setMarks({});
-      setComments({});
-      await load();
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setSaving(false);
-    }
-  };
-
-  const chooseStudent = (submission: StudentSubmission) => {
-    setSelectedId(submission.id);
-    setMarks({});
-    setComments({});
-    setMessage(null);
-  };
-
-  if (loading) {
-    return <Box sx={{ display: 'flex', justifyContent: 'center', py: 8 }}><CircularProgress /></Box>;
-  }
-
-  if (error && !queue) {
-    return (
-      <Container maxWidth="lg" sx={{ py: 4 }}>
-        <Alert severity="error">{error}</Alert>
-        <Button sx={{ mt: 2 }} startIcon={<ArrowBackIcon />} onClick={() => navigate('/exam-marker')}>
-          Back to Exam Marker
-        </Button>
-      </Container>
-    );
-  }
-
-  return (
-    <Container maxWidth="xl" sx={{ py: 3 }}>
-      <Stack spacing={2}>
-        <Box sx={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', gap: 2, flexWrap: 'wrap' }}>
-          <Box>
-            <Button size="small" startIcon={<ArrowBackIcon />} onClick={() => navigate('/exam-marker')} sx={{ mb: 1 }}>
-              Exam Marker
-            </Button>
-            <Typography variant="h4" component="h1" fontWeight={700}>{queue?.batch.title || 'Mark exam'}</Typography>
-            <Typography variant="body2" color="text.secondary">
-              {template?.title || queue?.batch.template_id} · {queue?.progress.total ?? 0} students in queue
-            </Typography>
-          </Box>
-          <Button variant="outlined" startIcon={<TableChartIcon />} onClick={() => batchId && navigate(`/exam-marker/${batchId}/results`)}>
-            Results
-          </Button>
-        </Box>
-
-        {error && <Alert severity="error" onClose={() => setError(null)}>{error}</Alert>}
-        {message && <Alert severity="success" onClose={() => setMessage(null)}>{message}</Alert>}
-        {markableQuestions.length === 0 && (
-          <Alert severity="warning">
-            This template has no markable parts yet. Add parts in template setup before entering marks.
-          </Alert>
-        )}
-
-        <Stack direction={{ xs: 'column', md: 'row' }} spacing={2} alignItems="stretch">
-          <Card variant="outlined" sx={{ width: { xs: '100%', md: 340 }, flexShrink: 0 }}>
-            <CardContent>
-              <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 1, mb: 1 }}>
-                <Typography variant="h6">Marking queue</Typography>
-                <Button
-                  size="small"
-                  variant="outlined"
-                  startIcon={<UploadFileIcon fontSize="small" />}
-                  disabled={uploading}
-                  onClick={() => fileInputRef.current?.click()}
-                >
-                  {uploading ? 'Uploading…' : 'Upload scans'}
-                </Button>
-                <input
-                  ref={fileInputRef}
-                  type="file"
-                  accept="application/pdf"
-                  multiple
-                  hidden
-                  onChange={(e) => { void onScanFiles(e.target.files); }}
-                />
-              </Box>
-              <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 1 }}>
-                Scanned PDFs fill the roster in order; unmatched scans appear below to reconcile.
-              </Typography>
-              <Stack direction="row" spacing={1} sx={{ mb: 1 }} flexWrap="wrap" useFlexGap>
-                <Chip size="small" label={`${queue?.progress.total ?? 0} total`} />
-                <Chip size="small" label={`${queue?.progress.absent ?? 0} absent`} color="warning" variant="outlined" />
-                <Chip size="small" label={`${queue?.progress.complete ?? 0} complete`} color="success" variant="outlined" />
-              </Stack>
-              <List dense disablePadding>
-                {(queue?.submissions ?? []).map((submission) => (
-                  <ListItemButton
-                    key={submission.id}
-                    selected={submission.id === selectedId}
-                    onClick={() => chooseStudent(submission)}
-                    sx={{ borderRadius: 1, mb: 0.5 }}
-                  >
-                    <ListItemText
-                      primary={submission.student_name || submission.student_id || 'Unknown student'}
-                      secondary={`${submission.status} · ${submission.mark_entry_count ?? 0} marks`}
-                    />
-                    <Chip size="small" label={submission.status} color={submission.status === 'absent' ? 'warning' : 'default'} variant="outlined" />
-                  </ListItemButton>
-                ))}
-              </List>
-            </CardContent>
-          </Card>
-
-          <Card variant="outlined" sx={{ flex: 1 }}>
-            <CardContent>
-              {selected ? (
-                <Stack spacing={2}>
-                  <Box>
-                    <Typography variant="h6">{selected.student_name || selected.student_id || 'Unknown student'}</Typography>
-                    <Typography variant="body2" color="text.secondary">Status: {selected.status}</Typography>
-                  </Box>
-                  <Divider />
-                  {markableQuestions.map((q: ExamQuestion) => (
-                    <Stack key={q.id} direction={{ xs: 'column', sm: 'row' }} spacing={1.5} alignItems={{ xs: 'stretch', sm: 'center' }}>
-                      <Box sx={{ minWidth: 150 }}>
-                        <Typography variant="body2" fontWeight={700}>{q.label}</Typography>
-                        <Typography variant="caption" color="text.secondary">/ {q.max_marks} marks</Typography>
-                      </Box>
-                      <TextField
-                        label="Mark"
-                        type="number"
-                        size="small"
-                        inputProps={{ min: 0, max: q.max_marks, step: 0.5 }}
-                        value={marks[q.id] ?? ''}
-                        onChange={(e) => setMarks((prev) => ({ ...prev, [q.id]: e.target.value }))}
-                        sx={{ width: { xs: '100%', sm: 120 } }}
-                      />
-                      <TextField
-                        label="Comment"
-                        size="small"
-                        value={comments[q.id] ?? ''}
-                        onChange={(e) => setComments((prev) => ({ ...prev, [q.id]: e.target.value }))}
-                        sx={{ flex: 1 }}
-                      />
-                    </Stack>
-                  ))}
-                  <Box sx={{ display: 'flex', justifyContent: 'flex-end', gap: 1 }}>
-                    <Button onClick={() => navigate(`/exam-marker/${batchId}/results`)}>Skip to results</Button>
-                    <Button variant="contained" startIcon={<SaveIcon />} onClick={saveSelected} disabled={saving || markableQuestions.length === 0}>
-                      {saving ? 'Saving…' : 'Save marks'}
-                    </Button>
-                  </Box>
-                </Stack>
-              ) : (
-                <Typography color="text.secondary" sx={{ py: 4, textAlign: 'center' }}>No submissions in this batch.</Typography>
-              )}
-            </CardContent>
-          </Card>
-        </Stack>
-      </Stack>
-    </Container>
-  );
-};
-
-export default ExamMarkingPage;

src/pages/exam/ExamResultsPage.tsx

@@ -1,177 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { useNavigate, useParams } from 'react-router-dom';
-import {
-  Alert,
-  Box,
-  Button,
-  Chip,
-  CircularProgress,
-  Container,
-  Paper,
-  Stack,
-  Table,
-  TableBody,
-  TableCell,
-  TableContainer,
-  TableHead,
-  TableRow,
-  Typography,
-} from '@mui/material';
-import ArrowBackIcon from '@mui/icons-material/ArrowBack';
-import DownloadIcon from '@mui/icons-material/Download';
-import EditIcon from '@mui/icons-material/Edit';
-
-import { examRepository } from '../../services/exam/examRepository';
-import type { BatchResultsResponse } from '../../types/exam.types';
-
-function formatMark(value: number | null | undefined) {
-  return value === null || value === undefined ? '' : String(value);
-}
-
-const ExamResultsPage: React.FC = () => {
-  const { batchId } = useParams<{ batchId: string }>();
-  const navigate = useNavigate();
-  const [data, setData] = useState<BatchResultsResponse | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [downloading, setDownloading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const load = useCallback(async () => {
-    if (!batchId) return;
-    setLoading(true);
-    setError(null);
-    try {
-      setData(await examRepository.getBatchResults(batchId));
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setLoading(false);
-    }
-  }, [batchId]);
-
-  useEffect(() => {
-    void load();
-  }, [load]);
-
-  const summary = useMemo(() => {
-    const rows = data?.results ?? [];
-    const presentTotals = rows
-      .map((r) => r.total)
-      .filter((v): v is number => typeof v === 'number');
-    const average = presentTotals.length
-      ? presentTotals.reduce((sum, v) => sum + v, 0) / presentTotals.length
-      : null;
-    return {
-      total: rows.length,
-      absent: rows.filter((r) => r.status === 'absent' && r.total === null).length,
-      marked: rows.filter((r) => r.total !== null).length,
-      average,
-    };
-  }, [data]);
-
-  const downloadCsv = async () => {
-    if (!batchId) return;
-    setDownloading(true);
-    setError(null);
-    try {
-      const csv = await examRepository.getBatchCsv(batchId);
-      const blob = new Blob([csv], { type: 'text/csv;charset=utf-8' });
-      const url = URL.createObjectURL(blob);
-      const a = document.createElement('a');
-      a.href = url;
-      a.download = `batch-${batchId}.csv`;
-      document.body.appendChild(a);
-      a.click();
-      a.remove();
-      URL.revokeObjectURL(url);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setDownloading(false);
-    }
-  };
-
-  if (loading) {
-    return <Box sx={{ display: 'flex', justifyContent: 'center', py: 8 }}><CircularProgress /></Box>;
-  }
-
-  if (error || !data) {
-    return (
-      <Container maxWidth="lg" sx={{ py: 4 }}>
-        <Alert severity="error">{error || 'Results not found'}</Alert>
-        <Button sx={{ mt: 2 }} startIcon={<ArrowBackIcon />} onClick={() => navigate('/exam-marker')}>
-          Back to Exam Marker
-        </Button>
-      </Container>
-    );
-  }
-
-  return (
-    <Container maxWidth="xl" sx={{ py: 4 }}>
-      <Stack spacing={3}>
-        <Box sx={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', gap: 2, flexWrap: 'wrap' }}>
-          <Box>
-            <Button size="small" startIcon={<ArrowBackIcon />} onClick={() => navigate('/exam-marker')} sx={{ mb: 1 }}>
-              Exam Marker
-            </Button>
-            <Typography variant="h4" component="h1" fontWeight={700}>
-              {data.batch.title || 'Exam results'}
-            </Typography>
-            <Typography variant="body2" color="text.secondary">
-              Batch {data.batch.id} · created {new Date(data.batch.created_at).toLocaleDateString('en-GB')}
-            </Typography>
-          </Box>
-          <Stack direction="row" spacing={1}>
-            <Button variant="outlined" startIcon={<EditIcon />} onClick={() => navigate(`/exam-marker/${data.batch.id}/mark`)}>
-              Mark
-            </Button>
-            <Button variant="contained" startIcon={<DownloadIcon />} onClick={downloadCsv} disabled={downloading}>
-              {downloading ? 'Preparing…' : 'Download CSV'}
-            </Button>
-          </Stack>
-        </Box>
-
-        <Stack direction="row" spacing={1} flexWrap="wrap" useFlexGap>
-          <Chip label={`${summary.total} students`} />
-          <Chip label={`${summary.marked} with marks`} color="success" variant="outlined" />
-          <Chip label={`${summary.absent} absent/no scan`} color="warning" variant="outlined" />
-          <Chip label={`Class average ${summary.average === null ? '—' : summary.average.toFixed(1)}`} color="primary" />
-        </Stack>
-
-        <TableContainer component={Paper} variant="outlined">
-          <Table size="small" stickyHeader>
-            <TableHead>
-              <TableRow>
-                <TableCell>Student</TableCell>
-                <TableCell>Status</TableCell>
-                {data.questions.map((q) => (
-                  <TableCell key={q.id} align="right">{q.label} / {q.max_marks}</TableCell>
-                ))}
-                <TableCell align="right">Total</TableCell>
-              </TableRow>
-            </TableHead>
-            <TableBody>
-              {data.results.map((row) => (
-                <TableRow key={row.submission_id} sx={row.status === 'absent' && row.total === null ? { opacity: 0.72 } : undefined}>
-                  <TableCell>
-                    <Typography variant="body2" fontWeight={600}>{row.student_name || row.student_id || 'Unknown student'}</Typography>
-                    {row.student_id && <Typography variant="caption" color="text.secondary">{row.student_id}</Typography>}
-                  </TableCell>
-                  <TableCell>
-                    <Chip size="small" label={row.status || 'unknown'} color={row.status === 'absent' ? 'warning' : 'default'} variant="outlined" />
-                  </TableCell>
-                  {data.questions.map((q) => (
-                    <TableCell key={q.id} align="right">{formatMark(row.marks[q.id])}</TableCell>
-                  ))}
-                  <TableCell align="right"><strong>{formatMark(row.total)}</strong></TableCell>
-                </TableRow>
-              ))}
-            </TableBody>
-          </Table>
-        </TableContainer>
-      </Stack>
-    </Container>
-  );
-};
-
-export default ExamResultsPage;

src/pages/exam/MarkSchemePage.tsx

@@ -1,501 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { useNavigate, useParams } from 'react-router-dom';
-import {
-  Alert,
-  Autocomplete,
-  Box,
-  Button,
-  Card,
-  CardContent,
-  Chip,
-  CircularProgress,
-  Container,
-  Divider,
-  FormControl,
-  Grid,
-  InputLabel,
-  MenuItem,
-  Paper,
-  Select,
-  Stack,
-  Tab,
-  Tabs,
-  TextField,
-  Typography,
-} from '@mui/material';
-import ArrowBackIcon from '@mui/icons-material/ArrowBack';
-import SaveIcon from '@mui/icons-material/Save';
-import SyncIcon from '@mui/icons-material/Sync';
-
-import { logger } from '../../debugConfig';
-import { examRepository } from '../../services/exam/examRepository';
-import type {
-  ExamQuestion,
-  ExamTemplateDetail,
-  MarkScheme,
-  MarkSchemeType,
-  SpecPoint,
-} from '../../types/exam.types';
-
-type Drafts = Record<string, PartDraft>;
-
-interface PartDraft {
-  max_marks: string;
-  answer_type: 'written' | 'mcq' | 'short' | 'diagram';
-  spec_ref: string;
-  schemeType: MarkSchemeType;
-  body: string;
-  notes: string;
-}
-
-const ANSWER_TYPES: Array<PartDraft['answer_type']> = ['written', 'short', 'mcq', 'diagram'];
-const SCHEME_TYPES: Array<{ value: MarkSchemeType; label: string; helper: string }> = [
-  { value: 'points', label: 'Points', helper: 'One mark point per line, e.g. "1 | Mentions resultant force".' },
-  { value: 'levels', label: 'Levels', helper: 'One level per line, e.g. "L2 | 3-4 | Clear linked explanation".' },
-  { value: 'parts', label: 'Parts', helper: 'One sub-part per line, e.g. "a | 2 | Correct substitution".' },
-  { value: 'checklist', label: 'Checklist', helper: 'One checklist item per line, e.g. "1 | Correct unit".' },
-  { value: 'free', label: 'Free text', helper: 'Paste or type the mark scheme exactly as it should be stored.' },
-];
-
-function deriveSpecCode(template: ExamTemplateDetail | null): string {
-  const examCode = template?.exam_code ?? '';
-  const match = examCode.match(/^([A-Z]+-[A-Z]+-\d+)/i);
-  return match?.[1] ?? '';
-}
-
-function schemeToDraft(scheme: MarkScheme | null | undefined): Pick<PartDraft, 'schemeType' | 'body' | 'notes'> {
-  const type = (scheme?.type as MarkSchemeType | undefined) ?? 'points';
-  const notes = typeof scheme?.notes === 'string' ? scheme.notes : '';
-
-  if (type === 'levels' && Array.isArray(scheme?.levels)) {
-    return {
-      schemeType: 'levels',
-      body: scheme.levels.map((l) => `${l.level ?? ''} | ${l.min ?? 0}-${l.max ?? 0} | ${l.descriptor ?? ''}`).join('\n'),
-      notes,
-    };
-  }
-  if (type === 'parts' && Array.isArray(scheme?.parts)) {
-    return {
-      schemeType: 'parts',
-      body: scheme.parts.map((p) => `${p.label ?? ''} | ${p.marks ?? 0} | ${p.guidance ?? ''}`).join('\n'),
-      notes,
-    };
-  }
-  if (type === 'checklist' && Array.isArray(scheme?.checklist)) {
-    return {
-      schemeType: 'checklist',
-      body: scheme.checklist.map((item) => `${item.marks ?? 1} | ${item.text ?? ''}`).join('\n'),
-      notes,
-    };
-  }
-  if (type === 'free') {
-    return { schemeType: 'free', body: typeof scheme?.text === 'string' ? scheme.text : '', notes };
-  }
-  if (Array.isArray(scheme?.points)) {
-    return {
-      schemeType: 'points',
-      body: scheme.points.map((p) => `${p.mark ?? 1} | ${p.text ?? ''}`).join('\n'),
-      notes,
-    };
-  }
-  return { schemeType: type, body: '', notes };
-}
-
-function parseNumber(value: string, fallback = 0): number {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : fallback;
-}
-
-function splitLine(line: string): string[] {
-  return line.split('|').map((part) => part.trim());
-}
-
-function draftToScheme(draft: PartDraft): MarkScheme {
-  const lines = draft.body.split('\n').map((line) => line.trim()).filter(Boolean);
-  if (draft.schemeType === 'free') return { type: 'free', text: draft.body, notes: draft.notes || undefined };
-  if (draft.schemeType === 'levels') {
-    return {
-      type: 'levels',
-      levels: lines.map((line, idx) => {
-        const [level, range, descriptor] = splitLine(line);
-        const [minRaw, maxRaw] = (range || '').split('-').map((part) => part.trim());
-        return {
-          level: level || `L${idx + 1}`,
-          min: parseNumber(minRaw, 0),
-          max: parseNumber(maxRaw, parseNumber(minRaw, 0)),
-          descriptor: descriptor || line,
-        };
-      }),
-      notes: draft.notes || undefined,
-    };
-  }
-  if (draft.schemeType === 'parts') {
-    return {
-      type: 'parts',
-      parts: lines.map((line, idx) => {
-        const [label, marks, guidance] = splitLine(line);
-        return { label: label || String(idx + 1), marks: parseNumber(marks, 1), guidance: guidance || line };
-      }),
-      notes: draft.notes || undefined,
-    };
-  }
-  if (draft.schemeType === 'checklist') {
-    return {
-      type: 'checklist',
-      checklist: lines.map((line) => {
-        const [marks, text] = splitLine(line);
-        return { marks: parseNumber(marks, 1), text: text || line };
-      }),
-      notes: draft.notes || undefined,
-    };
-  }
-  return {
-    type: 'points',
-    points: lines.map((line) => {
-      const [mark, text] = splitLine(line);
-      return { mark: parseNumber(mark, 1), text: text || line };
-    }),
-    notes: draft.notes || undefined,
-  };
-}
-
-function makeDraft(question: ExamQuestion): PartDraft {
-  const scheme = schemeToDraft(question.mark_scheme);
-  return {
-    max_marks: String(question.max_marks ?? 0),
-    answer_type: (question.answer_type as PartDraft['answer_type'] | null) ?? 'written',
-    spec_ref: question.spec_ref ?? '',
-    schemeType: scheme.schemeType,
-    body: scheme.body,
-    notes: scheme.notes,
-  };
-}
-
-const MarkSchemePage: React.FC = () => {
-  const navigate = useNavigate();
-  const { templateId } = useParams<{ templateId: string }>();
-
-  const [template, setTemplate] = useState<ExamTemplateDetail | null>(null);
-  const [selectedId, setSelectedId] = useState<string | null>(null);
-  const [drafts, setDrafts] = useState<Drafts>({});
-  const [specCode, setSpecCode] = useState('');
-  const [specPoints, setSpecPoints] = useState<SpecPoint[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [savingId, setSavingId] = useState<string | null>(null);
-  const [syncing, setSyncing] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [notice, setNotice] = useState<string | null>(null);
-  const [specEndpointMissing, setSpecEndpointMissing] = useState(false);
-
-  const load = useCallback(async () => {
-    if (!templateId) return;
-    setLoading(true);
-    setError(null);
-    try {
-      const detail = await examRepository.getTemplate(templateId);
-      const leafParts = detail.questions.filter((q) => !q.is_container).sort((a, b) => a.order - b.order || a.label.localeCompare(b.label));
-      setTemplate(detail);
-      setSelectedId((prev) => prev ?? leafParts[0]?.id ?? null);
-      setDrafts(Object.fromEntries(leafParts.map((q) => [q.id, makeDraft(q)])));
-      setSpecCode((prev) => prev || deriveSpecCode(detail));
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      logger.error('cc-exam-marker', 'Failed to load mark scheme template', { message: msg, templateId });
-      setError(msg);
-    } finally {
-      setLoading(false);
-    }
-  }, [templateId]);
-
-  useEffect(() => {
-    void load();
-  }, [load]);
-
-  const loadSpecPoints = useCallback(async () => {
-    if (!specCode.trim()) return;
-    setSpecEndpointMissing(false);
-    try {
-      setSpecPoints(await examRepository.listSpecPoints(specCode.trim()));
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      logger.warn('cc-exam-marker', 'SpecPoint endpoint unavailable; falling back to manual spec_ref entry', { message: msg, specCode });
-      setSpecEndpointMissing(true);
-      setSpecPoints([]);
-    }
-  }, [specCode]);
-
-  useEffect(() => {
-    void loadSpecPoints();
-  }, [loadSpecPoints]);
-
-  const parts = useMemo(
-    () => (template?.questions ?? []).filter((q) => !q.is_container).sort((a, b) => a.order - b.order || a.label.localeCompare(b.label)),
-    [template],
-  );
-  const selected = parts.find((p) => p.id === selectedId) ?? null;
-  const draft = selected ? drafts[selected.id] : null;
-  const selectedSpecPoint = draft?.spec_ref ? specPoints.find((p) => p.ref === draft.spec_ref) ?? null : null;
-
-  const updateDraft = (questionId: string, patch: Partial<PartDraft>) => {
-    setDrafts((prev) => ({ ...prev, [questionId]: { ...prev[questionId], ...patch } }));
-  };
-
-  const savePart = async (question: ExamQuestion) => {
-    const partDraft = drafts[question.id];
-    if (!partDraft) return;
-    setSavingId(question.id);
-    setError(null);
-    setNotice(null);
-    try {
-      await examRepository.patchQuestion(question.id, {
-        max_marks: parseNumber(partDraft.max_marks, question.max_marks),
-        answer_type: partDraft.answer_type,
-        mark_scheme: draftToScheme(partDraft),
-        spec_ref: partDraft.spec_ref.trim() || null,
-      });
-      setTemplate((prev) => {
-        if (!prev) return prev;
-        return {
-          ...prev,
-          questions: prev.questions.map((q) => q.id === question.id ? {
-            ...q,
-            max_marks: parseNumber(partDraft.max_marks, question.max_marks),
-            answer_type: partDraft.answer_type,
-            mark_scheme: draftToScheme(partDraft),
-            spec_ref: partDraft.spec_ref.trim() || null,
-          } : q),
-        };
-      });
-      setNotice(`Saved mark scheme for Part ${question.label}.`);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      logger.error('cc-exam-marker', 'Save mark scheme failed', { message: msg, questionId: question.id });
-      setError(msg);
-    } finally {
-      setSavingId(null);
-    }
-  };
-
-  const syncGraph = async () => {
-    if (!templateId) return;
-    setSyncing(true);
-    setError(null);
-    setNotice(null);
-    try {
-      const res = await examRepository.syncTemplateToGraph(templateId);
-      setNotice(`Neo4j projection ${res.status}; ${JSON.stringify(res.projection ?? {})}`);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      logger.error('cc-exam-marker', 'Neo4j sync failed', { message: msg, templateId });
-      setError(msg);
-    } finally {
-      setSyncing(false);
-    }
-  };
-
-  if (loading) {
-    return <Box sx={{ display: 'flex', justifyContent: 'center', py: 10 }}><CircularProgress /></Box>;
-  }
-
-  return (
-    <Container maxWidth="xl" sx={{ py: 4 }}>
-      <Stack spacing={3}>
-        <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', flexWrap: 'wrap', gap: 2 }}>
-          <Box>
-            <Button startIcon={<ArrowBackIcon />} onClick={() => navigate('/exam-marker')} sx={{ mb: 1 }}>
-              Back to templates
-            </Button>
-            <Typography variant="h3" component="h1">Mark Scheme editor</Typography>
-            <Typography variant="body1" color="text.secondary">
-              {template?.title ?? 'Template'} · Edit per-Part mark schemes and link assessed specification points.
-            </Typography>
-          </Box>
-          <Stack direction="row" spacing={1}>
-            {templateId && <Button variant="outlined" onClick={() => navigate(`/exam-marker/${templateId}/setup`)}>Setup canvas</Button>}
-            <Button variant="outlined" startIcon={<SyncIcon />} onClick={syncGraph} disabled={syncing || !templateId}>
-              {syncing ? 'Syncing…' : 'Sync to graph'}
-            </Button>
-          </Stack>
-        </Box>
-
-        {error && <Alert severity="error" onClose={() => setError(null)}>{error}</Alert>}
-        {notice && <Alert severity="success" onClose={() => setNotice(null)}>{notice}</Alert>}
-        {specEndpointMissing && (
-          <Alert severity="warning">
-            SpecPoint picker endpoint was not available from this API build. You can still type a spec_ref manually; the backend projection resolves it during neo4j-sync.
-          </Alert>
-        )}
-
-        <Paper variant="outlined" sx={{ p: 2 }}>
-          <Grid container spacing={2} alignItems="center">
-            <Grid item xs={12} md={4}>
-              <TextField
-                label="Specification code"
-                value={specCode}
-                onChange={(e) => setSpecCode(e.target.value)}
-                fullWidth
-                helperText="Example: AQA-PHYS-8463. Used by the SpecPoint picker."
-              />
-            </Grid>
-            <Grid item xs={12} md={8}>
-              <Typography variant="body2" color="text.secondary">
-                Save writes PATCH /api/exam/questions/:id. Spec refs are persisted on the Part and projected as (:Part)-[:ASSESSES]-&gt;(:SpecPoint).
-              </Typography>
-            </Grid>
-          </Grid>
-        </Paper>
-
-        {parts.length === 0 ? (
-          <Alert severity="info">
-            This template has no Parts yet. Draw Part boxes on the setup canvas first, then return here to enter mark schemes.
-          </Alert>
-        ) : (
-          <Grid container spacing={3}>
-            <Grid item xs={12} md={3}>
-              <Card variant="outlined">
-                <CardContent>
-                  <Typography variant="h6" gutterBottom>Parts</Typography>
-                  <Tabs
-                    orientation="vertical"
-                    value={selectedId ?? false}
-                    onChange={(_, value) => setSelectedId(value)}
-                    variant="scrollable"
-                    sx={{ borderRight: 1, borderColor: 'divider', maxHeight: '65vh' }}
-                  >
-                    {parts.map((part) => (
-                      <Tab
-                        key={part.id}
-                        value={part.id}
-                        label={
-                          <Box sx={{ textAlign: 'left', width: '100%' }}>
-                            <Typography variant="body2">Part {part.label}</Typography>
-                            <Stack direction="row" spacing={0.5} sx={{ mt: 0.5, flexWrap: 'wrap' }}>
-                              <Chip size="small" label={`${drafts[part.id]?.max_marks ?? part.max_marks} marks`} />
-                              {(drafts[part.id]?.spec_ref || part.spec_ref) && <Chip size="small" color="info" label={drafts[part.id]?.spec_ref || part.spec_ref || ''} />}
-                            </Stack>
-                          </Box>
-                        }
-                      />
-                    ))}
-                  </Tabs>
-                </CardContent>
-              </Card>
-            </Grid>
-
-            <Grid item xs={12} md={9}>
-              {selected && draft && (
-                <Card variant="outlined">
-                  <CardContent>
-                    <Stack spacing={3}>
-                      <Box sx={{ display: 'flex', justifyContent: 'space-between', gap: 2, flexWrap: 'wrap' }}>
-                        <Box>
-                          <Typography variant="h5">Part {selected.label}</Typography>
-                          <Typography variant="body2" color="text.secondary">
-                            {selected.parent_id ? `Parent question ${selected.parent_id}` : 'No parent question'}
-                          </Typography>
-                        </Box>
-                        <Button
-                          variant="contained"
-                          startIcon={<SaveIcon />}
-                          disabled={savingId === selected.id}
-                          onClick={() => savePart(selected)}
-                        >
-                          {savingId === selected.id ? 'Saving…' : 'Save part'}
-                        </Button>
-                      </Box>
-
-                      <Grid container spacing={2}>
-                        <Grid item xs={12} sm={4}>
-                          <TextField
-                            label="Max marks"
-                            value={draft.max_marks}
-                            onChange={(e) => updateDraft(selected.id, { max_marks: e.target.value })}
-                            type="number"
-                            inputProps={{ min: 0, step: 0.5 }}
-                            fullWidth
-                          />
-                        </Grid>
-                        <Grid item xs={12} sm={4}>
-                          <FormControl fullWidth>
-                            <InputLabel id="answer-type-label">Answer type</InputLabel>
-                            <Select
-                              labelId="answer-type-label"
-                              label="Answer type"
-                              value={draft.answer_type}
-                              onChange={(e) => updateDraft(selected.id, { answer_type: e.target.value as PartDraft['answer_type'] })}
-                            >
-                              {ANSWER_TYPES.map((type) => <MenuItem key={type} value={type}>{type}</MenuItem>)}
-                            </Select>
-                          </FormControl>
-                        </Grid>
-                        <Grid item xs={12} sm={4}>
-                          <FormControl fullWidth>
-                            <InputLabel id="scheme-type-label">Scheme form</InputLabel>
-                            <Select
-                              labelId="scheme-type-label"
-                              label="Scheme form"
-                              value={draft.schemeType}
-                              onChange={(e) => updateDraft(selected.id, { schemeType: e.target.value as MarkSchemeType })}
-                            >
-                              {SCHEME_TYPES.map((type) => <MenuItem key={type.value} value={type.value}>{type.label}</MenuItem>)}
-                            </Select>
-                          </FormControl>
-                        </Grid>
-                      </Grid>
-
-                      <Autocomplete
-                        options={specPoints}
-                        value={selectedSpecPoint}
-                        onChange={(_, value) => updateDraft(selected.id, { spec_ref: value?.ref ?? '' })}
-                        getOptionLabel={(option) => `${option.ref} — ${option.description}`}
-                        isOptionEqualToValue={(option, value) => option.ref === value.ref}
-                        renderInput={(params) => (
-                          <TextField
-                            {...params}
-                            label="SpecPoint picker"
-                            helperText={specPoints.length ? 'Choose a seeded SpecPoint, or type below to override.' : 'No picker results loaded; type spec_ref manually below.'}
-                          />
-                        )}
-                      />
-
-                      <TextField
-                        label="spec_ref"
-                        value={draft.spec_ref}
-                        onChange={(e) => updateDraft(selected.id, { spec_ref: e.target.value })}
-                        helperText="Persisted to exam_questions.spec_ref; graph sync creates the ASSESSES edge when the ref matches a seeded SpecPoint."
-                        fullWidth
-                      />
-
-                      <Divider />
-
-                      <TextField
-                        label={`${SCHEME_TYPES.find((type) => type.value === draft.schemeType)?.label ?? 'Mark scheme'} body`}
-                        value={draft.body}
-                        onChange={(e) => updateDraft(selected.id, { body: e.target.value })}
-                        helperText={SCHEME_TYPES.find((type) => type.value === draft.schemeType)?.helper}
-                        multiline
-                        minRows={10}
-                        fullWidth
-                      />
-
-                      <TextField
-                        label="Internal marking notes"
-                        value={draft.notes}
-                        onChange={(e) => updateDraft(selected.id, { notes: e.target.value })}
-                        multiline
-                        minRows={3}
-                        fullWidth
-                      />
-                    </Stack>
-                  </CardContent>
-                </Card>
-              )}
-            </Grid>
-          </Grid>
-        )}
-      </Stack>
-    </Container>
-  );
-};
-
-export default MarkSchemePage;

src/pages/exam/QuestionBankPage.tsx

@@ -1,207 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { useNavigate } from 'react-router-dom';
-import {
-  Alert, Box, Button, Card, CardActionArea, CardContent, Chip, CircularProgress, Container,
-  Dialog, DialogActions, DialogContent, DialogTitle, Stack, TextField, Typography,
-} from '@mui/material';
-import ArrowBackIcon from '@mui/icons-material/ArrowBack';
-import PlaylistAddCheckIcon from '@mui/icons-material/PlaylistAddCheck';
-import CheckCircleIcon from '@mui/icons-material/CheckCircle';
-import RadioButtonUncheckedIcon from '@mui/icons-material/RadioButtonUnchecked';
-
-import { examRepository } from '../../services/exam/examRepository';
-import type { BankQuestion, BankResponse } from '../../types/exam.types';
-import { cropQuestion } from './bankCrops';
-
-const QuestionCrop: React.FC<{ q: BankQuestion }> = ({ q }) => {
-  const [src, setSrc] = useState<string | null>(null);
-  const [done, setDone] = useState(false);
-  useEffect(() => {
-    let alive = true;
-    cropQuestion({ templateId: q.template_id, page: q.page, bounds: q.bounds })
-      .then((d) => { if (alive) { setSrc(d); setDone(true); } })
-      .catch(() => { if (alive) setDone(true); });
-    return () => { alive = false; };
-  }, [q.template_id, q.page, q.bounds]);
-  if (src) {
-    return <Box component="img" src={src} alt="" loading="lazy" sx={{ width: '100%', maxHeight: 150, objectFit: 'cover', objectPosition: 'top', display: 'block', bgcolor: '#fff', borderBottom: 1, borderColor: 'divider' }} />;
-  }
-  return (
-    <Box sx={{ height: 56, display: 'flex', alignItems: 'center', justifyContent: 'center', bgcolor: 'action.hover', borderBottom: 1, borderColor: 'divider', color: 'text.disabled', fontSize: 12 }}>
-      {done ? 'no preview' : <CircularProgress size={16} />}
-    </Box>
-  );
-};
-
-const QuestionBankPage: React.FC = () => {
-  const navigate = useNavigate();
-  const [bank, setBank] = useState<BankResponse | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-  const [specRef, setSpecRef] = useState<string | null>(null);
-  const [subject, setSubject] = useState<string | null>(null);
-  const [selected, setSelected] = useState<Set<string>>(new Set());
-  const [dialogOpen, setDialogOpen] = useState(false);
-  const [title, setTitle] = useState('');
-  const [creating, setCreating] = useState(false);
-
-  const load = useCallback(async () => {
-    setLoading(true); setError(null);
-    try {
-      setBank(await examRepository.getBank({ specRef: specRef ?? undefined, subject: subject ?? undefined }));
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setLoading(false);
-    }
-  }, [specRef, subject]);
-
-  useEffect(() => { void load(); }, [load]);
-
-  const toggle = (id: string) => setSelected((prev) => {
-    const next = new Set(prev);
-    if (next.has(id)) next.delete(id); else next.add(id);
-    return next;
-  });
-
-  const selectedList = useMemo(() => Array.from(selected), [selected]);
-  const selectedQuestions = useMemo(
-    () => (bank?.questions ?? []).filter((q) => selected.has(q.id)),
-    [bank, selected],
-  );
-  const totalMarks = selectedQuestions.reduce((s, q) => s + (q.max_marks ?? 0), 0);
-
-  // facet lists (sorted) with counts
-  const specFacets = Object.entries(bank?.facets.spec_ref ?? {}).sort((a, b) => (a[0] < b[0] ? -1 : 1));
-  const subjectFacets = Object.entries(bank?.facets.subject ?? {}).sort((a, b) => (a[0] < b[0] ? -1 : 1));
-
-  const create = async () => {
-    setCreating(true); setError(null);
-    try {
-      const subj = subject ?? selectedQuestions[0]?.paper.subject ?? undefined;
-      const res = await examRepository.createCustomPaper({
-        title: title.trim() || `Custom paper — ${new Date().toISOString().slice(0, 10)}`,
-        subject: subj ?? undefined,
-        question_ids: selectedList,
-      });
-      navigate(`/exam-marker/${res.id}/setup`);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-      setCreating(false);
-      setDialogOpen(false);
-    }
-  };
-
-  return (
-    <Container maxWidth="lg" sx={{ py: 4 }}>
-      <Button size="small" startIcon={<ArrowBackIcon />} onClick={() => navigate('/exam-marker')} sx={{ mb: 1 }}>
-        Exam Marker
-      </Button>
-      <Box sx={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', gap: 2, flexWrap: 'wrap', mb: 2 }}>
-        <Box>
-          <Typography variant="h4" component="h1" fontWeight={700}>Question bank</Typography>
-          <Typography variant="body2" color="text.secondary">
-            Plan by spec point, then assemble a custom paper from questions across your papers.
-          </Typography>
-        </Box>
-        <Button
-          variant="contained"
-          startIcon={<PlaylistAddCheckIcon />}
-          disabled={selected.size === 0}
-          onClick={() => setDialogOpen(true)}
-        >
-          Create paper ({selected.size}{totalMarks ? ` · ${totalMarks}m` : ''})
-        </Button>
-      </Box>
-
-      {error && <Alert severity="error" sx={{ mb: 2 }} onClose={() => setError(null)}>{error}</Alert>}
-
-      {/* Filters */}
-      <Stack spacing={1} sx={{ mb: 2 }}>
-        <Stack direction="row" spacing={0.75} alignItems="center" flexWrap="wrap" useFlexGap>
-          <Typography variant="caption" color="text.secondary" sx={{ mr: 0.5 }}>Spec point:</Typography>
-          <Chip size="small" label="all" color={specRef ? 'default' : 'primary'} onClick={() => setSpecRef(null)} variant={specRef ? 'outlined' : 'filled'} />
-          {specFacets.map(([ref, count]) => (
-            <Chip key={ref} size="small" label={`${ref} · ${count}`} color={specRef === ref ? 'primary' : 'default'} variant={specRef === ref ? 'filled' : 'outlined'} onClick={() => setSpecRef(ref)} />
-          ))}
-        </Stack>
-        {subjectFacets.length > 1 && (
-          <Stack direction="row" spacing={0.75} alignItems="center" flexWrap="wrap" useFlexGap>
-            <Typography variant="caption" color="text.secondary" sx={{ mr: 0.5 }}>Subject:</Typography>
-            <Chip size="small" label="all" color={subject ? 'default' : 'secondary'} onClick={() => setSubject(null)} variant={subject ? 'outlined' : 'filled'} />
-            {subjectFacets.map(([s, count]) => (
-              <Chip key={s} size="small" label={`${s} · ${count}`} color={subject === s ? 'secondary' : 'default'} variant={subject === s ? 'filled' : 'outlined'} onClick={() => setSubject(s)} sx={{ textTransform: 'capitalize' }} />
-            ))}
-          </Stack>
-        )}
-      </Stack>
-
-      {loading ? (
-        <Box sx={{ display: 'flex', justifyContent: 'center', py: 6 }}><CircularProgress /></Box>
-      ) : (bank?.questions.length ?? 0) === 0 ? (
-        <Alert severity="info">
-          No questions match yet. Questions appear here once your templates have parts with spec points
-          (set them in the mark-scheme editor). Auto-map + confirm on a paper to populate it.
-        </Alert>
-      ) : (
-        <>
-          <Typography variant="body2" color="text.secondary" sx={{ mb: 1 }}>
-            {bank?.n} question{bank?.n === 1 ? '' : 's'} · click to add to your paper
-          </Typography>
-          <Box sx={{ display: 'grid', gridTemplateColumns: { xs: '1fr', sm: '1fr 1fr', md: '1fr 1fr 1fr' }, gap: 1.5 }}>
-            {(bank?.questions ?? []).map((q: BankQuestion) => {
-              const on = selected.has(q.id);
-              return (
-                <Card key={q.id} variant="outlined" sx={{ borderColor: on ? 'primary.main' : 'divider', borderWidth: on ? 2 : 1 }}>
-                  <CardActionArea onClick={() => toggle(q.id)}>
-                    <QuestionCrop q={q} />
-                    <CardContent sx={{ pb: 1.5 }}>
-                      <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', mb: 0.5 }}>
-                        <Typography variant="subtitle2" fontWeight={700}>Q{q.label ?? '?'}</Typography>
-                        {on ? <CheckCircleIcon color="primary" fontSize="small" /> : <RadioButtonUncheckedIcon color="disabled" fontSize="small" />}
-                      </Box>
-                      <Stack direction="row" spacing={0.5} flexWrap="wrap" useFlexGap sx={{ mb: 0.75 }}>
-                        <Chip size="small" label={`${q.max_marks ?? 0} marks`} />
-                        {q.answer_type && <Chip size="small" variant="outlined" label={q.answer_type} />}
-                        {q.spec_ref && <Chip size="small" color="info" label={q.spec_ref} />}
-                      </Stack>
-                      <Typography variant="caption" color="text.secondary" noWrap sx={{ display: 'block', textTransform: 'capitalize' }}>
-                        {[q.paper.subject, q.paper.title].filter(Boolean).join(' · ') || 'Untitled paper'}
-                      </Typography>
-                    </CardContent>
-                  </CardActionArea>
-                </Card>
-              );
-            })}
-          </Box>
-        </>
-      )}
-
-      <Dialog open={dialogOpen} onClose={() => !creating && setDialogOpen(false)} fullWidth maxWidth="sm">
-        <DialogTitle>Create custom paper</DialogTitle>
-        <DialogContent>
-          <Typography variant="body2" color="text.secondary" sx={{ mb: 2 }}>
-            {selected.size} question{selected.size === 1 ? '' : 's'} · {totalMarks} marks. This creates a new
-            template you can open in setup and use for marking.
-          </Typography>
-          <TextField
-            autoFocus
-            fullWidth
-            label="Paper title"
-            value={title}
-            onChange={(e) => setTitle(e.target.value)}
-            placeholder={`Custom paper — ${new Date().toISOString().slice(0, 10)}`}
-          />
-        </DialogContent>
-        <DialogActions>
-          <Button onClick={() => setDialogOpen(false)} disabled={creating}>Cancel</Button>
-          <Button variant="contained" onClick={create} disabled={creating} startIcon={creating ? <CircularProgress size={16} color="inherit" /> : undefined}>
-            {creating ? 'Creating…' : 'Create & open'}
-          </Button>
-        </DialogActions>
-      </Dialog>
-    </Container>
-  );
-};
-
-export default QuestionBankPage;

src/pages/exam/ResultsWidget.tsx

@@ -1,169 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { useNavigate } from 'react-router-dom';
-import {
-  Alert,
-  Box,
-  Button,
-  Card,
-  CardContent,
-  Chip,
-  CircularProgress,
-  MenuItem,
-  Stack,
-  TextField,
-  Typography,
-} from '@mui/material';
-import AssessmentIcon from '@mui/icons-material/Assessment';
-import PlayArrowIcon from '@mui/icons-material/PlayArrow';
-import TableChartIcon from '@mui/icons-material/TableChart';
-
-import { examRepository } from '../../services/exam/examRepository';
-import type { BatchResultsResponse, ExamTemplate, MarkingBatch } from '../../types/exam.types';
-
-interface ResultsWidgetProps {
-  classId: string;
-  className?: string;
-}
-
-function averageFromResults(results: BatchResultsResponse | null) {
-  const totals = (results?.results ?? [])
-    .map((row) => row.total)
-    .filter((value): value is number => typeof value === 'number');
-  if (!totals.length) return null;
-  return totals.reduce((sum, value) => sum + value, 0) / totals.length;
-}
-
-const ResultsWidget: React.FC<ResultsWidgetProps> = ({ classId, className }) => {
-  const navigate = useNavigate();
-  const [templates, setTemplates] = useState<ExamTemplate[]>([]);
-  const [batches, setBatches] = useState<MarkingBatch[]>([]);
-  const [latestResults, setLatestResults] = useState<BatchResultsResponse | null>(null);
-  const [selectedTemplateId, setSelectedTemplateId] = useState('');
-  const [loading, setLoading] = useState(true);
-  const [creating, setCreating] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const load = useCallback(async () => {
-    setLoading(true);
-    setError(null);
-    try {
-      const [nextTemplates, nextBatches] = await Promise.all([
-        examRepository.listTemplates(),
-        examRepository.listBatches(),
-      ]);
-      const classBatches = nextBatches
-        .filter((batch) => batch.class_id === classId)
-        .sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-      setTemplates(nextTemplates);
-      setSelectedTemplateId((current) => current || nextTemplates[0]?.id || '');
-      setBatches(classBatches);
-      setLatestResults(classBatches[0] ? await examRepository.getBatchResults(classBatches[0].id) : null);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setLoading(false);
-    }
-  }, [classId]);
-
-  useEffect(() => {
-    void load();
-  }, [load]);
-
-  const latestBatch = batches[0] ?? null;
-  const average = useMemo(() => averageFromResults(latestResults), [latestResults]);
-  const absent = latestResults?.results.filter((row) => row.status === 'absent' && row.total === null).length ?? 0;
-
-  const createBatch = async () => {
-    if (!selectedTemplateId) return;
-    setCreating(true);
-    setError(null);
-    try {
-      const template = templates.find((item) => item.id === selectedTemplateId);
-      const created = await examRepository.createBatch({
-        template_id: selectedTemplateId,
-        class_id: classId,
-        title: `${className || 'Class'} · ${template?.title || 'Exam'}`,
-      });
-      navigate(`/exam-marker/${created.id}/mark`);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setCreating(false);
-    }
-  };
-
-  return (
-    <Card variant="outlined" sx={{ mb: 2 }}>
-      <CardContent>
-        <Stack spacing={2}>
-          <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 1, flexWrap: 'wrap' }}>
-            <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
-              <AssessmentIcon color="primary" />
-              <Box>
-                <Typography variant="h6">Assessment results</Typography>
-                <Typography variant="caption" color="text.secondary">Last exam summary for this class</Typography>
-              </Box>
-            </Box>
-            {loading && <CircularProgress size={22} />}
-          </Box>
-
-          {error && <Alert severity="warning" onClose={() => setError(null)}>{error}</Alert>}
-
-          {latestBatch ? (
-            <Stack spacing={1.5}>
-              <Box>
-                <Typography variant="body2" fontWeight={700}>{latestBatch.title || 'Exam batch'}</Typography>
-                <Typography variant="caption" color="text.secondary">
-                  {new Date(latestBatch.created_at).toLocaleDateString('en-GB')}
-                </Typography>
-              </Box>
-              <Stack direction="row" spacing={1} flexWrap="wrap" useFlexGap>
-                <Chip size="small" color="primary" label={`Average ${average === null ? '—' : average.toFixed(1)}`} />
-                <Chip size="small" variant="outlined" label={`${latestResults?.results.length ?? 0} students`} />
-                <Chip size="small" color="warning" variant="outlined" label={`${absent} absent`} />
-              </Stack>
-              <Stack direction="row" spacing={1}>
-                <Button size="small" variant="contained" startIcon={<TableChartIcon />} onClick={() => navigate(`/exam-marker/${latestBatch.id}/results`)}>
-                  View results
-                </Button>
-                <Button size="small" variant="outlined" onClick={() => navigate(`/exam-marker/${latestBatch.id}/mark`)}>
-                  Continue marking
-                </Button>
-              </Stack>
-            </Stack>
-          ) : !loading ? (
-            <Typography variant="body2" color="text.secondary">
-              No exam batches have been created for this class yet.
-            </Typography>
-          ) : null}
-
-          <Stack direction={{ xs: 'column', sm: 'row' }} spacing={1} alignItems={{ xs: 'stretch', sm: 'center' }}>
-            <TextField
-              select
-              size="small"
-              label="Template"
-              value={selectedTemplateId}
-              onChange={(e) => setSelectedTemplateId(e.target.value)}
-              disabled={!templates.length || creating}
-              sx={{ minWidth: 260 }}
-            >
-              {templates.map((template) => (
-                <MenuItem key={template.id} value={template.id}>{template.title}</MenuItem>
-              ))}
-            </TextField>
-            <Button
-              variant="outlined"
-              startIcon={<PlayArrowIcon />}
-              onClick={createBatch}
-              disabled={!selectedTemplateId || creating}
-            >
-              {creating ? 'Creating…' : 'Create marking batch'}
-            </Button>
-          </Stack>
-        </Stack>
-      </CardContent>
-    </Card>
-  );
-};
-
-export default ResultsWidget;

src/pages/exam/bankCrops.ts

@@ -1,68 +0,0 @@
-// Client-side crop thumbnails for the question bank. A bank question carries `bounds` (x,y,w,h) in the
-// 780px stacked-page canvas space and a `page` number; the source PDF renders at that same 780px width
-// (pdfLoader), so a thumbnail is just the page image cropped to the bounds. Renders each template's PDF
-// once (cached) and reuses it for all of that template's questions. No API/infra change.
-import { examRepository } from '../../services/exam/examRepository';
-import { loadPdfPageImages, PdfPageImage } from './setup/pdfLoader';
-
-const renderCache = new Map<string, Promise<PdfPageImage[]>>();
-const imageCache = new Map<string, Promise<HTMLImageElement>>();
-
-function templateRender(templateId: string): Promise<PdfPageImage[]> {
-  let p = renderCache.get(templateId);
-  if (!p) {
-    p = examRepository.getTemplateSourcePdf(templateId).then((bytes) => loadPdfPageImages(bytes));
-    p.catch(() => renderCache.delete(templateId)); // let a failed render be retried
-    renderCache.set(templateId, p);
-  }
-  return p;
-}
-
-function loadImage(src: string): Promise<HTMLImageElement> {
-  let p = imageCache.get(src);
-  if (!p) {
-    p = new Promise<HTMLImageElement>((resolve, reject) => {
-      const img = new Image();
-      img.onload = () => resolve(img);
-      img.onerror = () => reject(new Error('image decode failed'));
-      img.src = src;
-    });
-    imageCache.set(src, p);
-  }
-  return p;
-}
-
-export interface CropInput {
-  templateId: string;
-  page: number | null;
-  bounds: Record<string, number> | null;
-}
-
-// Returns a PNG data-URL cropped to the question, or null if it can't be produced (no bounds/page/PDF).
-export async function cropQuestion(input: CropInput, maxWidth = 320): Promise<string | null> {
-  const { templateId, page, bounds } = input;
-  if (!bounds || !page) return null;
-  const pages = await templateRender(templateId);
-  const pageImg = pages.find((pg) => pg.pageNumber === page);
-  if (!pageImg) return null;
-
-  // stacked y-offset of this page (bounds.y is absolute across the vertically-stacked pages)
-  let yTop = 0;
-  for (const pg of pages) { if (pg.pageNumber === page) break; yTop += pg.height; }
-
-  const sx = Math.max(0, Math.round(bounds.x ?? 0));
-  const sy = Math.max(0, Math.round((bounds.y ?? 0) - yTop));
-  const sw = Math.min(Math.round(bounds.w ?? pageImg.width), pageImg.width - sx);
-  const sh = Math.min(Math.round(bounds.h ?? 80), pageImg.height - sy);
-  if (sw <= 1 || sh <= 1) return null;
-
-  const img = await loadImage(pageImg.src);
-  const scale = Math.min(1, maxWidth / sw);
-  const canvas = document.createElement('canvas');
-  canvas.width = Math.max(1, Math.round(sw * scale));
-  canvas.height = Math.max(1, Math.round(sh * scale));
-  const ctx = canvas.getContext('2d');
-  if (!ctx) return null;
-  ctx.drawImage(img, sx, sy, sw, sh, 0, 0, canvas.width, canvas.height);
-  return canvas.toDataURL('image/png');
-}

src/pages/exam/index.ts

@@ -1,8 +1,2 @@
 export { default as ExamDashboardPage } from './ExamDashboardPage';
-export { default as QuestionBankPage } from './QuestionBankPage';
-export { default as CorpusPage } from './CorpusPage';
 export { default as ExamTemplateSetupPage } from './setup/ExamTemplateSetupPage';
-export { default as MarkSchemePage } from './MarkSchemePage';
-export { default as ExamMarkingPage } from './ExamMarkingPage';
-export { default as ExamResultsPage } from './ExamResultsPage';
-export { default as ResultsWidget } from './ResultsWidget';

src/pages/exam/setup/ExamTemplateSetupPage.tsx

@@ -1,16 +1,18 @@
 
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useNavigate, useParams } from 'react-router-dom'
-import { Alert, Box, Button, Chip, CircularProgress, Collapse, Dialog, DialogContent, DialogTitle, Divider, IconButton, Paper, Snackbar, Stack, Tooltip, Typography, useTheme } from '@mui/material'
+import { Alert, Box, Button, Chip, CircularProgress, Divider, Paper, Snackbar, Stack, Tooltip, Typography, useTheme } from '@mui/material'
-import DescriptionIcon from '@mui/icons-material/Description'
 import ArrowBackIcon from '@mui/icons-material/ArrowBack'
-import HelpOutlineIcon from '@mui/icons-material/HelpOutline'
-import AutoFixHighIcon from '@mui/icons-material/AutoFixHigh'
 import SaveIcon from '@mui/icons-material/Save'
 import MouseIcon from '@mui/icons-material/Mouse'
-import CheckIcon from '@mui/icons-material/Check'
+import HorizontalRuleIcon from '@mui/icons-material/HorizontalRule'
-import CloseIcon from '@mui/icons-material/Close'
+import CropSquareIcon from '@mui/icons-material/CropSquare'
-import DoneAllIcon from '@mui/icons-material/DoneAll'
+import EditNoteIcon from '@mui/icons-material/EditNote'
+import VisibilityIcon from '@mui/icons-material/Visibility'
+import TagIcon from '@mui/icons-material/Tag'
+import GradingIcon from '@mui/icons-material/Grading'
+import AttachFileIcon from '@mui/icons-material/AttachFile'
+import HideSourceIcon from '@mui/icons-material/HideSource'
 import '@tldraw/tldraw/tldraw.css'
 import { Editor, Tldraw, createShapeId, TLShape } from '@tldraw/tldraw'
 import axios from 'axios'
@@ -18,29 +20,27 @@ import axios from 'axios'
 import { ErrorBoundary } from '../../../components/ErrorBoundary'
 import { logger } from '../../../debugConfig'
 import { examRepository } from '../../../services/exam/examRepository'
-import type { AutoMapJobStatus, DigitalTextResponse, ExamTemplateDetail } from '../../../types/exam.types'
+import type { ExamTemplateDetail } from '../../../types/exam.types'
-import { CanvasPageGeometry, ExamCanvasShapeModel, PAGE_HEIGHT, PAGE_WIDTH, isUuid, newDomainId, serializeCanvasShapes, shapesFromTemplate } from '../../../utils/exam-canvas/model'
+import { CanvasPageGeometry, ExamCanvasShapeModel, PAGE_HEIGHT, PAGE_WIDTH, isUuid, newDomainId, pageForY, serializeCanvasShapes, shapesFromTemplate } from '../../../utils/exam-canvas/model'
-import { PDF_PAGE_SHAPE_TYPE, canvasShapePalette, examCanvasShapeUtils, examCanvasTools, ExamCanvasTLShape, SHAPE_TYPES, isPdfPageShape, shapeTypeToKind } from './examCanvasShapes'
+import { PDF_PAGE_SHAPE_TYPE, examCanvasShapeUtils, examCanvasTools, ExamCanvasTLShape, SHAPE_TYPES, isPdfPageShape, shapeTypeToKind } from './examCanvasShapes'
 import { loadPdfPageImages, PdfPageImage } from './pdfLoader'
 
 const TOOLS = [
-  { id: 'select', label: 'Select', icon: '↖', tip: 'Move, resize, delete, or inspect the Attached pill on a region.', color: 'inherit' as const },
+  { id: 'select', label: 'Select', tip: 'Move, resize, delete, or inspect attachment pills.', color: 'inherit' as const, icon: <MouseIcon fontSize="small" /> },
-  { id: SHAPE_TYPES.boundary, label: 'Boundary', icon: canvasShapePalette.boundary.icon, tip: 'Draw Q start and Q end horizontal rules; an end rule on a later page creates a multi-page question span.', color: 'error' as const },
+  { id: SHAPE_TYPES.boundary, label: 'Boundary', tip: 'Place a top line, then a bottom line; the bottom can be on a later PDF page for multi-page questions.', color: 'error' as const, icon: <HorizontalRuleIcon fontSize="small" /> },
-  { id: SHAPE_TYPES.part, label: 'Part', icon: canvasShapePalette.part.icon, tip: 'Draw the markable sub-question box inside a boundary pair; it becomes the leaf question/part.', color: 'warning' as const },
+  { id: SHAPE_TYPES.part, label: 'Part', tip: 'Draw the markable sub-question box inside a boundary pair.', color: 'warning' as const, icon: <CropSquareIcon fontSize="small" /> },
-  { id: SHAPE_TYPES.response, label: 'Response', icon: canvasShapePalette.response.icon, tip: 'Draw around where the student writes; blue regions save as response areas.', color: 'primary' as const },
+  { id: SHAPE_TYPES.response, label: 'Response', tip: 'Draw around where the student writes; saved with response_form=lines.', color: 'primary' as const, icon: <EditNoteIcon fontSize="small" /> },
-  { id: SHAPE_TYPES.context, label: 'Context', icon: canvasShapePalette.context.icon, tip: 'Draw stimulus, figures, tables, or prompt text; purple dashed regions save as context.', color: 'secondary' as const },
+  { id: SHAPE_TYPES.context, label: 'Context', tip: 'Draw around stimulus/context material; saved with context_type=generic.', color: 'secondary' as const, icon: <VisibilityIcon fontSize="small" /> },
-  { id: SHAPE_TYPES.question_number, label: 'Q Number', icon: canvasShapePalette.question_number.icon, tip: 'Box the printed question number for OCR/structure extraction.', color: 'success' as const },
+  { id: SHAPE_TYPES.question_number, label: 'Q Number', tip: 'Box the printed question number for OCR and template checking.', color: 'success' as const, icon: <TagIcon fontSize="small" /> },
-  { id: SHAPE_TYPES.mark_area, label: 'Mark Area', icon: canvasShapePalette.mark_area.icon, tip: 'Box printed marks such as [2] or Total for Question text.', color: 'success' as const },
+  { id: SHAPE_TYPES.mark_area, label: 'Mark Area', tip: 'Box printed marks such as [2] or Total for Question X.', color: 'success' as const, icon: <GradingIcon fontSize="small" /> },
-  { id: SHAPE_TYPES.reference, label: 'Reference', icon: canvasShapePalette.reference.icon, tip: 'Box formulae, data sheets, appendices, or other resources the student may use.', color: 'info' as const },
+  { id: SHAPE_TYPES.reference, label: 'Reference', tip: 'Box formula sheets, data sheets, appendices, or other student resources.', color: 'info' as const, icon: <AttachFileIcon fontSize="small" /> },
-  { id: SHAPE_TYPES.furniture, label: 'Furniture', icon: canvasShapePalette.furniture.icon, tip: 'Mark page numbers, margins, blank space, or decoration to exclude from extraction.', color: 'inherit' as const },
+  { id: SHAPE_TYPES.furniture, label: 'Furniture', tip: 'Mark margins, page numbers, blank extra space, or decoration to ignore.', color: 'inherit' as const, icon: <HideSourceIcon fontSize="small" /> },
 ]
 
-const PAGE_START_X = 0
+const PAGE_START_X = 260
 const PDF_PAGE_IDS_PREFIX = 'pdf-page-'
 
 function pageGeometryFromImages(pages: PdfPageImage[]): CanvasPageGeometry[] {
-  // S5 coordinate contract: use the actual pdf.js raster dimensions that feed each page src.
-  // Server mapper emits canvas coordinates against the same PAGE_START_X=0 and stacked page heights.
   let y = 0
   return pages.map((page) => {
     const geometry = { pageNumber: page.pageNumber, x: PAGE_START_X, y, w: page.width, h: page.height }
@@ -49,22 +49,6 @@ function pageGeometryFromImages(pages: PdfPageImage[]): CanvasPageGeometry[] {
   })
 }
 
-function applyDocViewConstraints(editor: Editor, pages: PdfPageImage[]) {
-  const maxW = pages.length ? Math.max(...pages.map((p) => p.width)) : PAGE_WIDTH
-  const totalH = pages.reduce((sum, p) => sum + p.height, 0) || PAGE_HEIGHT
-  editor.setCameraOptions({
-    constraints: {
-      bounds: { x: -64, y: -64, w: maxW + 128, h: totalH + 128 },
-      padding: { x: 64, y: 64 },
-      origin: { x: 0.5, y: 0 },
-      initialZoom: 'fit-x-100',
-      baseZoom: 'default',
-      behavior: 'contain',
-    },
-    isLocked: false,
-  })
-}
-
 function apiMessage(err: unknown): { message: string; conflict: boolean } {
   if (axios.isAxiosError(err)) {
     const detail = (err.response?.data as { detail?: string } | undefined)?.detail
@@ -74,33 +58,6 @@ function apiMessage(err: unknown): { message: string; conflict: boolean } {
   return { conflict: false, message: err instanceof Error ? err.message : String(err) }
 }
 
-
-function reviewSummary(template: ExamTemplateDetail | null) {
-  if (!template) return { ai: 0, unconfirmed: 0, lowConfidence: 0 }
-  const rows = [...(template.questions ?? []), ...(template.response_areas ?? []), ...(template.boundaries ?? []), ...(template.layout ?? [])]
-  return rows.reduce((acc, row) => {
-    if (row.source === 'ai') acc.ai += 1
-    if (row.source === 'ai' && row.confirmed === false) acc.unconfirmed += 1
-    if (typeof row.confidence === 'number' && row.confidence < 0.7) acc.lowConfidence += 1
-    return acc
-  }, { ai: 0, unconfirmed: 0, lowConfidence: 0 })
-}
-
-// Live review counts read straight off the canvas shapes, so accept/reject update them immediately
-// (the template-derived reviewSummary only reflects the last *saved* state).
-function reviewFromShapes(editor: Editor | null) {
-  const acc = { ai: 0, unconfirmed: 0, lowConfidence: 0 }
-  if (!editor) return acc
-  for (const shape of editor.getCurrentPageShapes()) {
-    if (!shapeTypeToKind(shape.type)) continue
-    const p = (shape as ExamCanvasTLShape).props
-    if (p.source === 'ai') acc.ai += 1
-    if (p.source === 'ai' && p.confirmed === false) acc.unconfirmed += 1
-    if (typeof p.confidence === 'number' && p.confidence < 0.7) acc.lowConfidence += 1
-  }
-  return acc
-}
-
 function stripShapePrefix(id: string) {
   return id.startsWith('shape:') ? id.slice('shape:'.length) : id
 }
@@ -136,18 +93,9 @@ function modelFromTLShape(shape: TLShape): ExamCanvasShapeModel | null {
     responseForm: s.props.responseForm as ExamCanvasShapeModel['responseForm'],
     contextType: s.props.contextType,
     questionId: s.props.questionId ?? null,
-    source: s.props.source ?? 'manual',
-    confirmed: s.props.confirmed ?? s.props.source !== 'ai',
-    confidence: typeof s.props.confidence === 'number' ? s.props.confidence : null,
-    derivation: s.props.derivation ?? null,
   }
 }
 
-function bringDomainShapesToFront(editor: Editor) {
-  const ids = editor.getCurrentPageShapes().filter((s) => !!shapeTypeToKind(s.type)).map((s) => s.id)
-  if (ids.length) try { editor.bringToFront(ids as any) } catch { /* */ }
-}
-
 function loadShapes(editor: Editor, models: ExamCanvasShapeModel[]) {
   const existing = editor.getCurrentPageShapes().filter((s) => shapeTypeToKind(s.type)).map((s) => s.id)
   if (existing.length) editor.deleteShapes(existing)
@@ -157,7 +105,7 @@ function loadShapes(editor: Editor, models: ExamCanvasShapeModel[]) {
     type: SHAPE_TYPES[m.kind],
     x: m.x,
     y: m.y,
-    props: { w: m.w, h: m.h, label: m.label ?? m.kind, kind: m.kind, maxMarks: m.maxMarks, responseForm: m.responseForm, contextType: m.contextType, questionId: m.questionId, domainId: m.id, source: m.source ?? 'manual', confirmed: m.confirmed ?? m.source !== 'ai', confidence: m.confidence ?? undefined, derivation: m.derivation ?? undefined, reviewFlags: m.reviewFlags?.join('|') },
+    props: { w: m.w, h: m.h, label: m.label ?? m.kind, kind: m.kind, maxMarks: m.maxMarks, responseForm: m.responseForm, contextType: m.contextType, questionId: m.questionId, domainId: m.id },
   })))
 }
 
@@ -177,7 +125,29 @@ function syncPdfPages(editor: Editor, pages: PdfPageImage[]) {
       props: { w: geometry.w, h: geometry.h, src: page.src, pageNumber: geometry.pageNumber },
     } as any
   }))
-  // z-order is enforced by the caller via bringDomainShapesToFront
+  const ids = geometries.map((geometry) => createShapeId(PDF_PAGE_IDS_PREFIX + geometry.pageNumber))
+  try { editor.sendToBack(ids as any) } catch { /* tldraw 3 keeps creation order behind later region shapes */ }
+}
+
+type BoundaryPairSummary = { index: number; label: string; startPage: number; endPage: number; multiPage: boolean }
+
+function boundaryPairSummaries(editor: Editor | null, pages: CanvasPageGeometry[]): BoundaryPairSummary[] {
+  if (!editor) return []
+  const boundaries = editor.getCurrentPageShapes()
+    .map(modelFromTLShape)
+    .filter((shape): shape is ExamCanvasShapeModel => shape?.kind === 'boundary')
+    .sort((a, b) => (pageForY(a.y + a.h / 2, pages) - pageForY(b.y + b.h / 2, pages)) || (a.y - b.y))
+  const summaries: BoundaryPairSummary[] = []
+  for (let i = 0; i < boundaries.length; i += 2) {
+    const top = boundaries[i]
+    const bottom = boundaries[i + 1]
+    if (!top || !bottom) break
+    const startPage = pageForY(top.y + top.h / 2, pages)
+    const endPage = pageForY(bottom.y + bottom.h / 2, pages)
+    const label = top.label?.replace(/\s+(start|end)$/i, '') || bottom.label?.replace(/\s+(start|end)$/i, '') || `Q${summaries.length + 1}`
+    summaries.push({ index: summaries.length + 1, label, startPage, endPage, multiPage: startPage !== endPage })
+  }
+  return summaries
 }
 
 function seedGuide(editor: Editor) {
@@ -185,27 +155,12 @@ function seedGuide(editor: Editor) {
   if (current.length) return
   editor.createShapes([
     { id: createShapeId(newDomainId()), type: SHAPE_TYPES.boundary, x: 48, y: 120, props: { w: PAGE_WIDTH - 96, h: 8, kind: 'boundary', label: 'Q1 start', domainId: newDomainId() } },
-    { id: createShapeId(newDomainId()), type: SHAPE_TYPES.boundary, x: 48, y: PAGE_HEIGHT + 160, props: { w: PAGE_WIDTH - 96, h: 8, kind: 'boundary', label: 'Q1 end (page 2)', domainId: newDomainId() } },
+    { id: createShapeId(newDomainId()), type: SHAPE_TYPES.boundary, x: 48, y: 520, props: { w: PAGE_WIDTH - 96, h: 8, kind: 'boundary', label: 'Q1 end', domainId: newDomainId() } },
     { id: createShapeId(newDomainId()), type: SHAPE_TYPES.part, x: 92, y: 180, props: { w: 520, h: 150, kind: 'part', label: 'Q1(a)', maxMarks: 3, domainId: newDomainId() } },
     { id: createShapeId(newDomainId()), type: SHAPE_TYPES.response, x: 116, y: 355, props: { w: 470, h: 120, kind: 'response', label: 'Response', responseForm: 'lines', domainId: newDomainId() } },
-    { id: createShapeId(newDomainId()), type: SHAPE_TYPES.context, x: 116, y: 495, props: { w: 470, h: 90, kind: 'context', label: 'Context', contextType: 'generic', domainId: newDomainId() } },
   ])
 }
 
-
-function isAutoMapAccepted(value: unknown): value is { status: 'accepted'; job_id: string } {
-  return !!value && typeof value === 'object' && (value as { status?: string }).status === 'accepted' && typeof (value as { job_id?: unknown }).job_id === 'string'
-}
-
-function autoMapStatusLabel(status: AutoMapJobStatus | null): string {
-  if (!status) return 'Auto-map running'
-  if (status.status === 'queued') return 'Auto-map queued'
-  if (status.status === 'running') return 'Auto-map running'
-  if (status.status === 'completed') return 'Auto-map complete'
-  if (status.status === 'failed') return 'Auto-map failed'
-  return `Auto-map ${status.status}`
-}
-
 const ExamTemplateSetupInner: React.FC = () => {
   const { templateId } = useParams<{ templateId: string }>()
   const navigate = useNavigate()
@@ -221,71 +176,12 @@ const ExamTemplateSetupInner: React.FC = () => {
   const [activeTool, setActiveTool] = useState('select')
   const [pdfStatus, setPdfStatus] = useState<'loading' | 'ready' | 'missing' | 'error'>('loading')
   const [pdfError, setPdfError] = useState<string | null>(null)
-  const [guideOpen, setGuideOpen] = useState(false)
+  const [boundaryPairs, setBoundaryPairs] = useState<BoundaryPairSummary[]>([])
-  const [autoMapStatus, setAutoMapStatus] = useState<AutoMapJobStatus | null>(null)
-  const [autoMapBusy, setAutoMapBusy] = useState(false)
-  const [liveReview, setLiveReview] = useState({ ai: 0, unconfirmed: 0, lowConfidence: 0 })
-  const [digitalText, setDigitalText] = useState<DigitalTextResponse | null>(null)
-  const [digitalOpen, setDigitalOpen] = useState(false)
-  const [digitalBusy, setDigitalBusy] = useState(false)
-  const autoMapPollRef = useRef<number | null>(null)
 
-  const openDigitalText = useCallback(async () => {
+  const refreshBoundaryPairs = useCallback(() => {
-    if (!template) return
+    setBoundaryPairs(boundaryPairSummaries(editorRef.current, pageGeometriesRef.current))
-    setDigitalBusy(true); setDigitalOpen(true)
-    try {
-      setDigitalText(await examRepository.getDigitalText(template.id))
-    } catch (e) {
-      setDigitalText(null)
-      setError(e instanceof Error ? e.message : 'No digital text yet — run auto-map first.')
-      setDigitalOpen(false)
-    } finally {
-      setDigitalBusy(false)
-    }
-  }, [template])
-
-  const refreshReview = useCallback(() => setLiveReview(reviewFromShapes(editorRef.current)), [])
-
-  const applyTemplateToCanvas = useCallback((detail: ExamTemplateDetail) => {
-    setTemplate(detail)
-    const editor = editorRef.current
-    if (editor) {
-      const shapes = shapesFromTemplate(detail, pageGeometriesRef.current)
-      loadShapes(editor, shapes)
-      if (!shapes.length) seedGuide(editor)
-      bringDomainShapesToFront(editor)
-    }
-    setDirty(false)
   }, [])
 
-  const acceptShapes = useCallback((shapes: TLShape[]) => {
-    const editor = editorRef.current
-    if (!editor) return
-    const updates = shapes
-      .filter((s) => !!shapeTypeToKind(s.type) && (s as ExamCanvasTLShape).props.source === 'ai' && (s as ExamCanvasTLShape).props.confirmed === false)
-      .map((s) => ({ id: s.id, type: s.type, props: { confirmed: true } }))
-    if (updates.length) { editor.updateShapes(updates as any); refreshReview(); setDirty(true) }
-  }, [refreshReview])
-
-  const selectedDomainShapes = useCallback((): TLShape[] => {
-    const editor = editorRef.current
-    if (!editor) return []
-    return editor.getSelectedShapeIds().map((id) => editor.getShape(id)).filter((s): s is TLShape => !!s && !!shapeTypeToKind(s.type))
-  }, [])
-
-  const acceptSelected = useCallback(() => acceptShapes(selectedDomainShapes()), [acceptShapes, selectedDomainShapes])
-  const acceptAllAi = useCallback(() => { const ed = editorRef.current; if (ed) acceptShapes(ed.getCurrentPageShapes()) }, [acceptShapes])
-  const rejectSelected = useCallback(() => {
-    const editor = editorRef.current
-    if (!editor) return
-    const ids = selectedDomainShapes().map((s) => s.id)
-    if (ids.length) { editor.deleteShapes(ids); refreshReview(); setDirty(true) }
-  }, [refreshReview, selectedDomainShapes])
-
-  // Displayed counts come live from the canvas so accept/reject reflect immediately (falls back to the
-  // saved-template summary only for the brief moment before shapes have mounted).
-  const review = (liveReview.ai || liveReview.unconfirmed) ? liveReview : reviewSummary(template)
-
   const load = useCallback(async () => {
     if (!templateId) return
     setLoading(true); setError(null); setConflict(null)
@@ -297,22 +193,7 @@ const ExamTemplateSetupInner: React.FC = () => {
       setPdfError(null)
       try {
         const bytes = await examRepository.getTemplateSourcePdf(templateId)
-        pages = await loadPdfPageImages(bytes, undefined, (partialPages) => {
+        pages = await loadPdfPageImages(bytes)
-          const newPage = partialPages[partialPages.length - 1]
-          const allGeometries = pageGeometryFromImages(partialPages)
-          pageGeometriesRef.current = allGeometries
-          const ed = editorRef.current
-          if (ed) {
-            const geometry = allGeometries[partialPages.length - 1]
-            const shapeId = createShapeId(PDF_PAGE_IDS_PREFIX + newPage.pageNumber)
-            if (!ed.getCurrentPageShapes().find((s) => s.id === shapeId)) {
-              ed.createShapes([{ id: shapeId, type: PDF_PAGE_SHAPE_TYPE, x: geometry.x, y: geometry.y, isLocked: true, props: { w: geometry.w, h: geometry.h, src: newPage.src, pageNumber: newPage.pageNumber } } as any])
-              bringDomainShapesToFront(ed)
-            }
-            applyDocViewConstraints(ed, partialPages)
-          }
-          setPdfStatus('ready')
-        })
         setPdfStatus(pages.length ? 'ready' : 'missing')
       } catch (pdfErr) {
         const pdfMsg = apiMessage(pdfErr).message
@@ -326,9 +207,9 @@ const ExamTemplateSetupInner: React.FC = () => {
       if (editor) {
         syncPdfPages(editor, pages)
         loadShapes(editor, shapesFromTemplate(detail, geometries))
-        bringDomainShapesToFront(editor)
+        setBoundaryPairs(boundaryPairSummaries(editor, geometries))
-        applyDocViewConstraints(editor, pages)
+      } else {
-        editor.resetZoom()
+        setBoundaryPairs([])
       }
       setDirty(false)
     } catch (e) {
@@ -338,66 +219,10 @@ const ExamTemplateSetupInner: React.FC = () => {
     } finally {
       setLoading(false)
     }
-  }, [templateId])
+  }, [templateId, refreshBoundaryPairs])
 
   useEffect(() => { void load() }, [load])
 
-  useEffect(() => () => {
-    if (autoMapPollRef.current !== null) window.clearTimeout(autoMapPollRef.current)
-  }, [])
-
-  const pollAutoMapStatus = useCallback(async (jobId: string) => {
-    if (!templateId) return
-    try {
-      const status = await examRepository.getAutoMapStatus(templateId, jobId)
-      setAutoMapStatus(status)
-      if (status.status === 'completed') {
-        if (autoMapPollRef.current !== null) window.clearTimeout(autoMapPollRef.current)
-        autoMapPollRef.current = null
-        setAutoMapBusy(false)
-        const detail = status.template ?? await examRepository.getTemplate(templateId)
-        applyTemplateToCanvas(detail)
-        return
-      }
-      if (status.status === 'failed') {
-        if (autoMapPollRef.current !== null) window.clearTimeout(autoMapPollRef.current)
-        autoMapPollRef.current = null
-        setAutoMapBusy(false)
-        setError(status.error ?? 'Auto-map failed; existing template state was preserved.')
-        return
-      }
-      autoMapPollRef.current = window.setTimeout(() => void pollAutoMapStatus(jobId), 2500)
-    } catch (e) {
-      const msg = apiMessage(e).message
-      setAutoMapBusy(false)
-      setError(msg)
-      logger.warn('cc-exam-marker', 'Auto-map status poll failed', { templateId, jobId, message: msg })
-    }
-  }, [applyTemplateToCanvas, templateId])
-
-  const autoMapFromPdf = useCallback(async () => {
-    if (!templateId || autoMapBusy) return
-    let queued = false
-    setAutoMapBusy(true); setAutoMapStatus(null); setError(null); setConflict(null)
-    try {
-      const result = await examRepository.autoMapTemplate(templateId)
-      if (isAutoMapAccepted(result)) {
-        queued = true
-        setAutoMapStatus({ job_id: result.job_id, status: 'queued', template_id: templateId })
-        await pollAutoMapStatus(result.job_id)
-        return
-      }
-      setAutoMapStatus(null)
-      applyTemplateToCanvas(result)
-    } catch (e) {
-      const msg = apiMessage(e)
-      if (msg.conflict) setConflict(msg.message); else setError(msg.message)
-      logger.warn('cc-exam-marker', 'Auto-map request failed', { templateId, message: msg.message })
-    } finally {
-      if (!queued) setAutoMapBusy(false)
-    }
-  }, [applyTemplateToCanvas, autoMapBusy, pollAutoMapStatus, templateId])
-
   const save = useCallback(async () => {
     const editor = editorRef.current
     if (!editor || !templateId || !template) return
@@ -409,6 +234,7 @@ const ExamTemplateSetupInner: React.FC = () => {
       const saved = await examRepository.replaceTemplate(templateId, payload)
       setTemplate(saved)
       loadShapes(editor, shapesFromTemplate(saved, pageGeometriesRef.current))
+      refreshBoundaryPairs()
       setDirty(false)
     } catch (e) {
       const msg = apiMessage(e)
@@ -417,12 +243,7 @@ const ExamTemplateSetupInner: React.FC = () => {
     } finally {
       setSaving(false)
     }
-  }, [template, templateId])
+  }, [template, templateId, refreshBoundaryPairs])
-
-  const layoutSummary = useMemo(() => {
-    const rows = (template?.layout ?? []).filter((row) => row.margins_enabled && row.margin_left !== null && row.margin_right !== null)
-    return rows.slice(0, 4).map((row) => `P${row.page_index + 1} ${row.role ?? 'page'} L${Math.round(row.margin_left ?? 0)} R${Math.round(row.margin_right ?? 0)} T${Math.round(row.margin_top ?? 0)} B${Math.round(row.margin_bottom ?? 0)}`)
-  }, [template?.layout])
 
   const toolButtons = useMemo(() => TOOLS.map((tool) => (
     <Tooltip title={tool.tip} key={tool.id} placement="right">
@@ -430,7 +251,7 @@ const ExamTemplateSetupInner: React.FC = () => {
         size="small"
         variant={activeTool === tool.id ? 'contained' : 'outlined'}
         color={tool.color}
-        startIcon={tool.id === 'select' ? <MouseIcon fontSize="small" /> : <Box component="span" sx={{ minWidth: 22, textAlign: 'center', fontWeight: 900 }}>{tool.icon}</Box>}
+        startIcon={tool.icon}
         onClick={() => {
           const editor = editorRef.current
           if (!editor) return
@@ -444,39 +265,93 @@ const ExamTemplateSetupInner: React.FC = () => {
     </Tooltip>
   )), [activeTool])
 
+  const canvasCss = {
+    '& .tlui-layout': { display: 'none' },
+    '& .exam-canvas-shape': {
+      width: '100%',
+      height: '100%',
+      boxSizing: 'border-box',
+      position: 'relative',
+      border: '2px var(--exam-shape-border-style) var(--exam-shape-stroke)',
+      borderRadius: 'var(--exam-shape-radius)',
+      background: 'var(--exam-shape-fill)',
+      color: 'var(--exam-shape-stroke)',
+      fontFamily: 'Inter, system-ui, sans-serif',
+      display: 'flex',
+      alignItems: 'flex-start',
+      justifyContent: 'space-between',
+      gap: 0.75,
+      padding: 1,
+      boxShadow: '0 10px 22px rgba(15,23,42,0.10)',
+      overflow: 'hidden',
+    },
+    '& .exam-canvas-shape--boundary': {
+      alignItems: 'center',
+      justifyContent: 'center',
+      height: '100%',
+      minHeight: 8,
+      padding: '0 64px',
+      background: 'transparent',
+      boxShadow: 'none',
+    },
+    '& .exam-canvas-shape__main-label': {
+      fontSize: 12,
+      fontWeight: 900,
+      textTransform: 'uppercase',
+      letterSpacing: 0.6,
+      background: 'rgba(255,255,255,0.90)',
+      border: '1px solid rgba(15,23,42,0.12)',
+      borderRadius: 999,
+      padding: '2px 8px',
+      display: 'inline-flex',
+      alignItems: 'center',
+      gap: 0.5,
+      lineHeight: 1.2,
+    },
+    '& .exam-canvas-shape__icon': { minWidth: 14, textAlign: 'center' },
+    '& .exam-canvas-shape__badge': {
+      fontSize: 10,
+      fontWeight: 800,
+      letterSpacing: 0.7,
+      textTransform: 'uppercase',
+      background: 'rgba(255,255,255,0.68)',
+      borderRadius: 999,
+      padding: '2px 7px',
+      color: 'inherit',
+    },
+    '& .exam-canvas-shape__endcap': {
+      position: 'absolute',
+      top: '50%',
+      transform: 'translateY(-50%)',
+      fontSize: 11,
+      fontWeight: 900,
+      borderRadius: 999,
+      padding: '1px 7px',
+      background: 'var(--exam-shape-stroke)',
+      color: '#fff',
+      boxShadow: '0 2px 8px rgba(0,0,0,0.16)',
+    },
+    '& .exam-canvas-shape__endcap--left': { left: 6 },
+    '& .exam-canvas-shape__endcap--right': { right: 6 },
+    ...(theme.palette.mode === 'dark' ? {
+      '& .exam-canvas-shape': {
+        borderColor: 'var(--exam-shape-stroke-dark)',
+        background: 'var(--exam-shape-fill-dark)',
+        color: 'var(--exam-shape-stroke-dark)',
+        boxShadow: '0 10px 22px rgba(0,0,0,0.28)',
+      },
+      '& .exam-canvas-shape--boundary': { background: 'transparent', boxShadow: 'none' },
+      '& .exam-canvas-shape__main-label, & .exam-canvas-shape__badge': {
+        background: 'rgba(15,23,42,0.84)',
+        borderColor: 'rgba(255,255,255,0.16)',
+      },
+      '& .exam-canvas-shape__endcap': { background: 'var(--exam-shape-stroke-dark)', color: '#0f172a' },
+    } : {}),
+  }
+
   return (
-    <Box sx={{ position: 'fixed', inset: 0, zIndex: (t) => t.zIndex.drawer + 20, bgcolor: 'background.default', display: 'flex', flexDirection: 'column' }}>
+    <Box sx={{ position: 'fixed', inset: 0, zIndex: (t) => t.zIndex.drawer + 20, bgcolor: 'background.default' }}>
-
+      <Box sx={{ position: 'absolute', inset: 0, ...canvasCss }} data-testid="exam-template-setup-canvas">
-      {/* Top bar — single compact line */}
-      <Paper elevation={8} sx={{ px: 1.5, py: 0.75, display: 'flex', alignItems: 'center', gap: 1, bgcolor: 'background.paper', borderRadius: 0, flexShrink: 0 }}>
-        <Tooltip title="Back to exam marker">
-          <IconButton onClick={() => navigate('/exam-marker')} size="small"><ArrowBackIcon fontSize="small" /></IconButton>
-        </Tooltip>
-        <Divider orientation="vertical" flexItem />
-        <Typography variant="subtitle2" noWrap sx={{ flex: 1, minWidth: 0 }}>{template?.title ?? 'Template setup'}</Typography>
-        <Chip size="small" color={review.unconfirmed ? 'warning' : review.ai ? 'info' : 'default'} label={review.ai ? `AI review: ${review.unconfirmed} unconfirmed · ${review.lowConfidence} low conf` : 'Manual template'} />
-        <Chip size="small" color={dirty ? 'warning' : 'success'} label={dirty ? 'Unsaved' : 'Saved'} />
-        {(autoMapBusy || autoMapStatus) && <Chip size="small" color={autoMapStatus?.status === 'failed' ? 'error' : autoMapStatus?.status === 'completed' ? 'success' : 'info'} label={autoMapStatusLabel(autoMapStatus)} />}
-        {(() => {
-          const a = (template as (ExamTemplateDetail & { extraction_meta?: { audit?: { status?: string; cover_total?: number; detected_total?: number } } }) | null)?.extraction_meta?.audit
-          return a?.status ? <Tooltip title="Extraction cover-total reconciliation (detected vs printed maximum)"><Chip size="small" color={a.status === 'ok' ? 'success' : 'warning'} label={`Marks ${a.detected_total ?? '?'}/${a.cover_total ?? '?'}`} /></Tooltip> : null
-        })()}
-        <Button size="small" variant="outlined" startIcon={digitalBusy ? <CircularProgress size={14} /> : <DescriptionIcon fontSize="small" />} onClick={openDigitalText} disabled={digitalBusy || !template}>Digital text</Button>
-        <Button size="small" variant="outlined" startIcon={autoMapBusy ? <CircularProgress size={14} /> : <AutoFixHighIcon fontSize="small" />} onClick={autoMapFromPdf} disabled={autoMapBusy || saving || loading || !template || pdfStatus !== 'ready'}>Auto-map from PDF</Button>
-        <Button size="small" variant="contained" startIcon={saving ? <CircularProgress size={14} color="inherit" /> : <SaveIcon fontSize="small" />} onClick={save} disabled={saving || loading || !template}>Save</Button>
-      </Paper>
-
-      {/* Body row */}
-      <Box sx={{ flex: 1, display: 'flex', overflow: 'hidden' }}>
-
-        {/* Left tool sidebar */}
-        <Paper elevation={4} sx={{ width: 160, flexShrink: 0, p: 1.25, borderRadius: 0, bgcolor: 'background.paper', overflowY: 'auto', display: 'flex', flexDirection: 'column', borderRight: 1, borderColor: 'divider' }}>
-          <Stack spacing={1}>{toolButtons}</Stack>
-        </Paper>
-
-        {/* Canvas area */}
-        <Box sx={{ flex: 1, position: 'relative', overflow: 'hidden' }} data-testid="exam-template-setup-canvas">
-          <Box sx={{ position: 'absolute', inset: 0, '& .tlui-layout': { display: 'none' } }}>
         <Tldraw
           shapeUtils={examCanvasShapeUtils as any}
           tools={examCanvasTools as any}
@@ -486,121 +361,56 @@ const ExamTemplateSetupInner: React.FC = () => {
           onMount={(editor) => {
             editorRef.current = editor
             editor.user.updateUserPreferences({ colorScheme: theme.palette.mode === 'dark' ? 'dark' : 'light' })
-                editor.store.listen(() => { setDirty(true); refreshReview() }, { scope: 'document' })
+            editor.store.listen(() => { setDirty(true); refreshBoundaryPairs() }, { scope: 'document' })
-                // Treat a user nudge/resize of an AI ghost as implicit confirmation (R3.3): a teacher who
+            if (template) loadShapes(editor, shapesFromTemplate(template, pageGeometriesRef.current)); else seedGuide(editor)
-                // adjusts a suggestion has reviewed it. Only geometry edits count, so the confirmed-only
+            refreshBoundaryPairs()
-                // update below can't recurse.
-                editor.store.listen((entry) => {
-                  try {
-                    const updates: Array<{ id: TLShape['id']; type: string; props: { confirmed: boolean } }> = []
-                    for (const rec of Object.values(entry.changes.updated)) {
-                      const [from, to] = rec as [any, any]
-                      if (!to || to.typeName !== 'shape' || !shapeTypeToKind(to.type)) continue
-                      if (to.props?.source !== 'ai' || to.props?.confirmed !== false) continue
-                      const moved = from.x !== to.x || from.y !== to.y || from.props?.w !== to.props?.w || from.props?.h !== to.props?.h
-                      if (moved) updates.push({ id: to.id, type: to.type, props: { confirmed: true } })
-                    }
-                    if (updates.length) editor.updateShapes(updates as any)
-                  } catch { /* non-fatal: implicit-confirm is best-effort */ }
-                }, { scope: 'document', source: 'user' })
-                applyDocViewConstraints(editor, [])
-                editor.resetZoom()
-                // Only seed the example guide for a genuinely-empty template AFTER it has loaded.
-                // (Previously `else seedGuide` fired on mount while `template` was still null during
-                // the async fetch, flashing placeholder shapes before the real shapes/PDF rendered.)
-                if (template) {
-                  const s = shapesFromTemplate(template, pageGeometriesRef.current)
-                  loadShapes(editor, s)
-                  if (!s.length) seedGuide(editor)
-                }
-                bringDomainShapesToFront(editor)
           }}
         />
       </Box>
 
-          {/* AI review actions — appears while there are unconfirmed suggestions to resolve */}
+      <Paper elevation={8} sx={{ position: 'absolute', top: 12, left: 12, right: 12, px: 2, py: 1.25, display: 'flex', alignItems: 'center', gap: 1.5, borderRadius: 3, bgcolor: 'background.paper' }}>
-          {review.unconfirmed > 0 && (
+        <Button startIcon={<ArrowBackIcon />} onClick={() => navigate('/exam-marker')} size="small">Back</Button>
-            <Paper elevation={6} sx={{ position: 'absolute', left: 16, bottom: 16, zIndex: 1002, px: 1, py: 0.75, borderRadius: 2, bgcolor: 'background.paper', display: 'flex', alignItems: 'center', gap: 0.75 }}>
+        <Divider orientation="vertical" flexItem />
-              <Chip size="small" color="warning" label={`${review.unconfirmed} AI unconfirmed`} sx={{ fontWeight: 700 }} />
+        <Box sx={{ minWidth: 0, flex: 1 }}>
-              <Tooltip title="Accept the selected AI suggestions (nudging one also confirms it)">
+          <Typography variant="subtitle1" noWrap>{template?.title ?? 'Template setup'}</Typography>
-                <span><Button size="small" color="success" startIcon={<CheckIcon fontSize="small" />} onClick={acceptSelected}>Accept</Button></span>
+          <Typography variant="caption" color="text.secondary">Exam Marker › Setup · draw boundaries, part boxes, and regions; Save persists a full replace.</Typography>
-              </Tooltip>
+        </Box>
-              <Tooltip title="Reject (delete) the selected shapes">
+        <Chip size="small" color={dirty ? 'warning' : 'success'} label={dirty ? 'Unsaved' : 'Saved'} />
-                <span><Button size="small" color="error" startIcon={<CloseIcon fontSize="small" />} onClick={rejectSelected}>Reject</Button></span>
+        <Button variant="contained" startIcon={saving ? <CircularProgress size={16} color="inherit" /> : <SaveIcon />} onClick={save} disabled={saving || loading || !template}>Save</Button>
-              </Tooltip>
-              <Tooltip title="Accept every AI suggestion on the page">
-                <span><Button size="small" variant="contained" startIcon={<DoneAllIcon fontSize="small" />} onClick={acceptAllAi}>Accept all</Button></span>
-              </Tooltip>
       </Paper>
-          )}
 
-          {/* Guide toggle */}
+      <Paper elevation={8} sx={{ position: 'absolute', top: 92, left: 12, p: 1.25, borderRadius: 3, bgcolor: 'background.paper' }}>
-          <Tooltip title={guideOpen ? 'Hide guide' : 'Show setup guide'} placement="left">
+        <Stack spacing={1}>{toolButtons}</Stack>
-            <IconButton onClick={() => setGuideOpen((v) => !v)} size="small" sx={{ position: 'absolute', right: 16, bottom: 16, zIndex: 1001, bgcolor: 'background.paper', boxShadow: 2, '&:hover': { bgcolor: 'background.paper' } }}>
+      </Paper>
-              <HelpOutlineIcon fontSize="small" color={guideOpen ? 'primary' : 'action'} />
-            </IconButton>
-          </Tooltip>
 
-          {/* Guide panel — collapsible */}
+      <Paper elevation={4} sx={{ position: 'absolute', right: 16, bottom: 16, maxWidth: 460, p: 2, borderRadius: 3, bgcolor: 'background.paper' }}>
-          <Collapse in={guideOpen} sx={{ position: 'absolute', right: 16, bottom: 48, zIndex: 1000, maxWidth: 440 }}>
-            <Paper elevation={4} sx={{ p: 2, borderRadius: 3, bgcolor: 'background.paper' }}>
         <Typography variant="subtitle2" gutterBottom>Setup guide</Typography>
-              <Typography variant="body2" color="text.secondary" sx={{ mb: 1 }}>
+        <Typography variant="body2" color="text.secondary">
-                1) Boundary start/end lines define each main question. 2) Draw amber Part boxes for markable sub-questions. 3) AI suggestions render dashed/translucent with confidence and cheap review flags; manual shapes stay solid.
+          Start with boundaries: place the top line, then the bottom line. If a question continues, scroll to the later page and place the bottom boundary there. Next draw Part boxes, then Response/Context/metadata regions; Save links regions by spatial containment.
         </Typography>
-              <Alert severity={review.unconfirmed || review.lowConfidence ? 'warning' : 'info'} variant="outlined" sx={{ my: 1 }}>
+        <Stack direction="row" spacing={0.75} flexWrap="wrap" useFlexGap sx={{ mt: 1 }}>
-                Review layer: {review.ai} AI suggestions, {review.unconfirmed} unconfirmed, {review.lowConfidence} below 70% confidence. Cheap flags include overlap, missing marks, uncertain labels, low confidence, and unconfirmed AI.
+          <Chip size="small" color="error" variant="outlined" label="Boundary = paired red lines" />
-              </Alert>
+          <Chip size="small" color="warning" variant="outlined" label="Part = amber markable box" />
-              <Stack direction="row" spacing={0.75} useFlexGap flexWrap="wrap" sx={{ my: 1 }}>
+          <Chip size="small" color="primary" variant="outlined" label="Response = blue writing area" />
-                {(['boundary', 'part', 'response', 'context', 'question_number', 'mark_area', 'reference', 'furniture'] as const).map((kind) => {
+          <Chip size="small" color="secondary" variant="outlined" label="Context = purple stimulus" />
-                  const p = canvasShapePalette[kind]
-                  return <Chip key={kind} size="small" label={`${p.icon} ${p.label}`} sx={{ borderColor: p.stroke, color: p.stroke, bgcolor: p.fill, fontWeight: 700 }} variant="outlined" />
-                })}
         </Stack>
-              <Divider sx={{ my: 1 }} />
+        <Box sx={{ mt: 1.25, p: 1, borderRadius: 2, bgcolor: (t) => t.palette.mode === 'dark' ? 'rgba(248,113,113,0.12)' : 'rgba(239,68,68,0.06)', border: '1px dashed', borderColor: 'error.main' }}>
-              <Typography variant="caption" color="text.secondary" display="block">Multi-page boundary pairing</Typography>
+          <Typography variant="caption" sx={{ fontWeight: 800, display: 'block' }}>Boundary pairing preview</Typography>
-              <Typography variant="body2" sx={{ fontWeight: 700 }}>Draw "Q start" on page N, then "Q end" on a later page; save pairs boundaries by reading order into one question span.</Typography>
+          {boundaryPairs.length ? boundaryPairs.slice(0, 4).map((pair) => (
-              <Typography variant="caption" color={pdfStatus === 'ready' ? 'success.main' : pdfStatus === 'error' ? 'error.main' : 'text.secondary'} sx={{ display: 'block', mt: 1 }}>
+            <Typography key={`${pair.index}-${pair.label}`} variant="caption" color={pair.multiPage ? 'warning.main' : 'text.secondary'} sx={{ display: 'block' }}>
-                PDF: {pdfStatus === 'ready' ? 'loaded' : pdfStatus === 'loading' ? 'loading…' : pdfStatus === 'missing' ? 'no source PDF' : pdfError ?? 'failed'}
+              {pair.label}: p{pair.startPage} top → p{pair.endPage} bottom{pair.multiPage ? ' · multi-page span' : ''}
             </Typography>
-              <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mt: 1 }}>
+          )) : (
-                Margins: {layoutSummary.length ? layoutSummary.join(' · ') : 'not detected yet'}
+            <Typography variant="caption" color="text.secondary" sx={{ display: 'block' }}>Draw two Boundary lines to preview the saved question span.</Typography>
+          )}
+        </Box>
+        <Typography variant="caption" color={pdfStatus === 'ready' ? 'success.main' : pdfStatus === 'error' ? 'error.main' : 'text.secondary'} sx={{ display: 'block', mt: 1 }}>
+          PDF backdrop: {pdfStatus === 'ready' ? 'loaded and locked behind regions' : pdfStatus === 'loading' ? 'loading…' : pdfStatus === 'missing' ? 'no source PDF for this template' : pdfError ?? 'failed to load'}
         </Typography>
       </Paper>
-          </Collapse>
 
-          {/* Conflict alert */}
+      {loading && <Box sx={{ position: 'absolute', inset: 0, display: 'grid', placeItems: 'center', bgcolor: 'rgba(15,23,42,.18)' }}><CircularProgress /></Box>}
-          {conflict && <Alert severity="warning" sx={{ position: 'absolute', top: 16, right: 16, maxWidth: 560, zIndex: 1001 }} onClose={() => setConflict(null)}>{conflict}</Alert>}
+      {conflict && <Alert severity="warning" sx={{ position: 'absolute', top: 86, right: 16, maxWidth: 560 }} onClose={() => setConflict(null)}>{conflict}</Alert>}
-        </Box>
-      </Box>
-
-      {loading && <Box sx={{ position: 'absolute', inset: 0, display: 'grid', placeItems: 'center', bgcolor: 'rgba(15,23,42,.18)', zIndex: 10 }}><CircularProgress /></Box>}
-      <Dialog open={digitalOpen} onClose={() => setDigitalOpen(false)} maxWidth="md" fullWidth>
-        <DialogTitle sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
-          <DescriptionIcon fontSize="small" />
-          Digital text
-          {digitalText && <Typography component="span" variant="body2" color="text.secondary">— {digitalText.title} · {digitalText.n_questions}Q · {digitalText.total_marks} marks</Typography>}
-          <Box sx={{ flex: 1 }} />
-          {digitalText && (
-            <Tooltip title="Download markdown">
-              <IconButton size="small" onClick={() => {
-                const blob = new Blob([digitalText.markdown], { type: 'text/markdown' })
-                const url = URL.createObjectURL(blob); const a = document.createElement('a')
-                a.href = url; a.download = `${digitalText.slug}.md`; a.click(); URL.revokeObjectURL(url)
-              }}><SaveIcon fontSize="small" /></IconButton>
-            </Tooltip>
-          )}
-        </DialogTitle>
-        <DialogContent dividers>
-          {digitalBusy ? (
-            <Box sx={{ display: 'flex', justifyContent: 'center', py: 4 }}><CircularProgress /></Box>
-          ) : digitalText ? (
-            <Box component="pre" sx={{ whiteSpace: 'pre-wrap', wordBreak: 'break-word', fontFamily: 'ui-monospace, SFMono-Regular, Menlo, monospace', fontSize: 13, m: 0 }}>{digitalText.markdown}</Box>
-          ) : (
-            <Typography variant="body2" color="text.secondary">No digital text available.</Typography>
-          )}
-        </DialogContent>
-      </Dialog>
       <Snackbar open={!!error} autoHideDuration={8000} onClose={() => setError(null)}><Alert severity="error" onClose={() => setError(null)}>{error}</Alert></Snackbar>
     </Box>
   )

src/pages/exam/setup/examCanvasShapes.tsx

@@ -1,10 +1,7 @@
 
 import React from 'react'
-import { BaseBoxShapeTool, BaseBoxShapeUtil, Edge2d, HTMLContainer, ShapeUtil, T, TLBaseBoxShape, Vec, toDomPrecision } from '@tldraw/tldraw'
+import { BaseBoxShapeTool, BaseBoxShapeUtil, HTMLContainer, T, TLBaseBoxShape, toDomPrecision } from '@tldraw/tldraw'
-import type { TLHandle } from '@tldraw/tldraw'
-import { PAGE_WIDTH } from '../../../utils/exam-canvas/model'
 import type { ExamCanvasRegionKind, ExamCanvasShapeKind } from '../../../utils/exam-canvas/model'
-import type { ExamTemplateSource } from '../../../types/exam.types'
 
 export const PDF_PAGE_SHAPE_TYPE = 'exam-pdf-page'
 
@@ -36,157 +33,56 @@ export type ExamCanvasTLShape = TLBaseBoxShape & {
     contextType?: string
     questionId?: string | null
     domainId?: string
-    source?: 'manual' | 'ai'
-    confirmed?: boolean
-    confidence?: number | null
-    derivation?: string | null
-    reviewFlags?: string
   }
 }
 
-type CanvasPaletteEntry = {
+const palette: Record<ExamCanvasShapeKind, { stroke: string; strokeDark: string; fill: string; fillDark: string; dash?: string; label: string; icon: string; badge: string }> = {
-  stroke: string
+  boundary: { stroke: '#dc2626', strokeDark: '#f87171', fill: 'rgba(239,68,68,0.06)', fillDark: 'rgba(248,113,113,0.12)', dash: '12 7', label: 'Boundary', icon: '↕', badge: 'TOP / BOTTOM' },
-  fill: string
+  part: { stroke: '#d97706', strokeDark: '#fbbf24', fill: 'rgba(245,158,11,0.18)', fillDark: 'rgba(251,191,36,0.26)', label: 'Part', icon: '□', badge: 'MARKABLE BOX' },
-  darkStroke: string
+  response: { stroke: '#2563eb', strokeDark: '#60a5fa', fill: 'rgba(37,99,235,0.17)', fillDark: 'rgba(96,165,250,0.32)', label: 'Response', icon: '✎', badge: 'STUDENT WRITES' },
-  darkFill: string
+  context: { stroke: '#7c3aed', strokeDark: '#c4b5fd', fill: 'rgba(124,58,237,0.14)', fillDark: 'rgba(167,139,250,0.28)', dash: '7 5', label: 'Context', icon: '◌', badge: 'STIMULUS' },
-  dash?: string
+  question_number: { stroke: '#0f766e', strokeDark: '#5eead4', fill: 'rgba(15,118,110,0.15)', fillDark: 'rgba(45,212,191,0.24)', label: 'Question #', icon: '#', badge: 'OCR LABEL' },
-  label: string
+  mark_area: { stroke: '#16a34a', strokeDark: '#86efac', fill: 'rgba(22,163,74,0.15)', fillDark: 'rgba(74,222,128,0.24)', label: 'Mark Area', icon: '✓', badge: 'PRINTED MARKS' },
-  icon: string
+  reference: { stroke: '#0891b2', strokeDark: '#67e8f9', fill: 'rgba(8,145,178,0.14)', fillDark: 'rgba(34,211,238,0.24)', label: 'Reference', icon: '📎', badge: 'RESOURCE' },
-  role: string
+  furniture: { stroke: '#64748b', strokeDark: '#cbd5e1', fill: 'rgba(100,116,139,0.12)', fillDark: 'rgba(148,163,184,0.22)', dash: '3 5', label: 'Furniture', icon: '×', badge: 'IGNORE' },
-}
-
-export const canvasShapePalette: Record<ExamCanvasShapeKind, CanvasPaletteEntry> = {
-  boundary: { stroke: '#ef4444', fill: 'rgba(239,68,68,0.06)', darkStroke: '#f87171', darkFill: 'rgba(248,113,113,0.10)', dash: '8 6', label: 'Boundary', icon: '↕', role: 'start/end rule' },
-  part: { stroke: '#f59e0b', fill: 'rgba(245,158,11,0.18)', darkStroke: '#fbbf24', darkFill: 'rgba(251,191,36,0.26)', label: 'Part', icon: '□', role: 'markable box' },
-  response: { stroke: '#2563eb', fill: 'rgba(37,99,235,0.18)', darkStroke: '#60a5fa', darkFill: 'rgba(96,165,250,0.34)', label: 'Response', icon: '✎', role: 'student writing' },
-  context: { stroke: '#7c3aed', fill: 'rgba(124,58,237,0.14)', darkStroke: '#a78bfa', darkFill: 'rgba(167,139,250,0.28)', dash: '6 5', label: 'Context', icon: '◉', role: 'stimulus' },
-  question_number: { stroke: '#0f766e', fill: 'rgba(15,118,110,0.14)', darkStroke: '#2dd4bf', darkFill: 'rgba(45,212,191,0.24)', label: 'Question #', icon: '#', role: 'printed label' },
-  mark_area: { stroke: '#16a34a', fill: 'rgba(22,163,74,0.14)', darkStroke: '#4ade80', darkFill: 'rgba(74,222,128,0.23)', label: 'Marks', icon: '[2]', role: 'printed marks' },
-  reference: { stroke: '#0891b2', fill: 'rgba(8,145,178,0.14)', darkStroke: '#22d3ee', darkFill: 'rgba(34,211,238,0.24)', label: 'Reference', icon: '§', role: 'resource' },
-  furniture: { stroke: '#64748b', fill: 'rgba(100,116,139,0.12)', darkStroke: '#cbd5e1', darkFill: 'rgba(148,163,184,0.18)', dash: '3 5', label: 'Furniture', icon: '×', role: 'ignore' },
-}
-
-// Human-legible names for the extraction service's response forms — so the canvas SHOWS what was
-// recognised (multiple-choice, draw-on, table…), not just a generic "Response" box.
-const RESPONSE_FORM_LABEL: Record<string, string> = {
-  lines: 'ruled lines',
-  'answer-box': 'answer box',
-  working: 'working space',
-  diagram: 'draw-on',
-  'tick-boxes': 'multiple choice',
-  table: 'table',
-  blanks: 'fill-in',
-}
-
-const shapeCss = `
-.exam-canvas-shape { --exam-stroke: var(--exam-light-stroke); --exam-fill: var(--exam-light-fill); }
-[data-color-mode="dark"] .exam-canvas-shape, .tl-theme__dark .exam-canvas-shape { --exam-stroke: var(--exam-dark-stroke); --exam-fill: var(--exam-dark-fill); }
-.exam-canvas-shape__pill { background: rgba(255,255,255,.90); color: var(--exam-stroke); box-shadow: 0 1px 4px rgba(15,23,42,.14); }
-.exam-canvas-shape__flag { background: rgba(251,191,36,.94); color: #78350f; box-shadow: 0 1px 4px rgba(120,53,15,.18); }
-.exam-canvas-shape__confidence { background: rgba(15,23,42,.82); color: #fff; }
-[data-color-mode="dark"] .exam-canvas-shape__pill, .tl-theme__dark .exam-canvas-shape__pill { background: rgba(15,23,42,.88); color: var(--exam-stroke); box-shadow: 0 1px 5px rgba(0,0,0,.35); }
-[data-color-mode="dark"] .exam-canvas-shape__flag, .tl-theme__dark .exam-canvas-shape__flag { background: rgba(251,191,36,.88); color: #422006; }
-`
-
-
-function confidenceLabel(confidence: number | null | undefined) {
-  return typeof confidence === 'number' ? `${Math.round(confidence * 100)}%` : null
-}
-
-// Unconfirmed AI ghosts fade by confidence (fainter = less certain); confirmed/manual render solid.
-function ghostOpacity(confidence: number | null | undefined) {
-  if (typeof confidence !== 'number') return 0.72
-  return 0.5 + 0.4 * Math.max(0, Math.min(1, confidence))
-}
-
-function reviewFlags(shape: ExamCanvasTLShape): string[] {
-  return (shape.props.reviewFlags ?? '').split('|').map((flag) => flag.trim()).filter(Boolean)
-}
-
-function provenanceTitle(shape: ExamCanvasTLShape, base: string) {
-  const bits = [base]
-  if (shape.props.source === 'ai') bits.push(shape.props.confirmed === false ? 'AI suggestion, unconfirmed' : 'AI, confirmed')
-  const confidence = confidenceLabel(shape.props.confidence)
-  if (confidence) bits.push(`confidence ${confidence}`)
-  if (shape.props.derivation) bits.push(`derivation: ${shape.props.derivation}`)
-  const flags = reviewFlags(shape)
-  if (flags.length) bits.push(`review flags: ${flags.join(', ')}`)
-  return bits.join(' • ')
-}
-
-function renderBoundaryLine(shape: ExamCanvasTLShape) {
-  const p = canvasShapePalette.boundary
-  const lineY = Math.max(1, Math.min(shape.props.h - 1, shape.props.h / 2))
-  const isAi = shape.props.source === 'ai'
-  const isGhost = isAi && shape.props.confirmed === false
-  const confidence = confidenceLabel(shape.props.confidence)
-  const flags = reviewFlags(shape)
-  return (
-    <HTMLContainer id={shape.id} style={{ width: toDomPrecision(shape.props.w), height: toDomPrecision(shape.props.h), overflow: 'visible', pointerEvents: 'all' }}>
-      <style>{shapeCss}</style>
-      <svg width={toDomPrecision(shape.props.w)} height={toDomPrecision(shape.props.h)} aria-label={`${p.label}: ${p.role}`} style={{ display: 'block', overflow: 'visible' }}>
-        <line x1={0} x2={toDomPrecision(shape.props.w)} y1={lineY} y2={lineY} stroke="var(--exam-stroke)" strokeWidth={2.5} strokeDasharray={isGhost ? '4 6' : p.dash} strokeLinecap="round" opacity={isGhost ? ghostOpacity(shape.props.confidence) : 1} style={{ '--exam-light-stroke': p.stroke, '--exam-dark-stroke': p.darkStroke } as React.CSSProperties} />
-      </svg>
-      <span className="exam-canvas-shape__pill" style={{ position: 'absolute', left: 8, top: -24, fontSize: 11, fontWeight: 900, textTransform: 'uppercase', letterSpacing: 0.6, borderRadius: 999, padding: '2px 7px', display: 'inline-flex', alignItems: 'center', gap: 5, color: p.stroke }}>
-        <span aria-hidden="true">{isGhost ? 'AI' : p.icon}</span>
-        {shape.props.label || p.label}
-      </span>
-      {confidence && <span className="exam-canvas-shape__pill exam-canvas-shape__confidence" style={{ position: 'absolute', right: 8, top: -24, fontSize: 11, fontWeight: 900, borderRadius: 999, padding: '2px 7px' }}>{confidence}</span>}
-      {flags.slice(0, 2).map((flag, index) => <span key={flag} className="exam-canvas-shape__pill exam-canvas-shape__flag" style={{ position: 'absolute', left: 8, top: 10 + index * 22, fontSize: 10, fontWeight: 900, borderRadius: 999, padding: '1px 6px' }}>{flag}</span>)}
-    </HTMLContainer>
-  )
 }
 
 function renderShape(shape: ExamCanvasTLShape) {
   const kind = shape.props.kind
-  const p = canvasShapePalette[kind] ?? canvasShapePalette.response
+  const p = palette[kind] ?? palette.response
   const isBoundary = kind === 'boundary'
-  const isAiSuggestion = shape.props.source === 'ai' && shape.props.confirmed === false
+  const label = shape.props.label || p.label
-  if (isBoundary) return renderBoundaryLine(shape)
-  const isAi = shape.props.source === 'ai'
-  const confidence = confidenceLabel(shape.props.confidence)
-  const flags = reviewFlags(shape)
-  const title = provenanceTitle(shape, `${p.label}: ${p.role}`)
   return (
     <HTMLContainer id={shape.id} style={{ width: toDomPrecision(shape.props.w), height: toDomPrecision(shape.props.h), pointerEvents: 'all' }}>
-      <style>{shapeCss}</style>
       <div
-        className={`exam-canvas-shape exam-canvas-shape--${kind}`}
+        className={`exam-canvas-shape exam-canvas-shape--${kind.replace('_', '-')}`}
         style={{
-          '--exam-light-stroke': p.stroke,
+          '--exam-shape-stroke': p.stroke,
-          '--exam-light-fill': p.fill,
+          '--exam-shape-stroke-dark': p.strokeDark,
-          '--exam-dark-stroke': p.darkStroke,
+          '--exam-shape-fill': p.fill,
-          '--exam-dark-fill': p.darkFill,
+          '--exam-shape-fill-dark': p.fillDark,
-          width: '100%', height: '100%', boxSizing: 'border-box', border: `${isBoundary ? 2 : 1.5}px solid var(--exam-stroke)`,
+          '--exam-shape-border-style': p.dash ? 'dashed' : 'solid',
-          borderStyle: isAiSuggestion ? 'dashed' : p.dash ? 'dashed' : 'solid', borderRadius: isBoundary ? 999 : 10,
+          '--exam-shape-radius': isBoundary ? '999px' : kind === 'part' ? '6px' : '10px',
-          background: isBoundary ? 'transparent' : 'var(--exam-fill)', opacity: isAiSuggestion ? ghostOpacity(shape.props.confidence) : 1, color: 'var(--exam-stroke)', fontFamily: 'Inter, system-ui, sans-serif',
-          display: 'flex', alignItems: isBoundary ? 'center' : 'flex-start', justifyContent: isBoundary ? 'center' : 'space-between',
-          padding: isBoundary ? '0 8px' : 8, boxShadow: isBoundary ? '0 0 0 3px rgba(239,68,68,0.08)' : '0 10px 22px rgba(15,23,42,0.10)', overflow: 'hidden', gap: 6,
         } as React.CSSProperties}
-        aria-label={title}
-        title={title}
       >
-        <span className="exam-canvas-shape__pill" style={{ fontSize: 12, fontWeight: 900, textTransform: 'uppercase', letterSpacing: 0.6, borderRadius: 999, padding: '2px 7px', display: 'inline-flex', alignItems: 'center', gap: 5 }}>
+        <span className="exam-canvas-shape__main-label">
-          <span aria-hidden="true">{isAiSuggestion ? 'AI' : p.icon}</span>
+          <span className="exam-canvas-shape__icon" aria-hidden="true">{p.icon}</span>
-          {shape.props.label || p.label}
+          <span>{label}</span>
         </span>
-        {confidence && <span className="exam-canvas-shape__pill exam-canvas-shape__confidence" style={{ fontSize: 11, fontWeight: 900, borderRadius: 999, padding: '2px 7px' }}>{confidence}</span>}
+        {!isBoundary && <span className="exam-canvas-shape__badge">{shape.props.questionId ? 'Attached' : p.badge}</span>}
-        {!confidence && !isBoundary && shape.props.questionId && <span className="exam-canvas-shape__pill" style={{ fontSize: 11, fontWeight: 800, borderRadius: 999, padding: '2px 7px' }}>Attached</span>}
+        {isBoundary && <span className="exam-canvas-shape__endcap exam-canvas-shape__endcap--left">{label.toLowerCase().includes('end') ? 'B' : 'T'}</span>}
-        {flags.length > 0 && <span className="exam-canvas-shape__pill exam-canvas-shape__flag" style={{ position: 'absolute', left: 8, bottom: 8, fontSize: 10, fontWeight: 900, borderRadius: 999, padding: '1px 6px', maxWidth: 'calc(100% - 16px)', whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis' }}>{flags.slice(0, 2).join(' · ')}</span>}
+        {isBoundary && <span className="exam-canvas-shape__endcap exam-canvas-shape__endcap--right">{label.toLowerCase().includes('end') ? 'Bottom' : 'Top'}</span>}
-        {kind === 'response' && shape.props.responseForm && <span className="exam-canvas-shape__pill" style={{ position: 'absolute', right: 8, bottom: 8, fontSize: 10, fontWeight: 800, borderRadius: 999, padding: '1px 6px', opacity: 0.9 }}>{RESPONSE_FORM_LABEL[shape.props.responseForm] ?? shape.props.responseForm}</span>}
-        {kind === 'context' && shape.props.contextType && shape.props.contextType !== 'generic' && <span className="exam-canvas-shape__pill" style={{ position: 'absolute', right: 8, bottom: 8, fontSize: 10, fontWeight: 800, borderRadius: 999, padding: '1px 6px', opacity: 0.9 }}>{shape.props.contextType}</span>}
-        {isBoundary && <span className="exam-canvas-shape__pill" style={{ fontSize: 10, fontWeight: 800, borderRadius: 999, padding: '1px 6px' }}>pair across pages</span>}
       </div>
     </HTMLContainer>
   )
 }
 
 function defaultProps(kind: ExamCanvasShapeKind, w: number, h: number) {
-  const p = canvasShapePalette[kind]
+  const p = palette[kind]
-  return { w, h, label: p.label, kind, responseForm: kind === 'response' ? 'lines' : undefined, contextType: kind === 'context' ? 'generic' : undefined, source: 'manual' as const, confirmed: true }
+  return { w, h, label: p.label, kind, responseForm: kind === 'response' ? 'lines' : undefined, contextType: kind === 'context' ? 'generic' : undefined }
 }
 
-const sharedProps = { w: T.number, h: T.number, label: T.string, kind: T.string, maxMarks: T.optional(T.number), responseForm: T.optional(T.string), contextType: T.optional(T.string), questionId: T.optional(T.string), domainId: T.optional(T.string), source: T.optional(T.string), confirmed: T.optional(T.boolean), confidence: T.optional(T.number), derivation: T.optional(T.string), reviewFlags: T.optional(T.string) }
+const sharedProps = { w: T.number, h: T.number, label: T.string, kind: T.string, maxMarks: T.optional(T.number), responseForm: T.optional(T.string), contextType: T.optional(T.string), questionId: T.optional(T.string), domainId: T.optional(T.string) }
 const ind = (s: ExamCanvasTLShape | ExamPdfPageTLShape) => <rect width={toDomPrecision(s.props.w)} height={toDomPrecision(s.props.h)} />
 
 class PdfPageUtil extends BaseBoxShapeUtil<ExamPdfPageTLShape> {
@@ -203,55 +99,7 @@ class PdfPageUtil extends BaseBoxShapeUtil<ExamPdfPageTLShape> {
   }
   override indicator(shape: ExamPdfPageTLShape) { return ind(shape) }
 }
-class BoundaryUtil extends ShapeUtil<ExamCanvasTLShape> {
+class BoundaryUtil extends BaseBoxShapeUtil<ExamCanvasTLShape> { static override type = SHAPE_TYPES.boundary; static override props = sharedProps; override getDefaultProps(){ return defaultProps('boundary', 680, 8) }; override component(shape: ExamCanvasTLShape){ return renderShape(shape) }; override indicator(shape: ExamCanvasTLShape){ return ind(shape) } }
-  static override type = SHAPE_TYPES.boundary
-  static override props = sharedProps
-
-  override getDefaultProps() { return defaultProps('boundary', PAGE_WIDTH, 8) }
-  override canEdit() { return false }
-  override canResize() { return false }
-  override canBind() { return false }
-  override hideResizeHandles() { return true }
-  override hideRotateHandle() { return true }
-  override hideSelectionBoundsBg() { return true }
-
-  private pageSpanForY(y: number) {
-    const pages = this.editor.getCurrentPageShapes().filter((shape): shape is ExamPdfPageTLShape => shape.type === PDF_PAGE_SHAPE_TYPE)
-    const hit = pages.find((page) => y >= page.y && y <= page.y + page.props.h)
-    const nearest = hit ?? pages.reduce<ExamPdfPageTLShape | null>((best, page) => {
-      if (!best) return page
-      const pageDy = Math.min(Math.abs(y - page.y), Math.abs(y - (page.y + page.props.h)))
-      const bestDy = Math.min(Math.abs(y - best.y), Math.abs(y - (best.y + best.props.h)))
-      return pageDy < bestDy ? page : best
-    }, null)
-    return nearest ? { x: nearest.x, w: nearest.props.w } : { x: 0, w: PAGE_WIDTH }
-  }
-
-  private normalize(shape: ExamCanvasTLShape): ExamCanvasTLShape {
-    const span = this.pageSpanForY(shape.y + shape.props.h / 2)
-    return { ...shape, x: span.x, rotation: 0, props: { ...shape.props, w: span.w, h: 8, kind: 'boundary' } }
-  }
-
-  override getGeometry(shape: ExamCanvasTLShape) {
-    const y = shape.props.h / 2
-    return new Edge2d({ start: new Vec(0, y), end: new Vec(shape.props.w, y) })
-  }
-
-  override getHandles(shape: ExamCanvasTLShape): TLHandle[] {
-    return [{ id: 'y', type: 'vertex', index: 'a1' as any, x: shape.props.w / 2, y: shape.props.h / 2, canSnap: false }]
-  }
-
-  override onBeforeCreate(next: ExamCanvasTLShape) { return this.normalize(next) }
-  override onBeforeUpdate(_prev: ExamCanvasTLShape, next: ExamCanvasTLShape) { return this.normalize(next) }
-  override onTranslate(initial: ExamCanvasTLShape, current: ExamCanvasTLShape): any {
-    return this.normalize({ ...current, x: initial.x })
-  }
-  override onHandleDrag(shape: ExamCanvasTLShape, { handle }: { handle: TLHandle }): any {
-    return this.normalize({ ...shape, y: shape.y + handle.y - shape.props.h / 2 })
-  }
-  override component(shape: ExamCanvasTLShape) { return renderShape(shape) }
-  override indicator(shape: ExamCanvasTLShape) { return <path d={`M 0 ${toDomPrecision(shape.props.h / 2)} L ${toDomPrecision(shape.props.w)} ${toDomPrecision(shape.props.h / 2)}`} /> }
-}
 class PartUtil extends BaseBoxShapeUtil<ExamCanvasTLShape> { static override type = SHAPE_TYPES.part; static override props = sharedProps; override getDefaultProps(){ return defaultProps('part', 420, 170) }; override component(shape: ExamCanvasTLShape){ return renderShape(shape) }; override indicator(shape: ExamCanvasTLShape){ return ind(shape) } }
 function regionUtil(type: string, kind: ExamCanvasRegionKind, w = 360, h = 120) { return class extends BaseBoxShapeUtil<ExamCanvasTLShape> { static override type = type; static override props = sharedProps; override getDefaultProps(){ return defaultProps(kind, w, h) }; override component(shape: ExamCanvasTLShape){ return renderShape(shape) }; override indicator(shape: ExamCanvasTLShape){ return ind(shape) } } }
 

src/pages/exam/setup/pdfLoader.ts

@@ -12,27 +12,20 @@ export interface PdfPageImage {
   height: number
 }
 
-export async function loadPdfPageImages(
+export async function loadPdfPageImages(pdfBytes: ArrayBuffer, targetWidth = PAGE_WIDTH): Promise<PdfPageImage[]> {
-  pdfBytes: ArrayBuffer,
-  targetWidth = PAGE_WIDTH,
-  onPageReady?: (pages: PdfPageImage[]) => void,
-): Promise<PdfPageImage[]> {
   const pdf = await pdfjsLib.getDocument({ data: new Uint8Array(pdfBytes) }).promise
   const pages: PdfPageImage[] = []
-  // Reuse a single canvas across all pages to avoid allocating ~120 MB of canvas memory
-  // for a typical 36-page exam paper.
-  const canvas = document.createElement("canvas")
 
   for (let pageNumber = 1; pageNumber <= pdf.numPages; pageNumber += 1) {
     const page = await pdf.getPage(pageNumber)
     const baseViewport = page.getViewport({ scale: 1 })
     const scale = targetWidth / baseViewport.width
     const viewport = page.getViewport({ scale })
+    const canvas = document.createElement("canvas")
     canvas.width = Math.ceil(viewport.width)
     canvas.height = Math.ceil(viewport.height)
     const context = canvas.getContext("2d")
     if (!context) throw new Error("Unable to create PDF render canvas")
-    context.clearRect(0, 0, canvas.width, canvas.height)
     await page.render({ canvasContext: context, viewport }).promise
     pages.push({
       pageNumber,
@@ -40,7 +33,6 @@ export async function loadPdfPageImages(
       width: canvas.width,
       height: canvas.height,
     })
-    onPageReady?.([...pages])
   }
 
   return pages

src/pages/timetable/ClassDetailPage.tsx

@@ -9,7 +9,6 @@ import {
     ArrowBack, PersonAdd, PersonRemove, CheckCircle, Cancel, School,
 } from '@mui/icons-material';
 import { useAuth } from '../../contexts/AuthContext';
-import { ResultsWidget } from '../exam';
 
 const API_BASE = import.meta.env.VITE_API_BASE || import.meta.env.VITE_API_URL || '/api';
 
@@ -132,20 +131,10 @@ const ClassDetailPage: React.FC = () => {
         setLoading(true);
         setError(null);
         try {
-            const clsRes = await fetch(`${API_BASE}/database/timetable/classes/${classId}`, {
+            const clsRes = await fetch(`${API_BASE}/classes/${classId}`, {
                 headers: { Authorization: `Bearer ${accessToken}` },
             }).then(r => r.json());
-            if (clsRes.id) {
+            if (clsRes.id) setCls(clsRes);
-                setCls({
-                    ...clsRes,
-                    class_code: clsRes.class_code || clsRes.code,
-                    year_group: clsRes.year_group || clsRes.school_year,
-                    teachers: clsRes.teachers || [],
-                    students: clsRes.students || [],
-                    enrollment_requests: clsRes.enrollment_requests || [],
-                    student_count: clsRes.student_count ?? clsRes.students?.length ?? 0,
-                });
-            }
             else setError(clsRes.detail || 'Class not found');
             const role = bootstrapData?.active_institute?.membership_role || '';
             setIsAdmin(role === 'school_admin' || role === 'department_head');
@@ -185,20 +174,20 @@ const ClassDetailPage: React.FC = () => {
 
     const handleAddStudent = async (studentId: string) => {
         setActionError(null);
-        const res = await apiPost(`/database/timetable/classes/${classId}/students`, { student_id: studentId });
+        const res = await apiPost(`/classes/${classId}/students`, { student_id: studentId });
         if (res.status === 'ok') load();
         else setActionError(res.detail || 'Failed to add student');
     };
 
     const handleRemoveStudent = async (studentId: string) => {
         setActionError(null);
-        await apiDelete(`/database/timetable/classes/${classId}/students/${studentId}`);
+        await apiDelete(`/classes/${classId}/students/${studentId}`);
         load();
     };
 
     const handleEnrollmentResponse = async (requestId: string, action: 'approve' | 'reject') => {
         setActionError(null);
-        const res = await apiPatch(`/database/timetable/classes/${classId}/enrollment-requests/${requestId}`, { action });
+        const res = await apiPatch(`/classes/${classId}/enrollment-requests/${requestId}`, { action });
         if (res.status === 'ok') load();
         else setActionError(res.detail || 'Action failed');
     };
@@ -265,8 +254,6 @@ const ClassDetailPage: React.FC = () => {
                 </Alert>
             )}
 
-            <ResultsWidget classId={cls.id} className={cls.name} />
-
             {/* Tabs */}
             <Tabs value={tab} onChange={(_, v) => setTab(v)} sx={{ borderBottom: 1, borderColor: 'divider', mb: 2 }}>
                 <Tab label={`Students (${cls.student_count})`} />

src/services/exam/examRepository.ts

@@ -11,29 +11,12 @@ import { API_BASE } from '../../config/apiConfig';
 import { logger } from '../../debugConfig';
 import { supabase } from '../../supabaseClient';
 import type {
-  AutoMapJobStatus,
-  AutoMapResponse,
-  BankResponse,
-  CorpusResponse,
-  DigitalTextResponse,
-  BatchQueueResponse,
-  BatchResultsResponse,
-  CreateBatchPayload,
-  CreateCustomPaperPayload,
-  CreateCustomPaperResult,
   CreateTemplatePayload,
   ExamBoundary,
   ExamQuestion,
   ExamResponseArea,
   ExamTemplate,
   ExamTemplateDetail,
-  ExamTemplateLayout,
-  MarkingBatch,
-  MarkUpsertPayload,
-  Neo4jSyncResult,
-  PatchQuestionPayload,
-  SpecPoint,
-  StudentSubmission,
   TemplateReplacePayload,
   UpdateTemplateMetaPayload,
 } from '../../types/exam.types';
@@ -73,10 +56,6 @@ function questionPayload(q: ExamQuestion, idMap?: Map<string, string>) {
     spec_ref: q.spec_ref,
     bounds: q.bounds ?? null,
     page: q.page ?? null,
-    source: q.source ?? 'manual',
-    confirmed: q.confirmed ?? true,
-    confidence: q.confidence ?? null,
-    derivation: q.derivation ?? null,
   };
 }
 
@@ -92,8 +71,6 @@ function responseAreaPayload(r: ExamResponseArea, idMap?: Map<string, string>, d
     source: r.source,
     confirmed: r.confirmed,
     confidence: r.confidence,
-    mark_subtype: r.mark_subtype ?? null,
-    derivation: r.derivation ?? null,
   };
 }
 
@@ -107,26 +84,6 @@ function boundaryPayload(b: ExamBoundary, idMap?: Map<string, string>, duplicate
     bounds: b.bounds,
     source: b.source,
     confirmed: b.confirmed,
-    confidence: b.confidence ?? null,
-    derivation: b.derivation ?? null,
-  };
-}
-
-function layoutPayload(layout: ExamTemplateLayout, duplicate = false) {
-  return {
-    id: duplicate ? newUuid() : layout.id,
-    page_index: layout.page_index,
-    role: layout.role ?? null,
-    margin_left: layout.margin_left ?? null,
-    margin_right: layout.margin_right ?? null,
-    margin_top: layout.margin_top ?? null,
-    margin_bottom: layout.margin_bottom ?? null,
-    margins_enabled: layout.margins_enabled ?? true,
-    source: layout.source ?? 'manual',
-    confirmed: layout.confirmed ?? true,
-    confidence: layout.confidence ?? null,
-    derivation: layout.derivation ?? null,
-    meta: layout.meta ?? {},
   };
 }
 
@@ -148,7 +105,6 @@ async function replaceTemplate(
       questions: detail.questions.map((q) => questionPayload(q, idMap)),
       response_areas: detail.response_areas.map((r) => responseAreaPayload(r, idMap, duplicateIds)),
       boundaries: detail.boundaries.map((b) => boundaryPayload(b, idMap, duplicateIds)),
-      layout: (detail.layout ?? []).map((layout) => layoutPayload(layout, duplicateIds)),
     },
     { headers },
   );
@@ -165,30 +121,12 @@ export const examRepository = {
     return res.data.templates ?? [];
   },
 
-  async getDigitalText(templateId: string): Promise<DigitalTextResponse> {
-    const headers = await authHeaders();
-    const res = await axios.get<DigitalTextResponse>(`${EXAM_BASE}/templates/${templateId}/digital-text`, { headers });
-    return res.data;
-  },
-
   async getTemplate(templateId: string): Promise<ExamTemplateDetail> {
     const headers = await authHeaders();
     const res = await axios.get<ExamTemplateDetail>(`${EXAM_BASE}/templates/${templateId}`, { headers });
     return res.data;
   },
 
-  async autoMapTemplate(templateId: string): Promise<AutoMapResponse> {
-    const headers = await authHeaders();
-    const res = await axios.post<AutoMapResponse>(`${EXAM_BASE}/templates/${templateId}/auto-map`, {}, { headers });
-    return res.data;
-  },
-
-  async getAutoMapStatus(templateId: string, jobId: string): Promise<AutoMapJobStatus> {
-    const headers = await authHeaders();
-    const res = await axios.get<AutoMapJobStatus>(`${EXAM_BASE}/templates/${templateId}/auto-map/${jobId}/status`, { headers });
-    return res.data;
-  },
-
   async getTemplateSourcePdf(templateId: string): Promise<ArrayBuffer> {
     const headers = await authHeaders();
     const res = await axios.get<ArrayBuffer>(`${EXAM_BASE}/templates/${templateId}/source-pdf`, {
@@ -246,106 +184,6 @@ export const examRepository = {
     const headers = await authHeaders();
     await axios.delete(`${EXAM_BASE}/templates/${templateId}`, { headers });
   },
-
-  async patchQuestion(questionId: string, payload: PatchQuestionPayload) {
-    const headers = await authHeaders();
-    const res = await axios.patch(`${EXAM_BASE}/questions/${questionId}`, payload, { headers });
-    return res.data;
-  },
-
-  async listSpecPoints(specCode: string, search?: string): Promise<SpecPoint[]> {
-    const headers = await authHeaders();
-    const res = await axios.get<{ points?: SpecPoint[] } | SpecPoint[]>(
-      `${EXAM_BASE}/specs/${encodeURIComponent(specCode)}/points`,
-      { headers, params: search ? { q: search } : undefined },
-    );
-    if (Array.isArray(res.data)) return res.data;
-    return res.data.points ?? [];
-  },
-
-  async syncTemplateToGraph(templateId: string): Promise<Neo4jSyncResult> {
-    const headers = await authHeaders();
-    const res = await axios.post<Neo4jSyncResult>(`${EXAM_BASE}/templates/${templateId}/neo4j-sync`, {}, { headers });
-    return res.data;
-  },
-
-  async createBatch(payload: CreateBatchPayload): Promise<MarkingBatch> {
-    const headers = await authHeaders();
-    const res = await axios.post<MarkingBatch>(`${EXAM_BASE}/batches`, payload, { headers });
-    return res.data;
-  },
-
-  async listBatches(params: { includeArchived?: boolean; templateId?: string } = {}): Promise<MarkingBatch[]> {
-    const headers = await authHeaders();
-    const res = await axios.get<{ batches: MarkingBatch[] }>(`${EXAM_BASE}/batches`, {
-      headers,
-      params: {
-        include_archived: params.includeArchived ?? false,
-        template_id: params.templateId,
-      },
-    });
-    return res.data.batches ?? [];
-  },
-
-  async getBatchQueue(batchId: string): Promise<BatchQueueResponse> {
-    const headers = await authHeaders();
-    const res = await axios.get<BatchQueueResponse>(`${EXAM_BASE}/batches/${batchId}/queue`, { headers });
-    return res.data;
-  },
-
-  async getBatchResults(batchId: string): Promise<BatchResultsResponse> {
-    const headers = await authHeaders();
-    const res = await axios.get<BatchResultsResponse>(`${EXAM_BASE}/batches/${batchId}/results`, { headers });
-    return res.data;
-  },
-
-  async getBatchCsv(batchId: string): Promise<string> {
-    const headers = await authHeaders();
-    const res = await axios.get<string>(`${EXAM_BASE}/batches/${batchId}/csv`, { headers, responseType: 'text' });
-    return res.data;
-  },
-
-  async upsertMark(markId: string, payload: MarkUpsertPayload): Promise<unknown> {
-    const headers = await authHeaders();
-    const res = await axios.put(`${EXAM_BASE}/marks/${markId}`, payload, { headers });
-    return res.data;
-  },
-
-  async getCorpus(): Promise<CorpusResponse> {
-    const headers = await authHeaders();
-    const res = await axios.get<CorpusResponse>(`${EXAM_BASE}/corpus`, { headers });
-    return res.data;
-  },
-
-  async getBank(params: { specRef?: string; subject?: string } = {}): Promise<BankResponse> {
-    const headers = await authHeaders();
-    const res = await axios.get<BankResponse>(`${EXAM_BASE}/bank`, {
-      headers,
-      params: { spec_ref: params.specRef, subject: params.subject },
-    });
-    return res.data;
-  },
-
-  async createCustomPaper(payload: CreateCustomPaperPayload): Promise<CreateCustomPaperResult> {
-    const headers = await authHeaders();
-    const res = await axios.post<CreateCustomPaperResult>(`${EXAM_BASE}/custom-papers`, payload, { headers });
-    return res.data;
-  },
-
-  async uploadScan(
-    batchId: string,
-    file: File,
-    opts: { studentId?: string; matchingMethod?: 'manual' | 'ordered' } = {},
-  ): Promise<StudentSubmission> {
-    const headers = await authHeaders();
-    const form = new FormData();
-    form.append('file', file);
-    form.append('matching_method', opts.matchingMethod ?? 'ordered');
-    if (opts.studentId) form.append('student_id', opts.studentId);
-    // Let axios set the multipart Content-Type + boundary (only Authorization is forwarded).
-    const res = await axios.post<StudentSubmission>(`${EXAM_BASE}/batches/${batchId}/scans`, form, { headers });
-    return res.data;
-  },
 };
 
 export default examRepository;

src/supabaseClient.ts

@@ -1,17 +1,9 @@
 import { createClient, SupabaseClient } from '@supabase/supabase-js';
 import { logger } from './debugConfig';
 
-const rawSupabaseUrl = import.meta.env.VITE_SUPABASE_URL;
+const supabaseUrl = import.meta.env.VITE_SUPABASE_URL;
 const supabaseAnonKey = import.meta.env.VITE_SUPABASE_ANON_KEY;
 
-// Same-origin proxy support: a leading-slash value (e.g. "/__supabase") is
-// resolved against the current browser origin so supabase-js receives an
-// absolute URL while every request stays same-origin (no CORS) and routes
-// through the app host's /__supabase nginx proxy to the backend Supabase.
-const supabaseUrl = rawSupabaseUrl?.startsWith('/')
-  ? `${window.location.origin}${rawSupabaseUrl}`
-  : rawSupabaseUrl;
-
 if (!supabaseUrl || !supabaseAnonKey) {
   throw new Error('Missing Supabase configuration');
 }

src/types/exam.types.ts

@@ -31,42 +31,6 @@ export interface CreateTemplatePayload {
   institute_id?: string;
 }
 
-export type MarkSchemeType = 'points' | 'levels' | 'parts' | 'checklist' | 'free';
-
-export interface MarkSchemePoint {
-  mark: number;
-  text: string;
-}
-
-export interface MarkSchemeLevel {
-  level: string;
-  min: number;
-  max: number;
-  descriptor: string;
-}
-
-export interface MarkSchemePart {
-  label: string;
-  marks: number;
-  guidance: string;
-}
-
-export interface MarkSchemeChecklistItem {
-  text: string;
-  marks: number;
-}
-
-export interface MarkScheme {
-  type?: MarkSchemeType;
-  points?: MarkSchemePoint[];
-  levels?: MarkSchemeLevel[];
-  parts?: MarkSchemePart[];
-  checklist?: MarkSchemeChecklistItem[];
-  text?: string;
-  notes?: string;
-  [key: string]: unknown;
-}
-
 export interface UpdateTemplateMetaPayload {
   title?: string;
   subject?: string | null;
@@ -75,8 +39,6 @@ export interface UpdateTemplateMetaPayload {
 }
 
 /** Canvas children (used from S4-9 onward; defined here so the seam is complete). */
-export type ExamTemplateSource = 'manual' | 'ai';
-
 export interface ExamQuestion {
   id: string;
   template_id: string;
@@ -86,15 +48,11 @@ export interface ExamQuestion {
   max_marks: number;
   answer_type: string | null;
   mcq_options: unknown | null;
-  mark_scheme: MarkScheme;
+  mark_scheme: Record<string, unknown>;
   is_container: boolean;
   spec_ref: string | null;
   bounds?: Record<string, number> | null;
   page?: number | null;
-  source: ExamTemplateSource;
-  confirmed: boolean;
-  confidence: number | null;
-  derivation: string | null;
 }
 
 export type ExamResponseAreaKind =
@@ -105,8 +63,6 @@ export type ExamResponseAreaKind =
   | 'reference'
   | 'furniture';
 
-export type ExamMarkSubtype = 'part_marks' | 'question_total' | 'grader_box';
-
 export interface ExamResponseArea {
   id: string;
   question_id: string;
@@ -116,11 +72,9 @@ export interface ExamResponseArea {
   kind: ExamResponseAreaKind;
   response_form: string | null;
   context_type?: string | null;
-  source: ExamTemplateSource;
+  source: 'manual' | 'ai';
   confirmed: boolean;
   confidence: number | null;
-  mark_subtype?: ExamMarkSubtype | null;
-  derivation?: string | null;
 }
 
 export interface ExamBoundary {
@@ -131,36 +85,14 @@ export interface ExamBoundary {
   page_index: number;
   y: number;
   bounds: Record<string, number> | null;
-  source: ExamTemplateSource;
+  source: 'manual' | 'ai';
   confirmed: boolean;
-  confidence: number | null;
-  derivation: string | null;
-}
-
-export interface ExamTemplateLayout {
-  id: string;
-  template_id: string;
-  page_index: number;
-  role: string | null;
-  margin_left: number | null;
-  margin_right: number | null;
-  margin_top: number | null;
-  margin_bottom: number | null;
-  margins_enabled: boolean;
-  source: ExamTemplateSource;
-  confirmed: boolean;
-  confidence: number | null;
-  derivation: string | null;
-  meta: Record<string, unknown>;
-  created_at?: string;
-  updated_at?: string;
 }
 
 export interface ExamTemplateDetail extends ExamTemplate {
   questions: ExamQuestion[];
   response_areas: ExamResponseArea[];
   boundaries: ExamBoundary[];
-  layout: ExamTemplateLayout[];
 }
 
 
@@ -184,10 +116,6 @@ export interface TemplateReplacePayload {
     spec_ref?: string | null;
     bounds?: Record<string, number> | null;
     page?: number | null;
-    source?: ExamTemplateSource;
-    confirmed?: boolean;
-    confidence?: number | null;
-    derivation?: string | null;
   }>;
   response_areas: Array<{
     id?: string;
@@ -200,8 +128,6 @@ export interface TemplateReplacePayload {
     source?: 'manual' | 'ai';
     confirmed?: boolean;
     confidence?: number | null;
-    mark_subtype?: ExamMarkSubtype | null;
-    derivation?: string | null;
   }>;
   boundaries: Array<{
     id?: string;
@@ -210,199 +136,7 @@ export interface TemplateReplacePayload {
     page_index: number;
     y: number;
     bounds?: Record<string, number> | null;
-    source?: ExamTemplateSource;
+    source?: 'manual' | 'ai';
     confirmed?: boolean;
-    confidence?: number | null;
-    derivation?: string | null;
-  }>;
-  layout?: Array<{
-    id?: string;
-    page_index: number;
-    role?: string | null;
-    margin_left?: number | null;
-    margin_right?: number | null;
-    margin_top?: number | null;
-    margin_bottom?: number | null;
-    margins_enabled?: boolean;
-    source?: ExamTemplateSource;
-    confirmed?: boolean;
-    confidence?: number | null;
-    derivation?: string | null;
-    meta?: Record<string, unknown>;
   }>;
 }
-
-export interface PatchQuestionPayload {
-  label?: string;
-  order?: number;
-  max_marks?: number;
-  answer_type?: 'written' | 'mcq' | 'short' | 'diagram' | null;
-  mcq_options?: unknown;
-  mark_scheme?: MarkScheme;
-  is_container?: boolean;
-  spec_ref?: string | null;
-}
-
-export interface SpecPoint {
-  uid?: string;
-  uuid_string?: string;
-  ref: string;
-  description: string;
-  spec_code: string;
-  exam_board_code?: string;
-}
-
-export interface Neo4jSyncResult {
-  status: string;
-  projection?: Record<string, unknown>;
-}
-
-export interface AutoMapAcceptedResponse {
-  status: 'accepted';
-  job_id: string;
-}
-
-export interface AutoMapJobStatus {
-  job_id: string;
-  status: 'queued' | 'running' | 'completed' | 'failed' | string;
-  template_id: string;
-  updated_at?: number;
-  counts?: Record<string, number>;
-  error?: string;
-  template?: ExamTemplateDetail;
-}
-
-export type AutoMapResponse = ExamTemplateDetail | AutoMapAcceptedResponse;
-
-export interface MarkingBatch {
-  id: string;
-  template_id: string;
-  class_id: string | null;
-  institute_id: string;
-  teacher_id: string;
-  title: string | null;
-  status: 'open' | 'closed' | 'archived' | string;
-  created_at: string;
-  updated_at?: string;
-  submission_count?: number;
-}
-
-export interface StudentSubmission {
-  id: string;
-  batch_id: string;
-  student_id: string | null;
-  student_name: string | null;
-  status: 'absent' | 'unmatched' | 'matched' | 'marking' | 'complete' | string;
-  storage_path?: string | null;
-  mark_entry_count?: number;
-}
-
-export interface BatchQueueResponse {
-  batch: MarkingBatch;
-  submissions: StudentSubmission[];
-  progress: {
-    total: number;
-    absent: number;
-    complete: number;
-    in_progress: number;
-  };
-}
-
-export interface ExamResultRow {
-  submission_id: string;
-  student_id: string | null;
-  student_name: string | null;
-  status: string | null;
-  marks: Record<string, number | null | undefined>;
-  total: number | null;
-}
-
-export interface BatchResultsResponse {
-  batch: MarkingBatch;
-  questions: Array<Pick<ExamQuestion, 'id' | 'label' | 'max_marks' | 'order'>>;
-  results: ExamResultRow[];
-}
-
-export interface CreateBatchPayload {
-  template_id: string;
-  class_id?: string;
-  title?: string;
-}
-
-export interface MarkUpsertPayload {
-  submission_id: string;
-  question_id: string;
-  awarded_marks: number;
-  mark_scheme_detail?: Record<string, unknown>;
-  annotation_shape_ids?: unknown;
-  comment?: string;
-  confirmed?: boolean;
-}
-
-// ── Mode-3 question bank + custom-paper assembly ──────────────────────────────
-export interface BankQuestion {
-  id: string;
-  template_id: string;
-  label: string | null;
-  max_marks: number | null;
-  answer_type: string | null;
-  spec_ref: string | null;
-  bounds: Record<string, number> | null;
-  page: number | null;
-  paper: { id: string | null; title: string | null; subject: string | null; exam_code: string | null };
-}
-
-export interface BankResponse {
-  questions: BankQuestion[];
-  n: number;
-  facets: { spec_ref: Record<string, number>; subject: Record<string, number> };
-}
-
-export interface CreateCustomPaperPayload {
-  title: string;
-  subject?: string;
-  question_ids: string[];
-}
-
-export interface CreateCustomPaperResult {
-  id: string;
-  title: string;
-  subject: string | null;
-  n_questions: number;
-  n_response_areas: number;
-}
-
-// ── Exam-bank corpus coverage (state of the collected bank) ───────────────────
-export type CorpusDocType = 'QP' | 'MS' | 'ER';
-export interface CorpusPaper {
-  paper_code: string | null;
-  session: string | null;
-  tier: string | null;
-  docs: Partial<Record<CorpusDocType, boolean>>;
-  exam_codes: Partial<Record<CorpusDocType, string>>;
-}
-export interface CorpusSpec {
-  spec_code: string;
-  subject: string;
-  level: string;
-  board: string;
-  first_teach: string | null;
-  n_papers: number;
-  counts: Record<CorpusDocType, number>;
-  papers: CorpusPaper[];
-}
-export interface CorpusBoard { board: string; n_specs: number; specs: CorpusSpec[] }
-export interface CorpusResponse {
-  totals: { specs: number; papers: number; sessions: number; QP: number; MS: number; ER: number };
-  boards: CorpusBoard[];
-}
-
-// ── Digital-replica markdown (P4) ─────────────────────────────────────────────
-export interface DigitalTextResponse {
-  slug: string;
-  title: string;
-  n_questions: number;
-  total_marks: number;
-  markdown: string;
-  questions: { label: string; marks: number | null; markdown: string }[];
-}

src/utils/exam-canvas/model.test.ts

@@ -4,7 +4,7 @@ import { isUuid, pageForY, serializeCanvasShapes, shapesFromTemplate } from './m
 
 const template: ExamTemplateDetail = {
   id: 'tpl-1', title: 'Physics', subject: 'Physics', exam_id: null, exam_code: null, source_file_id: null, page_count: 1,
-  institute_id: 'inst', teacher_id: 'teacher', status: 'draft', created_at: 'now', updated_at: 'now', questions: [], response_areas: [], boundaries: [], layout: [],
+  institute_id: 'inst', teacher_id: 'teacher', status: 'draft', created_at: 'now', updated_at: 'now', questions: [], response_areas: [], boundaries: [],
 }
 
 describe('exam setup canvas serialization', () => {
@@ -43,7 +43,6 @@ describe('exam setup canvas serialization', () => {
     ], pages)
     expect(payload.questions.find((q) => !q.is_container)?.page).toBe(2)
     expect(payload.boundaries.every((b) => b.page_index === 1)).toBe(true)
-    expect(payload.boundaries.every((b) => b.bounds?.x === 260 && b.bounds?.w === 780)).toBe(true)
     expect(payload.response_areas[0].page).toBe(2)
   })
 
@@ -51,69 +50,16 @@ describe('exam setup canvas serialization', () => {
     const shapes = shapesFromTemplate({
       ...template,
       questions: [
-        { id: 'q1', template_id: 'tpl-1', parent_id: null, label: 'Q1', order: 0, max_marks: 0, answer_type: null, mcq_options: null, mark_scheme: {}, is_container: true, spec_ref: null, source: 'manual', confirmed: true, confidence: null, derivation: null },
+        { id: 'q1', template_id: 'tpl-1', parent_id: null, label: 'Q1', order: 0, max_marks: 0, answer_type: null, mcq_options: null, mark_scheme: {}, is_container: true, spec_ref: null },
-        { id: 'p1', template_id: 'tpl-1', parent_id: 'q1', label: 'Q1(a)', order: 0, max_marks: 2, answer_type: 'written', mcq_options: null, mark_scheme: {}, is_container: false, spec_ref: null, bounds: { x: 1, y: 2, w: 3, h: 4 }, page: 1, source: 'manual', confirmed: true, confidence: null, derivation: null },
+        { id: 'p1', template_id: 'tpl-1', parent_id: 'q1', label: 'Q1(a)', order: 0, max_marks: 2, answer_type: 'written', mcq_options: null, mark_scheme: {}, is_container: false, spec_ref: null, bounds: { x: 1, y: 2, w: 3, h: 4 }, page: 1 },
       ],
       response_areas: [
-        { id: 'r1', question_id: 'p1', template_id: 'tpl-1', page: 1, bounds: { x: 10, y: 20, w: 30, h: 40 }, kind: 'response', response_form: 'lines', source: 'manual', confirmed: true, confidence: null, derivation: null },
+        { id: 'r1', question_id: 'p1', template_id: 'tpl-1', page: 1, bounds: { x: 10, y: 20, w: 30, h: 40 }, kind: 'response', response_form: 'lines', source: 'manual', confirmed: true, confidence: null },
-        { id: 'f1', question_id: 'p1', template_id: 'tpl-1', page: 1, bounds: { x: 11, y: 21, w: 31, h: 41 }, kind: 'furniture', response_form: null, source: 'manual', confirmed: true, confidence: null, derivation: null },
+        { id: 'f1', question_id: 'p1', template_id: 'tpl-1', page: 1, bounds: { x: 11, y: 21, w: 31, h: 41 }, kind: 'furniture', response_form: null, source: 'manual', confirmed: true, confidence: null },
       ],
-      boundaries: [{ id: 'b1', template_id: 'tpl-1', question_id: 'q1', label: 'Q1 start', page_index: 0, y: 100, bounds: { x: 0, y: 100, w: 700, h: 8 }, source: 'manual', confirmed: true, confidence: null, derivation: null }],
+      boundaries: [{ id: 'b1', template_id: 'tpl-1', question_id: 'q1', label: 'Q1 start', page_index: 0, y: 100, bounds: { x: 0, y: 100, w: 700, h: 8 }, source: 'manual', confirmed: true }],
     })
     expect(shapes.map((s) => s.kind).sort()).toEqual(['boundary', 'furniture', 'part', 'response'])
-    expect(shapes.find((s) => s.kind === 'boundary')).toMatchObject({ id: 'b1', x: 0, y: 100, w: 780, h: 8 })
     expect(shapes.find((s) => s.kind === 'part')).toMatchObject({ id: 'p1', x: 1, y: 2, w: 3, h: 4 })
   })
-
-  it('carries AI provenance into canvas models, flags cheap review issues, and preserves it on save', () => {
-    const detail: ExamTemplateDetail = {
-      ...template,
-      questions: [
-        { id: '11111111-1111-4111-8111-111111111111', template_id: 'tpl-1', parent_id: null, label: 'Q?', order: 0, max_marks: 0, answer_type: null, mcq_options: null, mark_scheme: {}, is_container: true, spec_ref: null, source: 'ai', confirmed: false, confidence: 0.62, derivation: 'g6' },
-        { id: '22222222-2222-4222-8222-222222222222', template_id: 'tpl-1', parent_id: '11111111-1111-4111-8111-111111111111', label: 'Q?', order: 0, max_marks: 0, answer_type: 'written', mcq_options: null, mark_scheme: {}, is_container: false, spec_ref: null, bounds: { x: 100, y: 120, w: 200, h: 100 }, page: 1, source: 'ai', confirmed: false, confidence: 0.62, derivation: 'g6' },
-        { id: '66666666-6666-4666-8666-666666666666', template_id: 'tpl-1', parent_id: '11111111-1111-4111-8111-111111111111', label: 'Q1(b)', order: 1, max_marks: 1, answer_type: 'written', mcq_options: null, mark_scheme: {}, is_container: false, spec_ref: null, bounds: { x: 150, y: 150, w: 200, h: 100 }, page: 1, source: 'ai', confirmed: false, confidence: 0.8, derivation: 'g6' },
-      ],
-      response_areas: [
-        { id: '33333333-3333-4333-8333-333333333333', question_id: '22222222-2222-4222-8222-222222222222', template_id: 'tpl-1', page: 1, bounds: { x: 120, y: 140, w: 120, h: 40 }, kind: 'response', response_form: 'lines', source: 'ai', confirmed: false, confidence: 0.8, derivation: 'regions' },
-      ],
-      boundaries: [
-        { id: '44444444-4444-4444-8444-444444444444', template_id: 'tpl-1', question_id: '11111111-1111-4111-8111-111111111111', label: 'Q? start', page_index: 0, y: 100, bounds: { x: 0, y: 100, w: 700, h: 8 }, source: 'ai', confirmed: false, confidence: 0.62, derivation: 'g6' },
-        { id: '55555555-5555-4555-8555-555555555555', template_id: 'tpl-1', question_id: '11111111-1111-4111-8111-111111111111', label: 'Q? end', page_index: 0, y: 500, bounds: { x: 0, y: 500, w: 700, h: 8 }, source: 'ai', confirmed: false, confidence: 0.62, derivation: 'g6' },
-      ],
-    }
-    const shapes = shapesFromTemplate(detail)
-    const part = shapes.find((shape) => shape.kind === 'part')
-    expect(part).toMatchObject({ source: 'ai', confirmed: false, confidence: 0.62, derivation: 'g6' })
-    expect(part?.reviewFlags).toEqual(expect.arrayContaining(['unconfirmed AI', 'low confidence', 'uncertain question label', 'missing marks', 'overlapping shapes']))
-
-    const payload = serializeCanvasShapes(template, shapes)
-    expect(payload.questions.find((q) => q.id === '22222222-2222-4222-8222-222222222222')).toMatchObject({ source: 'ai', confirmed: false, confidence: 0.62, derivation: 'g6' })
-    expect(payload.response_areas.find((r) => r.id === '33333333-3333-4333-8333-333333333333')).toMatchObject({ source: 'ai', confirmed: false, confidence: 0.8, derivation: 'regions' })
-    expect(payload.boundaries.find((b) => b.id === '44444444-4444-4444-8444-444444444444')).toMatchObject({ source: 'ai', confirmed: false, confidence: 0.62, derivation: 'g6' })
-  })
-
-  it('never drops a response region that has no enclosing part — it falls back to a question', () => {
-    const payload = serializeCanvasShapes(template, [
-      { id: 'b-top', kind: 'boundary', x: 40, y: 100, w: 700, h: 8, label: 'Q1 start' },
-      { id: 'b-bottom', kind: 'boundary', x: 40, y: 700, w: 700, h: 8, label: 'Q1 end' },
-      { id: 'part-1', kind: 'part', x: 100, y: 180, w: 400, h: 120, label: 'Q1(a)', maxMarks: 3 },
-      { id: 'resp-far', kind: 'response', x: 100, y: 520, w: 300, h: 90, responseForm: 'lines' }, // outside the part box
-    ])
-    const part = payload.questions.find((q) => !q.is_container)
-    expect(payload.response_areas).toHaveLength(1)               // previously dropped (no containing part)
-    expect(payload.response_areas[0].question_id).toBe(part?.id) // falls back to the part, not lost
-  })
-
-  it('respects a region persisted question over geometric nearest when no part contains it', () => {
-    const A = '11111111-1111-4111-8111-111111111111'
-    const B = '22222222-2222-4222-8222-222222222222'
-    const R = '33333333-3333-4333-8333-333333333333'
-    const payload = serializeCanvasShapes(template, [
-      { id: 'pa', kind: 'part', x: 100, y: 120, w: 300, h: 80, label: 'A', questionId: A },
-      { id: 'pb', kind: 'part', x: 100, y: 500, w: 300, h: 80, label: 'B', questionId: B },
-      { id: R, kind: 'response', x: 120, y: 260, w: 200, h: 60, questionId: B }, // contained by neither; nearest is A
-    ])
-    expect(payload.response_areas.find((r) => r.id === R)?.question_id).toBe(B) // persisted B wins over nearest A
-  })
-
 })

src/utils/exam-canvas/model.ts

@@ -1,5 +1,5 @@
 
-import type { ExamTemplateDetail, ExamTemplateSource, TemplateReplacePayload } from '../../types/exam.types'
+import type { ExamTemplateDetail, TemplateReplacePayload } from '../../types/exam.types'
 
 export const PAGE_HEIGHT = 1100
 export const PAGE_WIDTH = 780
@@ -10,7 +10,7 @@ export interface CanvasPageGeometry { pageNumber: number; x: number; y: number;
 export type ExamCanvasRegionKind = 'response' | 'context' | 'question_number' | 'mark_area' | 'reference' | 'furniture'
 export type ExamCanvasShapeKind = 'boundary' | 'part' | ExamCanvasRegionKind
 
-export interface CanvasBounds extends Record<string, number> { x: number; y: number; w: number; h: number }
+export interface CanvasBounds { x: number; y: number; w: number; h: number }
 
 export interface ExamCanvasShapeModel {
   /** Stable domain UUID persisted to Supabase. Do not reuse tldraw shape ids for new shapes. */
@@ -26,11 +26,6 @@ export interface ExamCanvasShapeModel {
   responseForm?: 'lines' | 'answer-box' | 'working' | 'diagram' | 'tick-boxes' | 'table' | 'blanks'
   contextType?: string
   questionId?: string | null
-  source?: ExamTemplateSource
-  confirmed?: boolean
-  confidence?: number | null
-  derivation?: string | null
-  reviewFlags?: string[]
 }
 
 export function pageForY(y: number, pages?: CanvasPageGeometry[]): number {
@@ -70,35 +65,10 @@ export function newDomainId(): string {
   })
 }
 
-function bounds(shape: Pick<ExamCanvasShapeModel, 'x' | 'y' | 'w' | 'h'>): CanvasBounds & Record<string, number> {
+function bounds(shape: Pick<ExamCanvasShapeModel, 'x' | 'y' | 'w' | 'h'>): CanvasBounds {
   return { x: shape.x, y: shape.y, w: shape.w, h: shape.h }
 }
 
-function pageGeometry(pageNumber: number, pages?: CanvasPageGeometry[]): CanvasPageGeometry {
-  return pages?.find((page) => page.pageNumber === pageNumber) ?? { pageNumber, x: 0, y: pageTop(pageNumber, pages), w: PAGE_WIDTH, h: PAGE_HEIGHT }
-}
-
-function boundaryBounds(shape: Pick<ExamCanvasShapeModel, 'y' | 'h'>, pages?: CanvasPageGeometry[]): CanvasBounds & Record<string, number> {
-  const page = pageGeometry(pageForShape(shape, pages), pages)
-  return { x: page.x, y: shape.y, w: page.w, h: 8 }
-}
-
-function persistedSource(shape: ExamCanvasShapeModel): ExamTemplateSource {
-  return shape.source ?? 'manual'
-}
-
-function persistedConfirmed(shape: ExamCanvasShapeModel): boolean {
-  return shape.confirmed ?? persistedSource(shape) !== 'ai'
-}
-
-function persistedConfidence(shape: ExamCanvasShapeModel): number | null {
-  return typeof shape.confidence === 'number' ? shape.confidence : null
-}
-
-function persistedDerivation(shape: ExamCanvasShapeModel): string | null {
-  return shape.derivation ?? null
-}
-
 function contains(outer: CanvasBounds, inner: CanvasBounds): boolean {
   const ox2 = outer.x + outer.w
   const oy2 = outer.y + outer.h
@@ -132,10 +102,10 @@ export function serializeCanvasShapes(template: ExamTemplateDetail, shapes: Exam
     const qNum = bands.length + 1
     const questionId = isUuid(top.questionId) ? top.questionId : isUuid(bottom.questionId) ? bottom.questionId : newDomainId()
     const label = top.label?.replace(/\s+(start|end)$/i, '') || bottom.label?.replace(/\s+(start|end)$/i, '') || `Q${qNum}`
-    questions.push({ id: questionId, label, order: qNum - 1, max_marks: 0, is_container: true, mark_scheme: {}, source: persistedSource(top), confirmed: persistedConfirmed(top), confidence: persistedConfidence(top), derivation: persistedDerivation(top) })
+    questions.push({ id: questionId, label, order: qNum - 1, max_marks: 0, is_container: true, mark_scheme: {} })
     bands.push({ questionId, top, bottom })
     for (const b of [top, bottom]) {
-      boundaries.push({ id: isUuid(b.id) ? b.id : newDomainId(), question_id: questionId, label: b === top ? `${label} start` : `${label} end`, page_index: pageForShape(b, pages) - 1, y: b.y, bounds: boundaryBounds(b, pages), source: persistedSource(b), confirmed: persistedConfirmed(b), confidence: persistedConfidence(b), derivation: persistedDerivation(b) })
+      boundaries.push({ id: isUuid(b.id) ? b.id : newDomainId(), question_id: questionId, label: b === top ? `${label} start` : `${label} end`, page_index: pageForShape(b, pages) - 1, y: b.y, bounds: bounds(b), source: 'manual', confirmed: true })
     }
   }
 
@@ -144,76 +114,37 @@ export function serializeCanvasShapes(template: ExamTemplateDetail, shapes: Exam
     const parentBand = bands.find((band) => bandContains(band.top, band.bottom, part))
     const qid = isUuid(part.questionId) ? part.questionId : isUuid(part.id) ? part.id : newDomainId()
     partQuestionIds.set(part.id, qid)
-    questions.push({ id: qid, parent_id: parentBand?.questionId ?? null, label: part.label || `Part ${index + 1}`, order: index, max_marks: Number(part.maxMarks ?? 0), answer_type: part.answerType ?? 'written', mcq_options: null, mark_scheme: {}, is_container: false, spec_ref: null, bounds: bounds(part), page: pageForShape(part, pages), source: persistedSource(part), confirmed: persistedConfirmed(part), confidence: persistedConfidence(part), derivation: persistedDerivation(part) })
+    questions.push({ id: qid, parent_id: parentBand?.questionId ?? null, label: part.label || `Part ${index + 1}`, order: index, max_marks: Number(part.maxMarks ?? 0), answer_type: part.answerType ?? 'written', mcq_options: null, mark_scheme: {}, is_container: false, spec_ref: null, bounds: bounds(part), page: pageForShape(part, pages) })
   })
 
-  // Resolve each region's owner question. Order: current geometric containment (a user who drags a
-  // region into a part re-attaches it) → the PERSISTED attachment if it still points at a saved
-  // question (survives pixel-overflow drift and regions with no enclosing part) → nearest part on the
-  // page → first part → first question of any kind. exam_response_areas.question_id is NOT NULL, so we
-  // never silently drop a region while any question exists (only a template with zero questions can).
-  const questionIds = new Set(questions.map((q) => q.id))
   const response_areas: TemplateReplacePayload['response_areas'] = []
   for (const region of regions) {
     const containingPart = parts.find((part) => contains(bounds(part), bounds(region)))
-    const persisted = isUuid(region.questionId) && questionIds.has(region.questionId) ? region.questionId : undefined
+    const fallbackPart = parts.find((part) => pageForShape(part, pages) === pageForShape(region, pages)) ?? parts[0]
-    const nearestPart = parts.find((part) => pageForShape(part, pages) === pageForShape(region, pages)) ?? parts[0]
+    const questionId = containingPart ? partQuestionIds.get(containingPart.id) : fallbackPart ? partQuestionIds.get(fallbackPart.id) : undefined
-    const questionId =
-      (containingPart && partQuestionIds.get(containingPart.id))
-      || persisted
-      || (nearestPart && partQuestionIds.get(nearestPart.id))
-      || questions[0]?.id
     if (!questionId) continue
     const kind = region.kind as ExamCanvasRegionKind
-    response_areas.push({ id: isUuid(region.id) ? region.id : newDomainId(), question_id: questionId, page: pageForShape(region, pages), bounds: bounds(region), kind, response_form: kind === 'response' ? (region.responseForm ?? 'lines') : null, context_type: kind === 'context' ? (region.contextType ?? 'generic') : null, source: persistedSource(region), confirmed: persistedConfirmed(region), confidence: persistedConfidence(region), mark_subtype: null, derivation: persistedDerivation(region) })
+    response_areas.push({ id: isUuid(region.id) ? region.id : newDomainId(), question_id: questionId, page: pageForShape(region, pages), bounds: bounds(region), kind, response_form: kind === 'response' ? (region.responseForm ?? 'lines') : null, context_type: kind === 'context' ? (region.contextType ?? 'generic') : null, source: 'manual', confirmed: true, confidence: null })
   }
 
-  return { meta: { title: template.title, subject: template.subject ?? undefined, page_count: template.page_count ?? undefined, status: template.status }, questions, response_areas, boundaries, layout: template.layout ?? [] }
+  return { meta: { title: template.title, subject: template.subject ?? undefined, page_count: template.page_count ?? undefined, status: template.status }, questions, response_areas, boundaries }
 }
 
 export function shapesFromTemplate(detail: ExamTemplateDetail, pages?: CanvasPageGeometry[]): ExamCanvasShapeModel[] {
   const shapes: ExamCanvasShapeModel[] = []
   const questions = new Map(detail.questions.map((q) => [q.id, q]))
   for (const b of detail.boundaries ?? []) {
-    const page = pageGeometry((b.page_index ?? 0) + 1, pages)
+    const bb = b.bounds ?? { x: 48, y: b.y, w: PAGE_WIDTH - 96, h: 8 }
-    // Boundary rows are y-lines. The old bounds rect is vestigial: keep y/domain ids,
+    shapes.push({ id: b.id, kind: 'boundary', x: Number(bb.x ?? 48), y: Number(bb.y ?? b.y), w: Number(bb.w ?? PAGE_WIDTH - 96), h: Number(bb.h ?? 8), label: b.label ?? undefined, questionId: b.question_id })
-    // but render and save a full rendered-page-width horizontal rule.
-    shapes.push({ id: b.id, kind: 'boundary', x: page.x, y: Number(b.y), w: page.w, h: 8, label: b.label ?? undefined, questionId: b.question_id, source: b.source, confirmed: b.confirmed, confidence: b.confidence, derivation: b.derivation })
   }
   for (const q of detail.questions ?? []) {
     if (q.is_container || !q.bounds) continue
-    shapes.push({ id: q.id, kind: 'part', x: Number(q.bounds.x ?? 80), y: Number(q.bounds.y ?? 120), w: Number(q.bounds.w ?? 420), h: Number(q.bounds.h ?? 180), label: q.label, maxMarks: q.max_marks, answerType: (q.answer_type as ExamCanvasShapeModel['answerType']) ?? 'written', questionId: q.id, source: q.source, confirmed: q.confirmed, confidence: q.confidence, derivation: q.derivation })
+    shapes.push({ id: q.id, kind: 'part', x: Number(q.bounds.x ?? 80), y: Number(q.bounds.y ?? 120), w: Number(q.bounds.w ?? 420), h: Number(q.bounds.h ?? 180), label: q.label, maxMarks: q.max_marks, answerType: q.answer_type ?? 'written', questionId: q.id })
   }
   for (const r of detail.response_areas ?? []) {
     const bb = r.bounds ?? { x: 100, y: pageTop(r.page, pages) + 360, w: 360, h: 120 }
     const q = questions.get(r.question_id)
-    shapes.push({ id: r.id, kind: r.kind, x: Number(bb.x ?? 100), y: Number(bb.y ?? pageTop(r.page, pages) + 360), w: Number(bb.w ?? 360), h: Number(bb.h ?? 120), label: q ? `→ ${q.label}` : r.kind, responseForm: (r.response_form as ExamCanvasShapeModel['responseForm']) ?? undefined, contextType: r.context_type ?? undefined, questionId: r.question_id, source: r.source, confirmed: r.confirmed, confidence: r.confidence, derivation: r.derivation })
+    shapes.push({ id: r.id, kind: r.kind, x: Number(bb.x ?? 100), y: Number(bb.y ?? pageTop(r.page, pages) + 360), w: Number(bb.w ?? 360), h: Number(bb.h ?? 120), label: q ? `→ ${q.label}` : r.kind, responseForm: r.response_form ?? undefined, contextType: r.context_type ?? undefined, questionId: r.question_id })
   }
-  return addCheapReviewFlags(shapes, pages)
+  return shapes
-}
-
-function overlaps(a: ExamCanvasShapeModel, b: ExamCanvasShapeModel): boolean {
-  const ax2 = a.x + a.w
-  const ay2 = a.y + a.h
-  const bx2 = b.x + b.w
-  const by2 = b.y + b.h
-  return a.x < bx2 && ax2 > b.x && a.y < by2 && ay2 > b.y
-}
-
-function looksUncertainLabel(label: string | undefined): boolean {
-  return !label || /\b(unknown|uncertain|maybe|todo|tbd)\b|\?/.test(label.toLowerCase())
-}
-
-function addCheapReviewFlags(shapes: ExamCanvasShapeModel[], pages?: CanvasPageGeometry[]): ExamCanvasShapeModel[] {
-  const markAreasByQuestion = new Set(shapes.filter((shape) => shape.kind === 'mark_area' && shape.questionId).map((shape) => shape.questionId as string))
-  return shapes.map((shape, index) => {
-    const flags: string[] = []
-    if (shape.source === 'ai' && shape.confirmed === false) flags.push('unconfirmed AI')
-    if (typeof shape.confidence === 'number' && shape.confidence < 0.7) flags.push('low confidence')
-    if ((shape.kind === 'part' || shape.kind === 'question_number') && looksUncertainLabel(shape.label)) flags.push('uncertain question label')
-    if (shape.kind === 'part' && (!shape.maxMarks || shape.maxMarks <= 0) && !markAreasByQuestion.has(shape.questionId ?? shape.id)) flags.push('missing marks')
-    const samePageOverlap = shapes.some((other, otherIndex) => otherIndex !== index && shape.kind !== 'boundary' && other.kind !== 'boundary' && pageForShape(shape, pages) === pageForShape(other, pages) && overlaps(shape, other) && (shape.kind === other.kind || (!contains(bounds(shape), bounds(other)) && !contains(bounds(other), bounds(shape)))))
-    if (samePageOverlap) flags.push('overlapping shapes')
-    return flags.length ? { ...shape, reviewFlags: flags } : shape
-  })
 }