diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
new file mode 100644
index 0000000..c3cd0cc
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -0,0 +1,97 @@
+name: Bug report
+description: Something in the app behaves differently from what it should.
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        For a wrong answer key, a duplicated question or a broken question,
+        please use **Question error report** instead — it asks for the chapter
+        and index needed to find the row.
+
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened
+      description: What you saw, in one or two sentences.
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: What you expected instead
+    validations:
+      required: true
+
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce
+      description: Numbered steps starting from a fresh page load.
+      placeholder: |
+        1. Open /app/practice
+        2. Pick Chapter 3
+        3. Answer the first question
+        4. ...
+    validations:
+      required: true
+
+  - type: input
+    id: url
+    attributes:
+      label: Page or route
+      placeholder: /app/practice/topic/book-ch3
+    validations:
+      required: false
+
+  - type: dropdown
+    id: area
+    attributes:
+      label: Which part of the app
+      options:
+        - Landing page
+        - Dashboard
+        - Practice (chapter / topic / quick / custom)
+        - Mock tests
+        - Study hub
+        - Flashcards
+        - Bookmarks
+        - Progress
+        - Profile / Settings
+        - Not sure
+    validations:
+      required: true
+
+  - type: input
+    id: environment
+    attributes:
+      label: Device and browser
+      description: >
+        Please be specific. A large share of users are on entry-level Android
+        over mobile data, and several bugs only appear there.
+      placeholder: Android 11, Chrome 120, 3G
+    validations:
+      required: true
+
+  - type: textarea
+    id: console
+    attributes:
+      label: Console errors
+      description: >
+        Open DevTools (or `chrome://inspect` on Android) and paste anything red.
+      render: text
+    validations:
+      required: false
+
+  - type: checkboxes
+    id: progress-loss
+    attributes:
+      label: Did this lose study progress?
+      description: >
+        All progress lives in this browser's `localStorage`. There is no account
+        and no server copy, so lost progress cannot be recovered — these reports
+        are triaged first.
+      options:
+        - label: Yes, saved progress, bookmarks or quiz history disappeared
+          required: false
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000..b8b22eb
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Question or idea to discuss first
+    url: https://github.com/SamirWagle/EngineeringLisenseProject/discussions
+    about: Not sure it is a bug or a feature yet? Start here.
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
new file mode 100644
index 0000000..3e3be44
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -0,0 +1,59 @@
+name: Feature request
+description: Propose something the app should do that it does not do yet.
+labels: [enhancement]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: What problem does this solve for someone studying for the NEC exam
+      description: >
+        Describe the situation you are in when you need this, not the feature.
+        The strongest requests come from someone who hit a wall while revising.
+    validations:
+      required: true
+
+  - type: textarea
+    id: proposal
+    attributes:
+      label: What you would like it to do
+    validations:
+      required: true
+
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: What you do instead today
+      description: The workaround, if there is one.
+    validations:
+      required: false
+
+  - type: dropdown
+    id: scope
+    attributes:
+      label: Does this need a server
+      description: >
+        The app is currently frontend-only: all data is static JSON and all
+        state is in this browser's `localStorage`. Anything needing an account,
+        sync across devices, or a leaderboard depends on the backend work that
+        is still in progress, and will be scheduled behind it.
+      options:
+        - No, it can work entirely in the browser
+        - Yes, it needs accounts or cross-device sync
+        - Not sure
+    validations:
+      required: true
+
+  - type: checkboxes
+    id: constraints
+    attributes:
+      label: Constraints you have considered
+      options:
+        - label: >
+            It does not meaningfully grow the initial page download. CI fails
+            above 180 kB of gzipped initial-load JavaScript, because much of the
+            audience is on entry-level Android over 3G.
+          required: false
+        - label: It works offline, or degrades cleanly without a network.
+          required: false
+        - label: I would be willing to open a PR for this.
+          required: false
diff --git a/.github/ISSUE_TEMPLATE/question_error.yml b/.github/ISSUE_TEMPLATE/question_error.yml
new file mode 100644
index 0000000..05a3a57
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/question_error.yml
@@ -0,0 +1,86 @@
+name: Question error report
+description: A question has the wrong answer, bad options, or is a duplicate.
+title: '[question] '
+labels: [question-bank]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        A wrong answer key teaches the wrong thing, so these are the highest
+        priority reports in the project.
+
+        Before filing, it helps to know that `scripts/validate-questions.mjs`
+        already catches several classes of defect automatically, and that
+        questions it proved unanswerable are listed in
+        `frontend/src/data/quarantine.json` and withheld from practice. If the
+        question you hit is already in that file, there is nothing to report —
+        though a suggested correction is very welcome.
+
+        `docs/question-format.md` explains the data format and every failure
+        mode the validator checks.
+
+  - type: dropdown
+    id: chapter
+    attributes:
+      label: Chapter
+      description: Shown in the practice header, and in the URL as `book-chN`.
+      options:
+        - ch1
+        - ch2
+        - ch3
+        - ch4
+        - ch5
+        - ch6
+        - ch7
+        - ch8
+        - ch9
+        - ch10
+        - Not sure
+    validations:
+      required: true
+
+  - type: textarea
+    id: stem
+    attributes:
+      label: The question text
+      description: >
+        Copy it exactly. This is what we search the JSON for, so an exact copy
+        locates the row faster than anything else.
+      render: text
+    validations:
+      required: true
+
+  - type: dropdown
+    id: defect
+    attributes:
+      label: What is wrong with it
+      options:
+        - The marked correct answer is wrong
+        - Two or more options are identical
+        - No option is correct
+        - More than one option is correct
+        - The question text is cut off or incomplete
+        - It is a duplicate of another question
+        - Typo or formatting only
+        - Other
+    validations:
+      required: true
+
+  - type: textarea
+    id: correction
+    attributes:
+      label: What it should be
+      description: >
+        Which option is actually correct, and ideally why — a textbook section,
+        a formula, or a past paper. A correction with a source can be applied
+        directly; one without needs independent verification first.
+    validations:
+      required: true
+
+  - type: markdown
+    attributes:
+      value: |
+        **Note on option order.** Options are deliberately reordered before they
+        are shown to you, because the authored bank has a severe answer-position
+        bias. "Option B is marked correct but it should be C" is therefore
+        ambiguous — please quote the option *text*, not its letter or number.
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 0000000..8d50cce
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,60 @@
+<!--
+Three sections, all required. Write them yourself — the point of the third one
+is to prove the diff is understood, which a generated summary cannot do.
+Delete these comments before submitting.
+-->
+
+## What changed and why
+
+<!--
+What this PR does, and the problem it solves. Link the issue if there is one
+(`Closes #123`). If it changes behaviour a student will notice, say what they
+will see.
+-->
+
+## How it was tested
+
+<!--
+Name the commands you ran and what they said. "Tested" without a command is not
+tested.
+
+    cd frontend
+    npx tsc -b
+    npm run lint
+    npx vitest run
+    npm run build
+    node ../.github/scripts/bundle-budget.mjs
+
+And, for any change touching frontend/public/data/books/ or the question loader:
+
+    node scripts/validate-questions.mjs
+
+Paste the relevant output. For a UI change, a screenshot at a narrow viewport
+(360px wide) is worth more than one at desktop width.
+-->
+
+## Explain the diff in your own words
+
+<!--
+Walk through the change file by file: what each edit does and why that approach
+rather than the obvious alternative. Call out anything you are unsure about, and
+anything a reviewer should look at hardest.
+-->
+
+---
+
+### Checklist
+
+- [ ] `npx tsc -b`, `npm run lint`, `npx vitest run` and `npm run build` all pass locally
+- [ ] `node scripts/validate-questions.mjs` passes — required if this touches question data or the loader
+- [ ] Initial-load JS is still within budget (the `Frontend` CI job prints the number)
+- [ ] No new `eslint-disable`, `@ts-ignore`, `@ts-expect-error` or skipped test; if there is one, the PR explains why
+- [ ] `frontend/src/data/bookChapters.generated.ts` is regenerated and committed, if chapter JSONs changed
+- [ ] The README and `docs/` still describe what the code actually does
+
+### If this changes question data
+
+- [ ] Every row has `correct_option_index` **1-based** and `correct_option` matching the text at that index exactly
+- [ ] No duplicate option text within a question, and no duplicate stems against the existing bank
+- [ ] The correct answer is not always in the same position — see `docs/question-format.md`
+- [ ] Any ids removed from `frontend/src/data/quarantine.json` have had their underlying rows actually fixed
diff --git a/.github/scripts/bundle-budget.mjs b/.github/scripts/bundle-budget.mjs
new file mode 100644
index 0000000..870f33a
--- /dev/null
+++ b/.github/scripts/bundle-budget.mjs
@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * bundle-budget.mjs
+ *
+ * Fails the build when initial-load JavaScript grows past its budget.
+ *
+ * Why a hard gate rather than a dashboard: most of this app's audience sits on
+ * entry-level Android handsets on 3G in Nepal. On a 400 kbit/s effective link,
+ * every 50 kB of gzipped JavaScript is roughly another second before anything is
+ * interactive - and that is before the phone has to parse and compile it. A
+ * budget that nothing enforces is a number in a README; this one blocks the PR.
+ *
+ * What counts as "initial-load": exactly the JavaScript the browser fetches
+ * before it can render the landing page. Vite declares that set in dist/index.html
+ * as the entry <script type="module"> plus one <link rel="modulepreload"> per
+ * static import of that entry. Route chunks behind React.lazy() are NOT listed
+ * there and are NOT counted - they are the reason the budget is affordable, and
+ * counting them would punish code splitting.
+ *
+ * Sizes are gzipped, because that is what crosses the wire. 1 kB = 1000 bytes,
+ * matching Vite's own build report so the two sets of numbers can be compared.
+ *
+ * Usage:
+ *   node .github/scripts/bundle-budget.mjs
+ *   node .github/scripts/bundle-budget.mjs --dist frontend/dist --budget 180
+ *   node .github/scripts/bundle-budget.mjs --json
+ *
+ * Exit codes: 0 within budget, 1 over budget, 2 could not run.
+ */
+
+import { readFileSync, existsSync, statSync, appendFileSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { gzipSync } from 'node:zlib';
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+const args = process.argv.slice(2);
+const flag = (name, fallback) => {
+  const i = args.indexOf(`--${name}`);
+  return i !== -1 && args[i + 1] ? args[i + 1] : fallback;
+};
+
+const DIST = resolve(REPO_ROOT, flag('dist', 'frontend/dist'));
+/** Budget in kB (1000 bytes) of gzipped initial-load JavaScript. */
+const BUDGET_KB = Number(flag('budget', '180'));
+const BUDGET_BYTES = BUDGET_KB * 1000;
+const asJson = args.includes('--json');
+
+if (!Number.isFinite(BUDGET_KB) || BUDGET_KB <= 0) {
+  console.error(`Invalid --budget: ${flag('budget', '180')}`);
+  process.exit(2);
+}
+
+const INDEX = join(DIST, 'index.html');
+if (!existsSync(INDEX)) {
+  console.error(
+    `No build to measure: ${INDEX} does not exist.\n` +
+      `Run the production build first (cd frontend && npm run build).`
+  );
+  process.exit(2);
+}
+
+const html = readFileSync(INDEX, 'utf8');
+
+/**
+ * Pull every local asset reference out of index.html.
+ *
+ * Only same-origin references are measured. A third-party <script src="https://...">
+ * (this page loads AdSense) is real cost to the user but is not shipped from this
+ * repo, cannot be fixed by a diff here, and would make the number depend on a
+ * vendor we do not control.
+ */
+const isLocal = (url) => !!url && !/^(https?:)?\/\//.test(url) && !url.startsWith('data:');
+const unique = (xs) => [...new Set(xs)];
+
+const collect = (re, group) =>
+  unique([...html.matchAll(re)].map((m) => m[group]).filter(isLocal));
+
+// Entry module(s): <script type="module" src="/assets/index-xxxx.js">
+const entryScripts = collect(/<script\b[^>]*\bsrc=["']([^"']+)["'][^>]*>/gi, 1);
+// Static imports of the entry, hoisted by Vite: <link rel="modulepreload" href="...">
+const preloadedModules = collect(
+  /<link\b[^>]*\brel=["'](?:modulepreload|preload)["'][^>]*\bhref=["']([^"']+)["'][^>]*>/gi,
+  1
+);
+// Render-blocking stylesheets. Not part of the JS budget, but reported, since
+// they block first paint and are easy to forget.
+const stylesheets = collect(
+  /<link\b[^>]*\brel=["']stylesheet["'][^>]*\bhref=["']([^"']+)["'][^>]*>/gi,
+  1
+);
+
+const sizeOf = (url) => {
+  const file = join(DIST, url.replace(/^\//, '').split('?')[0]);
+  if (!existsSync(file) || !statSync(file).isFile()) return null;
+  const buf = readFileSync(file);
+  // Default zlib level, to match Vite's own gzip column.
+  return { url, raw: buf.length, gzip: gzipSync(buf).length };
+};
+
+const measure = (urls, kind) =>
+  urls
+    .map((u) => {
+      const s = sizeOf(u);
+      if (!s) {
+        console.error(`::warning::Referenced in index.html but missing from the build: ${u}`);
+        return null;
+      }
+      return { ...s, kind };
+    })
+    .filter(Boolean);
+
+const js = [
+  ...measure(entryScripts, 'entry'),
+  ...measure(preloadedModules, 'static-import'),
+].filter((a) => /\.m?js$/.test(a.url));
+
+const css = measure(stylesheets, 'stylesheet');
+
+if (js.length === 0) {
+  console.error(
+    `Found no initial-load JavaScript in ${INDEX}. ` +
+      `Either the build is broken or the markup no longer matches what this script parses.`
+  );
+  process.exit(2);
+}
+
+const sum = (xs, k) => xs.reduce((n, x) => n + x[k], 0);
+const totalGzip = sum(js, 'gzip');
+const totalRaw = sum(js, 'raw');
+const cssGzip = sum(css, 'gzip');
+const over = totalGzip > BUDGET_BYTES;
+
+const kb = (n) => (n / 1000).toFixed(2);
+const pct = ((totalGzip / BUDGET_BYTES) * 100).toFixed(1);
+
+const report = {
+  budgetKb: BUDGET_KB,
+  initialJs: { rawBytes: totalRaw, gzipBytes: totalGzip, chunks: js },
+  blockingCss: { gzipBytes: cssGzip, files: css },
+  usedPercent: Number(pct),
+  withinBudget: !over,
+};
+
+if (asJson) {
+  console.log(JSON.stringify(report, null, 2));
+} else {
+  const rows = [...js].sort((a, b) => b.gzip - a.gzip);
+  const name = (u) => u.replace(/^.*\//, '');
+  const width = Math.max(12, ...rows.map((r) => name(r.url).length));
+
+  console.log(`\n  Initial-load JavaScript budget\n`);
+  console.log(`  ${'chunk'.padEnd(width)} ${'raw kB'.padStart(9)} ${'gzip kB'.padStart(9)}`);
+  for (const r of rows) {
+    console.log(`  ${name(r.url).padEnd(width)} ${kb(r.raw).padStart(9)} ${kb(r.gzip).padStart(9)}`);
+  }
+  console.log(`  ${'-'.repeat(width + 20)}`);
+  console.log(
+    `  ${`TOTAL (${rows.length} chunks)`.padEnd(width)} ${kb(totalRaw).padStart(9)} ${kb(totalGzip).padStart(9)}`
+  );
+  if (css.length) {
+    console.log(
+      `\n  Render-blocking CSS (not in the JS budget): ${kb(cssGzip)} kB gzip ` +
+        `across ${css.length} file(s)`
+    );
+  }
+  console.log(
+    `\n  ${kb(totalGzip)} kB of ${BUDGET_KB} kB used (${pct}%). ` +
+      `${over ? 'OVER BUDGET' : `${kb(BUDGET_BYTES - totalGzip)} kB of headroom`}.\n`
+  );
+}
+
+// GitHub Actions surfaces: a job-summary table and, on failure, an annotation.
+if (process.env.GITHUB_STEP_SUMMARY) {
+  const lines = [
+    `### Initial-load JS budget: ${over ? 'FAIL' : 'pass'}`,
+    '',
+    `**${kb(totalGzip)} kB** gzipped of a **${BUDGET_KB} kB** budget (${pct}% used).`,
+    '',
+    '| chunk | raw kB | gzip kB |',
+    '| --- | --: | --: |',
+    ...[...js]
+      .sort((a, b) => b.gzip - a.gzip)
+      .map((r) => `| \`${r.url.replace(/^.*\//, '')}\` | ${kb(r.raw)} | ${kb(r.gzip)} |`),
+    `| **total** | **${kb(totalRaw)}** | **${kb(totalGzip)}** |`,
+    '',
+    `Render-blocking CSS, outside this budget: ${kb(cssGzip)} kB gzip.`,
+    '',
+    'Route chunks loaded behind `React.lazy()` are excluded: they are not fetched',
+    'before first render. Keep them that way.',
+    '',
+  ];
+  appendFileSync(process.env.GITHUB_STEP_SUMMARY, lines.join('\n'));
+}
+
+if (over) {
+  console.error(
+    `::error::Initial-load JavaScript is ${kb(totalGzip)} kB gzipped, over the ` +
+      `${BUDGET_KB} kB budget by ${kb(totalGzip - BUDGET_BYTES)} kB. ` +
+      `Lazy-load it behind a route, drop the dependency, or raise the budget deliberately ` +
+      `in .github/workflows/ci.yml with a reason.`
+  );
+  process.exit(1);
+}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..66e9356
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,132 @@
+name: CI
+
+# Until this file existed there was no automated check of any kind on this
+# repository, which is how 15 ESLint errors reached `main`. Every gate below
+# corresponds to a class of defect that has actually shipped here.
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+# A new push to the same branch makes the previous run's answer irrelevant.
+# Cancelling it returns the runner and gets the new answer sooner.
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+env:
+  # 22, not 20: scripts/validate-questions.mjs imports the app's option-ordering
+  # module directly from TypeScript so there is only one implementation of it.
+  # Native type stripping landed in Node 22.18; on Node 20 that import fails.
+  NODE_VERSION: '22'
+
+jobs:
+  # ---------------------------------------------------------------------------
+  # The question bank is plain JSON and the validator imports nothing outside
+  # node: builtins, so this job needs no npm install. It is kept separate from
+  # the frontend job for exactly that reason: a bad answer key is reported in
+  # seconds instead of waiting behind a dependency install and a Vite build.
+  # ---------------------------------------------------------------------------
+  question-bank:
+    name: Question bank
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      # Gates: answer keys that contradict themselves (KEY_CONFLICT),
+      # correct_option_index pointing past the last option (INDEX_RANGE),
+      # identical option text (OPTION_DUPLICATE), missing or non-string fields,
+      # malformed JSON, and answer-position bias measured AFTER the loader's
+      # option reordering. Known-bad rows listed in
+      # frontend/src/data/quarantine.json are reported but do not fail, so the
+      # gate stays usable while that backlog is worked down.
+      # See docs/question-format.md for what each code means and why.
+      - name: Validate question bank
+        run: node scripts/validate-questions.mjs --csv question-bank-triage.csv
+
+      # The validator writes the CSV before it decides its exit code, so the
+      # triage list is available precisely when the job failed and it is needed.
+      - name: Upload triage CSV
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: question-bank-triage
+          path: question-bank-triage.csv
+          if-no-files-found: ignore
+          retention-days: 14
+
+  # ---------------------------------------------------------------------------
+  # Type check, lint, unit tests, production build, bundle budget. One job, one
+  # `npm ci`: every step here needs node_modules, and on a project this size a
+  # second cached install costs more than the steps it would parallelise.
+  # ---------------------------------------------------------------------------
+  frontend:
+    name: Frontend
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    defaults:
+      run:
+        working-directory: frontend
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: npm
+          cache-dependency-path: frontend/package-lock.json
+
+      # `npm ci` and not `npm install`: it installs the locked tree exactly and
+      # fails if package.json and package-lock.json have drifted apart, which is
+      # itself a defect worth failing on.
+      - name: Install dependencies
+        run: npm ci
+
+      # Gates type errors. `tsc -b` honours the project references in
+      # tsconfig.json (tsconfig.app.json + tsconfig.node.json) and emits nothing.
+      - name: Type check
+        run: npx tsc -b
+
+      # Gates lint errors. This is the check whose absence let 15 errors land.
+      - name: Lint
+        run: npm run lint
+
+      # Gates behaviour. Tests live in src/**/__tests__ and run under jsdom.
+      - name: Unit tests
+        run: npx vitest run
+
+      # Gates the production build, which is a stricter path than dev: it
+      # regenerates bookChapters.generated.ts from the chapter JSONs via
+      # scripts/sync-chapters.mjs, re-runs tsc and ESLint, then builds. The
+      # repeat of tsc/lint is deliberate - this is the exact command Vercel
+      # runs, so it is the one whose failure matters.
+      - name: Build
+        run: npm run build
+
+      # Gates payload. Fails if the JavaScript needed before first render
+      # exceeds 180 kB gzipped. The audience is largely on entry-level Android
+      # handsets on 3G in Nepal, where that budget is roughly the difference
+      # between a usable app and an abandoned tab. Route chunks behind
+      # React.lazy() are excluded by design.
+      - name: Initial-load JS budget
+        run: node ../.github/scripts/bundle-budget.mjs --dist frontend/dist --budget 180
+
+      # The generated manifest is committed. If the build rewrote it, the commit
+      # is stale and the counts shown in the app disagree with the JSON on disk.
+      - name: Check generated files are committed
+        run: |
+          if ! git diff --quiet -- src/data/bookChapters.generated.ts; then
+            msg="Out of date. Run 'node scripts/sync-chapters.mjs' and commit the result."
+            echo "::error file=frontend/src/data/bookChapters.generated.ts::$msg"
+            git --no-pager diff -- src/data/bookChapters.generated.ts
+            exit 1
+          fi
diff --git a/.gitignore b/.gitignore
index 7b6d43f..a6cb74b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,29 @@ frontend/dist/
 .env.*.local
 frontend/.env
 frontend/.env.local
+# The production build's API base URL. A VITE_ variable is public by
+# definition -- it is compiled into the bundle every visitor downloads -- and
+# this one holds only the Worker's URL, so there is nothing here to protect.
+# It stays out of the repo anyway because the stage guard treats every .env
+# file as a secret file, and that rule is worth more than the convenience of
+# building from a clean checkout without one extra step.
+# docs/deploy-cloudflare.md step 6 says how to recreate it.
+frontend/.env.production
+
+# Local secrets for `wrangler dev`. Wrangler reads this file and puts its
+# contents on `env` exactly as deployed secrets arrive, which is what lets the
+# Google flow be tested locally without a deploy. It holds real credentials.
+worker/.dev.vars
+.dev.vars
+
+# Belt and braces for credentials that end up loose in the tree. A secret
+# should never be in a file here at all -- it belongs in `wrangler secret put`,
+# which reads from the terminal and stores it on Cloudflare -- but a wildcard
+# costs nothing and a leaked client secret costs a rotation.
+*secret*
+*.pem
+*.key
+!scripts/*secret*
 
 # Logs
 *.log
@@ -37,3 +60,28 @@ frontend/.vite/
 
 # Debug artifacts
 debug_screenshot.png
+
+# Test / coverage output
+coverage/
+frontend/coverage/
+.vitest/
+
+# Lint cache
+.eslintcache
+
+# Validator and budget reports (generated on demand and in CI)
+question-bank-triage.csv
+*-triage.csv
+bundle-budget.json
+
+# Hosting CLI state
+.vercel
+frontend/.vercel
+
+# Local agent / tool scratch
+.claude/settings.local.json
+
+# Working artefact from scripts/classify-subchapters.mjs --review. Regenerate it
+# rather than committing it: it is 1,536 rows derived from the term lists, so a
+# committed copy is stale the moment a term changes.
+subchapter-review.tsv
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..2bfd77f
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,193 @@
+# Contributing to NECPrep
+
+NECPrep is a free study platform for people sitting the Nepal Engineering
+Council licence exam. Two facts about its users shape almost every rule below:
+
+- **A wrong answer key is the worst bug this project can ship.** It does not
+  throw an error, it teaches the wrong thing to someone preparing for a
+  licensing exam, and they have no way to tell.
+- **Most of the audience is on entry-level Android handsets on mobile data in
+  Nepal.** Payload is a feature. CI enforces a hard budget on it.
+
+Everything else is ordinary open-source contribution.
+
+---
+
+## Getting set up
+
+Requires **Node 20+** and npm 9+.
+
+```bash
+git clone https://github.com/SamirWagle/EngineeringLisenseProject.git
+cd EngineeringLisenseProject/frontend
+npm install
+npm run dev          # http://localhost:5173
+```
+
+`npm run dev` first runs `scripts/sync-chapters.mjs`, which regenerates
+`frontend/src/data/bookChapters.generated.ts` from the chapter JSONs in
+`frontend/public/data/books/`.
+
+There is no backend to run and no environment variables to set. The app fetches
+static JSON and keeps all state in `localStorage`.
+
+## The commands CI runs
+
+Run these before you open a PR. They are exactly the checks that gate it.
+
+```bash
+cd frontend
+npx tsc -b           # type check (project references; emits nothing)
+npm run lint         # ESLint
+npx vitest run       # unit tests, jsdom
+npm run build        # sync-chapters + tsc + eslint + vite build
+
+# from the repo root
+node .github/scripts/bundle-budget.mjs     # initial-load JS budget
+node scripts/validate-questions.mjs        # question bank quality gate
+```
+
+`npm run test:watch` runs Vitest in watch mode while you work.
+
+The question-bank validator needs no `node_modules` at all — it imports only
+`node:` builtins — so you can run it from a clean checkout.
+
+## What CI gates
+
+Two jobs, in `.github/workflows/ci.yml`:
+
+**`Question bank`** — runs `scripts/validate-questions.mjs`. Fails on answer keys
+that contradict themselves, indices pointing past the last option, identical
+option text, missing or mistyped fields, malformed JSON, and answer-position bias
+measured after the loader's option reordering. No install step, so it answers in
+seconds. Full reference: [`docs/question-format.md`](docs/question-format.md).
+
+**`Frontend`** — type check, lint, unit tests, production build, initial-load JS
+budget, and a check that `bookChapters.generated.ts` is not stale.
+
+Both must pass. If a check is failing for a reason you believe is wrong, say so
+in the PR — do not add a suppression to get to green.
+
+### The bundle budget
+
+`.github/scripts/bundle-budget.mjs` fails the build if the JavaScript needed
+before first render exceeds **180 kB gzipped**.
+
+"Initial-load" means precisely the entry `<script type="module">` in
+`dist/index.html` plus every `<link rel="modulepreload">` Vite emits beside it —
+the static import graph of the entry. Route chunks behind `React.lazy()` are
+excluded, which is what makes the budget affordable.
+
+Measured 2026-10-20: **365.23 kB raw / 118.81 kB gzipped**, about 66% of budget.
+`react` alone is 60.29 kB gzipped of that and `framer-motion` another 37.82 kB.
+Render-blocking CSS sits outside the JS budget and is reported alongside it. Run
+the script for current numbers; the `Frontend` CI job writes the same table into
+its run summary.
+
+If you need a new dependency:
+
+1. Check whether it can load behind a route with `React.lazy()`, or on demand.
+2. Check its gzipped cost — run the budget script before and after.
+3. If it must be in the initial load and pushes past the budget, that is a
+   conversation in the PR, not a number to edit. The budget lives in the
+   workflow and is changed deliberately, with a reason recorded.
+
+## Code standards
+
+- **TypeScript, strict.** No `any`, no `@ts-ignore`, no `@ts-expect-error`
+  without a comment explaining why it is unavoidable.
+- **No new `eslint-disable`.** The absence of CI is how 15 ESLint errors reached
+  `main`; the fix is not to silence them.
+- **Do not weaken a check to pass it.** Deleting an assertion, skipping a test,
+  or raising a threshold to get green is a change to the project's quality bar
+  and needs to be argued for explicitly, not slipped into a diff.
+- **Keep refactors and behaviour changes in separate commits.** A reviewer
+  should be able to see which lines change what the app does.
+- Conventional Commits for messages: `feat:`, `fix:`, `refactor:`, `docs:`,
+  `test:`, `chore:`.
+- Tests go in `__tests__/` next to the code, named `*.test.ts(x)`.
+
+### Accessibility and small screens
+
+Design for a 360px-wide viewport first. Keyboard navigation and visible focus
+states are requirements, not polish — a meaningful share of users are on cheap
+devices with unreliable touch digitisers.
+
+## Working on question data
+
+**Read [`docs/question-format.md`](docs/question-format.md) first.** It documents
+the `{qsns, opt1..opt4, correct_option, correct_option_index}` format, the fact
+that `correct_option_index` is **1-based**, every failure mode the validator
+catches with worked examples from real defects in this bank, the answer-position
+bias and how the loader neutralises it, and the quarantine list.
+
+The short version:
+
+- `correct_option_index` is 1-based. `1` is `opt1`, `4` is `opt4`.
+- `correct_option` must be the full text of the option at that index,
+  character-for-character.
+- No two options in a question may have the same text.
+- Search the existing bank for your stem before adding it. The bank has a
+  substantial duplicate backlog and PRs should not add to it.
+- Vary which slot the correct answer sits in. Roughly a quarter in each.
+- Never write "both (a) and (c)" or refer to an option by letter or number.
+  Options are reordered before display, so such references are broken by
+  construction.
+- `node scripts/validate-questions.mjs` must exit 0.
+
+Questions that are provably broken and not yet fixed are listed in
+`frontend/src/data/quarantine.json` and withheld from practice. Removing an id
+from that list without fixing the underlying row puts a broken question back in
+front of students.
+
+## Reporting a problem with a question
+
+Use the **Question error report** issue template. Quote the question text exactly
+and quote the correct option's *text*, not its letter or number — options are
+reordered per question, so "option B" means nothing to anyone else.
+
+A correction with a source (textbook section, formula, past paper) can be applied
+directly. One without needs independent verification first, so it takes much
+longer.
+
+## Pull requests
+
+1. Branch from `main`. One change per branch.
+2. Stage the files you changed by name. Avoid `git add -A`.
+3. Run the commands above.
+4. Open the PR. The template has three required sections — **what changed and
+   why**, **how it was tested**, and **explain the diff in your own words**.
+   Write all three yourself. The third exists to show the diff is understood,
+   which is the thing a reviewer most needs and the thing a generated summary
+   cannot provide.
+5. "Tested" names the command you ran and shows its output. "Fixed" shows the
+   failing run before and the passing run after.
+
+For UI changes, include a screenshot at 360px wide.
+
+## Project layout
+
+```
+.
+├── .github/
+│   ├── workflows/ci.yml            # the two CI jobs
+│   └── scripts/bundle-budget.mjs   # initial-load JS budget check
+├── docs/question-format.md         # question bank format and validation reference
+├── scripts/
+│   ├── sync-chapters.mjs           # chapter JSONs -> bookChapters.generated.ts
+│   └── validate-questions.mjs      # question bank quality gate
+└── frontend/
+    ├── public/data/books/ch1..ch10.json   # the question bank
+    └── src/
+        ├── routes/AppRoutes.tsx    # all routes; everything under /app is lazy
+        ├── services/localData.ts   # question loading, option ordering, localStorage
+        ├── data/                   # chapter manifest, topics, quarantine list
+        ├── hooks/useChapters.ts
+        ├── layout/AppShell.tsx
+        └── pages/                  # Landing.tsx + pages/app/*
+```
+
+## Licence
+
+By contributing you agree your work is distributed under the project's
+[MIT licence](LICENSE).
diff --git a/README.md b/README.md
index b283836..22b41d9 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
 <div align="center">
 
-<img src="frontend/public/favicon.ico" alt="NECPrep Logo" width="80" height="80" />
+<img src="frontend/public/favicon.svg" alt="NECPrep logo" width="80" height="80" />
 
 # NECPrep
 
-**The open-source exam preparation platform for Nepal Engineering Council (NEC) license candidates.**
+**Free, open-source exam preparation for Nepal Engineering Council (NEC) licence candidates.**
 
 [![React](https://img.shields.io/badge/React-19-61DAFB?logo=react&logoColor=white)](https://react.dev)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.9-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org)
@@ -20,34 +20,60 @@
 
 ---
 
-## Table of Contents
-
-- [About the Project](#-about-the-project)
-- [Screenshots](#-screenshots)
-- [Features](#-features)
-- [Topics Covered](#-topics-covered)
-- [Tech Stack](#-tech-stack)
-- [Project Structure](#-project-structure)
-- [Getting Started](#-getting-started)
-  - [Prerequisites](#prerequisites)
-  - [Installation](#installation)
-  - [Running Locally](#running-locally)
-  - [Building for Production](#building-for-production)
-- [Question Data](#-question-data)
-- [Contributing](#-contributing)
-- [Roadmap](#-roadmap)
-- [Acknowledgements](#-acknowledgements)
-- [License](#-license)
+## Contents
+
+- [What this is](#what-this-is)
+- [Current state](#current-state)
+- [Screenshots](#screenshots)
+- [Features](#features)
+- [The question bank](#the-question-bank)
+- [Known data defects and the quality gate](#known-data-defects-and-the-quality-gate)
+- [Architecture](#architecture)
+- [Tech stack](#tech-stack)
+- [Getting started](#getting-started)
+- [Commands](#commands)
+- [Performance budget](#performance-budget)
+- [Project structure](#project-structure)
+- [Contributing](#contributing)
+- [Roadmap](#roadmap)
+- [Licence](#licence)
 
 ---
 
-## About the Project
+## What this is
 
-**NECPrep** is a free, open-source study platform designed specifically for engineers preparing for the **Nepal Engineering Council (NEC) license examination**. It brings together a rich question bank, smart practice modes, timed mock tests, and progress analytics — all in a clean, fast, fully client-side web app that works without any backend sign-up.
+A study app for the **Nepal Engineering Council licence examination** (Computer
+Engineering). It serves a bank of multiple-choice questions organised by textbook
+chapter, with chapter practice, timed mock tests, flashcards, bookmarks and
+progress tracking.
 
-> No account required. Open the app, enter your name, and start studying immediately.
+> No account. Open the app, type a name, start practising. The name is stored in
+> this browser and nothing is sent anywhere.
 
-🌐 **Try it now:** [lisensepreparation.samirwagle.com.np](https://lisensepreparation.samirwagle.com.np/)
+**Try it:** [lisensepreparation.samirwagle.com.np](https://lisensepreparation.samirwagle.com.np/)
+
+### Who it is built for
+
+A large share of users are on **entry-level Android handsets on 3G or metered
+mobile data in Nepal**. That single fact drives most of the engineering decisions
+in this repo: the app is static, works offline once loaded, splits every route
+out of the initial download, and has a CI-enforced ceiling on how much JavaScript
+it may ship before first render.
+
+---
+
+## Current state
+
+Read this section before the feature list. The project is mid-rebuild and this
+README is written to describe what the code does today, not what is planned.
+
+| | |
+|---|---|
+| **Backend** | **None.** The app is entirely frontend. All questions are static JSON fetched from `/data/books/`. A Cloudflare Workers + D1 backend is in progress and is not yet in this repository. |
+| **Accounts / authentication** | **None.** There is no sign-up, no login, no session, no password. The "login" on the landing page writes a display name to `localStorage` (`UserContext`, key `userName`) and nothing more. Every route under `/app` is publicly reachable. |
+| **Data persistence** | Browser `localStorage` only. Progress, bookmarks, quiz history and in-progress mock drafts live in one browser and **cannot be recovered if cleared**. Settings offers an export to JSON. |
+| **Question bank** | 10 book chapters, under active repair — see [below](#the-question-bank). A validator gates it in CI. 145 questions are currently quarantined and withheld from practice. |
+| **Deployment** | Static build on Vercel (`frontend/vercel.json`). CI does not deploy; it only gates. |
 
 ---
 
@@ -55,74 +81,151 @@
 
 <div align="center">
 
-| Landing Page | Dashboard | Practice Hub |
-|:---:|:---:|:---:|
-| ![Landing](Screenshots/Screenshot%202026-03-05%20212111.png) | ![Dashboard](Screenshots/Screenshot%202026-03-05%20212124.png) | ![Practice](Screenshots/Screenshot%202026-03-05%20212137.png) |
+| Landing page | Mock test detail |
+|:---:|:---:|
+| ![Landing](Screenshots/Screenshot%202026-03-05%20212111.png) | ![Mock test](Screenshots/Screenshot%202026-03-05%20212137.png) |
 
 </div>
 
+Captured 2026-03-05; the UI has moved on since. "Sign In" on the landing page
+opens a name prompt — it stores a display name in this browser and does not
+create an account.
+
 ---
 
 ## Features
 
-| Feature | Description |
+| Feature | What it actually does |
 |---|---|
-| **Dashboard** | Personalized overview showing accuracy, questions attempted, topics started, and recent quiz history |
-| **Practice Hub** | Multiple practice modes — topic-based, chapter-based, quick random, and fully custom |
-| **Topic Practice** | Drill per-subject question banks across all 10 NEC exam topics |
-| **Chapter Practice** | Practice directly from textbook chapters (Books Ch 1–10) |
-| **Quick Practice** | Instant 10-question random quiz to warm up fast |
-| **Custom Practice** | Build your own quiz by selecting topics and question count |
-| **Mock Tests** | Full-length, timed exams that simulate the real NEC license test |
-| **Study Hub** | Read and review topic summaries before attempting questions |
-| **Flashcards** | Flip-card review mode drawn from the question bank for active recall |
-| **Bookmarks** | Save any question to revisit later |
-| **Progress Tracker** | Visual analytics: overall completion %, accuracy rate, per-chapter breakdown |
-| **3D Landing Page** | Immersive animated Three.js background on the landing screen |
-| **Fully Offline-Ready** | All question data is bundled as JSON; progress is saved in `localStorage` |
+| **Chapter practice** | Question-by-question practice from any of the 10 book chapters, with immediate feedback |
+| **Quick practice** | A 10-question random set drawn across the bank |
+| **Custom practice** | Pick chapters and a question count, get a quiz |
+| **Mock tests** | Three timed configurations (10 per chapter / 45 min, a second 10-per-chapter set, and 5 per chapter / 20 min). Defined in `frontend/src/data/topics.ts`. Drafts survive a page reload |
+| **Study hub** | Chapter-level syllabus and summary reading before practice |
+| **Flashcards** | Flip-card recall over the chapter banks |
+| **Bookmarks** | Flag any question and come back to it |
+| **Progress** | Accuracy, questions attempted, and a per-chapter breakdown, computed from `localStorage` |
+| **Settings** | Change display name, export all local data as JSON, reset all progress |
+| **Deterministic option ordering** | Options are reordered before display to neutralise a severe answer-position bias in the authored data — [see below](#answer-position-bias) |
+| **Works offline** | Static assets plus static JSON; once a chapter is loaded it needs no network |
+
+### Not implemented, despite appearances
+
+- **No theme switching.** The app is dark-only. A Dark Mode toggle previously
+  shipped in Settings and controlled nothing; it has been removed rather than
+  left as a lie.
+- **No authentication, cloud sync, or leaderboard.** See
+  [Current state](#current-state).
 
 ---
 
-## Topics Covered
+## The question bank
+
+The bank lives in `frontend/public/data/books/` as `ch1.json` … `ch10.json` and
+is fetched at runtime. There is **no** aggregated `all_questions.json` and no
+`model-question.json`; earlier versions of this README documented both, and the
+topic-based JSONs they summarised were deleted in commit `7ba0454`. The ten book
+chapters are now the only question source, and they *are* the subject split.
+
+**Snapshot measured 2026-10-20** with `node scripts/validate-questions.mjs`, while
+deduplication of the bank was still in progress:
+
+| File | Chapter | Rows |
+|---|---|---:|
+| `ch1.json` | Basic Electrical & Electronics | 525 |
+| `ch2.json` | Digital Logic & Number Systems | 332 |
+| `ch3.json` | C / C++ Programming | 391 |
+| `ch4.json` | Computer Organization & Embedded Systems | 422 |
+| `ch5.json` | Computer Networks & Security | 69 |
+| `ch6.json` | Theory of Computation & Computer Graphics | 64 |
+| `ch7.json` | DSA, DBMS and OS | 68 |
+| `ch8.json` | Software Engineering and OOAD | 130 |
+| `ch9.json` | AI & Machine Learning | 71 |
+| `ch10.json` | Project Planning, Design and Implementation | 240 |
+| | **Total rows** | **2,312** |
+| | of which unique stems | 2,243 |
+| | quarantined, not shown to students | 145 |
+
+> **These numbers move.** The bank is being actively deduplicated and repaired, so
+> treat the table as a dated snapshot, not a specification. For the current
+> figures run `node scripts/validate-questions.mjs`. The counts the app displays
+> come from `frontend/src/data/bookChapters.generated.ts`, which
+> `scripts/sync-chapters.mjs` regenerates from the JSON on every dev start and
+> every build — CI fails if that generated file is stale.
+
+### Format
 
-The question bank spans all major NEC license examination subjects:
+```json
+{
+  "qsns": "What is the time complexity of binary search on a sorted array?",
+  "opt1": "O(n)",
+  "opt2": "O(log n)",
+  "opt3": "O(n log n)",
+  "opt4": "O(1)",
+  "correct_option": "O(log n)",
+  "correct_option_index": 2
+}
+```
 
-| # | Topic | Questions |
-|---|---|---|
-| 1 | Artificial Intelligence & Neural Networks | 150 |
-| 2 | Computer Organization & Embedded Systems | 120 |
-| 3 | Basic Electrical & Electronics Engineering | 100 |
-| 4 | Computer Network & Network Security | 130 |
-| 5 | Data Structures, Algorithms, Database & OS | 180 |
-| 6 | Digital Logic & Microprocessor | 110 |
-| 7 | Programming Languages & Applications | 200 |
-| 8 | Project Planning, Design & Implementation | 90 |
-| 9 | Software Engineering & OOAD | 140 |
-| 10 | Theory of Computation & Computer Graphics | 160 |
-| **Total** | | **1,380+** |
-
-Plus **10 textbook chapters** (Ch 1–10) served from `public/data/books/` with auto-generated TypeScript metadata via `scripts/sync-chapters.mjs`.
+`correct_option_index` is **1-based**. Full reference, including every validation
+rule and why it exists: **[`docs/question-format.md`](docs/question-format.md)**.
 
 ---
 
-## Tech Stack
+## Known data defects and the quality gate
 
-| Layer | Technology |
-|---|---|
-| **Framework** | [React 19](https://react.dev) |
-| **Language** | [TypeScript 5.9](https://www.typescriptlang.org) |
-| **Build Tool** | [Vite 7](https://vite.dev) |
-| **Routing** | [React Router DOM v7](https://reactrouter.com) |
-| **3D / WebGL** | [Three.js](https://threejs.org) · [@react-three/fiber](https://r3f.docs.pmnd.rs) · [@react-three/drei](https://drei.docs.pmnd.rs) |
-| **Animations** | [Framer Motion](https://www.framer.com/motion/) |
-| **Icons** | [Lucide React](https://lucide.dev) |
-| **Auth (opt)** | [Firebase](https://firebase.google.com) |
-| **Persistence** | Browser `localStorage` (no server required) |
-| **Deployment** | [Vercel](https://vercel.com) |
+Nothing had ever checked this data. `scripts/validate-questions.mjs` now does,
+and it runs as a required CI job. What it found on first run:
+
+| Defect | Count | Why it matters |
+|---|---|---|
+| `correct_option_index` disagreed with `correct_option`, and the text named by `correct_option` was **not among the four options at all** | 15 | The app trusts the index, so the student is told the right answer is wrong |
+| `correct_option_index: 5` with only four options | 2 | Unanswerable — no selection can be correct |
+| Two options with identical text | 7 | Two answers are simultaneously correct; only one is keyed |
+| Duplicate question rows | 558 rows across 391 groups, **192 groups spanning `ch1` and `ch2`** | Inflated counts, repeats within one quiz, skewed statistics |
+| Answer-position bias | option 2 correct in **32.0%** of the bank; **64.8%** of `ch9` | See below |
+
+Questions that are provably unanswerable, and not yet repaired, are listed by id
+in **`frontend/src/data/quarantine.json`** (145 entries as of 2026-10-20) and
+filtered out by the loader so no student ever sees them.
+
+The quarantine list exists for one reason: a gate that is permanently red is
+useless for catching the *next* bad question. Known defects are logged as explicit,
+reviewable decisions and excluded from the failure count, so any newly introduced
+bad question fails the build on its own. It is a backlog to drain, not a place to
+hide rows — removing an id without fixing the underlying question puts it straight
+back in front of students and the validator will fail for it.
+
+### Answer position bias
+
+Across the bank, **option 2 was the correct answer in 32.0% of questions** against
+a uniform 25%, with a chi-square of **158.2 on 3 degrees of freedom** (p < 0.001
+begins at 16.27). Per chapter it was far worse: **64.8% in `ch9`**.
+
+Options were never shuffled anywhere in the app, so **a student could score about
+65% on chapter 9 by blind-guessing "option 2" without reading a single question.**
+That makes the score meaningless as a readiness signal and trains positional
+pattern-matching instead of engineering.
+
+`orderOptions()` in `frontend/src/services/localData.ts` neutralises it:
+
+- A uniform Fisher–Yates shuffle, **seeded from the question id**, so each question
+  always presents in the same order. Determinism is required, not convenient:
+  saved mock drafts and progress records store the chosen option *index*, and a
+  permutation that varied between loads would silently re-point every stored
+  answer. What is removed is the systematic correlation *across* the bank.
+- **"All of the above" and similar options are pinned to the last slot** and
+  excluded from the shuffle — moving one mid-list makes the question nonsense.
+  There are 452 such options in the bank.
+
+CI gates on the distribution **after** reordering: a chapter fails if any one slot
+still holds the correct answer in 32% or more of its questions. The raw authored
+skew is reported as a warning. Authors are still expected to vary the correct
+position — the shuffle is a safety net, not a licence.
 
 ---
 
-## Project Structure
+## Architecture
 
 ```
 NECPrep/
@@ -170,16 +273,54 @@ NECPrep/
     └── sync-chapters.mjs              # Generates bookChapters.generated.ts from JSON files
 ```
 
+Points worth knowing before changing anything:
+
+- **`frontend/src/services/localData.ts` is the hinge of the app.** Question
+  loading, 1-based-to-0-based index conversion, option reordering, quarantine
+  filtering, the per-chapter cache, and every `localStorage` read and write go
+  through it.
+- **`orderOptions()` is duplicated in `scripts/validate-questions.mjs`** so the
+  validator can measure the distribution a student actually sees. The two copies
+  must change together or the CI gate measures something that is not what ships.
+- **Only `Landing` is in the initial chunk.** Everything under `/app` is behind
+  `React.lazy()` in `frontend/src/routes/AppRoutes.tsx`, so a visitor who never
+  starts practising never downloads the app.
+- **`bookChapters.generated.ts` is generated, not authored.** Edit
+  `CHAPTER_META` in `scripts/sync-chapters.mjs` instead.
+- **Question ids are `{topicId}_{arrayIndex}`** — for example `book-ch2_116`.
+  They are positional, so reordering a chapter JSON invalidates every stored
+  progress record and the entire quarantine list. Moving to content-hash ids is
+  on the roadmap.
+
 ---
 
-## Getting Started
+## Tech stack
 
-### Prerequisites
+| Layer | Technology |
+|---|---|
+| **Framework** | [React 19](https://react.dev) |
+| **Language** | [TypeScript 5.9](https://www.typescriptlang.org), strict |
+| **Build** | [Vite 7](https://vite.dev) |
+| **Routing** | [React Router 7](https://reactrouter.com) |
+| **Animation** | [Framer Motion](https://www.framer.com/motion/) |
+| **Icons** | [Lucide React](https://lucide.dev) |
+| **Styling** | Hand-written CSS (`src/index.css`, `src/App.css`, per-page CSS) |
+| **Tests** | [Vitest](https://vitest.dev) + [Testing Library](https://testing-library.com) under jsdom |
+| **Lint** | ESLint 9 flat config + typescript-eslint |
+| **Persistence** | Browser `localStorage`. No server, no database, no SDK |
+| **Hosting** | [Vercel](https://vercel.com), static output |
+
+There is **no 3D/WebGL layer**: Three.js, `@react-three/fiber`, `@react-three/drei`
+and the `ThreeBackground` component were removed — a WebGL canvas was a poor trade
+on the low-end Android hardware this app targets. There is **no Firebase and no
+Supabase**; neither is a dependency and neither is imported anywhere. (`frontend/.env.example`
+still mentions Supabase keys; nothing reads them.)
+
+---
 
-- [Node.js](https://nodejs.org) **v18+**
-- [npm](https://npmjs.com) **v9+** (or `pnpm` / `yarn`)
+## Getting started
 
-### Installation
+Requires **Node 20+** and npm 9+.
 
 ```bash
 # 1. Clone the repository
@@ -189,68 +330,144 @@ cd NECPrep
 # 2. Install frontend dependencies
 cd frontend
 npm install
+npm run dev          # http://localhost:5173
 ```
 
-### Running Locally
+`npm run dev` first runs `scripts/sync-chapters.mjs` to regenerate
+`src/data/bookChapters.generated.ts` from the chapter JSONs, then starts Vite.
 
-```bash
-# From the frontend/ directory
-npm run dev
-```
+No environment variables are needed. There is no backend to run.
 
-This will:
-1. Run `sync-chapters.mjs` to auto-generate `bookChapters.generated.ts` from any JSON files in `public/data/books/`
-2. Start the Vite dev server at **http://localhost:5173**
+---
 
-### Building for Production
+## Commands
 
-```bash
-# From the frontend/ directory
-npm run build
-```
+Run from `frontend/` unless noted:
 
-The production-ready static files will be output to `frontend/dist/`. Deploy the `dist/` folder to any static host (Vercel, Netlify, GitHub Pages, etc.).
+| Command | What it does |
+|---|---|
+| `npm run dev` | Sync chapter manifest, then start the dev server |
+| `npm run build` | Sync manifest → `tsc -b` → `eslint .` → `vite build` into `dist/` |
+| `npm run preview` | Serve the production build locally |
+| `npx tsc -b` | Type check only (project references; emits nothing) |
+| `npm run lint` | ESLint |
+| `npm run test` / `npx vitest run` | Unit tests, once |
+| `npm run test:watch` | Unit tests in watch mode |
 
-To preview the production build locally:
+From the **repo root**:
 
-```bash
-npm run preview
-```
+| Command | What it does |
+|---|---|
+| `node scripts/validate-questions.mjs` | Question-bank quality gate. Exits 1 on data errors. Add `--json`, `--csv out.csv`, or `--strict` to fail on warnings too |
+| `node scripts/sync-chapters.mjs` | Regenerate `bookChapters.generated.ts` from the chapter JSONs |
+| `node .github/scripts/bundle-budget.mjs` | Measure initial-load JS against the 180 kB gzipped budget (needs a build in `frontend/dist/`) |
+
+### What CI gates
+
+`.github/workflows/ci.yml` runs on every pull request and every push to `main`.
+Before it existed there was no automated check of any kind on this repository,
+which is how 15 ESLint errors reached `main`.
+
+**`Question bank`** — `scripts/validate-questions.mjs`. Gates malformed JSON,
+missing or mistyped fields, empty stems and options, `correct_option_index` out of
+range, the two answer fields disagreeing, duplicate option text, and
+answer-position bias after reordering. Needs no `npm install`, so it answers in
+seconds.
+
+**`Frontend`** — `npm ci`, `npx tsc -b`, `npm run lint`, `npx vitest run`,
+`npm run build`, the initial-load JS budget, and a check that
+`bookChapters.generated.ts` is not stale.
+
+CI does not deploy. Deployment is a separate, later decision.
 
 ---
 
-## Question Data
+## Performance budget
 
-All question data lives in `frontend/public/data/` as JSON files and is fetched at runtime — no backend needed.
+CI **fails** if initial-load JavaScript exceeds **180 kB gzipped**.
 
-**Question format** (each entry in a topic JSON):
+"Initial-load" is exactly the entry `<script type="module">` in `dist/index.html`
+plus every `<link rel="modulepreload">` Vite emits beside it — the static import
+graph of the entry. Route chunks behind `React.lazy()` are excluded, which is what
+makes the budget affordable.
 
-```json
-{
-  "qsns": "What is the time complexity of binary search?",
-  "opt1": "O(n)",
-  "opt2": "O(log n)",
-  "opt3": "O(n²)",
-  "opt4": "O(1)",
-  "correct_option": "opt2",
-  "correct_option_index": 1
-}
-```
+Measured 2026-10-20 with `node .github/scripts/bundle-budget.mjs` against a local
+production build:
 
-### Adding Book Chapters
+| Chunk | raw | gzip |
+|---|---:|---:|
+| `react` | 192.35 kB | 60.29 kB |
+| `motion` | 115.37 kB | 37.82 kB |
+| `router` | 36.32 kB | 13.12 kB |
+| `index` (app entry) | 18.83 kB | 6.33 kB |
+| `vendor` | 2.23 kB | 1.14 kB |
+| `registerSW` | 0.13 kB | 0.13 kB |
+| **Total** | **365.23 kB** | **118.81 kB** |
 
-Drop a new `chN.json` file (same format as above) into `frontend/public/data/books/` and run:
+That is **66% of budget**, leaving about 61 kB of headroom. Render-blocking CSS
+sits outside the JS budget but is reported alongside it (16.51 kB gzipped in the
+same build). Run the script yourself for current figures — it prints the live
+numbers and the CI job writes the same table into the run summary.
 
-```bash
-node scripts/sync-chapters.mjs
-```
+The budget is not decoration. On a 400 kbit/s effective link, every 50 kB of
+gzipped JavaScript is roughly another second before anything is interactive —
+before the phone has even parsed it. Vendor code is split per package in
+`vite.config.ts` so an app deploy does not invalidate the framework in users'
+caches.
 
-The script will automatically detect the subject, assign a color and icon, and update `bookChapters.generated.ts`. This also runs automatically on every `npm run dev` and `npm run build`.
+---
 
-### Adding Topic Questions
+## Project structure
 
-1. Add your JSON file to `frontend/public/data/` following the format above.
-2. Register the topic in `frontend/src/data/topics.ts` with an `id`, `name`, `questionCount`, and `dataFile`.
+```
+.
+├── .github/
+│   ├── workflows/ci.yml                 # the two CI jobs
+│   ├── scripts/bundle-budget.mjs        # initial-load JS budget check
+│   ├── ISSUE_TEMPLATE/                  # bug, feature, question error
+│   └── pull_request_template.md
+├── docs/
+│   └── question-format.md               # question format + every validation rule
+├── scripts/
+│   ├── sync-chapters.mjs                # chapter JSONs → bookChapters.generated.ts
+│   └── validate-questions.mjs           # question bank quality gate
+├── CONTRIBUTING.md
+└── frontend/
+    ├── public/
+    │   ├── favicon.svg
+    │   └── data/books/ch1.json … ch10.json      # the question bank
+    ├── src/
+    │   ├── main.tsx, App.tsx
+    │   ├── routes/AppRoutes.tsx         # all routes; everything under /app is lazy
+    │   ├── layout/AppShell.tsx          # sidebar + <Outlet/>
+    │   ├── context/
+    │   │   ├── UserContext.tsx          # display name in localStorage
+    │   │   └── user-context.ts
+    │   ├── services/
+    │   │   ├── localData.ts             # loading, option ordering, localStorage
+    │   │   └── __tests__/
+    │   ├── data/
+    │   │   ├── bookChapters.generated.ts   # GENERATED — do not edit
+    │   │   ├── topics.ts                # Topic/MockTest types + mock test config
+    │   │   ├── syllabus.ts
+    │   │   ├── quarantine.ts            # typed accessor over the list
+    │   │   ├── quarantine.json          # ids withheld from practice
+    │   │   └── duplicate-triage.json    # duplicate-group triage notes
+    │   ├── hooks/useChapters.ts
+    │   ├── pages/
+    │   │   ├── Landing.tsx              # the only eager page
+    │   │   └── app/                     # Dashboard, PracticeHub, TopicPractice,
+    │   │                                # ChapterPracticeSelector, QuickPractice,
+    │   │                                # CustomPractice, MockTests, MockTestDetail,
+    │   │                                # MockTestQuiz, StudyHub, TopicStudy,
+    │   │                                # Flashcards, Bookmarks, Progress,
+    │   │                                # Profile, Settings, BookPractice
+    │   └── test/setup.ts
+    ├── eslint.config.js, vite.config.ts, vitest.config.ts
+    └── vercel.json
+```
+
+There is no `src/pages/auth/` directory, and no authentication code of any kind.
 
 ---
 
@@ -293,14 +510,18 @@ Please make sure your PR:
 
 ## Roadmap
 
-- [ ] Spaced repetition algorithm for Flashcards
-- [ ] Dark / Light theme toggle
+Ordered roughly by priority.
+
+- [ ] Drain the quarantine backlog: verify and fix every withheld question
+- [ ] Finish deduplicating the bank, then enforce uniqueness as a CI error
+- [ ] Content-hash question ids, replacing the positional `{topicId}_{index}` form
+      that ties progress records and the quarantine list to array order
+- [ ] Cloudflare Workers + D1 backend: real accounts and cross-device progress
+- [ ] Per-question explanations and solution notes
+- [ ] PWA / service worker for genuine offline installs
+- [ ] Spaced repetition for flashcards
 - [ ] Nepali language support (i18n)
-- [ ] Detailed per-question explanation / solution notes
-- [ ] PWA support for fully offline usage
-- [ ] Share quiz results / leaderboard
-- [ ] Firebase cloud sync for cross-device progress
-- [ ] More model question sets and past exam papers
+- [ ] Past exam papers as dedicated mock sets
 
 Have a feature idea not listed here? [Open a feature request!](https://github.com/SamirWagle/NECPrep/issues/new)
 
@@ -308,17 +529,17 @@ Have a feature idea not listed here? [Open a feature request!](https://github.co
 
 ## Acknowledgements
 
-This project was built with the help of some amazing tools and people:
-
-- **[Samir Wagle](https://github.com/SamirWagle)** — Creator & maintainer
-- **[GitHub Copilot](https://github.com/features/copilot)** — AI pair programmer that helped accelerate development
-- **[Claude (Anthropic)](https://www.anthropic.com)** — AI assistant that helped with code architecture and problem-solving
-- **[React](https://react.dev)**, **[Vite](https://vite.dev)**, **[Three.js](https://threejs.org)**, **[Framer Motion](https://www.framer.com/motion/)** — The incredible open-source libraries powering this app
-- Every **NEC license candidate** who uses this platform and gives feedback 🙏
+- **[Samir Wagle](https://github.com/SamirWagle)** — creator and maintainer
+- **[React](https://react.dev)**, **[Vite](https://vite.dev)**,
+  **[React Router](https://reactrouter.com)**,
+  **[Framer Motion](https://www.framer.com/motion/)**,
+  **[Vitest](https://vitest.dev)** — the libraries this is built on
+- Every NEC licence candidate who reported a wrong answer. Those reports are the
+  reason the question bank now has a validator.
 
 ---
 
-## License
+## Licence
 
 Distributed under the **Apache License 2.0**. See [LICENSE](LICENSE) for more information.
 
@@ -326,9 +547,9 @@ Distributed under the **Apache License 2.0**. See [LICENSE](LICENSE) for more in
 
 <div align="center">
 
-Made by [Samir Wagle](https://github.com/SamirWagle) for every engineer working toward their NEC license.
+Made by [Samir Wagle](https://github.com/SamirWagle) for every engineer working toward their NEC licence.
 
-**If NECPrep helped you study, please consider giving it a ⭐ — it means a lot!**
+**If NECPrep helped you study, a star genuinely helps others find it.**
 
 [![GitHub stars](https://img.shields.io/github/stars/SamirWagle/NECPrep?style=social)](https://github.com/SamirWagle/NECPrep/stargazers)
 [![GitHub forks](https://img.shields.io/github/forks/SamirWagle/NECPrep?style=social)](https://github.com/SamirWagle/NECPrep/network/members)
diff --git a/docs/adr/0001-cloudflare-d1-over-supabase.md b/docs/adr/0001-cloudflare-d1-over-supabase.md
new file mode 100644
index 0000000..436a71f
--- /dev/null
+++ b/docs/adr/0001-cloudflare-d1-over-supabase.md
@@ -0,0 +1,282 @@
+# ADR 0001 — Cloudflare Workers + D1 + Drizzle, not Supabase
+
+- **Status:** Accepted
+- **Date:** 2026-10-20
+- **Deciders:** NECPrep platform rebuild, phase 0
+- **Supersedes:** the Supabase integration removed in the localStorage-only
+  rewrite (`frontend/src/services/localData.ts` still opens with the comment
+  "replaces all Supabase API calls")
+- **Affects:** `worker/**`, and every authorization decision on the platform
+
+## Context
+
+NECPrep is a question bank and mock-exam platform for the Nepal Engineering
+Council registration exam. Today it has no backend at all: 2,290 questions ship
+as public JSON under `frontend/public/data/books/`, and all progress,
+bookmarks and quiz history live in `localStorage`. Phase 0 of the rebuild adds
+a real backend.
+
+The requirements that actually constrain the choice:
+
+1. **The answer key must not be reachable by a client.** Today it is a field in
+   a public JSON file. Any backend that lets a browser talk to the database
+   directly has to keep the key safe with a row- or column-level policy, and
+   that policy is one misconfiguration away from publishing the entire exam.
+2. **Students are in Nepal.** Round-trip latency from Kathmandu to the nearest
+   `us-east` or `ap-south` managed-Postgres region is a real cost on a
+   question-by-question interaction loop.
+3. **It must be free at the current scale and cheap at 10× it.** This is a
+   student project serving exam candidates, not a funded product.
+4. **One unbounded table.** `attempt_answers` grows at roughly 500 rows per
+   active user per month and nothing else on the platform grows without bound.
+   Whatever we pick, we need to know its storage and write ceilings *before*
+   building on it.
+
+## Decision
+
+**Cloudflare Workers + D1 (serverless SQLite) + Drizzle ORM.** All
+authorization is hand-written in the Worker. No client ever holds a database
+credential.
+
+## Alternatives considered
+
+### Supabase (Postgres + PostgREST + RLS + GoTrue auth)
+
+The most capable option on features: real Postgres, managed auth, row-level
+security, realtime, storage, generous free tier. Rejected on two grounds.
+
+The first is architectural. Supabase's value proposition is that the browser
+talks to PostgREST directly with a JWT, and row-level security policies decide
+what it may see. For most applications that is a good trade. For an exam
+platform it inverts the thing we most need to be true: the answer key becomes
+reachable-by-default and safe only because a policy says so. `SELECT * FROM
+questions` from a browser is a supported, documented, one-line operation, and
+the only thing standing between it and the answer key is a correctly written
+policy on every table, forever, including every table added later. Getting a
+policy wrong is a configuration mistake with no compile step, no type error and
+no test that fails by default — and the cost of getting it wrong once is the
+whole product.
+
+The second is operational. Supabase free-tier projects pause after seven days
+of inactivity and the free tier allows two active projects; a paused database
+is a dead platform for however long it takes someone to notice. The paid tier
+starts at $25/month.
+
+### Neon (or Prisma Postgres) behind Cloudflare Hyperdrive
+
+Attractive because it keeps real Postgres and the Worker runtime. Rejected
+because it is two vendors, two bills and two failure domains for a platform
+whose entire dataset is 2,290 questions and some per-user counters.
+
+It is worth being precise about what Hyperdrive is, because its placement in
+Cloudflare's docs invites the misreading: **Hyperdrive is a connection pooler
+and query cache, not a database.** Cloudflare has **no first-party managed
+Postgres**. It partners with PlanetScale, and it routes Neon and Prisma
+Postgres through Hyperdrive. Choosing "Postgres on Cloudflare" therefore always
+means choosing a second provider, with its own region (so requirement 2 is back
+in play), its own free-tier rules, and a connection-pool sizing problem that D1
+simply does not have.
+
+### Firebase / Firestore
+
+Rejected for the same client-direct-to-database reason as Supabase, with the
+security-rules DSL in place of RLS, plus a document model that fits this domain
+badly. The hot query is "draw 10 published questions from chapter 2 excluding
+the 100 flagged ones", which is a relational filter; the schema is thoroughly
+relational (questions → options → answer keys → attempts → answers); and
+`leaderboard_snapshots` and `user_question_stats` are aggregates that Firestore
+charges per document to compute.
+
+### PlanetScale
+
+Cloudflare's own managed-database partner, and technically strong — but
+PlanetScale **removed its free tier** in April 2024. Paid-only from the first
+day disqualifies it against requirement 3.
+
+### Keep localStorage
+
+The honest baseline, and it is what ships today. Rejected because every
+requirement the rebuild exists to meet — accounts, cross-device progress,
+contributor workflows, errata reporting, leaderboards, an answer key that is
+not in the git history — needs server state.
+
+## Evidence: D1's actual limits
+
+These are the numbers the schema is designed against. They are stated here so
+that a future reader can check whether a decision still holds rather than
+re-deriving it.
+
+| | Free | Workers Paid ($5/mo) |
+|---|---|---|
+| Storage, total | 5 GB | 250 GB |
+| Storage, **per database** | **500 MB** | 10 GB |
+| Databases | 10 | 50,000 |
+| Rows read / day | 5 million | 25 billion / month |
+| Rows written / day | **100,000** | 50 million / month |
+| **Queries per Worker invocation** | **50** | 1,000 |
+
+Other properties that shaped the schema:
+
+- **Single-threaded per database.** D1 serialises queries against one database
+  and sustains roughly 1,000 queries/second at 1 ms each. One slow full-table
+  scan blocks every write behind it.
+- **Max 100 columns per table**, max 2 MB per row.
+- **No `VACUUM`.** Deleting rows frees pages for reuse but never shrinks the
+  file, so a retention window bounds the live set rather than the file size.
+- **No row-level security.** SQLite has none to expose.
+
+And the one number that is ours, not Cloudflare's — measured, not estimated, by
+`npm run db:measure` against the real schema with all three of its indexes and
+the rollup triggers live:
+
+```
+attempt_answers (table b-tree)         42.7 bytes/row
+uq_attempt_answers_attempt_question    33.1
+idx_attempt_answers_answered_at        25.7
+idx_attempt_answers_question_correct   30.9
+                                      ------
+TOTAL                                 132.4 bytes/row
+```
+
+So a 500 MB free D1 database holds **3.92 million answer rows**; a 10 GB paid
+one holds 81 million. The rest of the schema — 2,290 questions, 9,160 options,
+the 60 syllabus codes and the FTS5 index — measures 5.1 MB.
+
+## Consequences
+
+### No row-level security. Authorization is code, and that is the point.
+
+This is the decision's sharpest edge and it is deliberate, so it is worth
+stating as a positive rather than as a cost.
+
+D1 has no RLS, so the client cannot be allowed to talk to the database at all —
+and that removes the client-direct-to-database path *entirely*. There is no
+anon key, no JWT the browser presents to the database, no PostgREST endpoint,
+no "one policy away from publishing the answer key". The answer key's exposure
+surface by default is zero, and increasing it requires someone to write a
+handler that names `question_answer_keys` in a `FROM` clause. That is a
+grep-able, reviewable, testable event. An RLS policy's absence is not.
+
+The schema then makes the safe path the easy path:
+
+- `questions` has **no** correct-answer column. `question_options` has **no**
+  `is_correct` column. The key lives only in `question_answer_keys`, one row
+  per question.
+- `SELECT * FROM questions JOIN question_options …` — the shape every delivery
+  handler actually writes — therefore cannot leak the key, even written
+  carelessly, even with a stray `SELECT *`, even from an endpoint added next
+  year by someone who has not read this file.
+- `v_question_delivery` is the view the delivery path reads. A SQLite view
+  grants nothing; its value is that it is the shortest correct thing to write
+  and it cannot reference the key table.
+- Papers are permuted per attempt (`attempt_questions.option_order`, a JSON
+  array of **option ids**, never positions), because the public JSON bank is in
+  git history permanently and a fixed option order would let a captured paper
+  be graded offline by position.
+
+The cost is real: every authorization predicate must be written in every
+handler, every time. The three permitted answer-key queries are written out
+verbatim in `worker/migrations/0002_content.sql` and `worker/README.md`
+precisely so that "write it yourself" does not mean "invent it yourself".
+
+### No managed auth
+
+No GoTrue, no Firebase Auth. We own password hashing, session cookies, email
+verification and password reset. `0001_identity.sql` is written for it:
+`sessions.id` is the SHA-256 digest of the cookie value rather than the cookie
+itself, so a dump of the table does not let anyone sign in; sessions carry both
+an idle clock and an absolute ceiling so a stolen cookie cannot be renewed
+forever; and `users` is split from `user_profiles` so the leaderboard joins a
+table that physically contains no credential.
+
+### Single writer, and batching is not optional
+
+D1 serialises writes per database, so nothing on a request path may scan a
+large table. Two consequences are baked into the schema rather than left to
+discipline:
+
+- **Leaderboards are precomputed.** `leaderboard_snapshots` plus
+  `leaderboard_entries` are written by a cron Worker. The naive
+  `SUM(is_correct) … GROUP BY user_id` over the answer log would scan millions
+  of rows per page view, block every write behind it, and stop being correct
+  the moment archival ran.
+- **Rollups are trigger-maintained.** The 50-queries-per-invocation free-tier
+  limit means a handler cannot spend two or three of its budget on
+  bookkeeping. Work done inside a trigger is part of the statement that fired
+  it and does not count against that budget, so `user_question_stats`,
+  `attempts.correct_count`, `tags.question_count` and the FTS5 index are all
+  maintained by the eleven triggers in `0003`/`0005`. The progress page is then
+  one covering index scan (`NQ-27`), not an aggregate over the answer log — and
+  it keeps working after archival deletes that log.
+
+Grading a 100-question mock is one batched statement (`NQ-10b`), not 100
+queries, for the same reason.
+
+### Archival is a day-one requirement, not a later optimisation
+
+With a 90-day retention window: 1,000 MAU is 1.5 M live answer rows (189 MB) —
+fits free. 10,000 MAU is 15 M rows (1.85 GB) — needs Paid. The binding
+constraint on the free plan is not storage but the **100,000 row-writes-per-day
+cap**: D1 counts index rows as writes, so one answer is four row writes, and
+~1,500 MAU saturates it. The retention job, the exact queries it runs, and the
+reason there is deliberately **no** `DELETE` trigger on `attempt_answers` are
+documented in `0004_assessment.sql`.
+
+### Cost projection
+
+- **Free to roughly 1,000–1,500 MAU** (bounded by D1's daily write cap, not by
+  storage).
+- **$5/month beyond that** — the Workers Paid plan, which covers 10,000 MAU at
+  90-day answer retention with room to spare, and includes D1, Workers, cron
+  triggers and R2 for the archive drain.
+- **Beyond ~25,000 MAU**, shard `attempt_answers` across D1 databases by user
+  id, or move that one table to Durable Object SQL storage. Both are
+  schema-compatible with what is written today, because nothing joins
+  `attempt_answers` across users — a constraint worth keeping.
+
+### Drizzle, but the SQL is the source of truth
+
+`worker/migrations/*.sql` is authoritative. `worker/db/schema.ts` is a typed
+client, not a DDL generator: Drizzle cannot express `STRICT` tables, triggers,
+FTS5 virtual tables, `DESC` index keys, or partial-index predicates in their
+exact SQLite form, so `drizzle-kit generate` would silently drop most of what
+makes this schema correct. `npm run db:verify` introspects a migrated database
+and fails on any drift between the two — 308 columns, 65 indexes, 49 foreign
+keys and 35 enums compared, including the TypeScript literal unions against the
+SQL `CHECK … IN (…)` lists.
+
+### Vendor lock-in is modest
+
+D1 is SQLite. The migrations are ordinary SQLite DDL and `wrangler d1 export`
+produces a plain `.sql` dump. The portable exit is Turso or LiteFS; the costly
+one is Postgres, which would mean rewriting the generated columns, the triggers
+and the FTS5 index. The Worker-side authorization code, which is the real
+investment, ports anywhere.
+
+## Verification
+
+Reproduce every claim above:
+
+```bash
+cd worker && npm install
+npm run db:check       # apply migrations, import the bank, verify parity, smoke, typecheck
+npm run db:measure     # re-measure bytes/row and re-derive the ceiling table
+npm run d1:migrate:local   # the same migrations through wrangler's D1 runner
+```
+
+Measured on SQLite 3.54 and on Miniflare's local D1: 7 migrations apply clean,
+28 tables + 1 view + 1 FTS5 table, 65 indexes, 11 triggers, 59/59 smoke
+assertions pass.
+
+## What this ADR does not claim
+
+- It does not claim D1 is a better database than Postgres. It is not.
+- It does not claim hand-written authorization is less work than RLS. It is
+  more work. It claims the work is more reviewable, and that for a schema whose
+  crown jewel is an answer key, a zero-exposure default beats a policy-guarded
+  one.
+- It has **not** been verified against production D1. Everything here was
+  verified locally against SQLite 3.54 and Miniflare's D1 emulation; no
+  Cloudflare account was provisioned. `STRICT` tables and FTS5 both work in
+  Miniflare, and D1 documents full SQLite SQL support, but the first real
+  deploy should confirm both before anyone relies on this paragraph.
diff --git a/docs/api.md b/docs/api.md
new file mode 100644
index 0000000..ddd44c5
--- /dev/null
+++ b/docs/api.md
@@ -0,0 +1,871 @@
+# NECPrep API
+
+The Cloudflare Worker that owns the question bank, scoring, and progress.
+
+Base URL comes from `VITE_API_BASE_URL`. With it unset the frontend never calls
+this API at all and falls back to `frontend/src/services/localData.ts`; see
+[Running with no backend](#running-with-no-backend).
+
+**Stack:** Cloudflare Workers + D1 (serverless SQLite) + Drizzle + Hono.
+**Auth:** self-hosted cookie sessions (D1 has no managed auth).
+**Client:** `frontend/src/services/api.ts`, typed from `worker/src/shared/types.ts`.
+
+---
+
+## Contents
+
+- [Why this API exists](#why-this-api-exists)
+- [Platform limits this design is shaped by](#platform-limits-this-design-is-shaped-by)
+- [Conventions](#conventions)
+- [Endpoint reference](#endpoint-reference)
+- [The offline outbox contract](#the-offline-outbox-contract)
+- [Idempotency](#idempotency)
+- [Rate limits](#rate-limits)
+- [Errors](#errors)
+- [Running with no backend](#running-with-no-backend)
+- [Configuration](#configuration)
+
+---
+
+## Why this API exists
+
+`frontend/src/pages/app/MockTestQuiz.tsx` currently fetches the chapter JSON
+**including `correct_option_index`**, scores in the browser against
+`q.correctIndex`, and runs the exam clock as a client `setInterval`. Two
+consequences:
+
+1. Open devtools and you have the entire answer key.
+2. Stop the interval, or edit the localStorage draft's `endsAt`, and you have
+   unlimited time.
+
+Worse, `frontend/public/data/books/*.json` ships the answer key and will remain
+in this repository's git history forever. So it is not enough to stop sending
+the key — any endpoint that returns options **in the authored order** lets an
+attacker recover the key by joining position to position, without ever touching
+the database.
+
+This API makes both attacks structurally impossible:
+
+| Defence | Mechanism |
+| --- | --- |
+| The key never reaches a pre-answer payload | `is_correct` is selected by exactly one function, `loadAnswerKey` in `worker/src/data/content.ts`. The function that builds option lists, `loadOptionsForQuestions`, does not have that column in its SELECT list. There is no field to forget to delete. |
+| Option position cannot be joined to the public JSON | Every option list that leaves the Worker is permuted. Mock and practice papers get a CSPRNG permutation stored per attempt; content browsing gets one seeded from a server-only secret plus the viewer's user id. |
+| A ref from one attempt is useless in another | The client names an option by an opaque **ref**: 60 bits of CSPRNG minted per `(attempt, option)` at start and stored on the attempt row. Raw `question_options.id` values never leave the server. |
+| The deadline cannot be moved | `mock_attempts.expires_at` is written once by the server at start. No request body anywhere in this API has a field for a time, a duration, or a deadline. |
+| Stalling past the deadline gains nothing | Scoring uses the server clock and falls back to the last snapshot the **server itself accepted** before the deadline. See [the expiry clamp](#the-expiry-clamp). |
+| A submission cannot assert a score | `MockSubmitRequest` is `{ attemptId, idempotencyKey, answers }` and the validator is **strict** — an extra `score` or `isCorrect` field is a 400, not an ignored field. |
+
+The key is disclosed in exactly two places, both of them after the answer is on
+the record:
+
+- `POST /api/mock/submit` and `GET /api/mock/attempts/:id/review` — the whole
+  paper, after the attempt is `submitted`.
+- `POST /api/practice/answer` — **one** question, after that answer is written.
+
+### The expiry clamp
+
+The only claim a server can verify about timing is *what it received, and when
+it received it*. So:
+
+1. While an attempt is live the client pushes its answer map to
+   `POST /api/mock/sync` every 10–15 seconds. The `UPDATE` carries
+   `AND ?now <= expires_at`, so the stored snapshot is **by construction** a
+   pre-deadline state. The guard is in the SQL, not in a preceding read, so
+   there is no race to win.
+2. A submission inside the grace window (`expires_at + 10s`) is scored from its
+   payload. Ten seconds covers network latency and clock skew; it is not enough
+   to be useful as working time.
+3. A submission after that window has its **payload discarded**. The last
+   pre-deadline snapshot is scored instead, `timing` comes back as `expired`,
+   and `droppedLateAnswers` says how many answers the clamp refused.
+
+`scoredAt` is always `min(submittedAt, expiresAt)` — the instant the paper was
+frozen.
+
+There is deliberately **no `answeredAt` field** on the wire. A client-asserted
+answer time is exactly what a cheater would forge, and accepting one would
+reintroduce the hole through a different door.
+
+---
+
+## Platform limits this design is shaped by
+
+These are not tunable, and every one of them is visible in the shape of the API.
+
+| Limit | Free plan | Consequence here |
+| --- | --- | --- |
+| D1 queries per Worker invocation | **50** (1,000 on paid) | `worker/src/data/d1.ts` counts every statement and throws `QueryBudgetExceeded` past a configured budget (default 45). Every response carries `X-D1-Queries`. An accidental N+1 fails the request and the test suite instead of working on a 12-question paper and breaking on a 100-question one. |
+| D1 bound parameters per statement | **100** | A 102-question submission is 4 columns × 102 rows = 408 parameters. So multi-row writes pass the payload as **one** JSON parameter and expand it with `json_each()`. `Db` throws `TooManyBoundParams` before the statement is even prepared. |
+| D1 rows written per day | **100,000** (index writes count) | Progress is kept as three upserted **rollups**, not an append-only event log. A 102-question submission writes ~102 + ≤10 + 1 rows. An events table would roughly double that and cap the platform at about 80 full mocks a day across all users. |
+| D1 transactions | **none** (no interactive transactions, single-threaded per DB) | `db.batch()` is the only atomic write primitive. Concurrency safety comes from guard predicates inside statements plus statement ordering, never from a lock. See [Concurrency](#concurrency-without-transactions). |
+| Workers requests per day | **100,000** | Endpoints are coarse. `GET /api/bootstrap` returns session + chapters + templates + content version in one call. `GET /api/progress/overview` returns stats + streaks + recent attempts in one call. The client does not chat. |
+| Workers CPU per invocation | ~10 ms | PBKDF2 defaults to 100,000 iterations rather than the OWASP-recommended 600,000. Documented under [Configuration](#configuration); raise it on the paid plan. |
+
+### Concurrency without transactions
+
+Two concurrent mock submissions with **different** idempotency keys cannot both
+score, and the mechanism needs no lock:
+
+- Each of the five write statements in the submission batch carries
+  `WHERE EXISTS (SELECT 1 FROM mock_attempts WHERE id = ? AND user_id = ? AND status = 'in_progress')`.
+- The statement that flips the attempt to `submitted` runs **last**, and its
+  `changes` count is the decision.
+- A duplicate arriving after the first batch committed finds the guard false,
+  writes nothing at all, reports zero changes, and gets
+  `409 ATTEMPT_NOT_IN_PROGRESS`.
+
+`POST /api/practice/answer` uses the same device with a
+`NOT EXISTS (an answer for this session+question)` guard, which is what makes it
+idempotent with no key.
+
+---
+
+## Conventions
+
+- **Transport:** JSON over HTTPS. `Content-Type: application/json` is required
+  on any request with a body; anything else is a 400.
+- **Auth:** an `HttpOnly; SameSite=Lax; Secure` cookie named `necprep_session`,
+  carrying an opaque session id and **nothing else** — no user id, no role, no
+  signed claims. Every authenticated request costs one indexed `sessions` join.
+  Send `credentials: 'include'`.
+- **Timestamps:** integer **epoch milliseconds**, always from the server clock.
+  Fields named `serverNow` are provided so the client can render a countdown
+  without trusting the device clock.
+- **Ownership:** D1 has no row-level security. Every data-access function takes
+  `userId` and puts it in the `WHERE` clause; another user's resource reads as
+  `404 NOT_FOUND`, never `403`, so ids are not enumerable.
+- **Option refs:** opaque strings. Never an index, never a position. The client
+  submits a ref and nothing else.
+- **Request bodies are strict.** An unknown field is a `400 BAD_REQUEST` with
+  `error.fields`, not a silently-stripped or silently-kept value. Bodies over
+  128 KB are refused before being read.
+- **Query cost** below is measured, not estimated — the numbers come from
+  `worker/src/__tests__/query-cost.test.ts` and an instrumented run of every
+  handler. `(batch)` marks statements that share one round trip.
+
+---
+
+## Endpoint reference
+
+### Auth
+
+| Method | Path | Auth | D1 cost |
+| --- | --- | --- | --- |
+| `GET` | `/api/auth/session` | optional | **1** (0 with no cookie) |
+| `POST` | `/api/auth/anonymous` | optional | **3** |
+| `POST` | `/api/auth/signup` | none | **3** |
+| `POST` | `/api/auth/login` | none | **4** |
+| `POST` | `/api/auth/logout` | optional | **1** |
+| `POST` | `/api/auth/upgrade` | required (anonymous) | **6** |
+| `GET` | `/api/auth/google/start` | optional | **1** |
+| `GET` | `/api/auth/google/callback` | optional | **4–7** |
+
+#### `GET /api/auth/session`
+→ `SessionResponse` · `{ user: SessionUser | null, sessionExpiresAt, serverNow }`
+
+#### `POST /api/auth/anonymous`
+No body. → `SessionResponse` with `user.isAnonymous === true`.
+
+Creates a **real `users` row** for a guest. That is the point: a guest's first
+mock attempt is written server-side with a server-side deadline from the first
+question. The alternative — a client-side guest identity — is the hole this API
+exists to close.
+
+**Idempotency:** if the request already carries a live session the existing one
+is returned untouched and no new session is minted. Safe to call on every cold
+start, which is how the client uses it.
+
+#### `POST /api/auth/signup`
+`{ email, password, displayName? }` → `201 SessionResponse`
+
+`password` is 8–200 characters. The ceiling exists because the password is fed
+to PBKDF2 and an unbounded input is a cheap CPU-exhaustion vector.
+
+Uniqueness is enforced by a **partial unique index** on `users.email`, not by a
+preceding `SELECT`, so two simultaneous signups for one address cannot both win.
+Duplicate → `409 EMAIL_IN_USE`.
+
+> The upsert's conflict target must restate the index predicate
+> (`ON CONFLICT (email) WHERE email IS NOT NULL`). A bare `ON CONFLICT (email)`
+> raises *"does not match any PRIMARY KEY or UNIQUE constraint"* at runtime, on
+> every signup. The test suite caught this.
+
+#### `POST /api/auth/login`
+`{ email, password }` → `SessionResponse` · wrong credentials →
+`401 INVALID_CREDENTIALS`
+
+An unknown address runs a dummy PBKDF2 derivation before answering. Without it
+"no such user" returns in a fraction of the time a real verification takes and
+response latency becomes a user-enumeration oracle — a vague error message does
+not help. A guest row (no password) is treated identically to a nonexistent one.
+
+Rate-limited per IP **and** per email, so one attacker cannot lock every user
+out from a single address and one account cannot be hammered from a thousand.
+
+A hash stored with fewer iterations than the current setting verifies and is
+transparently rehashed, so the cost can be raised without locking anyone out.
+
+#### `POST /api/auth/upgrade`
+`{ email, password, displayName? }` → `SessionResponse`
+
+Turns the **current anonymous session's user** into a real account **in place**.
+The user id does not change, so every attempt, bookmark, streak and SRS card the
+guest accumulated stays attached. The alternative — create a new user and
+migrate — is a multi-table copy with no transaction to protect it, on a database
+that has none.
+
+**Idempotency:** the `UPDATE` carries `AND is_anonymous = 1`. A replay matches
+zero rows and returns `409 NOT_ANONYMOUS` rather than resetting the password of
+an account that has since been claimed. Taken address → `409 EMAIL_IN_USE`.
+
+Other sessions for that user are revoked; the current one survives.
+
+#### `GET /api/auth/google/start`
+`?redirect_to=/app/...` (optional) → `302` to Google.
+
+PKCE is used even though this is a confidential client: the verifier is stored
+server-side against a single-use `state`, so an intercepted redirect still
+cannot be redeemed. Only a path on our own origin is accepted as `redirect_to`,
+so `state` cannot bounce a signed-in user to an attacker's site.
+
+#### `GET /api/auth/google/callback`
+`?code&state` → `302` to `APP_ORIGIN + redirectTo`
+
+`state` is consumed with `DELETE ... RETURNING`, which is atomic — a replayed
+callback finds nothing and gets `400 OAUTH_STATE_INVALID`. An **unverified**
+Google email is refused (`OAUTH_EXCHANGE_FAILED`); accepting one would be an
+account-takeover path for any address a user has not verified.
+
+Resolution order: existing `oauth_accounts` link → existing user with that
+verified email (link added) → the current anonymous guest, claimed in place →
+new user.
+
+---
+
+### Content
+
+| Method | Path | Auth | D1 cost |
+| --- | --- | --- | --- |
+| `GET` | `/api/bootstrap` | optional | **4** |
+| `GET` | `/api/content/chapters` | optional | **1** |
+| `GET` | `/api/content/mock-templates` | optional | **1** |
+| `GET` | `/api/content/chapters/:chapterId/questions` | optional | **3** |
+| `GET` | `/api/content/search` | optional | **2** |
+
+#### `GET /api/bootstrap`
+→ `BootstrapResponse` · `{ session, chapters, mockTemplates, contentVersion }`
+
+One call for the whole app shell. Four separate calls on every cold start would
+burn the 100k requests/day budget four times faster for no benefit.
+`contentVersion` is derived from `MAX(questions.updated_at)` and the published
+count, so publishing or retiring a question changes it and the client knows to
+refetch.
+
+#### `GET /api/content/chapters/:chapterId/questions`
+`?offset=0&limit=50` (limit ≤ 100) → `ChapterQuestionsResponse`
+
+Questions **without keys**, for browsing and study. Paged because a chapter holds
+up to 746 questions and sending all of them would be a multi-megabyte payload on
+a mobile connection.
+
+Options are permuted with a **stable per-viewer** permutation: seeded from
+`CONTENT_PERMUTATION_SECRET` + user id + question id, so it cannot be reproduced
+by anyone without the secret, but does not reshuffle between reloads (selections
+are stored by ref, and a reshuffle would re-point them).
+
+`ref` here is a **keyed, non-reversible digest**, not the `question_options.id`.
+That distinction is load-bearing, and the first version of this endpoint got it
+wrong: the schema mints option ids as `question_id || '#' || ordinal`
+(`worker/migrations/0002_content.sql`), so returning an id hands over the
+authored ordinal — and the public chapter JSON publishes
+`correct_option_index`, which makes that ordinal the answer. Permuting the array
+is no defence when the ordinal travels *inside* the id. It needs no
+reversibility because browsing is read-only: a browse ref is never submitted
+back, and answering goes through a practice session, which mints its own
+per-attempt refs. `worker/src/__tests__/content-refs.test.ts` holds that line.
+
+Options whose meaning depends on being last ("All of the above") are pinned,
+matching `frontend/src/services/optionOrdering.ts`.
+
+#### `GET /api/content/search`
+`?q=&chapterId=&limit=` (`q` is 2–120 chars) → `SearchResponse`
+
+Stems only — returning options would be a bulk-enumeration path, and the UI only
+needs a link. `%` and `_` in the query are escaped, so searching `100%` is a
+literal search and not a match-everything wildcard. Rate-limited.
+
+A LIKE scan over ~2,800 published rows. The upgrade path when the bank grows is
+FTS5 plus triggers; it is deliberately not here yet, because a stale FTS index
+returns silently wrong results, which is worse than a scan.
+
+---
+
+### Mock tests
+
+| Method | Path | Auth | D1 cost (102-question paper) |
+| --- | --- | --- | --- |
+| `POST` | `/api/mock/start` | required | **10** |
+| `GET` | `/api/mock/attempts/:attemptId` | required | **3** |
+| `POST` | `/api/mock/sync` | required | **3** |
+| `POST` | `/api/mock/submit` | required | **13** |
+| `GET` | `/api/mock/attempts/:attemptId/review` | required | **5** |
+
+**All five are constant in the size of the paper.** `start` and `submit` cost
+the same 10 and 13 queries at 12 questions and at 102 — asserted in
+`worker/src/__tests__/query-cost.test.ts`.
+
+#### `POST /api/mock/start`
+`{ templateId, idempotencyKey }` → `MockAttemptPaper`
+
+The server picks the paper from `mock_template_blueprint`. The request names a
+template and nothing else: it cannot ask for a shorter paper, an easier chapter,
+or a specific question.
+
+Cost breakdown: rate limit 1 · idempotency reserve 1 · template 1 · blueprint 1 ·
+pool draw 1 · option bodies 1 · attempt + paper insert 2 *(batch)* ·
+paper read-back 1 · idempotency finalise 1.
+
+The random selection happens **in SQLite** with
+`ROW_NUMBER() OVER (PARTITION BY chapter_id ORDER BY RANDOM())`, so the Worker
+never materialises all 2,800 questions to pick 100. The paper insert is **one
+statement** for any number of rows, via `json_each`.
+
+Response carries `startedAt`, `expiresAt`, `serverNow`, `durationSeconds`, and
+`questions[]` of `{ questionId, chapterId, position, stem, options: [{ ref, body }] }`.
+
+There is no `correctRef`, no `isCorrect`, and no raw option id anywhere in it —
+asserted by scanning the serialised payload for every seeded option id in
+`worker/src/__tests__/mock-anticheat.test.ts`.
+
+A chapter that cannot fill its blueprint quota contributes what it has; the
+attempt records the **actual** question count. A completely empty paper is
+`409 INSUFFICIENT_CONTENT`. (Chapters 5, 6, 7 and 9 hold only 64–71 questions
+each, so a hard failure would take every mock offline for one thin chapter.)
+
+**Idempotency:** required key. A replay returns the identical paper **with the
+identical refs** — anything else would have the client submitting refs the
+server never minted.
+
+#### `GET /api/mock/attempts/:attemptId`
+→ `MockAttemptPaper`, with `savedAnswers` from the last accepted sync.
+
+The resume path. A reload does not depend on localStorage surviving, and cannot
+be influenced by editing it.
+
+#### `POST /api/mock/sync`
+`{ attemptId, answers }` → `MockSyncResponse`
+`{ accepted, serverNow, expiresAt, remainingMs, reason? }`
+
+The coarse autosave, and the mechanism that gives the expiry clamp something
+true to score. Call it every 10–15 seconds and on page change — **not** on every
+keystroke.
+
+`answers` is `questionId → optionRef` and **replaces** the stored snapshot
+wholesale. Past the deadline it is refused with `accepted: false` and
+`reason: "past_deadline"`, and the stored snapshot does not move.
+
+**Idempotency:** inherent, no key. A replacement is convergent, so the outbox
+replays it without a key at all.
+
+#### `POST /api/mock/submit`
+`{ attemptId, idempotencyKey, answers }` → `MockSubmitResponse`
+
+Server-side scoring, and the only moment the mock key is disclosed.
+
+Cost breakdown: rate limit 1 · idempotency reserve 1 · attempt 1 · paper 1 ·
+answer key 1 · option bodies 1 · commit 6 *(batch)* · idempotency finalise 1.
+
+The commit batch is six statements in **one round trip**: answers, per-question
+stats, per-chapter stats, daily activity, SRS cards, then the status flip. Each
+of the first five writes the whole paper with a single `INSERT ... SELECT FROM
+json_each(?)`, so 102 answers are one statement, not 102 inserts.
+
+Rejections:
+
+| Condition | Response |
+| --- | --- |
+| Attempt not owned by the caller | `404 NOT_FOUND` |
+| Attempt not `in_progress` | `409 ATTEMPT_NOT_IN_PROGRESS` |
+| An answer for a question not on this paper | `422 QUESTION_NOT_ON_PAPER` |
+| A ref that does not belong to that question on this attempt | `422 UNKNOWN_OPTION_REF` |
+| Lost a race with a concurrent submission | `409 ATTEMPT_NOT_IN_PROGRESS`, nothing written |
+
+Strictness is conditional, and the distinction is deliberate: a **live** payload
+is strict, because an off-paper id or an unresolvable ref is a client bug or a
+probe. The **stored snapshot** on the expired path is lenient, because it was
+already accepted once and refusing to score a paper over one stale entry would
+penalise a candidate who merely ran out of time.
+
+Response includes `score`, `total`, `correct`, `incorrect`, `skipped`,
+`accuracyPct`, `timing` (`on_time` | `expired`), `scoredAt`,
+`droppedLateAnswers`, and `review[]` — the per-question payload carrying
+`correctRef`, `selectedRef`, `isCorrect` and the explanation.
+
+A question whose stored key points at no option on the paper is **excluded from
+`total`**, not marked wrong. The authored bank genuinely contains these — see
+`frontend/src/data/quarantine.json` — and marking them wrong would punish the
+candidate for a content bug.
+
+**Idempotency:** required key. Replay returns the byte-identical response
+without re-scoring or re-counting stats, and costs fewer queries than the
+original. Same key with a **different** body → `409 IDEMPOTENCY_KEY_REUSED`;
+guessing would be worse than refusing.
+
+#### `GET /api/mock/attempts/:attemptId/review`
+→ `MockSubmitResponse`
+
+Re-reads a submitted attempt from what was recorded, so a lost response or a
+cleared browser does not lose the paper. A read, so it cannot change a stored
+score, and it refuses an attempt that is still `in_progress` — which is what
+stops it being a mid-exam key oracle.
+
+---
+
+### Practice (untimed)
+
+| Method | Path | Auth | D1 cost |
+| --- | --- | --- | --- |
+| `POST` | `/api/practice/start` | required | **7** (50 questions) |
+| `GET` | `/api/practice/sessions/:sessionId` | required | **4–5** |
+| `POST` | `/api/practice/answer` | required | **9** |
+| `POST` | `/api/practice/finish` | required | **4** |
+
+#### `POST /api/practice/start`
+`{ mode, chapterIds?, questionCount, idempotencyKey }` → `PracticeSessionPaper`
+
+`mode` is `chapter` | `bookmarks` | `srs` | `wrong` | `custom`. The **source** of
+the questions is server-decided: `wrong` means the questions the server's own
+stats say the caller got wrong, `srs` means the cards the server says are due.
+A client cannot hand over a list of question ids, which would be a way to farm
+the per-question reveal for a chosen set.
+
+#### `POST /api/practice/answer`
+`{ sessionId, questionId, optionRef, idempotencyKey?, latencyMs?, flaggedGuess?, confidence? }`
+→ `PracticeAnswerResponse`
+
+**Practice reveals the key one question at a time, AFTER the answer is
+committed.** The ordering is what makes it safe:
+
+1. resolve the submitted ref against the paper stored for this session
+2. join the key, compute correctness
+3. **write** the answer and the stats (guarded, so a replay cannot re-write)
+4. only then put `correctRef` and the explanation in the response
+
+So the key for question 7 becomes visible only once question 7 is answered on
+the record. Nothing reveals question 8. Seeing all 50 keys means truthfully
+recording 50 answers, which is what practice is for.
+
+`optionRef: null` records a deliberate skip, which still reveals the key but
+does not count as an attempt toward accuracy or the revision schedule.
+
+`latencyMs`, `flaggedGuess` and `confidence` are **learner telemetry, and
+untrusted**. They are inputs to the spaced-repetition grade only — compare
+`ratingFromOutcome` in `frontend/src/services/scheduler.ts` — never to the
+score. They are safe to accept from a client precisely because the only thing
+they can influence is how soon that learner sees the question again: lying makes
+your own revision schedule worse. Correctness is still computed server-side from
+the key. A mock answer accepts none of this.
+
+**Idempotency:** inherent on `(sessionId, questionId)`, **no key needed**. The
+commit batch guards every increment with `NOT EXISTS (an answer for this pair)`
+and the answer `INSERT` runs last, so replaying a queued offline answer
+converges instead of inflating the user's stats. A key is accepted for
+uniformity.
+
+Another user's session id → `422 QUESTION_NOT_ON_PAPER`. The error does not
+confirm the session exists and does not leak any part of the key — asserted for
+every question on a victim's paper in `worker/src/__tests__/ownership.test.ts`.
+
+#### `GET /api/practice/sessions/:sessionId`
+→ `PracticeSessionPaper`
+
+Resume. `answered` replays `correctRef` for the questions **already answered**
+and for no others, so reloading restores exactly the knowledge the user had
+earned — it is not a way to read the whole paper's key by starting a session and
+reloading. The key query runs only over the answered ids (hence 4 queries when
+none are answered, 5 once some are).
+
+#### `POST /api/practice/finish`
+`{ sessionId, idempotencyKey }` → `PracticeFinishResponse`
+
+Idempotent twice over: the key, and `AND status = 'in_progress'` on the UPDATE.
+A replay returns the same totals rather than a 409.
+
+---
+
+### Progress
+
+| Method | Path | Auth | D1 cost |
+| --- | --- | --- | --- |
+| `GET` | `/api/progress/overview` | required | **3** |
+| `GET` | `/api/progress/history` | required | **1** |
+
+#### `GET /api/progress/overview`
+→ `ProgressOverview` · `{ stats, streak, recent }`
+
+One call for the whole dashboard: per-chapter stats, streaks and the ten most
+recent attempts. The current client computes all of this by reading every
+chapter's JSON and walking localStorage.
+
+Streaks are bucketed by **calendar day in UTC+05:45** (Nepal), not UTC — a 9pm
+study session in Kathmandu would otherwise land on the next UTC day and break
+the streak. A streak survives "nothing done yet today" and breaks only once a
+full day is skipped.
+
+#### `GET /api/progress/history`
+`?limit=20&cursor=` → `AttemptHistoryResponse`
+
+Mock and practice attempts in one `UNION ALL`, newest first. `cursor` is the
+`started_at` of the last row seen; a malformed cursor is a 400, not a `NaN` that
+silently pages from the beginning.
+
+---
+
+### Bookmarks
+
+| Method | Path | Auth | D1 cost |
+| --- | --- | --- | --- |
+| `GET` | `/api/bookmarks` | required | **1** |
+| `PUT` | `/api/bookmarks` | required | **3** |
+
+#### `PUT /api/bookmarks`
+`{ questionId, desired, idempotencyKey? }` → `BookmarkSetResponse`
+
+Expressed as a **desired end state**, not as add/remove verbs. That is what
+makes it replay-safe: `INSERT ... ON CONFLICT DO NOTHING` and a `DELETE` of a
+missing row both converge, so the outbox can replay the same entry any number of
+times. A toggle would flip.
+
+The response is read back from the database rather than echoed from the request:
+bookmarking an unpublished question is a silent no-op in the SQL, and the client
+must be told the truth about the resulting state.
+
+---
+
+### Spaced repetition
+
+| Method | Path | Auth | D1 cost |
+| --- | --- | --- | --- |
+| `GET` | `/api/srs/due` | required | **1** (nothing due) / **3** |
+| `POST` | `/api/srs/review` | required | **3** |
+
+#### `POST /api/srs/review`
+`{ questionId, grade, revision, idempotencyKey? }` → `SrsReviewResponse`
+
+`grade` is `again` | `hard` | `good` | `easy`.
+
+**Idempotent through `revision`, not through a key.** The write carries
+`AND revision = ?expected`, so a replayed outbox entry whose revision the server
+has already moved past changes nothing and comes back as `applied: false` with
+the current card. This is strictly better than a key here, because it also makes
+a stale review from a second device a no-op instead of a conflict.
+
+The schedule is server state, so a client cannot bring a card forward to farm an
+easy session, and it survives a cleared browser.
+
+---
+
+### Errata reports
+
+| Method | Path | Auth | D1 cost |
+| --- | --- | --- | --- |
+| `POST` | `/api/reports` | required | **2** |
+| `GET` | `/api/reports` | required | **1** |
+
+#### `POST /api/reports`
+`{ questionId, reason, detail?, idempotencyKey? }` → `{ reportId, created }`
+
+`reason` is `wrong_answer` | `ambiguous` | `typo` | `duplicate` |
+`out_of_syllabus` | `other`.
+
+**Idempotent with no key**, through a unique index on `(user_id, question_id)`:
+re-reporting updates the existing report instead of filling the triage queue
+with duplicates. `created` tells the caller which happened.
+
+The `INSERT` selects from `questions`, so an unknown question id writes nothing
+and returns `404` rather than creating an orphan report.
+
+---
+
+### Admin
+
+Behind a role check on `users.role`, read from the database through the session —
+never from the cookie, never from a request field, so there is nothing a client
+can edit to escalate. An unrecognised role reads as the least privileged.
+
+| Method | Path | Role | D1 cost |
+| --- | --- | --- | --- |
+| `GET` | `/api/admin/reports` | moderator+ | **1** |
+| `POST` | `/api/admin/reports/triage` | moderator+ | **4** (any batch size) |
+| `POST` | `/api/admin/questions/publish` | **admin only** | **4** (any batch size) |
+| `GET` | `/api/admin/audit` | moderator+ | **1** |
+
+Publishing is admin-only, not moderator, because it changes what candidates sit.
+
+#### `POST /api/admin/reports/triage`
+`{ reportIds, status, resolutionNote?, idempotencyKey }` → `{ updated, status }`
+
+Up to 100 ids travel as one JSON parameter, so bulk triage does not scale with
+the number of rows.
+
+#### `POST /api/admin/questions/publish`
+`{ questionIds, state, idempotencyKey }` → `{ updated, state }`
+
+`state` is `draft` | `published` | `retired`. **Retiring** is the lever that
+takes a known-bad question out of every future paper without deleting the
+attempts recorded against it — which is what `frontend/src/data/quarantine.ts`
+is doing by hand today with a hardcoded id list.
+
+Both mutations write an `audit_log` row **in the same batch** as the mutation, so
+there is no path that changes published content without leaving a trace.
+
+---
+
+## The offline outbox contract
+
+The app is a PWA (`vite-plugin-pwa`) used on patchy mobile connections. The
+client in `frontend/src/services/api.ts` implements this contract.
+
+### The rule
+
+> **An outbox entry carries an idempotency key minted ONCE at enqueue time, and
+> never regenerated on retry.**
+
+A retry with a fresh key is a *second mutation* as far as the server is
+concerned: for a mock submission that means `409 ATTEMPT_NOT_IN_PROGRESS`, and
+for anything that increments it would mean double-counted progress.
+
+### Replayable mutations
+
+`OutboxEntry` in `worker/src/shared/types.ts` is the closed, discriminated set:
+
+| Kind | Endpoint | Idempotency mechanism |
+| --- | --- | --- |
+| `mock.sync` | `POST /api/mock/sync` | Snapshot replacement — **no key** |
+| `mock.submit` | `POST /api/mock/submit` | **Key required** |
+| `practice.answer` | `POST /api/practice/answer` | Unique `(session, question)` |
+| `practice.finish` | `POST /api/practice/finish` | **Key required** + status guard |
+| `bookmark.set` | `PUT /api/bookmarks` | Desired end state |
+| `srs.review` | `POST /api/srs/review` | `revision` guard |
+| `report.submit` | `POST /api/reports` | Unique `(user, question)` |
+
+### Draining
+
+`drainOutbox()` replays **oldest first and stops on the first retryable
+failure**. Order is load-bearing: a `mock.submit` queued behind a `mock.sync`
+must not overtake it, because the sync is what the expiry clamp scores if the
+submission turns out to be late. Skipping past a stalled entry would silently
+change what gets scored.
+
+| Outcome | Action |
+| --- | --- |
+| `ok` | Remove, continue |
+| `NETWORK_UNAVAILABLE`, `RATE_LIMITED`, `REQUEST_IN_FLIGHT`, 5xx | Increment `attempts`, **stop**, preserve order |
+| `BAD_REQUEST`, `FORBIDDEN`, `NOT_FOUND`, `CONFLICT`, `IDEMPOTENCY_KEY_REUSED`, `ATTEMPT_NOT_IN_PROGRESS`, `QUESTION_NOT_ON_PAPER`, `UNKNOWN_OPTION_REF`, `UNAUTHENTICATED`, … | **Drop** and report via `onDropped` |
+| 8 attempts reached | Drop |
+
+A permanently-failing entry is dropped rather than kept, because the drain is
+ordered: keeping it would block every later mutation forever.
+
+`sendOrQueue(entry)` is the function most call sites want — it tries now and
+falls back to the queue, using the **same key** for both, so the eventual replay
+cannot duplicate a mutation that actually did land.
+
+Call `drainOutbox()` on `online`, on app focus, and after any successful request.
+
+### What the outbox must not be used for
+
+Auth. A queued `login` or `upgrade` replayed hours later against a changed
+server state is confusing at best; both are interactive and must fail loudly.
+
+---
+
+## Idempotency
+
+Send the key in the request **body** as `idempotencyKey`. Keys are 8–80
+characters from `[A-Za-z0-9_.:-]` (a `randomUUID()` qualifies) and are scoped to
+`(user_id, key)` — one user's key can neither collide with nor read another's.
+
+| Situation | Response |
+| --- | --- |
+| First use | The work is done; the response is stored |
+| Same key, same body, finished | The stored response, replayed verbatim, with `Idempotent-Replay: true` |
+| Same key, same body, still in flight | `409 REQUEST_IN_FLIGHT` with `retryAfterMs` |
+| Same key, **different** body | `409 IDEMPOTENCY_KEY_REUSED` |
+
+The reservation is a real row with a `NULL response_json`, so two concurrent
+copies of the same request cannot both proceed — the second gets `in_flight`
+rather than both scoring the same attempt. The body fingerprint is
+`SHA-256(endpoint + canonical JSON)`, with object keys sorted and
+`idempotencyKey` itself excluded, so a queue rehydrated from storage with a
+different key order still fingerprints identically.
+
+If a handler throws, the reservation is released so an immediate retry is not
+stuck behind a key that will never be finalised. Records are retained for 7 days.
+
+---
+
+## Rate limits
+
+Fixed-window counters in D1, one query per check, keyed by user id or by hashed
+IP (the table stores a hash, never a raw address).
+
+| Bucket | Limit | Window |
+| --- | --- | --- |
+| `auth:login` (per IP **and** per email) | 10 | 10 min |
+| `auth:signup` | 5 | 1 h |
+| `auth:anonymous` | 10 | 1 h |
+| `auth:upgrade` | 5 | 1 h |
+| `mock:start` | 20 | 1 h |
+| `mock:submit` | 40 | 1 h |
+| `mock:sync` | 240 | 1 h |
+| `practice:answer` | 600 | 1 h |
+| `report:submit` | 30 | 1 h |
+| `content:search` | 120 | 1 h |
+
+Exceeding one gives `429 RATE_LIMITED` with `error.retryAfterMs` and a
+`Retry-After` header.
+
+**These are best-effort by construction, and the honest reason is worth writing
+down:** D1 replicates asynchronously, so two requests served from different
+Cloudflare locations can both read a stale counter and both be allowed. The
+effective limit is roughly *limit per window per region*. That is adequate
+against credential stuffing, submit hammering and search abuse. It is not a
+substitute for a Durable Object or Cloudflare's WAF rate limiting, neither of
+which is on the free plan.
+
+---
+
+## Errors
+
+Every failure is `{ "error": { "code", "message", "fields?", "retryAfterMs?" } }`.
+Unexpected throws become a bare `500 INTERNAL` with a fixed message — a D1 error
+string can contain SQL, column names, and sometimes row values.
+
+| Code | Status | Meaning |
+| --- | --- | --- |
+| `BAD_REQUEST` | 400 | Validation failed; see `fields` |
+| `UNAUTHENTICATED` | 401 | No live session |
+| `INVALID_CREDENTIALS` | 401 | Wrong email or password |
+| `FORBIDDEN` | 403 | Authenticated but not permitted |
+| `NOT_FOUND` | 404 | Missing, **or owned by someone else** |
+| `CONFLICT` | 409 | Generic state conflict |
+| `EMAIL_IN_USE` | 409 | Address already claimed |
+| `NOT_ANONYMOUS` | 409 | Account already registered |
+| `ATTEMPT_NOT_IN_PROGRESS` | 409 | Already submitted, or finished |
+| `IDEMPOTENCY_KEY_REUSED` | 409 | Same key, different body |
+| `REQUEST_IN_FLIGHT` | 409 | Duplicate still processing; retry |
+| `INSUFFICIENT_CONTENT` | 409 | Not enough published questions |
+| `PAYLOAD_TOO_LARGE` | 413 | Body over 128 KB |
+| `QUESTION_NOT_ON_PAPER` | 422 | Answer for a question not on this attempt |
+| `UNKNOWN_OPTION_REF` | 422 | Ref does not belong to that question here |
+| `RATE_LIMITED` | 429 | See `retryAfterMs` |
+| `OAUTH_STATE_INVALID` | 400 | Expired or replayed OAuth callback |
+| `OAUTH_EXCHANGE_FAILED` | 502 | Google rejected the exchange |
+| `INTERNAL` | 500 | Unexpected |
+| `BACKEND_NOT_CONFIGURED` | 501 | **Client-synthesised**; no `VITE_API_BASE_URL` |
+| `NETWORK_UNAVAILABLE` | 503 | **Client-synthesised**; server unreachable |
+
+The last two are never sent by the Worker. They live in the same union so a
+caller can switch over one exhaustive set of codes instead of handling transport
+failures through a separate channel.
+
+---
+
+## Running with no backend
+
+The app must keep working with no backend configured — that is the deployment
+that is live today. `frontend/src/services/api.ts` **adds to**
+`frontend/src/services/localData.ts`; it does not replace it.
+
+With `VITE_API_BASE_URL` unset, `isBackendConfigured()` returns `false` and
+nothing in the module issues a request: every function short-circuits to an
+`ApiResult` with code `BACKEND_NOT_CONFIGURED`. A call site that forgets to
+branch degrades to "no data" rather than to a stack of failed fetches.
+
+```ts
+import { isBackendConfigured, api } from '../services/api';
+import * as local from '../services/localData';
+
+const chapters = isBackendConfigured()
+  ? (await api.getChapters()).data?.chapters ?? []
+  : local.bookChapters;
+```
+
+**Note the asymmetry, because it is the whole point:** the localStorage path
+cannot enforce the anti-cheat guarantees. It has the key in the browser by
+construction. Mock tests are only tamper-resistant with a backend configured.
+
+---
+
+## Configuration
+
+Worker bindings. Configuration **fails closed**: a missing secret throws at
+request time naming the variable, rather than falling back to a development
+default that would ship a predictable permutation secret or an open CORS policy.
+
+| Variable | Required | Notes |
+| --- | --- | --- |
+| `DB` | yes | D1 binding |
+| `APP_ORIGIN` | yes | Drives CORS and OAuth redirects. No wildcard: credentials are cookies, so `Access-Control-Allow-Origin` cannot be `*`, and an unrecognised origin gets no CORS headers at all |
+| `CONTENT_PERMUTATION_SECRET` | yes | ≥ 32 chars. Seeds the stable browse permutation. With it, the permutation for a given `(user, question)` can be reproduced offline and joined against the public chapter JSON in git history |
+| `GOOGLE_CLIENT_ID` / `GOOGLE_CLIENT_SECRET` / `GOOGLE_REDIRECT_URI` | all or none | A half-configured OAuth app fails with `redirect_uri_mismatch` at Google, which is a confusing place to debug it. Omit all three and the Google routes 404 |
+| `PASSWORD_HASH_ITERATIONS` | no | Default `100000`. **Raise to `600000` on the paid plan.** OWASP asks for 600k for PBKDF2-SHA256, but Workers Free allows ~10 ms CPU per invocation and 600k will not fit. The stored hash format is self-describing, so raising this verifies old hashes and transparently rehashes them on next login |
+| `D1_QUERY_BUDGET` | no | Default `45`, under the free cap of 50. Raise to ~900 on the paid plan |
+| `ENVIRONMENT` | no | `development` disables the `Secure` cookie flag |
+
+`frontend`: `VITE_API_BASE_URL`. Unset means local-only mode.
+
+---
+
+## Schema reconciliation
+
+This API was written alongside the Drizzle schema in `worker/db/` and
+`worker/migrations/`, and does not import it. Everything it assumes about the
+database is declared in one place — `ASSUMED_SCHEMA_DDL` in
+`worker/src/data/tables.ts` — which is also the DDL the test suite runs against,
+so the suite is simultaneously a test of this API and an executable statement of
+its requirements.
+
+The shipped migrations have since been read. The full delta, with a
+table-by-table name map, is in the reconciliation block at the bottom of
+`worker/src/data/tables.ts`. **Four items block this API from running against
+them as written:**
+
+1. **Timestamps are seconds, not milliseconds.** The migrations default to
+   `unixepoch()`. This API is milliseconds throughout. It does not fail loudly —
+   it makes a 45-minute deadline expire in 45 milliseconds. Highest-risk item on
+   the list.
+2. **`users.email` is `NOT NULL` and there is no `is_anonymous`,** so there is
+   nowhere to put an anonymous guest — and with the guest goes the ability to
+   sit a server-scored mock without signing up.
+3. **`idempotency_keys`, `rate_limits`, `oauth_accounts` and `oauth_states` do
+   not exist.** The offline replay contract, the rate limits and Google sign-in
+   all need them.
+4. **`attempts` has nowhere to store a pre-deadline answer snapshot.** Without
+   two columns for it, a late submission can only be scored as zero or trusted
+   wholesale, and both are wrong.
+
+Everything else is a rename handled inside `worker/src/data/`. Nothing above
+that directory knows a table name.
+
+---
+
+## Testing
+
+```bash
+node --test "worker/src/__tests__/*.test.ts"
+```
+
+88 tests, no dependencies and no network: Node 22's `node:sqlite` provides a
+local SQLite database and `node:test` the runner.
+
+The suite drives the **real handlers** — ownership checks, the expiry clamp,
+scoring, idempotency, the actual SQL — because everything in `worker/src/handlers/`
+is a plain `(ctx, input) => { status, body }` function and the Hono layer in
+`worker/src/index.ts` only parses, validates, calls one of them, and serialises.
+Nothing is re-implemented for the tests.
+
+The schema under test is `ASSUMED_SCHEMA_DDL` in `worker/src/data/tables.ts`, so
+the suite is simultaneously a test of this API and an executable statement of
+what it expects from the database.
diff --git a/docs/deploy-cloudflare.md b/docs/deploy-cloudflare.md
new file mode 100644
index 0000000..04ba9f5
--- /dev/null
+++ b/docs/deploy-cloudflare.md
@@ -0,0 +1,491 @@
+# Deploying to Cloudflare — the steps only an account holder can do
+
+Everything in this file needs your Cloudflare account. Nothing here can be
+done from the repo, which is why it is a checklist rather than a script.
+
+Work through it in order; later steps depend on ids produced by earlier ones.
+Each step says what to paste where, and what "it worked" looks like.
+
+**Never paste a secret into a chat, a commit, a PR or a screenshot.** Secrets
+go in via `wrangler secret put`, which reads from your terminal and stores the
+value on Cloudflare. They are never written to a file in this repo.
+
+---
+
+## 0. Prerequisites
+
+```bash
+cd worker
+npx wrangler login          # opens a browser, authorises this machine
+npx wrangler whoami         # should print your account name and id
+```
+
+If `whoami` prints an account, you are ready. Note the **account id** — you
+will not need to paste it anywhere, but it confirms which account the rest of
+these commands act on.
+
+**Cost check before you start.** Everything below runs on free tiers:
+
+| | Free allowance | What binds first here |
+|---|---|---|
+| Workers | 100,000 requests/day | Request count |
+| D1 storage | 500 MB per database | ~4M answer rows; the retention cron keeps it bounded |
+| D1 reads | 5M rows/day | Comfortable |
+| D1 writes | 100,000 rows/day | Answer recording; the retention cron is capped at 25,000/day so it can never eat the budget |
+| Pages | unlimited requests | — |
+
+Workers Paid is $5/month and raises D1 writes to 50M/day. You do not need it
+to launch. The one thing it buys that matters is headroom on write volume once
+you have a few hundred daily users.
+
+---
+
+## 1. Create the D1 database
+
+```bash
+cd worker
+npx wrangler d1 create necprep
+```
+
+It prints a block like:
+
+```
+[[d1_databases]]
+binding = "DB"
+database_name = "necprep"
+database_id = "a1b2c3d4-...."
+```
+
+**Copy the `database_id`.** Paste it into `worker/wrangler.toml` in **two**
+places, replacing `REPLACE_WITH_D1_DATABASE_ID`:
+
+- line ~25, under the top-level `[[d1_databases]]`
+- line ~85, under `[[env.production.d1_databases]]`
+
+It is the same id in both. The placeholder is deliberate: a wrong-but-plausible
+id would deploy against the wrong database, so it must fail loudly until a
+human pastes the real one.
+
+> The database id is **not** a secret. It identifies a database that still
+> requires your API token to touch. It is fine in the repo, and it has to be —
+> `wrangler` reads it from this file at deploy time.
+
+**Verify:**
+```bash
+npx wrangler d1 list        # necprep should appear
+```
+
+---
+
+## 2. Apply the migrations to the real database
+
+```bash
+cd worker
+npx wrangler d1 migrations apply necprep --remote
+```
+
+This runs `migrations/0001` through `0009` in order. It will list them and ask
+for confirmation.
+
+**Verify** — this should print 10 chapters and 60 sub-chapters:
+```bash
+npx wrangler d1 execute necprep --remote \
+  --command "SELECT (SELECT COUNT(*) FROM chapters) AS chapters, (SELECT COUNT(*) FROM subchapters) AS subchapters"
+```
+
+If `chapters` is 0, migration `0007_reference_data.sql` did not run — stop and
+say so, rather than continuing.
+
+---
+
+## 3. Set the secrets
+
+Two are required. The third group is optional.
+
+### 3a. `CONTENT_PERMUTATION_SECRET` — required
+
+This seeds the option shuffle the content endpoints serve. It must be at least
+32 characters and must not be guessable: with it, the shuffle applied to any
+(user, question) can be reproduced offline and joined against the chapter JSON
+that is public in this repo's git history.
+
+Generate one and pipe it straight in, so it never appears in your shell
+history or on screen:
+
+```bash
+cd worker
+openssl rand -base64 48 | npx wrangler secret put CONTENT_PERMUTATION_SECRET
+openssl rand -base64 48 | npx wrangler secret put CONTENT_PERMUTATION_SECRET --env production
+```
+
+Run it for **both** environments — they are separate secret stores. Different
+values in each is fine and slightly better.
+
+> If you ever need to rotate this: it is safe. Rotating reshuffles every
+> browse order and nothing else breaks.
+
+### 3b. `APP_ORIGIN` — required, but it is a var, not a secret
+
+You edit this in `worker/wrangler.toml`, not via `wrangler secret`. It drives
+CORS and the OAuth redirect, so it must be the exact origin your frontend is
+served from, **with no trailing slash**:
+
+- `[vars]` → `APP_ORIGIN` — leave as `http://localhost:5173` for local dev
+- `[env.production.vars]` → `APP_ORIGIN` — replace
+  `REPLACE_WITH_FRONTEND_ORIGIN` with the real one, e.g.
+  `https://necprep.pages.dev` or your custom domain
+
+You will know this value after step 5, so it is fine to come back to it.
+
+### 3c. Google sign-in — optional, skip to step 4 if you do not want it
+
+Google is **not required to launch.** Guest and email/password both work
+without it. Everything below is additive.
+
+#### What you do NOT need
+
+These are the three things people assume block them, and none of them apply:
+
+- **App verification / review.** The code requests `openid email profile`
+  (`worker/src/handlers/auth.ts:384`). All three are *non-sensitive* scopes, so
+  Google requires no review, no demo video and no security assessment.
+- **Billing.** No card, no paid project.
+- **A different auth provider.** Auth0 and the like ship "developer keys" for
+  Google that are documented as testing-only — shared and rate-limited. Going
+  to production through them means creating your own Google OAuth client
+  anyway, i.e. doing exactly this section plus running a second auth system.
+
+#### You do not enable an API for this
+
+There is no API to turn on. Sign-in with Google uses the OAuth endpoints
+directly, and the code calls `accounts.google.com` and
+`openidconnect.googleapis.com` without any project-level API being enabled.
+
+In particular **`cloudoauth.googleapis.com` ("Cloud OAuth Service API") is not
+it.** That service issues tokens for calling Google Cloud APIs as a Google
+Cloud user; it has nothing to do with your users signing in. Enabling it is
+harmless and does nothing for this.
+
+If you find yourself on an **API/Service Details** page with Metrics and Quotas
+tabs, you are in the wrong part of the console.
+
+#### The console was renamed
+
+What older guides call the **OAuth consent screen** is now **Google Auth
+Platform**, and it is split into four pages: Branding, Audience, Clients and
+Data access. `APIs & Services → OAuth consent screen` redirects there.
+
+Direct links, with the project already selected — replace `PROJECT_ID` with
+yours:
+
+| Page | URL |
+|---|---|
+| Overview | `https://console.cloud.google.com/auth/overview?project=PROJECT_ID` |
+| Branding | `https://console.cloud.google.com/auth/branding?project=PROJECT_ID` |
+| Audience | `https://console.cloud.google.com/auth/audience?project=PROJECT_ID` |
+| Clients | `https://console.cloud.google.com/auth/clients?project=PROJECT_ID` |
+
+#### Click by click
+
+**1. Create a project.** [console.cloud.google.com](https://console.cloud.google.com)
+→ project dropdown in the top bar → **New project** → name it `necprep` →
+**Create**. Wait for the notification, then make sure that project is selected
+in the top bar. *Most confusion here comes from configuring one project while
+a different one is selected.*
+
+**2. Branding** (`/auth/branding`) — the old consent screen.
+
+- **App name**: `NECPrep`
+- **User support email**: your address
+- **Developer contact email**: your address
+- Leave the App domain fields **empty for now** — see "Testing vs Published"
+  below.
+- Save.
+
+**3. Audience** (`/auth/audience`).
+
+- User type: **External**.
+  (*Internal* is only offered on Google Workspace accounts and would restrict
+  sign-in to your own organisation.)
+- **Test users** → **Add users** → add your own Gmail address → Save.
+  This matters: while the app is in Testing, *only* the addresses listed here
+  can sign in. A correctly configured app will refuse everyone else, with an
+  error that mentions verification and misleads accordingly.
+
+**4. Data access** (`/auth/dataaccess`) → change nothing. `openid`, `email`
+and `profile` are granted by default and need not be added; adding anything
+from this page is what turns a no-review app into one that needs review.
+
+**5. Create the credential.** **Clients** (`/auth/clients`) →
+**Create client**. (Classic console: APIs & Services → Credentials → Create
+credentials → OAuth client ID. Both reach the same place.)
+
+- Application type: **Web application**
+- Name: `necprep-api`
+- **Authorised JavaScript origins**: leave **empty**. This is a server-side
+  flow; the browser never holds the token.
+- **Authorised redirect URIs** → **Add URI** → paste exactly:
+  ```
+  https://necprep-api.waglesameer5.workers.dev/api/auth/google/callback
+  ```
+- **Create**
+
+A dialog shows the **Client ID** and **Client secret**. Keep it open, or
+download the JSON — the secret can be re-shown later, but it is easier not to
+have to.
+
+**6. Hand them over.** Either run these three and paste each value when
+prompted:
+
+```bash
+cd worker
+npx wrangler secret put GOOGLE_CLIENT_ID --env production
+npx wrangler secret put GOOGLE_CLIENT_SECRET --env production
+npx wrangler secret put GOOGLE_REDIRECT_URI --env production
+```
+
+`GOOGLE_REDIRECT_URI` is the full callback URL from step 5, **character for
+character** — a trailing slash or `http` instead of `https` is a mismatch.
+
+The client id is not really a secret, but all three are stored the same way
+because `loadConfig` requires all three or none: a half-configured OAuth app
+fails at Google with `redirect_uri_mismatch`, which is a confusing place to
+debug a missing environment variable.
+
+#### Testing vs Published
+
+Leaving the app in **Testing** is a legitimate place to stop. Up to 100 listed
+test users can sign in, no App-domain fields are required, and nothing expires
+for a non-sensitive-scope app.
+
+**Publishing** removes the test-user list so anyone can sign in, and Google
+then requires an **Application homepage** and a **Privacy policy URL** on the
+consent screen. The platform has neither page yet. Ask and I will build
+`/privacy` and `/terms` — a public exam platform needs them regardless — and
+then publishing is two clicks.
+
+#### If it goes wrong
+
+| Message | Cause |
+|---|---|
+| `Error 400: redirect_uri_mismatch` | The redirect URI in the console differs from `GOOGLE_REDIRECT_URI`. Compare them character for character, including `https` and no trailing slash. |
+| `Error 403: access_denied` + "has not completed the Google verification process" | The app is in Testing and the signing-in address is not in the test-user list. Add it in step 4. |
+| "This app isn't verified" warning screen | Expected in Testing. Click **Advanced** → **Go to NECPrep (unsafe)**. It disappears once published. |
+| Google routes return 404 | Fewer than three secrets are set. That is deliberate — see `loadConfig`. |
+| `invalid_client` | Client id or secret mistyped, or they belong to a different project than the redirect URI. |
+| You are on an "API/Service Details" page with Metrics and Quotas tabs | Wrong section. No API needs enabling; go to `/auth/clients`. |
+| Cannot find "OAuth consent screen" | Renamed to **Google Auth Platform**. See the table above. |
+
+Confirm it is live:
+```bash
+curl -s -o /dev/null -w "%{http_code} %{redirect_url}\n" \
+  "https://necprep-api.waglesameer5.workers.dev/api/auth/google/start"
+```
+A `302` to `accounts.google.com` means configured. A `404` means the secrets
+are not all set.
+
+**Verify:**
+```bash
+npx wrangler secret list --env production
+```
+
+---
+
+## 4. Deploy the Worker
+
+```bash
+cd worker
+npx wrangler deploy --env production
+```
+
+Expected output includes:
+
+- `Your Worker has access to the following bindings:` listing `env.DB`,
+  `env.ENVIRONMENT`, `env.APP_ORIGIN`, `env.ANSWER_RETENTION_DAYS`
+- a **Schedules** section listing the three crons — `10 2 * * *`,
+  `40 2 * * *`, `5 * * * *`
+- a URL like `https://necprep-api.<your-subdomain>.workers.dev`
+
+**Copy that URL.** It is `VITE_API_BASE_URL` in step 5.
+
+If the Schedules section is missing, the `scheduled` handler did not register —
+tell me, do not work around it.
+
+**Verify the API is alive:**
+```bash
+curl -s https://necprep-api.<your-subdomain>.workers.dev/api/content/chapters | head -c 200
+```
+
+A JSON array of chapters means the Worker, D1 and the reference data are all
+wired. A 500 almost always means `APP_ORIGIN` or
+`CONTENT_PERMUTATION_SECRET` is missing — the config fails closed on purpose.
+
+---
+
+## 5. Load the question bank into the real database
+
+The bank is in git, so this is an import rather than a transfer. Three
+commands:
+
+```bash
+cd worker
+npm run db:apply:local        # migrations into .local/necprep.sqlite
+npm run db:seed:local         # 2,290 questions, 1,523 classified
+npm run db:export:remote      # writes .local/remote/*.sql
+```
+
+The last one prints nine numbered files. Replay them **in order**:
+
+```bash
+cd worker
+for f in .local/remote/*.sql; do
+  npx wrangler d1 execute necprep --remote --file "$f" -y || break
+done
+```
+
+The `|| break` matters: `question_options` and `question_answer_keys`
+reference `questions`, so a later file needs rows an earlier one inserted. If
+one fails, stop and fix it rather than continuing.
+
+**Verify** — should print 2290, 2184 and 1523:
+```bash
+npx wrangler d1 execute necprep --remote --command \
+  "SELECT COUNT(*) AS questions,
+          SUM(status = 'published') AS published,
+          SUM(subchapter_id IS NOT NULL) AS classified
+     FROM questions"
+```
+
+> **Why a script and not `wrangler d1 export`.** `--local` exports the
+> database `wrangler dev` uses, which is *not* the one `db:seed:local` writes,
+> and it emits CREATE TABLE statements that fail against an already-migrated
+> database. Both failures are quiet. `db/seed/export-content-sql.mjs` reads the
+> file the seed actually wrote and emits data only.
+>
+> **It is safe to re-run**, both the export and the replay: every statement is
+> `INSERT OR REPLACE` and question ids are content hashes, so after a bank
+> update only changed rows change. Verified by replaying the full set twice
+> into a fresh migrated database — identical counts, zero foreign-key
+> violations.
+>
+> **It only touches content.** Questions, options and answer keys. No users,
+> sessions, attempts or progress: content is derived from files in git and is
+> safe to replace wholesale, user data is not.
+
+---
+
+## 6. Deploy the frontend
+
+```bash
+cd frontend
+npm run build
+npx wrangler pages deploy dist --project-name necprep
+```
+
+First run asks to create the project; accept. It prints a URL like
+`https://necprep.pages.dev`.
+
+### The API base URL
+
+Vite inlines `VITE_API_BASE_URL` at **build** time. We deploy a bundle that is
+already built, so Cloudflare never runs the build and a Pages dashboard
+variable would have no effect — **the value has to be present on the machine
+that runs `npm run build`.**
+
+Create `frontend/.env.production` with the Worker URL from step 4, no trailing
+slash:
+
+```bash
+cd frontend
+printf 'VITE_API_BASE_URL=https://necprep-api.<your-subdomain>.workers.dev\n' > .env.production
+npm run build
+npx wrangler pages deploy dist --project-name necprep --branch main
+```
+
+That file is **gitignored**. The value is public — a `VITE_` variable is
+compiled into the bundle every visitor downloads — but the stage guard treats
+every `.env` file as a secret file and that rule is worth keeping, so the file
+lives on the build machine rather than in the repo. Anyone setting up a new
+build environment runs the `printf` above once.
+
+**Leaving it out is not an error.** The build succeeds and produces the
+local-only app: questions from `public/data/*.json`, progress in
+localStorage, no sign-in. That is a supported mode. It is also easy to ship by
+accident, so confirm the URL is in the bundle before you call it done:
+
+```bash
+grep -rl "workers.dev" dist/assets/ | head -1    # should print one .js file
+```
+
+Now go back to **step 3b** and set `APP_ORIGIN` in
+`[env.production.vars]` to this Pages URL, then redeploy the Worker:
+
+```bash
+cd worker
+npx wrangler deploy --env production
+```
+
+The two have to agree: the Worker's CORS policy names the frontend origin, and
+the frontend names the Worker URL.
+
+---
+
+## 7. Confirm the crons are actually scheduled
+
+```bash
+cd worker
+npx wrangler deployments list --env production | head -20
+```
+
+And in the dashboard: **Workers & Pages** → `necprep-api` → **Settings** →
+**Trigger Events**. Three cron triggers should be listed.
+
+To test one immediately rather than waiting for 02:10 UTC:
+
+```bash
+cd worker
+npx wrangler dev --test-scheduled --env production
+# then, in another terminal:
+curl "http://localhost:8787/__scheduled?cron=5+*+*+*+*"
+```
+
+That fires the leaderboard job. It logs one JSON line with `ok: true`, the
+query count and what it wrote. An unknown cron string throws on purpose.
+
+---
+
+## What you do NOT need to do
+
+- **No Hyperdrive.** D1 is single-threaded per database and serialises writes;
+  there is no connection pool to put in front of it.
+- **No R2 bucket**, unless you later want long-term answer archival. The
+  retention job deletes rather than archives, which is what actually bounds
+  the database. See `worker/src/jobs/retention.ts` for why.
+- **No KV namespace.** Sessions, rate limits and idempotency keys are all D1
+  tables, deliberately — one store, one set of transactional guarantees.
+- **No Durable Objects.** `wrangler.toml` has an empty migration tag so
+  `deploy` does not warn; nothing uses them.
+- **No Workers Paid**, to launch.
+
+---
+
+## If something fails
+
+| Symptom | Cause |
+|---|---|
+| Every request 500s | `APP_ORIGIN` or `CONTENT_PERMUTATION_SECRET` missing. Config fails closed by design. |
+| `Server is not configured` in logs | Same, and the log names the variable. |
+| CORS error in the browser | `APP_ORIGIN` does not exactly match the frontend origin. Check the scheme and the trailing slash. |
+| `redirect_uri_mismatch` at Google | `GOOGLE_REDIRECT_URI` differs from the console value. |
+| `/api/content/chapters` returns `[]` | Migration 0007 did not run, or step 5 was skipped. |
+| Google routes 404 | Fewer than three Google secrets set. That is the intended behaviour. |
+| No Schedules section on deploy | The `scheduled` export is missing. Report it. |
+
+Worker logs:
+```bash
+cd worker
+npx wrangler tail --env production
+```
+
+Observability is already enabled in `wrangler.toml`, so logs are retained in
+the dashboard as well.
diff --git a/docs/local-development.md b/docs/local-development.md
new file mode 100644
index 0000000..b31a30f
--- /dev/null
+++ b/docs/local-development.md
@@ -0,0 +1,179 @@
+# Running the whole thing locally
+
+You can test everything on your own machine, including the real Google sign-in
+flow. There is no "dev mode" branch in the code — the local Worker runs the
+same handlers, against the same schema, reading secrets the same way.
+
+Testing OAuth by deploying to production and clicking around is the slow and
+dangerous way to do it. This is the fast one.
+
+---
+
+## One-time setup
+
+```bash
+cd worker
+cp .dev.vars.example .dev.vars     # local secrets; gitignored
+npm run dev:setup                  # migrations + 2,290 questions
+```
+
+`dev:setup` takes a couple of minutes and does five things:
+
+| Step | What it builds |
+|---|---|
+| `db:apply:local` | migrations into `.local/necprep.sqlite` |
+| `db:seed:local` | the question bank, classified into sub-chapters |
+| `db:export:remote` | `.local/remote/*.sql` |
+| `d1:migrate:local` | migrations into the **wrangler** database |
+| `d1:load:local` | the same content into the **wrangler** database |
+
+### Why two databases
+
+This trips people up, so it is worth a sentence:
+
+```
+.local/necprep.sqlite                         tests, db:smoke, db:verify
+.wrangler/state/v3/d1/miniflare-<hash>.sqlite  wrangler dev, --local
+```
+
+`npm run db:seed:local` fills the **first**. `wrangler dev` reads the
+**second**, and never looks at the first. So it is entirely possible to run
+`npm run db:check`, see 2,290 questions pass, start `wrangler dev`, and get an
+empty API. `d1:load:local` is what bridges them, and `dev:setup` runs both.
+
+---
+
+## Every day
+
+Two terminals.
+
+```bash
+# terminal 1 — the API on http://localhost:8787
+cd worker && npm run dev
+```
+
+```bash
+# terminal 2 — the app on http://localhost:5173
+cd frontend
+echo "VITE_API_BASE_URL=http://localhost:8787" > .env.local   # once
+npm run dev
+```
+
+`.env.local` is gitignored. Delete it to run the app against static JSON with
+no backend at all — a supported mode, and worth checking occasionally, because
+it is what a visitor gets if a build ever ships without the variable.
+
+**Check the API is awake:**
+
+```bash
+curl -s http://localhost:8787/api/content/chapters | head -c 120
+```
+
+Ten chapters with real counts means the Worker, the local D1 and the seed all
+line up.
+
+---
+
+## Testing Google sign-in locally
+
+Google permits `http://localhost` redirect URIs as an explicit exception to
+its HTTPS rule. That is what makes this possible.
+
+**1. Add a second redirect URI to the SAME OAuth client** —
+[Clients](https://console.cloud.google.com/auth/clients) → your client → add,
+alongside the production one:
+
+```
+http://localhost:8787/api/auth/google/callback
+```
+
+One client with two URIs, not two clients. A second client is a second secret
+to rotate and a second consent screen to keep in step.
+
+**2. Fill in all three values in `worker/.dev.vars`:**
+
+```
+GOOGLE_CLIENT_ID=...apps.googleusercontent.com
+GOOGLE_CLIENT_SECRET=GOCSPX-...
+GOOGLE_REDIRECT_URI=http://localhost:8787/api/auth/google/callback
+```
+
+**All three or none.** With one or two set, the Google routes return
+`500 Google sign-in is misconfigured` — on purpose, because a half-configured
+OAuth app otherwise fails much later, at Google, as
+`redirect_uri_mismatch`. Everything else keeps working; see below.
+
+**3. Restart `npm run dev`.** Wrangler reads `.dev.vars` at startup, not per
+request.
+
+**4. Check:**
+
+```bash
+curl -s -o /dev/null -w "%{http_code}\n" \
+  http://localhost:8787/api/auth/google/start
+```
+
+| | |
+|---|---|
+| `302` | configured — it is redirecting to `accounts.google.com` |
+| `404` | none of the three set; the feature is simply off |
+| `500` | one or two set. Fix `.dev.vars` and restart |
+
+Then click Continue with Google in the app at `http://localhost:5173`.
+
+Expect an **"This app isn't verified"** warning while the consent screen is in
+Testing: Advanced → Go to NECPrep. And your own address must be on the
+**Test users** list, or Google refuses with a message about verification that
+has nothing to do with the real cause.
+
+---
+
+## A misconfigured optional feature cannot break a required one
+
+`loadConfig` runs in the `/api/*` middleware, once per request, so anything it
+throws for takes down every endpoint. That is correct for `APP_ORIGIN` and
+`CONTENT_PERMUTATION_SECRET` — the first is the CORS policy and the second
+protects the option permutation, and neither has a safe default.
+
+It is not correct for Google. It used to throw there too, which meant one
+missing secret 500'd the chapter list, guest sign-in and paper submission,
+each reporting `Google OAuth needs GOOGLE_CLIENT_ID...` — a baffling thing to
+read when you asked for a list of chapters. Now the misconfiguration is
+recorded and surfaces only on the three Google routes.
+
+`src/__tests__/config.test.ts` holds that line: what must still fail hard, and
+what must not.
+
+---
+
+## Secrets, local and deployed
+
+They are separate stores and neither can see the other.
+
+| | Local | Deployed |
+|---|---|---|
+| Where | `worker/.dev.vars` | Cloudflare |
+| Set by | editing the file | `wrangler secret put NAME --env production` |
+| Visible after | yes, it is a file you own | **no, never again** |
+
+`wrangler secret put` reads the value from your terminal and stores it on
+Cloudflare. It does not read `.dev.vars`, and `.dev.vars` is not uploaded.
+
+**A secret never belongs in a file in this repository.** `.gitignore` covers
+`.dev.vars`, `*secret*`, `*.pem` and `*.key` as a backstop, but the backstop
+is not the rule — the rule is that it goes from the console to
+`wrangler secret put` and nowhere else. If one does land in a file, or in a
+chat, or in a screenshot, it is burned: add a new secret in the console, set
+it, then **delete the old one**. Deleting the file changes nothing on its own.
+
+---
+
+## Resetting
+
+```bash
+cd worker
+rm -rf .wrangler .local     # both local databases
+npm run dev:setup           # rebuild from migrations + the question bank
+```
+
+Nothing in either database is authored by hand, so this is always safe.
diff --git a/docs/question-format.md b/docs/question-format.md
new file mode 100644
index 0000000..1ba13a8
--- /dev/null
+++ b/docs/question-format.md
@@ -0,0 +1,483 @@
+# The question bank format
+
+Every practice question in NECPrep comes from a JSON file in
+`frontend/public/data/books/`, one file per book chapter, `ch1.json` through
+`ch10.json`. The files are fetched at runtime by the browser — there is no
+build step that transforms them and no database behind them, so whatever is in
+these files is exactly what a student is shown.
+
+That is why this document is long. A wrong answer key here does not produce an
+error message; it silently teaches the wrong thing to someone sitting a
+licensing exam.
+
+Before you add or change anything in these files, read [The answer key](#the-answer-key)
+and [Answer position](#answer-position-bias). Those are the two places where the
+existing bank went wrong at scale.
+
+---
+
+## The shape
+
+Each file is a **JSON array of question objects**. No wrapper object, no
+metadata, no trailing commas.
+
+```json
+[
+  {
+    "qsns": "What is the time complexity of binary search on a sorted array?",
+    "opt1": "O(n)",
+    "opt2": "O(log n)",
+    "opt3": "O(n log n)",
+    "opt4": "O(1)",
+    "correct_option": "O(log n)",
+    "correct_option_index": 2
+  }
+]
+```
+
+### Fields
+
+| Field | Type | Required | Meaning |
+|---|---|---|---|
+| `qsns` | string | yes | The question stem, as shown to the student. Non-empty after trimming. |
+| `opt1` | string | yes | First answer option. Non-empty after trimming. |
+| `opt2` | string | yes | Second answer option. |
+| `opt3` | string | yes | Third answer option. |
+| `opt4` | string | yes | Fourth answer option. |
+| `correct_option` | string | yes | The **full text** of the correct option, character-for-character identical to the `optN` it refers to. |
+| `correct_option_index` | integer | yes | Which option is correct, **1-based**: `1` means `opt1`, `4` means `opt4`. |
+
+All seven fields must be present on every row. There are no optional fields and
+no extra fields are read — anything else you add is ignored by the app, so do not
+rely on it.
+
+### `correct_option_index` is 1-based
+
+This is the single most important sentence in this document, and the easiest
+thing to get wrong.
+
+```json
+{ "correct_option_index": 1 }   // opt1 is correct
+{ "correct_option_index": 2 }   // opt2 is correct
+{ "correct_option_index": 3 }   // opt3 is correct
+{ "correct_option_index": 4 }   // opt4 is correct
+{ "correct_option_index": 0 }   // INVALID — not a question, no answer
+{ "correct_option_index": 5 }   // INVALID — there is no opt5
+```
+
+The app converts it internally: `frontend/src/services/localData.ts` does
+`correctIndex = q.correct_option_index - 1` to get a 0-based array position. If
+you author 0-based indices, every question in your file will be marked one
+option too early and **the validator will not always catch it** — an off-by-one
+that happens to produce a self-consistent pair of `correct_option_index` and
+`correct_option` is indistinguishable from a deliberate answer. This is the one
+failure mode that only human review catches, which is why it is called out here
+rather than buried in the error table.
+
+### The two answer fields must agree
+
+`correct_option` and `correct_option_index` are redundant on purpose: each one
+checks the other. The app **trusts the index** and ignores `correct_option`
+entirely at runtime. `correct_option` exists so that a disagreement between the
+two is detectable, and the validator treats any disagreement as a build-breaking
+error.
+
+So: set the index to the slot you mean, and copy the option text into
+`correct_option` verbatim. Do not paraphrase it, do not strip punctuation, do
+not fix its capitalisation in one place and not the other.
+
+---
+
+## Validation
+
+```bash
+node scripts/validate-questions.mjs              # human-readable report
+node scripts/validate-questions.mjs --json       # full machine-readable output
+node scripts/validate-questions.mjs --csv t.csv  # triage spreadsheet
+node scripts/validate-questions.mjs --strict     # also fail on warnings
+```
+
+Exit codes: `0` clean, `1` errors found, `2` could not run (no data directory,
+no JSON files).
+
+This runs in CI as the **Question bank** job on every pull request and every push
+to `main`. It needs no `npm install`, so it reports in seconds. If it exits
+non-zero, the PR does not merge.
+
+**Errors block the build. Warnings do not**, unless you pass `--strict`. The
+split is not about severity of principle but about whether a machine can be
+certain: an error means the row is provably broken, a warning means it is
+probably worth a human look.
+
+---
+
+## Failure modes: errors
+
+Each of these makes a question either unanswerable or mis-graded. The worked
+examples are real rows from this bank, found the first time the validator was
+run against it.
+
+### `KEY_CONFLICT` — the two answer fields disagree
+
+`correct_option_index` points at one option and `correct_option` names different
+text.
+
+**Why it matters.** The app trusts the index. If the index is the wrong one, the
+student is told the right answer is wrong and the wrong answer is right. There is
+no way for them to tell; they will go and re-learn the material to fit the lie.
+
+**What was found.** 15 rows in this condition, and in all 15 the text named by
+`correct_option` was **not among the four options at all** — so the conflict
+could not be resolved by trusting either field. Every one had to be withheld and
+re-derived by hand. Examples:
+
+```jsonc
+// ch2.json — a binary conversion question
+{
+  "opt1": "110100", "opt2": "110010", "opt3": "110110", "opt4": "111000",
+  "correct_option": "110100",
+  "correct_option_index": 3        // index 3 is "110110", not "110100"
+}
+```
+
+```jsonc
+// ch1.json — a cutoff-frequency question
+{
+  "opt4": "1.59 kHz",
+  "correct_option": "1.59 Hz",     // kHz vs Hz: a factor of 1000
+  "correct_option_index": 4
+}
+```
+
+```jsonc
+// ch2.json — an 8-bit range question
+{
+  "opt2": "0 to 256",
+  "correct_option": "0 to 255",    // the correct answer, but it is not an option
+  "correct_option_index": 2
+}
+```
+
+That last one is the instructive case. `0 to 255` is the right answer to the
+question and `0 to 256` is wrong, so the defect is not in the key — it is in
+`opt2`. A conflict tells you something is wrong; it does not tell you which field
+is wrong. That takes subject knowledge, which is why these cannot be auto-fixed.
+
+**How to fix.** Work out the correct answer from the material. Then set `optN` to
+that text, set `correct_option_index` to `N`, and set `correct_option` to the
+same string.
+
+### `INDEX_RANGE` — the index points past the last option
+
+`correct_option_index` is less than 1 or greater than 4.
+
+**Why it matters.** There are only four options. An index of `5` resolves to
+`undefined`; the student cannot select the correct answer because it does not
+exist. Whatever they pick, they are marked wrong.
+
+**What was found.** 2 rows with `"correct_option_index": 5` and only four
+options. Almost certainly authored in a spreadsheet where a fifth column existed
+and was later dropped.
+
+```jsonc
+// ch2.json
+{
+  "opt1": "…", "opt2": "…", "opt3": "…", "opt4": "…",
+  "correct_option_index": 5        // unanswerable
+}
+```
+
+A `0` here is the same defect wearing a different hat: it is what you get from
+authoring 0-based indices, and it is the reason the validator rejects `0` rather
+than quietly accepting it as "opt1".
+
+### `OPTION_DUPLICATE` — two options have identical text
+
+Compared case-insensitively and after trimming whitespace.
+
+**Why it matters.** Two options that read the same are either both correct or
+both wrong. Only one is keyed, so a student who picks the other one is marked
+wrong for giving the identical answer. It is also a reliable sign that an option
+was meant to be different and got lost in copy-paste — so the question is
+usually missing a real distractor too.
+
+**What was found.** 7 rows. One had two separate collisions:
+
+```jsonc
+// ch3.json — array-of-structs declaration syntax
+{
+  "opt1": "struct *array_name[size];",
+  "opt2": "struct (*array_name)[size];",
+  "opt3": "struct *array_name[size];",    // same as opt1
+  "opt4": "struct (*array_name)[size];",  // same as opt2
+  "correct_option_index": 2
+}
+```
+
+Four options, two distinct answers. Whichever is keyed, half the students who
+know the answer are marked wrong.
+
+```jsonc
+// ch1.json — a resonant-frequency question
+{ "opt3": "159.15 Hz", "opt4": "159.15 Hz" }
+```
+
+**How to fix.** Replace the duplicate with a genuine distractor — a plausible
+wrong answer, ideally one that corresponds to a specific mistake a student might
+make (wrong unit, dropped factor of 2π, transposed digits).
+
+### `MISSING_FIELD`, `OPTION_TYPE`, `OPTION_EMPTY`, `STEM_EMPTY`, `INDEX_TYPE`
+
+Structural checks. A field is absent, an option is a number or `null` instead of
+a string, an option or the stem is blank, or `correct_option_index` is not an
+integer (a string `"2"` fails here, and so does `2.0` written as `2.5`).
+
+**Why they matter.** These are the defects that make the app render blank buttons
+or `undefined`. They are cheap to catch and have no legitimate exception.
+
+### `PARSE`, `SHAPE`
+
+The file is not valid JSON, or its top level is not an array.
+
+**Why they matter.** A single trailing comma takes a whole chapter offline for
+every user, and the app's loader catches the exception and returns an empty
+array — so the chapter silently shows zero questions rather than erroring
+visibly. This check is the only thing standing between a stray comma and a dead
+chapter.
+
+### `ANSWER_POSITION_BIAS` — the correct answer is still clustered after reordering
+
+See [Answer position](#answer-position-bias) below, which this check exists to
+enforce.
+
+---
+
+## Failure modes: warnings
+
+These do not block the build. They are judgement calls, or they describe a
+condition the app already compensates for.
+
+### `DUPLICATE_STEM` — the same question appears more than once
+
+Stems are compared after normalising: lowercased, runs of whitespace collapsed,
+and all punctuation except `?` removed. So `"What is an embedded system?"` and
+`"What is an Embedded System ?"` are the same stem.
+
+**Why it matters.** Duplicates distort everything built on top of the bank. A
+chapter's advertised question count is inflated. A "random 10 questions" quiz can
+serve the same question twice in one sitting. Accuracy statistics
+over-weight whatever the duplicated question happens to test. And a student
+revising feels they are making progress through new material when they are
+re-answering rows they have already seen.
+
+**What was found.** 558 redundant rows across 391 duplicate groups — and 192 of
+those groups spanned `ch1.json` and `ch2.json`, meaning a large block of
+questions had been pasted into both chapters. Deduplication is in progress; run
+the validator for the current figure.
+
+It is a warning rather than an error for one reason: the validator cannot know
+whether two identically-worded stems are a copy-paste accident or two legitimate
+variants with different options and different answers. A human has to look. The
+triage notes for this bank's groups are in
+`frontend/src/data/duplicate-triage.json`.
+
+**How to avoid it.** Before adding questions, search the existing bank for the
+stem. A duplicate that arrives in a PR is far cheaper to reject than one that has
+to be found later among thousands of rows.
+
+### `POSITIONAL_NOT_LAST` — "All of the above" is not in `opt4`
+
+Options matching `all|none|both (of) (the) above|these|mentioned`.
+
+**Why it matters.** These options only make sense in the final slot. "All of the
+above" sitting in `opt2` refers to one option. The app pins them last when it
+reorders (see below), so this is cosmetic in effect — but an option in the wrong
+slot usually means the row was assembled by hand and deserves a second look.
+
+### `KEY_MISSING_TEXT` — `correct_option` is empty
+
+Only the index identifies the answer, so the cross-check that would catch an
+off-by-one is gone. The row still works; it is just unguarded.
+
+### `STEM_TRUNCATED` — the stem ends in `...` or `…`
+
+**Why it matters.** The question is probably cut off mid-sentence, usually from a
+spreadsheet column that clipped. A student cannot answer `"…the capitalized
+value of the property is..."` because they were never told the rest.
+
+### `STEM_SHORT` — the stem is under 15 characters
+
+**Why it matters.** Stems like `"CPM is"` or `"A thread is:"` are fragments. They
+are answerable by someone who recognises the topic, but they test recall of a
+definition rather than understanding, and they are frequently the visible end of
+a truncated row.
+
+### `ANSWER_POSITION_SKEW_AS_AUTHORED`
+
+Reported per chapter when the authored distribution of correct positions is
+non-uniform at p < 0.001 (chi-square above 16.27 on 3 degrees of freedom, with at
+least 30 questions). It is a warning because the loader neutralises it — see
+below.
+
+---
+
+## Answer position bias
+
+This is the defect in the bank that mattered most and was hardest to see.
+
+### What was measured
+
+Across the whole bank, **option 2 was the correct answer in 32.0% of questions**,
+against the 25% a uniform distribution would give. Chi-square was **158.2 on 3
+degrees of freedom** — the p < 0.001 critical value is 16.27, so this is not
+close to chance.
+
+Per chapter it was far worse. In `ch9.json`, **option 2 was correct in 64.8% of
+questions**.
+
+### Why that is a serious defect, not a cosmetic one
+
+A student who notices the pattern — and students do notice patterns, that is
+most of what exam preparation trains — **could score about 65% on chapter 9 by
+blind-guessing "option 2" without reading a single question.**
+
+That breaks the app in both directions. The score is meaningless as a signal of
+readiness, so the student walks into the real exam believing they know chapter 9.
+And the practice itself becomes actively harmful: the most rewarded behaviour is
+pattern-matching on position, so that is the skill being trained instead of the
+engineering.
+
+The bias was invisible because options were never shuffled anywhere in the app.
+Each question presented in exactly the authored order, every time, for every
+user.
+
+### What the app does about it
+
+`orderOptions()` in `frontend/src/services/localData.ts` reorders every
+question's options before they are shown:
+
+- The permutation is a uniform **Fisher–Yates shuffle**, not a
+  `sort(() => Math.random() - 0.5)` comparator — that trick is not a uniform
+  shuffle and its output depends on the sort implementation.
+- It is **seeded from the question id** (FNV-1a hash into a mulberry32 PRNG), so
+  it is deterministic: a given question always presents in the same order. This
+  is required, not merely convenient — saved mock-test drafts and progress
+  records store the chosen option *index*, so a permutation that varied between
+  page loads would silently re-point every answer a student had already saved.
+  What is being removed is the systematic correlation *across* the bank, not
+  per-question unpredictability.
+- **"All of the above"-style options are pinned to the last slot** and excluded
+  from the shuffle. Moving one into the middle of the list makes the question
+  nonsense. There are 452 such options in the current bank and nearly all of them
+  were authored in slot 4.
+- If fewer than two options are free to move, the order is left alone.
+
+The same function is reimplemented inside `scripts/validate-questions.mjs` so the
+validator measures the distribution a student actually experiences. **The two
+implementations must stay in step** — if you change `orderOptions()`, change the
+copy in the validator in the same commit, or the gate starts measuring something
+that is not what ships.
+
+### What CI gates on
+
+The `ANSWER_POSITION_BIAS` **error** fires when, *after* reordering, any single
+slot holds the correct answer in **32% or more** of a chapter's questions, for
+chapters with at least 100 questions. Quarantined rows are excluded, since they
+never reach a student.
+
+The `ANSWER_POSITION_SKEW_AS_AUTHORED` **warning** reports the raw, pre-reordering
+skew.
+
+The gate is on the post-reordering number deliberately. Gating on the authored
+distribution would be permanently red and would demand re-authoring thousands of
+existing questions to fix something the loader already handles. Gating on what is
+shown catches the case that actually harms a student — including the case where
+new questions are so skewed that the shuffle cannot absorb them.
+
+### What authors must still do
+
+**Vary the position of the correct answer in what you author.** Do not rely on
+the loader.
+
+- The shuffle is seeded and therefore fixed. It breaks the bank-wide
+  correlation, but it is not a licence to put every answer in slot 2 and let the
+  code sort it out — feed it a 65% skew in a small chapter and the result can
+  still come out skewed, which is exactly what the CI error catches.
+- A chapter authored with every answer in one slot is a strong signal the
+  questions were generated rather than drawn from source material, and generated
+  questions in this bank have a markedly higher defect rate.
+- Options are reordered before display, so **never refer to an option by its
+  letter or number** in a stem, a distractor, or an explanation. "Both (a) and
+  (c)" is broken by the shuffle. Spell out the content instead.
+
+Aim for roughly a quarter of correct answers in each of the four slots across
+any batch you contribute.
+
+---
+
+## Quarantine
+
+Some rows in the bank are provably broken and have not yet been fixed. Rather
+than let the gate sit permanently red — where it would be useless for catching
+the *next* bad question — those rows are listed explicitly in
+`frontend/src/data/quarantine.json`:
+
+```json
+[
+  {
+    "id": "book-ch2_116",
+    "codes": ["INDEX_RANGE"],
+    "notes": ["correct_option_index is 5 but there are only 4 options - this question is unanswerable"]
+  }
+]
+```
+
+Two things follow from being on that list:
+
+1. **The loader filters the question out**, so it is never shown to a student.
+   See `quarantinedIds` in `frontend/src/data/quarantine.ts`.
+2. **The validator reports its findings separately** and does not count them as
+   build-breaking errors. A *newly introduced* bad question is not on the list,
+   so it still fails the build.
+
+The ids are the synthetic `{topicId}_{arrayIndex}` form — `book-ch2_116` is index
+116 of `ch2.json`. **These ids are tied to array position**, so reordering,
+inserting into, or deduplicating a chapter JSON invalidates the whole list and
+must be accompanied by regenerating it. This fragility is one of the reasons the
+bank is moving to content-hash ids.
+
+**Quarantine is a backlog, not a resting place.** To clear an entry: fix the row
+in `frontend/public/data/books/`, re-run the validator, confirm the row no longer
+produces a finding, and remove its id from `quarantine.json` in the same commit.
+Removing an id without fixing the row puts a broken question straight back in
+front of students, and the validator will fail the build for it — which is the
+intended behaviour.
+
+---
+
+## Adding a new chapter
+
+1. Add `chN.json` to `frontend/public/data/books/`, in the format above.
+2. Run `node scripts/sync-chapters.mjs` from the repo root. It regenerates
+   `frontend/src/data/bookChapters.generated.ts` with the chapter's title, colour,
+   icon and question count. **Commit the regenerated file** — CI fails if it is
+   stale, because the counts shown in the app would otherwise disagree with the
+   JSON on disk.
+3. Run `node scripts/validate-questions.mjs` and fix every error.
+4. Open a PR. Fill in the question-data section of the checklist.
+
+## Contributing a batch of questions
+
+The owner of this project supplies new question JSON in the shape above. Before
+it is merged:
+
+```bash
+# from the repo root
+node scripts/validate-questions.mjs                      # must exit 0
+node scripts/validate-questions.mjs --csv triage.csv     # spreadsheet of findings
+node scripts/validate-questions.mjs --json | less         # full detail
+```
+
+A batch is ready when the validator exits 0, the duplicate-stem warnings are
+either empty or individually justified, and the correct answer is spread across
+all four positions.
diff --git a/frontend/.env.example b/frontend/.env.example
index b0c422e..5be3482 100644
--- a/frontend/.env.example
+++ b/frontend/.env.example
@@ -1,3 +1,26 @@
-# Supabase Configuration
-VITE_SUPABASE_URL=your_supabase_project_url
-VITE_SUPABASE_ANON_KEY=your_supabase_anon_key
+# Copy to `.env.local` for local development. `.env.local` is gitignored.
+#
+# Supabase is gone: this platform runs on Cloudflare Workers + D1. The reasons
+# are in docs/adr/0001-cloudflare-d1-over-supabase.md, and the one that matters
+# here is that D1 has no row-level security, so there is no anon key to put in
+# a browser. The client talks to the Worker and the Worker is the only thing
+# that talks to the database.
+
+# Base URL of the NECPrep Worker API, with NO trailing slash.
+#
+# Leave it UNSET to run fully local: `services/api.ts` then short-circuits every
+# call with `BACKEND_NOT_CONFIGURED` and the app serves questions from
+# `public/data/*.json` with progress in localStorage. That is a supported mode,
+# not a broken one.
+#
+#   local Worker:  npm run dev  (in ../worker)  ->  http://127.0.0.1:8787
+#   deployed:      https://necprep-api.waglesameer5.workers.dev
+#
+# Vite inlines this at BUILD time, so changing it needs a rebuild, not a
+# restart of the server that serves the built files.
+VITE_API_BASE_URL=
+
+# NOTE: everything in a VITE_-prefixed variable is PUBLIC. It is compiled into
+# the JavaScript every visitor downloads. Never put a secret here. The session
+# is an HttpOnly cookie set by the Worker, so the browser never holds a
+# credential this file could leak.
diff --git a/frontend/index.html b/frontend/index.html
index 79570d5..86a4b10 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -1,16 +1,66 @@
 <!doctype html>
-<html lang="en">
+<!--
+  data-theme="dark" is a TEMPORARY PIN, not a design decision.
+
+  tokens.css defines a complete light palette on bare :root and a complete dark
+  palette under both prefers-color-scheme and [data-theme="dark"], so all three
+  theme states work. But App.css (6,175 lines, not yet migrated) hard-codes
+  dark-only values - rgba(255,255,255,.1) borders, rgba(10,10,15,.8) nav chrome,
+  white text inside gradients. Leaving the default to follow the OS would hand
+  every light-mode phone a half-light/half-dark broken UI on the next deploy.
+
+  Pinning dark here keeps today's rendering identical while the mechanism stays
+  fully live: a theme toggle just writes
+  document.documentElement.dataset.theme = "light" | "dark", or deletes the
+  attribute to follow the OS. Remove this attribute once App.css stops
+  hard-coding dark values.
+-->
+<html lang="en" data-theme="dark">
   <head>
-    <script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-4693315098720016"
-     crossorigin="anonymous"></script>
-<meta name="google-adsense-account" content="ca-pub-4693315098720016">
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>NEC License Exam</title>
+
+    <title>NECPrep — Nepal Engineering Council License Exam Preparation</title>
+    <meta name="description" content="Free, open-source practice platform for the Nepal Engineering Council (NEC) Computer Engineering licence exam. Chapter practice, timed mock tests, flashcards and progress tracking. Works offline, no account needed." />
+    <!-- Matches the PWA manifest theme_color and --color-neutral-950. A single
+         value while the app is pinned to dark (see the <html> comment above).
+         When the theme toggle ships, split this into the media-qualified pair:
+           theme-color #fafafa for (prefers-color-scheme: light)
+           theme-color #0b0b0f for (prefers-color-scheme: dark)  -->
+    <meta name="theme-color" content="#0b0b0f" />
+    <!-- Declared before any CSS loads so a 3G user never gets a white flash
+         while index.css is still in flight. -->
+    <meta name="color-scheme" content="dark" />
+
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <!-- iOS ignores SVG touch icons; it needs a raster one. -->
+    <link rel="apple-touch-icon" href="/icons/icon-192.png" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <meta name="apple-mobile-web-app-title" content="NECPrep" />
+
+    <!-- Inter is now self-hosted (src/styles/fonts.css), so the two Google Fonts
+         preconnects are gone: nothing resolves fonts.googleapis.com any more. -->
+
+    <meta property="og:type" content="website" />
+    <meta property="og:site_name" content="NECPrep" />
+    <meta property="og:title" content="NECPrep — NEC License Exam Preparation" />
+    <meta property="og:description" content="Free, open-source practice platform for the Nepal Engineering Council Computer Engineering licence exam." />
+    <meta property="og:url" content="https://lisensepreparation.samirwagle.com.np/" />
+    <meta name="twitter:card" content="summary" />
+
+    <meta name="google-adsense-account" content="ca-pub-4693315098720016" />
   </head>
   <body>
     <div id="root"></div>
     <script type="module" src="/src/main.tsx"></script>
+
+    <!-- Ads load last and async: this previously sat above <meta charset>, so a
+         third-party script blocked the charset declaration. -->
+    <script
+      async
+      src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-4693315098720016"
+      crossorigin="anonymous"
+    ></script>
   </body>
 </html>
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 171dc13..ed3c52c 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -8,18 +8,18 @@
       "name": "frontend",
       "version": "0.0.0",
       "dependencies": {
-        "@react-three/drei": "^10.7.7",
-        "@react-three/fiber": "^9.5.0",
-        "@types/three": "^0.182.0",
         "framer-motion": "^12.29.0",
         "lucide-react": "^0.563.0",
         "react": "^19.2.0",
         "react-dom": "^19.2.0",
-        "react-router-dom": "^7.13.0",
-        "three": "^0.182.0"
+        "react-router-dom": "^7.13.0"
       },
       "devDependencies": {
         "@eslint/js": "^9.39.1",
+        "@tailwindcss/vite": "^4.3.3",
+        "@testing-library/jest-dom": "^7.0.1",
+        "@testing-library/react": "^16.3.3",
+        "@testing-library/user-event": "^14.6.8",
         "@types/node": "^24.10.1",
         "@types/react": "^19.2.5",
         "@types/react-dom": "^19.2.3",
@@ -28,19 +28,83 @@
         "eslint-plugin-react-hooks": "^7.0.1",
         "eslint-plugin-react-refresh": "^0.4.24",
         "globals": "^16.5.0",
+        "jsdom": "^30.1.3",
+        "tailwindcss": "^4.3.3",
         "typescript": "~5.9.3",
         "typescript-eslint": "^8.46.4",
-        "vite": "^7.2.4"
+        "vite": "^7.2.4",
+        "vite-plugin-pwa": "^2.0.0",
+        "vitest": "^3.2.7"
+      }
+    },
+    "node_modules/@adobe/css-tools": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.5.0.tgz",
+      "integrity": "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "7.1.7",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-7.1.7.tgz",
+      "integrity": "sha512-Q7ioeear07HwixdIitIn9KS1LZi97CEDFCSjPNm9v+y8KNbsu9q4Lrd4zUQW4faED+E7qxvfeVnbNRW46wFKuw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/css-calc": "^3.4.3",
+        "@csstools/css-color-parser": "^4.2.6",
+        "@csstools/css-parser-algorithms": "^4.0.2",
+        "@csstools/css-tokenizer": "^4.0.2",
+        "lru-cache": "^11.5.3"
+      },
+      "engines": {
+        "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/css-color/node_modules/lru-cache": {
+      "version": "11.5.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.3.tgz",
+      "integrity": "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector": {
+      "version": "10.0.4",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-10.0.4.tgz",
+      "integrity": "sha512-A6f1nKy99I6tyoK82U6kBHvQQZmdHmTmPzJYPY/0eaOW0r8/qPmEOwjGHs+hL/vCgOwQTupu4LT1XtXNUuDruA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "bidi-js": "^1.1.0",
+        "css-tree": "^3.2.1",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.5.3"
+      },
+      "engines": {
+        "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector/node_modules/lru-cache": {
+      "version": "11.5.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.3.tgz",
+      "integrity": "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
       }
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.28.6.tgz",
-      "integrity": "sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/helper-validator-identifier": "^7.29.7",
         "js-tokens": "^4.0.0",
         "picocolors": "^1.1.1"
       },
@@ -49,9 +113,9 @@
       }
     },
     "node_modules/@babel/compat-data": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.6.tgz",
-      "integrity": "sha512-2lfu57JtzctfIrcGMz992hyLlByuzgIk58+hhGCxjKZ3rWI82NnVLjXcaTqkI2NvlcvOskZaiZ5kjUALo3Lpxg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
+      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -64,7 +128,6 @@
       "integrity": "sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.28.6",
         "@babel/generator": "^7.28.6",
@@ -91,14 +154,14 @@
       }
     },
     "node_modules/@babel/generator": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.6.tgz",
-      "integrity": "sha512-lOoVRwADj8hjf7al89tvQ2a1lf53Z+7tiXMgpZJL3maQPDxh0DgLMN62B2MKUOFcoodBHLMbDM6WAbKgNy5Suw==",
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz",
+      "integrity": "sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/parser": "^7.28.6",
-        "@babel/types": "^7.28.6",
+        "@babel/parser": "^7.29.8",
+        "@babel/types": "^7.29.8",
         "@jridgewell/gen-mapping": "^0.3.12",
         "@jridgewell/trace-mapping": "^0.3.28",
         "jsesc": "^3.0.2"
@@ -107,15 +170,28 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/helper-annotate-as-pure": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.29.7.tgz",
+      "integrity": "sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
-      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
+      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/compat-data": "^7.28.6",
-        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
         "browserslist": "^4.24.0",
         "lru-cache": "^5.1.1",
         "semver": "^6.3.1"
@@ -124,40 +200,111 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/helper-create-class-features-plugin": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.29.7.tgz",
+      "integrity": "sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-member-expression-to-functions": "^7.29.7",
+        "@babel/helper-optimise-call-expression": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-create-regexp-features-plugin": {
+      "version": "7.29.10",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.29.10.tgz",
+      "integrity": "sha512-/YY9soQuWa8TURtHXHT+GbklpbAA+dZErxFGHIr6qgDg96xuGWrTAs1+MfjgVJPF0YLQsOVsOYs8lhgsPbOinQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "regexpu-core": "^6.5.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-define-polyfill-provider": {
+      "version": "0.6.8",
+      "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz",
+      "integrity": "sha512-47UwBLPpQi1NoWzLuHNjRoHlYXMwIJoBf7MFou6viC/sIHWYygpvr0B6IAyh5sBdA2nr2LPIRww8lfaUVQINBA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "debug": "^4.4.3",
+        "lodash.debounce": "^4.0.8",
+        "resolve": "^1.22.11"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+      }
+    },
     "node_modules/@babel/helper-globals": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
-      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-member-expression-to-functions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.29.7.tgz",
+      "integrity": "sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-imports": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
-      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-transforms": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
-      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-imports": "^7.28.6",
-        "@babel/helper-validator-identifier": "^7.28.5",
-        "@babel/traverse": "^7.28.6"
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -166,20 +313,83 @@
         "@babel/core": "^7.0.0"
       }
     },
+    "node_modules/@babel/helper-optimise-call-expression": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.29.7.tgz",
+      "integrity": "sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/helper-plugin-utils": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
-      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz",
+      "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==",
       "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/helper-remap-async-to-generator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.29.7.tgz",
+      "integrity": "sha512-16AMiW26DbXWBbr3B8wNozKM0ydMLB892vaOaJW/fPJdnT8vJk5sdkQcU/isqUxyCE0cEoa8wZOcbgDuC4b6Og==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-wrap-function": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-replace-supers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.29.7.tgz",
+      "integrity": "sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-member-expression-to-functions": "^7.29.7",
+        "@babel/helper-optimise-call-expression": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-skip-transparent-expression-wrappers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.29.7.tgz",
+      "integrity": "sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/helper-string-parser": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
-      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -187,9 +397,9 @@
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
-      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -197,15 +407,30 @@
       }
     },
     "node_modules/@babel/helper-validator-option": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
-      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
       "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/helper-wrap-function": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.29.7.tgz",
+      "integrity": "sha512-iES0Skag9ERIF68aXadpO6dbXa03mNWK3sEqJaMnLNs/eC3l0lkImdfoy6Y09/SfkpawdAB4RjQ7PVA7TcVGdw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/helpers": {
       "version": "7.28.6",
       "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz",
@@ -221,13 +446,13 @@
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.6.tgz",
-      "integrity": "sha512-TeR9zWR18BvbfPmGbLampPMW+uW1NZnJlRuuHso8i87QZNq2JRF9i6RgxRqtEq+wQGsS19NNTWr2duhnE49mfQ==",
+      "version": "7.29.9",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.9.tgz",
+      "integrity": "sha512-CjXrNHTnvqBVqHgdBysY3vk2T8tpJHb5/RMeHJBTyVa9xgugCB0CJTx/3oO8RV2QRQP391RWpB7D6hLjm8V9uA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.28.6"
+        "@babel/types": "^7.29.8"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -236,1004 +461,1390 @@
         "node": ">=6.0.0"
       }
     },
-    "node_modules/@babel/plugin-transform-react-jsx-self": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
-      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+    "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.29.7.tgz",
+      "integrity": "sha512-j8SrR0zLZrRsC09DlszEx8FpMiwukKffYXMK0d5LmOglO7vGG6sz/BR/20yHqWH+Lnn31JTt2PE3hIWNgM2J6w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@babel/plugin-transform-react-jsx-source": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
-      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+    "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.29.7.tgz",
+      "integrity": "sha512-r8j8escF+U2FUHo0KOhPUdMzUO+jp9fInva6+ACVAF3Y97Ev+5iNZwiqTghmzNeWwDkOPlYuTcfb1vDaoZKmAQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@babel/runtime": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz",
-      "integrity": "sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==",
+    "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.29.7.tgz",
+      "integrity": "sha512-GE1TFSiuFeGsCxmYXZl8HwoPrVlwe4rHPFE8weieGKZqnDORK+Ar3vgWMgW+AOxQ6/2TgLSKx9p6W7O4rC6qgQ==",
+      "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
         "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@babel/template": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
-      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+    "node_modules/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array/-/plugin-bugfix-safari-rest-destructuring-rhs-array-7.29.7.tgz",
+      "integrity": "sha512-oBNVCvnO5tND+xSopWvV8WNGfpTfgP4Zr/YXXSj8zfmcPktp5Ku/aZlsIowgSD4fjmgHn6sGmB9APVsU5zOdhA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.28.6",
-        "@babel/parser": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@babel/traverse": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.6.tgz",
-      "integrity": "sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==",
+    "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.29.7.tgz",
+      "integrity": "sha512-QQt9qKHZ2sg/kivaLr7lnQr8HVrQDdBNSfCsTjiDxRuX/K5ORyKq+Bu8Xr0cDE3Dfkv0cw28Ve0EKyKMvulkOw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.28.6",
-        "@babel/generator": "^7.28.6",
-        "@babel/helper-globals": "^7.28.0",
-        "@babel/parser": "^7.28.6",
-        "@babel/template": "^7.28.6",
-        "@babel/types": "^7.28.6",
-        "debug": "^4.3.1"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7",
+        "@babel/plugin-transform-optional-chaining": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.13.0"
       }
     },
-    "node_modules/@babel/types": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.6.tgz",
-      "integrity": "sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg==",
+    "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.29.7.tgz",
+      "integrity": "sha512-pn6QacGLgvCcwc+syUhKE/qSjV2D1IHDB84RNxWYSt1mW3K/SCtjinZ2p0cETJxAWBjPy3K/1lHwG5BjjPxNlw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-string-parser": "^7.27.1",
-        "@babel/helper-validator-identifier": "^7.28.5"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@dimforge/rapier3d-compat": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/@dimforge/rapier3d-compat/-/rapier3d-compat-0.12.0.tgz",
-      "integrity": "sha512-uekIGetywIgopfD97oDL5PfeezkFpNhwlzlaEYNOA0N6ghdsOvh/HYjSMek5Q2O1PYvRSDFcqFVJl4r4ZBwOow==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz",
-      "integrity": "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==",
-      "cpu": [
-        "ppc64"
-      ],
+    "node_modules/@babel/plugin-proposal-private-property-in-object": {
+      "version": "7.21.0-placeholder-for-preset-env.2",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz",
+      "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.2.tgz",
-      "integrity": "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==",
-      "cpu": [
-        "arm"
-      ],
+    "node_modules/@babel/plugin-syntax-import-assertions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.29.7.tgz",
+      "integrity": "sha512-/An1OCBN93thpBAGyfsK2pcf0jvju1SAtKkL2Ny++B5Sy6sqgzXDQH1cZxWbF96Wuk+bn41MDA9bLd4VVAw6rw==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz",
-      "integrity": "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-syntax-import-attributes": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.29.7.tgz",
+      "integrity": "sha512-zGYcYfq/WmZ4V+kBIXQon9dSSc8ircGZqw9ZaNhhGj9nZkeBu1jHLBDQqYYi5WA9uawvA2sIMbry2nCFhf5Djg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.2.tgz",
-      "integrity": "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@babel/plugin-syntax-unicode-sets-regex": {
+      "version": "7.18.6",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz",
+      "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.18.6",
+        "@babel/helper-plugin-utils": "^7.18.6"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz",
-      "integrity": "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-transform-arrow-functions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.29.7.tgz",
+      "integrity": "sha512-N7zArUXWzAMzm+/N0uPBeVB3Fam5lMxtUwMmDK5f/IBBS7a7p1qeUoxd/6CckXoxUdgsntq1Dh8xNW06maZbDQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz",
-      "integrity": "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@babel/plugin-transform-async-generator-functions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.7.tgz",
+      "integrity": "sha512-d98gXZkgswvkyohMBABkhm3GeXhYj8psWfwQ2C7gtfrKGTykQa/iOIi+JJhwMjPlZ6Vm2XN+DCf3Es1EoG4ZLA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-remap-async-to-generator": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz",
-      "integrity": "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-transform-async-to-generator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.29.7.tgz",
+      "integrity": "sha512-pcUb2SS+RMo9TWVBwKGI5ShtoG7R+zBsFmCKDa6fe8c+hPr3XJlZgoE5j6i8W7gDjhyvy+85vmYexanvXh3d1w==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-remap-async-to-generator": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz",
-      "integrity": "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@babel/plugin-transform-block-scoped-functions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.29.7.tgz",
+      "integrity": "sha512-cUSmjh72N+rN4PrkFlN1dJwNCwjVp5d38/CQrEsFggkD10UiFlBFgdH3tv5dNsLuHY+3S8db2xCHjhZcv5WgvA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz",
-      "integrity": "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==",
-      "cpu": [
-        "arm"
-      ],
+    "node_modules/@babel/plugin-transform-block-scoping": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.29.7.tgz",
+      "integrity": "sha512-ONyr4+AZhKh8yKWInVxU9AXA9EbsyeLcL6V0dJy6M2/62vuvpGm29zzuymbTpdc451GEpDIdAyPLP3r+P61yKQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz",
-      "integrity": "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-transform-class-properties": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.29.7.tgz",
+      "integrity": "sha512-GtcpjFvanPfzNQi3eTitsCqtRRmmqzpy/A+yhTR1HaZo1Ly3EA8ZXxlPyHdR8/IuRMYc3E4wdGBewB2QKQjAaA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+      "dependencies": {
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz",
-      "integrity": "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==",
-      "cpu": [
-        "ia32"
-      ],
+    "node_modules/@babel/plugin-transform-class-static-block": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.29.7.tgz",
+      "integrity": "sha512-kibJgmEdX2iMwsHY2tSZNDgj8PwIlCQz7FK9KuGKO8zsuoUwSEhoNnNVp/emKWrbY4HeO6kkXfdMqRKKKXBm2A==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+      "dependencies": {
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.12.0"
       }
     },
-    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz",
-      "integrity": "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==",
-      "cpu": [
-        "loong64"
-      ],
+    "node_modules/@babel/plugin-transform-classes": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.29.7.tgz",
+      "integrity": "sha512-qV0OGGBVacduzQHE649JyCneOFI/maT+YKsO+K4Yi3xv2wTPNjM/W2o2gdzMwEAZz7fXNTHAe0NcSg30bIN69g==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz",
-      "integrity": "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==",
-      "cpu": [
-        "mips64el"
-      ],
+    "node_modules/@babel/plugin-transform-computed-properties": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.29.7.tgz",
+      "integrity": "sha512-RK7/IyU5phpuCdBAuig5VkzG/EnbDaui5SQGdU9BFrHdV+mV4cUjLMQ9lJDjLNtWHsqtiefpGZUXQP2BiTYMsA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/template": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz",
-      "integrity": "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==",
-      "cpu": [
-        "ppc64"
-      ],
+    "node_modules/@babel/plugin-transform-destructuring": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.29.7.tgz",
+      "integrity": "sha512-iPX8aD6H9zV5s7ZsqTdNocPN/MGQ5sSMnElKrktxjJRMnB2jN/1p2+R7GkfD6CAYoVFqy5A4XnSIUeGgJzIWpg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz",
-      "integrity": "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==",
-      "cpu": [
-        "riscv64"
-      ],
+    "node_modules/@babel/plugin-transform-dotall-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.29.7.tgz",
+      "integrity": "sha512-3qc18hsD2RdZiyJNDNc7HQpv6xbncwh8FYtxNFFzclSyh/trPD9KkVR9BDECUjDLvb7yJVF15GfYUuC+LMkkiQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz",
-      "integrity": "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==",
-      "cpu": [
-        "s390x"
-      ],
+    "node_modules/@babel/plugin-transform-duplicate-keys": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.29.7.tgz",
+      "integrity": "sha512-6IvRRriEMqnBwD6chtxdLpMYCHWEzN+oL5cyQtjykya19UgzbmKhxmhZgKC/LHxS2nYr9Q/qYPZ5Lr6jOL9+yQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz",
-      "integrity": "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.7.tgz",
+      "integrity": "sha512-2wiIyo2BjtgU7HufSeDnL9L2O7zr8jmhFKuSr65VpRkUiRKRNpb0mdlk56+XPPKoIrfHqzbMuglDvZun0RISsA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz",
-      "integrity": "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-transform-dynamic-import": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.29.7.tgz",
+      "integrity": "sha512-giOlEm/EFjfjr+te9NsdjkUo2v4f8rS/SXPumRVHAtbNcyNlvtREkU1dZzaIDclNpnaVhlCqRdFKhJBjBikzLg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz",
-      "integrity": "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@babel/plugin-transform-explicit-resource-management": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.29.7.tgz",
+      "integrity": "sha512-Rstj7coNz8sE+7Ju7ihpHLI564lsK5pUpNNlvptCIC/16E/S5hbl6n3kESPKdNRmqEWlpn5xpS5Q2dvXBsySLw==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/plugin-transform-destructuring": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz",
-      "integrity": "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-transform-exponentiation-operator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.29.7.tgz",
+      "integrity": "sha512-zFpMOTLZBdW5LfObqcSbL6kefg4R4eLdmvS0wbN9M6D5Mym/sKm9toOoWyVOa+xDjvCnuWcHls2YonXwHvH3CQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz",
-      "integrity": "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@babel/plugin-transform-export-namespace-from": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.29.7.tgz",
+      "integrity": "sha512-24B2nOy2TeJSMheqwPD4DDQOV/elLSIlKxjZt4i05H5AgdPdWR3n18HnNrcJ+j76WJd9gbwb9jPjNYUy6RautA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz",
-      "integrity": "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-transform-for-of": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.29.7.tgz",
+      "integrity": "sha512-zeSIHh0+E1Um1WJRXCFlHQYu2ieJNdivLLjlBEp+dIBu3S51n+SZZmIXjxnItw6pz56Cn+KvK68BIBVsxq2JiQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz",
-      "integrity": "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@babel/plugin-transform-function-name": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.29.7.tgz",
+      "integrity": "sha512-otRWaHXE6fbAGkePvaj/kvs3HsqXfPhlnzwSOlnFgbqCPMd975dW+4wZ00WFBt+/YlBGcJwNrARQTOJOb4ZrIg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
+      "dependencies": {
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz",
-      "integrity": "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-transform-json-strings": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.29.7.tgz",
+      "integrity": "sha512-RRnE2+eon1rJAq8MnoF1b5kTpY1vU88twHcvcKMrsqP/jxIRqDVs9iJB5fqPuqyeFAW0wJo4MlUIPpQCq/aRsg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz",
-      "integrity": "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==",
-      "cpu": [
-        "ia32"
-      ],
+    "node_modules/@babel/plugin-transform-literals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.29.7.tgz",
+      "integrity": "sha512-DZ/oLP21ZuWx1vKqnoNv6/tvEK48AQOBRai40CX9dTjGluvT/YZCyY3rryDtyUqCEoyNroy5KKPwX2iQCiRvyw==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz",
-      "integrity": "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@babel/plugin-transform-logical-assignment-operators": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.29.7.tgz",
+      "integrity": "sha512-A0H91hh6W8MFRkp5TqJmMr39jzGD1A1E1Ysiv2O06Sfbhkapm+XyIzxWCEh5kqwOZ1/8QZ0dY3SeQ7XBqfJd5Q==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.9.1",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
-      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+    "node_modules/@babel/plugin-transform-member-expression-literals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.29.7.tgz",
+      "integrity": "sha512-hl1kwFZCCiDyfH25Xmco9jTrkPgnS9pmOzSG7W5I4SaGbLeqKv417hcU2RKmaxoPEgsoJh7ZPOrnPGq99bHoUg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "eslint-visitor-keys": "^3.4.3"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
+        "node": ">=6.9.0"
       },
       "peerDependencies": {
-        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
-      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+    "node_modules/@babel/plugin-transform-modules-amd": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.29.7.tgz",
+      "integrity": "sha512-fxtQoH3m5ywUSIfaH0FGCzWu4McsYon5bD3K4XnskC7f+OyQMj7rsOMi4NvvmJ83WwBAg4UCe+ov4VZlqEvyew==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+        "node": ">=6.9.0"
       },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint-community/regexpp": {
-      "version": "4.12.2",
-      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
-      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+    "node_modules/@babel/plugin-transform-modules-commonjs": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.29.7.tgz",
+      "integrity": "sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint/config-array": {
-      "version": "0.21.1",
-      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz",
-      "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==",
+    "node_modules/@babel/plugin-transform-modules-systemjs": {
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.8.tgz",
+      "integrity": "sha512-6iSnEK0zlkLKU4heofK/AdmRD4e2SHVpJMtrwnTCzhnaM98ria4rTrOXBBi45BTTYnJtO8txnPsX4fChYXkmeA==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@eslint/object-schema": "^2.1.7",
-        "debug": "^4.3.1",
-        "minimatch": "^3.1.2"
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.8"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint/config-helpers": {
-      "version": "0.4.2",
-      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
-      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+    "node_modules/@babel/plugin-transform-modules-umd": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.29.7.tgz",
+      "integrity": "sha512-B4UkaTK3QpgCwJnrxKfMPKdo92CN7OKXAlpAAnM3UPu0Q0lCCk57ylA9AJbRy2v8dDKOPAAWcoR6CMyeoHwRCA==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@eslint/core": "^0.17.0"
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint/core": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
-      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+    "node_modules/@babel/plugin-transform-named-capturing-groups-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.7.tgz",
+      "integrity": "sha512-vuFoLwr4qnv2xbZ16SQd6uPcH5FNrLHhk/Jzo++0XJFcaDsr4gjJVg6j398oMHiC+83k/GiBzviwF5KBJkPUtQ==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@types/json-schema": "^7.0.15"
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@eslint/eslintrc": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.3.tgz",
-      "integrity": "sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==",
+    "node_modules/@babel/plugin-transform-new-target": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.29.7.tgz",
+      "integrity": "sha512-fEo41GmsOUhOBlw8ioo6zvjX5Xc2Lqkzlyfqbpsk3eB6TReV18uhxZ0esfEokVbY2+PVJAQHNKxER6lGrzNd3A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ajv": "^6.12.4",
-        "debug": "^4.3.2",
-        "espree": "^10.0.1",
-        "globals": "^14.0.0",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.2.1",
-        "js-yaml": "^4.1.1",
-        "minimatch": "^3.1.2",
-        "strip-json-comments": "^3.1.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=6.9.0"
       },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint/eslintrc/node_modules/globals": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
-      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+    "node_modules/@babel/plugin-transform-nullish-coalescing-operator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.29.7.tgz",
+      "integrity": "sha512-idmp1dFaekP9GbcMvG24Kvw2BfhFZjHnNJCkV4WuIY4PskJzwI3f1N5OdgYke38T7rftO6ERulFRn2cFeZwRkg==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=6.9.0"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint/js": {
-      "version": "9.39.2",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.2.tgz",
-      "integrity": "sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==",
+    "node_modules/@babel/plugin-transform-numeric-separator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.29.7.tgz",
+      "integrity": "sha512-zR7fv/z14OjgHl4AgRtkDBvBMhIzCxqV/qN/2BCRC7LjFwvuzjYe7gDWxC4Wl/SNsLM6SE1IWvRPYMgSJaUvNw==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=6.9.0"
       },
-      "funding": {
-        "url": "https://eslint.org/donate"
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint/object-schema": {
-      "version": "2.1.7",
-      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
-      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+    "node_modules/@babel/plugin-transform-object-rest-spread": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.29.7.tgz",
+      "integrity": "sha512-Ld98jn4c0smUywL57m7SgsHq3OpThOa6LqZJif3G6jYOovPleoFhVrBJ1WegRApSFB2wu4+RelAj9AC9G08Z4A==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/plugin-transform-destructuring": "^7.29.7",
+        "@babel/plugin-transform-parameters": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@eslint/plugin-kit": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
-      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+    "node_modules/@babel/plugin-transform-object-super": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.29.7.tgz",
+      "integrity": "sha512-Ea/diGcw0twB5IlZPO5sgET6fJsLJqPABqTuFWIR+iMPGPZJkATEIWx0wa+aEQ5UY1CBQyP/gkAiLEqn1vBiQA==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@eslint/core": "^0.17.0",
-        "levn": "^0.4.1"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@humanfs/core": {
-      "version": "0.19.1",
-      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
-      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+    "node_modules/@babel/plugin-transform-optional-catch-binding": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.29.7.tgz",
+      "integrity": "sha512-sLsyndxK2VwX6yNUOakMb7Sh553ZTe/vVM1XJ+9Z5aW1ytsc8xOIwmyk05NNjN60vkc5/KqoTH6hB4V41LJhng==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18.18.0"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@humanfs/node": {
-      "version": "0.16.7",
-      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
-      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+    "node_modules/@babel/plugin-transform-optional-chaining": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.29.7.tgz",
+      "integrity": "sha512-6GM1dhvK3gNODkXcEcMCOLEDCLSoZ/sBbro2Ax8HURyasQ4NshagQixkRFdh5niI6E4gmA/jYI/4aT7rRos3ZQ==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
       "dependencies": {
-        "@humanfs/core": "^0.19.1",
-        "@humanwhocodes/retry": "^0.4.0"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
       },
       "engines": {
-        "node": ">=18.18.0"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@humanwhocodes/module-importer": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
-      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+    "node_modules/@babel/plugin-transform-parameters": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.29.7.tgz",
+      "integrity": "sha512-ZDOBqV/qLYJI0YElr8DcENEyARsFQeESqWXH6gZlghYXuPPjvweuDhP4VyEi4BlUBlLRFZVjxoZDMjxhLW766g==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=12.22"
+        "node": ">=6.9.0"
       },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@humanwhocodes/retry": {
-      "version": "0.4.3",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
-      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+    "node_modules/@babel/plugin-transform-private-methods": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.29.7.tgz",
+      "integrity": "sha512-/6Rz4DK1ETDEM/bWHsPHcaEe7ZaT1EqSXjtSP/L0DijOYuaUhiRiOKcwpZ8P7zR4xXEHc2ITdiCgBm9Tpyv9ug==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
       "engines": {
-        "node": ">=18.18"
+        "node": ">=6.9.0"
       },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.13",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
-      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+    "node_modules/@babel/plugin-transform-private-property-in-object": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.29.7.tgz",
+      "integrity": "sha512-+BNo06dnrzdNNqCm1X6YUaVv0DKk8Q+JYcoZfOkLhYWNCXzlwTSRq8zGWayT1csjcpNXV9CQTBRRbmTLZac5cA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.0",
-        "@jridgewell/trace-mapping": "^0.3.24"
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@jridgewell/remapping": {
-      "version": "2.3.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
-      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+    "node_modules/@babel/plugin-transform-property-literals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.29.7.tgz",
+      "integrity": "sha512-bOMRLQuI0A5ZqHq3OWJ89/rXpJ/NJrbVhXiP4zwPGMs6kpcVsuTUNjwoE30K0Qm3mf48a/TnRYYD6vPNqcg6jA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
-      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
       "engines": {
-        "node": ">=6.0.0"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
-      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
     },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.31",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
-      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+    "node_modules/@babel/plugin-transform-regenerator": {
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.8.tgz",
+      "integrity": "sha512-0UpIXPtdDtMXfnV2OJAVMLpj3H/92vmkA6lpSRakmycJvj3VUy6Xs1dM8tXRugupykr5WB+LpiVl0J8LMVg2mg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jridgewell/resolve-uri": "^3.1.0",
-        "@jridgewell/sourcemap-codec": "^1.4.14"
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@mediapipe/tasks-vision": {
-      "version": "0.10.17",
-      "resolved": "https://registry.npmjs.org/@mediapipe/tasks-vision/-/tasks-vision-0.10.17.tgz",
-      "integrity": "sha512-CZWV/q6TTe8ta61cZXjfnnHsfWIdFhms03M9T7Cnd5y2mdpylJM0rF1qRq+wsQVRMLz1OYPVEBU9ph2Bx8cxrg==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/@monogrid/gainmap-js": {
-      "version": "3.4.0",
-      "resolved": "https://registry.npmjs.org/@monogrid/gainmap-js/-/gainmap-js-3.4.0.tgz",
-      "integrity": "sha512-2Z0FATFHaoYJ8b+Y4y4Hgfn3FRFwuU5zRrk+9dFWp4uGAdHGqVEdP7HP+gLA3X469KXHmfupJaUbKo1b/aDKIg==",
+    "node_modules/@babel/plugin-transform-regexp-modifiers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.29.7.tgz",
+      "integrity": "sha512-mB5Fs0VWrJ42ZCmc8114v60qetdaUVNkj9PmSZRmanCZM3S9hm0CFRLjRmYIsuXav14l2jvZ+4T8iiCGnhj3nQ==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "promise-worker-transferable": "^1.0.4"
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
       },
       "peerDependencies": {
-        "three": ">= 0.159.0"
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@react-three/drei": {
-      "version": "10.7.7",
-      "resolved": "https://registry.npmjs.org/@react-three/drei/-/drei-10.7.7.tgz",
-      "integrity": "sha512-ff+J5iloR0k4tC++QtD/j9u3w5fzfgFAWDtAGQah9pF2B1YgOq/5JxqY0/aVoQG5r3xSZz0cv5tk2YuBob4xEQ==",
+    "node_modules/@babel/plugin-transform-reserved-words": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.29.7.tgz",
+      "integrity": "sha512-5+YhdpVgmfSmwZyLMftfaiffLRMHjzIRHFHHLdibcSyJm2pasMrKHrO3Ptrt2DRshjvpgjEJJ1zVW14WPq/6QA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/runtime": "^7.26.0",
-        "@mediapipe/tasks-vision": "0.10.17",
-        "@monogrid/gainmap-js": "^3.0.6",
-        "@use-gesture/react": "^10.3.1",
-        "camera-controls": "^3.1.0",
-        "cross-env": "^7.0.3",
-        "detect-gpu": "^5.0.56",
-        "glsl-noise": "^0.0.0",
-        "hls.js": "^1.5.17",
-        "maath": "^0.10.8",
-        "meshline": "^3.3.1",
-        "stats-gl": "^2.2.8",
-        "stats.js": "^0.17.0",
-        "suspend-react": "^0.1.3",
-        "three-mesh-bvh": "^0.8.3",
-        "three-stdlib": "^2.35.6",
-        "troika-three-text": "^0.52.4",
-        "tunnel-rat": "^0.1.2",
-        "use-sync-external-store": "^1.4.0",
-        "utility-types": "^3.11.0",
-        "zustand": "^5.0.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
-      "peerDependencies": {
-        "@react-three/fiber": "^9.0.0",
-        "react": "^19",
-        "react-dom": "^19",
-        "three": ">=0.159"
+      "engines": {
+        "node": ">=6.9.0"
       },
-      "peerDependenciesMeta": {
-        "react-dom": {
-          "optional": true
-        }
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@react-three/fiber": {
-      "version": "9.5.0",
-      "resolved": "https://registry.npmjs.org/@react-three/fiber/-/fiber-9.5.0.tgz",
-      "integrity": "sha512-FiUzfYW4wB1+PpmsE47UM+mCads7j2+giRBltfwH7SNhah95rqJs3ltEs9V3pP8rYdS0QlNne+9Aj8dS/SiaIA==",
+    "node_modules/@babel/plugin-transform-shorthand-properties": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.29.7.tgz",
+      "integrity": "sha512-I+WYbGBAiCn7nA6xBrlgPH+MB7HWb4u8pv5S0Pv7OtwNvIFvCCb24YlttKEeUFVurfBCEaOTnuhlqsb7f0Z5Dg==",
+      "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@babel/runtime": "^7.17.8",
-        "@types/webxr": "*",
-        "base64-js": "^1.5.1",
-        "buffer": "^6.0.3",
-        "its-fine": "^2.0.0",
-        "react-use-measure": "^2.1.7",
-        "scheduler": "^0.27.0",
-        "suspend-react": "^0.1.3",
-        "use-sync-external-store": "^1.4.0",
-        "zustand": "^5.0.3"
-      },
-      "peerDependencies": {
-        "expo": ">=43.0",
-        "expo-asset": ">=8.4",
-        "expo-file-system": ">=11.0",
-        "expo-gl": ">=11.0",
-        "react": ">=19 <19.3",
-        "react-dom": ">=19 <19.3",
-        "react-native": ">=0.78",
-        "three": ">=0.156"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
-      "peerDependenciesMeta": {
-        "expo": {
-          "optional": true
-        },
-        "expo-asset": {
-          "optional": true
-        },
-        "expo-file-system": {
-          "optional": true
-        },
-        "expo-gl": {
-          "optional": true
-        },
-        "react-dom": {
-          "optional": true
-        },
-        "react-native": {
-          "optional": true
-        }
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
       }
     },
-    "node_modules/@rolldown/pluginutils": {
-      "version": "1.0.0-beta.53",
-      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.53.tgz",
-      "integrity": "sha512-vENRlFU4YbrwVqNDZ7fLvy+JR1CRkyr01jhSiDpE1u6py3OMzQfztQU2jxykW3ALNxO4kSlqIDeYyD0Y9RcQeQ==",
+    "node_modules/@babel/plugin-transform-spread": {
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.29.8.tgz",
+      "integrity": "sha512-4S9ksMGVWUshvgK0mKfvZky7leuG5/uoFVwMpAomJ8bMoDJiNHRVmc1EglwW/CmGVSqqWpEbXm9FmbRit22qoA==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
     },
-    "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz",
-      "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==",
-      "cpu": [
-        "arm"
-      ],
+    "node_modules/@babel/plugin-transform-sticky-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.29.7.tgz",
+      "integrity": "sha512-BCHzNYJGe9l7EpwwDBN/ztlL2NYFFq8hp9ddjtUEM9f2O7S7kKV/lL6Fwo7IF7NSkYhPK2vO+86nIGltA90MsA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
     },
-    "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz",
-      "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-transform-template-literals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.29.7.tgz",
+      "integrity": "sha512-NCSEJ4sLFU2gqAub45HYh4fus2yQ36rr6ei6vpU7NdoJqCpxvEG8E6eJpscGyXP3VHD2Ny+fSXr04k1hoUrFqA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
     },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz",
-      "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@babel/plugin-transform-typeof-symbol": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.29.7.tgz",
+      "integrity": "sha512-223mNGoTkBiTEWFoK+Q6Go3tueMRclO8vxxxxquNCYuNI4jWOofFKJRRDu6SDrB8Sgo1UEGW9T4GAQ8ZyRso1A==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz",
-      "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==",
-      "cpu": [
-        "x64"
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-unicode-escapes": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.29.7.tgz",
+      "integrity": "sha512-jCfXxSjf94lf4E0hKE0AByxF6F3/pVFqRdUUNkDJhsY0m1ZKjnN6ZYyMeHNpzflxb/0q5b7t3p+BE+SLF1WOtA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-unicode-property-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.29.7.tgz",
+      "integrity": "sha512-OgZ+zoAJgZLUCunsTRQ5LAjOywDv5zzZ2/hQ5aMw1pGXyY2rtE8/chXYUmu3AlVHKpm10KEdG9aMwbI/K76ZGw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-unicode-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.29.7.tgz",
+      "integrity": "sha512-7D/x/23/d/3VqZ0QA+LGbZMlGwZjztBygSWWWsfTPoQ1oQ6Q1P6Mr3d0kk42XabyUVw+fha3LqdRsFqeKqvCyA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-unicode-sets-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.29.7.tgz",
+      "integrity": "sha512-BLOhLht9DOJwIxlmp91wHvkXv1lguuHS3/FwUO8HL1H0u8s4hR1gASVFyilu9iGtcTRYqjTZmlsFFeQletntEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/preset-env": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.29.7.tgz",
+      "integrity": "sha512-GYzX36n1nsciIb0uyH0GHwxwtNwPQIcpxSeiVLDtG/B7jB5xXgchnmL1f/jCX5o+pwnaDBtO60ONSJhEBJfxYA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.29.7",
+        "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.29.7",
+        "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.29.7",
+        "@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": "^7.29.7",
+        "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.29.7",
+        "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.29.7",
+        "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2",
+        "@babel/plugin-syntax-import-assertions": "^7.29.7",
+        "@babel/plugin-syntax-import-attributes": "^7.29.7",
+        "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6",
+        "@babel/plugin-transform-arrow-functions": "^7.29.7",
+        "@babel/plugin-transform-async-generator-functions": "^7.29.7",
+        "@babel/plugin-transform-async-to-generator": "^7.29.7",
+        "@babel/plugin-transform-block-scoped-functions": "^7.29.7",
+        "@babel/plugin-transform-block-scoping": "^7.29.7",
+        "@babel/plugin-transform-class-properties": "^7.29.7",
+        "@babel/plugin-transform-class-static-block": "^7.29.7",
+        "@babel/plugin-transform-classes": "^7.29.7",
+        "@babel/plugin-transform-computed-properties": "^7.29.7",
+        "@babel/plugin-transform-destructuring": "^7.29.7",
+        "@babel/plugin-transform-dotall-regex": "^7.29.7",
+        "@babel/plugin-transform-duplicate-keys": "^7.29.7",
+        "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.29.7",
+        "@babel/plugin-transform-dynamic-import": "^7.29.7",
+        "@babel/plugin-transform-explicit-resource-management": "^7.29.7",
+        "@babel/plugin-transform-exponentiation-operator": "^7.29.7",
+        "@babel/plugin-transform-export-namespace-from": "^7.29.7",
+        "@babel/plugin-transform-for-of": "^7.29.7",
+        "@babel/plugin-transform-function-name": "^7.29.7",
+        "@babel/plugin-transform-json-strings": "^7.29.7",
+        "@babel/plugin-transform-literals": "^7.29.7",
+        "@babel/plugin-transform-logical-assignment-operators": "^7.29.7",
+        "@babel/plugin-transform-member-expression-literals": "^7.29.7",
+        "@babel/plugin-transform-modules-amd": "^7.29.7",
+        "@babel/plugin-transform-modules-commonjs": "^7.29.7",
+        "@babel/plugin-transform-modules-systemjs": "^7.29.7",
+        "@babel/plugin-transform-modules-umd": "^7.29.7",
+        "@babel/plugin-transform-named-capturing-groups-regex": "^7.29.7",
+        "@babel/plugin-transform-new-target": "^7.29.7",
+        "@babel/plugin-transform-nullish-coalescing-operator": "^7.29.7",
+        "@babel/plugin-transform-numeric-separator": "^7.29.7",
+        "@babel/plugin-transform-object-rest-spread": "^7.29.7",
+        "@babel/plugin-transform-object-super": "^7.29.7",
+        "@babel/plugin-transform-optional-catch-binding": "^7.29.7",
+        "@babel/plugin-transform-optional-chaining": "^7.29.7",
+        "@babel/plugin-transform-parameters": "^7.29.7",
+        "@babel/plugin-transform-private-methods": "^7.29.7",
+        "@babel/plugin-transform-private-property-in-object": "^7.29.7",
+        "@babel/plugin-transform-property-literals": "^7.29.7",
+        "@babel/plugin-transform-regenerator": "^7.29.7",
+        "@babel/plugin-transform-regexp-modifiers": "^7.29.7",
+        "@babel/plugin-transform-reserved-words": "^7.29.7",
+        "@babel/plugin-transform-shorthand-properties": "^7.29.7",
+        "@babel/plugin-transform-spread": "^7.29.7",
+        "@babel/plugin-transform-sticky-regex": "^7.29.7",
+        "@babel/plugin-transform-template-literals": "^7.29.7",
+        "@babel/plugin-transform-typeof-symbol": "^7.29.7",
+        "@babel/plugin-transform-unicode-escapes": "^7.29.7",
+        "@babel/plugin-transform-unicode-property-regex": "^7.29.7",
+        "@babel/plugin-transform-unicode-regex": "^7.29.7",
+        "@babel/plugin-transform-unicode-sets-regex": "^7.29.7",
+        "@babel/preset-modules": "0.1.6-no-external-plugins",
+        "babel-plugin-polyfill-corejs2": "^0.4.15",
+        "babel-plugin-polyfill-corejs3": "^0.14.0",
+        "babel-plugin-polyfill-regenerator": "^0.6.6",
+        "core-js-compat": "^3.48.0",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/preset-modules": {
+      "version": "0.1.6-no-external-plugins",
+      "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz",
+      "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.0.0",
+        "@babel/types": "^7.4.4",
+        "esutils": "^2.0.2"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0 || ^8.0.0-0 <8.0.0"
+      }
+    },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.10",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.10.tgz",
+      "integrity": "sha512-NpugTzbKgGrNe45Ui32cN8vCFFMxVtP/9rtfwv0nP5FRDAjvYBxJcLVpYA9mr1jxP6cnIT7x9LUzuDTbWYYNRA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.10",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.10.tgz",
+      "integrity": "sha512-B3lYAs2nkKskbgQ1nfy8Ma9ao9Q1rntTAQHrzzyDuj+TSO+X3le6PfWwqDvodsb+OumE10eMFfuMCTQSQ5iuIQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.8",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/parser": "^7.29.9",
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.8",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz",
+      "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@bramus/specificity": {
+      "version": "2.4.3",
+      "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.3.tgz",
+      "integrity": "sha512-0GEz8qJWokkUVYQYRukmkSHIFNoBH8QTreeHrAFbvz1XFYc3Y+puhMs8PQ5x8GNugiC2l5jvDBXKLbBIByeSBw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "css-tree": "^3.2.1"
+      },
+      "bin": {
+        "specificity": "bin/cli.js"
+      }
+    },
+    "node_modules/@csstools/color-helpers": {
+      "version": "6.1.2",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.1.2.tgz",
+      "integrity": "sha512-grhRy3OKmniaAEKXMjua5z/EODX0MSqBGjunw8+j/3HQjOnahs2AGhvEOIYVUWcU6ScApbhLhVrQTX8XqrMrow==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.4.3.tgz",
+      "integrity": "sha512-iex20d8CHVkyvg6B7UKV7uHnI2Bqo9g+EFfT9E0y+GvTvhZ/DwONJ+9aKb1dlqm0ZiGsL5RXjp0fCoJYnkeDjA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
       ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.2",
+        "@csstools/css-tokenizer": "^4.0.2"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "4.2.6",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.2.6.tgz",
+      "integrity": "sha512-iiPQ3iRWwnJkeEn6RIu6SJPr7hYrLz6XZ9s/QZl+2/LI5KQVjpl2fdmDSZKuD4xP6GMmMPgHFFXg6k1Wkz0Trg==",
       "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
+      "dependencies": {
+        "@csstools/color-helpers": "^6.1.2",
+        "@csstools/css-calc": "^3.4.3"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.2",
+        "@csstools/css-tokenizer": "^4.0.2"
+      }
     },
-    "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz",
-      "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==",
-      "cpu": [
-        "arm64"
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.2.tgz",
+      "integrity": "sha512-40cSKyMvK+tq4qz6Awrlye2WGuOKt3FwPgtGg6KTfbHOWNw+Rk1rzbAtZnZ6IBhsY491HLRnDXwoyBAijmmILA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^4.0.2"
+      }
+    },
+    "node_modules/@csstools/css-syntax-patches-for-csstree": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.15.tgz",
+      "integrity": "sha512-J0u7HkVl2nzSlhsiTOp4AmwcUQ3D+mGEEKfBy/7To5/y7F2OHwyLrXfrhR0SMgr4p5Lo+eaMVSeai24zUcBIxA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
       ],
+      "license": "MIT-0",
+      "peerDependencies": {
+        "css-tree": "^3.2.1"
+      },
+      "peerDependenciesMeta": {
+        "css-tree": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.2.tgz",
+      "integrity": "sha512-OoKoR0f76dCY666JlcbhmVTs2drYj1GUXZTYTcbUgJjh9Nv41aFfZ21bPQTERm5+L5cBDo466NltB2lplS5GBw==",
       "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
+      "engines": {
+        "node": ">=20.19.0"
+      }
     },
-    "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz",
-      "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==",
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz",
+      "integrity": "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==",
       "cpu": [
-        "x64"
+        "ppc64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "freebsd"
-      ]
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz",
-      "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==",
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.2.tgz",
+      "integrity": "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==",
       "cpu": [
         "arm"
       ],
@@ -1241,41 +1852,135 @@
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz",
-      "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==",
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz",
+      "integrity": "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==",
       "cpu": [
-        "arm"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz",
-      "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==",
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.2.tgz",
+      "integrity": "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz",
+      "integrity": "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz",
+      "integrity": "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz",
+      "integrity": "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz",
+      "integrity": "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz",
+      "integrity": "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": ">=18"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz",
-      "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==",
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz",
+      "integrity": "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==",
       "cpu": [
         "arm64"
       ],
@@ -1284,812 +1989,5313 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": ">=18"
+      }
     },
-    "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz",
-      "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==",
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz",
+      "integrity": "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz",
+      "integrity": "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==",
       "cpu": [
         "loong64"
       ],
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz",
+      "integrity": "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz",
+      "integrity": "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz",
+      "integrity": "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz",
+      "integrity": "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz",
+      "integrity": "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz",
+      "integrity": "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz",
+      "integrity": "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz",
+      "integrity": "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz",
+      "integrity": "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz",
+      "integrity": "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz",
+      "integrity": "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz",
+      "integrity": "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz",
+      "integrity": "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz",
+      "integrity": "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.21.1",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz",
+      "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.7",
+        "debug": "^4.3.1",
+        "minimatch": "^3.1.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
+      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
+      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.3.tgz",
+      "integrity": "sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.12.4",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.1",
+        "minimatch": "^3.1.2",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.39.2",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.2.tgz",
+      "integrity": "sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
+    "node_modules/@eslint/object-schema": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
+      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
+      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@exodus/bytes": {
+      "version": "1.16.0",
+      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.16.0.tgz",
+      "integrity": "sha512-IcpW84uEn3N7ETtNZMlxKhfl6Pec8rUNGOTBtWbK1FKhJxIFAptZyVrvVRVBimAJxJCgc3PxepxkdWWG4DVzfA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@noble/hashes": "^1.8.0 || ^2.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@noble/hashes": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.1",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
+      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.7",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
+      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.1",
+        "@humanwhocodes/retry": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@isaacs/cliui": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-9.0.0.tgz",
+      "integrity": "sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/source-map": {
+      "version": "0.3.11",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz",
+      "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.25"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.53",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.53.tgz",
+      "integrity": "sha512-vENRlFU4YbrwVqNDZ7fLvy+JR1CRkyr01jhSiDpE1u6py3OMzQfztQU2jxykW3ALNxO4kSlqIDeYyD0Y9RcQeQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/plugin-babel": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-6.1.0.tgz",
+      "integrity": "sha512-dFZNuFD2YRcoomP4oYf+DvQNSUA9ih+A3vUqopQx5EdtPGo3WBnQcI/S8pwpz91UsGfL0HsMSOlaMld8HrbubA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.18.6",
+        "@rollup/pluginutils": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0",
+        "@types/babel__core": "^7.1.9",
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/babel__core": {
+          "optional": true
+        },
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-node-resolve": {
+      "version": "16.0.3",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-16.0.3.tgz",
+      "integrity": "sha512-lUYM3UBGuM93CnMPG1YocWu7X802BrNF3jW2zny5gQyLQgRFJhV1Sq0Zi74+dh/6NBx1DxFC4b4GXg9wUCG5Qg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.0.1",
+        "@types/resolve": "1.20.2",
+        "deepmerge": "^4.2.2",
+        "is-module": "^1.0.0",
+        "resolve": "^1.22.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.78.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-replace": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-replace/-/plugin-replace-6.0.3.tgz",
+      "integrity": "sha512-J4RZarRvQAm5IF0/LwUUg+obsm+xZhYnbMXmXROyoSE1ATJe3oXSb9L5MMppdxP2ylNSjv6zFBwKYjcKMucVfA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.0.1",
+        "magic-string": "^0.30.3"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-terser": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-terser/-/plugin-terser-1.0.0.tgz",
+      "integrity": "sha512-FnCxhTBx6bMOYQrar6C8h3scPt8/JwIzw3+AJ2K++6guogH5fYaIFia+zZuhqv0eo1RN7W1Pz630SyvLbDjhtQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "serialize-javascript": "^7.0.3",
+        "smob": "^1.0.0",
+        "terser": "^5.17.4"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/pluginutils": {
+      "version": "5.4.0",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.4.0.tgz",
+      "integrity": "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/pluginutils/node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz",
+      "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz",
+      "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz",
+      "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz",
+      "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz",
+      "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz",
+      "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz",
+      "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz",
+      "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz",
+      "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz",
+      "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz",
+      "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz",
+      "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz",
+      "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz",
+      "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz",
+      "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz",
+      "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz",
+      "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz",
+      "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz",
+      "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz",
+      "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz",
+      "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz",
+      "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz",
+      "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@tailwindcss/node": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.3.3.tgz",
+      "integrity": "sha512-/T8IKEsf9VTU6tLjgC7+sv2mOPtQxzE2jMw7u4Tt40Tx+QSZxpzh95/H6cMKoja9XuW7iMdLJYBB0o9G1CaAgg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.5",
+        "enhanced-resolve": "^5.24.1",
+        "jiti": "^2.7.0",
+        "lightningcss": "1.32.0",
+        "magic-string": "^0.30.21",
+        "source-map-js": "^1.2.1",
+        "tailwindcss": "4.3.3"
+      }
+    },
+    "node_modules/@tailwindcss/oxide": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.3.3.tgz",
+      "integrity": "sha512-krXjAikiaFSPaK/FkAQT5UTx3VormQaiZ5hBFlJZ9UFQGB/rwg1MZIhHAG9smMQRTdyJxP6Qt5MwMtdyU5FWrA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      },
+      "optionalDependencies": {
+        "@tailwindcss/oxide-android-arm64": "4.3.3",
+        "@tailwindcss/oxide-darwin-arm64": "4.3.3",
+        "@tailwindcss/oxide-darwin-x64": "4.3.3",
+        "@tailwindcss/oxide-freebsd-x64": "4.3.3",
+        "@tailwindcss/oxide-linux-arm-gnueabihf": "4.3.3",
+        "@tailwindcss/oxide-linux-arm64-gnu": "4.3.3",
+        "@tailwindcss/oxide-linux-arm64-musl": "4.3.3",
+        "@tailwindcss/oxide-linux-x64-gnu": "4.3.3",
+        "@tailwindcss/oxide-linux-x64-musl": "4.3.3",
+        "@tailwindcss/oxide-wasm32-wasi": "4.3.3",
+        "@tailwindcss/oxide-win32-arm64-msvc": "4.3.3",
+        "@tailwindcss/oxide-win32-x64-msvc": "4.3.3"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-android-arm64": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.3.3.tgz",
+      "integrity": "sha512-Y85A2gmPSkl5Ve5qR86GL4HT509cFqQh1aes9p3sSkyTPwt0Pppf3GkwGe4JPACcRYjgJIEhQgM6dBClnr0NYw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-arm64": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.3.3.tgz",
+      "integrity": "sha512-BiaWatpBcERQFDlOjRDpIVXuFK5PJez5SA4JMg6VYZdBYU+qKfV/vqjcIs+IYmtitf1xYQZTwXvU/8y4lfZUGw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-x64": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.3.3.tgz",
+      "integrity": "sha512-fAeUqfV5ndhxRwai8cXGzdLvul9utWOmeTkv69unv4ZXixjn61Z+p9lCWdwOwA3TYboG3BwdVuN/RDjhBRl0mw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-freebsd-x64": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.3.3.tgz",
+      "integrity": "sha512-iyf5bV6+wnAlflVeEy7R25dupxTNECZN5QMI0qNT6eT+EgaGdZcKhGkr5SdoaWiLJ3spLqIY9VCeSGrwmtg4kw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.3.3.tgz",
+      "integrity": "sha512-aAYUprJAJQWWbRrPvtjdroZ56Md+JM8pMiopS6xGEwDfLhqj+2ver2p4nU4Mb3CRqcMmNBjo8KkUgcxhkzVQGQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-gnu": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.3.3.tgz",
+      "integrity": "sha512-nDxldcEENOxZRzC2uu9jrutZdAAQtb+8WWDCSnWL1zvBk1+FN+x6MtDViPB5AJMfttVCUhehGWus3XBPgatM/w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-musl": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.3.3.tgz",
+      "integrity": "sha512-Md44bD6veX/PC5iyF8cDVnw4HBIANZepRZZ7a8DQOvkfo5WUBwcp6iAuCUz23u+4SUkhJlD3eL7hNdW8ezd/kA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-gnu": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.3.3.tgz",
+      "integrity": "sha512-tx7us1muwOKAKWao2v/GaafFeQboE6aj88vC6ziN2NCGcRm8gWUhwjzg+YdVB1e4boAtdtma4L43onunI6NS4w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-musl": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.3.3.tgz",
+      "integrity": "sha512-SJxX60smvHgasZoBy11dX6YRjXJFovwWBoedhbQPOBzgFWBHGB+TVPWB9BxzR7TTxU8FQZAI2AyiNCMzFm8Img==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.3.3.tgz",
+      "integrity": "sha512-jx1+rPhY/5Ympkktd656HBWEBLxP7dH06losBLjjf5vgCODXvi9KhtftWcMIwTFIDqBr7cRnQkdLnAG+IOlGvQ==",
+      "bundleDependencies": [
+        "@napi-rs/wasm-runtime",
+        "@emnapi/core",
+        "@emnapi/runtime",
+        "@tybys/wasm-util",
+        "@emnapi/wasi-threads",
+        "tslib"
+      ],
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.11.1",
+        "@emnapi/runtime": "^1.11.1",
+        "@emnapi/wasi-threads": "^1.2.2",
+        "@napi-rs/wasm-runtime": "^1.1.4",
+        "@tybys/wasm-util": "^0.10.2",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-win32-arm64-msvc": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.3.3.tgz",
+      "integrity": "sha512-3rc292Ca2ceK6Ulcc/bAVnTs/3nDtoPhyEKlgPv+yQJQi/JS/AMJlqzxvlDacL1nekbrcf6bTqp/jV4qgnPxNQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-win32-x64-msvc": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.3.3.tgz",
+      "integrity": "sha512-yJ0pwIVc/nYeGoV02WtsN8KYyLQv7kyI2wDnkezyJlGGjkd4QLwDGAwl47YpPJeuI0M0ObaXGSPjvWDPeTPggw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/vite": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/vite/-/vite-4.3.3.tgz",
+      "integrity": "sha512-yYU8cogLeSh/ms2jh8Fj7jaba/EWa7Ja6GoUqYZaraEuCI5YS6ms6ObZgjjedm+jm6XZjdNRWBpPP6Z86oOxcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@tailwindcss/node": "4.3.3",
+        "@tailwindcss/oxide": "4.3.3",
+        "tailwindcss": "4.3.3"
+      },
+      "peerDependencies": {
+        "vite": "^5.2.0 || ^6 || ^7 || ^8"
+      }
+    },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.2",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.2.tgz",
+      "integrity": "sha512-yzr2S9HyAIdhz2/6qHgbs665Q7PKVcDF05vsOlHPxG1mo36gKVesdYVeDLnXgfjJ03CrKRk08knc6+E/9m8v2Q==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@testing-library/jest-dom": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-7.0.1.tgz",
+      "integrity": "sha512-oMDTC3oA+6CXSO2JZnvOI7CA6oVub6kij5ggk9ohwye5slmkwxYDXcPOVxgMw/RQlticjtO0C1RZkR97HgrWMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@adobe/css-tools": "^4.4.0",
+        "aria-query": "^5.0.0",
+        "css.escape": "^1.5.1",
+        "dom-accessibility-api": "^0.6.3",
+        "picocolors": "^1.1.1",
+        "redent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=22",
+        "npm": ">=6",
+        "yarn": ">=1"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": ">=10 <11",
+        "vitest": ">= 0.32"
+      },
+      "peerDependenciesMeta": {
+        "vitest": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz",
+      "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@testing-library/react": {
+      "version": "16.3.3",
+      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.3.tgz",
+      "integrity": "sha512-Uo193NgQbPMz6lrrhtRQQFcMC6Re/ELLFbbuVL30WDlZxlpZf9/lMHTAVxPRLw1q1iu9OJmR1c2BLiENRstdBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.12.5"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": "^10.0.0",
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^18.0.0 || ^19.0.0",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@testing-library/user-event": {
+      "version": "14.6.8",
+      "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.8.tgz",
+      "integrity": "sha512-vgSSqnANMnkcYR/vUNDbwS7aM3OErRLNUG8vCVVlj4oc6cKffUrccX7UAS5AmJQQNZTSibi9z5GvvRZ0aYgUCQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": ">=7.21.4"
+      }
+    },
+    "node_modules/@trickfilm400/rollup-plugin-off-main-thread": {
+      "version": "3.0.0-pre1",
+      "resolved": "https://registry.npmjs.org/@trickfilm400/rollup-plugin-off-main-thread/-/rollup-plugin-off-main-thread-3.0.0-pre1.tgz",
+      "integrity": "sha512-/67zpWDBLV+oYAEL682s1ktXL0HgqX76f6gaVGkGnVZlBbm1zd0v4Bz8MFF2GGhoX9rvfq3KSQHubFHwa6w6/Q==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "ejs": "^3.1.10",
+        "json5": "^2.2.3",
+        "magic-string": "^0.30.21",
+        "string.prototype.matchall": "^4.0.12"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "24.10.9",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.9.tgz",
+      "integrity": "sha512-ne4A0IpG3+2ETuREInjPNhUGis1SFjv1d5asp8MzEAGtOZeTeHVDOYqOgqfhvseqg/iXty2hjBf1zAOb7RNiNw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.16.0"
+      }
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.9",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.9.tgz",
+      "integrity": "sha512-Lpo8kgb/igvMIPeNV2rsYKTgaORYdO1XGVZ4Qz3akwOj0ySGYMPlQWa8BaLn0G63D1aSaAQ5ldR06wCpChQCjA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
+    "node_modules/@types/resolve": {
+      "version": "1.20.2",
+      "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz",
+      "integrity": "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/trusted-types": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+      "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@typescript-eslint/eslint-plugin": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.53.1.tgz",
+      "integrity": "sha512-cFYYFZ+oQFi6hUnBTbLRXfTJiaQtYE3t4O692agbBl+2Zy+eqSKWtPjhPXJu1G7j4RLjKgeJPDdq3EqOwmX5Ag==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/regexpp": "^4.12.2",
+        "@typescript-eslint/scope-manager": "8.53.1",
+        "@typescript-eslint/type-utils": "8.53.1",
+        "@typescript-eslint/utils": "8.53.1",
+        "@typescript-eslint/visitor-keys": "8.53.1",
+        "ignore": "^7.0.5",
+        "natural-compare": "^1.4.0",
+        "ts-api-utils": "^2.4.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/parser": "^8.53.1",
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/@typescript-eslint/parser": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.53.1.tgz",
+      "integrity": "sha512-nm3cvFN9SqZGXjmw5bZ6cGmvJSyJPn0wU9gHAZZHDnZl2wF9PhHv78Xf06E0MaNk4zLVHL8hb2/c32XvyJOLQg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/scope-manager": "8.53.1",
+        "@typescript-eslint/types": "8.53.1",
+        "@typescript-eslint/typescript-estree": "8.53.1",
+        "@typescript-eslint/visitor-keys": "8.53.1",
+        "debug": "^4.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/project-service": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.53.1.tgz",
+      "integrity": "sha512-WYC4FB5Ra0xidsmlPb+1SsnaSKPmS3gsjIARwbEkHkoWloQmuzcfypljaJcR78uyLA1h8sHdWWPHSLDI+MtNog==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/tsconfig-utils": "^8.53.1",
+        "@typescript-eslint/types": "^8.53.1",
+        "debug": "^4.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/scope-manager": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.53.1.tgz",
+      "integrity": "sha512-Lu23yw1uJMFY8cUeq7JlrizAgeQvWugNQzJp8C3x8Eo5Jw5Q2ykMdiiTB9vBVOOUBysMzmRRmUfwFrZuI2C4SQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.53.1",
+        "@typescript-eslint/visitor-keys": "8.53.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/tsconfig-utils": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.53.1.tgz",
+      "integrity": "sha512-qfvLXS6F6b1y43pnf0pPbXJ+YoXIC7HKg0UGZ27uMIemKMKA6XH2DTxsEDdpdN29D+vHV07x/pnlPNVLhdhWiA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/type-utils": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.53.1.tgz",
+      "integrity": "sha512-MOrdtNvyhy0rHyv0ENzub1d4wQYKb2NmIqG7qEqPWFW7Mpy2jzFC3pQ2yKDvirZB7jypm5uGjF2Qqs6OIqu47w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.53.1",
+        "@typescript-eslint/typescript-estree": "8.53.1",
+        "@typescript-eslint/utils": "8.53.1",
+        "debug": "^4.4.3",
+        "ts-api-utils": "^2.4.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/types": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.53.1.tgz",
+      "integrity": "sha512-jr/swrr2aRmUAUjW5/zQHbMaui//vQlsZcJKijZf3M26bnmLj8LyZUpj8/Rd6uzaek06OWsqdofN/Thenm5O8A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.53.1.tgz",
+      "integrity": "sha512-RGlVipGhQAG4GxV1s34O91cxQ/vWiHJTDHbXRr0li2q/BGg3RR/7NM8QDWgkEgrwQYCvmJV9ichIwyoKCQ+DTg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/project-service": "8.53.1",
+        "@typescript-eslint/tsconfig-utils": "8.53.1",
+        "@typescript-eslint/types": "8.53.1",
+        "@typescript-eslint/visitor-keys": "8.53.1",
+        "debug": "^4.4.3",
+        "minimatch": "^9.0.5",
+        "semver": "^7.7.3",
+        "tinyglobby": "^0.2.15",
+        "ts-api-utils": "^2.4.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
+      "version": "9.0.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@typescript-eslint/utils": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.53.1.tgz",
+      "integrity": "sha512-c4bMvGVWW4hv6JmDUEG7fSYlWOl3II2I4ylt0NM+seinYQlZMQIaKaXIIVJWt9Ofh6whrpM+EdDQXKXjNovvrg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.9.1",
+        "@typescript-eslint/scope-manager": "8.53.1",
+        "@typescript-eslint/types": "8.53.1",
+        "@typescript-eslint/typescript-estree": "8.53.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/visitor-keys": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.53.1.tgz",
+      "integrity": "sha512-oy+wV7xDKFPRyNggmXuZQSBzvoLnpmJs+GhzRhPjrxl2b/jIlyjVokzm47CZCDUdXKr2zd7ZLodPfOBpOPyPlg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.53.1",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.1.2.tgz",
+      "integrity": "sha512-EcA07pHJouywpzsoTUqNh5NwGayl2PPVEJKUSinGGSxFGYn+shYbqMGBg6FXDqgXum9Ou/ecb+411ssw8HImJQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.5",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.53",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.18.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.7.tgz",
+      "integrity": "sha512-E8eBXaKibuvH2pSZErOjdVb5vF4PbKYcrnluBTYxEk1l/VhhwZg1kZQsdtjq+CsF5CFydf2Rdkz7jDHKSisi3w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "3.2.7",
+        "@vitest/utils": "3.2.7",
+        "chai": "^5.2.0",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.7.tgz",
+      "integrity": "sha512-Trr0hYO9CM3Wj6ksWHRhK9IZpIY6wTMO5u/MqXurMxT57sWBaOPEtP3Oq60ihZuh5JsiagKfz95OcxdEP6dBrA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "3.2.7",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.17"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.7.tgz",
+      "integrity": "sha512-KUHlwqVu0sRlhCdyPdQ/wBoTfRahjUky1MubOmYw9fWfIZy1gNoHpuaaQBPAaMaVYdQYHJLurzj8ECCj5OwTqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.7.tgz",
+      "integrity": "sha512-sB9y4ovltoQP+WaUPwmSxO9WIg9Ig694Di5PalVPsYHklAdE027mehpWF2SQSVq+k6sFgaivbTjTJwZLSHbedA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "3.2.7",
+        "pathe": "^2.0.3",
+        "strip-literal": "^3.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.7.tgz",
+      "integrity": "sha512-7C+MwShwtBSI5Buwoyg3s/iY1eHL9PKAf+O1wVh/TdnjXUtkoL/9YQtre90i4MtNXM6edP1wJ2zOBpfCyhIS7g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "3.2.7",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.7.tgz",
+      "integrity": "sha512-Q2eQGI6d2L/hBtZ0qNuKcAGid68XK6cv1xsoaIma6PaJhHPoqcEJhYpXZ/5myCMqkNgtP6UKuBhbc0nHKnrkuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyspy": "^4.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.7.tgz",
+      "integrity": "sha512-x6BDOd7dyo3PFLY3I9/HJ25X/6OurhGXk2/B9gOZNPF7XDVjeBK4k01lQE5uvDpbuheErh91qYuE1E2OEjK3Rw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "3.2.7",
+        "loupe": "^3.1.4",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.15.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+      "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/aria-query": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "dequal": "^2.0.3"
+      }
+    },
+    "node_modules/array-buffer-byte-length": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz",
+      "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "is-array-buffer": "^3.0.5"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/arraybuffer.prototype.slice": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz",
+      "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "array-buffer-byte-length": "^1.0.1",
+        "call-bind": "^1.0.8",
+        "define-properties": "^1.2.1",
+        "es-abstract": "^1.23.5",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "is-array-buffer": "^3.0.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/async": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+      "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/async-function": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz",
+      "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/at-least-node": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
+      "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">= 4.0.0"
+      }
+    },
+    "node_modules/available-typed-arrays": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
+      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "possible-typed-array-names": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/babel-plugin-polyfill-corejs2": {
+      "version": "0.4.17",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz",
+      "integrity": "sha512-aTyf30K/rqAsNwN76zYrdtx8obu0E4KoUME29B1xj+B3WxgvWkp943vYQ+z8Mv3lw9xHXMHpvSPOBxzAkIa94w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-define-polyfill-provider": "^0.6.8",
+        "semver": "^6.3.1"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+      }
+    },
+    "node_modules/babel-plugin-polyfill-corejs3": {
+      "version": "0.14.2",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz",
+      "integrity": "sha512-coWpDLJ410R781Npmn/SIBZEsAetR4xVi0SxLMXPaMO4lSf1MwnkGYMtkFxew0Dn8B3/CpbpYxN0JCgg8mn67g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-define-polyfill-provider": "^0.6.8",
+        "core-js-compat": "^3.48.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+      }
+    },
+    "node_modules/babel-plugin-polyfill-regenerator": {
+      "version": "0.6.8",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz",
+      "integrity": "sha512-M762rNHfSF1EV3SLtnCJXFoQbbIIz0OyRwnCmV0KPC7qosSfCO0QLTSuJX3ayAebubhE6oYBAYPrBA5ljowaZg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-define-polyfill-provider": "^0.6.8"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.11.30",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.30.tgz",
+      "integrity": "sha512-YJs6Pz17RMNv8HoyKREtCY38E3BV1nPkWVmIb+XN1uHC1Vqt3KZCH/uJH9ZKRoiKb/icZ6tvehyee6RZNbFfRA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/bidi-js": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.1.0.tgz",
+      "integrity": "sha512-fX1Onk0tdVPC7obPWB5EbJ1z7NVhLq4m2xZLq2YXBkxzMXIGRpNMU88n0EPgWseKl12J7zXs7qrDxPK4sRs2fg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "require-from-string": "^2.0.2"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.29.4",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.4.tgz",
+      "integrity": "sha512-2TcbbiwXEq+N0kD36tykpCfyyQigUXmuwNQbnPp4Xk4PX9JOqVIKjJlIDjpH7uY6tmRGoAd+apeT1p60T8wsdA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.11.29",
+        "caniuse-lite": "^1.0.30001816",
+        "electron-to-chromium": "^1.5.459",
+        "node-releases": "^2.0.59",
+        "update-browserslist-db": "^1.3.4"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/call-bind": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.9.tgz",
+      "integrity": "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "get-intrinsic": "^1.3.0",
+        "set-function-length": "^1.2.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001817",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001817.tgz",
+      "integrity": "sha512-uZ1JG80BwhtMalIAGPxPfmNhHyd/B/nTdr3hITWlRamSyAdUStP1Gop01e7SD5q6J90ixJvWDbvmiFVfDgn4bw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/chai": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
+      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/check-error": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",
+      "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/common-tags": {
+      "version": "1.8.2",
+      "resolved": "https://registry.npmjs.org/common-tags/-/common-tags-1.8.2.tgz",
+      "integrity": "sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cookie": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz",
+      "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/core-js-compat": {
+      "version": "3.51.0",
+      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.51.0.tgz",
+      "integrity": "sha512-52r6fkXgxv4GLMjmFcMWRx7X9bw071xTTdrDcdyPGRqU2oE+9pCG0bAOMifSBdLw0JRBZKEF0q3B55qPlLuE8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.29.3"
+      },
+      "engines": {
+        "node": ">=6.4.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/core-js"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/crypto-random-string": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-2.0.0.tgz",
+      "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/css-tree": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+      "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.27.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+      }
+    },
+    "node_modules/css.escape": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz",
+      "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/data-urls": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-8.0.0.tgz",
+      "integrity": "sha512-JQUCCK+/CAGbGGx618PlFZMXH81Jtj7t73CHv9dd/zVWvxgGT2zLFRjnKb+Ng46GIwcy+f7f88qd4duqllK+WQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^17.1.2"
+      },
+      "engines": {
+        "node": "^22.14.0 || >=24.0.0"
+      }
+    },
+    "node_modules/data-view-buffer": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
+      "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "is-data-view": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/data-view-byte-length": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz",
+      "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "is-data-view": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/inspect-js"
+      }
+    },
+    "node_modules/data-view-byte-offset": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz",
+      "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "is-data-view": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/define-properties": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
+      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "define-data-property": "^1.0.1",
+        "has-property-descriptors": "^1.0.0",
+        "object-keys": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/dom-accessibility-api": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ejs": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
+      "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "jake": "^10.8.5"
+      },
+      "bin": {
+        "ejs": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.460",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.460.tgz",
+      "integrity": "sha512-rRaVC7bNUyGsL+GMtmZfv3AfgG6za7gE9v5bT0PIbjEerddA0IQ+tCK05NFAXqCpNlrxBZqbFqquyxHRQONHTA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/enhanced-resolve": {
+      "version": "5.26.0",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.26.0.tgz",
+      "integrity": "sha512-9vhedylFonb2YGogzUKX6+Ja72gOJbN1QHAqdrvqLwhdl/QWbKopzoUC9EbQNVsAns/bx/4uyqalrQAoy1IByw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.4",
+        "tapable": "^2.3.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/entities": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-8.1.0.tgz",
+      "integrity": "sha512-kxL7msIffSuh9aaFAMD7rxAIuTRMAHMeBtgHW2yUdWw732ZNh4MehkF2gdjvtdmikkaIP9bFDDJOPlsvm7avrA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/es-abstract": {
+      "version": "1.24.2",
+      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.2.tgz",
+      "integrity": "sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "array-buffer-byte-length": "^1.0.2",
+        "arraybuffer.prototype.slice": "^1.0.4",
+        "available-typed-arrays": "^1.0.7",
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.4",
+        "data-view-buffer": "^1.0.2",
+        "data-view-byte-length": "^1.0.2",
+        "data-view-byte-offset": "^1.0.1",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "es-set-tostringtag": "^2.1.0",
+        "es-to-primitive": "^1.3.0",
+        "function.prototype.name": "^1.1.8",
+        "get-intrinsic": "^1.3.0",
+        "get-proto": "^1.0.1",
+        "get-symbol-description": "^1.1.0",
+        "globalthis": "^1.0.4",
+        "gopd": "^1.2.0",
+        "has-property-descriptors": "^1.0.2",
+        "has-proto": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "internal-slot": "^1.1.0",
+        "is-array-buffer": "^3.0.5",
+        "is-callable": "^1.2.7",
+        "is-data-view": "^1.0.2",
+        "is-negative-zero": "^2.0.3",
+        "is-regex": "^1.2.1",
+        "is-set": "^2.0.3",
+        "is-shared-array-buffer": "^1.0.4",
+        "is-string": "^1.1.1",
+        "is-typed-array": "^1.1.15",
+        "is-weakref": "^1.1.1",
+        "math-intrinsics": "^1.1.0",
+        "object-inspect": "^1.13.4",
+        "object-keys": "^1.1.1",
+        "object.assign": "^4.1.7",
+        "own-keys": "^1.0.1",
+        "regexp.prototype.flags": "^1.5.4",
+        "safe-array-concat": "^1.1.3",
+        "safe-push-apply": "^1.0.0",
+        "safe-regex-test": "^1.1.0",
+        "set-proto": "^1.0.0",
+        "stop-iteration-iterator": "^1.1.0",
+        "string.prototype.trim": "^1.2.10",
+        "string.prototype.trimend": "^1.0.9",
+        "string.prototype.trimstart": "^1.0.8",
+        "typed-array-buffer": "^1.0.3",
+        "typed-array-byte-length": "^1.0.3",
+        "typed-array-byte-offset": "^1.0.4",
+        "typed-array-length": "^1.0.7",
+        "unbox-primitive": "^1.1.0",
+        "which-typed-array": "^1.1.19"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/es-abstract-get": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/es-abstract-get/-/es-abstract-get-1.0.0.tgz",
+      "integrity": "sha512-6PMWXpdhshVvFp+FoWYs1EvG1Nj0tvk0dZM+XcK0xMEM1czRVcP6ohqPWHy6qPagSpC8j4+p89WXlT+xXJs/fg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.2",
+        "is-callable": "^1.2.7",
+        "object-inspect": "^1.13.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-to-primitive": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.4.tgz",
+      "integrity": "sha512-yPDz7wqpg1/mmHLmS3tcfTfbw5f1eryXvyghYBffGdERwe+mV7ZcWzTR8LR17Kvqt3qfPurjlonmnq3MKXIOXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-abstract-get": "^1.0.0",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "is-callable": "^1.2.7",
+        "is-date-object": "^1.1.0",
+        "is-symbol": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.27.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.2.tgz",
+      "integrity": "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.27.2",
+        "@esbuild/android-arm": "0.27.2",
+        "@esbuild/android-arm64": "0.27.2",
+        "@esbuild/android-x64": "0.27.2",
+        "@esbuild/darwin-arm64": "0.27.2",
+        "@esbuild/darwin-x64": "0.27.2",
+        "@esbuild/freebsd-arm64": "0.27.2",
+        "@esbuild/freebsd-x64": "0.27.2",
+        "@esbuild/linux-arm": "0.27.2",
+        "@esbuild/linux-arm64": "0.27.2",
+        "@esbuild/linux-ia32": "0.27.2",
+        "@esbuild/linux-loong64": "0.27.2",
+        "@esbuild/linux-mips64el": "0.27.2",
+        "@esbuild/linux-ppc64": "0.27.2",
+        "@esbuild/linux-riscv64": "0.27.2",
+        "@esbuild/linux-s390x": "0.27.2",
+        "@esbuild/linux-x64": "0.27.2",
+        "@esbuild/netbsd-arm64": "0.27.2",
+        "@esbuild/netbsd-x64": "0.27.2",
+        "@esbuild/openbsd-arm64": "0.27.2",
+        "@esbuild/openbsd-x64": "0.27.2",
+        "@esbuild/openharmony-arm64": "0.27.2",
+        "@esbuild/sunos-x64": "0.27.2",
+        "@esbuild/win32-arm64": "0.27.2",
+        "@esbuild/win32-ia32": "0.27.2",
+        "@esbuild/win32-x64": "0.27.2"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "9.39.2",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.2.tgz",
+      "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.8.0",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.21.1",
+        "@eslint/config-helpers": "^0.4.2",
+        "@eslint/core": "^0.17.0",
+        "@eslint/eslintrc": "^3.3.1",
+        "@eslint/js": "9.39.2",
+        "@eslint/plugin-kit": "^0.4.1",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "ajv": "^6.12.4",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.4.0",
+        "eslint-visitor-keys": "^4.2.1",
+        "espree": "^10.4.0",
+        "esquery": "^1.5.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.2",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-plugin-react-hooks": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.0.1.tgz",
+      "integrity": "sha512-O0d0m04evaNzEPoSW+59Mezf8Qt0InfgGIBJnpC0h3NH/WjUAR7BIKUfysC6todmtiZ/A0oUVS8Gce0WhBrHsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.24.4",
+        "@babel/parser": "^7.24.4",
+        "hermes-parser": "^0.25.1",
+        "zod": "^3.25.0 || ^4.0.0",
+        "zod-validation-error": "^3.5.0 || ^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-react-refresh": {
+      "version": "0.4.26",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.26.tgz",
+      "integrity": "sha512-1RETEylht2O6FM/MvgnyvT+8K21wLqDNg4qD51Zj3guhjt433XbnnkVttHMyaVyAFD03QSV4LPS5iE3VQmO7XQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "eslint": ">=8.40"
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
+      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/espree": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
+      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/eta": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/eta/-/eta-4.6.0.tgz",
+      "integrity": "sha512-lW6is4T1NFOYnmqGZIfvixqj7A7sSvScF+DN8EK6K58xI5MZ5UvYe0GjopxOXQtZvUn4eDdVuZ8XSoYWTMEKwA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/bgub/eta?sponsor=1"
+      }
+    },
+    "node_modules/expect-type": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz",
+      "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-uri": {
+      "version": "3.1.9",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.9.tgz",
+      "integrity": "sha512-hS/0Wt3Ya043oKXs0sIxrMpKQITXhMLIrVAKKXi4gozGC9v7YRWVnXIZzjNPTO02M9BdxLCWqK1yRXgNziVyJQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/filelist": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz",
+      "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "minimatch": "^5.0.1"
+      }
+    },
+    "node_modules/filelist/node_modules/brace-expansion": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.7.tgz",
+      "integrity": "sha512-uZbew1NqdmPDTMJ8ah1y+b+9QEJrfkXFk3RcTQw3X0jW/xRUvFKsg1CfQdSYGdTbXZWExtU3J3ccxtnfw1Fi0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/filelist/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
+      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/for-each": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
+      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-callable": "^1.2.7"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/foreground-child": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "cross-spawn": "^7.0.6",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/framer-motion": {
+      "version": "12.29.0",
+      "resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-12.29.0.tgz",
+      "integrity": "sha512-1gEFGXHYV2BD42ZPTFmSU9buehppU+bCuOnHU0AD18DKh9j4DuTx47MvqY5ax+NNWRtK32qIcJf1UxKo1WwjWg==",
+      "license": "MIT",
+      "dependencies": {
+        "motion-dom": "^12.29.0",
+        "motion-utils": "^12.27.2",
+        "tslib": "^2.4.0"
+      },
+      "peerDependencies": {
+        "@emotion/is-prop-valid": "*",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@emotion/is-prop-valid": {
+          "optional": true
+        },
+        "react": {
+          "optional": true
+        },
+        "react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fs-extra": {
+      "version": "9.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+      "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "at-least-node": "^1.0.0",
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/function.prototype.name": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.2.0.tgz",
+      "integrity": "sha512-jObKIik1P2QjPHP5nz5BaOtUlfgS0fWo8IUByNXkM+o+02sJOi94em77GwJKQSJ3gfPHdgzLNrHc1uokV4P/ew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "functions-have-names": "^1.2.3",
+        "has-property-descriptors": "^1.0.2",
+        "hasown": "^2.0.4",
+        "is-callable": "^1.2.7",
+        "is-document.all": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/functions-have-names": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
+      "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/generator-function": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz",
+      "integrity": "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-own-enumerable-property-symbols": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz",
+      "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/get-symbol-description": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz",
+      "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/glob": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-11.1.0.tgz",
+      "integrity": "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "foreground-child": "^3.3.1",
+        "jackspeak": "^4.1.1",
+        "minimatch": "^10.1.1",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^2.0.0"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/glob/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/glob/node_modules/brace-expansion": {
+      "version": "5.0.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz",
+      "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "10.2.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz",
+      "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.8"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/globals": {
+      "version": "16.5.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz",
+      "integrity": "sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/globalthis": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
+      "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "define-properties": "^1.2.1",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/has-bigints": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
+      "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/has-property-descriptors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-define-property": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-proto": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz",
+      "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/hermes-estree": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz",
+      "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/hermes-parser": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz",
+      "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hermes-estree": "0.25.1"
+      }
+    },
+    "node_modules/html-encoding-sniffer": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-7.0.0.tgz",
+      "integrity": "sha512-UikN5yr7xsCDAq87Or5or0PAlD3HJJOKVzM05az588WnpDJ4Ux7a2A53Qi6gofGg2/EtvF/H4hCi/TXfCW4Y6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.15.1"
+      },
+      "engines": {
+        "node": "^22.13.0 || >=24.0.0"
+      }
+    },
+    "node_modules/idb": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/idb/-/idb-7.1.1.tgz",
+      "integrity": "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/indent-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
+      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/internal-slot": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
+      "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "hasown": "^2.0.2",
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/is-array-buffer": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
+      "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.3",
+        "get-intrinsic": "^1.2.6"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-async-function": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz",
+      "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "async-function": "^1.0.0",
+        "call-bound": "^1.0.3",
+        "get-proto": "^1.0.1",
+        "has-tostringtag": "^1.0.2",
+        "safe-regex-test": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-bigint": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz",
+      "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-bigints": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-boolean-object": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz",
+      "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-callable": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
+      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.17.0",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.17.0.tgz",
+      "integrity": "sha512-J/vG0zBCbIKOQFfufSwyXdMrsohyJIUNkrnmo6WZGzoM7tr/lsbfW5b2BvisL6zsyMzK9UxV9L6c7AoFbyXHOA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hasown": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-data-view": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz",
+      "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "get-intrinsic": "^1.2.6",
+        "is-typed-array": "^1.1.13"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-date-object": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz",
+      "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-document.all": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-document.all/-/is-document.all-1.0.0.tgz",
+      "integrity": "sha512-+XSoyS05OdBbhFuELhgTCpFNHkpBOJqtsZfUFFpe5QTw+9Sjbh8zitxhQkYAo6wV7e1Vb8cAPvpCk9jGam/82g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-finalizationregistry": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz",
+      "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-generator-function": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz",
+      "integrity": "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.4",
+        "generator-function": "^2.0.0",
+        "get-proto": "^1.0.1",
+        "has-tostringtag": "^1.0.2",
+        "safe-regex-test": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-map": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
+      "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-module": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz",
+      "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/is-negative-zero": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz",
+      "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-number-object": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz",
+      "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-obj": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz",
+      "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/is-regex": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
+      "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "gopd": "^1.2.0",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-regexp": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz",
+      "integrity": "sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-set": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz",
+      "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-shared-array-buffer": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz",
+      "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-string": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz",
+      "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-symbol": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz",
+      "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "has-symbols": "^1.1.0",
+        "safe-regex-test": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-typed-array": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
+      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "which-typed-array": "^1.1.16"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-weakmap": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
+      "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-weakref": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz",
+      "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-weakset": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz",
+      "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "get-intrinsic": "^1.2.6"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/isarray": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/jackspeak": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.2.3.tgz",
+      "integrity": "sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/cliui": "^9.0.0"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/jake": {
+      "version": "10.9.4",
+      "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz",
+      "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "async": "^3.2.6",
+        "filelist": "^1.0.4",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "jake": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/jiti": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz",
+      "integrity": "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jiti": "lib/jiti-cli.mjs"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/jsdom": {
+      "version": "30.1.3",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-30.1.3.tgz",
+      "integrity": "sha512-hQMUPvRgN7KxsfIytDQji7bimuJeRQa6Qo5+iuiZQk5CafeRxLIA10/cG5YCBFNpD9RO3oqIiN4CO1Y44kxqXg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^7.1.3",
+        "@asamuzakjp/dom-selector": "^10.0.3",
+        "@bramus/specificity": "^2.4.2",
+        "@csstools/css-syntax-patches-for-csstree": "^1.1.15",
+        "@exodus/bytes": "^1.16.0",
+        "css-tree": "^3.2.1",
+        "data-urls": "^8.0.0",
+        "decimal.js": "^10.6.0",
+        "html-encoding-sniffer": "^7.0.0",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.5.3",
+        "parse5": "^8.0.1",
+        "saxes": "^6.0.0",
+        "tough-cookie": "^6.0.2",
+        "undici": "^8.12.1",
+        "w3c-xmlserializer": "^6.0.0",
+        "webidl-conversions": "^8.0.1",
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^17.2.0",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+      },
+      "peerDependencies": {
+        "canvas": "^3.2.3"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jsdom/node_modules/lru-cache": {
+      "version": "11.5.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.3.tgz",
+      "integrity": "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
     },
-    "node_modules/@rollup/rollup-linux-loong64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz",
-      "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==",
-      "cpu": [
-        "loong64"
-      ],
+    "node_modules/jsonpointer": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz",
+      "integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": ">=0.10.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz",
-      "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==",
-      "cpu": [
-        "ppc64"
-      ],
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
     },
-    "node_modules/@rollup/rollup-linux-ppc64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz",
-      "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==",
-      "cpu": [
-        "ppc64"
-      ],
+    "node_modules/leven": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz",
+      "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": ">=6"
+      }
     },
-    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz",
-      "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==",
-      "cpu": [
-        "riscv64"
-      ],
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz",
-      "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==",
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
+      "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
       "cpu": [
-        "riscv64"
+        "arm64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "android"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz",
-      "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==",
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
+      "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
       "cpu": [
-        "s390x"
+        "arm64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz",
-      "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==",
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
+      "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz",
-      "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==",
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
+      "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/@rollup/rollup-openbsd-x64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz",
-      "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==",
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
+      "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
       "cpu": [
-        "x64"
+        "arm"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
-        "openbsd"
-      ]
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz",
-      "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==",
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
+      "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
-        "openharmony"
-      ]
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz",
-      "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==",
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
+      "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
-        "win32"
-      ]
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz",
-      "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==",
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
       "cpu": [
-        "ia32"
+        "x64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
-        "win32"
-      ]
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz",
-      "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==",
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
-        "win32"
-      ]
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz",
-      "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==",
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
+      "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
       "cpu": [
-        "x64"
+        "arm64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "optional": true,
       "os": [
         "win32"
-      ]
-    },
-    "node_modules/@tweenjs/tween.js": {
-      "version": "23.1.3",
-      "resolved": "https://registry.npmjs.org/@tweenjs/tween.js/-/tween.js-23.1.3.tgz",
-      "integrity": "sha512-vJmvvwFxYuGnF2axRtPYocag6Clbb5YS7kLL+SO/TeVFzHqDIWrNKYtcsPMibjDx9O+bu+psAy9NKfWklassUA==",
-      "license": "MIT"
-    },
-    "node_modules/@types/babel__core": {
-      "version": "7.20.5",
-      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
-      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.20.7",
-        "@babel/types": "^7.20.7",
-        "@types/babel__generator": "*",
-        "@types/babel__template": "*",
-        "@types/babel__traverse": "*"
-      }
-    },
-    "node_modules/@types/babel__generator": {
-      "version": "7.27.0",
-      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
-      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.0.0"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/@types/babel__template": {
-      "version": "7.4.4",
-      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
-      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.1.0",
-        "@babel/types": "^7.0.0"
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/@types/babel__traverse": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
-      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.28.2"
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@types/draco3d": {
-      "version": "1.4.10",
-      "resolved": "https://registry.npmjs.org/@types/draco3d/-/draco3d-1.4.10.tgz",
-      "integrity": "sha512-AX22jp8Y7wwaBgAixaSvkoG4M/+PlAcm3Qs4OW8yT9DM4xUpWKeFhLueTAyZF39pviAdcDdeJoACapiAceqNcw==",
-      "license": "MIT"
-    },
-    "node_modules/@types/estree": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
-      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+    "node_modules/lodash.debounce": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz",
+      "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/@types/json-schema": {
-      "version": "7.0.15",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
-      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/@types/node": {
-      "version": "24.10.9",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.9.tgz",
-      "integrity": "sha512-ne4A0IpG3+2ETuREInjPNhUGis1SFjv1d5asp8MzEAGtOZeTeHVDOYqOgqfhvseqg/iXty2hjBf1zAOb7RNiNw==",
+    "node_modules/loupe": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
+      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
       "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "undici-types": "~7.16.0"
-      }
-    },
-    "node_modules/@types/offscreencanvas": {
-      "version": "2019.7.3",
-      "resolved": "https://registry.npmjs.org/@types/offscreencanvas/-/offscreencanvas-2019.7.3.tgz",
-      "integrity": "sha512-ieXiYmgSRXUDeOntE1InxjWyvEelZGP63M+cGuquuRLuIKKT1osnkXjxev9B7d1nXSug5vpunx+gNlbVxMlC9A==",
       "license": "MIT"
     },
-    "node_modules/@types/react": {
-      "version": "19.2.9",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.9.tgz",
-      "integrity": "sha512-Lpo8kgb/igvMIPeNV2rsYKTgaORYdO1XGVZ4Qz3akwOj0ySGYMPlQWa8BaLn0G63D1aSaAQ5ldR06wCpChQCjA==",
-      "license": "MIT",
-      "peer": true,
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
       "dependencies": {
-        "csstype": "^3.2.2"
+        "yallist": "^3.0.2"
       }
     },
-    "node_modules/@types/react-dom": {
-      "version": "19.2.3",
-      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
-      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
-      "dev": true,
-      "license": "MIT",
+    "node_modules/lucide-react": {
+      "version": "0.563.0",
+      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.563.0.tgz",
+      "integrity": "sha512-8dXPB2GI4dI8jV4MgUDGBeLdGk8ekfqVZ0BdLcrRzocGgG75ltNEmWS+gE7uokKF/0oSUuczNDT+g9hFJ23FkA==",
+      "license": "ISC",
       "peerDependencies": {
-        "@types/react": "^19.2.0"
+        "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
-    "node_modules/@types/react-reconciler": {
-      "version": "0.28.9",
-      "resolved": "https://registry.npmjs.org/@types/react-reconciler/-/react-reconciler-0.28.9.tgz",
-      "integrity": "sha512-HHM3nxyUZ3zAylX8ZEyrDNd2XZOnQ0D5XfunJF5FLQnZbHHYq4UWvW1QfelQNXv1ICNkwYhfxjwfnqivYB6bFg==",
+    "node_modules/lz-string": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
+      "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "@types/react": "*"
+      "peer": true,
+      "bin": {
+        "lz-string": "bin/bin.js"
       }
     },
-    "node_modules/@types/stats.js": {
-      "version": "0.17.4",
-      "resolved": "https://registry.npmjs.org/@types/stats.js/-/stats.js-0.17.4.tgz",
-      "integrity": "sha512-jIBvWWShCvlBqBNIZt0KAshWpvSjhkwkEu4ZUcASoAvhmrgAUI2t1dXrjSL4xXVLB4FznPrIsX3nKXFl/Dt4vA==",
-      "license": "MIT"
-    },
-    "node_modules/@types/three": {
-      "version": "0.182.0",
-      "resolved": "https://registry.npmjs.org/@types/three/-/three-0.182.0.tgz",
-      "integrity": "sha512-WByN9V3Sbwbe2OkWuSGyoqQO8Du6yhYaXtXLoA5FkKTUJorZ+yOHBZ35zUUPQXlAKABZmbYp5oAqpA4RBjtJ/Q==",
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@dimforge/rapier3d-compat": "~0.12.0",
-        "@tweenjs/tween.js": "~23.1.3",
-        "@types/stats.js": "*",
-        "@types/webxr": ">=0.5.17",
-        "@webgpu/types": "*",
-        "fflate": "~0.8.2",
-        "meshoptimizer": "~0.22.0"
+        "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
-    "node_modules/@types/webxr": {
-      "version": "0.5.24",
-      "resolved": "https://registry.npmjs.org/@types/webxr/-/webxr-0.5.24.tgz",
-      "integrity": "sha512-h8fgEd/DpoS9CBrjEQXR+dIDraopAEfu4wYVNY2tEPwk60stPWhvZMf4Foo5FakuQ7HFZoa8WceaWFervK2Ovg==",
-      "license": "MIT"
-    },
-    "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.53.1.tgz",
-      "integrity": "sha512-cFYYFZ+oQFi6hUnBTbLRXfTJiaQtYE3t4O692agbBl+2Zy+eqSKWtPjhPXJu1G7j4RLjKgeJPDdq3EqOwmX5Ag==",
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@eslint-community/regexpp": "^4.12.2",
-        "@typescript-eslint/scope-manager": "8.53.1",
-        "@typescript-eslint/type-utils": "8.53.1",
-        "@typescript-eslint/utils": "8.53.1",
-        "@typescript-eslint/visitor-keys": "8.53.1",
-        "ignore": "^7.0.5",
-        "natural-compare": "^1.4.0",
-        "ts-api-utils": "^2.4.0"
-      },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "@typescript-eslint/parser": "^8.53.1",
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
-      "version": "7.0.5",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
-      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+    "node_modules/mdn-data": {
+      "version": "2.27.1",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+      "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
+    "node_modules/min-indent": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
+      "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">= 4"
+        "node": ">=4"
       }
     },
-    "node_modules/@typescript-eslint/parser": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.53.1.tgz",
-      "integrity": "sha512-nm3cvFN9SqZGXjmw5bZ6cGmvJSyJPn0wU9gHAZZHDnZl2wF9PhHv78Xf06E0MaNk4zLVHL8hb2/c32XvyJOLQg==",
+    "node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
       "dev": true,
-      "license": "MIT",
-      "peer": true,
+      "license": "ISC",
       "dependencies": {
-        "@typescript-eslint/scope-manager": "8.53.1",
-        "@typescript-eslint/types": "8.53.1",
-        "@typescript-eslint/typescript-estree": "8.53.1",
-        "@typescript-eslint/visitor-keys": "8.53.1",
-        "debug": "^4.4.3"
+        "brace-expansion": "^1.1.7"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "node": "*"
       }
     },
-    "node_modules/@typescript-eslint/project-service": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.53.1.tgz",
-      "integrity": "sha512-WYC4FB5Ra0xidsmlPb+1SsnaSKPmS3gsjIARwbEkHkoWloQmuzcfypljaJcR78uyLA1h8sHdWWPHSLDI+MtNog==",
+    "node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/tsconfig-utils": "^8.53.1",
-        "@typescript-eslint/types": "^8.53.1",
-        "debug": "^4.4.3"
-      },
+      "license": "BlueOak-1.0.0",
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+        "node": ">=16 || 14 >=14.17"
       }
     },
-    "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.53.1.tgz",
-      "integrity": "sha512-Lu23yw1uJMFY8cUeq7JlrizAgeQvWugNQzJp8C3x8Eo5Jw5Q2ykMdiiTB9vBVOOUBysMzmRRmUfwFrZuI2C4SQ==",
-      "dev": true,
+    "node_modules/motion-dom": {
+      "version": "12.29.0",
+      "resolved": "https://registry.npmjs.org/motion-dom/-/motion-dom-12.29.0.tgz",
+      "integrity": "sha512-3eiz9bb32yvY8Q6XNM4AwkSOBPgU//EIKTZwsSWgA9uzbPBhZJeScCVcBuwwYVqhfamewpv7ZNmVKTGp5qnzkA==",
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.53.1",
-        "@typescript-eslint/visitor-keys": "8.53.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "motion-utils": "^12.27.2"
       }
     },
-    "node_modules/@typescript-eslint/tsconfig-utils": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.53.1.tgz",
-      "integrity": "sha512-qfvLXS6F6b1y43pnf0pPbXJ+YoXIC7HKg0UGZ27uMIemKMKA6XH2DTxsEDdpdN29D+vHV07x/pnlPNVLhdhWiA==",
+    "node_modules/motion-utils": {
+      "version": "12.27.2",
+      "resolved": "https://registry.npmjs.org/motion-utils/-/motion-utils-12.27.2.tgz",
+      "integrity": "sha512-B55gcoL85Mcdt2IEStY5EEAsrMSVE2sI14xQ/uAdPL+mfQxhKKFaEag9JmfxedJOR4vZpBGoPeC/Gm13I/4g5Q==",
+      "license": "MIT"
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
-      }
+      "license": "MIT"
     },
-    "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.53.1.tgz",
-      "integrity": "sha512-MOrdtNvyhy0rHyv0ENzub1d4wQYKb2NmIqG7qEqPWFW7Mpy2jzFC3pQ2yKDvirZB7jypm5uGjF2Qqs6OIqu47w==",
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
       "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
       "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "8.53.1",
-        "@typescript-eslint/typescript-estree": "8.53.1",
-        "@typescript-eslint/utils": "8.53.1",
-        "debug": "^4.4.3",
-        "ts-api-utils": "^2.4.0"
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
-    "node_modules/@typescript-eslint/types": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.53.1.tgz",
-      "integrity": "sha512-jr/swrr2aRmUAUjW5/zQHbMaui//vQlsZcJKijZf3M26bnmLj8LyZUpj8/Rd6uzaek06OWsqdofN/Thenm5O8A==",
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.59",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.59.tgz",
+      "integrity": "sha512-5qr2okC4ItAI0hG5SaV0HoYMpnM/Y6+Oqr7AmPYy/2uEoGvS+GbSKLeRxSS1uAdu59yz0ouzcuXievSgg///WA==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "node": ">=18"
       }
     },
-    "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.53.1.tgz",
-      "integrity": "sha512-RGlVipGhQAG4GxV1s34O91cxQ/vWiHJTDHbXRr0li2q/BGg3RR/7NM8QDWgkEgrwQYCvmJV9ichIwyoKCQ+DTg==",
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/project-service": "8.53.1",
-        "@typescript-eslint/tsconfig-utils": "8.53.1",
-        "@typescript-eslint/types": "8.53.1",
-        "@typescript-eslint/visitor-keys": "8.53.1",
-        "debug": "^4.4.3",
-        "minimatch": "^9.0.5",
-        "semver": "^7.7.3",
-        "tinyglobby": "^0.2.15",
-        "ts-api-utils": "^2.4.0"
-      },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">= 0.4"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+    "node_modules/object-keys": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
+      "engines": {
+        "node": ">= 0.4"
       }
     },
-    "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
-      "version": "9.0.9",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
-      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+    "node_modules/object.assign": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
+      "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
       "dev": true,
-      "license": "ISC",
+      "license": "MIT",
       "dependencies": {
-        "brace-expansion": "^2.0.2"
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.3",
+        "define-properties": "^1.2.1",
+        "es-object-atoms": "^1.0.0",
+        "has-symbols": "^1.1.0",
+        "object-keys": "^1.1.1"
       },
       "engines": {
-        "node": ">=16 || 14 >=14.17"
+        "node": ">= 0.4"
       },
       "funding": {
-        "url": "https://github.com/sponsors/isaacs"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": {
-      "version": "7.7.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
-      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
       "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">= 0.8.0"
       }
     },
-    "node_modules/@typescript-eslint/utils": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.53.1.tgz",
-      "integrity": "sha512-c4bMvGVWW4hv6JmDUEG7fSYlWOl3II2I4ylt0NM+seinYQlZMQIaKaXIIVJWt9Ofh6whrpM+EdDQXKXjNovvrg==",
+    "node_modules/own-keys": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.2.tgz",
+      "integrity": "sha512-19YVAg7T+WTrxggPukVq7DjTv6+PJ867TmhCvBsYwmbFCsZd344rq2Ld1p0wo8f8Qrrhgp82c6FJRqdXWtSEhg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@eslint-community/eslint-utils": "^4.9.1",
-        "@typescript-eslint/scope-manager": "8.53.1",
-        "@typescript-eslint/types": "8.53.1",
-        "@typescript-eslint/typescript-estree": "8.53.1"
+        "call-bound": "^1.0.4",
+        "get-intrinsic": "^1.3.0",
+        "object-keys": "^1.1.1",
+        "safe-push-apply": "^1.0.0"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">= 0.4"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.53.1.tgz",
-      "integrity": "sha512-oy+wV7xDKFPRyNggmXuZQSBzvoLnpmJs+GhzRhPjrxl2b/jIlyjVokzm47CZCDUdXKr2zd7ZLodPfOBpOPyPlg==",
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.53.1",
-        "eslint-visitor-keys": "^4.2.1"
+        "yocto-queue": "^0.1.0"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=10"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@use-gesture/core": {
-      "version": "10.3.1",
-      "resolved": "https://registry.npmjs.org/@use-gesture/core/-/core-10.3.1.tgz",
-      "integrity": "sha512-WcINiDt8WjqBdUXye25anHiNxPc0VOrlT8F6LLkU6cycrOGUDyY/yyFmsg3k8i5OLvv25llc0QC45GhR/C8llw==",
-      "license": "MIT"
-    },
-    "node_modules/@use-gesture/react": {
-      "version": "10.3.1",
-      "resolved": "https://registry.npmjs.org/@use-gesture/react/-/react-10.3.1.tgz",
-      "integrity": "sha512-Yy19y6O2GJq8f7CHf7L0nxL8bf4PZCPaVOCgJrusOeFHY1LvHgYXnmnXg6N5iwAnbgbZCDjo60SiM6IPJi9C5g==",
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@use-gesture/core": "10.3.1"
+        "p-limit": "^3.0.2"
       },
-      "peerDependencies": {
-        "react": ">= 16.8.0"
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@vitejs/plugin-react": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.1.2.tgz",
-      "integrity": "sha512-EcA07pHJouywpzsoTUqNh5NwGayl2PPVEJKUSinGGSxFGYn+shYbqMGBg6FXDqgXum9Ou/ecb+411ssw8HImJQ==",
+    "node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0"
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/core": "^7.28.5",
-        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
-        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
-        "@rolldown/pluginutils": "1.0.0-beta.53",
-        "@types/babel__core": "^7.20.5",
-        "react-refresh": "^0.18.0"
+        "callsites": "^3.0.0"
       },
       "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      },
-      "peerDependencies": {
-        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+        "node": ">=6"
       }
     },
-    "node_modules/@webgpu/types": {
-      "version": "0.1.69",
-      "resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.69.tgz",
-      "integrity": "sha512-RPmm6kgRbI8e98zSD3RVACvnuktIja5+yLgDAkTmxLr90BEwdTXRQWNLF3ETTTyH/8mKhznZuN5AveXYFEsMGQ==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/acorn": {
-      "version": "8.15.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
-      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+    "node_modules/parse5": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
+      "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
-      "bin": {
-        "acorn": "bin/acorn"
+      "dependencies": {
+        "entities": "^8.0.0"
       },
-      "engines": {
-        "node": ">=0.4.0"
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
       }
     },
-    "node_modules/acorn-jsx": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
-      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
       "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/ajv": {
-      "version": "6.14.0",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
-      "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
       "dev": true,
-      "license": "MIT",
+      "license": "MIT"
+    },
+    "node_modules/path-scurry": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
+      "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
       "dependencies": {
-        "color-convert": "^2.0.1"
+        "lru-cache": "^11.0.0",
+        "minipass": "^7.1.2"
       },
       "engines": {
-        "node": ">=8"
+        "node": "18 || 20 || >=22"
       },
       "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+        "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/argparse": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+    "node_modules/path-scurry/node_modules/lru-cache": {
+      "version": "11.5.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.3.tgz",
+      "integrity": "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg==",
       "dev": true,
-      "license": "Python-2.0"
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
     },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/base64-js": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
-      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
-    "node_modules/baseline-browser-mapping": {
-      "version": "2.9.17",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.17.tgz",
-      "integrity": "sha512-agD0MgJFUP/4nvjqzIB29zRPUuCF7Ge6mEv9s8dHrtYD7QWXRcx75rOADE/d5ah1NI+0vkDl0yorDd5U852IQQ==",
+    "node_modules/pathval": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
       "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "baseline-browser-mapping": "dist/cli.js"
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.16"
       }
     },
-    "node_modules/bidi-js": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
-      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "require-from-string": "^2.0.2"
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
-    "node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+    "node_modules/possible-typed-array-names": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
+      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
+      "engines": {
+        "node": ">= 0.4"
       }
     },
-    "node_modules/browserslist": {
-      "version": "4.28.1",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
-      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+    "node_modules/postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
       "dev": true,
       "funding": [
         {
           "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
+          "url": "https://opencollective.com/postcss/"
         },
         {
           "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
+          "url": "https://tidelift.com/funding/github/npm/postcss"
         },
         {
           "type": "github",
@@ -2097,1162 +7303,1353 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "baseline-browser-mapping": "^2.9.0",
-        "caniuse-lite": "^1.0.30001759",
-        "electron-to-chromium": "^1.5.263",
-        "node-releases": "^2.0.27",
-        "update-browserslist-db": "^1.2.0"
-      },
-      "bin": {
-        "browserslist": "cli.js"
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
       },
       "engines": {
-        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
-      }
-    },
-    "node_modules/buffer": {
-      "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz",
-      "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "base64-js": "^1.3.1",
-        "ieee754": "^1.2.1"
+        "node": "^10 || ^12 || >=14"
       }
     },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=6"
+        "node": ">= 0.8.0"
       }
     },
-    "node_modules/camera-controls": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/camera-controls/-/camera-controls-3.1.2.tgz",
-      "integrity": "sha512-xkxfpG2ECZ6Ww5/9+kf4mfg1VEYAoe9aDSY+IwF0UEs7qEzwy0aVRfs2grImIECs/PoBtWFrh7RXsQkwG922JA==",
+    "node_modules/pretty-bytes": {
+      "version": "6.1.1",
+      "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-6.1.1.tgz",
+      "integrity": "sha512-mQUvGU6aUFQ+rNvTIAcZuWGRT9a6f6Yrg9bHs4ImKF+HZCEK+plBvnAZYSIQztknZF2qnzNtr6F8s0+IuptdlQ==",
+      "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=22.0.0",
-        "npm": ">=10.5.1"
+        "node": "^14.13.1 || >=16.0.0"
       },
-      "peerDependencies": {
-        "three": ">=0.126.1"
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/caniuse-lite": {
-      "version": "1.0.30001766",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001766.tgz",
-      "integrity": "sha512-4C0lfJ0/YPjJQHagaE9x2Elb69CIqEPZeG0anQt9SIvIoOH4a4uaRl73IavyO+0qZh6MDLH//DrXThEYKHkmYA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "CC-BY-4.0"
-    },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+    "node_modules/pretty-format": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
+        "ansi-regex": "^5.0.1",
+        "ansi-styles": "^5.0.0",
+        "react-is": "^17.0.1"
       },
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
+        "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
       }
     },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+    "node_modules/pretty-format/node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
+      "peer": true,
       "engines": {
-        "node": ">=7.0.0"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/convert-source-map": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
-      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
       "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/cookie": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz",
-      "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==",
       "license": "MIT",
       "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
+        "node": ">=6"
       }
     },
-    "node_modules/cross-env": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/cross-env/-/cross-env-7.0.3.tgz",
-      "integrity": "sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==",
+    "node_modules/react": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
+      "integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
       "license": "MIT",
-      "dependencies": {
-        "cross-spawn": "^7.0.1"
-      },
-      "bin": {
-        "cross-env": "src/bin/cross-env.js",
-        "cross-env-shell": "src/bin/cross-env-shell.js"
-      },
       "engines": {
-        "node": ">=10.14",
-        "npm": ">=6",
-        "yarn": ">=1"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/cross-spawn": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
-      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+    "node_modules/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-yELu4WmLPw5Mr/lmeEpox5rw3RETacE++JgHqQzd2dg+YbJuat3jH4ingc+WPZhxaoFzdv9y33G+F7Nl5O0GBg==",
       "license": "MIT",
       "dependencies": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
+        "scheduler": "^0.27.0"
       },
-      "engines": {
-        "node": ">= 8"
+      "peerDependencies": {
+        "react": "^19.2.3"
       }
     },
-    "node_modules/csstype": {
-      "version": "3.2.3",
-      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
-      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
-      "license": "MIT"
+    "node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
     },
-    "node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+    "node_modules/react-refresh": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz",
+      "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==",
       "dev": true,
       "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-router": {
+      "version": "7.13.0",
+      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.13.0.tgz",
+      "integrity": "sha512-PZgus8ETambRT17BUm/LL8lX3Of+oiLaPuVTRH3l1eLvSPpKO3AvhAEb5N7ihAFZQrYDqkvvWfFh9p0z9VsjLw==",
+      "license": "MIT",
       "dependencies": {
-        "ms": "^2.1.3"
+        "cookie": "^1.0.1",
+        "set-cookie-parser": "^2.6.0"
       },
       "engines": {
-        "node": ">=6.0"
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=18",
+        "react-dom": ">=18"
       },
       "peerDependenciesMeta": {
-        "supports-color": {
+        "react-dom": {
           "optional": true
         }
       }
     },
-    "node_modules/deep-is": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
-      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/detect-gpu": {
-      "version": "5.0.70",
-      "resolved": "https://registry.npmjs.org/detect-gpu/-/detect-gpu-5.0.70.tgz",
-      "integrity": "sha512-bqerEP1Ese6nt3rFkwPnGbsUF9a4q+gMmpTVVOEzoCyeCc+y7/RvJnQZJx1JwhgQI5Ntg0Kgat8Uu7XpBqnz1w==",
+    "node_modules/react-router-dom": {
+      "version": "7.13.0",
+      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.13.0.tgz",
+      "integrity": "sha512-5CO/l5Yahi2SKC6rGZ+HDEjpjkGaG/ncEP7eWFTvFxbHP8yeeI0PxTDjimtpXYlR3b3i9/WIL4VJttPrESIf2g==",
       "license": "MIT",
       "dependencies": {
-        "webgl-constants": "^1.1.1"
+        "react-router": "7.13.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=18",
+        "react-dom": ">=18"
       }
     },
-    "node_modules/draco3d": {
-      "version": "1.5.7",
-      "resolved": "https://registry.npmjs.org/draco3d/-/draco3d-1.5.7.tgz",
-      "integrity": "sha512-m6WCKt/erDXcw+70IJXnG7M3awwQPAsZvJGX5zY7beBqpELw6RDGkYVU0W43AFxye4pDZ5i2Lbyc/NNGqwjUVQ==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/electron-to-chromium": {
-      "version": "1.5.278",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.278.tgz",
-      "integrity": "sha512-dQ0tM1svDRQOwxnXxm+twlGTjr9Upvt8UFWAgmLsxEzFQxhbti4VwxmMjsDxVC51Zo84swW7FVCXEV+VAkhuPw==",
+    "node_modules/redent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
+      "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
       "dev": true,
-      "license": "ISC"
+      "license": "MIT",
+      "dependencies": {
+        "indent-string": "^4.0.0",
+        "strip-indent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
     },
-    "node_modules/esbuild": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.2.tgz",
-      "integrity": "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==",
+    "node_modules/reflect.getprototypeof": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
+      "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==",
       "dev": true,
-      "hasInstallScript": true,
       "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "define-properties": "^1.2.1",
+        "es-abstract": "^1.23.9",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.0.0",
+        "get-intrinsic": "^1.2.7",
+        "get-proto": "^1.0.1",
+        "which-builtin-type": "^1.2.1"
       },
       "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.27.2",
-        "@esbuild/android-arm": "0.27.2",
-        "@esbuild/android-arm64": "0.27.2",
-        "@esbuild/android-x64": "0.27.2",
-        "@esbuild/darwin-arm64": "0.27.2",
-        "@esbuild/darwin-x64": "0.27.2",
-        "@esbuild/freebsd-arm64": "0.27.2",
-        "@esbuild/freebsd-x64": "0.27.2",
-        "@esbuild/linux-arm": "0.27.2",
-        "@esbuild/linux-arm64": "0.27.2",
-        "@esbuild/linux-ia32": "0.27.2",
-        "@esbuild/linux-loong64": "0.27.2",
-        "@esbuild/linux-mips64el": "0.27.2",
-        "@esbuild/linux-ppc64": "0.27.2",
-        "@esbuild/linux-riscv64": "0.27.2",
-        "@esbuild/linux-s390x": "0.27.2",
-        "@esbuild/linux-x64": "0.27.2",
-        "@esbuild/netbsd-arm64": "0.27.2",
-        "@esbuild/netbsd-x64": "0.27.2",
-        "@esbuild/openbsd-arm64": "0.27.2",
-        "@esbuild/openbsd-x64": "0.27.2",
-        "@esbuild/openharmony-arm64": "0.27.2",
-        "@esbuild/sunos-x64": "0.27.2",
-        "@esbuild/win32-arm64": "0.27.2",
-        "@esbuild/win32-ia32": "0.27.2",
-        "@esbuild/win32-x64": "0.27.2"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/escalade": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
-      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+    "node_modules/regenerate": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.5.0.tgz",
+      "integrity": "sha512-1s+CxXjJ71i7LNVy8nYwg47XV4y6lAnOEhsMtSKq3WpmPfhl9LuKlTqKIn/3yUpE8lBz+W+TT88Bxyhnr0U4yw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/regenerate-unicode-properties": {
+      "version": "10.3.0",
+      "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.3.0.tgz",
+      "integrity": "sha512-9ns8odR8e9q3otKeHj3DE80jZYKg6zVeZKE+zQmRKXFoVUcuiTGeO6iusDhPRoIQQPVPRvH+SfBhrTud4eczuw==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "regenerate": "^1.4.2"
+      },
       "engines": {
-        "node": ">=6"
+        "node": ">=4"
       }
     },
-    "node_modules/escape-string-regexp": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+    "node_modules/regexp.prototype.flags": {
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
+      "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "define-properties": "^1.2.1",
+        "es-errors": "^1.3.0",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "set-function-name": "^2.0.2"
+      },
       "engines": {
-        "node": ">=10"
+        "node": ">= 0.4"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/eslint": {
-      "version": "9.39.2",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.2.tgz",
-      "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
+    "node_modules/regexpu-core": {
+      "version": "6.5.3",
+      "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.5.3.tgz",
+      "integrity": "sha512-E8VgUoSK+LMQrLboDxavm76MTBGrQhx9RiNuomRmYnZ10Uw12HrI8fkxOOncktb2hBpzIZ9SV/347euQHG5z+g==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@eslint-community/eslint-utils": "^4.8.0",
-        "@eslint-community/regexpp": "^4.12.1",
-        "@eslint/config-array": "^0.21.1",
-        "@eslint/config-helpers": "^0.4.2",
-        "@eslint/core": "^0.17.0",
-        "@eslint/eslintrc": "^3.3.1",
-        "@eslint/js": "9.39.2",
-        "@eslint/plugin-kit": "^0.4.1",
-        "@humanfs/node": "^0.16.6",
-        "@humanwhocodes/module-importer": "^1.0.1",
-        "@humanwhocodes/retry": "^0.4.2",
-        "@types/estree": "^1.0.6",
-        "ajv": "^6.12.4",
-        "chalk": "^4.0.0",
-        "cross-spawn": "^7.0.6",
-        "debug": "^4.3.2",
-        "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^8.4.0",
-        "eslint-visitor-keys": "^4.2.1",
-        "espree": "^10.4.0",
-        "esquery": "^1.5.0",
-        "esutils": "^2.0.2",
-        "fast-deep-equal": "^3.1.3",
-        "file-entry-cache": "^8.0.0",
-        "find-up": "^5.0.0",
-        "glob-parent": "^6.0.2",
-        "ignore": "^5.2.0",
-        "imurmurhash": "^0.1.4",
-        "is-glob": "^4.0.0",
-        "json-stable-stringify-without-jsonify": "^1.0.1",
-        "lodash.merge": "^4.6.2",
-        "minimatch": "^3.1.2",
-        "natural-compare": "^1.4.0",
-        "optionator": "^0.9.3"
-      },
-      "bin": {
-        "eslint": "bin/eslint.js"
+        "regenerate": "^1.5.0",
+        "regenerate-unicode-properties": "^10.3.0",
+        "regjsgen": "^0.8.0",
+        "regjsparser": "^0.13.0",
+        "unicode-match-property-ecmascript": "^2.0.0",
+        "unicode-match-property-value-ecmascript": "^2.2.1"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://eslint.org/donate"
-      },
-      "peerDependencies": {
-        "jiti": "*"
+        "node": ">=4"
+      }
+    },
+    "node_modules/regjsgen": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz",
+      "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/regjsparser": {
+      "version": "0.13.4",
+      "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.4.tgz",
+      "integrity": "sha512-EWV80YgFaVgFrjGCAsV7oybp4GOxbls5RzBg8OB0nKEVXsBJR1JlV8Di1JhCROg3MzTfe1RI8yitIm1eOs68iA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "jsesc": "~3.1.0"
       },
-      "peerDependenciesMeta": {
-        "jiti": {
-          "optional": true
-        }
+      "bin": {
+        "regjsparser": "bin/parser"
       }
     },
-    "node_modules/eslint-plugin-react-hooks": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.0.1.tgz",
-      "integrity": "sha512-O0d0m04evaNzEPoSW+59Mezf8Qt0InfgGIBJnpC0h3NH/WjUAR7BIKUfysC6todmtiZ/A0oUVS8Gce0WhBrHsA==",
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.13",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.13.tgz",
+      "integrity": "sha512-Dj/cW9zBV2aRj6XzCxuGIs3ESZKv02jixne3q6jFZYZ3/Tg09gHHviSMDL4kObh9pqSahdRHEnDoaP2gn8YLhA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/core": "^7.24.4",
-        "@babel/parser": "^7.24.4",
-        "hermes-parser": "^0.25.1",
-        "zod": "^3.25.0 || ^4.0.0",
-        "zod-validation-error": "^3.5.0 || ^4.0.0"
+        "es-errors": "^1.3.0",
+        "is-core-module": "^2.17.0",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
       },
       "engines": {
-        "node": ">=18"
+        "node": ">= 0.4"
       },
-      "peerDependencies": {
-        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0"
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/eslint-plugin-react-refresh": {
-      "version": "0.4.26",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.26.tgz",
-      "integrity": "sha512-1RETEylht2O6FM/MvgnyvT+8K21wLqDNg4qD51Zj3guhjt433XbnnkVttHMyaVyAFD03QSV4LPS5iE3VQmO7XQ==",
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
       "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "eslint": ">=8.40"
+      "engines": {
+        "node": ">=4"
       }
     },
-    "node_modules/eslint-scope": {
-      "version": "8.4.0",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
-      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+    "node_modules/rollup": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz",
+      "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "license": "MIT",
       "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^5.2.0"
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
       },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.59.0",
+        "@rollup/rollup-android-arm64": "4.59.0",
+        "@rollup/rollup-darwin-arm64": "4.59.0",
+        "@rollup/rollup-darwin-x64": "4.59.0",
+        "@rollup/rollup-freebsd-arm64": "4.59.0",
+        "@rollup/rollup-freebsd-x64": "4.59.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.59.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.59.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.59.0",
+        "@rollup/rollup-linux-arm64-musl": "4.59.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.59.0",
+        "@rollup/rollup-linux-loong64-musl": "4.59.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.59.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.59.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.59.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.59.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-musl": "4.59.0",
+        "@rollup/rollup-openbsd-x64": "4.59.0",
+        "@rollup/rollup-openharmony-arm64": "4.59.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.59.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.59.0",
+        "@rollup/rollup-win32-x64-gnu": "4.59.0",
+        "@rollup/rollup-win32-x64-msvc": "4.59.0",
+        "fsevents": "~2.3.2"
       }
     },
-    "node_modules/eslint-visitor-keys": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
-      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+    "node_modules/safe-array-concat": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.4.tgz",
+      "integrity": "sha512-wtZlHyOje6OZTGqAoaDKxFkgRtkF9CnHAVnCHKfuj200wAgL+bSJhdsCD2l0Qx/2ekEXjPWcyKkfGb5CPboslg==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "get-intrinsic": "^1.3.0",
+        "has-symbols": "^1.1.0",
+        "isarray": "^2.0.5"
+      },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=0.4"
       },
       "funding": {
-        "url": "https://opencollective.com/eslint"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/espree": {
-      "version": "10.4.0",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
-      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+    "node_modules/safe-push-apply": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
+      "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "license": "MIT",
       "dependencies": {
-        "acorn": "^8.15.0",
-        "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^4.2.1"
+        "es-errors": "^1.3.0",
+        "isarray": "^2.0.5"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">= 0.4"
       },
       "funding": {
-        "url": "https://opencollective.com/eslint"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/esquery": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
-      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
+    "node_modules/safe-regex-test": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz",
+      "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==",
       "dev": true,
-      "license": "BSD-3-Clause",
+      "license": "MIT",
       "dependencies": {
-        "estraverse": "^5.1.0"
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "is-regex": "^1.2.1"
       },
       "engines": {
-        "node": ">=0.10"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/esrecurse": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
-      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "license": "ISC",
       "dependencies": {
-        "estraverse": "^5.2.0"
+        "xmlchars": "^2.2.0"
       },
       "engines": {
-        "node": ">=4.0"
+        "node": ">=v12.22.7"
       }
     },
-    "node_modules/estraverse": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
-      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/serialize-javascript": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-7.1.2.tgz",
+      "integrity": "sha512-GL2BWwVa6JydKO6l/ljVgjAZF4QJ3S7dWDWi53s5GZT8PJzD2fNxi67HANQGKAqPrwEpL5ba7gUBGi0Ls/sEoQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
       "engines": {
-        "node": ">=4.0"
+        "node": ">=20.0.0"
       }
     },
-    "node_modules/esutils": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
-      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+    "node_modules/set-cookie-parser": {
+      "version": "2.7.2",
+      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz",
+      "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==",
+      "license": "MIT"
+    },
+    "node_modules/set-function-length": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "license": "MIT",
+      "dependencies": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "gopd": "^1.0.1",
+        "has-property-descriptors": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/set-function-name": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz",
+      "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "functions-have-names": "^1.2.3",
+        "has-property-descriptors": "^1.0.2"
+      },
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+    "node_modules/set-proto": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz",
+      "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
     },
-    "node_modules/fast-json-stable-stringify": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
-      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
     },
-    "node_modules/fast-levenshtein": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
-      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
     },
-    "node_modules/fdir": {
-      "version": "6.5.0",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
-      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+    "node_modules/side-channel": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=12.0.0"
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
       },
-      "peerDependencies": {
-        "picomatch": "^3 || ^4"
+      "engines": {
+        "node": ">= 0.4"
       },
-      "peerDependenciesMeta": {
-        "picomatch": {
-          "optional": true
-        }
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/fflate": {
-      "version": "0.8.2",
-      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.2.tgz",
-      "integrity": "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==",
-      "license": "MIT"
-    },
-    "node_modules/file-entry-cache": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
-      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+    "node_modules/side-channel-list": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "flat-cache": "^4.0.0"
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4"
       },
       "engines": {
-        "node": ">=16.0.0"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">= 0.4"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/flat-cache": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
-      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "flatted": "^3.2.9",
-        "keyv": "^4.5.4"
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
       },
       "engines": {
-        "node": ">=16"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/flatted": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
-      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/framer-motion": {
-      "version": "12.29.0",
-      "resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-12.29.0.tgz",
-      "integrity": "sha512-1gEFGXHYV2BD42ZPTFmSU9buehppU+bCuOnHU0AD18DKh9j4DuTx47MvqY5ax+NNWRtK32qIcJf1UxKo1WwjWg==",
-      "license": "MIT",
-      "dependencies": {
-        "motion-dom": "^12.29.0",
-        "motion-utils": "^12.27.2",
-        "tslib": "^2.4.0"
-      },
-      "peerDependencies": {
-        "@emotion/is-prop-valid": "*",
-        "react": "^18.0.0 || ^19.0.0",
-        "react-dom": "^18.0.0 || ^19.0.0"
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
       },
-      "peerDependenciesMeta": {
-        "@emotion/is-prop-valid": {
-          "optional": true
-        },
-        "react": {
-          "optional": true
-        },
-        "react-dom": {
-          "optional": true
-        }
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/fsevents": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
-      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+    "node_modules/smob": {
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/smob/-/smob-1.6.2.tgz",
+      "integrity": "sha512-RQsvleCbF8cVHEv+xuDGaA4pOizFqJ0GgjtMSRo6oP8pnN7WsigHgVGey6aILRBKv4W2YOMHLqbKdnB6hpB9fw==",
       "dev": true,
-      "hasInstallScript": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
       "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+        "node": ">=20.0.0"
       }
     },
-    "node_modules/gensync": {
-      "version": "1.0.0-beta.2",
-      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
-      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+    "node_modules/source-map": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.8.0.tgz",
+      "integrity": "sha512-d8EqvL+k/SOXCreS/SUzg2ciyHqBBLcN/yuRjFsbvVhHTE2pgei7oAhmPM7kWFbkX6OSMQfUq4KbkF3au9lhYQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/source-map-support/node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
       "engines": {
-        "node": ">=6.9.0"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/glob-parent": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
-      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
       "dev": true,
-      "license": "ISC",
+      "license": "MIT"
+    },
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/stop-iteration-iterator": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
+      "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==",
+      "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "is-glob": "^4.0.3"
+        "es-errors": "^1.3.0",
+        "internal-slot": "^1.1.0"
       },
       "engines": {
-        "node": ">=10.13.0"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/globals": {
-      "version": "16.5.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz",
-      "integrity": "sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==",
+    "node_modules/string.prototype.matchall": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.1.0.tgz",
+      "integrity": "sha512-tHNHTxInrYLCga9O9YGxWA3G9/nnzQw8UGAyqGx3Ar1pSTTzIuM4woFSq4SowkXCjJIwq5sIiQvEfRI9tCH1qQ==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=18"
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "define-properties": "^1.2.1",
+        "es-abstract": "^1.24.2",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.2",
+        "get-intrinsic": "^1.3.0",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "internal-slot": "^1.1.0",
+        "regexp.prototype.flags": "^1.5.4",
+        "set-function-name": "^2.0.2",
+        "side-channel": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/glsl-noise": {
-      "version": "0.0.0",
-      "resolved": "https://registry.npmjs.org/glsl-noise/-/glsl-noise-0.0.0.tgz",
-      "integrity": "sha512-b/ZCF6amfAUb7dJM/MxRs7AetQEahYzJ8PtgfrmEdtw6uyGOr+ZSGtgjFm6mfsBkxJ4d2W7kg+Nlqzqvn3Bc0w==",
-      "license": "MIT"
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+    "node_modules/string.prototype.trim": {
+      "version": "1.2.11",
+      "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.11.tgz",
+      "integrity": "sha512-PwvK7BU+CMTJGYQCTZb5RWXIML92lftJLhQz1tBzgKiqGxJaMlBAa48POXaNAC2s4y8jr3EFqrkF9+44neS46w==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "define-data-property": "^1.1.4",
+        "define-properties": "^1.2.1",
+        "es-abstract": "^1.24.2",
+        "es-object-atoms": "^1.1.2",
+        "has-property-descriptors": "^1.0.2",
+        "safe-regex-test": "^1.1.0"
+      },
       "engines": {
-        "node": ">=8"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/hermes-estree": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz",
-      "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==",
+    "node_modules/string.prototype.trimend": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.10.tgz",
+      "integrity": "sha512-2+3aDAOmPTmuFwjDnmJG2ctEkQKVki7vOSqaxkv42Mowj1V6PnvuwFCRrR5lChUux1TBskPjfkeTOhqczDMxTw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "define-properties": "^1.2.1",
+        "es-object-atoms": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
     },
-    "node_modules/hermes-parser": {
-      "version": "0.25.1",
-      "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz",
-      "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==",
+    "node_modules/string.prototype.trimstart": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz",
+      "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "hermes-estree": "0.25.1"
+        "call-bind": "^1.0.7",
+        "define-properties": "^1.2.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/hls.js": {
-      "version": "1.6.15",
-      "resolved": "https://registry.npmjs.org/hls.js/-/hls.js-1.6.15.tgz",
-      "integrity": "sha512-E3a5VwgXimGHwpRGV+WxRTKeSp2DW5DI5MWv34ulL3t5UNmyJWCQ1KmLEHbYzcfThfXG8amBL+fCYPneGHC4VA==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/ieee754": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
-      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "BSD-3-Clause"
+    "node_modules/stringify-object": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz",
+      "integrity": "sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "get-own-enumerable-property-symbols": "^3.0.0",
+        "is-obj": "^1.0.1",
+        "is-regexp": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
     },
-    "node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+    "node_modules/strip-comments": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/strip-comments/-/strip-comments-2.0.1.tgz",
+      "integrity": "sha512-ZprKx+bBLXv067WTCALv8SSz5l2+XhpYCsVtSqlMnkAXMWDq+/ekVbl1ghqP9rUHTzv6sm/DwCOiYutU/yp1fw==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">= 4"
+        "node": ">=10"
       }
     },
-    "node_modules/immediate": {
-      "version": "3.0.6",
-      "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
-      "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
-      "license": "MIT"
-    },
-    "node_modules/import-fresh": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
-      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+    "node_modules/strip-indent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
+      "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
+        "min-indent": "^1.0.0"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/imurmurhash": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+    "node_modules/strip-literal": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.1.0.tgz",
+      "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=0.8.19"
+      "dependencies": {
+        "js-tokens": "^9.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
       }
     },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+    "node_modules/strip-literal/node_modules/js-tokens": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz",
+      "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">=8"
       }
     },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/is-promise": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.2.2.tgz",
-      "integrity": "sha512-+lP4/6lKUBfQjZ2pdxThZvLUAafmZb8OAxFb8XXtiQmS35INgr85hdOGoEs124ez1FCnZJt6jau/T+alh58QFQ==",
+    "node_modules/tailwindcss": {
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.3.3.tgz",
+      "integrity": "sha512-gOhV3P7ufE62QDGg1zVaTgCR+EtPv92k2nIhVcVKcLmxT1sUBsQGhnZj175j+MqRt4zLF7ic+sCYjfhxMxj7YQ==",
+      "dev": true,
       "license": "MIT"
     },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "license": "ISC"
-    },
-    "node_modules/its-fine": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/its-fine/-/its-fine-2.0.0.tgz",
-      "integrity": "sha512-KLViCmWx94zOvpLwSlsx6yOCeMhZYaxrJV87Po5k/FoZzcPSahvK5qJ7fYhS61sZi5ikmh2S3Hz55A2l3U69ng==",
+    "node_modules/tapable": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.3.tgz",
+      "integrity": "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==",
+      "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@types/react-reconciler": "^0.28.9"
+      "engines": {
+        "node": ">=6"
       },
-      "peerDependencies": {
-        "react": "^19.0.0"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
       }
     },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+    "node_modules/temp-dir": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/temp-dir/-/temp-dir-2.0.0.tgz",
+      "integrity": "sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
     },
-    "node_modules/js-yaml": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+    "node_modules/tempy": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/tempy/-/tempy-0.6.0.tgz",
+      "integrity": "sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "argparse": "^2.0.1"
+        "is-stream": "^2.0.0",
+        "temp-dir": "^2.0.0",
+        "type-fest": "^0.16.0",
+        "unique-string": "^2.0.0"
       },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/jsesc": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
-      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+    "node_modules/terser": {
+      "version": "5.51.2",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.51.2.tgz",
+      "integrity": "sha512-bWnjSNscmuI+GJze6ZupnHP8G/cTcsJF+bXCeQknk2SHQsgbNJnLrqiH9jZ2W4STPVXH2mDKKRX3iwPhc9Cn/Q==",
       "dev": true,
-      "license": "MIT",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "@jridgewell/source-map": "^0.3.3",
+        "acorn": "^8.15.0",
+        "commander": "^2.20.0",
+        "source-map-support": "~0.5.20"
+      },
       "bin": {
-        "jsesc": "bin/jsesc"
+        "terser": "bin/terser"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=10"
       }
     },
-    "node_modules/json-buffer": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
-      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/json-stable-stringify-without-jsonify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
-      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+    "node_modules/tinyexec": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/json5": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
-      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
       "dev": true,
       "license": "MIT",
-      "bin": {
-        "json5": "lib/cli.js"
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
-    "node_modules/keyv": {
-      "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
-      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+    "node_modules/tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "json-buffer": "3.0.1"
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
       }
     },
-    "node_modules/levn": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
-      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+    "node_modules/tinyrainbow": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz",
+      "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1",
-        "type-check": "~0.4.0"
-      },
       "engines": {
-        "node": ">= 0.8.0"
+        "node": ">=14.0.0"
       }
     },
-    "node_modules/lie": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz",
-      "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==",
+    "node_modules/tinyspy": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.6.tgz",
+      "integrity": "sha512-u8KszXvGfU68hVcZpRHKG28T0krMuv2G5nDhiHaMLen/gIuFEgIJhaJuO69qjnXg5paSrbPMFfx3brNuN8eVSg==",
+      "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "immediate": "~3.0.5"
+      "engines": {
+        "node": ">=14.0.0"
       }
     },
-    "node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+    "node_modules/tldts": {
+      "version": "7.4.18",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.18.tgz",
+      "integrity": "sha512-somxA8xKAUzlAxl0TX/jMSYIbRNFIVGnI96pVGJPeMc5BsHmfVXn6mOJT6U++ELnl04eGfzpfcEuZe8WiASkXg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "p-locate": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=10"
+        "tldts-core": "^7.4.18"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+      "bin": {
+        "tldts": "bin/cli.js"
       }
     },
-    "node_modules/lodash.merge": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
-      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+    "node_modules/tldts-core": {
+      "version": "7.4.18",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.18.tgz",
+      "integrity": "sha512-KI2PKvCmvQI/xD6ypPqkU0i7oxNXR/O58RLRaHR4svsgVUQ2JE/XC8BtMbG6PSehD27I8sZJRcC1ASnCy6lp3g==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/lru-cache": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
-      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+    "node_modules/tough-cookie": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz",
+      "integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==",
       "dev": true,
-      "license": "ISC",
+      "license": "BSD-3-Clause",
       "dependencies": {
-        "yallist": "^3.0.2"
-      }
-    },
-    "node_modules/lucide-react": {
-      "version": "0.563.0",
-      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.563.0.tgz",
-      "integrity": "sha512-8dXPB2GI4dI8jV4MgUDGBeLdGk8ekfqVZ0BdLcrRzocGgG75ltNEmWS+gE7uokKF/0oSUuczNDT+g9hFJ23FkA==",
-      "license": "ISC",
-      "peerDependencies": {
-        "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+        "tldts": "^7.0.5"
+      },
+      "engines": {
+        "node": ">=16"
       }
     },
-    "node_modules/maath": {
-      "version": "0.10.8",
-      "resolved": "https://registry.npmjs.org/maath/-/maath-0.10.8.tgz",
-      "integrity": "sha512-tRvbDF0Pgqz+9XUa4jjfgAQ8/aPKmQdWXilFu2tMy4GWj4NOsx99HlULO4IeREfbO3a0sA145DZYyvXPkybm0g==",
+    "node_modules/tr46": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-7.0.0.tgz",
+      "integrity": "sha512-BcDSDW+SIGWVOns1Zm6Yg91q9AEj7eaID0QDY9oIqJD1A8dscNwMcl9Sms2DeuWCNov1X0/oXanHGYQBSLwZsg==",
+      "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "@types/three": ">=0.134.0",
-        "three": ">=0.134.0"
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": "^22.14.0 || >=24.0.0"
       }
     },
-    "node_modules/meshline": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/meshline/-/meshline-3.3.1.tgz",
-      "integrity": "sha512-/TQj+JdZkeSUOl5Mk2J7eLcYTLiQm2IDzmlSvYm7ov15anEcDJ92GHqqazxTSreeNgfnYu24kiEvvv0WlbCdFQ==",
+    "node_modules/ts-api-utils": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.4.0.tgz",
+      "integrity": "sha512-3TaVTaAv2gTiMB35i3FiGJaRfwb3Pyn/j3m/bfAvGe8FB7CF6u+LMYqYlDh7reQf7UNvoTvdfAqHGmPGOSsPmA==",
+      "dev": true,
       "license": "MIT",
+      "engines": {
+        "node": ">=18.12"
+      },
       "peerDependencies": {
-        "three": ">=0.137"
+        "typescript": ">=4.8.4"
       }
     },
-    "node_modules/meshoptimizer": {
-      "version": "0.22.0",
-      "resolved": "https://registry.npmjs.org/meshoptimizer/-/meshoptimizer-0.22.0.tgz",
-      "integrity": "sha512-IebiK79sqIy+E4EgOr+CAw+Ke8hAspXKzBd0JdgEmPHiAwmvEj2S4h1rfvo+o/BnfEYd/jAOg5IeeIjzlzSnDg==",
-      "license": "MIT"
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
     },
-    "node_modules/minimatch": {
-      "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
-      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
       "dev": true,
-      "license": "ISC",
+      "license": "MIT",
       "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "prelude-ls": "^1.2.1"
       },
       "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/motion-dom": {
-      "version": "12.29.0",
-      "resolved": "https://registry.npmjs.org/motion-dom/-/motion-dom-12.29.0.tgz",
-      "integrity": "sha512-3eiz9bb32yvY8Q6XNM4AwkSOBPgU//EIKTZwsSWgA9uzbPBhZJeScCVcBuwwYVqhfamewpv7ZNmVKTGp5qnzkA==",
-      "license": "MIT",
-      "dependencies": {
-        "motion-utils": "^12.27.2"
+        "node": ">= 0.8.0"
       }
     },
-    "node_modules/motion-utils": {
-      "version": "12.27.2",
-      "resolved": "https://registry.npmjs.org/motion-utils/-/motion-utils-12.27.2.tgz",
-      "integrity": "sha512-B55gcoL85Mcdt2IEStY5EEAsrMSVE2sI14xQ/uAdPL+mfQxhKKFaEag9JmfxedJOR4vZpBGoPeC/Gm13I/4g5Q==",
-      "license": "MIT"
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+    "node_modules/type-fest": {
+      "version": "0.16.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.16.0.tgz",
+      "integrity": "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==",
       "dev": true,
-      "license": "MIT"
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
     },
-    "node_modules/nanoid": {
-      "version": "3.3.11",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
-      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+    "node_modules/typed-array-buffer": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
+      "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
       "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "bin": {
-        "nanoid": "bin/nanoid.cjs"
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "is-typed-array": "^1.1.14"
       },
       "engines": {
-        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+        "node": ">= 0.4"
       }
     },
-    "node_modules/natural-compare": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
-      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+    "node_modules/typed-array-byte-length": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz",
+      "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "for-each": "^0.3.3",
+        "gopd": "^1.2.0",
+        "has-proto": "^1.2.0",
+        "is-typed-array": "^1.1.14"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
     },
-    "node_modules/node-releases": {
-      "version": "2.0.27",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
-      "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
+    "node_modules/typed-array-byte-offset": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.5.tgz",
+      "integrity": "sha512-0FHJvLPqZ7KJzp17O13jfsAjsqazgrxBu2zEK95PmUz8lv2+GjRuxUInCr2Rk9Dms3ihN21zJ929ZO43yJ95QQ==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "available-typed-arrays": "^1.0.7",
+        "call-bind": "^1.0.9",
+        "for-each": "^0.3.5",
+        "gopd": "^1.2.0",
+        "is-typed-array": "^1.1.15",
+        "reflect.getprototypeof": "^1.0.10"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
     },
-    "node_modules/optionator": {
-      "version": "0.9.4",
-      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
-      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+    "node_modules/typed-array-length": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.8.tgz",
+      "integrity": "sha512-phPGCwqr2+Qo0fwniCE8e4pKnGu/yFb5nD5Y8bf0EEeiI5GklnACYA9GFy/DrAeRrKHXvHn+1SUsOWgJp6RO+g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "deep-is": "^0.1.3",
-        "fast-levenshtein": "^2.0.6",
-        "levn": "^0.4.1",
-        "prelude-ls": "^1.2.1",
-        "type-check": "^0.4.0",
-        "word-wrap": "^1.2.5"
+        "call-bind": "^1.0.9",
+        "for-each": "^0.3.5",
+        "gopd": "^1.2.0",
+        "is-typed-array": "^1.1.15",
+        "possible-typed-array-names": "^1.1.0",
+        "reflect.getprototypeof": "^1.0.10"
       },
       "engines": {
-        "node": ">= 0.8.0"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/p-limit": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/typescript-eslint": {
+      "version": "8.53.1",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.53.1.tgz",
+      "integrity": "sha512-gB+EVQfP5RDElh9ittfXlhZJdjSU4jUSTyE2+ia8CYyNvet4ElfaLlAIqDvQV9JPknKx0jQH1racTYe/4LaLSg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "yocto-queue": "^0.1.0"
+        "@typescript-eslint/eslint-plugin": "8.53.1",
+        "@typescript-eslint/parser": "8.53.1",
+        "@typescript-eslint/typescript-estree": "8.53.1",
+        "@typescript-eslint/utils": "8.53.1"
       },
       "engines": {
-        "node": ">=10"
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
       }
     },
-    "node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+    "node_modules/unbox-primitive": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz",
+      "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "p-limit": "^3.0.2"
+        "call-bound": "^1.0.3",
+        "has-bigints": "^1.0.2",
+        "has-symbols": "^1.1.0",
+        "which-boxed-primitive": "^1.1.1"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">= 0.4"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/parent-module": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
-      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+    "node_modules/undici": {
+      "version": "8.12.3",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-8.12.3.tgz",
+      "integrity": "sha512-+fdndUTwBP86cVjihTp21hZHo7d6oj1c/47XPA3lL8mM0XHs+C4EkcjmgRsFnFk2f/UONGDy9ItBItmXsLOQHw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=22.19.0"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
+      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/unicode-canonical-property-names-ecmascript": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz",
+      "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/unicode-match-property-ecmascript": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz",
+      "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "callsites": "^3.0.0"
+        "unicode-canonical-property-names-ecmascript": "^2.0.0",
+        "unicode-property-aliases-ecmascript": "^2.0.0"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=4"
       }
     },
-    "node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+    "node_modules/unicode-match-property-value-ecmascript": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz",
+      "integrity": "sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=4"
       }
     },
-    "node_modules/path-key": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
-      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+    "node_modules/unicode-property-aliases-ecmascript": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz",
+      "integrity": "sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==",
+      "dev": true,
       "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/unique-string": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz",
+      "integrity": "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "crypto-random-string": "^2.0.0"
+      },
       "engines": {
         "node": ">=8"
       }
     },
-    "node_modules/picocolors": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
-      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+    "node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
       "dev": true,
-      "license": "ISC"
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
     },
-    "node_modules/picomatch": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
-      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+    "node_modules/upath": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz",
+      "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
+        "node": ">=4",
+        "yarn": "*"
       }
     },
-    "node_modules/postcss": {
-      "version": "8.5.6",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
-      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+    "node_modules/update-browserslist-db": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.4.tgz",
+      "integrity": "sha512-t8wonIOdQyOjtPd2VktlBu6QjTVTks6v8bSi7kd0r2Vll8TK1JYDZtRRdbmCHOAMphkZgrzK+L+vXK4pyZ8t4A==",
       "dev": true,
       "funding": [
         {
           "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
+          "url": "https://opencollective.com/browserslist"
         },
         {
           "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/postcss"
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
         },
         {
           "type": "github",
@@ -3261,686 +8658,686 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "nanoid": "^3.3.11",
-        "picocolors": "^1.1.1",
-        "source-map-js": "^1.2.1"
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
       },
-      "engines": {
-        "node": "^10 || ^12 || >=14"
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
       }
     },
-    "node_modules/potpack": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/potpack/-/potpack-1.0.2.tgz",
-      "integrity": "sha512-choctRBIV9EMT9WGAZHn3V7t0Z2pMQyl0EZE6pFc/6ml3ssw7Dlf/oAOvFwjm1HVsqfQN8GfeFyJ+d8tRzqueQ==",
-      "license": "ISC"
-    },
-    "node_modules/prelude-ls": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
-      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
       "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/promise-worker-transferable": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/promise-worker-transferable/-/promise-worker-transferable-1.0.4.tgz",
-      "integrity": "sha512-bN+0ehEnrXfxV2ZQvU2PetO0n4gqBD4ulq3MI1WOPLgr7/Mg9yRQkX5+0v1vagr74ZTsl7XtzlaYDo2EuCeYJw==",
-      "license": "Apache-2.0",
+      "license": "BSD-2-Clause",
       "dependencies": {
-        "is-promise": "^2.1.0",
-        "lie": "^3.0.2"
+        "punycode": "^2.1.0"
       }
     },
-    "node_modules/punycode": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+    "node_modules/vite": {
+      "version": "7.3.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
+      "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.27.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
       "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/react": {
-      "version": "19.2.3",
-      "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
-      "integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
-      "license": "MIT",
-      "peer": true,
-      "engines": {
-        "node": ">=0.10.0"
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
       }
     },
-    "node_modules/react-dom": {
-      "version": "19.2.3",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.3.tgz",
-      "integrity": "sha512-yELu4WmLPw5Mr/lmeEpox5rw3RETacE++JgHqQzd2dg+YbJuat3jH4ingc+WPZhxaoFzdv9y33G+F7Nl5O0GBg==",
+    "node_modules/vite-node": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz",
+      "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==",
+      "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "scheduler": "^0.27.0"
+        "cac": "^6.7.14",
+        "debug": "^4.4.1",
+        "es-module-lexer": "^1.7.0",
+        "pathe": "^2.0.3",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
       },
-      "peerDependencies": {
-        "react": "^19.2.3"
-      }
-    },
-    "node_modules/react-refresh": {
-      "version": "0.18.0",
-      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz",
-      "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==",
-      "dev": true,
-      "license": "MIT",
       "engines": {
-        "node": ">=0.10.0"
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/react-router": {
-      "version": "7.13.0",
-      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.13.0.tgz",
-      "integrity": "sha512-PZgus8ETambRT17BUm/LL8lX3Of+oiLaPuVTRH3l1eLvSPpKO3AvhAEb5N7ihAFZQrYDqkvvWfFh9p0z9VsjLw==",
+    "node_modules/vite-plugin-pwa": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/vite-plugin-pwa/-/vite-plugin-pwa-2.0.0.tgz",
+      "integrity": "sha512-6G9dsPKT9QKYpeTuTLJM28zZL3HsXUTUM/QUZBEgQk2jbfrPJDq2i8gTewAKqi1c9Mt6MiidrL4SFI+HthiQMg==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "cookie": "^1.0.1",
-        "set-cookie-parser": "^2.6.0"
+        "debug": "^4.3.6",
+        "pretty-bytes": "^6.1.1",
+        "tinyglobby": "^0.2.10",
+        "workbox-build": "^7.4.1",
+        "workbox-window": "^7.4.1"
       },
       "engines": {
-        "node": ">=20.0.0"
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
       },
       "peerDependencies": {
-        "react": ">=18",
-        "react-dom": ">=18"
+        "@vite-pwa/assets-generator": "^1.0.0 || ^2.0.0",
+        "vite": "^3.1.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
+        "workbox-build": "^7.4.1",
+        "workbox-window": "^7.4.1"
       },
       "peerDependenciesMeta": {
-        "react-dom": {
+        "@vite-pwa/assets-generator": {
           "optional": true
         }
       }
     },
-    "node_modules/react-router-dom": {
-      "version": "7.13.0",
-      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.13.0.tgz",
-      "integrity": "sha512-5CO/l5Yahi2SKC6rGZ+HDEjpjkGaG/ncEP7eWFTvFxbHP8yeeI0PxTDjimtpXYlR3b3i9/WIL4VJttPrESIf2g==",
+    "node_modules/vitest": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.7.tgz",
+      "integrity": "sha512-KrxIJ62Fd89gfysR4WotlgZABiz2dqFPgqGzX7s+CwsqLFomRH7777ZcrOD6+WVAh7khPQP41A+BKbpcJFrdEg==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "react-router": "7.13.0"
+        "@types/chai": "^5.2.2",
+        "@vitest/expect": "3.2.7",
+        "@vitest/mocker": "3.2.7",
+        "@vitest/pretty-format": "^3.2.7",
+        "@vitest/runner": "3.2.7",
+        "@vitest/snapshot": "3.2.7",
+        "@vitest/spy": "3.2.7",
+        "@vitest/utils": "3.2.7",
+        "chai": "^5.2.0",
+        "debug": "^4.4.1",
+        "expect-type": "^1.2.1",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.2",
+        "std-env": "^3.9.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^0.3.2",
+        "tinyglobby": "^0.2.14",
+        "tinypool": "^1.1.1",
+        "tinyrainbow": "^2.0.0",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
+        "vite-node": "3.2.4",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
       },
       "engines": {
-        "node": ">=20.0.0"
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
-        "react": ">=18",
-        "react-dom": ">=18"
-      }
-    },
-    "node_modules/react-use-measure": {
-      "version": "2.1.7",
-      "resolved": "https://registry.npmjs.org/react-use-measure/-/react-use-measure-2.1.7.tgz",
-      "integrity": "sha512-KrvcAo13I/60HpwGO5jpW7E9DfusKyLPLvuHlUyP5zqnmAPhNc6qTRjUQrdTADl0lpPpDVU2/Gg51UlOGHXbdg==",
-      "license": "MIT",
-      "peerDependencies": {
-        "react": ">=16.13",
-        "react-dom": ">=16.13"
+        "@edge-runtime/vm": "*",
+        "@types/debug": "^4.1.12",
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "@vitest/browser": "3.2.7",
+        "@vitest/ui": "3.2.7",
+        "happy-dom": "*",
+        "jsdom": "*"
       },
       "peerDependenciesMeta": {
-        "react-dom": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/debug": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
           "optional": true
         }
       }
     },
-    "node_modules/require-from-string": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
-      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+    "node_modules/w3c-xmlserializer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-6.0.0.tgz",
+      "integrity": "sha512-4Nsy8K5Tr6SPDH9jhKJOHf7ChDrc1zufZTVSF7x72hwuEXBqxqk9G6cK+K2NRUtB3iELRJqjXb4JPDMBjMTl2Q==",
+      "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
       "engines": {
-        "node": ">=0.10.0"
+        "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
       }
     },
-    "node_modules/resolve-from": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+    "node_modules/webidl-conversions": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
+      "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
+      "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=4"
+        "node": ">=20"
       }
     },
-    "node_modules/rollup": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz",
-      "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
+    "node_modules/whatwg-url": {
+      "version": "17.3.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-17.3.0.tgz",
+      "integrity": "sha512-KwOAJrpf+GTgBvcBQJcP38sMF0DsQKdwtG+TxM2pW44P6E5k0hDbWrDmyuJDIF0Uef0aQq0ZoJs+5oI+k8ddhg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "1.0.8"
-      },
-      "bin": {
-        "rollup": "dist/bin/rollup"
+        "@exodus/bytes": "^1.16.0",
+        "tr46": "^7.0.0",
+        "webidl-conversions": "^8.0.1"
       },
       "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
-      },
-      "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.59.0",
-        "@rollup/rollup-android-arm64": "4.59.0",
-        "@rollup/rollup-darwin-arm64": "4.59.0",
-        "@rollup/rollup-darwin-x64": "4.59.0",
-        "@rollup/rollup-freebsd-arm64": "4.59.0",
-        "@rollup/rollup-freebsd-x64": "4.59.0",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.59.0",
-        "@rollup/rollup-linux-arm-musleabihf": "4.59.0",
-        "@rollup/rollup-linux-arm64-gnu": "4.59.0",
-        "@rollup/rollup-linux-arm64-musl": "4.59.0",
-        "@rollup/rollup-linux-loong64-gnu": "4.59.0",
-        "@rollup/rollup-linux-loong64-musl": "4.59.0",
-        "@rollup/rollup-linux-ppc64-gnu": "4.59.0",
-        "@rollup/rollup-linux-ppc64-musl": "4.59.0",
-        "@rollup/rollup-linux-riscv64-gnu": "4.59.0",
-        "@rollup/rollup-linux-riscv64-musl": "4.59.0",
-        "@rollup/rollup-linux-s390x-gnu": "4.59.0",
-        "@rollup/rollup-linux-x64-gnu": "4.59.0",
-        "@rollup/rollup-linux-x64-musl": "4.59.0",
-        "@rollup/rollup-openbsd-x64": "4.59.0",
-        "@rollup/rollup-openharmony-arm64": "4.59.0",
-        "@rollup/rollup-win32-arm64-msvc": "4.59.0",
-        "@rollup/rollup-win32-ia32-msvc": "4.59.0",
-        "@rollup/rollup-win32-x64-gnu": "4.59.0",
-        "@rollup/rollup-win32-x64-msvc": "4.59.0",
-        "fsevents": "~2.3.2"
+        "node": "^22.14.0 || >=24.0.0"
       }
     },
-    "node_modules/scheduler": {
-      "version": "0.27.0",
-      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
-      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
-      "license": "MIT"
-    },
-    "node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
       "dev": true,
       "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "node_modules/set-cookie-parser": {
-      "version": "2.7.2",
-      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz",
-      "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==",
-      "license": "MIT"
-    },
-    "node_modules/shebang-command": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
-      "license": "MIT",
       "dependencies": {
-        "shebang-regex": "^3.0.0"
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">= 8"
       }
     },
-    "node_modules/shebang-regex": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+    "node_modules/which-boxed-primitive": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz",
+      "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==",
+      "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "is-bigint": "^1.1.0",
+        "is-boolean-object": "^1.2.1",
+        "is-number-object": "^1.1.1",
+        "is-string": "^1.1.1",
+        "is-symbol": "^1.1.1"
+      },
       "engines": {
-        "node": ">=8"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/source-map-js": {
+    "node_modules/which-builtin-type": {
       "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
-      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz",
+      "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==",
       "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "function.prototype.name": "^1.1.6",
+        "has-tostringtag": "^1.0.2",
+        "is-async-function": "^2.0.0",
+        "is-date-object": "^1.1.0",
+        "is-finalizationregistry": "^1.1.0",
+        "is-generator-function": "^1.0.10",
+        "is-regex": "^1.2.1",
+        "is-weakref": "^1.0.2",
+        "isarray": "^2.0.5",
+        "which-boxed-primitive": "^1.1.0",
+        "which-collection": "^1.0.2",
+        "which-typed-array": "^1.1.16"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/stats-gl": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/stats-gl/-/stats-gl-2.4.2.tgz",
-      "integrity": "sha512-g5O9B0hm9CvnM36+v7SFl39T7hmAlv541tU81ME8YeSb3i1CIP5/QdDeSB3A0la0bKNHpxpwxOVRo2wFTYEosQ==",
+    "node_modules/which-collection": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz",
+      "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/three": "*",
-        "three": "^0.170.0"
+        "is-map": "^2.0.3",
+        "is-set": "^2.0.3",
+        "is-weakmap": "^2.0.2",
+        "is-weakset": "^2.0.3"
       },
-      "peerDependencies": {
-        "@types/three": "*",
-        "three": "*"
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/stats-gl/node_modules/three": {
-      "version": "0.170.0",
-      "resolved": "https://registry.npmjs.org/three/-/three-0.170.0.tgz",
-      "integrity": "sha512-FQK+LEpYc0fBD+J8g6oSEyyNzjp+Q7Ks1C568WWaoMRLW+TkNNWmenWeGgJjV105Gd+p/2ql1ZcjYvNiPZBhuQ==",
-      "license": "MIT"
-    },
-    "node_modules/stats.js": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/stats.js/-/stats.js-0.17.0.tgz",
-      "integrity": "sha512-hNKz8phvYLPEcRkeG1rsGmV5ChMjKDAWU7/OJJdDErPBNChQXxCo3WZurGpnWc6gZhAzEPFad1aVgyOANH1sMw==",
-      "license": "MIT"
-    },
-    "node_modules/strip-json-comments": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
-      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+    "node_modules/which-typed-array": {
+      "version": "1.1.24",
+      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.24.tgz",
+      "integrity": "sha512-wk4Mf4pR5mRP7eYuuTBCIQ9d0ud2Fv2jRLQpfgnRjbOxAFHmjKFValgTpitVKzJJS8ajnYQV2Du1SZ8j6b/EUQ==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "available-typed-arrays": "^1.0.7",
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "for-each": "^0.3.5",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-tostringtag": "^1.0.2"
+      },
       "engines": {
-        "node": ">=8"
+        "node": ">= 0.4"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "has-flag": "^4.0.0"
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
       },
       "engines": {
         "node": ">=8"
       }
     },
-    "node_modules/suspend-react": {
-      "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/suspend-react/-/suspend-react-0.1.3.tgz",
-      "integrity": "sha512-aqldKgX9aZqpoDp3e8/BZ8Dm7x1pJl+qI3ZKxDN0i/IQTWUwBx/ManmlVJ3wowqbno6c2bmiIfs+Um6LbsjJyQ==",
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "react": ">=17.0"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/three": {
-      "version": "0.182.0",
-      "resolved": "https://registry.npmjs.org/three/-/three-0.182.0.tgz",
-      "integrity": "sha512-GbHabT+Irv+ihI1/f5kIIsZ+Ef9Sl5A1Y7imvS5RQjWgtTPfPnZ43JmlYI7NtCRDK9zir20lQpfg8/9Yd02OvQ==",
-      "license": "MIT",
-      "peer": true
-    },
-    "node_modules/three-mesh-bvh": {
-      "version": "0.8.3",
-      "resolved": "https://registry.npmjs.org/three-mesh-bvh/-/three-mesh-bvh-0.8.3.tgz",
-      "integrity": "sha512-4G5lBaF+g2auKX3P0yqx+MJC6oVt6sB5k+CchS6Ob0qvH0YIhuUk1eYr7ktsIpY+albCqE80/FVQGV190PmiAg==",
+    "node_modules/workbox-background-sync": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-background-sync/-/workbox-background-sync-7.4.1.tgz",
+      "integrity": "sha512-HhT7KE8tOWDm02wRNshXUnUPofMlhenF2DBdUnDPOubhizzPeItkYTmAB6td1Z2cjYPa98vzEiPLEuzn5hN66g==",
+      "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "three": ">= 0.159.0"
+      "dependencies": {
+        "idb": "^7.0.1",
+        "workbox-core": "7.4.1"
       }
     },
-    "node_modules/three-stdlib": {
-      "version": "2.36.1",
-      "resolved": "https://registry.npmjs.org/three-stdlib/-/three-stdlib-2.36.1.tgz",
-      "integrity": "sha512-XyGQrFmNQ5O/IoKm556ftwKsBg11TIb301MB5dWNicziQBEs2g3gtOYIf7pFiLa0zI2gUwhtCjv9fmjnxKZ1Cg==",
+    "node_modules/workbox-broadcast-update": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-broadcast-update/-/workbox-broadcast-update-7.4.1.tgz",
+      "integrity": "sha512-uAlgslKLvbQY+suirIdnBCSYrcgBhjp81Nj4l1lj/Jmj0MJO2CJERnCJjT0GFVwmReV0N+zs78K6gqd5gr9/+A==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/draco3d": "^1.4.0",
-        "@types/offscreencanvas": "^2019.6.4",
-        "@types/webxr": "^0.5.2",
-        "draco3d": "^1.4.1",
-        "fflate": "^0.6.9",
-        "potpack": "^1.0.1"
-      },
-      "peerDependencies": {
-        "three": ">=0.128.0"
+        "workbox-core": "7.4.1"
       }
     },
-    "node_modules/three-stdlib/node_modules/fflate": {
-      "version": "0.6.10",
-      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.6.10.tgz",
-      "integrity": "sha512-IQrh3lEPM93wVCEczc9SaAOvkmcoQn/G8Bo1e8ZPlY3X3bnAxWaBdvTdvM1hP62iZp0BXWDy4vTAy4fF0+Dlpg==",
-      "license": "MIT"
-    },
-    "node_modules/tinyglobby": {
-      "version": "0.2.15",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
-      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+    "node_modules/workbox-build": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-build/-/workbox-build-7.4.1.tgz",
+      "integrity": "sha512-SDhxIvEAde9Gy/5w4Yo1Jh/M49Z0qE3q0oteyE8zGq0DScxFqVBcCtIXFuLtmtxRQZCMbf0prco4VyEu3KBQuw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "fdir": "^6.5.0",
-        "picomatch": "^4.0.3"
+        "@apideck/better-ajv-errors": "^0.3.1",
+        "@babel/core": "^7.24.4",
+        "@babel/preset-env": "^7.11.0",
+        "@babel/runtime": "^7.11.2",
+        "@rollup/plugin-babel": "^6.1.0",
+        "@rollup/plugin-node-resolve": "^16.0.3",
+        "@rollup/plugin-replace": "^6.0.3",
+        "@rollup/plugin-terser": "^1.0.0",
+        "@trickfilm400/rollup-plugin-off-main-thread": "^3.0.0-pre1",
+        "ajv": "^8.6.0",
+        "common-tags": "^1.8.0",
+        "eta": "^4.5.1",
+        "fast-json-stable-stringify": "^2.1.0",
+        "fs-extra": "^9.0.1",
+        "glob": "^11.0.1",
+        "pretty-bytes": "^5.3.0",
+        "rollup": "^4.53.3",
+        "source-map": "^0.8.0-beta.0",
+        "stringify-object": "^3.3.0",
+        "strip-comments": "^2.0.1",
+        "tempy": "^0.6.0",
+        "upath": "^1.2.0",
+        "workbox-background-sync": "7.4.1",
+        "workbox-broadcast-update": "7.4.1",
+        "workbox-cacheable-response": "7.4.1",
+        "workbox-core": "7.4.1",
+        "workbox-expiration": "7.4.1",
+        "workbox-google-analytics": "7.4.1",
+        "workbox-navigation-preload": "7.4.1",
+        "workbox-precaching": "7.4.1",
+        "workbox-range-requests": "7.4.1",
+        "workbox-recipes": "7.4.1",
+        "workbox-routing": "7.4.1",
+        "workbox-strategies": "7.4.1",
+        "workbox-streams": "7.4.1",
+        "workbox-sw": "7.4.1",
+        "workbox-window": "7.4.1"
       },
       "engines": {
-        "node": ">=12.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/SuperchupuDev"
+        "node": ">=20.0.0"
       }
     },
-    "node_modules/troika-three-text": {
-      "version": "0.52.4",
-      "resolved": "https://registry.npmjs.org/troika-three-text/-/troika-three-text-0.52.4.tgz",
-      "integrity": "sha512-V50EwcYGruV5rUZ9F4aNsrytGdKcXKALjEtQXIOBfhVoZU9VAqZNIoGQ3TMiooVqFAbR1w15T+f+8gkzoFzawg==",
+    "node_modules/workbox-build/node_modules/@apideck/better-ajv-errors": {
+      "version": "0.3.7",
+      "resolved": "https://registry.npmjs.org/@apideck/better-ajv-errors/-/better-ajv-errors-0.3.7.tgz",
+      "integrity": "sha512-TajUJwGWbDwkCx/CZi7tRE8PVB7simCvKJfHUsSdvps+aTM/PDPP4gkLmKnc+x3CE//y9i/nj74GqdL/hwk7Iw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "bidi-js": "^1.0.2",
-        "troika-three-utils": "^0.52.4",
-        "troika-worker-utils": "^0.52.0",
-        "webgl-sdf-generator": "1.1.1"
+        "jsonpointer": "^5.0.1",
+        "leven": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=10"
       },
       "peerDependencies": {
-        "three": ">=0.125.0"
+        "ajv": ">=8"
       }
     },
-    "node_modules/troika-three-utils": {
-      "version": "0.52.4",
-      "resolved": "https://registry.npmjs.org/troika-three-utils/-/troika-three-utils-0.52.4.tgz",
-      "integrity": "sha512-NORAStSVa/BDiG52Mfudk4j1FG4jC4ILutB3foPnfGbOeIs9+G5vZLa0pnmnaftZUGm4UwSoqEpWdqvC7zms3A==",
+    "node_modules/workbox-build/node_modules/ajv": {
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz",
+      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
+      "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "three": ">=0.125.0"
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
       }
     },
-    "node_modules/troika-worker-utils": {
-      "version": "0.52.0",
-      "resolved": "https://registry.npmjs.org/troika-worker-utils/-/troika-worker-utils-0.52.0.tgz",
-      "integrity": "sha512-W1CpvTHykaPH5brv5VHLfQo9D1OYuo0cSBEUQFFT/nBUzM8iD6Lq2/tgG/f1OelbAS1WtaTPQzE5uM49egnngw==",
+    "node_modules/workbox-build/node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+      "dev": true,
       "license": "MIT"
     },
-    "node_modules/ts-api-utils": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.4.0.tgz",
-      "integrity": "sha512-3TaVTaAv2gTiMB35i3FiGJaRfwb3Pyn/j3m/bfAvGe8FB7CF6u+LMYqYlDh7reQf7UNvoTvdfAqHGmPGOSsPmA==",
+    "node_modules/workbox-build/node_modules/pretty-bytes": {
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-5.6.0.tgz",
+      "integrity": "sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=18.12"
+        "node": ">=6"
       },
-      "peerDependencies": {
-        "typescript": ">=4.8.4"
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/tslib": {
-      "version": "2.8.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
-      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-      "license": "0BSD"
-    },
-    "node_modules/tunnel-rat": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/tunnel-rat/-/tunnel-rat-0.1.2.tgz",
-      "integrity": "sha512-lR5VHmkPhzdhrM092lI2nACsLO4QubF0/yoOhzX7c+wIpbN1GjHNzCc91QlpxBi+cnx8vVJ+Ur6vL5cEoQPFpQ==",
+    "node_modules/workbox-cacheable-response": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-cacheable-response/-/workbox-cacheable-response-7.4.1.tgz",
+      "integrity": "sha512-8xaFoJdDc2OjrlbbL3gEeBO1WKcMwRqwLRupgqahYXu75yXajPLuwrbXMrIGZuWYXrQwk0xDjOxZ/ujCy/oJYw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "zustand": "^4.3.2"
+        "workbox-core": "7.4.1"
       }
     },
-    "node_modules/tunnel-rat/node_modules/zustand": {
-      "version": "4.5.7",
-      "resolved": "https://registry.npmjs.org/zustand/-/zustand-4.5.7.tgz",
-      "integrity": "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw==",
+    "node_modules/workbox-core": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-core/-/workbox-core-7.4.1.tgz",
+      "integrity": "sha512-DT+vu46eh/2vRsSHTY4Xmc32Z1rr9PRlQUXr1Dx30ZuXRWwOsvZgGgcwxcasubQLQmbTNYZjv44LkBAQ4tT5tQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/workbox-expiration": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-expiration/-/workbox-expiration-7.4.1.tgz",
+      "integrity": "sha512-lRKUF7b+OGbeXkQk1s6MHXOa3d7Xxf7Of31W6c6hCfipfIyrtdWZ89stq21AHZMaoG7VNFoHply4Ox+rU31TWg==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "use-sync-external-store": "^1.2.2"
-      },
-      "engines": {
-        "node": ">=12.7.0"
-      },
-      "peerDependencies": {
-        "@types/react": ">=16.8",
-        "immer": ">=9.0.6",
-        "react": ">=16.8"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "immer": {
-          "optional": true
-        },
-        "react": {
-          "optional": true
-        }
+        "idb": "^7.0.1",
+        "workbox-core": "7.4.1"
       }
     },
-    "node_modules/type-check": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
-      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+    "node_modules/workbox-google-analytics": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-google-analytics/-/workbox-google-analytics-7.4.1.tgz",
+      "integrity": "sha512-Mks1JwLEt++ZAkF6sS1OpSh9RtAMIsiDgRpK+codiHGIPXeaUOgi4cPc3GFadUl8V5QPeypEk8Oxgl3HlwVzHw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "prelude-ls": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
+        "workbox-background-sync": "7.4.1",
+        "workbox-core": "7.4.1",
+        "workbox-routing": "7.4.1",
+        "workbox-strategies": "7.4.1"
       }
     },
-    "node_modules/typescript": {
-      "version": "5.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
-      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+    "node_modules/workbox-navigation-preload": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-navigation-preload/-/workbox-navigation-preload-7.4.1.tgz",
+      "integrity": "sha512-C4KVsjPcYKJOhr631AxR9XoG2rLF3QiTk5aMv36MXOjtWvm8axwNFAtKUPGsWUwLXXAMgYM1En7fsvndaXeXRQ==",
       "dev": true,
-      "license": "Apache-2.0",
-      "peer": true,
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
+      "license": "MIT",
+      "dependencies": {
+        "workbox-core": "7.4.1"
       }
     },
-    "node_modules/typescript-eslint": {
-      "version": "8.53.1",
-      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.53.1.tgz",
-      "integrity": "sha512-gB+EVQfP5RDElh9ittfXlhZJdjSU4jUSTyE2+ia8CYyNvet4ElfaLlAIqDvQV9JPknKx0jQH1racTYe/4LaLSg==",
+    "node_modules/workbox-precaching": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-precaching/-/workbox-precaching-7.4.1.tgz",
+      "integrity": "sha512-cdr/9qByww7yzEp7zg/qI4ukUrrNjQLgN+ONQRpjy/VqGQXwkgHwr00KksGJK8v0VifwDXBb8a4cWNZH71jn3Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/eslint-plugin": "8.53.1",
-        "@typescript-eslint/parser": "8.53.1",
-        "@typescript-eslint/typescript-estree": "8.53.1",
-        "@typescript-eslint/utils": "8.53.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "workbox-core": "7.4.1",
+        "workbox-routing": "7.4.1",
+        "workbox-strategies": "7.4.1"
       }
     },
-    "node_modules/undici-types": {
-      "version": "7.16.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
-      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/update-browserslist-db": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
-      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+    "node_modules/workbox-range-requests": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-range-requests/-/workbox-range-requests-7.4.1.tgz",
+      "integrity": "sha512-7i2oxAUE82gHdAJBCAQ04JzNOdRPqzuOzGfoUyJpFSmeqBNYGPrAH8GPoPjUQTfp+NycwrD2H68VtuF8qxv0vQ==",
       "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
       "license": "MIT",
       "dependencies": {
-        "escalade": "^3.2.0",
-        "picocolors": "^1.1.1"
-      },
-      "bin": {
-        "update-browserslist-db": "cli.js"
-      },
-      "peerDependencies": {
-        "browserslist": ">= 4.21.0"
+        "workbox-core": "7.4.1"
       }
     },
-    "node_modules/uri-js": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
-      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+    "node_modules/workbox-recipes": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-recipes/-/workbox-recipes-7.4.1.tgz",
+      "integrity": "sha512-gnbVfmV4/TtmQaM4x9AtuXhcdstJsep3XMVeztOrQVPT+R6+6DeBjGTCQ7fFCXm+4GEHUA5VEBTyi5+4gWGeog==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "license": "MIT",
       "dependencies": {
-        "punycode": "^2.1.0"
+        "workbox-cacheable-response": "7.4.1",
+        "workbox-core": "7.4.1",
+        "workbox-expiration": "7.4.1",
+        "workbox-precaching": "7.4.1",
+        "workbox-routing": "7.4.1",
+        "workbox-strategies": "7.4.1"
       }
     },
-    "node_modules/use-sync-external-store": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz",
-      "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==",
+    "node_modules/workbox-routing": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-routing/-/workbox-routing-7.4.1.tgz",
+      "integrity": "sha512-yubJGErZOusuidAenaL5ypfhQOa7urxP/f8E0ws7FPb4039RiWXUWBAyUkmUoOL/BcQGen3h0J8872d51IYxtA==",
+      "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      "dependencies": {
+        "workbox-core": "7.4.1"
       }
     },
-    "node_modules/utility-types": {
-      "version": "3.11.0",
-      "resolved": "https://registry.npmjs.org/utility-types/-/utility-types-3.11.0.tgz",
-      "integrity": "sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw==",
+    "node_modules/workbox-strategies": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-strategies/-/workbox-strategies-7.4.1.tgz",
+      "integrity": "sha512-GZxpaw9NbmOelj7667uZ2kpk5BFpOGbO4X0qjwh5ls8XQ8C+Lha5LQchTiUzsTFSS+NlUpftYAyOVXvQUrcqOQ==",
+      "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">= 4"
+      "dependencies": {
+        "workbox-core": "7.4.1"
       }
     },
-    "node_modules/vite": {
-      "version": "7.3.1",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
-      "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
+    "node_modules/workbox-streams": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-streams/-/workbox-streams-7.4.1.tgz",
+      "integrity": "sha512-HWWtraKUbJknd9kgqGcpQ3G114HOPYvqs8HaJMDs2ebLNAimDkVDaWfAXE6Ybl+m8U6KsCE6pWyLYuigWmnAXw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "esbuild": "^0.27.0",
-        "fdir": "^6.5.0",
-        "picomatch": "^4.0.3",
-        "postcss": "^8.5.6",
-        "rollup": "^4.43.0",
-        "tinyglobby": "^0.2.15"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      },
-      "funding": {
-        "url": "https://github.com/vitejs/vite?sponsor=1"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      },
-      "peerDependencies": {
-        "@types/node": "^20.19.0 || >=22.12.0",
-        "jiti": ">=1.21.0",
-        "less": "^4.0.0",
-        "lightningcss": "^1.21.0",
-        "sass": "^1.70.0",
-        "sass-embedded": "^1.70.0",
-        "stylus": ">=0.54.8",
-        "sugarss": "^5.0.0",
-        "terser": "^5.16.0",
-        "tsx": "^4.8.1",
-        "yaml": "^2.4.2"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "jiti": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "sass-embedded": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        },
-        "tsx": {
-          "optional": true
-        },
-        "yaml": {
-          "optional": true
-        }
+        "workbox-core": "7.4.1",
+        "workbox-routing": "7.4.1"
       }
     },
-    "node_modules/webgl-constants": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/webgl-constants/-/webgl-constants-1.1.1.tgz",
-      "integrity": "sha512-LkBXKjU5r9vAW7Gcu3T5u+5cvSvh5WwINdr0C+9jpzVB41cjQAP5ePArDtk/WHYdVj0GefCgM73BA7FlIiNtdg=="
-    },
-    "node_modules/webgl-sdf-generator": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/webgl-sdf-generator/-/webgl-sdf-generator-1.1.1.tgz",
-      "integrity": "sha512-9Z0JcMTFxeE+b2x1LJTdnaT8rT8aEp7MVxkNwoycNmJWwPdzoXzMh0BjJSh/AEFP+KPYZUli814h8bJZFIZ2jA==",
+    "node_modules/workbox-sw": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-sw/-/workbox-sw-7.4.1.tgz",
+      "integrity": "sha512-fez5f2DUlDJWTFYkCWQpY10N8gtztd849NswCbVFk0QlcSM4HT5A8x4g4ii650yem4I8tHY0R7JZahwp3ltIPw==",
+      "dev": true,
       "license": "MIT"
     },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "license": "ISC",
+    "node_modules/workbox-window": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-window/-/workbox-window-7.4.1.tgz",
+      "integrity": "sha512-notZDH2u8VXaqyuD7xaqIfEFi6SRM4SUSd7ewe9PDsVqADuepxX2ZMY3uvuZGxzY5ZOsGC/vD3A/3smFtJt4/A==",
+      "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "node-which": "bin/node-which"
-      },
-      "engines": {
-        "node": ">= 8"
+        "@types/trusted-types": "^2.0.2",
+        "workbox-core": "7.4.1"
       }
     },
-    "node_modules/word-wrap": {
-      "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
-      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
       "dev": true,
-      "license": "MIT",
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">=18"
       }
     },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/yallist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
@@ -3967,7 +9364,6 @@
       "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }
@@ -3984,35 +9380,6 @@
       "peerDependencies": {
         "zod": "^3.25.0 || ^4.0.0"
       }
-    },
-    "node_modules/zustand": {
-      "version": "5.0.10",
-      "resolved": "https://registry.npmjs.org/zustand/-/zustand-5.0.10.tgz",
-      "integrity": "sha512-U1AiltS1O9hSy3rul+Ub82ut2fqIAefiSuwECWt6jlMVUGejvf+5omLcRBSzqbRagSM3hQZbtzdeRc6QVScXTg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.20.0"
-      },
-      "peerDependencies": {
-        "@types/react": ">=18.0.0",
-        "immer": ">=9.0.6",
-        "react": ">=18.0.0",
-        "use-sync-external-store": ">=1.2.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "immer": {
-          "optional": true
-        },
-        "react": {
-          "optional": true
-        },
-        "use-sync-external-store": {
-          "optional": true
-        }
-      }
     }
   }
 }
diff --git a/frontend/package.json b/frontend/package.json
index 7aef569..7f26c2e 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -5,23 +5,25 @@
   "type": "module",
   "scripts": {
     "dev": "node ../scripts/sync-chapters.mjs && vite",
-    "build": "node ../scripts/sync-chapters.mjs && tsc -b && vite build",
+    "build": "node ../scripts/sync-chapters.mjs && tsc -b && eslint . && vite build",
     "lint": "eslint .",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
-    "@react-three/drei": "^10.7.7",
-    "@react-three/fiber": "^9.5.0",
-    "@types/three": "^0.182.0",
     "framer-motion": "^12.29.0",
     "lucide-react": "^0.563.0",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
-    "react-router-dom": "^7.13.0",
-    "three": "^0.182.0"
+    "react-router-dom": "^7.13.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
+    "@tailwindcss/vite": "^4.3.3",
+    "@testing-library/jest-dom": "^7.0.1",
+    "@testing-library/react": "^16.3.3",
+    "@testing-library/user-event": "^14.6.8",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.5",
     "@types/react-dom": "^19.2.3",
@@ -30,8 +32,12 @@
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
+    "jsdom": "^30.1.3",
+    "tailwindcss": "^4.3.3",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.46.4",
-    "vite": "^7.2.4"
+    "vite": "^7.2.4",
+    "vite-plugin-pwa": "^2.0.0",
+    "vitest": "^3.2.7"
   }
 }
diff --git a/frontend/public/data/books/ch1.json b/frontend/public/data/books/ch1.json
index beda312..f52416c 100644
--- a/frontend/public/data/books/ch1.json
+++ b/frontend/public/data/books/ch1.json
@@ -1,5285 +1,4727 @@
 [
-  {
-    "qsns": "Which of the following best describes Ohm's Law?",
-    "opt1": "The relationship between voltage and power",
-    "opt2": "The relationship between current and resistance",
-    "opt3": "The relationship between voltage and current",
-    "opt4": "The relationship between resistance and power",
-    "correct_option": "The relationship between voltage and current",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the unit of electrical resistance?",
-    "opt1": "Volt",
-    "opt2": "Ampere",
-    "opt3": "Watt",
-    "opt4": "Ohm",
-    "correct_option": "Ohm",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a correct expression of Ohm's Law?",
-    "opt1": "I=VR",
-    "opt2": "R=VI",
-    "opt3": "V=IR",
-    "opt4": "R=IV",
-    "correct_option": "V=IR",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "A circuit has a voltage of 12 volts and a resistance of 4 ohms. What is the current flowing through the circuit?",
-    "opt1": "48 amps",
-    "opt2": "8 amps",
-    "opt3": "4 amps",
-    "opt4": "3 amps",
-    "correct_option": "3 amps",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "If the voltage across a circuit remains constant and the resistance decreases, what happens to the current?",
-    "opt1": "It increases",
-    "opt2": "It decreases",
-    "opt3": "It stays the same",
-    "opt4": "It is impossible to determine without more information",
-    "correct_option": "It increases",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following materials has the highest electrical resistance?",
-    "opt1": "Copper",
-    "opt2": "Silver",
-    "opt3": "Aluminum",
-    "opt4": "Nichrome",
-    "correct_option": "Nichrome",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "A circuit has a resistance of 10 ohms and a current of 2 amps. What is the voltage across the circuit?",
-    "opt1": "5 volts",
-    "opt2": "10 volts",
-    "opt3": "20 volts",
-    "opt4": "40 volts",
-    "correct_option": "20 volts",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is an example of a non-ohmic conductor?",
-    "opt1": "Copper wire",
-    "opt2": "Silver wire",
-    "opt3": "Light bulb filament",
-    "opt4": "Carbon resistor",
-    "correct_option": "Light bulb filament",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What happens to the current in a circuit if the voltage is doubled while the resistance remains constant?",
-    "opt1": "It is halved",
-    "opt2": "It is doubled",
-    "opt3": "It remains the same",
-    "opt4": "It is impossible to determine without more information",
-    "correct_option": "It is doubled",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "A circuit has a voltage of 20 volts and a current of 4 amps. What is the resistance of the circuit?",
-    "opt1": "16 ohms",
-    "opt2": "8 ohms",
-    "opt3": "5 ohms",
-    "opt4": "80 ohms",
-    "correct_option": "5 ohms",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a characteristic of a good conductor?",
-    "opt1": "High resistance",
-    "opt2": "Low resistance",
-    "opt3": "High voltage",
-    "opt4": "Low voltage",
-    "correct_option": "Low resistance",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following materials has the lowest electrical resistance?",
-    "opt1": "Aluminum",
-    "opt2": "Gold",
-    "opt3": "Copper",
-    "opt4": "Silver",
-    "correct_option": "Silver",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What happens to the current in a circuit if the resistance is doubled while the voltage remains constant?",
-    "opt1": "It is halved",
-    "opt2": "It is doubled",
-    "opt3": "It remains the same",
-    "opt4": "It is impossible to determine without more information",
-    "correct_option": "It is halved",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the relationship between current and voltage in a circuit with a constant resistance?",
-    "opt1": "They are directly proportional",
-    "opt2": "They are inversely proportional",
-    "opt3": "They are not related",
-    "opt4": "It is impossible to determine without more information",
-    "correct_option": "They are directly proportional",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is electric voltage?",
-    "opt1": "The flow of electric charge through a conductor",
-    "opt2": "The measure of electric potential energy per unit charge between two points in an electric circuit",
-    "opt3": "The resistance of a conductor",
-    "opt4": "The unit of electric voltage",
-    "correct_option": "The measure of electric potential energy per unit charge between two points in an electric circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is electric current?",
-    "opt1": "The measure of the electric potential energy per unit charge between two points in an electric circuit",
-    "opt2": "The flow of electric charge through a conductor",
-    "opt3": "The resistance of a conductor to the flow of electric charge",
-    "opt4": "The measure of resistivity of a conductor",
-    "correct_option": "The flow of electric charge through a conductor",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the unit of electric voltage?",
-    "opt1": "Ampere (A)",
-    "opt2": "Watt (W)",
-    "opt3": "Volt (V)",
-    "opt4": "Ohm (Ω)",
-    "correct_option": "Volt (V)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the unit of electric current?",
-    "opt1": "Amperes",
-    "opt2": "Watts",
-    "opt3": "Volts",
-    "opt4": "Coulombs",
-    "correct_option": "Amperes",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the relationship between voltage and current according to Ohm's Law?",
-    "opt1": "Voltage is inversely proportional to current",
-    "opt2": "Voltage is directly proportional to current",
-    "opt3": "Voltage is not related to current",
-    "opt4": "Voltage is directly proportional to square of current",
-    "correct_option": "Voltage is directly proportional to current",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What instrument is used to measure electric current in a circuit?",
-    "opt1": "Voltmeter",
-    "opt2": "Ammeter",
-    "opt3": "Oscilloscope",
-    "opt4": "Galvanometer",
-    "correct_option": "Ammeter",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is power?",
-    "opt1": "The rate at which energy is transferred in an electric circuit",
-    "opt2": "The capacity of a system to do work",
-    "opt3": "The unit of energy",
-    "opt4": "Energy per unit area",
-    "correct_option": "The rate at which energy is transferred in an electric circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the unit of power?",
-    "opt1": "Amperes",
-    "opt2": "Volts",
-    "opt3": "Watts",
-    "opt4": "Coulombs",
-    "correct_option": "Watts",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the formula for calculating power in an electric circuit?",
-    "opt1": "P=V+I",
-    "opt2": "P=VI",
-    "opt3": "P=IR",
-    "opt4": "P=V/I",
-    "correct_option": "P=VI",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the formula for calculating power when resistance is known?",
-    "opt1": "P=V+I",
-    "opt2": "P=V",
-    "opt3": "P=I^2R",
-    "opt4": "P=I^2R^2",
-    "correct_option": "P=I^2R",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is energy?",
-    "opt1": "The rate at which energy is transferred in an electric circuit",
-    "opt2": "The capacity of a system to do work",
-    "opt3": "The unit of power",
-    "opt4": "Work done per unit area",
-    "correct_option": "The capacity of a system to do work",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the unit of energy?",
-    "opt1": "Amperes",
-    "opt2": "Joules",
-    "opt3": "Watts",
-    "opt4": "Coulombs",
-    "correct_option": "Joules",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the formula for calculating energy transferred in an electric circuit?",
-    "opt1": "E=V",
-    "opt2": "E=P",
-    "opt3": "E=IR",
-    "opt4": "E=Pt",
-    "correct_option": "E=Pt",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the formula for calculating power if the current and resistance are known?",
-    "opt1": "P=I^2R",
-    "opt2": "P=IV",
-    "opt3": "P=IR",
-    "opt4": "P=I^2R^2",
-    "correct_option": "P=I^2R",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following materials is an example of a conducting material?",
-    "opt1": "Glass",
-    "opt2": "Rubber",
-    "opt3": "Copper",
-    "opt4": "Plastic",
-    "correct_option": "Copper",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the resistivity of a conducting material?",
-    "opt1": "The resistance of a material of unit length and unit cross-sectional area",
-    "opt2": "The maximum voltage that the material can withstand before it breaks down",
-    "opt3": "The ability of a material to prevent the flow of electric current",
-    "opt4": "All of above",
-    "correct_option": "The resistance of a material of unit length and unit cross-sectional area",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following materials is an example of an insulating material?",
-    "opt1": "Copper",
-    "opt2": "Plastic",
-    "opt3": "Silver",
-    "opt4": "both a and b",
-    "correct_option": "Plastic",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the dielectric strength of an insulating material?",
-    "opt1": "The resistance of a material of unit length and unit cross-sectional area",
-    "opt2": "The ability of a material to prevent the flow of electric current",
-    "opt3": "The maximum voltage that the material can withstand before it breaks down",
-    "opt4": "None of above",
-    "correct_option": "The maximum voltage that the material can withstand before it breaks down",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What are semiconducting materials?",
-    "opt1": "Materials that have properties between those of conducting and insulating materials",
-    "opt2": "Materials that allow electric current to flow through them easily",
-    "opt3": "Materials that do not allow electric current to flow through them easily",
-    "opt4": "All of above",
-    "correct_option": "Materials that have properties between those of conducting and insulating materials",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following materials is commonly used in electronic devices?",
-    "opt1": "Silicon",
-    "opt2": "Rubber",
-    "opt3": "Glass",
-    "opt4": "Steel",
-    "correct_option": "Silicon",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the process of controlling the conductivity of a semiconducting material called?",
-    "opt1": "Doping",
-    "opt2": "Refracting",
-    "opt3": "Conducting",
-    "opt4": "Insulating",
-    "correct_option": "Doping",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of insulating materials in electrical circuits?",
-    "opt1": "To separate conductors and prevent the flow of electric current to unintended locations",
-    "opt2": "To connect components",
-    "opt3": "To provide a path for the flow of electric current",
-    "opt4": "None of above",
-    "correct_option": "To separate conductors and prevent the flow of electric current to unintended locations",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In a series circuit, which of the following statements is true?",
-    "opt1": "The components are connected across each other in multiple paths.",
-    "opt2": "The same current flows through each component.",
-    "opt3": "The total resistance is less than the individual resistances of the components",
-    "opt4": "All of above",
-    "correct_option": "The same current flows through each component.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits has a total resistance that is less than the individual resistances of the components?",
-    "opt1": "Series circuit",
-    "opt2": "Parallel circuit",
-    "opt3": "Series-parallel circuit",
-    "opt4": "both b and c",
-    "correct_option": "Parallel circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a series circuit, if the resistance of one component increases, what happens to the total resistance of the circuit?",
-    "opt1": "It decreases",
-    "opt2": "It increases",
-    "opt3": "It stays the same",
-    "opt4": "First increases then stays same",
-    "correct_option": "It increases",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a parallel circuit, if the resistance of one component increases, what happens to the total resistance of the circuit?",
-    "opt1": "It decreases",
-    "opt2": "It increases",
-    "opt3": "It stays the same",
-    "opt4": "First increases then stays same",
-    "correct_option": "It increases",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits is used in applications where voltage regulation is required?",
-    "opt1": "Series circuit",
-    "opt2": "Parallel circuit",
-    "opt3": "Series-parallel circuit",
-    "opt4": "None of above",
-    "correct_option": "Parallel circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits is used in applications where current limiting is required?",
-    "opt1": "Series circuit",
-    "opt2": "Parallel circuit",
-    "opt3": "Series-parallel circuit",
-    "opt4": "None of above",
-    "correct_option": "Series circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In a series-parallel circuit, which components are connected in series?",
-    "opt1": "No components",
-    "opt2": "All components",
-    "opt3": "Some components",
-    "opt4": "Both a and b",
-    "correct_option": "Some components",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following circuits is more reliable in terms of component failure?",
-    "opt1": "Series circuit",
-    "opt2": "Parallel circuit",
-    "opt3": "Both circuits are equally reliable",
-    "opt4": "Series-parallel circuit",
-    "correct_option": "Parallel circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What happens to the current in a parallel circuit if one component fails?",
-    "opt1": "The current through the other components increases.",
-    "opt2": "The current through the other components decreases.",
-    "opt3": "The current through the other components stays the same.",
-    "opt4": "First Increases then stays same",
-    "correct_option": "The current through the other components stays the same.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What Is the total resistance of a series circuit?",
-    "opt1": "The sum of the individual conductance's",
-    "opt2": "The sum of the individual resistances",
-    "opt3": "The reciprocal of the sum of the individual resistances",
-    "opt4": "sum of square of individual resistances",
-    "correct_option": "The sum of the individual resistances",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a parallel circuit, each component has the same:",
-    "opt1": "Current flowing through it",
-    "opt2": "Voltage across it",
-    "opt3": "Same power consumed",
-    "opt4": "Energy consumed",
-    "correct_option": "Voltage across it",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What Is the total resistance of a parallel circuit?",
-    "opt1": "Sum of the individual conductance's",
-    "opt2": "Sum of the individual resistances",
-    "opt3": "Reciprocal of the sum of the individual resistances",
-    "opt4": "Sum of reciprocal of individual conductance",
-    "correct_option": "Sum of the individual conductance's",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of star-delta conversion?",
-    "opt1": "To reduce the starting current of a motor",
-    "opt2": "To increase the starting current of a motor",
-    "opt3": "To regulate the voltage levels of a three-phase supply",
-    "opt4": "All of above",
-    "correct_option": "To reduce the starting current of a motor",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In which type of circuit is delta-star conversion commonly used?",
-    "opt1": "Motor control circuits",
-    "opt2": "Power distribution systems",
-    "opt3": "Generator",
-    "opt4": "Both a and b",
-    "correct_option": "Power distribution systems",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of delta-star conversion?",
-    "opt1": "To reduce the starting current of a motor",
-    "opt2": "To increase the starting current of a motor",
-    "opt3": "To regulate the voltage levels of a three-phase supply",
-    "opt4": "None of above",
-    "correct_option": "To regulate the voltage levels of a three-phase supply",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the difference between a star and delta configuration in a three-phase system?",
-    "opt1": "In a star configuration, the three phases are connected in a closed loop, while in a delta configuration, the three phases are connected to a common point or neutral.",
-    "opt2": "In a star configuration, the three phases are connected to a common point or neutral, while in a delta configuration, the three phases are connected in a closed loop.",
-    "opt3": "There is no difference between a star and delta configuration in a three-phase system.",
-    "opt4": "None of above",
-    "correct_option": "In a star configuration, the three phases are connected to a common point or neutral, while in a delta configuration, the three phases are connected in a closed loop.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a star-delta conversion, what is re-arranged?",
-    "opt1": "The voltage levels of the three-phase supply",
-    "opt2": "The connections between the components of the circuit",
-    "opt3": "The starting current of a motor",
-    "opt4": "None of above",
-    "correct_option": "The connections between the components of the circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of conversion is commonly used in motor control circuits?",
-    "opt1": "Star-delta conversion",
-    "opt2": "Delta-star conversion",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Star-delta conversion",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of conversion is commonly used in power distribution systems?",
-    "opt1": "Star-delta conversion",
-    "opt2": "Delta-star conversion",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Delta-star conversion",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the primary advantage of using star-delta conversion in motor control circuits?",
-    "opt1": "It increases the starting current of the motor",
-    "opt2": "It reduces the starting current of the motor",
-    "opt3": "It regulates the voltage levels of the three-phase supply",
-    "opt4": "All of above",
-    "correct_option": "It reduces the starting current of the motor",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the primary advantage of using delta-star conversion in power distribution systems?",
-    "opt1": "It increases the voltage levels of the three-phase supply",
-    "opt2": "It reduces the voltage levels of the three-phase supply",
-    "opt3": "It regulates the voltage levels of the three-phase supply",
-    "opt4": "None of above",
-    "correct_option": "It regulates the voltage levels of the three-phase supply",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of conversion is used to regulate the voltage levels of a three-phase supply?",
-    "opt1": "Star-delta conversion",
-    "opt2": "Delta-star conversion",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Delta-star conversion",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of star-delta conversion?",
-    "opt1": "To convert a three-phase system from a delta to a star configuration",
-    "opt2": "To reduce the starting current of a motor",
-    "opt3": "To regulate the voltage levels of a power distribution system",
-    "opt4": "None of above",
-    "correct_option": "To reduce the starting current of a motor",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of delta-star conversion?",
-    "opt1": "To convert a three-phase system from a star to a delta configuration",
-    "opt2": "To reduce the starting current of a motor",
-    "opt3": "To regulate the voltage levels of a power distribution system",
-    "opt4": "None of above",
-    "correct_option": "To regulate the voltage levels of a power distribution system",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following connections is used in a star configuration?",
-    "opt1": "The three phases are connected in a closed loop",
-    "opt2": "The three phases are connected to a common point or neutral",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "The three phases are connected to a common point or neutral",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following connections is used in a delta configuration?",
-    "opt1": "The three phases are connected in a closed loop",
-    "opt2": "The three phases are connected to a common point or neutral",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "The three phases are connected in a closed loop",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of conversion is commonly used in motor control circuits?",
-    "opt1": "Star-delta conversion",
-    "opt2": "Delta-star conversion",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Star-delta conversion",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of conversion is commonly used in power distribution systems?",
-    "opt1": "Star-delta conversion",
-    "opt2": "Delta-star conversion",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Delta-star conversion",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the primary benefit of star-delta conversion in motor control circuits?",
-    "opt1": "It reduces the voltage levels",
-    "opt2": "It reduces the starting current of the motor",
-    "opt3": "It increases the speed of the motor",
-    "opt4": "None of above",
-    "correct_option": "It reduces the starting current of the motor",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the primary benefit of delta-star conversion in power distribution systems?",
-    "opt1": "It reduces the voltage levels",
-    "opt2": "It regulates the voltage levels of the system",
-    "opt3": "It reduces the current levels",
-    "opt4": "It increases the voltage levels",
-    "correct_option": "It regulates the voltage levels of the system",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the process involved in converting a three-phase system from a star to a delta configuration?",
-    "opt1": "Re-arranging the connections between the components of the circuit",
-    "opt2": "Replacing the components of the circuit",
-    "opt3": "Increasing the voltage levels of the system",
-    "opt4": "None of above",
-    "correct_option": "Re-arranging the connections between the components of the circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the process involved in converting a three-phase system from a delta to a star configuration?",
-    "opt1": "Re-arranging the connections between the components of the circuit",
-    "opt2": "Replacing the components of the circuit",
-    "opt3": "Decreasing the voltage levels of the system",
-    "opt4": "None of above",
-    "correct_option": "Re-arranging the connections between the components of the circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is Kirchhoff's Current Law?",
-    "opt1": "The sum of voltages around a closed loop is zero",
-    "opt2": "The total current entering a node is equal to the total current leaving that node",
-    "opt3": "The sum of currents around a closed loop is zero",
-    "opt4": "Both a and b",
-    "correct_option": "The total current entering a node is equal to the total current leaving that node",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is Kirchhoff's Voltage Law?",
-    "opt1": "The sum of voltages around a closed loop is zero",
-    "opt2": "The total current entering a node is equal to the total current leaving that node",
-    "opt3": "The sum of currents around a closed loop is zero",
-    "opt4": "Both a and c",
-    "correct_option": "The sum of voltages around a closed loop is zero",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the principle on which Kirchhoff's Current Law is based?",
-    "opt1": "Conservation of energy",
-    "opt2": "Conservation of charge",
-    "opt3": "Conservation of power",
-    "opt4": "Conservation of Potential",
-    "correct_option": "Conservation of charge",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the principle on which Kirchhoff's Voltage Law is based?",
-    "opt1": "Conservation of energy",
-    "opt2": "Conservation of charge",
-    "opt3": "Conservation of power",
-    "opt4": "Conservation of Potential",
-    "correct_option": "Conservation of energy",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of using Kirchhoff's laws in circuit analysis?",
-    "opt1": "To predict the behavior of electrical circuits",
-    "opt2": "To determine the currents and voltages in a circuit",
-    "opt3": "To analyze current flow and voltage drops in circuit",
-    "opt4": "All of above",
-    "correct_option": "All of above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What type of circuits can be analyzed using Kirchhoff's laws?",
-    "opt1": "Series circuits",
-    "opt2": "Parallel circuits",
-    "opt3": "Complex circuits",
-    "opt4": "Both a and b",
-    "correct_option": "Both a and b",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the algebraic sum of the currents at a node according to Kirchhoff's Current Law?",
-    "opt1": "Always zero",
-    "opt2": "Always positive",
-    "opt3": "Always negative",
-    "opt4": "Always 1",
-    "correct_option": "Always zero",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the algebraic sum of the voltage drops across all the components in a loop according to Kirchhoff's Voltage Law?",
-    "opt1": "Always zero",
-    "opt2": "Always positive",
-    "opt3": "Always negative",
-    "opt4": "Always 1",
-    "correct_option": "Always zero",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can Kirchhoff's laws be used to identify problems in a circuit?",
-    "opt1": "Yes",
-    "opt2": "No",
-    "opt3": "Sometimes",
-    "opt4": "Most of times",
-    "correct_option": "Yes",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Why is understanding Kirchhoff's laws important in electrical and electronics engineering?",
-    "opt1": "To design and troubleshoot electrical circuits",
-    "opt2": "To predict the behavior of electrical circuits",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Both a and b",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Kirchhoff's current law is based on the principle of:",
-    "opt1": "Conservation of energy",
-    "opt2": "Conservation of charge",
-    "opt3": "Conservation of power",
-    "opt4": "Conservation of Potential",
-    "correct_option": "Conservation of charge",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Kirchhoff's voltage law is based on the principle of:",
-    "opt1": "Conservation of energy",
-    "opt2": "Conservation of charge",
-    "opt3": "Conservation of power",
-    "opt4": "Conservation of Potential",
-    "correct_option": "Conservation of energy",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Kirchhoff's current law states that the total current entering a node is:",
-    "opt1": "Greater than the total current leaving the node",
-    "opt2": "Equal to the total current leaving the node",
-    "opt3": "Less than the total current leaving the node",
-    "opt4": "None of above",
-    "correct_option": "Equal to the total current leaving the node",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Kirchhoff's voltage law states that the sum of the voltages around any closed loop in a circuit is:",
-    "opt1": "Equal to zero",
-    "opt2": "Greater than zero",
-    "opt3": "Less than zero",
-    "opt4": "Equal to 1",
-    "correct_option": "Equal to zero",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Kirchhoff's laws are fundamental laws in:",
-    "opt1": "Electrical circuit analysis",
-    "opt2": "Mechanical engineering",
-    "opt3": "Civil engineering",
-    "opt4": "All of above",
-    "correct_option": "Electrical circuit analysis",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "A linear circuit is one where the output response is:",
-    "opt1": "Directly proportional to the input signal",
-    "opt2": "Inversely proportional to the input signal",
-    "opt3": "Not related to the input signal",
-    "opt4": "None of above",
-    "correct_option": "Directly proportional to the input signal",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Non-linear circuits do not follow a simple scaling rule, meaning that:",
-    "opt1": "The input and output signals are directly proportional",
-    "opt2": "The input and output signals are inversely proportional",
-    "opt3": "The relationship between the input and output signals may be more complex",
-    "opt4": "None of above",
-    "correct_option": "The relationship between the input and output signals may be more complex",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Linear circuits are easy to analyze using mathematical tools such as:",
-    "opt1": "Kirchhoff's laws and Ohm's law",
-    "opt2": "Differential equations and Laplace transforms",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Kirchhoff's laws and Ohm's law",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Non-linear circuits often exhibit a threshold voltage or current, beyond which:",
-    "opt1": "The output response becomes distorted or unpredictable",
-    "opt2": "The output response becomes directly proportional to the input signal",
-    "opt3": "The output response remains constant",
-    "opt4": "All of above",
-    "correct_option": "The output response becomes distorted or unpredictable",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following circuits is an example of a non-linear circuit?",
-    "opt1": "Resistor-capacitor circuit",
-    "opt2": "Op-amp circuit",
-    "opt3": "Diode rectifier circuit",
-    "opt4": "All of above",
-    "correct_option": "Diode rectifier circuit",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "In a non-linear circuit, the relationship between the input and output signals may be more complex, meaning that:",
-    "opt1": "The circuit is always unstable",
-    "opt2": "The circuit is difficult to analyze",
-    "opt3": "The circuit is easy to analyze",
-    "opt4": "None of above",
-    "correct_option": "The circuit is difficult to analyze",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Linear circuits are often used in:",
-    "opt1": "Simple electronic devices",
-    "opt2": "Advanced electronic devices",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Simple electronic devices",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Non-linear circuits are often used in:",
-    "opt1": "Simple electronic devices",
-    "opt2": "Advanced electronic devices",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Advanced electronic devices",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a linear circuit, the output response is directly proportional to the input signal, meaning that if the input signal is doubled:",
-    "opt1": "The output signal will be halved",
-    "opt2": "The output signal will be doubled",
-    "opt3": "The output signal will not change",
-    "opt4": "The output signal will remain same",
-    "correct_option": "The output signal will be doubled",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following mathematical tools can be used to analyze linear circuits?",
-    "opt1": "Kirchhoff's laws",
-    "opt2": "Differential equations",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Both A and B",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following circuits is an example of a non-linear circuit?",
-    "opt1": "Resistor-capacitor circuit",
-    "opt2": "Op-amp circuit",
-    "opt3": "Diode rectifier circuit",
-    "opt4": "All of above",
-    "correct_option": "Diode rectifier circuit",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of circuit is easier to analyze using mathematical tools like Kirchhoff's laws?",
-    "opt1": "Linear circuit",
-    "opt2": "Non-linear circuit",
-    "opt3": "Both a and b are equally easier",
-    "opt4": "none of above circuit can be analyzed",
-    "correct_option": "Linear circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following techniques is often used to analyze non-linear circuits?",
-    "opt1": "Nodal analysis",
-    "opt2": "Mesh analysis",
-    "opt3": "Nonlinear circuit analysis",
-    "opt4": "Both b and c",
-    "correct_option": "Nonlinear circuit analysis",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What happens to the output response of a non-linear circuit when the input signal is too large or too small?",
-    "opt1": "It becomes distorted or unpredictable.",
-    "opt2": "It remains constant.",
-    "opt3": "It becomes linear",
-    "opt4": "It becomes diminished.",
-    "correct_option": "It becomes distorted or unpredictable.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuit is commonly found in applications such as amplifiers and oscillators?",
-    "opt1": "Linear circuit",
-    "opt2": "Non-linear circuit",
-    "opt3": "Both types of circuits are equally common",
-    "opt4": "None of above",
-    "correct_option": "Non-linear circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the main difference between linear and non-linear circuits?",
-    "opt1": "Linear circuits have a predictable output response, while non-linear circuits do not",
-    "opt2": "Non-linear circuits follow a simple scaling rule, while linear circuits do not",
-    "opt3": "Both types of circuits behave in exactly the same way.",
-    "opt4": "None of above",
-    "correct_option": "Linear circuits have a predictable output response, while non-linear circuits do not",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is an example of a linear circuit element?",
-    "opt1": "Diode",
-    "opt2": "Capacitor",
-    "opt3": "Resistor",
-    "opt4": "Both a and c",
-    "correct_option": "Resistor",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is an example of a non-linear circuit element?",
-    "opt1": "Diode",
-    "opt2": "Inductor",
-    "opt3": "Resistor",
-    "opt4": "Both a and c",
-    "correct_option": "Diode",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuit is more commonly used in digital electronics?",
-    "opt1": "Linear circuit",
-    "opt2": "Non-linear circuit",
-    "opt3": "Both types of circuits are equally common",
-    "opt4": "both a and b not used at all",
-    "correct_option": "Linear circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuit requires AC analysis techniques?",
-    "opt1": "Bilateral circuits",
-    "opt2": "Unilateral circuits",
-    "opt3": "Both bilateral and unilateral circuits",
-    "opt4": "None of the above",
-    "correct_option": "Bilateral circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which circuit element is an example of a unilateral element?",
-    "opt1": "Resistor",
-    "opt2": "Capacitor",
-    "opt3": "Inductor",
-    "opt4": "Diode",
-    "correct_option": "Diode",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which type of circuit can be analyzed using only DC circuit analysis techniques?",
-    "opt1": "Bilateral circuits",
-    "opt2": "Unilateral circuits",
-    "opt3": "Both bilateral and unilateral circuits",
-    "opt4": "None of the above",
-    "correct_option": "Bilateral circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is another name for bilateral circuits?",
-    "opt1": "Asymmetric circuits",
-    "opt2": "Unilateral circuits",
-    "opt3": "Symmetric circuits",
-    "opt4": "AC circuits",
-    "correct_option": "Symmetric circuits",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of circuit element exhibits the same response to signals applied in either direction?",
-    "opt1": "Unilateral element",
-    "opt2": "Bilateral element",
-    "opt3": "Both unilateral and bilateral elements",
-    "opt4": "None of the above",
-    "correct_option": "Bilateral element",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits is an example of a unilateral circuit?",
-    "opt1": "Diode rectifier circuit",
-    "opt2": "RC circuit",
-    "opt3": "LC circuit",
-    "opt4": "AC circuit",
-    "correct_option": "Diode rectifier circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuit element requires consideration of the direction of the applied signal?",
-    "opt1": "Bilateral element",
-    "opt2": "Unilateral element",
-    "opt3": "Both A and B",
-    "opt4": "None of the above",
-    "correct_option": "Unilateral element",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of circuit exhibits both symmetric and asymmetric behavior?",
-    "opt1": "Unilateral circuit",
-    "opt2": "Bilateral circuit",
-    "opt3": "Circuits with both bilateral and unilateral elements",
-    "opt4": "None of the above",
-    "correct_option": "Circuits with both bilateral and unilateral elements",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is true regarding the analysis of circuits with both bilateral and unilateral elements?",
-    "opt1": "They require only DC circuit analysis techniques.",
-    "opt2": "They require only AC circuit analysis techniques.",
-    "opt3": "They require both DC and AC circuit analysis techniques.",
-    "opt4": "They cannot be analyzed.",
-    "correct_option": "They require both DC and AC circuit analysis techniques.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of circuit elements respond identically to signals applied in either direction?",
-    "opt1": "Bilateral",
-    "opt2": "Unilateral",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Bilateral",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuits require only DC circuit analysis techniques?",
-    "opt1": "Bilateral",
-    "opt2": "Unilateral",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Bilateral",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuit elements respond differently to signals applied in different directions?",
-    "opt1": "Bilateral",
-    "opt2": "Unilateral",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Unilateral",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of circuits require AC circuit analysis techniques?",
-    "opt1": "Bilateral",
-    "opt2": "Unilateral",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Bilateral",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is an example of a bilateral circuit element?",
-    "opt1": "Diode",
-    "opt2": "Resistor",
-    "opt3": "Transistor",
-    "opt4": "None of above",
-    "correct_option": "Resistor",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of circuits are also known as symmetric circuits?",
-    "opt1": "Bilateral",
-    "opt2": "Unilateral",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Bilateral",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuits are also known as asymmetric circuits?",
-    "opt1": "Bilateral",
-    "opt2": "Unilateral",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Unilateral",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of circuits can have both bilateral and unilateral elements?",
-    "opt1": "Bilateral circuits only",
-    "opt2": "Unilateral circuits only",
-    "opt3": "Circuits with both bilateral and unilateral elements",
-    "opt4": "None of above",
-    "correct_option": "Circuits with both bilateral and unilateral elements",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "In which type of circuits does the direction of the signal matter?",
-    "opt1": "Bilateral",
-    "opt2": "Unilateral",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Unilateral",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of circuit must be analyzed using both DC and AC circuit analysis techniques?",
-    "opt1": "Bilateral circuits only",
-    "opt2": "Unilateral circuits only",
-    "opt3": "Circuits with both bilateral and unilateral elements",
-    "opt4": "None of above",
-    "correct_option": "Circuits with both bilateral and unilateral elements",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following circuits is an example of a bilateral circuit?",
-    "opt1": "Diode rectifier circuit",
-    "opt2": "Resistor-capacitor circuit",
-    "opt3": "Transistor amplifier circuit",
-    "opt4": "None of the above",
-    "correct_option": "Resistor-capacitor circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits requires an external source of power to function?",
-    "opt1": "Passive circuit",
-    "opt2": "Active circuit",
-    "opt3": "Bilateral circuit",
-    "opt4": "Unilateral circuit",
-    "correct_option": "Active circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following components is not present in passive circuits?",
-    "opt1": "Transistors",
-    "opt2": "Inductors",
-    "opt3": "Capacitors",
-    "opt4": "Resistors",
-    "correct_option": "Transistors",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuit is used in filters and impedance matching circuits?",
-    "opt1": "Passive circuits",
-    "opt2": "Active circuits",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Passive circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuit is used in amplifiers and oscillators?",
-    "opt1": "Passive circuits",
-    "opt2": "Active circuits",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Active circuits",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of circuit requires an external power source to function?",
-    "opt1": "Passive circuits",
-    "opt2": "Active circuits",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Active circuits",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits can control signals?",
-    "opt1": "Passive circuits",
-    "opt2": "Active circuits",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Active circuits",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits attenuates signals?",
-    "opt1": "Passive circuits",
-    "opt2": "Active circuits",
-    "opt3": "Both a and b",
-    "opt4": "None of above",
-    "correct_option": "Passive circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following components is an active component?",
-    "opt1": "Capacitor",
-    "opt2": "Transistor",
-    "opt3": "Resistor",
-    "opt4": "Inductor",
-    "correct_option": "Transistor",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits can generate power gain?",
-    "opt1": "Passive circuit",
-    "opt2": "Active circuit",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Active circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits requires an external source of power to function?",
-    "opt1": "Passive circuit",
-    "opt2": "Active circuit",
-    "opt3": "Bilateral circuit",
-    "opt4": "Unilateral circuit",
-    "correct_option": "Active circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following circuits can only attenuate or filter a signal?",
-    "opt1": "Passive circuit",
-    "opt2": "Active circuit",
-    "opt3": "Bilateral circuit",
-    "opt4": "Unilateral circuit",
-    "correct_option": "Passive circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuit contains only passive components?",
-    "opt1": "Active circuit",
-    "opt2": "Bilateral circuit",
-    "opt3": "Passive circuit",
-    "opt4": "Unilateral circuit",
-    "correct_option": "Passive circuit",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following circuits cannot perform mathematical operations on signals?",
-    "opt1": "Passive circuit",
-    "opt2": "Active circuit",
-    "opt3": "Bilateral circuit",
-    "opt4": "Unilateral circuit",
-    "correct_option": "Passive circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following circuits is commonly used in filters and impedance matching circuits?",
-    "opt1": "Active circuit",
-    "opt2": "Bilateral circuit",
-    "opt3": "Unilateral circuit",
-    "opt4": "Passive circuit",
-    "correct_option": "Passive circuit",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which type of circuit can both attenuate and amplify signals?",
-    "opt1": "Passive circuit",
-    "opt2": "Active circuit",
-    "opt3": "Unilateral circuit",
-    "opt4": "Bilateral circuit",
-    "correct_option": "Active circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of circuit exhibits the same behavior in both directions of current flow?",
-    "opt1": "Passive circuit",
-    "opt2": "Active circuit",
-    "opt3": "Bilateral circuit",
-    "opt4": "Unilateral circuit",
-    "correct_option": "Bilateral circuit",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of circuit can only exhibit behavior in one direction of current flow?",
-    "opt1": "Passive circuit",
-    "opt2": "Active circuit",
-    "opt3": "Bilateral circuit",
-    "opt4": "Unilateral circuit",
-    "correct_option": "Unilateral circuit",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the superposition theorem used for?",
-    "opt1": "To simplify complex circuits",
-    "opt2": "To analyze AC circuits",
-    "opt3": "To analyze non-linear circuits",
-    "opt4": "To calculate power in circuits",
-    "correct_option": "To simplify complex circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is a necessary condition for applying the superposition theorem?",
-    "opt1": "The circuit must be linear",
-    "opt2": "The circuit must be passive",
-    "opt3": "The circuit must be bilateral",
-    "opt4": "The circuit must contain only resistors",
-    "correct_option": "The circuit must be linear",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In a circuit with multiple voltage sources, how is the superposition theorem applied?",
-    "opt1": "Each voltage source is turned on individually and the resulting current is added together",
-    "opt2": "Each voltage source is turned on individually and the resulting voltage is added together",
-    "opt3": "Each voltage source is turned on individually and the resulting current is subtracted from the total current",
-    "opt4": "Each voltage source is turned on individually and the resulting voltage is subtracted from the total voltage",
-    "correct_option": "Each voltage source is turned on individually and the resulting current is added together",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In a circuit with multiple current sources, how is the superposition theorem applied?",
-    "opt1": "Each current source is turned on individually and the resulting voltage is added together",
-    "opt2": "Each current source is turned on individually and the resulting voltage is subtracted from the total voltage",
-    "opt3": "Each current source is turned on individually and the resulting current is added together",
-    "opt4": "Each current source is turned on individually and the resulting current is subtracted from the total current",
-    "correct_option": "Each current source is turned on individually and the resulting current is added together",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the main advantage of using the superposition theorem?",
-    "opt1": "It simplifies complex circuits",
-    "opt2": "It eliminates the need for Kirchhoff's laws",
-    "opt3": "It reduces power consumption in circuits",
-    "opt4": "It can only be used for DC circuits",
-    "correct_option": "It simplifies complex circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of using the superposition theorem?",
-    "opt1": "It is time-consuming to apply to large circuits",
-    "opt2": "It can only be used for circuits with few components",
-    "opt3": "It requires specialized equipment",
-    "opt4": "It provides accurate results for non-linear circuits",
-    "correct_option": "It is time-consuming to apply to large circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the superposition theorem based on?",
-    "opt1": "Ohm's law",
-    "opt2": "Faraday's law",
-    "opt3": "Kirchhoff's laws",
-    "opt4": "The principle of superposition",
-    "correct_option": "The principle of superposition",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What type of circuits is the superposition theorem used to solve?",
-    "opt1": "Series circuits",
-    "opt2": "Parallel circuits",
-    "opt3": "Complex circuits",
-    "opt4": "Linear circuits",
-    "correct_option": "Linear circuits",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "According to the superposition theorem, what happens when multiple sources are present in a circuit?",
-    "opt1": "They cancel each other out",
-    "opt2": "They add together",
-    "opt3": "Each source is considered independently",
-    "opt4": "None of the above",
-    "correct_option": "Each source is considered independently",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the superposition theorem based on?",
-    "opt1": "Kirchhoff's current law",
-    "opt2": "Kirchhoff's voltage law",
-    "opt3": "Ohm's law",
-    "opt4": "Faraday's law",
-    "correct_option": "Ohm's law",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a requirement for the superposition theorem to be applicable?",
-    "opt1": "The circuit must be linear",
-    "opt2": "The circuit must contain only passive components",
-    "opt3": "The circuit must have only one voltage source",
-    "opt4": "The circuit must be in series configuration",
-    "correct_option": "The circuit must be linear",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How is the superposition theorem applied to a circuit with multiple sources?",
-    "opt1": "Each source is turned on one at a time, with all other sources turned off",
-    "opt2": "All sources are turned on at the same time",
-    "opt3": "All sources are turned off",
-    "opt4": "Each source is turned on in pairs, with all other sources turned off",
-    "correct_option": "Each source is turned on one at a time, with all other sources turned off",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the primary advantage of using the superposition theorem to solve circuits?",
-    "opt1": "It allows for a quick and easy solution",
-    "opt2": "It can be applied to any type of circuit",
-    "opt3": "It provides a more accurate solution than other methods",
-    "opt4": "It simplifies the circuit and reduces the number of components",
-    "correct_option": "It simplifies the circuit and reduces the number of components",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a limitation of the superposition theorem?",
-    "opt1": "It cannot be used on circuits with more than two sources",
-    "opt2": "It requires complex calculations",
-    "opt3": "It can only be used on circuits with passive components",
-    "opt4": "It is not applicable to non-linear circuits",
-    "correct_option": "It is not applicable to non-linear circuits",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the result of applying the superposition theorem to a circuit with multiple sources?",
-    "opt1": "The total voltage and current in the circuit are calculated",
-    "opt2": "The voltage and current in each component are calculated",
-    "opt3": "The power dissipated by each component is calculated",
-    "opt4": "The resistance of each component is calculated",
-    "correct_option": "The total voltage and current in the circuit are calculated",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is a step in applying the superposition theorem to a circuit?",
-    "opt1": "Calculate the total resistance of the circuit",
-    "opt2": "Calculate the voltage and current of each source individually",
-    "opt3": "Add the voltage and current of each source together",
-    "opt4": "Replace each source with a resistor of equivalent value",
-    "correct_option": "Add the voltage and current of each source together",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the formula for calculating the voltage across a component in a circuit using the superposition theorem?",
-    "opt1": "V=IR",
-    "opt2": "V=I/R",
-    "opt3": "V=Sum(V1+V2+...+Vn)",
-    "opt4": "V=Sum(I1+I2+...+In)",
-    "correct_option": "V=Sum(V1+V2+...+Vn)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Superposition theorem is applicable to which type of circuits?",
-    "opt1": "Linear circuits only",
-    "opt2": "Non-linear circuits only",
-    "opt3": "Both linear and non-linear circuits",
-    "opt4": "Passive circuits only",
-    "correct_option": "Linear circuits only",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Superposition theorem states that in a linear circuit with multiple sources, the total response is equal to:",
-    "opt1": "The sum of all individual responses",
-    "opt2": "The product of all individual responses",
-    "opt3": "The average of all individual responses",
-    "opt4": "None of the above",
-    "correct_option": "The sum of all individual responses",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In superposition theorem, which of the following needs to be kept constant while analyzing each individual source?",
-    "opt1": "Voltage",
-    "opt2": "Current",
-    "opt3": "Resistance",
-    "opt4": "All of the above",
-    "correct_option": "Resistance",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Superposition theorem is used to calculate which of the following in a circuit?",
-    "opt1": "Voltage",
-    "opt2": "Current",
-    "opt3": "Power",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "In a circuit with two voltage sources, how many separate analyses are required using the superposition theorem?",
-    "opt1": "1",
-    "opt2": "2",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "2",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "The superposition theorem is not applicable to circuits with which of the following components?",
-    "opt1": "Resistors",
-    "opt2": "Capacitors",
-    "opt3": "Inductors",
-    "opt4": "Diodes",
-    "correct_option": "Diodes",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the Thevenin equivalent circuit?",
-    "opt1": "A circuit consisting of a single voltage source and a single resistor",
-    "opt2": "A circuit consisting of a single current source and a single resistor",
-    "opt3": "A circuit consisting of multiple voltage sources and resistors",
-    "opt4": "A circuit consisting of multiple voltage sources and a single resistor",
-    "correct_option": "A circuit consisting of a single voltage source and a single resistor",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of Thevenin's theorem?",
-    "opt1": "To simplify complex circuits into simpler, equivalent circuits",
-    "opt2": "To measure voltage and current in a circuit",
-    "opt3": "To determine the power dissipated in a circuit",
-    "opt4": "All of above",
-    "correct_option": "To simplify complex circuits into simpler, equivalent circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the first step in determining the Thevenin equivalent circuit?",
-    "opt1": "Identify the load circuit that is connected to the circuit of interest",
-    "opt2": "Remove the load circuit from the circuit of interest",
-    "opt3": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
-    "opt4": "Determine the internal resistance Rth of the circuit between those terminals",
-    "correct_option": "Identify the load circuit that is connected to the circuit of interest",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the second step in determining the Thevenin equivalent circuit?",
-    "opt1": "Identify the load circuit that is connected to the circuit of interest",
-    "opt2": "Remove the load circuit from the circuit of interest",
-    "opt3": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
-    "opt4": "Determine the internal resistance Rth of the circuit between those terminals",
-    "correct_option": "Remove the load circuit from the circuit of interest",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the third step in determining the Thevenin equivalent circuit?",
-    "opt1": "Identify the load circuit that is connected to the circuit of interest",
-    "opt2": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
-    "opt3": "Determine the internal resistance Rth of the circuit between those terminals",
-    "opt4": "None of above",
-    "correct_option": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the fourth step in determining the Thevenin equivalent circuit?",
-    "opt1": "Identify the load circuit that is connected to the circuit of interest",
-    "opt2": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
-    "opt3": "Determine the internal resistance Rth of the circuit between those terminals",
-    "opt4": "None of above",
-    "correct_option": "Determine the internal resistance Rth of the circuit between those terminals",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the final step in determining the Thevenin equivalent circuit?",
-    "opt1": "Draw the Thevenin equivalent circuit with the voltage source Vth and the resistor Rth",
-    "opt2": "Draw the Thevenin equivalent circuit with multiple voltage sources and resistors",
-    "opt3": "Determine the power delivered to the load circuit",
-    "opt4": "None of above",
-    "correct_option": "Draw the Thevenin equivalent circuit with the voltage source Vth and the resistor Rth",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the advantage of using the Thevenin equivalent circuit?",
-    "opt1": "It simplifies complex circuits into simpler, equivalent circuits",
-    "opt2": "It allows the voltage and current across the load to be easily determined",
-    "opt3": "It is useful for designing circuits that are optimized for a specific load",
-    "opt4": "All of above",
-    "correct_option": "All of above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Can Thevenin's theorem be used for non-linear circuits?",
-    "opt1": "No, it only applies to linear circuits",
-    "opt2": "Yes, it can be applied to both linear and non-linear circuits",
-    "opt3": "It only applies to circuits with voltage sources and resistors",
-    "opt4": "It only applies to circuits with current sources",
-    "correct_option": "No, it only applies to linear circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the Thevenin equivalent circuit?",
-    "opt1": "To calculate the voltage and current across a load circuit",
-    "opt2": "To determine the power delivered to a load circuit",
-    "opt3": "To simplify complex circuits into simpler, equivalent circuits",
-    "opt4": "All of above",
-    "correct_option": "All of above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is Thevenin's theorem used for in electrical engineering?",
-    "opt1": "To simplify complex circuits",
-    "opt2": "To increase the resistance of a circuit",
-    "opt3": "To reduce the voltage of a circuit",
-    "opt4": "To add more components to a circuit",
-    "correct_option": "To simplify complex circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the Thevenin equivalent circuit?",
-    "opt1": "A circuit consisting of multiple voltage sources and resistors",
-    "opt2": "A circuit consisting of a single voltage source and a single resistor",
-    "opt3": "A circuit consisting of multiple voltage sources and a single resistor",
-    "opt4": "A circuit consisting of a single voltage source and multiple resistors",
-    "correct_option": "A circuit consisting of a single voltage source and a single resistor",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the first step in determining the Thevenin equivalent circuit?",
-    "opt1": "Identify the load circuit that is connected to the circuit of interest",
-    "opt2": "Remove the load circuit from the circuit of interest",
-    "opt3": "Determine the internal resistance of the circuit between those terminals",
-    "opt4": "Determine the open-circuit voltage across the terminals where the load was connected",
-    "correct_option": "Identify the load circuit that is connected to the circuit of interest",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the second step in determining the Thevenin equivalent circuit?",
-    "opt1": "Identify the load circuit that is connected to the circuit of interest",
-    "opt2": "Determine the internal resistance of the circuit between those terminals",
-    "opt3": "Determine the open-circuit voltage across the terminals where the load was connected",
-    "opt4": "Remove the load circuit from the circuit of interest",
-    "correct_option": "Remove the load circuit from the circuit of interest",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the third step in determining the Thevenin equivalent circuit?",
-    "opt1": "Identify the load circuit that is connected to the circuit of interest",
-    "opt2": "Determine the open-circuit voltage across the terminals where the load was connected",
-    "opt3": "Determine the internal resistance of the circuit between those terminals",
-    "opt4": "Remove the load circuit from the circuit of interest",
-    "correct_option": "Determine the open-circuit voltage across the terminals where the load was connected",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the fourth step in determining the Thevenin equivalent circuit?",
-    "opt1": "Identify the load circuit that is connected to the circuit of interest",
-    "opt2": "Determine the open-circuit voltage across the terminals where the load was connected",
-    "opt3": "Determine the internal resistance of the circuit between those terminals",
-    "opt4": "Remove the load circuit from the circuit of interest",
-    "correct_option": "Determine the internal resistance of the circuit between those terminals",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Can Thevenin's theorem be used for non-linear circuits?",
-    "opt1": "No, it can only be used for linear circuits",
-    "opt2": "Yes, it can be used for both linear and non-linear circuits",
-    "opt3": "Yes, but only for circuits with a single non-linear element",
-    "opt4": "It depends on the complexity of the circuit",
-    "correct_option": "No, it can only be used for linear circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the advantage of using Thevenin's theorem to simplify a circuit?",
-    "opt1": "It reduces the number of components that need to be analyzed",
-    "opt2": "It increases the voltage of the circuit",
-    "opt3": "It decreases the resistance of the circuit",
-    "opt4": "It adds more components to the circuit",
-    "correct_option": "It reduces the number of components that need to be analyzed",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between a Thevenin equivalent circuit and a Norton equivalent circuit?",
-    "opt1": "A Thevenin equivalent circuit uses a voltage source and a resistor, while a Norton equivalent circuit uses a current source and a resistor.",
-    "opt2": "A Thevenin equivalent circuit uses a current source and a resistor, while a Norton equivalent circuit uses a voltage source and a resistor.",
-    "opt3": "There is no difference between a Thevenin and Norton equivalent circuit.",
-    "opt4": "The choice between a Thevenin and Norton equivalent circuit depends on the type of circuit being analyzed.",
-    "correct_option": "A Thevenin equivalent circuit uses a voltage source and a resistor, while a Norton equivalent circuit uses a current source and a resistor.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the primary use of the Thevenin equivalent circuit in circuit design?",
-    "opt1": "To optimize circuits for a specific load",
-    "opt2": "To increase the resistance of a circuit",
-    "opt3": "To reduce the voltage of a circuit",
-    "opt4": "To add more components to a circuit",
-    "correct_option": "To optimize circuits for a specific load",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is Norton's theorem?",
-    "opt1": "A method to calculate the resistance of a circuit.",
-    "opt2": "A method to simplify complex circuits by using an equivalent voltage source and a series resistor.",
-    "opt3": "A method to simplify complex circuits by using an equivalent current source and a parallel resistor.",
-    "opt4": "Both a and c",
-    "correct_option": "A method to simplify complex circuits by using an equivalent current source and a parallel resistor.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the Norton equivalent current?",
-    "opt1": "The current that flows through a resistor in the circuit.",
-    "opt2": "The current that would flow if the output terminals of the circuit were short-circuited.",
-    "opt3": "The current that would flow if the output terminals of the circuit were open-circuited.",
-    "opt4": "None of above",
-    "correct_option": "The current that would flow if the output terminals of the circuit were short-circuited.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the equivalent resistance seen from the output terminals in Norton's theorem?",
-    "opt1": "The resistance of the load resistor.",
-    "opt2": "The resistance of the circuit with all voltage sources replaced by their internal resistances.",
-    "opt3": "The resistance of the circuit with all current sources replaced by their internal resistances.",
-    "opt4": "None of above",
-    "correct_option": "The resistance of the circuit with all voltage sources replaced by their internal resistances.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the Norton equivalent circuit of a linear circuit?",
-    "opt1": "A voltage source and a series resistor",
-    "opt2": "A current source and a series resistor",
-    "opt3": "A voltage source and a parallel resistor",
-    "opt4": "A current source and a parallel resistor",
-    "correct_option": "A current source and a parallel resistor",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the relationship between Norton's theorem and Thevenin's theorem?",
-    "opt1": "They are unrelated.",
-    "opt2": "They provide different methods to simplify complex circuits",
-    "opt3": "They are equivalent and can be used interchangeably.",
-    "opt4": "Thevenin's theorem can be used in place for Norton's theorem but not vice versa",
-    "correct_option": "They are equivalent and can be used interchangeably.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the advantage of using Norton's theorem?",
-    "opt1": "It simplifies complex circuits",
-    "opt2": "It allows the calculation of voltage at any point in the circuit",
-    "opt3": "It is applicable to nonlinear circuits",
-    "opt4": "It requires only one step to calculate the output",
-    "correct_option": "It simplifies complex circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the limitation of Norton's theorem?",
-    "opt1": "It can provide a method for calculating the power in the circuit.",
-    "opt2": "It can be used to analyze circuits with capacitors and inductors.",
-    "opt3": "It cannot be used for circuits with resistors in parallel",
-    "opt4": "It can only be used for circuits in steady-state conditions.",
-    "correct_option": "It can only be used for circuits in steady-state conditions.",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Can Norton's theorem be used to analyze non-linear circuits?",
-    "opt1": "Yes, as long as the circuit is simple.",
-    "opt2": "It depends on the type of non-linearity in the circuit.",
-    "opt3": "No, Norton's theorem is only applicable to linear circuits.",
-    "opt4": "Both a and b",
-    "correct_option": "No, Norton's theorem is only applicable to linear circuits.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "How is the Norton equivalent circuit connected to the load resistor?",
-    "opt1": "In series.",
-    "opt2": "In parallel",
-    "opt3": "The Norton equivalent circuit is not connected to the load resistor.",
-    "opt4": "None of above",
-    "correct_option": "In parallel",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "The Norton equivalent circuit must be connected to an external load to obtain the desired output.",
-    "opt1": "A voltage source and a series resistor",
-    "opt2": "A current source and a series resistor",
-    "opt3": "A voltage source and a parallel resistor",
-    "opt4": "A current source and a parallel resistor",
-    "correct_option": "A current source and a parallel resistor",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the Norton equivalent circuit of a linear circuit?",
-    "opt1": "A voltage source and a series resistor",
-    "opt2": "A current source and a series resistor",
-    "opt3": "A voltage source and a parallel resistor",
-    "opt4": "A current source and a parallel resistor",
-    "correct_option": "A current source and a parallel resistor",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "When using Norton's theorem, what must be disconnected from the circuit first?",
-    "opt1": "The voltage source",
-    "opt2": "The current source",
-    "opt3": "The load resistor",
-    "opt4": "The switch",
-    "correct_option": "The load resistor",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "How is the Norton equivalent current calculated?",
-    "opt1": "By open-circuiting the output terminals and finding the current",
-    "opt2": "By short-circuiting the output terminals and finding the current",
-    "opt3": "By connecting a load resistor to the output terminals and finding the current",
-    "opt4": "By calculating the voltage across the output terminals and dividing by the resistance",
-    "correct_option": "By short-circuiting the output terminals and finding the current",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the equivalent resistance seen from the output terminals in Norton's theorem?",
-    "opt1": "The total resistance of the circuit",
-    "opt2": "The resistance of the load resistor",
-    "opt3": "The resistance of the voltage source",
-    "opt4": "The resistance seen from the output terminals with all voltage sources replaced by their internal resistances",
-    "correct_option": "The resistance seen from the output terminals with all voltage sources replaced by their internal resistances",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the advantage of using Norton's theorem?",
-    "opt1": "It simplifies complex circuits",
-    "opt2": "It allows the calculation of voltage at any point in the circuit",
-    "opt3": "It is applicable to nonlinear circuits",
-    "opt4": "It requires only one step to calculate the output",
-    "correct_option": "It simplifies complex circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In Norton's theorem, what is the Norton equivalent current source dependent on?",
-    "opt1": "The load resistor",
-    "opt2": "The voltage across the circuit",
-    "opt3": "The current through the circuit",
-    "opt4": "The total resistance of the circuit",
-    "correct_option": "The current through the circuit",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "How many steps are involved in applying Norton's theorem?",
-    "opt1": "Two",
-    "opt2": "Three",
-    "opt3": "Four",
-    "opt4": "Five",
-    "correct_option": "Five",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the main requirement for a circuit to be analyzed using Norton's theorem?",
-    "opt1": "It must be in steady-state conditions",
-    "opt2": "It must contain only resistors and voltage sources",
-    "opt3": "It must be a linear circuit",
-    "opt4": "It must contain only resistors and current sources",
-    "correct_option": "It must be a linear circuit",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the equivalent circuit obtained in Norton's theorem?",
-    "opt1": "A voltage source in series with a resistor",
-    "opt2": "A current source in series with a resistor",
-    "opt3": "A voltage source in parallel with a resistor",
-    "opt4": "A current source in parallel with a resistor",
-    "correct_option": "A current source in parallel with a resistor",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the purpose of the Norton equivalent circuit?",
-    "opt1": "To calculate the resistance of the circuit.",
-    "opt2": "To replace the original circuit with a simpler circuit.",
-    "opt3": "To provide a method for calculating the voltage at any point in the circuit.",
-    "opt4": "All of above",
-    "correct_option": "To replace the original circuit with a simpler circuit.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the maximum power transfer theorem?",
-    "opt1": "It states that the power transferred from a source to a load is maximum when the load impedance is equal to the source impedance.",
-    "opt2": "It states that the power transferred from a source to a load is maximum when the load impedance is greater than the source impedance.",
-    "opt3": "It states that the power transferred from a source to a load is maximum when the load impedance is less than the source impedance.",
-    "opt4": "None of the above.",
-    "correct_option": "It states that the power transferred from a source to a load is maximum when the load impedance is equal to the source impedance.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What type of circuits does the maximum power transfer theorem apply to?",
-    "opt1": "Linear circuits only.",
-    "opt2": "Non-linear circuits only.",
-    "opt3": "Both linear and non-linear circuits.",
-    "opt4": "None of the above.",
-    "correct_option": "Linear circuits only.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the advantage of applying the maximum power transfer theorem in a circuit?",
-    "opt1": "It reduces the power loss in the circuit.",
-    "opt2": "It increases the power loss in the circuit.",
-    "opt3": "It reduces the voltage and current in the circuit.",
-    "opt4": "None of the above.",
-    "correct_option": "It reduces the power loss in the circuit.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How does the maximum power transfer theorem help in designing power systems?",
-    "opt1": "It helps to optimize the power transfer in the system.",
-    "opt2": "It helps to increase the efficiency of the system.",
-    "opt3": "It helps to reduce the power loss in the system.",
-    "opt4": "All of the above.",
-    "correct_option": "All of the above.",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What happens when the load impedance is not equal to the source impedance in a circuit?",
-    "opt1": "The power transfer is maximum.",
-    "opt2": "The power transfer is minimum.",
-    "opt3": "The power transfer is zero.",
-    "opt4": "None of the above.",
-    "correct_option": "The power transfer is minimum.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Is the maximum power transfer theorem applicable to AC circuits?",
-    "opt1": "Yes, it is applicable to AC circuits.",
-    "opt2": "No, it is applicable only to DC circuits.",
-    "opt3": "It depends on the type of load.",
-    "opt4": "None of the above.",
-    "correct_option": "Yes, it is applicable to AC circuits.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the formula for calculating the maximum power transfer in a circuit?",
-    "opt1": "P=V*2/R",
-    "opt2": "P=I^2R",
-    "opt3": "P=V^2/2R",
-    "opt4": "P=V^2/R+L",
-    "correct_option": "P=I^2R",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Can the maximum power transfer occur at multiple values of load impedance?",
-    "opt1": "Yes, it can occur at multiple values of load impedance.",
-    "opt2": "No, it can occur at only one value of load impedance.",
-    "opt3": "It depends on the source impedance.",
-    "opt4": "None of the above.",
-    "correct_option": "No, it can occur at only one value of load impedance.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the condition for maximum power transfer in a circuit?",
-    "opt1": "The load impedance must be equal to the source impedance.",
-    "opt2": "The load impedance must be greater than the source impedance.",
-    "opt3": "The load impedance must be less than the source impedance.",
-    "opt4": "None of the above.",
-    "correct_option": "The load impedance must be equal to the source impedance.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the maximum efficiency that can be achieved in a circuit using the maximum power transfer theorem?",
-    "opt1": "100%",
-    "opt2": "50%",
-    "opt3": "25%",
-    "opt4": "It depends on the circuit.",
-    "correct_option": "25%",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "The maximum power transfer theorem is applicable to:",
-    "opt1": "Linear circuits only.",
-    "opt2": "Non-linear circuits only.",
-    "opt3": "Both linear and non-linear circuits.",
-    "opt4": "All of above",
-    "correct_option": "Linear circuits only.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "The maximum power transfer occurs when:",
-    "opt1": "The load impedance is zero.",
-    "opt2": "The load impedance is equal to the source impedance",
-    "opt3": "The load impedance is infinite.",
-    "opt4": "When load impedance is double of source impedance",
-    "correct_option": "The load impedance is equal to the source impedance",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the formula for calculating the maximum power transfer?",
-    "opt1": "Pmax=V*2",
-    "opt2": "Pmax=V^2 2",
-    "opt3": "Pmax=V^2/4R",
-    "opt4": "Pmax=V^2 2/(2R)",
-    "correct_option": "Pmax=V^2/4R",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "In which applications is the maximum power transfer theorem useful?",
-    "opt1": "Audio",
-    "opt2": "Power supplies",
-    "opt3": "Power transmission systems",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What happens when the load impedance is much larger than the source impedance?",
-    "opt1": "The power transfer is maximum",
-    "opt2": "The power transfer is minimum.",
-    "opt3": "The power transfer is zero",
-    "opt4": "None of above",
-    "correct_option": "The power transfer is minimum.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "The maximum power transfer theorem helps to:",
-    "opt1": "Minimize the amount of energy lost in transmission.",
-    "opt2": "Maximize the amount of energy lost in transmission.",
-    "opt3": "Have no effect on the amount of energy lost in transmission.",
-    "opt4": "Helps to distribute energy evenly in transmission.",
-    "correct_option": "Minimize the amount of energy lost in transmission.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "The maximum power transfer theorem is useful in designing and optimizing:",
-    "opt1": "Power systems",
-    "opt2": "Lighting systems",
-    "opt3": "Communication systems",
-    "opt4": "Both a and c",
-    "correct_option": "Power systems",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the time constant of an R-C circuit consisting of a 1 kΩ resistor and a 100 nF capacitor?",
-    "opt1": "1 ms",
-    "opt2": "100 µs",
-    "opt3": "10 µs",
-    "opt4": "10 ms",
-    "correct_option": "1 ms",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In an R-L circuit, the voltage across the Inductor lags behind the current by how many degrees?",
-    "opt1": "0°",
-    "opt2": "45°",
-    "opt3": "90°",
-    "opt4": "180°",
-    "correct_option": "0°",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the resonant frequency of an R-L-C circuit with a 100 Ω resistor, 1 mH inductor, and a 100 nF capacitor?",
-    "opt1": "160 kHz",
-    "opt2": "16 kHz",
-    "opt3": "1.6 kHz",
-    "opt4": "1.6 MHz",
-    "correct_option": "160 kHz",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In an R-L-C circuit, what happens to the Impedance at resonance?",
-    "opt1": "It is zero",
-    "opt2": "It is at a minimum",
-    "opt3": "It is at a maximum",
-    "opt4": "It is infinite",
-    "correct_option": "It is infinite",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "A series R-C circuit has a resistor of 100 Ω and a capacitor of 10 µF. What is the cutoff frequency?",
-    "opt1": "15.9 Hz",
-    "opt2": "159 Hz",
-    "opt3": "1.59 kHz",
-    "opt4": "1.59 Hz",
-    "correct_option": "159 Hz",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In an R-L circuit, what happens to the impedance as the frequency increases?",
-    "opt1": "It increases",
-    "opt2": "It decreases",
-    "opt3": "It remains constant",
-    "opt4": "It oscillates",
-    "correct_option": "It increases",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the phase angle between the voltage and current in an R-L-C circuit at resonance?",
-    "opt1": "0°",
-    "opt2": "45°",
-    "opt3": "90°",
-    "opt4": "180°",
-    "correct_option": "45°",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the time constant of an R-L circuit consisting of a 100 Ω resistor and a 10 mH inductor?",
-    "opt1": "100 µs",
-    "opt2": "1 µs",
-    "opt3": "10 µs",
-    "opt4": "1 ms",
-    "correct_option": "1 µs",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In an R-L-C circuit, what happens to the bandwidth as the quality factor increases?",
-    "opt1": "It increases",
-    "opt2": "It decreases",
-    "opt3": "It remains constant",
-    "opt4": "It oscillates",
-    "correct_option": "It increases",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the resonant frequency?",
-    "opt1": "15.92 Hz",
-    "opt2": "15.92 kHz",
-    "opt3": "159.2 Hz",
-    "opt4": "1.59 kHz",
-    "correct_option": "15.92 Hz",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of circuit contains an inductor and a resistor?",
-    "opt1": "R-L circuit",
-    "opt2": "R-C circuit",
-    "opt3": "R-L-C circuit",
-    "opt4": "None of the above",
-    "correct_option": "R-L circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the time constant of an R-C circuit?",
-    "opt1": "R/C",
-    "opt2": "CR",
-    "opt3": "RC",
-    "opt4": "1/RC",
-    "correct_option": "R/C",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the voltage across an inductor in an R-L circuit at steady state?",
-    "opt1": "Zero",
-    "opt2": "Infinite",
-    "opt3": "The same as the voltage across the resistor",
-    "opt4": "None of the above",
-    "correct_option": "Infinite",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What happens to the current in an R-L circuit if the inductance is increased?",
-    "opt1": "The current decreases",
-    "opt2": "The current increases",
-    "opt3": "The current remains the same",
-    "opt4": "The current becomes erratic",
-    "correct_option": "The current remains the same",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "In an R-C circuit, what happens to the current as the capacitor becomes fully charged?",
-    "opt1": "The current increases",
-    "opt2": "The current decreases",
-    "opt3": "The current remains the same",
-    "opt4": "The current becomes zero",
-    "correct_option": "The current becomes zero",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the resonance frequency of an R-L-C circuit?",
-    "opt1": "1/(2pisqrt(LC))",
-    "opt2": "2pisqrt(LC)",
-    "opt3": "1/(L*C)",
-    "opt4": "None of the above",
-    "correct_option": "2pisqrt(LC)",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What happens to the impedance of an R-L-C circuit at resonance?",
-    "opt1": "The impedance is maximum",
-    "opt2": "The impedance is minimum",
-    "opt3": "The impedance is zero",
-    "opt4": "The impedance remains the same",
-    "correct_option": "The impedance is maximum",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In an R-L-C circuit, what happens to the phase angle at resonance?",
-    "opt1": "The phase angle is zero",
-    "opt2": "The phase angle is 180 degrees",
-    "opt3": "The phase angle is 90 degrees",
-    "opt4": "The phase angle remains the same",
-    "correct_option": "The phase angle is zero",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the resonant frequency of an AC series circuit consisting of a 20mH Inductor and a 10µF capacitor?",
-    "opt1": "159.15 Hz",
-    "opt2": "318.3 Hz",
-    "opt3": "500 Hz",
-    "opt4": "1000 Hz",
-    "correct_option": "159.15 Hz",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the resonant frequency of an AC parallel circuit consisting of a 10mH inductor and a capacitor 100µF?",
-    "opt1": "318.3 Hz",
-    "opt2": "1000 Hz",
-    "opt3": "159.15 Hz",
-    "opt4": "159.15 Hz",
-    "correct_option": "159.15 Hz",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What happens to the Impedance of an AC series resonant circuit at resonance?",
-    "opt1": "It is minimum",
-    "opt2": "It is maximum",
-    "opt3": "It is zero",
-    "opt4": "It is infinity",
-    "correct_option": "It is maximum",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What happens to the current in an AC parallel resonant circuit at resonance?",
-    "opt1": "It is minimum",
-    "opt2": "It is maximum",
-    "opt3": "It is zero",
-    "opt4": "It is infinity",
-    "correct_option": "It is maximum",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the power factor of an AC series resonant circuit at resonance?",
-    "opt1": "Unity",
-    "opt2": "Zero",
-    "opt3": "Negative",
-    "opt4": "Indeterminate",
-    "correct_option": "Zero",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the power factor of an AC parallel resonant circuit at resonance?",
-    "opt1": "Unity",
-    "opt2": "Zero",
-    "opt3": "Negative",
-    "opt4": "Indeterminate",
-    "correct_option": "Zero",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the phase angle between the voltage and current in an AC series resonant circuit at resonance?",
-    "opt1": "0 degrees",
-    "opt2": "45 degrees",
-    "opt3": "90 degrees",
-    "opt4": "180 degrees",
-    "correct_option": "0 degrees",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the phase angle between the voltage and current in an AC parallel resonant circuit at resonance?",
-    "opt1": "0 degrees",
-    "opt2": "45 degrees",
-    "opt3": "90 degrees",
-    "opt4": "180 degrees",
-    "correct_option": "0 degrees",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What happens to the voltage across the capacitor in an AC series resonant circuit at resonance?",
-    "opt1": "It is maximum",
-    "opt2": "It is minimum",
-    "opt3": "It is zero",
-    "opt4": "It is infinity",
-    "correct_option": "It is minimum",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In an AC series resonant circuit, at the resonant frequency, what is the power factor?",
-    "opt1": "Zero",
-    "opt2": "Unity",
-    "opt3": "Inductive",
-    "opt4": "Capacitive",
-    "correct_option": "Unity",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the resonant frequency of an AC series resonant circuit with an inductance of 5mH and a capacitance 10µF?",
-    "opt1": "3.18 kHz",
-    "opt2": "31.8 kHz",
-    "opt3": "318 kHz",
-    "opt4": "3.18 MHz",
-    "correct_option": "3.18 kHz",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In an AC parallel resonant circuit, at the resonant frequency, what is the impedance?",
-    "opt1": "Zero",
-    "opt2": "Infinite",
-    "opt3": "Minimum",
-    "opt4": "Maximum",
-    "correct_option": "Minimum",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 5µF?",
-    "opt1": "3.57 kHz",
-    "opt2": "35.7 kHz",
-    "opt3": "357 kHz",
-    "opt4": "3.57 MHz",
-    "correct_option": "35.7 kHz",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the phase relationship between the voltage across the capacitor and the voltage across the inductor in an AC series resonant circuit at resonance?",
-    "opt1": "They are in phase",
-    "opt2": "They are 180 degrees out of phase",
-    "opt3": "They cancel each other out",
-    "opt4": "None of the above",
-    "correct_option": "They are 180 degrees out of phase",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the phase relationship between the current and the voltage in an AC series resonant circuit at resonance?",
-    "opt1": "They are in phase",
-    "opt2": "They are 180 degrees out of phase",
-    "opt3": "They cancel each other out",
-    "opt4": "None of the above",
-    "correct_option": "They are in phase",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the unit of active power?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "None of the above",
-    "correct_option": "Watts (W)",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the formula for reactive power?",
-    "opt1": "Q=V*I",
-    "opt2": "Q=V*I*cos(theta)",
-    "opt3": "Q=V*I*sin(theta)",
-    "opt4": "None of the above",
-    "correct_option": "Q=V*I*sin(theta)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the unit of reactive power?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "None of the above",
-    "correct_option": "Volt-amperes reactive (VAR)",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the formula for active power?",
-    "opt1": "P=V^2I",
-    "opt2": "P=V*I*cos(theta)",
-    "opt3": "P=V*I*sin(theta)",
-    "opt4": "None of the above",
-    "correct_option": "P=V*I*cos(theta)",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the unit of apparent power?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "None of the above",
-    "correct_option": "Volt-amperes (VA)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the formula for power factor?",
-    "opt1": "pf=Q/S",
-    "opt2": "pf=P/Q",
-    "opt3": "pf=P/S",
-    "opt4": "None of the above",
-    "correct_option": "pf=P/S",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the unit of power factor?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "None of the above",
-    "correct_option": "None of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the relationship between active power and reactive power?",
-    "opt1": "They are the same thing",
-    "opt2": "Reactive power is always greater than active power",
-    "opt3": "Active power is always greater than reactive power",
-    "opt4": "They are two different types of power",
-    "correct_option": "They are the same thing",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the formula for apparent power?",
-    "opt1": "S=V",
-    "opt2": "S=V*I*cos(theta)",
-    "opt3": "S=V^2I*sin(theta)",
-    "opt4": "None of the above",
-    "correct_option": "S=V",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the significance of power factor in electrical circuits?",
-    "opt1": "It determines the maximum power that can be delivered to the circuit",
-    "opt2": "It measures the efficiency of the circuit in using the power delivered to it",
-    "opt3": "It is a measure of the resistance of the circuit",
-    "opt4": "None of the above",
-    "correct_option": "It measures the efficiency of the circuit in using the power delivered to it",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is a measure of how efficiently the circuit is using the power delivered to it?",
-    "opt1": "Active power",
-    "opt2": "Reactive power",
-    "opt3": "Apparent power",
-    "opt4": "Power factor",
-    "correct_option": "Power factor",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which type of power is used in the circuit to perform useful work?",
-    "opt1": "Active power",
-    "opt2": "Reactive power",
-    "opt3": "Apparent power",
-    "opt4": "None of the above",
-    "correct_option": "Active power",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of power is stored and released by the circuit?",
-    "opt1": "Active power",
-    "opt2": "Reactive power",
-    "opt3": "Apparent power",
-    "opt4": "None of the above",
-    "correct_option": "Reactive power",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the power factor of a circuit that has 100 W of active power and 120 VA of apparent power?",
-    "opt1": "0.83",
-    "opt2": "1.20",
-    "opt3": "0.20",
-    "opt4": "0.01",
-    "correct_option": "0.83",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What happens to the power factor of a circuit if the reactive power increases?",
-    "opt1": "It increases",
-    "opt2": "It decreases",
-    "opt3": "It remains the same",
-    "opt4": "Cannot be determined",
-    "correct_option": "It decreases",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is not a measure of power in an AC circuit?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "Hertz (Hz)",
-    "correct_option": "Hertz (Hz)",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the maximum power transfer theorem?",
-    "opt1": "It states that the power transferred from a source to a load is maximum when the load impedance is equal to the source impedance.",
-    "opt2": "It states that the power transferred from a source to a load is maximum when the load impedance is greater than the source impedance.",
-    "opt3": "It states that the power transferred from a source to a load is maximum when the load impedance is less than the source impedance.",
-    "opt4": "None of the above.",
-    "correct_option": "It states that the power transferred from a source to a load is maximum when the load impedance is equal to the source impedance.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What type of circuits does the maximum power transfer theorem apply to?",
-    "opt1": "Linear circuits only.",
-    "opt2": "Non-linear circuits only.",
-    "opt3": "Both linear and non-linear circuits.",
-    "opt4": "None of the above.",
-    "correct_option": "Linear circuits only.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the advantage of applying the maximum power transfer theorem in a circuit?",
-    "opt1": "It reduces the power loss in the circuit.",
-    "opt2": "It increases the power loss in the circuit.",
-    "opt3": "It reduces the voltage and current in the circuit.",
-    "opt4": "None of the above.",
-    "correct_option": "It reduces the power loss in the circuit.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How does the maximum power transfer theorem help in designing power systems?",
-    "opt1": "It helps to optimize the power transfer in the system.",
-    "opt2": "It helps to increase the efficiency of the system.",
-    "opt3": "It helps to reduce the power loss in the system.",
-    "opt4": "All of the above.",
-    "correct_option": "All of the above.",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What happens when the load impedance is not equal to the source impedance in a circuit?",
-    "opt1": "The power transfer is maximum.",
-    "opt2": "The power transfer is minimum.",
-    "opt3": "The power transfer is zero.",
-    "opt4": "None of the above.",
-    "correct_option": "The power transfer is minimum.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Is the maximum power transfer theorem applicable to AC circuits?",
-    "opt1": "Yes, it is applicable to AC circuits.",
-    "opt2": "No, it is applicable only to DC circuits.",
-    "opt3": "It depends on the type of load.",
-    "opt4": "None of the above.",
-    "correct_option": "Yes, it is applicable to AC circuits.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the formula for calculating the maximum power transfer in a circuit?",
-    "opt1": "P=V*2/R",
-    "opt2": "P=I^2R",
-    "opt3": "P=V^2/2R",
-    "opt4": "P=V^2/R+L",
-    "correct_option": "P=I^2R",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Can the maximum power transfer occur at multiple values of load impedance?",
-    "opt1": "Yes, it can occur at multiple values of load impedance.",
-    "opt2": "No, it can occur at only one value of load impedance.",
-    "opt3": "It depends on the source impedance.",
-    "opt4": "None of the above.",
-    "correct_option": "No, it can occur at only one value of load impedance.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the condition for maximum power transfer in a circuit?",
-    "opt1": "The load impedance must be equal to the source impedance.",
-    "opt2": "The load impedance must be greater than the source impedance.",
-    "opt3": "The load impedance must be less than the source impedance.",
-    "opt4": "None of the above.",
-    "correct_option": "The load impedance must be equal to the source impedance.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the maximum efficiency that can be achieved in a circuit using the maximum power transfer theorem?",
-    "opt1": "100%",
-    "opt2": "50%",
-    "opt3": "25%",
-    "opt4": "It depends on the circuit.",
-    "correct_option": "50%",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "The maximum power transfer theorem is applicable to:",
-    "opt1": "Linear circuits only.",
-    "opt2": "Non-linear circuits only.",
-    "opt3": "Both linear and non-linear circuits.",
-    "opt4": "All of above",
-    "correct_option": "Linear circuits only.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "The maximum power transfer occurs when:",
-    "opt1": "The load impedance is zero.",
-    "opt2": "The load impedance is equal to the source impedance",
-    "opt3": "The load impedance is infinite.",
-    "opt4": "When load impedance is double of source impedance",
-    "correct_option": "The load impedance is equal to the source impedance",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the formula for calculating the maximum power transfer?",
-    "opt1": "Pmax=V*2",
-    "opt2": "Pmax=V^2 2",
-    "opt3": "Pmax=V^2/4R",
-    "opt4": "Pmax=V^2 2/(2R)",
-    "correct_option": "Pmax=V^2/4R",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "In which applications is the maximum power transfer theorem useful?",
-    "opt1": "Audio",
-    "opt2": "Power supplies",
-    "opt3": "Power transmission systems",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What happens when the load impedance is much larger than the source impedance?",
-    "opt1": "The power transfer is maximum",
-    "opt2": "The power transfer is minimum.",
-    "opt3": "The power transfer is zero",
-    "opt4": "None of above",
-    "correct_option": "The power transfer is minimum.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "The maximum power transfer theorem helps to:",
-    "opt1": "Minimize the amount of energy lost in transmission.",
-    "opt2": "Maximize the amount of energy lost in transmission.",
-    "opt3": "Have no effect on the amount of energy lost in transmission.",
-    "opt4": "Helps to distribute energy evenly in transmission.",
-    "correct_option": "Minimize the amount of energy lost in transmission.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "The maximum power transfer theorem is useful in designing and optimizing:",
-    "opt1": "Power systems",
-    "opt2": "Lighting systems",
-    "opt3": "Communication systems",
-    "opt4": "Both a and c",
-    "correct_option": "Power systems",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the time constant of an R-C circuit consisting of a 1 kΩ resistor and a 100 nF capacitor?",
-    "opt1": "1 ms",
-    "opt2": "100 µs",
-    "opt3": "10 µs",
-    "opt4": "10 ms",
-    "correct_option": "100 µs",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In an R-L circuit, the voltage across the Inductor lags behind the current by how many degrees?",
-    "opt1": "0°",
-    "opt2": "45°",
-    "opt3": "90°",
-    "opt4": "180°",
-    "correct_option": "90°",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the resonant frequency of an R-L-C circuit with a 100 Ω resistor, 1 mH inductor, and a 100 nF capacitor?",
-    "opt1": "160 kHz",
-    "opt2": "16 kHz",
-    "opt3": "1.6 kHz",
-    "opt4": "1.6 MHz",
-    "correct_option": "16 kHz",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In an R-L-C circuit, what happens to the Impedance at resonance?",
-    "opt1": "It is zero",
-    "opt2": "It is at a minimum",
-    "opt3": "It is at a maximum",
-    "opt4": "It is infinite",
-    "correct_option": "It is at a minimum",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "A series R-C circuit has a resistor of 100 Ω and a capacitor of 10 µF. What is the cutoff frequency?",
-    "opt1": "15.9 Hz",
-    "opt2": "159 Hz",
-    "opt3": "1.59 kHz",
-    "opt4": "1.59 Hz",
-    "correct_option": "159 Hz",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In an R-L circuit, what happens to the impedance as the frequency increases?",
-    "opt1": "It increases",
-    "opt2": "It decreases",
-    "opt3": "It remains constant",
-    "opt4": "It oscillates",
-    "correct_option": "It increases",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the phase angle between the voltage and current in an R-L-C circuit at resonance?",
-    "opt1": "0°",
-    "opt2": "45°",
-    "opt3": "90°",
-    "opt4": "180°",
-    "correct_option": "0°",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the time constant of an R-L circuit consisting of a 100 Ω resistor and a 10 mH inductor?",
-    "opt1": "100 µs",
-    "opt2": "1 µs",
-    "opt3": "10 µs",
-    "opt4": "1 ms",
-    "correct_option": "100 µs",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In an R-L-C circuit, what happens to the bandwidth as the quality factor increases?",
-    "opt1": "It increases",
-    "opt2": "It decreases",
-    "opt3": "It remains constant",
-    "opt4": "It oscillates",
-    "correct_option": "It decreases",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the resonant frequency?",
-    "opt1": "15.92 Hz",
-    "opt2": "15.92 kHz",
-    "opt3": "159.2 Hz",
-    "opt4": "1.59 kHz",
-    "correct_option": "1.59 Hz",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which type of circuit contains an inductor and a resistor?",
-    "opt1": "R-L circuit",
-    "opt2": "R-C circuit",
-    "opt3": "R-L-C circuit",
-    "opt4": "None of the above",
-    "correct_option": "R-L circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the time constant of an R-C circuit?",
-    "opt1": "R/C",
-    "opt2": "CR",
-    "opt3": "RC",
-    "opt4": "1/RC",
-    "correct_option": "RC",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the voltage across an inductor in an R-L circuit at steady state?",
-    "opt1": "Zero",
-    "opt2": "Infinite",
-    "opt3": "The same as the voltage across the resistor",
-    "opt4": "None of the above",
-    "correct_option": "Zero",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What happens to the current in an R-L circuit if the inductance is increased?",
-    "opt1": "The current decreases",
-    "opt2": "The current increases",
-    "opt3": "The current remains the same",
-    "opt4": "The current becomes erratic",
-    "correct_option": "The current remains the same",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "In an R-C circuit, what happens to the current as the capacitor becomes fully charged?",
-    "opt1": "The current increases",
-    "opt2": "The current decreases",
-    "opt3": "The current remains the same",
-    "opt4": "The current becomes zero",
-    "correct_option": "The current becomes zero",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the resonance frequency of an R-L-C circuit?",
-    "opt1": "1/(2pisqrt(LC))",
-    "opt2": "2pisqrt(LC)",
-    "opt3": "1/(L*C)",
-    "opt4": "None of the above",
-    "correct_option": "1/(2pisqrt(LC))",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What happens to the impedance of an R-L-C circuit at resonance?",
-    "opt1": "The impedance is maximum",
-    "opt2": "The impedance is minimum",
-    "opt3": "The impedance is zero",
-    "opt4": "The impedance remains the same",
-    "correct_option": "The impedance is minimum",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In an R-L-C circuit, what happens to the phase angle at resonance?",
-    "opt1": "The phase angle is zero",
-    "opt2": "The phase angle is 180 degrees",
-    "opt3": "The phase angle is 90 degrees",
-    "opt4": "The phase angle remains the same",
-    "correct_option": "The phase angle is zero",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the resonant frequency of an AC series circuit consisting of a 20mH Inductor and a 10µF capacitor?",
-    "opt1": "159.15 Hz",
-    "opt2": "318.3 Hz",
-    "opt3": "500 Hz",
-    "opt4": "1000 Hz",
-    "correct_option": "159.15 Hz",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the resonant frequency of an AC parallel circuit consisting of a 10mH inductor and a capacitor 100µF?",
-    "opt1": "318.3 Hz",
-    "opt2": "1000 Hz",
-    "opt3": "159.15 Hz",
-    "opt4": "159.15 Hz",
-    "correct_option": "159.15 Hz",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What happens to the Impedance of an AC series resonant circuit at resonance?",
-    "opt1": "It is minimum",
-    "opt2": "It is maximum",
-    "opt3": "It is zero",
-    "opt4": "It is infinity",
-    "correct_option": "It is minimum",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What happens to the current in an AC parallel resonant circuit at resonance?",
-    "opt1": "It is minimum",
-    "opt2": "It is maximum",
-    "opt3": "It is zero",
-    "opt4": "It is infinity",
-    "correct_option": "It is minimum",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the power factor of an AC series resonant circuit at resonance?",
-    "opt1": "Unity",
-    "opt2": "Zero",
-    "opt3": "Negative",
-    "opt4": "Indeterminate",
-    "correct_option": "Unity",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the power factor of an AC parallel resonant circuit at resonance?",
-    "opt1": "Unity",
-    "opt2": "Zero",
-    "opt3": "Negative",
-    "opt4": "Indeterminate",
-    "correct_option": "Unity",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the phase angle between the voltage and current in an AC series resonant circuit at resonance?",
-    "opt1": "0 degrees",
-    "opt2": "45 degrees",
-    "opt3": "90 degrees",
-    "opt4": "180 degrees",
-    "correct_option": "0 degrees",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the phase angle between the voltage and current in an AC parallel resonant circuit at resonance?",
-    "opt1": "0 degrees",
-    "opt2": "45 degrees",
-    "opt3": "90 degrees",
-    "opt4": "180 degrees",
-    "correct_option": "0 degrees",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What happens to the voltage across the capacitor in an AC series resonant circuit at resonance?",
-    "opt1": "It is maximum",
-    "opt2": "It is minimum",
-    "opt3": "It is zero",
-    "opt4": "It is infinity",
-    "correct_option": "It is maximum",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In an AC series resonant circuit, at the resonant frequency, what is the power factor?",
-    "opt1": "Zero",
-    "opt2": "Unity",
-    "opt3": "Inductive",
-    "opt4": "Capacitive",
-    "correct_option": "Unity",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the resonant frequency of an AC series resonant circuit with an inductance of 5mH and a capacitance 10µF?",
-    "opt1": "3.18 kHz",
-    "opt2": "31.8 kHz",
-    "opt3": "318 kHz",
-    "opt4": "3.18 MHz",
-    "correct_option": "3.18 kHz",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In an AC parallel resonant circuit, at the resonant frequency, what is the impedance?",
-    "opt1": "Zero",
-    "opt2": "Infinite",
-    "opt3": "Minimum",
-    "opt4": "Maximum",
-    "correct_option": "Maximum",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 5µF?",
-    "opt1": "3.57 kHz",
-    "opt2": "35.7 kHz",
-    "opt3": "357 kHz",
-    "opt4": "3.57 MHz",
-    "correct_option": "357 kHz",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the phase relationship between the voltage across the capacitor and the voltage across the inductor in an AC series resonant circuit at resonance?",
-    "opt1": "They are in phase",
-    "opt2": "They are 180 degrees out of phase",
-    "opt3": "They cancel each other out",
-    "opt4": "None of the above",
-    "correct_option": "They are 180 degrees out of phase",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the phase relationship between the current and the voltage in an AC series resonant circuit at resonance?",
-    "opt1": "They are in phase",
-    "opt2": "They are 180 degrees out of phase",
-    "opt3": "They cancel each other out",
-    "opt4": "None of the above",
-    "correct_option": "They are in phase",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the unit of active power?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "None of the above",
-    "correct_option": "Watts (W)",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the formula for reactive power?",
-    "opt1": "Q=V*I",
-    "opt2": "Q=V*I*cos(theta)",
-    "opt3": "Q=V*I*sin(theta)",
-    "opt4": "None of the above",
-    "correct_option": "Q=V*I*sin(theta)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the unit of reactive power?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "None of the above",
-    "correct_option": "Volt-amperes reactive (VAR)",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the formula for active power?",
-    "opt1": "P=V^2I",
-    "opt2": "P=V*I*cos(theta)",
-    "opt3": "P=V*I*sin(theta)",
-    "opt4": "None of the above",
-    "correct_option": "P=V*I*cos(theta)",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the unit of apparent power?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "None of the above",
-    "correct_option": "Volt-amperes (VA)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the formula for power factor?",
-    "opt1": "pf=Q/S",
-    "opt2": "pf=P/Q",
-    "opt3": "pf=P/S",
-    "opt4": "None of the above",
-    "correct_option": "pf=P/S",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the unit of power factor?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "None of the above",
-    "correct_option": "None of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the relationship between active power and reactive power?",
-    "opt1": "They are the same thing",
-    "opt2": "Reactive power is always greater than active power",
-    "opt3": "Active power is always greater than reactive power",
-    "opt4": "They are two different types of power",
-    "correct_option": "They are two different types of power",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the formula for apparent power?",
-    "opt1": "S=V",
-    "opt2": "S=V*I*cos(theta)",
-    "opt3": "S=V^2I*sin(theta)",
-    "opt4": "None of the above",
-    "correct_option": "S=V*I (Calculated)",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the significance of power factor in electrical circuits?",
-    "opt1": "It determines the maximum power that can be delivered to the circuit",
-    "opt2": "It measures the efficiency of the circuit in using the power delivered to it",
-    "opt3": "It is a measure of the resistance of the circuit",
-    "opt4": "None of the above",
-    "correct_option": "It measures the efficiency of the circuit in using the power delivered to it",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is a measure of how efficiently the circuit is using the power delivered to it?",
-    "opt1": "Active power",
-    "opt2": "Reactive power",
-    "opt3": "Apparent power",
-    "opt4": "Power factor",
-    "correct_option": "Power factor",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which type of power is used in the circuit to perform useful work?",
-    "opt1": "Active power",
-    "opt2": "Reactive power",
-    "opt3": "Apparent power",
-    "opt4": "None of the above",
-    "correct_option": "Active power",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of power is stored and released by the circuit?",
-    "opt1": "Active power",
-    "opt2": "Reactive power",
-    "opt3": "Apparent power",
-    "opt4": "None of the above",
-    "correct_option": "Reactive power",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the power factor of a circuit that has 100 W of active power and 120 VA of apparent power?",
-    "opt1": "0.83",
-    "opt2": "1.20",
-    "opt3": "0.20",
-    "opt4": "0.01",
-    "correct_option": "0.83",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What happens to the power factor of a circuit if the reactive power increases?",
-    "opt1": "It increases",
-    "opt2": "It decreases",
-    "opt3": "It remains the same",
-    "opt4": "Cannot be determined",
-    "correct_option": "It decreases",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is not a measure of power in an AC circuit?",
-    "opt1": "Volt-amperes reactive (VAR)",
-    "opt2": "Watts (W)",
-    "opt3": "Volt-amperes (VA)",
-    "opt4": "Hertz (Hz)",
-    "correct_option": "Hertz (Hz)",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which BJT configuration has unity voltage gain?",
-    "opt1": "Common Emitter",
-    "opt2": "Common Base",
-    "opt3": "Common Collector",
-    "opt4": "Both A and B",
-    "correct_option": "Common Collector",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which biasing technique uses a fixed DC voltage applied to the base terminal with respect to the emitter terminal?",
-    "opt1": "Fixed Bias",
-    "opt2": "Self-Bias",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Fixed Bias",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which biasing technique uses a resistor in series with the base-emitter junction for negative feedback?",
-    "opt1": "Fixed Bias",
-    "opt2": "Self-Bias",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Self-Bias",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which BJT configuration has low voltage gain and high current gain?",
-    "opt1": "Common Emitter",
-    "opt2": "Common Base",
-    "opt3": "Common Collector",
-    "opt4": "Both A and B",
-    "correct_option": "Common Collector",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "In which BJT configuration is the collector terminal common to both input and output circuits?",
-    "opt1": "Common Emitter",
-    "opt2": "Common Base",
-    "opt3": "Common Collector",
-    "opt4": "Both b and c",
-    "correct_option": "Common Collector",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which biasing technique is stable with changes in temperature and transistor parameters?",
-    "opt1": "Fixed Bias",
-    "opt2": "Self-Bias",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Self-Bias",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which BJT configuration is commonly used in voltage amplifier circuits?",
-    "opt1": "Common Emitter",
-    "opt2": "Common Base",
-    "opt3": "Common Collector",
-    "opt4": "Both A and B",
-    "correct_option": "Common Emitter",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In which BJT configuration is the base terminal common to both input and output circuits?",
-    "opt1": "Common Emitter",
-    "opt2": "Common Base",
-    "opt3": "Common Collector",
-    "opt4": "Both A and B",
-    "correct_option": "Common Base",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which model is used to analyze a circuit's behavior when a small AC signal is applied?",
-    "opt1": "Large Signal Model",
-    "opt2": "Small Signal Model",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Small Signal Model",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which model is used to analyze a circuit's behavior when a large DC signal is applied?",
-    "opt1": "Large Signal Model",
-    "opt2": "Small Signal Model",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Large Signal Model",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which model uses linear circuit analysis techniques such as superposition, Thevenin's theorem, and Norton's theorem?",
-    "opt1": "Large Signal Model",
-    "opt2": "Small Signal Model",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Small Signal Model",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which model uses nonlinear circuit analysis techniques such as load-line analysis and graphical analysis?",
-    "opt1": "Large Signal Model",
-    "opt2": "Small Signal Model",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Large Signal Model",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which model represents the transistor as a voltage-controlled current source?",
-    "opt1": "Large Signal Model",
-    "opt2": "Small Signal Model",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Small Signal Model",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which model includes the effects of the nonlinear components such as diodes, transistors, and operational amplifiers?",
-    "opt1": "Large Signal Model",
-    "opt2": "Small Signal Model",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Large Signal Model",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which model is used to analyze switching circuits?",
-    "opt1": "Large Signal Model of BJT",
-    "opt2": "Small Signal Model of BJT",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Large Signal Model of BJT",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which model is used to design and analyze amplifier circuits?",
-    "opt1": "Large Signal Model of BJT",
-    "opt2": "Small Signal Model of BJT",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Small Signal Model of BJT",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which model uses the transistor parameters such as hfe, hie, and hoe to calculate the voltage gain and current gain of the circuit?",
-    "opt1": "Large Signal Model of BJT",
-    "opt2": "Small Signal Model of BJT",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Small Signal Model of BJT",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which model uses the transistor parameters such as saturation voltage, Vce(sat), and cut-off voltage, Vce(cut-off) to analyze the circuit's behavior?",
-    "opt1": "Large Signal Model of BJT",
-    "opt2": "Small Signal Model of BJT",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Large Signal Model of BJT",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What does MOSFET stand for?",
-    "opt1": "Metal-Oxide-Semiconductor Field-Effect Transistor",
-    "opt2": "Magnetic-Oscillation-Silicon Field-Effect Transistor",
-    "opt3": "Multi-Oscillator-Silicon Field-Effect Transistor",
-    "opt4": "None of above",
-    "correct_option": "Metal-Oxide-Semiconductor Field-Effect Transistor",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In which region of operation does the MOSFET act as a voltage-controlled resistor?",
-    "opt1": "Cut-off region",
-    "opt2": "Saturation region",
-    "opt3": "Triode region",
-    "opt4": "None of above",
-    "correct_option": "Triode region",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the threshold voltage of a MOSFET?",
-    "opt1": "The voltage required to turn on the MOSFET",
-    "opt2": "The voltage required to turn off the MOSFET",
-    "opt3": "The voltage at which the MOSFET conducts maximum current",
-    "opt4": "The voltage at which the MOSFET conducts minimum current",
-    "correct_option": "The voltage required to turn on the MOSFET",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of MOSFET has a lower on-resistance and higher switching speed?",
-    "opt1": "Enhancement-mode MOSFET",
-    "opt2": "Depletion-mode MOSFET",
-    "opt3": "Both have the same characteristics",
-    "opt4": "None of above",
-    "correct_option": "Enhancement-mode MOSFET",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the full form of CMOS?",
-    "opt1": "Complementary Metal-Oxide-Semiconductor",
-    "opt2": "Complex Metal-Oxide-Semiconductor",
-    "opt3": "Complementary Magnetic-Oscillation-Semiconductor",
-    "opt4": "Complementary Magnetic Oxide Semiconductor",
-    "correct_option": "Complementary Metal-Oxide-Semiconductor",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which logic family uses CMOS technology?",
-    "opt1": "TTL",
-    "opt2": "ECL",
-    "opt3": "CMOS",
-    "opt4": "All of above",
-    "correct_option": "CMOS",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of logic gate is used to implement the CMOS circuit?",
-    "opt1": "NAND gate",
-    "opt2": "NOR gate",
-    "opt3": "Both NAND and NOR gates",
-    "opt4": "None of above",
-    "correct_option": "Both NAND and NOR gates",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the main advantage of CMOS technology over other logic families?",
-    "opt1": "Low power consumption",
-    "opt2": "High speed",
-    "opt3": "Low cost",
-    "opt4": "All of above",
-    "correct_option": "Low power consumption",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of MOSFET is more commonly used in digital logic circuits?",
-    "opt1": "N-channel MOSFET",
-    "opt2": "P-channel MOSFET",
-    "opt3": "Both A and B are equally used",
-    "opt4": "None of above",
-    "correct_option": "N-channel MOSFET",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which application of MOSFET is used in power electronics?",
-    "opt1": "Switching",
-    "opt2": "Amplification",
-    "opt3": "Oscillation",
-    "opt4": "All of above",
-    "correct_option": "Switching",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following describes the working principle of a MOSFET?",
-    "opt1": "A voltage applied to the gate terminal creates an electric field that controls the current flow through the channel between the source and drain terminals.",
-    "opt2": "The current flow through the channel between the source and drain terminals controls the voltage applied to the gate terminal.",
-    "opt3": "The current flow through the channel between the source and drain terminals is independent of the voltage applied to the gate terminal.",
-    "opt4": "None of above",
-    "correct_option": "A voltage applied to the gate terminal creates an electric field that controls the current flow through the channel between the source and drain terminals.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the basic building block of a CMOS circuit?",
-    "opt1": "Bipolar Junction Transistor (BJT)",
-    "opt2": "Field Effect Transistor (FET)",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Field Effect Transistor (FET)",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following describes the working principle of a CMOS circuit?",
-    "opt1": "The output is a function of the input voltage and the current flowing through the transistor.",
-    "opt2": "The output is a function of the input voltage and the voltage level at the gate of the transistor.",
-    "opt3": "The output is a function of the input voltage and the logic level of the transistor",
-    "opt4": "None of above",
-    "correct_option": "The output is a function of the input voltage and the voltage level at the gate of the transistor.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following statements is true about MOSFETs?",
-    "opt1": "They have a high input impedance and a low output impedance.",
-    "opt2": "They have a low input impedance and a high output impedance.",
-    "opt3": "They have both high input and output impedances.",
-    "opt4": "All of above",
-    "correct_option": "They have a high input impedance and a low output impedance.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following describes the typical applications of MOSFETs?",
-    "opt1": "Digital logic circuits and memory devices",
-    "opt2": "Power amplifiers and switching circuits",
-    "opt3": "Power switching and amplification",
-    "opt4": "Both A and B",
-    "correct_option": "Both A and B",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is an advantage of CMOS technology?",
-    "opt1": "Low power consumption",
-    "opt2": "High speed operation",
-    "opt3": "High gain",
-    "opt4": "All of above",
-    "correct_option": "Low power consumption",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about CMOS circuits?",
-    "opt1": "They are sensitive to noise and interference.",
-    "opt2": "They have a higher power consumption compared to other technologies.",
-    "opt3": "They are immune to noise and interference and have low power consumption.",
-    "opt4": "None of above",
-    "correct_option": "They are immune to noise and interference and have low power consumption.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following describes the typical applications of CMOS circuits?",
-    "opt1": "Microprocessors and digital logic circuits",
-    "opt2": "Power amplifiers and switching circuits",
-    "opt3": "Both A and B",
-    "opt4": "None of above",
-    "correct_option": "Microprocessors and digital logic circuits",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about MOSFETs and CMOS circuits?",
-    "opt1": "MOSFETs are more suitable for digital logic circuits, while CMOS circuits are more suitable for power switching applications.",
-    "opt2": "Both MOSFETs and CMOS circuits can be used for power switching and digital logic circuits.",
-    "opt3": "MOSFETs are more suitable for power switching applications, while CMOS circuits are more suitable for digital logic circuits.",
-    "opt4": "None of above",
-    "correct_option": "MOSFETs are more suitable for power switching applications, while CMOS circuits are more suitable for digital logic circuits.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of oscillator uses a resistor and capacitor in a feedback circuit?",
-    "opt1": "RC oscillator",
-    "opt2": "LC oscillator",
-    "opt3": "Crystal oscillator",
-    "opt4": "None of the above",
-    "correct_option": "RC oscillator",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What determines the frequency of an RC oscillator?",
-    "opt1": "The time constant of the RC circuit",
-    "opt2": "The resonant frequency of the tank circuit",
-    "opt3": "The inductance of a coil",
-    "opt4": "The capacitance of a capacitor",
-    "correct_option": "The time constant of the RC circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of oscillator uses an inductor and capacitor in a feedback circuit?",
-    "opt1": "RC oscillator",
-    "opt2": "LC oscillator",
-    "opt3": "Crystal oscillator",
-    "opt4": "None of the above",
-    "correct_option": "LC oscillator",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What determines the frequency of an LC oscillator?",
-    "opt1": "The time constant of an RC circuit",
-    "opt2": "The resonant frequency of a tank circuit",
-    "opt3": "The inductance of a coil",
-    "opt4": "The capacitance of a capacitor",
-    "correct_option": "The resonant frequency of a tank circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of oscillator uses a quartz crystal as the resonant element in the feedback circuit?",
-    "opt1": "RC oscillator",
-    "opt2": "LC oscillator",
-    "opt3": "Crystal oscillator",
-    "opt4": "None of the above",
-    "correct_option": "Crystal oscillator",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the primary advantage of using a crystal oscillator?",
-    "opt1": "Low cost",
-    "opt2": "Simplicity",
-    "opt3": "High frequency stability and accuracy",
-    "opt4": "Low power consumption",
-    "correct_option": "High frequency stability and accuracy",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the role of the feedback circuit in an oscillator?",
-    "opt1": "To amplify the input signal",
-    "opt2": "To filter out unwanted frequencies",
-    "opt3": "To provide positive feedback to sustain oscillations",
-    "opt4": "To provide negative feedback to stabilize the oscillations",
-    "correct_option": "To provide positive feedback to sustain oscillations",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of oscillator is commonly used in digital circuits?",
-    "opt1": "RC oscillator",
-    "opt2": "LC oscillator",
-    "opt3": "Crystal oscillator",
-    "opt4": "Square wave generator",
-    "correct_option": "Crystal oscillator",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of oscillator is typically the most complex and expensive?",
-    "opt1": "RC oscillator",
-    "opt2": "LC oscillator",
-    "opt3": "Crystal oscillator",
-    "opt4": "None of the above",
-    "correct_option": "Crystal oscillator",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the resonant circuit in an oscillator?",
-    "opt1": "To amplify the input signal",
-    "opt2": "To filter out unwanted frequencies",
-    "opt3": "To provide positive feedback to sustain oscillations",
-    "opt4": "To provide negative feedback to stabilize the oscillations",
-    "correct_option": "To provide positive feedback to sustain oscillations",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is an RC oscillator?",
-    "opt1": "An oscillator that uses a resistor and capacitor in a feedback circuit",
-    "opt2": "An oscillator that uses an inductor and capacitor in a feedback circuit",
-    "opt3": "An oscillator that uses a quartz crystal in a feedback circuit",
-    "opt4": "An oscillator that uses a diode in a feedback circuit",
-    "correct_option": "An oscillator that uses a resistor and capacitor in a feedback circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What determines the frequency of an RC oscillator?",
-    "opt1": "The time constant of the RC circuit",
-    "opt2": "The resonant frequency of the tank circuit",
-    "opt3": "The frequency of the crystal",
-    "opt4": "The input voltage of the oscillator",
-    "correct_option": "The time constant of the RC circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the advantage of using an LC oscillator over an RC oscillator?",
-    "opt1": "Greater simplicity and lower cost",
-    "opt2": "Higher frequency stability and accuracy",
-    "opt3": "Higher power output",
-    "opt4": "Greater frequency range",
-    "correct_option": "Higher frequency stability and accuracy",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is a tank circuit in an LC oscillator?",
-    "opt1": "A circuit that filters out unwanted frequencies",
-    "opt2": "A circuit that amplifies the input signal",
-    "opt3": "A circuit that provides positive feedback",
-    "opt4": "A circuit that consists of an inductor and capacitor in a feedback circuit",
-    "correct_option": "A circuit that consists of an inductor and capacitor in a feedback circuit",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the resonant frequency of a crystal oscillator determined by?",
-    "opt1": "The time constant of the RC circuit",
-    "opt2": "The resonant frequency of the tank circuit",
-    "opt3": "The frequency of the crystal",
-    "opt4": "The input voltage of the oscillator",
-    "correct_option": "The frequency of the crystal",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the advantage of using a crystal oscillator over an LC oscillator?",
-    "opt1": "Greater simplicity and lower cost",
-    "opt2": "Higher frequency stability and accuracy",
-    "opt3": "Higher power output",
-    "opt4": "Greater frequency range",
-    "correct_option": "Higher frequency stability and accuracy",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of oscillator is typically used in clocks and digital circuits?",
-    "opt1": "RC oscillator",
-    "opt2": "LC oscillator",
-    "opt3": "Crystal oscillator",
-    "opt4": "Relaxation oscillator",
-    "correct_option": "Crystal oscillator",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of positive feedback in an oscillator?",
-    "opt1": "To amplify the input signal",
-    "opt2": "To provide a frequency-selective response",
-    "opt3": "To sustain oscillations",
-    "opt4": "To filter out unwanted frequencies",
-    "correct_option": "To sustain oscillations",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the role of the resonant circuit in an oscillator?",
-    "opt1": "To provide positive feedback",
-    "opt2": "To amplify the input signal",
-    "opt3": "To filter out unwanted frequencies",
-    "opt4": "To provide a frequency-selective response",
-    "correct_option": "To provide a frequency-selective response",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the advantage of using a high-Q resonant circuit in an oscillator?",
-    "opt1": "Greater simplicity and lower cost",
-    "opt2": "Higher frequency stability and accuracy",
-    "opt3": "Higher power output",
-    "opt4": "Greater frequency range",
-    "correct_option": "Higher frequency stability and accuracy",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the duty cycle of a square wave generator?",
-    "opt1": "The time period of the waveform",
-    "opt2": "The ratio of the pulse width to the time period",
-    "opt3": "The amplitude of the waveform",
-    "opt4": "The frequency of the waveform",
-    "correct_option": "The ratio of the pulse width to the time period",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What type of waveform is produced by a triangle wave generator?",
-    "opt1": "A waveform with constant amplitude and frequency",
-    "opt2": "A waveform with a linearly increasing or decreasing amplitude",
-    "opt3": "A waveform with a constant frequency and varying amplitude",
-    "opt4": "A waveform with random fluctuations in amplitude and frequency",
-    "correct_option": "A waveform with a linearly increasing or decreasing amplitude",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What type of circuit is commonly used to generate square wave signals?",
-    "opt1": "An op-amp circuit",
-    "opt2": "A transistor circuit",
-    "opt3": "A flip-flop circuit",
-    "opt4": "A filter circuit",
-    "correct_option": "An op-amp circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the advantage of using a relaxation oscillator for square wave generation?",
-    "opt1": "Simplicity and low cost",
-    "opt2": "High frequency stability and accuracy",
-    "opt3": "High power output",
-    "opt4": "Greater frequency range",
-    "correct_option": "Simplicity and low cost",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the role of a Schmitt trigger in a square wave generator circuit?",
-    "opt1": "To generate a clean and stable square wave signal",
-    "opt2": "To provide frequency-selective response",
-    "opt3": "To amplify the input signal",
-    "opt4": "To filter out unwanted frequencies",
-    "correct_option": "To generate a clean and stable square wave signal",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the frequency of a triangle wave generator determined by?",
-    "opt1": "The time constant of the RC circuit",
-    "opt2": "The resonant frequency of the tank circuit",
-    "opt3": "The frequency of the crystal",
-    "opt4": "The input voltage of the oscillator",
-    "correct_option": "The time constant of the RC circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the advantage of using a ramp generator for triangle wave generation?",
-    "opt1": "Simplicity and low cost",
-    "opt2": "High frequency stability and accuracy",
-    "opt3": "High power output",
-    "opt4": "Greater frequency range",
-    "correct_option": "Simplicity and low cost",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What type of circuit is commonly used to generate triangle wave signals?",
-    "opt1": "An op-amp circuit",
-    "opt2": "An integrator circuit",
-    "opt3": "A flip-flop circuit",
-    "opt4": "A transistor circuit",
-    "correct_option": "An integrator circuit",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the amplitude of a triangle wave generator determined by?",
-    "opt1": "The time constant of the RC circuit",
-    "opt2": "The resonant frequency of the tank circuit",
-    "opt3": "The frequency of the crystal",
-    "opt4": "The input voltage of the oscillator",
-    "correct_option": "The input voltage of the oscillator",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the advantage of using an op-amp circuit for triangle wave generation?",
-    "opt1": "Simplicity and low cost",
-    "opt2": "High frequency stability and accuracy",
-    "opt3": "High power output",
-    "opt4": "Greater frequency range",
-    "correct_option": "Simplicity and low cost",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which waveform generator is typically used for testing digital circuits?",
-    "opt1": "Sine wave generator",
-    "opt2": "Square wave generator",
-    "opt3": "Triangle wave generator",
-    "opt4": "Sawtooth wave generator",
-    "correct_option": "Square wave generator",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the duty cycle of a square wave?",
-    "opt1": "The time period of the wave",
-    "opt2": "The ratio of the pulse width to the time period",
-    "opt3": "The frequency of the wave",
-    "opt4": "The amplitude of the wave",
-    "correct_option": "The ratio of the pulse width to the time period",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the advantage of using a square wave generator over other types of waveform generators?",
-    "opt1": "Simplicity and low cost",
-    "opt2": "High frequency stability and accuracy",
-    "opt3": "High power output",
-    "opt4": "Wide range of frequency and waveform options",
-    "correct_option": "Simplicity and low cost",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which waveform generator is capable of producing more complex waveforms than a square wave generator?",
-    "opt1": "Sine wave generator",
-    "opt2": "Triangle wave generator",
-    "opt3": "Sawtooth wave generator",
-    "opt4": "Arbitrary waveform generator",
-    "correct_option": "Arbitrary waveform generator",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the shape of the waveform produced by a triangle wave generator?",
-    "opt1": "A series of pulses with a constant amplitude",
-    "opt2": "A smoothly varying waveform with a linear rise and fall",
-    "opt3": "A waveform with a rapidly changing rise and a slow fall",
-    "opt4": "A waveform with a rapidly changing fall and a slow rise",
-    "correct_option": "A smoothly varying waveform with a linear rise and fall",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the frequency of a triangle wave generator determined by?",
-    "opt1": "The time period of the waveform",
-    "opt2": "The amplitude of the waveform",
-    "opt3": "The duty cycle of the waveform",
-    "opt4": "The slope of the waveform",
-    "correct_option": "The slope of the waveform",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the advantage of using a triangle wave generator over a square wave generator?",
-    "opt1": "Greater simplicity and lower cost",
-    "opt2": "Higher frequency stability and accuracy",
-    "opt3": "Higher power output",
-    "opt4": "More gradual transitions and reduced harmonic content",
-    "correct_option": "More gradual transitions and reduced harmonic content",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which type of waveform generator is commonly used in audio applications?",
-    "opt1": "Sine wave generator",
-    "opt2": "Square wave generator",
-    "opt3": "Triangle wave generator",
-    "opt4": "Sawtooth wave generator",
-    "correct_option": "Sine wave generator",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the shape of the waveform produced by a sawtooth wave generator?",
-    "opt1": "A series of pulses with a constant amplitude",
-    "opt2": "A smoothly varying waveform with a linear rise and fall",
-    "opt3": "A waveform with a rapidly changing rise and a slow fall",
-    "opt4": "A waveform with a rapidly changing fall and a slow rise",
-    "correct_option": "A waveform with a rapidly changing rise and a slow fall",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the advantage of using an arbitrary waveform generator over other types of waveform generators?",
-    "opt1": "Greater simplicity and lower cost",
-    "opt2": "Higher frequency stability and accuracy",
-    "opt3": "Higher power output",
-    "opt4": "The ability to generate complex and customized waveforms",
-    "correct_option": "The ability to generate complex and customized waveforms",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the amplifying element used in a Class A output stage?",
-    "opt1": "Bipolar Junction Transistor",
-    "opt2": "Field-Effect Transistor",
-    "opt3": "Operational Amplifier",
-    "opt4": "Vacuum Tube",
-    "correct_option": "Bipolar Junction Transistor",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What causes crossover distortion in a Class B output stage?",
-    "opt1": "The amplifying element conducts for the entire input signal cycle",
-    "opt2": "The amplifying element is biased so that it conducts for less than half of the input signal cycle",
-    "opt3": "Two amplifying elements are used and each one conducts for half of the input signal cycle",
-    "opt4": "The switching between the amplifying elements causes a gap in the output signal.",
-    "correct_option": "The switching between the amplifying elements causes a gap in the output signal.",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the advantage of a Class AB output stage over a Class B output stage?",
-    "opt1": "Higher efficiency",
-    "opt2": "Lower distortion",
-    "opt3": "Reduced crossover distortion",
-    "opt4": "Lower cost",
-    "correct_option": "Reduced crossover distortion",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the operating mode of a Class C output stage?",
-    "opt1": "Linear",
-    "opt2": "Non-linear",
-    "opt3": "Saturated",
-    "opt4": "Reverse biased",
-    "correct_option": "Non-linear",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the advantage of a Class D output stage over other output stages?",
-    "opt1": "Low distortion",
-    "opt2": "High linearity",
-    "opt3": "High efficiency",
-    "opt4": "Low switching noise",
-    "correct_option": "High efficiency",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the primary disadvantage of a Class A output stage?",
-    "opt1": "High distortion",
-    "opt2": "Low efficiency",
-    "opt3": "High switching noise",
-    "opt4": "High cost",
-    "correct_option": "Low efficiency",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of output stage is suitable for RF amplifiers?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class C",
-    "correct_option": "Class C",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the biasing arrangement used in a Class AB output stage?",
-    "opt1": "The amplifying element is biased to conduct for the entire input signal cycle.",
-    "opt2": "The amplifying element is biased to conduct for less than half of the input signal cycle.",
-    "opt3": "The bias voltage is varied to adjust the conduction angle.",
-    "opt4": "Two amplifying elements are used and each one conducts for half of the input signal cycle.",
-    "correct_option": "The bias voltage is varied to adjust the conduction angle.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of output stage is used in audio power amplifiers?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class C",
-    "correct_option": "Class AB",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of output stage is commonly used in switch-mode power supplies?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class D",
-    "correct_option": "Class D",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a characteristic of a class A output stage?",
-    "opt1": "High efficiency",
-    "opt2": "Low distortion",
-    "opt3": "Crossover distortion",
-    "opt4": "Conducts for less than half of the input signal cycle",
-    "correct_option": "Low distortion",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following output stages uses two amplifying elements that conduct for half of the input signal cycle each?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class C",
-    "opt4": "Class AB",
-    "correct_option": "Class B",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following output stages is a combination of class A and class B?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class C",
-    "correct_option": "Class AB",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following output stages is suitable for RF amplifiers?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class C",
-    "correct_option": "Class C",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following output stages uses pulse width modulation to convert the input signal into a train of pulses?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class C",
-    "opt4": "Class D",
-    "correct_option": "Class D",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of a class B output stage?",
-    "opt1": "Low distortion",
-    "opt2": "High efficiency",
-    "opt3": "Crossover distortion",
-    "opt4": "Conducts for the entire input signal cycle",
-    "correct_option": "Crossover distortion",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following output stages is the most efficient?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class C",
-    "correct_option": "Class C",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following output stages is the least efficient?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class C",
-    "correct_option": "Class A",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following output stages has a biasing arrangement that allows the amplifying element to conduct slightly even when there is no input signal?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class C",
-    "correct_option": "Class AB",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following output stages is suitable for high power audio amplifiers?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class C",
-    "correct_option": "Class AB",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the main advantage of a Class A output stage?",
-    "opt1": "High efficiency",
-    "opt2": "Low distortion",
-    "opt3": "Low power consumption",
-    "opt4": "High output power",
-    "correct_option": "Low distortion",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the main disadvantage of a Class A output stage?",
-    "opt1": "High distortion",
-    "opt2": "Low efficiency",
-    "opt3": "High power consumption",
-    "opt4": "Low output power",
-    "correct_option": "Low efficiency",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What type of biasing is commonly used in Class A output stages?",
-    "opt1": "Fixed bias",
-    "opt2": "Self-bias",
-    "opt3": "Voltage divider bias",
-    "opt4": "Current mirror bias",
-    "correct_option": "Fixed bias",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the DC bias point of a Class A output stage?",
-    "opt1": "Equal to the positive supply voltage",
-    "opt2": "Halfway between the positive and negative supply voltage",
-    "opt3": "Equal to the negative supply voltage",
-    "opt4": "Zero",
-    "correct_option": "Halfway between the positive and negative supply voltage",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the maximum theoretical efficiency of a Class A output stage?",
-    "opt1": "25%",
-    "opt2": "50%",
-    "opt3": "75%",
-    "opt4": "100%",
-    "correct_option": "50%",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the typical output power of a Class A amplifier?",
-    "opt1": "Less than 1 watt",
-    "opt2": "1 watt to 10 watts",
-    "opt3": "10 watts to 100 watts",
-    "opt4": "More than 100 watts",
-    "correct_option": "1 watt to 10 watts",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What type of load is commonly used in Class A output stages?",
-    "opt1": "Resistive load",
-    "opt2": "Capacitive load",
-    "opt3": "Inductive load",
-    "opt4": "Reactive load",
-    "correct_option": "Resistive load",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the main advantage of a Class A output stage over other amplifier configurations?",
-    "opt1": "High efficiency",
-    "opt2": "High output power",
-    "opt3": "Low distortion",
-    "opt4": "Low power consumption",
-    "correct_option": "Low distortion",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What type of input signal is best suited for a Class A output stage?",
-    "opt1": "Sinusoidal signal",
-    "opt2": "Square wave signal",
-    "opt3": "Triangular wave signal",
-    "opt4": "Pulse signal",
-    "correct_option": "Sinusoidal signal",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the typical voltage gain of a Class A amplifier?",
-    "opt1": "Less than 10",
-    "opt2": "10 to 100",
-    "opt3": "100 to 1000",
-    "opt4": "More than 1000",
-    "correct_option": "10 to 100",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is a characteristic of a Class A output stage?",
-    "opt1": "High efficiency",
-    "opt2": "Low distortion",
-    "opt3": "Crossover distortion",
-    "opt4": "Conducts for less than half of the input signal cycle",
-    "correct_option": "Low distortion",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a Class A output stage, the amplifying device conducts for:",
-    "opt1": "Half of the input signal cycle",
-    "opt2": "Less than half of the input signal cycle",
-    "opt3": "More than half of the input signal cycle",
-    "opt4": "The entire input signal cycle",
-    "correct_option": "The entire input signal cycle",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "The efficiency of a Class A output stage is:",
-    "opt1": "High",
-    "opt2": "Low",
-    "opt3": "Moderate",
-    "opt4": "Not applicable",
-    "correct_option": "Low",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the advantage of a Class A output stage over other classes of amplifiers?",
-    "opt1": "Higher efficiency",
-    "opt2": "Lower distortion",
-    "opt3": "Lower cost",
-    "opt4": "Higher power output",
-    "correct_option": "Lower distortion",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the key feature of a Class A output stage?",
-    "opt1": "The amplifying device conducts for the entire input signal cycle",
-    "opt2": "The amplifying device conducts for only half of the input signal cycle",
-    "opt3": "The amplifying device conducts for less than half of the input signal cycle",
-    "opt4": "The amplifying device is biased to a cutoff state",
-    "correct_option": "The amplifying device conducts for the entire input signal cycle",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the typical efficiency of a Class A output stage?",
-    "opt1": "100%",
-    "opt2": "50%",
-    "opt3": "25%",
-    "opt4": "Less than 10%",
-    "correct_option": "25%",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of a Class A output stage?",
-    "opt1": "High efficiency",
-    "opt2": "High distortion",
-    "opt3": "High cost",
-    "opt4": "Low power output",
-    "correct_option": "Low power output",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which type of amplifying device is commonly used in Class A output stages?",
-    "opt1": "Bipolar Junction Transistor (BJT)",
-    "opt2": "Metal-Oxide-Semiconductor Field-Effect Transistor (MOSFET)",
-    "opt3": "Junction Field-Effect Transistor (JFET)",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the purpose of the biasing circuit in a Class A output stage?",
-    "opt1": "To set the operating point of the amplifying device",
-    "opt2": "To provide negative feedback",
-    "opt3": "To boost the output signal",
-    "opt4": "To reduce distortion",
-    "correct_option": "To set the operating point of the amplifying device",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the quiescent current of a Class A output stage?",
-    "opt1": "The maximum current the amplifying device can handle",
-    "opt2": "The current flowing through the load resistor when there is no input signal",
-    "opt3": "The current required to bias the amplifying device",
-    "opt4": "The current flowing through the amplifying device when there is no input signal",
-    "correct_option": "The current flowing through the amplifying device when there is no input signal",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a common application of a Class A output stage?",
-    "opt1": "Audio power amplifiers",
-    "opt2": "RF amplifiers",
-    "opt3": "Voltage regulators",
-    "opt4": "Digital circuits",
-    "correct_option": "Audio power amplifiers",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is a characteristic of the output signal of a Class A output stage?",
-    "opt1": "It is a square wave",
-    "opt2": "It is a sine wave",
-    "opt3": "It is a triangular wave",
-    "opt4": "It depends on the input signal",
-    "correct_option": "It depends on the input signal",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of a Class A output stage in terms of power efficiency?",
-    "opt1": "It generates more heat than other classes of amplifiers",
-    "opt2": "It consumes more power than other classes of amplifiers",
-    "opt3": "It is more expensive than other classes of amplifiers",
-    "opt4": "It has a lower power output than other classes of amplifiers",
-    "correct_option": "It generates more heat than other classes of amplifiers",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a Class B output stage in amplifiers?",
-    "opt1": "An amplifier configuration where the amplifying device conducts for the full input signal cycle",
-    "opt2": "An amplifier configuration where the amplifying device conducts only for half of the input signal cycle",
-    "opt3": "An amplifier configuration where the output signal is inverted with respect to the input signal",
-    "opt4": "An amplifier configuration where two input signals are combined to produce the output signal",
-    "correct_option": "An amplifier configuration where the amplifying device conducts only for half of the input signal cycle",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the advantage of a Class B output stage?",
-    "opt1": "High power efficiency",
-    "opt2": "Low distortion",
-    "opt3": "High linearity",
-    "opt4": "Large voltage gain",
-    "correct_option": "High power efficiency",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is crossover distortion in a Class B output stage?",
-    "opt1": "A reduction in the voltage gain of the amplifier",
-    "opt2": "A discontinuity in the output signal at the point where one device switches off and the other switches on",
-    "opt3": "A change in the phase shift of the output signal",
-    "opt4": "An increase in the noise level of the amplifier",
-    "correct_option": "A discontinuity in the output signal at the point where one device switches off and the other switches on",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How is crossover distortion reduced in a Class B output stage?",
-    "opt1": "By increasing the voltage gain of the amplifier",
-    "opt2": "By decreasing the load impedance of the amplifier",
-    "opt3": "By applying a small amount of bias current to the amplifying devices",
-    "opt4": "By using a feedback network in the amplifier",
-    "correct_option": "By applying a small amount of bias current to the amplifying devices",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the main application of Class B output stages?",
-    "opt1": "Audio power amplifiers",
-    "opt2": "Voltage amplifiers",
-    "opt3": "Current amplifiers",
-    "opt4": "Low noise amplifiers",
-    "correct_option": "Audio power amplifiers",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the main disadvantage of Class B output stages?",
-    "opt1": "Crossover distortion",
-    "opt2": "Low power efficiency",
-    "opt3": "High distortion",
-    "opt4": "Poor linearity",
-    "correct_option": "Crossover distortion",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of biasing in a Class B output stage?",
-    "opt1": "To keep the amplifying devices slightly conductive even when there is no input signal",
-    "opt2": "To increase the voltage gain of the amplifier",
-    "opt3": "To decrease the noise level of the amplifier",
-    "opt4": "To reduce the distortion of the amplifier",
-    "correct_option": "To keep the amplifying devices slightly conductive even when there is no input signal",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the output signal waveform of a Class B output stage?",
-    "opt1": "A square wave",
-    "opt2": "A sawtooth wave",
-    "opt3": "A sine wave",
-    "opt4": "A combination of the signals produced by each device",
-    "correct_option": "A combination of the signals produced by each device",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What type of load is typically used with a Class B output stage?",
-    "opt1": "Resistive load",
-    "opt2": "Capacitive load",
-    "opt3": "Inductive load",
-    "opt4": "None of the above",
-    "correct_option": "Resistive load",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the maximum theoretical efficiency of a Class B output stage?",
-    "opt1": "50%",
-    "opt2": "75%",
-    "opt3": "90%",
-    "opt4": "100%",
-    "correct_option": "75%",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a Class B output stage, how many amplifying devices are used?",
-    "opt1": "One",
-    "opt2": "Two",
-    "opt3": "Three",
-    "opt4": "Four",
-    "correct_option": "Two",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the key advantage of a Class B output stage?",
-    "opt1": "Low power consumption",
-    "opt2": "High distortion",
-    "opt3": "High power efficiency",
-    "opt4": "Low heat generation",
-    "correct_option": "High power efficiency",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the major disadvantage of a Class B output stage?",
-    "opt1": "Low power efficiency",
-    "opt2": "High power consumption",
-    "opt3": "High distortion",
-    "opt4": "Crossover distortion",
-    "correct_option": "Crossover distortion",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "How does bias current help to address the issue of crossover distortion in a Class B output stage?",
-    "opt1": "By increasing power consumption",
-    "opt2": "By reducing power efficiency",
-    "opt3": "By keeping the amplifying devices slightly conductive",
-    "opt4": "By increasing the gain of the amplifier",
-    "correct_option": "By keeping the amplifying devices slightly conductive",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which application is Class B output stage commonly used in?",
-    "opt1": "Low-distortion audio power amplifiers",
-    "opt2": "Low-power RF amplifiers",
-    "opt3": "High-distortion audio power amplifiers",
-    "opt4": "High-power RF amplifiers",
-    "correct_option": "High-power RF amplifiers",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the output signal of a Class B output stage?",
-    "opt1": "A combination of the input signal and the bias current",
-    "opt2": "A combination of two signals produced by each device",
-    "opt3": "A constant voltage signal",
-    "opt4": "A high distortion signal",
-    "correct_option": "A combination of two signals produced by each device",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of amplifiers produce less distortion than Class B amplifiers?",
-    "opt1": "Class A amplifiers",
-    "opt2": "Class AB amplifiers",
-    "opt3": "Class C amplifiers",
-    "opt4": "Class D amplifiers",
-    "correct_option": "Class AB amplifiers",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the function of the load resistor in a Class B output stage?",
-    "opt1": "To provide a bias current to the amplifying devices",
-    "opt2": "To reduce the power consumption of the amplifying devices",
-    "opt3": "To eliminate the crossover distortion",
-    "opt4": "To increase the gain of the amplifier",
-    "correct_option": "To eliminate the crossover distortion",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of distortion is commonly associated with Class B output stages?",
-    "opt1": "Harmonic distortion",
-    "opt2": "Frequency distortion",
-    "opt3": "Amplitude distortion",
-    "opt4": "Crossover distortion",
-    "correct_option": "Crossover distortion",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a limitation of using Class B amplifiers?",
-    "opt1": "High power efficiency",
-    "opt2": "Low distortion",
-    "opt3": "High linearity",
-    "opt4": "High power consumption",
-    "correct_option": "Low distortion",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the main advantage of a Class AB output stage over a Class B output stage?",
-    "opt1": "Higher power efficiency",
-    "opt2": "Lower distortion",
-    "opt3": "High distortion",
-    "opt4": "None of the above",
-    "correct_option": "Lower distortion",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of biasing both amplifying devices in a Class AB output stage?",
-    "opt1": "To eliminate crossover distortion",
-    "opt2": "To improve power efficiency",
-    "opt3": "To increase linearity",
-    "opt4": "None of the above",
-    "correct_option": "To eliminate crossover distortion",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is not a characteristic of Class AB output stages?",
-    "opt1": "High linearity",
-    "opt2": "High power efficiency",
-    "opt3": "Low distortion",
-    "opt4": "High bias",
-    "correct_option": "High bias",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "In which application are Class AB output stages commonly used?",
-    "opt1": "Low-power audio amplifiers",
-    "opt2": "High-fidelity audio amplifiers",
-    "opt3": "Power supplies",
-    "opt4": "None of the above",
-    "correct_option": "High-fidelity audio amplifiers",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of output stage offers the highest linearity?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "None of the above",
-    "correct_option": "Class A",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the disadvantage of Class AB output stages compared to Class B output stages?",
-    "opt1": "Lower power efficiency",
-    "opt2": "Higher distortion",
-    "opt3": "More complex design",
-    "opt4": "None of the above",
-    "correct_option": "Lower power efficiency",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is not a benefit of using a Class AB output stage?",
-    "opt1": "High power output",
-    "opt2": "Low distortion",
-    "opt3": "High power efficiency",
-    "opt4": "None of the above",
-    "correct_option": "None of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which type of output stage produces lower distortion than Class B output stages?",
-    "opt1": "Class A",
-    "opt2": "Class AB",
-    "opt3": "Class C",
-    "opt4": "Both A and B",
-    "correct_option": "Both A and B",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the key advantage of using a Class AB output stage?",
-    "opt1": "High power efficiency",
-    "opt2": "Low distortion",
-    "opt3": "High power efficiency and low distortion",
-    "opt4": "Low power efficiency and high distortion",
-    "correct_option": "High power efficiency and low distortion",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the main disadvantage of Class A output stages compared to Class AB output stages?",
-    "opt1": "Lower linearity",
-    "opt2": "Lower power efficiency",
-    "opt3": "Higher distortion",
-    "opt4": "None of the above",
-    "correct_option": "Lower power efficiency",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following statements is true about a Class AB output stage?",
-    "opt1": "It has high power efficiency and high distortion.",
-    "opt2": "It has low power efficiency and low distortion.",
-    "opt3": "It has high power efficiency and low distortion.",
-    "opt4": "It has low power efficiency and high distortion.",
-    "correct_option": "It has high power efficiency and low distortion.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of output stage is commonly used in power supplies?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "None of the above",
-    "correct_option": "Class B",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the main advantage of using a Class AB output stage in an audio amplifier?",
-    "opt1": "High distortion",
-    "opt2": "Low efficiency",
-    "opt3": "High efficiency and low distortion",
-    "opt4": "Low efficiency and high distortion",
-    "correct_option": "High efficiency and low distortion",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "In a Class AB output stage, both amplifying devices are biased to conduct a small amount of current even when there is no input signal. What is the purpose of this bias current?",
-    "opt1": "To increase distortion",
-    "opt2": "To reduce power efficiency",
-    "opt3": "To maintain high power efficiency",
-    "opt4": "To decrease linearity",
-    "correct_option": "To reduce power efficiency",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of output stage is commonly used in high-fidelity audio amplifiers?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class AB",
-    "opt4": "Class C",
-    "correct_option": "Class AB",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the process of gradual conduction transfer in a Class AB output stage known as?",
-    "opt1": "Crossover",
-    "opt2": "Biasing",
-    "opt3": "Amplification",
-    "opt4": "Distortion",
-    "correct_option": "Crossover",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of using a Class AB output stage?",
-    "opt1": "High distortion",
-    "opt2": "Low power efficiency",
-    "opt3": "Low linearity",
-    "opt4": "High cost",
-    "correct_option": "Low power efficiency",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a Class AB output stage, how do the amplifying devices behave when there is an input signal?",
-    "opt1": "They both conduct fully.",
-    "opt2": "One conducts fully and the other conducts partially.",
-    "opt3": "They both conduct partially.",
-    "opt4": "One conducts partially and the other is turned off.",
-    "correct_option": "One conducts fully and the other conducts partially.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the main purpose of a Class AB output stage?",
-    "opt1": "To reduce distortion",
-    "opt2": "To increase power efficiency",
-    "opt3": "To increase distortion",
-    "opt4": "To reduce power efficiency",
-    "correct_option": "To reduce distortion",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of biasing the Class AB output stage in amplifiers?",
-    "opt1": "To set the operating point of the amplifying devices",
-    "opt2": "To reduce distortion in the output signal",
-    "opt3": "To ensure that the amplifying devices operate in the active region of their characteristic curves",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is a common biasing technique for the Class AB output stage?",
-    "opt1": "Voltage divider network",
-    "opt2": "Diode biasing",
-    "opt3": "Transistor biasing",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "In a voltage divider biasing network, where is the bias voltage set?",
-    "opt1": "At the base or gate of the amplifying device",
-    "opt2": "At the power supply voltage",
-    "opt3": "At ground",
-    "opt4": "None of the above",
-    "correct_option": "At the base or gate of the amplifying device",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How does a diode biasing circuit work?",
-    "opt1": "By using a transistor configured as a voltage divider",
-    "opt2": "By connecting a diode in series with the base or gate of the amplifying device",
-    "opt3": "By using a voltage divider network",
-    "opt4": "None of the above",
-    "correct_option": "By connecting a diode in series with the base or gate of the amplifying device",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which biasing technique allows for fine-tuning of the operating point?",
-    "opt1": "Voltage divider network",
-    "opt2": "Diode biasing",
-    "opt3": "Transistor biasing",
-    "opt4": "None of the above",
-    "correct_option": "Voltage divider network",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the goal of biasing the Class AB stage?",
-    "opt1": "To maximize power efficiency",
-    "opt2": "To minimize power dissipation",
-    "opt3": "To ensure linear operation with low distortion",
-    "opt4": "None of the above",
-    "correct_option": "To ensure linear operation with low distortion",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of amplifying device is typically used in a Class AB output stage?",
-    "opt1": "Bipolar junction transistor (BJT)",
-    "opt2": "Field-effect transistor (FET)",
-    "opt3": "Operational amplifier (Op-amp)",
-    "opt4": "None of the above",
-    "correct_option": "Bipolar junction transistor (BJT)",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which biasing technique uses a transistor configured as a voltage divider?",
-    "opt1": "Voltage divider network",
-    "opt2": "Diode biasing",
-    "opt3": "Transistor biasing",
-    "opt4": "None of the above",
-    "correct_option": "Transistor biasing",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Why is biasing necessary for Class AB amplifiers?",
-    "opt1": "To prevent the amplifying devices from saturating",
-    "opt2": "To ensure that the amplifying devices operate in the active region",
-    "opt3": "To decrease the gain of the amplifier",
-    "opt4": "None of the above",
-    "correct_option": "To ensure that the amplifying devices operate in the active region",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the main advantage of using a Class AB output stage in amplifiers?",
-    "opt1": "High power efficiency",
-    "opt2": "Low power dissipation",
-    "opt3": "High linearity with low distortion",
-    "opt4": "None of the above",
-    "correct_option": "High linearity with low distortion",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the bias voltage typically set to in the Class AB output stage?",
-    "opt1": "The forward voltage drop of a diode",
-    "opt2": "The power supply voltage",
-    "opt3": "Zero volts",
-    "opt4": "The voltage across a capacitor",
-    "correct_option": "The forward voltage drop of a diode",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of using a diode biasing circuit?",
-    "opt1": "It is more complex than other biasing techniques",
-    "opt2": "It is less stable than other biasing techniques",
-    "opt3": "It requires more power to operate",
-    "opt4": "It is less accurate than other biasing techniques",
-    "correct_option": "It is less stable than other biasing techniques",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of using a transistor biasing circuit?",
-    "opt1": "To set the bias voltage",
-    "opt2": "To amplify the input signal",
-    "opt3": "To reduce distortion in the output signal",
-    "opt4": "To increase power efficiency",
-    "correct_option": "To set the bias voltage",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following biasing techniques is commonly used in Class AB amplifiers?",
-    "opt1": "Voltage divider network",
-    "opt2": "Diode biasing",
-    "opt3": "Transistor biasing",
-    "opt4": "All of the above",
-    "correct_option": "Diode biasing",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How does the choice of biasing technique affect the power efficiency of the amplifier?",
-    "opt1": "It has no effect on power efficiency",
-    "opt2": "It can increase power efficiency",
-    "opt3": "It can decrease power efficiency",
-    "opt4": "It can cause the amplifier to malfunction",
-    "correct_option": "It can decrease power efficiency",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the disadvantage of using an adjustable biasing network?",
-    "opt1": "It is less accurate than a fixed biasing network",
-    "opt2": "It is less stable than a fixed biasing network",
-    "opt3": "It is more complex than a fixed biasing network",
-    "opt4": "It is more expensive than a fixed biasing network",
-    "correct_option": "It is more complex than a fixed biasing network",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a key consideration when selecting a biasing technique for the Class AB output stage?",
-    "opt1": "Power efficiency",
-    "opt2": "Cost",
-    "opt3": "Stability",
-    "opt4": "Input impedance",
-    "correct_option": "Power efficiency",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the primary application of power BJTs in amplifier circuits?",
-    "opt1": "High frequency amplification",
-    "opt2": "Low noise amplification",
-    "opt3": "Power amplification",
-    "opt4": "Voltage amplification",
-    "correct_option": "Power amplification",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of power BJT is more commonly used in power amplifier circuits?",
-    "opt1": "PNP",
-    "opt2": "NPN",
-    "opt3": "Both are used equally",
-    "opt4": "None of the above",
-    "correct_option": "NPN",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the operating region of the power BJT?",
-    "opt1": "Saturation",
-    "opt2": "Cutoff",
-    "opt3": "Active",
-    "opt4": "Reverse breakdown",
-    "correct_option": "Active",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which configuration is most commonly used for low-power amplifiers?",
-    "opt1": "Class A",
-    "opt2": "Class AB",
-    "opt3": "Class B",
-    "opt4": "Class C",
-    "correct_option": "Class A",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the main advantage of power BJTs over small signal BJTs?",
-    "opt1": "Higher frequency response",
-    "opt2": "Lower noise",
-    "opt3": "Higher power handling capability",
-    "opt4": "Lower distortion",
-    "correct_option": "Higher power handling capability",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a common application of power BJTs?",
-    "opt1": "Voltage regulators",
-    "opt2": "Oscillators",
-    "opt3": "Audio amplifiers",
-    "opt4": "Digital circuits",
-    "correct_option": "Audio amplifiers",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the primary purpose of switching amplifiers?",
-    "opt1": "To increase power gain",
-    "opt2": "To reduce distortion",
-    "opt3": "To improve efficiency",
-    "opt4": "To increase frequency response",
-    "correct_option": "To improve efficiency",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of amplifier uses power MOSFETs to provide high efficiency?",
-    "opt1": "Class A",
-    "opt2": "Class B",
-    "opt3": "Class D",
-    "opt4": "Class AB",
-    "correct_option": "Class D",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is not a technique used to improve the efficiency of power amplifiers?",
-    "opt1": "Class G and H amplifiers",
-    "opt2": "Switching amplifiers",
-    "opt3": "Feedback amplifiers",
-    "opt4": "Class D amplifiers",
-    "correct_option": "Feedback amplifiers",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the main disadvantage of power BJTs in amplifier circuits?",
-    "opt1": "High distortion",
-    "opt2": "Low power handling capability",
-    "opt3": "Low frequency response",
-    "opt4": "High heat dissipation",
-    "correct_option": "High heat dissipation",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the primary function of power BJTs in amplifier circuits?",
-    "opt1": "To provide high voltage gain",
-    "opt2": "To provide low noise amplification",
-    "opt3": "To provide high power gain and efficiency",
-    "opt4": "To provide high frequency response",
-    "correct_option": "To provide high power gain and efficiency",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a commonly used configuration for power BJTs in low-power amplifiers?",
-    "opt1": "Class A",
-    "opt2": "Class AB",
-    "opt3": "Class B",
-    "opt4": "Class C",
-    "correct_option": "Class A",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which type of power BJT is commonly used in power amplifier circuits?",
-    "opt1": "PNP",
-    "opt2": "NPN",
-    "opt3": "JFET",
-    "opt4": "MOSFET",
-    "correct_option": "NPN",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In which region of operation does the power BJT operate?",
-    "opt1": "Saturation region",
-    "opt2": "Cutoff region",
-    "opt3": "Active region",
-    "opt4": "Reverse-bias region",
-    "correct_option": "Active region",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a technique used to improve the efficiency of power amplifiers?",
-    "opt1": "Class A amplification",
-    "opt2": "Switching amplifiers",
-    "opt3": "Class AB amplification",
-    "opt4": "Linear amplifiers",
-    "correct_option": "Switching amplifiers",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is an application of power BJTs?",
-    "opt1": "Audio amplifiers",
-    "opt2": "Radio receivers",
-    "opt3": "Logic gates",
-    "opt4": "Voltage regulators",
-    "correct_option": "Audio amplifiers",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the primary difference between small signal BJTs and power BJTs?",
-    "opt1": "Current gain",
-    "opt2": "Voltage gain",
-    "opt3": "Frequency response",
-    "opt4": "High power handling capability",
-    "correct_option": "High power handling capability",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which type of power BJT has a higher current gain?",
-    "opt1": "PNP",
-    "opt2": "NPN",
-    "opt3": "JFET",
-    "opt4": "MOSFET",
-    "correct_option": "NPN",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is a benefit of using power BJTs in amplifier circuits?",
-    "opt1": "High frequency response",
-    "opt2": "Low power consumption",
-    "opt3": "Low distortion",
-    "opt4": "High power gain",
-    "correct_option": "High power gain",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following amplifier configurations is commonly used in high-power amplifiers?",
-    "opt1": "Class A",
-    "opt2": "Class AB",
-    "opt3": "Class B",
-    "opt4": "Class D",
-    "correct_option": "Class D",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "In a transformer-coupled push-pull amplifier, the primary winding of the output transformer is connected to:",
-    "opt1": "The input signal",
-    "opt2": "The collector of the NPN transistor in the driver stage",
-    "opt3": "The base of the NPN transistor in the driver stage",
-    "opt4": "The collector of both transistors",
-    "correct_option": "The collector of both transistors",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "The transformer in a transformer-coupled push-pull amplifier is used to:",
-    "opt1": "Provide impedance matching between the driver and output stages",
-    "opt2": "Amplify the signal",
-    "opt3": "Provide voltage gain",
-    "opt4": "Provide current gain",
-    "correct_option": "Provide impedance matching between the driver and output stages",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In a transformer-coupled push-pull amplifier, the two output transistors are biased so that they conduct:",
-    "opt1": "Simultaneously",
-    "opt2": "Randomly",
-    "opt3": "Alternately",
-    "opt4": "None of the above",
-    "correct_option": "Alternately",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is an advantage of a transformer-coupled push-pull amplifier?",
-    "opt1": "High efficiency",
-    "opt2": "Low distortion",
-    "opt3": "High gain",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "The output of a transformer-coupled push-pull amplifier is taken from:",
-    "opt1": "The primary winding of the output transformer",
-    "opt2": "The secondary winding of the output transformer",
-    "opt3": "The center tap of the output transformer",
-    "opt4": "None of the above",
-    "correct_option": "The secondary winding of the output transformer",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "The load impedance in a transformer-coupled push-pull amplifier is:",
-    "opt1": "Always equal to the output impedance of the amplifier",
-    "opt2": "Always lower than the output impedance of the amplifier",
-    "opt3": "Always higher than the output impedance of the amplifier",
-    "opt4": "None of the above",
-    "correct_option": "Always equal to the output impedance of the amplifier",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "The DC bias voltage for the output transistors in a transformer-coupled push-pull amplifier is provided by:",
-    "opt1": "The input signal",
-    "opt2": "The driver stage",
-    "opt3": "A separate bias circuit",
-    "opt4": "None of the above",
-    "correct_option": "A separate bias circuit",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "The crossover distortion in a transformer-coupled push-pull amplifier is caused by:",
-    "opt1": "The mismatch between the two output transistors",
-    "opt2": "The bias voltage being too high",
-    "opt3": "The load impedance being too low",
-    "opt4": "None of the above",
-    "correct_option": "The mismatch between the two output transistors",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "The transformer in a transformer-coupled push-pull amplifier is usually:",
-    "opt1": "A step-up transformer",
-    "opt2": "A step-down transformer",
-    "opt3": "A transformer with a 1:1 turns ratio",
-    "opt4": "None of the above",
-    "correct_option": "A step-down transformer",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a transformer-coupled push-pull amplifier, the output transistors are typically:",
-    "opt1": "Darlington transistors",
-    "opt2": "Complementary pair transistors",
-    "opt3": "MOSFETs",
-    "opt4": "None of the above",
-    "correct_option": "None of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "In a transformer-coupled push-pull stage, two identical transistors are used with one conducting during the positive half-cycle of the input signal and the other conducting during the negative half-cycle. What is the main advantage of using two transistors in this configuration?",
-    "opt1": "Increased efficiency",
-    "opt2": "Increased voltage gain",
-    "opt3": "Reduced distortion",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following statements about the transformer-coupled push-pull stage is true?",
-    "opt1": "It is commonly used in audio power amplifiers",
-    "opt2": "It is a type of class A amplifier",
-    "opt3": "It requires a large amount of power for operation",
-    "opt4": "It has a low voltage gain",
-    "correct_option": "It is commonly used in audio power amplifiers",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "The transformer in a transformer-coupled push-pull stage is used to:",
-    "opt1": "Increase the voltage gain of the amplifier",
-    "opt2": "Couple the output signal to the load",
-    "opt3": "Provide impedance matching between the amplifier and the load",
-    "opt4": "All of the above",
-    "correct_option": "Provide impedance matching between the amplifier and the load",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "In a transformer-coupled push-pull stage, the transformer is typically wound with a center-tapped secondary winding. What is the purpose of the center tap?",
-    "opt1": "To provide a reference voltage for biasing the transistors",
-    "opt2": "To provide a means for adjusting the gain of the amplifier",
-    "opt3": "To provide a balanced load for the transistors",
-    "opt4": "None of the above",
-    "correct_option": "To provide a reference voltage for biasing the transistors",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "The transformer-coupled push-pull stage is a type of:",
-    "opt1": "Class A amplifier",
-    "opt2": "Class B amplifier",
-    "opt3": "Class AB amplifier",
-    "opt4": "None of the above",
-    "correct_option": "Class B amplifier",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is an advantage of using a transformer-coupled push-pull stage over a single-ended output stage?",
-    "opt1": "Higher efficiency",
-    "opt2": "Higher voltage gain",
-    "opt3": "Reduced distortion",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "The output of a transformer-coupled push-pull stage is taken from:",
-    "opt1": "The collector of one transistor",
-    "opt2": "The center tap of the transformer secondary winding",
-    "opt3": "The collector of both transistors",
-    "opt4": "The primary winding of the transformer",
-    "correct_option": "The center tap of the transformer secondary winding",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the main disadvantage of a transformer-coupled push-pull stage compared to other output stage configurations?",
-    "opt1": "Reduced efficiency",
-    "opt2": "Increased distortion",
-    "opt3": "Limited frequency response",
-    "opt4": "All of the above",
-    "correct_option": "Limited frequency response",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "The transformer in a transformer-coupled push-pull stage should be designed with:",
-    "opt1": "High primary-to-secondary turns ratio",
-    "opt2": "Low primary-to-secondary turns ratio",
-    "opt3": "High frequency response",
-    "opt4": "Low leakage inductance",
-    "correct_option": "Low leakage inductance",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the main advantage of using a transformer in a push-pull output stage?",
-    "opt1": "Increased voltage gain",
-    "opt2": "Impedance matching to the load",
-    "opt3": "Reduced distortion",
-    "opt4": "Increased efficiency",
-    "correct_option": "Impedance matching to the load",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the basic function of a tuned amplifier?",
-    "opt1": "To provide high power amplification",
-    "opt2": "To provide high selectivity and gain",
-    "opt3": "To filter out unwanted signals",
-    "opt4": "To provide high frequency stability",
-    "correct_option": "To provide high selectivity and gain",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of resonant circuit is typically used in tuned amplifiers?",
-    "opt1": "RC circuits",
-    "opt2": "RL circuits",
-    "opt3": "LC circuits",
-    "opt4": "RLC circuits",
-    "correct_option": "LC circuits",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the Q factor of a resonant circuit?",
-    "opt1": "The frequency at which the circuit resonates",
-    "opt2": "The voltage gain of the circuit",
-    "opt3": "The energy stored in the circuit",
-    "opt4": "The ratio of energy stored in the circuit to energy lost per cycle",
-    "correct_option": "The ratio of energy stored in the circuit to energy lost per cycle",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the difference between a single tuned amplifier and a double tuned amplifier?",
-    "opt1": "A single tuned amplifier is more selective than a double tuned amplifier.",
-    "opt2": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two.",
-    "opt3": "A double tuned amplifier provides more gain than a single tuned amplifier.",
-    "opt4": "A double tuned amplifier uses a transformer to couple the resonant circuits.",
-    "correct_option": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of amplifier is commonly used in radio receivers and transmitters?",
-    "opt1": "Class A amplifier",
-    "opt2": "Class B amplifier",
-    "opt3": "Class AB amplifier",
-    "opt4": "Tuned amplifier",
-    "correct_option": "Tuned amplifier",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which electronic device can be used as the active element in a tuned amplifier?",
-    "opt1": "Capacitor",
-    "opt2": "Resistor",
-    "opt3": "Inductor",
-    "opt4": "Transistor",
-    "correct_option": "Transistor",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the function of the Q multiplier in a tuned amplifier?",
-    "opt1": "To provide additional gain at the center frequency of the circuit",
-    "opt2": "To increase the bandwidth of the circuit",
-    "opt3": "To improve the stability of the circuit",
-    "opt4": "To reduce distortion in the output signal",
-    "correct_option": "To provide additional gain at the center frequency of the circuit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a tuned amplifier?",
-    "opt1": "An amplifier with no selectivity or gain",
-    "opt2": "An amplifier that only works with specific types of signals",
-    "opt3": "An amplifier that uses tuned circuits to achieve high selectivity and gain",
-    "opt4": "An amplifier that is not commonly used in electronic applications",
-    "correct_option": "An amplifier that uses tuned circuits to achieve high selectivity and gain",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What type of resonant circuits are used in tuned amplifiers?",
-    "opt1": "RC circuits",
-    "opt2": "LC circuits",
-    "opt3": "RL circuits",
-    "opt4": "RLC circuits",
-    "correct_option": "LC circuits",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is a key factor in determining the gain and selectivity of a tuned amplifier?",
-    "opt1": "The type of amplifier used",
-    "opt2": "The power supply voltage",
-    "opt3": "The Q factor of the resonant circuits",
-    "opt4": "The input signal frequency",
-    "correct_option": "The Q factor of the resonant circuits",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the difference between a single tuned amplifier and a double tuned amplifier?",
-    "opt1": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two resonant circuits.",
-    "opt2": "A single tuned amplifier is only used in audio applications, while a double tuned amplifier is only used in radio applications.",
-    "opt3": "A single tuned amplifier is less efficient than a double tuned amplifier.",
-    "opt4": "A single tuned amplifier has a lower Q factor than a double tuned amplifier.",
-    "correct_option": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two resonant circuits.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Where are tuned amplifiers commonly used?",
-    "opt1": "In power supplies",
-    "opt2": "In digital circuits",
-    "opt3": "In radio receivers and transmitters",
-    "opt4": "In microcontrollers",
-    "correct_option": "In radio receivers and transmitters",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the Q factor of a resonant circuit?",
-    "opt1": "The amount of power dissipated in the circuit",
-    "opt2": "The amount of power supplied to the circuit",
-    "opt3": "The ratio of energy stored in the circuit to energy lost per cycle",
-    "opt4": "The ratio of energy lost in the circuit to energy stored per cycle",
-    "correct_option": "The ratio of energy stored in the circuit to energy lost per cycle",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which type of amplifying device can be used in tuned amplifiers?",
-    "opt1": "BJTs",
-    "opt2": "MOSFETs",
-    "opt3": "Vacuum tubes",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the purpose of a tuned amplifier in a radio receiver?",
-    "opt1": "To amplify all incoming signals equally",
-    "opt2": "To amplify only the desired signal while rejecting other signals",
-    "opt3": "To reduce the strength of the incoming signal",
-    "opt4": "To generate a new signal at a different frequency",
-    "correct_option": "To amplify only the desired signal while rejecting other signals",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the main advantage of a double tuned amplifier over a single tuned amplifier?",
-    "opt1": "Higher efficiency",
-    "opt2": "Higher gain",
-    "opt3": "Higher selectivity",
-    "opt4": "Lower distortion",
-    "correct_option": "Higher selectivity",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of tuned amplifiers?",
-    "opt1": "They are expensive to produce.",
-    "opt2": "They are large in size.",
-    "opt3": "They can be difficult to tune and adjust.",
-    "opt4": "They are not capable of providing high gain.",
-    "correct_option": "They can be difficult to tune and adjust.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What does op-amp stand for?",
-    "opt1": "Operational amplifier",
-    "opt2": "Optimal amplifier",
-    "opt3": "Organic amplifier",
-    "opt4": "Oscillating amplifier",
-    "correct_option": "Operational amplifier",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which configuration is most commonly used in op-amp circuits?",
-    "opt1": "Inverting amplifier",
-    "opt2": "Non-inverting amplifier",
-    "opt3": "Differential amplifier",
-    "opt4": "Voltage follower",
-    "correct_option": "Inverting amplifier",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the gain of an inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
-    "opt1": "-1",
-    "opt2": "-10",
-    "opt3": "10",
-    "opt4": "100",
-    "correct_option": "-10",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which parameter determines the maximum output voltage swing of an op-amp?",
-    "opt1": "Input offset voltage",
-    "opt2": "Gain-bandwidth product",
-    "opt3": "Slew rate",
-    "opt4": "Output saturation voltage",
-    "correct_option": "Output saturation voltage",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the purpose of a voltage follower op-amp circuit?",
-    "opt1": "To provide high gain",
-    "opt2": "To provide low gain",
-    "opt3": "To buffer a signal",
-    "opt4": "To invert a signal",
-    "correct_option": "To buffer a signal",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the transfer function of a non-inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
-    "opt1": "Vout = Vin",
-    "opt2": "Vout = -10Vin",
-    "opt3": "Vout = 10Vin",
-    "opt4": "Vout = (1 + 10kΩ/1kΩ)Vin",
-    "correct_option": "Vout = (1 + 10kΩ/1kΩ)Vin",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which op-amp parameter determines the rate at which the output can change in response to changes in the input?",
-    "opt1": "Input offset voltage",
-    "opt2": "Gain-bandwidth product",
-    "opt3": "Slew rate",
-    "opt4": "Input bias current",
-    "correct_option": "Slew rate",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of a differential amplifier?",
-    "opt1": "To amplify the difference between two input signals",
-    "opt2": "To amplify the sum of two input signals",
-    "opt3": "To invert a signal",
-    "opt4": "To provide a high-impedance input",
-    "correct_option": "To amplify the difference between two input signals",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which op-amp configuration is used to perform mathematical operations, such as addition and subtraction?",
-    "opt1": "Inverting amplifier",
-    "opt2": "Non-inverting amplifier",
-    "opt3": "Summing amplifier",
-    "opt4": "Differentiator",
-    "correct_option": "Summing amplifier",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the output voltage of an inverting amplifier with an input voltage of 2 V and a feedback resistor of 10 kΩ, assuming an ideal op-amp?",
-    "opt1": "-2V",
-    "opt2": "-20 V",
-    "opt3": "2V",
-    "opt4": "20 V",
-    "correct_option": "-20 V",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is a characteristic of an ideal operational amplifier?",
-    "opt1": "Infinite input impedance",
-    "opt2": "Infinite output impedance",
-    "opt3": "Infinite gain",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is not a type of operational amplifier?",
-    "opt1": "Differential amplifier",
-    "opt2": "Inverting amplifier",
-    "opt3": "Non-inverting amplifier",
-    "opt4": "Power amplifier",
-    "correct_option": "Power amplifier",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the function of a summing amplifier?",
-    "opt1": "To amplify a single input signal",
-    "opt2": "To sum multiple input signals and provide an amplified output signal",
-    "opt3": "To provide an inverted output signal",
-    "opt4": "To provide a non-inverted output signal",
-    "correct_option": "To sum multiple input signals and provide an amplified output signal",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the output voltage of an inverting amplifier with a gain of -10 if the input voltage is 2V?",
-    "opt1": "-10V",
-    "opt2": "-20V",
-    "opt3": "10V",
-    "opt4": "20V",
-    "correct_option": "-20V",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the function of a voltage follower?",
-    "opt1": "To amplify a voltage",
-    "opt2": "To provide a high input impedance",
-    "opt3": "To provide a low output impedance",
-    "opt4": "To provide unity gain and high input and output impedances",
-    "correct_option": "To provide unity gain and high input and output impedances",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the advantage of using an op-amp as a comparator?",
-    "opt1": "It has a very high input impedance",
-    "opt2": "It has a very low output impedance",
-    "opt3": "It has a very high gain",
-    "opt4": "It has a very low bandwidth",
-    "correct_option": "It has a very high gain",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the function of a differentiator circuit?",
-    "opt1": "To differentiate the input signal with respect to time",
-    "opt2": "To integrate the input signal with respect to time",
-    "opt3": "To amplify the input signal",
-    "opt4": "To provide a DC offset to the input signal",
-    "correct_option": "To differentiate the input signal with respect to time",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the function of an integrator circuit?",
-    "opt1": "To differentiate the input signal with respect to time",
-    "opt2": "To integrate the input signal with respect to time",
-    "opt3": "To amplify the input signal",
-    "opt4": "To provide a DC offset to the input signal",
-    "correct_option": "To integrate the input signal with respect to time",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the advantage of using a non-inverting amplifier instead of an inverting amplifier?",
-    "opt1": "The input signal is not inverted",
-    "opt2": "The output impedance is lower",
-    "opt3": "The gain is higher",
-    "opt4": "The bandwidth is wider",
-    "correct_option": "The input signal is not inverted",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the function of a Schmitt trigger circuit?",
-    "opt1": "To amplify a signal",
-    "opt2": "To filter a signal",
-    "opt3": "To generate a square wave signal from a triangular wave signal",
-    "opt4": "To provide hysteresis to a signal",
-    "correct_option": "To provide hysteresis to a signal",
-    "correct_option_index": 4
-  }
-]
\ No newline at end of file
+    {
+        "qsns": "Which of the following best describes Ohm's Law?",
+        "opt1": "The relationship between voltage and power",
+        "opt2": "The relationship between current and resistance",
+        "opt3": "The relationship between voltage and current",
+        "opt4": "The relationship between resistance and power",
+        "correct_option": "The relationship between voltage and current",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the unit of electrical resistance?",
+        "opt1": "Volt",
+        "opt2": "Ampere",
+        "opt3": "Watt",
+        "opt4": "Ohm",
+        "correct_option": "Ohm",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a correct expression of Ohm's Law?",
+        "opt1": "I=VR",
+        "opt2": "R=VI",
+        "opt3": "V=IR",
+        "opt4": "R=IV",
+        "correct_option": "V=IR",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "A circuit has a voltage of 12 volts and a resistance of 4 ohms. What is the current flowing through the circuit?",
+        "opt1": "48 amps",
+        "opt2": "8 amps",
+        "opt3": "4 amps",
+        "opt4": "3 amps",
+        "correct_option": "3 amps",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "If the voltage across a circuit remains constant and the resistance decreases, what happens to the current?",
+        "opt1": "It increases",
+        "opt2": "It decreases",
+        "opt3": "It stays the same",
+        "opt4": "It is impossible to determine without more information",
+        "correct_option": "It increases",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following materials has the highest electrical resistance?",
+        "opt1": "Copper",
+        "opt2": "Silver",
+        "opt3": "Aluminum",
+        "opt4": "Nichrome",
+        "correct_option": "Nichrome",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "A circuit has a resistance of 10 ohms and a current of 2 amps. What is the voltage across the circuit?",
+        "opt1": "5 volts",
+        "opt2": "10 volts",
+        "opt3": "20 volts",
+        "opt4": "40 volts",
+        "correct_option": "20 volts",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is an example of a non-ohmic conductor?",
+        "opt1": "Copper wire",
+        "opt2": "Silver wire",
+        "opt3": "Light bulb filament",
+        "opt4": "Carbon resistor",
+        "correct_option": "Light bulb filament",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What happens to the current in a circuit if the voltage is doubled while the resistance remains constant?",
+        "opt1": "It is halved",
+        "opt2": "It is doubled",
+        "opt3": "It remains the same",
+        "opt4": "It is impossible to determine without more information",
+        "correct_option": "It is doubled",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "A circuit has a voltage of 20 volts and a current of 4 amps. What is the resistance of the circuit?",
+        "opt1": "16 ohms",
+        "opt2": "8 ohms",
+        "opt3": "5 ohms",
+        "opt4": "80 ohms",
+        "correct_option": "5 ohms",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a characteristic of a good conductor?",
+        "opt1": "High resistance",
+        "opt2": "Low resistance",
+        "opt3": "High voltage",
+        "opt4": "Low voltage",
+        "correct_option": "Low resistance",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following materials has the lowest electrical resistance?",
+        "opt1": "Aluminum",
+        "opt2": "Gold",
+        "opt3": "Copper",
+        "opt4": "Silver",
+        "correct_option": "Silver",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What happens to the current in a circuit if the resistance is doubled while the voltage remains constant?",
+        "opt1": "It is halved",
+        "opt2": "It is doubled",
+        "opt3": "It remains the same",
+        "opt4": "It is impossible to determine without more information",
+        "correct_option": "It is halved",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the relationship between current and voltage in a circuit with a constant resistance?",
+        "opt1": "They are directly proportional",
+        "opt2": "They are inversely proportional",
+        "opt3": "They are not related",
+        "opt4": "It is impossible to determine without more information",
+        "correct_option": "They are directly proportional",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is electric voltage?",
+        "opt1": "The flow of electric charge through a conductor",
+        "opt2": "The measure of electric potential energy per unit charge between two points in an electric circuit",
+        "opt3": "The resistance of a conductor",
+        "opt4": "The unit of electric voltage",
+        "correct_option": "The measure of electric potential energy per unit charge between two points in an electric circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is electric current?",
+        "opt1": "The measure of the electric potential energy per unit charge between two points in an electric circuit",
+        "opt2": "The flow of electric charge through a conductor",
+        "opt3": "The resistance of a conductor to the flow of electric charge",
+        "opt4": "The measure of resistivity of a conductor",
+        "correct_option": "The flow of electric charge through a conductor",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the unit of electric voltage?",
+        "opt1": "Ampere (A)",
+        "opt2": "Watt (W)",
+        "opt3": "Volt (V)",
+        "opt4": "Ohm (Ω)",
+        "correct_option": "Volt (V)",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the unit of electric current?",
+        "opt1": "Amperes",
+        "opt2": "Watts",
+        "opt3": "Volts",
+        "opt4": "Coulombs",
+        "correct_option": "Amperes",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the relationship between voltage and current according to Ohm's Law?",
+        "opt1": "Voltage is inversely proportional to current",
+        "opt2": "Voltage is directly proportional to current",
+        "opt3": "Voltage is not related to current",
+        "opt4": "Voltage is directly proportional to square of current",
+        "correct_option": "Voltage is directly proportional to current",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What instrument is used to measure electric current in a circuit?",
+        "opt1": "Voltmeter",
+        "opt2": "Ammeter",
+        "opt3": "Oscilloscope",
+        "opt4": "Galvanometer",
+        "correct_option": "Ammeter",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is power?",
+        "opt1": "The rate at which energy is transferred in an electric circuit",
+        "opt2": "The capacity of a system to do work",
+        "opt3": "The unit of energy",
+        "opt4": "Energy per unit area",
+        "correct_option": "The rate at which energy is transferred in an electric circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the unit of power?",
+        "opt1": "Amperes",
+        "opt2": "Volts",
+        "opt3": "Watts",
+        "opt4": "Coulombs",
+        "correct_option": "Watts",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the formula for calculating power in an electric circuit?",
+        "opt1": "P=V+I",
+        "opt2": "P=VI",
+        "opt3": "P=IR",
+        "opt4": "P=V/I",
+        "correct_option": "P=VI",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the formula for calculating power when resistance is known?",
+        "opt1": "P=V+I",
+        "opt2": "P=V",
+        "opt3": "P=I^2R",
+        "opt4": "P=I^2R^2",
+        "correct_option": "P=I^2R",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is energy?",
+        "opt1": "The rate at which energy is transferred in an electric circuit",
+        "opt2": "The capacity of a system to do work",
+        "opt3": "The unit of power",
+        "opt4": "Work done per unit area",
+        "correct_option": "The capacity of a system to do work",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the unit of energy?",
+        "opt1": "Amperes",
+        "opt2": "Joules",
+        "opt3": "Watts",
+        "opt4": "Coulombs",
+        "correct_option": "Joules",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the formula for calculating energy transferred in an electric circuit?",
+        "opt1": "E=V",
+        "opt2": "E=P",
+        "opt3": "E=IR",
+        "opt4": "E=Pt",
+        "correct_option": "E=Pt",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the formula for calculating power if the current and resistance are known?",
+        "opt1": "P=I^2R",
+        "opt2": "P=IV",
+        "opt3": "P=IR",
+        "opt4": "P=I^2R^2",
+        "correct_option": "P=I^2R",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following materials is an example of a conducting material?",
+        "opt1": "Glass",
+        "opt2": "Rubber",
+        "opt3": "Copper",
+        "opt4": "Plastic",
+        "correct_option": "Copper",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the resistivity of a conducting material?",
+        "opt1": "The resistance of a material of unit length and unit cross-sectional area",
+        "opt2": "The maximum voltage that the material can withstand before it breaks down",
+        "opt3": "The ability of a material to prevent the flow of electric current",
+        "opt4": "All of above",
+        "correct_option": "The resistance of a material of unit length and unit cross-sectional area",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following materials is an example of an insulating material?",
+        "opt1": "Copper",
+        "opt2": "Plastic",
+        "opt3": "Silver",
+        "opt4": "both a and b",
+        "correct_option": "Plastic",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the dielectric strength of an insulating material?",
+        "opt1": "The resistance of a material of unit length and unit cross-sectional area",
+        "opt2": "The ability of a material to prevent the flow of electric current",
+        "opt3": "The maximum voltage that the material can withstand before it breaks down",
+        "opt4": "None of above",
+        "correct_option": "The maximum voltage that the material can withstand before it breaks down",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What are semiconducting materials?",
+        "opt1": "Materials that have properties between those of conducting and insulating materials",
+        "opt2": "Materials that allow electric current to flow through them easily",
+        "opt3": "Materials that do not allow electric current to flow through them easily",
+        "opt4": "All of above",
+        "correct_option": "Materials that have properties between those of conducting and insulating materials",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following materials is commonly used in electronic devices?",
+        "opt1": "Silicon",
+        "opt2": "Rubber",
+        "opt3": "Glass",
+        "opt4": "Steel",
+        "correct_option": "Silicon",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the process of controlling the conductivity of a semiconducting material called?",
+        "opt1": "Doping",
+        "opt2": "Refracting",
+        "opt3": "Conducting",
+        "opt4": "Insulating",
+        "correct_option": "Doping",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of insulating materials in electrical circuits?",
+        "opt1": "To separate conductors and prevent the flow of electric current to unintended locations",
+        "opt2": "To connect components",
+        "opt3": "To provide a path for the flow of electric current",
+        "opt4": "None of above",
+        "correct_option": "To separate conductors and prevent the flow of electric current to unintended locations",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In a series circuit, which of the following statements is true?",
+        "opt1": "The components are connected across each other in multiple paths.",
+        "opt2": "The same current flows through each component.",
+        "opt3": "The total resistance is less than the individual resistances of the components",
+        "opt4": "All of above",
+        "correct_option": "The same current flows through each component.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following circuits has a total resistance that is less than the individual resistances of the components?",
+        "opt1": "Series circuit",
+        "opt2": "Parallel circuit",
+        "opt3": "Series-parallel circuit",
+        "opt4": "both b and c",
+        "correct_option": "Parallel circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a series circuit, if the resistance of one component increases, what happens to the total resistance of the circuit?",
+        "opt1": "It decreases",
+        "opt2": "It increases",
+        "opt3": "It stays the same",
+        "opt4": "First increases then stays same",
+        "correct_option": "It increases",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a parallel circuit, if the resistance of one component increases, what happens to the total resistance of the circuit?",
+        "opt1": "It decreases",
+        "opt2": "It increases",
+        "opt3": "It stays the same",
+        "opt4": "First increases then stays same",
+        "correct_option": "It increases",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following circuits is used in applications where voltage regulation is required?",
+        "opt1": "Series circuit",
+        "opt2": "Parallel circuit",
+        "opt3": "Series-parallel circuit",
+        "opt4": "None of above",
+        "correct_option": "Parallel circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following circuits is used in applications where current limiting is required?",
+        "opt1": "Series circuit",
+        "opt2": "Parallel circuit",
+        "opt3": "Series-parallel circuit",
+        "opt4": "None of above",
+        "correct_option": "Series circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In a series-parallel circuit, which components are connected in series?",
+        "opt1": "No components",
+        "opt2": "All components",
+        "opt3": "Some components",
+        "opt4": "Both a and b",
+        "correct_option": "Some components",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following circuits is more reliable in terms of component failure?",
+        "opt1": "Series circuit",
+        "opt2": "Parallel circuit",
+        "opt3": "Both circuits are equally reliable",
+        "opt4": "Series-parallel circuit",
+        "correct_option": "Parallel circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What happens to the current in a parallel circuit if one component fails?",
+        "opt1": "The current through the other components increases.",
+        "opt2": "The current through the other components decreases.",
+        "opt3": "The current through the other components stays the same.",
+        "opt4": "First Increases then stays same",
+        "correct_option": "The current through the other components stays the same.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What Is the total resistance of a series circuit?",
+        "opt1": "The sum of the individual conductance's",
+        "opt2": "The sum of the individual resistances",
+        "opt3": "The reciprocal of the sum of the individual resistances",
+        "opt4": "sum of square of individual resistances",
+        "correct_option": "The sum of the individual resistances",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a parallel circuit, each component has the same:",
+        "opt1": "Current flowing through it",
+        "opt2": "Voltage across it",
+        "opt3": "Same power consumed",
+        "opt4": "Energy consumed",
+        "correct_option": "Voltage across it",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What Is the total resistance of a parallel circuit?",
+        "opt1": "Sum of the individual conductance's",
+        "opt2": "Sum of the individual resistances",
+        "opt3": "Reciprocal of the sum of the individual resistances",
+        "opt4": "Sum of reciprocal of individual conductance",
+        "correct_option": "Sum of the individual conductance's",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of star-delta conversion?",
+        "opt1": "To reduce the starting current of a motor",
+        "opt2": "To increase the starting current of a motor",
+        "opt3": "To regulate the voltage levels of a three-phase supply",
+        "opt4": "All of above",
+        "correct_option": "To reduce the starting current of a motor",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In which type of circuit is delta-star conversion commonly used?",
+        "opt1": "Motor control circuits",
+        "opt2": "Power distribution systems",
+        "opt3": "Generator",
+        "opt4": "Both a and b",
+        "correct_option": "Power distribution systems",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of delta-star conversion?",
+        "opt1": "To reduce the starting current of a motor",
+        "opt2": "To increase the starting current of a motor",
+        "opt3": "To regulate the voltage levels of a three-phase supply",
+        "opt4": "None of above",
+        "correct_option": "To regulate the voltage levels of a three-phase supply",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the difference between a star and delta configuration in a three-phase system?",
+        "opt1": "In a star configuration, the three phases are connected in a closed loop, while in a delta configuration, the three phases are connected to a common point or neutral.",
+        "opt2": "In a star configuration, the three phases are connected to a common point or neutral, while in a delta configuration, the three phases are connected in a closed loop.",
+        "opt3": "There is no difference between a star and delta configuration in a three-phase system.",
+        "opt4": "None of above",
+        "correct_option": "In a star configuration, the three phases are connected to a common point or neutral, while in a delta configuration, the three phases are connected in a closed loop.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a star-delta conversion, what is re-arranged?",
+        "opt1": "The voltage levels of the three-phase supply",
+        "opt2": "The connections between the components of the circuit",
+        "opt3": "The starting current of a motor",
+        "opt4": "None of above",
+        "correct_option": "The connections between the components of the circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of conversion is commonly used in motor control circuits?",
+        "opt1": "Star-delta conversion",
+        "opt2": "Delta-star conversion",
+        "opt3": "Both a and b",
+        "opt4": "None of above",
+        "correct_option": "Star-delta conversion",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of conversion is commonly used in power distribution systems?",
+        "opt1": "Star-delta conversion",
+        "opt2": "Delta-star conversion",
+        "opt3": "Both a and b",
+        "opt4": "None of above",
+        "correct_option": "Delta-star conversion",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the primary advantage of using star-delta conversion in motor control circuits?",
+        "opt1": "It increases the starting current of the motor",
+        "opt2": "It reduces the starting current of the motor",
+        "opt3": "It regulates the voltage levels of the three-phase supply",
+        "opt4": "All of above",
+        "correct_option": "It reduces the starting current of the motor",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the primary advantage of using delta-star conversion in power distribution systems?",
+        "opt1": "It increases the voltage levels of the three-phase supply",
+        "opt2": "It reduces the voltage levels of the three-phase supply",
+        "opt3": "It regulates the voltage levels of the three-phase supply",
+        "opt4": "None of above",
+        "correct_option": "It regulates the voltage levels of the three-phase supply",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of conversion is used to regulate the voltage levels of a three-phase supply?",
+        "opt1": "Star-delta conversion",
+        "opt2": "Delta-star conversion",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Delta-star conversion",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of delta-star conversion?",
+        "opt1": "To convert a three-phase system from a star to a delta configuration",
+        "opt2": "To reduce the starting current of a motor",
+        "opt3": "To regulate the voltage levels of a power distribution system",
+        "opt4": "None of above",
+        "correct_option": "To regulate the voltage levels of a power distribution system",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following connections is used in a star configuration?",
+        "opt1": "The three phases are connected in a closed loop",
+        "opt2": "The three phases are connected to a common point or neutral",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "The three phases are connected to a common point or neutral",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following connections is used in a delta configuration?",
+        "opt1": "The three phases are connected in a closed loop",
+        "opt2": "The three phases are connected to a common point or neutral",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "The three phases are connected in a closed loop",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the primary benefit of star-delta conversion in motor control circuits?",
+        "opt1": "It reduces the voltage levels",
+        "opt2": "It reduces the starting current of the motor",
+        "opt3": "It increases the speed of the motor",
+        "opt4": "None of above",
+        "correct_option": "It reduces the starting current of the motor",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the primary benefit of delta-star conversion in power distribution systems?",
+        "opt1": "It reduces the voltage levels",
+        "opt2": "It regulates the voltage levels of the system",
+        "opt3": "It reduces the current levels",
+        "opt4": "It increases the voltage levels",
+        "correct_option": "It regulates the voltage levels of the system",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the process involved in converting a three-phase system from a star to a delta configuration?",
+        "opt1": "Re-arranging the connections between the components of the circuit",
+        "opt2": "Replacing the components of the circuit",
+        "opt3": "Increasing the voltage levels of the system",
+        "opt4": "None of above",
+        "correct_option": "Re-arranging the connections between the components of the circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the process involved in converting a three-phase system from a delta to a star configuration?",
+        "opt1": "Re-arranging the connections between the components of the circuit",
+        "opt2": "Replacing the components of the circuit",
+        "opt3": "Decreasing the voltage levels of the system",
+        "opt4": "None of above",
+        "correct_option": "Re-arranging the connections between the components of the circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is Kirchhoff's Current Law?",
+        "opt1": "The sum of voltages around a closed loop is zero",
+        "opt2": "The total current entering a node is equal to the total current leaving that node",
+        "opt3": "The sum of currents around a closed loop is zero",
+        "opt4": "Both a and b",
+        "correct_option": "The total current entering a node is equal to the total current leaving that node",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is Kirchhoff's Voltage Law?",
+        "opt1": "The sum of voltages around a closed loop is zero",
+        "opt2": "The total current entering a node is equal to the total current leaving that node",
+        "opt3": "The sum of currents around a closed loop is zero",
+        "opt4": "Both a and c",
+        "correct_option": "The sum of voltages around a closed loop is zero",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the principle on which Kirchhoff's Current Law is based?",
+        "opt1": "Conservation of energy",
+        "opt2": "Conservation of charge",
+        "opt3": "Conservation of power",
+        "opt4": "Conservation of Potential",
+        "correct_option": "Conservation of charge",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the principle on which Kirchhoff's Voltage Law is based?",
+        "opt1": "Conservation of energy",
+        "opt2": "Conservation of charge",
+        "opt3": "Conservation of power",
+        "opt4": "Conservation of Potential",
+        "correct_option": "Conservation of energy",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of using Kirchhoff's laws in circuit analysis?",
+        "opt1": "To predict the behavior of electrical circuits",
+        "opt2": "To determine the currents and voltages in a circuit",
+        "opt3": "To analyze current flow and voltage drops in circuit",
+        "opt4": "All of above",
+        "correct_option": "All of above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What type of circuits can be analyzed using Kirchhoff's laws?",
+        "opt1": "Series circuits",
+        "opt2": "Parallel circuits",
+        "opt3": "Complex circuits",
+        "opt4": "Both a and b",
+        "correct_option": "Both a and b",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the algebraic sum of the currents at a node according to Kirchhoff's Current Law?",
+        "opt1": "Always zero",
+        "opt2": "Always positive",
+        "opt3": "Always negative",
+        "opt4": "Always 1",
+        "correct_option": "Always zero",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the algebraic sum of the voltage drops across all the components in a loop according to Kirchhoff's Voltage Law?",
+        "opt1": "Always zero",
+        "opt2": "Always positive",
+        "opt3": "Always negative",
+        "opt4": "Always 1",
+        "correct_option": "Always zero",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can Kirchhoff's laws be used to identify problems in a circuit?",
+        "opt1": "Yes",
+        "opt2": "No",
+        "opt3": "Sometimes",
+        "opt4": "Most of times",
+        "correct_option": "Yes",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Why is understanding Kirchhoff's laws important in electrical and electronics engineering?",
+        "opt1": "To design and troubleshoot electrical circuits",
+        "opt2": "To predict the behavior of electrical circuits",
+        "opt3": "Both a and b",
+        "opt4": "None of above",
+        "correct_option": "Both a and b",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Kirchhoff's current law is based on the principle of:",
+        "opt1": "Conservation of energy",
+        "opt2": "Conservation of charge",
+        "opt3": "Conservation of power",
+        "opt4": "Conservation of Potential",
+        "correct_option": "Conservation of charge",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Kirchhoff's voltage law is based on the principle of:",
+        "opt1": "Conservation of energy",
+        "opt2": "Conservation of charge",
+        "opt3": "Conservation of power",
+        "opt4": "Conservation of Potential",
+        "correct_option": "Conservation of energy",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Kirchhoff's current law states that the total current entering a node is:",
+        "opt1": "Greater than the total current leaving the node",
+        "opt2": "Equal to the total current leaving the node",
+        "opt3": "Less than the total current leaving the node",
+        "opt4": "None of above",
+        "correct_option": "Equal to the total current leaving the node",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Kirchhoff's voltage law states that the sum of the voltages around any closed loop in a circuit is:",
+        "opt1": "Equal to zero",
+        "opt2": "Greater than zero",
+        "opt3": "Less than zero",
+        "opt4": "Equal to 1",
+        "correct_option": "Equal to zero",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Kirchhoff's laws are fundamental laws in:",
+        "opt1": "Electrical circuit analysis",
+        "opt2": "Mechanical engineering",
+        "opt3": "Civil engineering",
+        "opt4": "All of above",
+        "correct_option": "Electrical circuit analysis",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "A linear circuit is one where the output response is:",
+        "opt1": "Directly proportional to the input signal",
+        "opt2": "Inversely proportional to the input signal",
+        "opt3": "Not related to the input signal",
+        "opt4": "None of above",
+        "correct_option": "Directly proportional to the input signal",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Non-linear circuits do not follow a simple scaling rule, meaning that:",
+        "opt1": "The input and output signals are directly proportional",
+        "opt2": "The input and output signals are inversely proportional",
+        "opt3": "The relationship between the input and output signals may be more complex",
+        "opt4": "None of above",
+        "correct_option": "The relationship between the input and output signals may be more complex",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Linear circuits are easy to analyze using mathematical tools such as:",
+        "opt1": "Kirchhoff's laws and Ohm's law",
+        "opt2": "Differential equations and Laplace transforms",
+        "opt3": "Both a and b",
+        "opt4": "None of above",
+        "correct_option": "Kirchhoff's laws and Ohm's law",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Non-linear circuits often exhibit a threshold voltage or current, beyond which:",
+        "opt1": "The output response becomes distorted or unpredictable",
+        "opt2": "The output response becomes directly proportional to the input signal",
+        "opt3": "The output response remains constant",
+        "opt4": "All of above",
+        "correct_option": "The output response becomes distorted or unpredictable",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following circuits is an example of a non-linear circuit?",
+        "opt1": "Resistor-capacitor circuit",
+        "opt2": "Op-amp circuit",
+        "opt3": "Diode rectifier circuit",
+        "opt4": "All of above",
+        "correct_option": "Diode rectifier circuit",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "In a non-linear circuit, the relationship between the input and output signals may be more complex, meaning that:",
+        "opt1": "The circuit is always unstable",
+        "opt2": "The circuit is difficult to analyze",
+        "opt3": "The circuit is easy to analyze",
+        "opt4": "None of above",
+        "correct_option": "The circuit is difficult to analyze",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Linear circuits are often used in:",
+        "opt1": "Simple electronic devices",
+        "opt2": "Advanced electronic devices",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Simple electronic devices",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Non-linear circuits are often used in:",
+        "opt1": "Simple electronic devices",
+        "opt2": "Advanced electronic devices",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Advanced electronic devices",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a linear circuit, the output response is directly proportional to the input signal, meaning that if the input signal is doubled:",
+        "opt1": "The output signal will be halved",
+        "opt2": "The output signal will be doubled",
+        "opt3": "The output signal will not change",
+        "opt4": "The output signal will remain same",
+        "correct_option": "The output signal will be doubled",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following mathematical tools can be used to analyze linear circuits?",
+        "opt1": "Kirchhoff's laws",
+        "opt2": "Differential equations",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Both A and B",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of circuit is easier to analyze using mathematical tools like Kirchhoff's laws?",
+        "opt1": "Linear circuit",
+        "opt2": "Non-linear circuit",
+        "opt3": "Both a and b are equally easier",
+        "opt4": "none of above circuit can be analyzed",
+        "correct_option": "Linear circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following techniques is often used to analyze non-linear circuits?",
+        "opt1": "Nodal analysis",
+        "opt2": "Mesh analysis",
+        "opt3": "Nonlinear circuit analysis",
+        "opt4": "Both b and c",
+        "correct_option": "Nonlinear circuit analysis",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What happens to the output response of a non-linear circuit when the input signal is too large or too small?",
+        "opt1": "It becomes distorted or unpredictable.",
+        "opt2": "It remains constant.",
+        "opt3": "It becomes linear",
+        "opt4": "It becomes diminished.",
+        "correct_option": "It becomes distorted or unpredictable.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuit is commonly found in applications such as amplifiers and oscillators?",
+        "opt1": "Linear circuit",
+        "opt2": "Non-linear circuit",
+        "opt3": "Both types of circuits are equally common",
+        "opt4": "None of above",
+        "correct_option": "Non-linear circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the main difference between linear and non-linear circuits?",
+        "opt1": "Linear circuits have a predictable output response, while non-linear circuits do not",
+        "opt2": "Non-linear circuits follow a simple scaling rule, while linear circuits do not",
+        "opt3": "Both types of circuits behave in exactly the same way.",
+        "opt4": "None of above",
+        "correct_option": "Linear circuits have a predictable output response, while non-linear circuits do not",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is an example of a linear circuit element?",
+        "opt1": "Diode",
+        "opt2": "Capacitor",
+        "opt3": "Resistor",
+        "opt4": "Both a and c",
+        "correct_option": "Resistor",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is an example of a non-linear circuit element?",
+        "opt1": "Diode",
+        "opt2": "Inductor",
+        "opt3": "Resistor",
+        "opt4": "Both a and c",
+        "correct_option": "Diode",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuit is more commonly used in digital electronics?",
+        "opt1": "Linear circuit",
+        "opt2": "Non-linear circuit",
+        "opt3": "Both types of circuits are equally common",
+        "opt4": "both a and b not used at all",
+        "correct_option": "Linear circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuit requires AC analysis techniques?",
+        "opt1": "Bilateral circuits",
+        "opt2": "Unilateral circuits",
+        "opt3": "Both bilateral and unilateral circuits",
+        "opt4": "None of the above",
+        "correct_option": "Bilateral circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which circuit element is an example of a unilateral element?",
+        "opt1": "Resistor",
+        "opt2": "Capacitor",
+        "opt3": "Inductor",
+        "opt4": "Diode",
+        "correct_option": "Diode",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which type of circuit can be analyzed using only DC circuit analysis techniques?",
+        "opt1": "Bilateral circuits",
+        "opt2": "Unilateral circuits",
+        "opt3": "Both bilateral and unilateral circuits",
+        "opt4": "None of the above",
+        "correct_option": "Bilateral circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is another name for bilateral circuits?",
+        "opt1": "Asymmetric circuits",
+        "opt2": "Unilateral circuits",
+        "opt3": "Symmetric circuits",
+        "opt4": "AC circuits",
+        "correct_option": "Symmetric circuits",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of circuit element exhibits the same response to signals applied in either direction?",
+        "opt1": "Unilateral element",
+        "opt2": "Bilateral element",
+        "opt3": "Both unilateral and bilateral elements",
+        "opt4": "None of the above",
+        "correct_option": "Bilateral element",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following circuits is an example of a unilateral circuit?",
+        "opt1": "Diode rectifier circuit",
+        "opt2": "RC circuit",
+        "opt3": "LC circuit",
+        "opt4": "AC circuit",
+        "correct_option": "Diode rectifier circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuit element requires consideration of the direction of the applied signal?",
+        "opt1": "Bilateral element",
+        "opt2": "Unilateral element",
+        "opt3": "Both A and B",
+        "opt4": "None of the above",
+        "correct_option": "Unilateral element",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of circuit exhibits both symmetric and asymmetric behavior?",
+        "opt1": "Unilateral circuit",
+        "opt2": "Bilateral circuit",
+        "opt3": "Circuits with both bilateral and unilateral elements",
+        "opt4": "None of the above",
+        "correct_option": "Circuits with both bilateral and unilateral elements",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true regarding the analysis of circuits with both bilateral and unilateral elements?",
+        "opt1": "They require only DC circuit analysis techniques.",
+        "opt2": "They require only AC circuit analysis techniques.",
+        "opt3": "They require both DC and AC circuit analysis techniques.",
+        "opt4": "They cannot be analyzed.",
+        "correct_option": "They require both DC and AC circuit analysis techniques.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of circuit elements respond identically to signals applied in either direction?",
+        "opt1": "Bilateral",
+        "opt2": "Unilateral",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Bilateral",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuits require only DC circuit analysis techniques?",
+        "opt1": "Bilateral",
+        "opt2": "Unilateral",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Bilateral",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuit elements respond differently to signals applied in different directions?",
+        "opt1": "Bilateral",
+        "opt2": "Unilateral",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Unilateral",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of circuits require AC circuit analysis techniques?",
+        "opt1": "Bilateral",
+        "opt2": "Unilateral",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Bilateral",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is an example of a bilateral circuit element?",
+        "opt1": "Diode",
+        "opt2": "Resistor",
+        "opt3": "Transistor",
+        "opt4": "None of above",
+        "correct_option": "Resistor",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of circuits are also known as symmetric circuits?",
+        "opt1": "Bilateral",
+        "opt2": "Unilateral",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Bilateral",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuits are also known as asymmetric circuits?",
+        "opt1": "Bilateral",
+        "opt2": "Unilateral",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Unilateral",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of circuits can have both bilateral and unilateral elements?",
+        "opt1": "Bilateral circuits only",
+        "opt2": "Unilateral circuits only",
+        "opt3": "Circuits with both bilateral and unilateral elements",
+        "opt4": "None of above",
+        "correct_option": "Circuits with both bilateral and unilateral elements",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "In which type of circuits does the direction of the signal matter?",
+        "opt1": "Bilateral",
+        "opt2": "Unilateral",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Unilateral",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of circuit must be analyzed using both DC and AC circuit analysis techniques?",
+        "opt1": "Bilateral circuits only",
+        "opt2": "Unilateral circuits only",
+        "opt3": "Circuits with both bilateral and unilateral elements",
+        "opt4": "None of above",
+        "correct_option": "Circuits with both bilateral and unilateral elements",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following circuits is an example of a bilateral circuit?",
+        "opt1": "Diode rectifier circuit",
+        "opt2": "Resistor-capacitor circuit",
+        "opt3": "Transistor amplifier circuit",
+        "opt4": "None of the above",
+        "correct_option": "Resistor-capacitor circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following circuits requires an external source of power to function?",
+        "opt1": "Passive circuit",
+        "opt2": "Active circuit",
+        "opt3": "Bilateral circuit",
+        "opt4": "Unilateral circuit",
+        "correct_option": "Active circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following components is not present in passive circuits?",
+        "opt1": "Transistors",
+        "opt2": "Inductors",
+        "opt3": "Capacitors",
+        "opt4": "Resistors",
+        "correct_option": "Transistors",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuit is used in filters and impedance matching circuits?",
+        "opt1": "Passive circuits",
+        "opt2": "Active circuits",
+        "opt3": "Both a and b",
+        "opt4": "None of above",
+        "correct_option": "Passive circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuit is used in amplifiers and oscillators?",
+        "opt1": "Passive circuits",
+        "opt2": "Active circuits",
+        "opt3": "Both a and b",
+        "opt4": "None of above",
+        "correct_option": "Active circuits",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of circuit requires an external power source to function?",
+        "opt1": "Passive circuits",
+        "opt2": "Active circuits",
+        "opt3": "Both a and b",
+        "opt4": "None of above",
+        "correct_option": "Active circuits",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following circuits can control signals?",
+        "opt1": "Passive circuits",
+        "opt2": "Active circuits",
+        "opt3": "Both a and b",
+        "opt4": "None of above",
+        "correct_option": "Active circuits",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following circuits attenuates signals?",
+        "opt1": "Passive circuits",
+        "opt2": "Active circuits",
+        "opt3": "Both a and b",
+        "opt4": "None of above",
+        "correct_option": "Passive circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following components is an active component?",
+        "opt1": "Capacitor",
+        "opt2": "Transistor",
+        "opt3": "Resistor",
+        "opt4": "Inductor",
+        "correct_option": "Transistor",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following circuits can generate power gain?",
+        "opt1": "Passive circuit",
+        "opt2": "Active circuit",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Active circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following circuits can only attenuate or filter a signal?",
+        "opt1": "Passive circuit",
+        "opt2": "Active circuit",
+        "opt3": "Bilateral circuit",
+        "opt4": "Unilateral circuit",
+        "correct_option": "Passive circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of circuit contains only passive components?",
+        "opt1": "Active circuit",
+        "opt2": "Bilateral circuit",
+        "opt3": "Passive circuit",
+        "opt4": "Unilateral circuit",
+        "correct_option": "Passive circuit",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following circuits cannot perform mathematical operations on signals?",
+        "opt1": "Passive circuit",
+        "opt2": "Active circuit",
+        "opt3": "Bilateral circuit",
+        "opt4": "Unilateral circuit",
+        "correct_option": "Passive circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following circuits is commonly used in filters and impedance matching circuits?",
+        "opt1": "Active circuit",
+        "opt2": "Bilateral circuit",
+        "opt3": "Unilateral circuit",
+        "opt4": "Passive circuit",
+        "correct_option": "Passive circuit",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which type of circuit can both attenuate and amplify signals?",
+        "opt1": "Passive circuit",
+        "opt2": "Active circuit",
+        "opt3": "Unilateral circuit",
+        "opt4": "Bilateral circuit",
+        "correct_option": "Active circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of circuit exhibits the same behavior in both directions of current flow?",
+        "opt1": "Passive circuit",
+        "opt2": "Active circuit",
+        "opt3": "Bilateral circuit",
+        "opt4": "Unilateral circuit",
+        "correct_option": "Bilateral circuit",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of circuit can only exhibit behavior in one direction of current flow?",
+        "opt1": "Passive circuit",
+        "opt2": "Active circuit",
+        "opt3": "Bilateral circuit",
+        "opt4": "Unilateral circuit",
+        "correct_option": "Unilateral circuit",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the superposition theorem used for?",
+        "opt1": "To simplify complex circuits",
+        "opt2": "To analyze AC circuits",
+        "opt3": "To analyze non-linear circuits",
+        "opt4": "To calculate power in circuits",
+        "correct_option": "To simplify complex circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is a necessary condition for applying the superposition theorem?",
+        "opt1": "The circuit must be linear",
+        "opt2": "The circuit must be passive",
+        "opt3": "The circuit must be bilateral",
+        "opt4": "The circuit must contain only resistors",
+        "correct_option": "The circuit must be linear",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In a circuit with multiple voltage sources, how is the superposition theorem applied?",
+        "opt1": "Each voltage source is turned on individually and the resulting current is added together",
+        "opt2": "Each voltage source is turned on individually and the resulting voltage is added together",
+        "opt3": "Each voltage source is turned on individually and the resulting current is subtracted from the total current",
+        "opt4": "Each voltage source is turned on individually and the resulting voltage is subtracted from the total voltage",
+        "correct_option": "Each voltage source is turned on individually and the resulting current is added together",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In a circuit with multiple current sources, how is the superposition theorem applied?",
+        "opt1": "Each current source is turned on individually and the resulting voltage is added together",
+        "opt2": "Each current source is turned on individually and the resulting voltage is subtracted from the total voltage",
+        "opt3": "Each current source is turned on individually and the resulting current is added together",
+        "opt4": "Each current source is turned on individually and the resulting current is subtracted from the total current",
+        "correct_option": "Each current source is turned on individually and the resulting current is added together",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the main advantage of using the superposition theorem?",
+        "opt1": "It simplifies complex circuits",
+        "opt2": "It eliminates the need for Kirchhoff's laws",
+        "opt3": "It reduces power consumption in circuits",
+        "opt4": "It can only be used for DC circuits",
+        "correct_option": "It simplifies complex circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of using the superposition theorem?",
+        "opt1": "It is time-consuming to apply to large circuits",
+        "opt2": "It can only be used for circuits with few components",
+        "opt3": "It requires specialized equipment",
+        "opt4": "It provides accurate results for non-linear circuits",
+        "correct_option": "It is time-consuming to apply to large circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the superposition theorem based on?",
+        "opt1": "Ohm's law",
+        "opt2": "Faraday's law",
+        "opt3": "Kirchhoff's laws",
+        "opt4": "The principle of superposition",
+        "correct_option": "The principle of superposition",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What type of circuits is the superposition theorem used to solve?",
+        "opt1": "Series circuits",
+        "opt2": "Parallel circuits",
+        "opt3": "Complex circuits",
+        "opt4": "Linear circuits",
+        "correct_option": "Linear circuits",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "According to the superposition theorem, what happens when multiple sources are present in a circuit?",
+        "opt1": "They cancel each other out",
+        "opt2": "They add together",
+        "opt3": "Each source is considered independently",
+        "opt4": "None of the above",
+        "correct_option": "Each source is considered independently",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the superposition theorem based on?",
+        "opt1": "Kirchhoff's current law",
+        "opt2": "Kirchhoff's voltage law",
+        "opt3": "Ohm's law",
+        "opt4": "Faraday's law",
+        "correct_option": "Ohm's law",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a requirement for the superposition theorem to be applicable?",
+        "opt1": "The circuit must be linear",
+        "opt2": "The circuit must contain only passive components",
+        "opt3": "The circuit must have only one voltage source",
+        "opt4": "The circuit must be in series configuration",
+        "correct_option": "The circuit must be linear",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How is the superposition theorem applied to a circuit with multiple sources?",
+        "opt1": "Each source is turned on one at a time, with all other sources turned off",
+        "opt2": "All sources are turned on at the same time",
+        "opt3": "All sources are turned off",
+        "opt4": "Each source is turned on in pairs, with all other sources turned off",
+        "correct_option": "Each source is turned on one at a time, with all other sources turned off",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the primary advantage of using the superposition theorem to solve circuits?",
+        "opt1": "It allows for a quick and easy solution",
+        "opt2": "It can be applied to any type of circuit",
+        "opt3": "It provides a more accurate solution than other methods",
+        "opt4": "It simplifies the circuit and reduces the number of components",
+        "correct_option": "It simplifies the circuit and reduces the number of components",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a limitation of the superposition theorem?",
+        "opt1": "It cannot be used on circuits with more than two sources",
+        "opt2": "It requires complex calculations",
+        "opt3": "It can only be used on circuits with passive components",
+        "opt4": "It is not applicable to non-linear circuits",
+        "correct_option": "It is not applicable to non-linear circuits",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the result of applying the superposition theorem to a circuit with multiple sources?",
+        "opt1": "The total voltage and current in the circuit are calculated",
+        "opt2": "The voltage and current in each component are calculated",
+        "opt3": "The power dissipated by each component is calculated",
+        "opt4": "The resistance of each component is calculated",
+        "correct_option": "The total voltage and current in the circuit are calculated",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is a step in applying the superposition theorem to a circuit?",
+        "opt1": "Calculate the total resistance of the circuit",
+        "opt2": "Calculate the voltage and current of each source individually",
+        "opt3": "Add the voltage and current of each source together",
+        "opt4": "Replace each source with a resistor of equivalent value",
+        "correct_option": "Add the voltage and current of each source together",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the formula for calculating the voltage across a component in a circuit using the superposition theorem?",
+        "opt1": "V=IR",
+        "opt2": "V=I/R",
+        "opt3": "V=Sum(V1+V2+...+Vn)",
+        "opt4": "V=Sum(I1+I2+...+In)",
+        "correct_option": "V=Sum(V1+V2+...+Vn)",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Superposition theorem is applicable to which type of circuits?",
+        "opt1": "Linear circuits only",
+        "opt2": "Non-linear circuits only",
+        "opt3": "Both linear and non-linear circuits",
+        "opt4": "Passive circuits only",
+        "correct_option": "Linear circuits only",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Superposition theorem states that in a linear circuit with multiple sources, the total response is equal to:",
+        "opt1": "The sum of all individual responses",
+        "opt2": "The product of all individual responses",
+        "opt3": "The average of all individual responses",
+        "opt4": "None of the above",
+        "correct_option": "The sum of all individual responses",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In superposition theorem, which of the following needs to be kept constant while analyzing each individual source?",
+        "opt1": "Voltage",
+        "opt2": "Current",
+        "opt3": "Resistance",
+        "opt4": "All of the above",
+        "correct_option": "Resistance",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Superposition theorem is used to calculate which of the following in a circuit?",
+        "opt1": "Voltage",
+        "opt2": "Current",
+        "opt3": "Power",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "In a circuit with two voltage sources, how many separate analyses are required using the superposition theorem?",
+        "opt1": "1",
+        "opt2": "2",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "2",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "The superposition theorem is not applicable to circuits with which of the following components?",
+        "opt1": "Resistors",
+        "opt2": "Capacitors",
+        "opt3": "Inductors",
+        "opt4": "Diodes",
+        "correct_option": "Diodes",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the Thevenin equivalent circuit?",
+        "opt1": "A circuit consisting of a single voltage source and a single resistor",
+        "opt2": "A circuit consisting of a single current source and a single resistor",
+        "opt3": "A circuit consisting of multiple voltage sources and resistors",
+        "opt4": "A circuit consisting of multiple voltage sources and a single resistor",
+        "correct_option": "A circuit consisting of a single voltage source and a single resistor",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of Thevenin's theorem?",
+        "opt1": "To simplify complex circuits into simpler, equivalent circuits",
+        "opt2": "To measure voltage and current in a circuit",
+        "opt3": "To determine the power dissipated in a circuit",
+        "opt4": "All of above",
+        "correct_option": "To simplify complex circuits into simpler, equivalent circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the first step in determining the Thevenin equivalent circuit?",
+        "opt1": "Identify the load circuit that is connected to the circuit of interest",
+        "opt2": "Remove the load circuit from the circuit of interest",
+        "opt3": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
+        "opt4": "Determine the internal resistance Rth of the circuit between those terminals",
+        "correct_option": "Identify the load circuit that is connected to the circuit of interest",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the second step in determining the Thevenin equivalent circuit?",
+        "opt1": "Identify the load circuit that is connected to the circuit of interest",
+        "opt2": "Remove the load circuit from the circuit of interest",
+        "opt3": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
+        "opt4": "Determine the internal resistance Rth of the circuit between those terminals",
+        "correct_option": "Remove the load circuit from the circuit of interest",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the third step in determining the Thevenin equivalent circuit?",
+        "opt1": "Identify the load circuit that is connected to the circuit of interest",
+        "opt2": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
+        "opt3": "Determine the internal resistance Rth of the circuit between those terminals",
+        "opt4": "None of above",
+        "correct_option": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the fourth step in determining the Thevenin equivalent circuit?",
+        "opt1": "Identify the load circuit that is connected to the circuit of interest",
+        "opt2": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
+        "opt3": "Determine the internal resistance Rth of the circuit between those terminals",
+        "opt4": "None of above",
+        "correct_option": "Determine the internal resistance Rth of the circuit between those terminals",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the final step in determining the Thevenin equivalent circuit?",
+        "opt1": "Draw the Thevenin equivalent circuit with the voltage source Vth and the resistor Rth",
+        "opt2": "Draw the Thevenin equivalent circuit with multiple voltage sources and resistors",
+        "opt3": "Determine the power delivered to the load circuit",
+        "opt4": "None of above",
+        "correct_option": "Draw the Thevenin equivalent circuit with the voltage source Vth and the resistor Rth",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the advantage of using the Thevenin equivalent circuit?",
+        "opt1": "It simplifies complex circuits into simpler, equivalent circuits",
+        "opt2": "It allows the voltage and current across the load to be easily determined",
+        "opt3": "It is useful for designing circuits that are optimized for a specific load",
+        "opt4": "All of above",
+        "correct_option": "All of above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Can Thevenin's theorem be used for non-linear circuits?",
+        "opt1": "No, it only applies to linear circuits",
+        "opt2": "Yes, it can be applied to both linear and non-linear circuits",
+        "opt3": "It only applies to circuits with voltage sources and resistors",
+        "opt4": "It only applies to circuits with current sources",
+        "correct_option": "No, it only applies to linear circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the Thevenin equivalent circuit?",
+        "opt1": "To calculate the voltage and current across a load circuit",
+        "opt2": "To determine the power delivered to a load circuit",
+        "opt3": "To simplify complex circuits into simpler, equivalent circuits",
+        "opt4": "All of above",
+        "correct_option": "All of above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is Thevenin's theorem used for in electrical engineering?",
+        "opt1": "To simplify complex circuits",
+        "opt2": "To increase the resistance of a circuit",
+        "opt3": "To reduce the voltage of a circuit",
+        "opt4": "To add more components to a circuit",
+        "correct_option": "To simplify complex circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the advantage of using Thevenin's theorem to simplify a circuit?",
+        "opt1": "It reduces the number of components that need to be analyzed",
+        "opt2": "It increases the voltage of the circuit",
+        "opt3": "It decreases the resistance of the circuit",
+        "opt4": "It adds more components to the circuit",
+        "correct_option": "It reduces the number of components that need to be analyzed",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between a Thevenin equivalent circuit and a Norton equivalent circuit?",
+        "opt1": "A Thevenin equivalent circuit uses a voltage source and a resistor, while a Norton equivalent circuit uses a current source and a resistor.",
+        "opt2": "A Thevenin equivalent circuit uses a current source and a resistor, while a Norton equivalent circuit uses a voltage source and a resistor.",
+        "opt3": "There is no difference between a Thevenin and Norton equivalent circuit.",
+        "opt4": "The choice between a Thevenin and Norton equivalent circuit depends on the type of circuit being analyzed.",
+        "correct_option": "A Thevenin equivalent circuit uses a voltage source and a resistor, while a Norton equivalent circuit uses a current source and a resistor.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the primary use of the Thevenin equivalent circuit in circuit design?",
+        "opt1": "To optimize circuits for a specific load",
+        "opt2": "To increase the resistance of a circuit",
+        "opt3": "To reduce the voltage of a circuit",
+        "opt4": "To add more components to a circuit",
+        "correct_option": "To optimize circuits for a specific load",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is Norton's theorem?",
+        "opt1": "A method to calculate the resistance of a circuit.",
+        "opt2": "A method to simplify complex circuits by using an equivalent voltage source and a series resistor.",
+        "opt3": "A method to simplify complex circuits by using an equivalent current source and a parallel resistor.",
+        "opt4": "Both a and c",
+        "correct_option": "A method to simplify complex circuits by using an equivalent current source and a parallel resistor.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the Norton equivalent current?",
+        "opt1": "The current that flows through a resistor in the circuit.",
+        "opt2": "The current that would flow if the output terminals of the circuit were short-circuited.",
+        "opt3": "The current that would flow if the output terminals of the circuit were open-circuited.",
+        "opt4": "None of above",
+        "correct_option": "The current that would flow if the output terminals of the circuit were short-circuited.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the equivalent resistance seen from the output terminals in Norton's theorem?",
+        "opt1": "The resistance of the load resistor.",
+        "opt2": "The resistance of the circuit with all voltage sources replaced by their internal resistances.",
+        "opt3": "The resistance of the circuit with all current sources replaced by their internal resistances.",
+        "opt4": "None of above",
+        "correct_option": "The resistance of the circuit with all voltage sources replaced by their internal resistances.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the Norton equivalent circuit of a linear circuit?",
+        "opt1": "A voltage source and a series resistor",
+        "opt2": "A current source and a series resistor",
+        "opt3": "A voltage source and a parallel resistor",
+        "opt4": "A current source and a parallel resistor",
+        "correct_option": "A current source and a parallel resistor",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the relationship between Norton's theorem and Thevenin's theorem?",
+        "opt1": "They are unrelated.",
+        "opt2": "They provide different methods to simplify complex circuits",
+        "opt3": "They are equivalent and can be used interchangeably.",
+        "opt4": "Thevenin's theorem can be used in place for Norton's theorem but not vice versa",
+        "correct_option": "They are equivalent and can be used interchangeably.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the advantage of using Norton's theorem?",
+        "opt1": "It simplifies complex circuits",
+        "opt2": "It allows the calculation of voltage at any point in the circuit",
+        "opt3": "It is applicable to nonlinear circuits",
+        "opt4": "It requires only one step to calculate the output",
+        "correct_option": "It simplifies complex circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the limitation of Norton's theorem?",
+        "opt1": "It can provide a method for calculating the power in the circuit.",
+        "opt2": "It can be used to analyze circuits with capacitors and inductors.",
+        "opt3": "It cannot be used for circuits with resistors in parallel",
+        "opt4": "It can only be used for circuits in steady-state conditions.",
+        "correct_option": "It can only be used for circuits in steady-state conditions.",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Can Norton's theorem be used to analyze non-linear circuits?",
+        "opt1": "Yes, as long as the circuit is simple.",
+        "opt2": "It depends on the type of non-linearity in the circuit.",
+        "opt3": "No, Norton's theorem is only applicable to linear circuits.",
+        "opt4": "Both a and b",
+        "correct_option": "No, Norton's theorem is only applicable to linear circuits.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "How is the Norton equivalent circuit connected to the load resistor?",
+        "opt1": "In series.",
+        "opt2": "In parallel",
+        "opt3": "The Norton equivalent circuit is not connected to the load resistor.",
+        "opt4": "None of above",
+        "correct_option": "In parallel",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "The Norton equivalent circuit must be connected to an external load to obtain the desired output.",
+        "opt1": "A voltage source and a series resistor",
+        "opt2": "A current source and a series resistor",
+        "opt3": "A voltage source and a parallel resistor",
+        "opt4": "A current source and a parallel resistor",
+        "correct_option": "A current source and a parallel resistor",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "When using Norton's theorem, what must be disconnected from the circuit first?",
+        "opt1": "The voltage source",
+        "opt2": "The current source",
+        "opt3": "The load resistor",
+        "opt4": "The switch",
+        "correct_option": "The load resistor",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "How is the Norton equivalent current calculated?",
+        "opt1": "By open-circuiting the output terminals and finding the current",
+        "opt2": "By short-circuiting the output terminals and finding the current",
+        "opt3": "By connecting a load resistor to the output terminals and finding the current",
+        "opt4": "By calculating the voltage across the output terminals and dividing by the resistance",
+        "correct_option": "By short-circuiting the output terminals and finding the current",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the equivalent resistance seen from the output terminals in Norton's theorem?",
+        "opt1": "The total resistance of the circuit",
+        "opt2": "The resistance of the load resistor",
+        "opt3": "The resistance of the voltage source",
+        "opt4": "The resistance seen from the output terminals with all voltage sources replaced by their internal resistances",
+        "correct_option": "The resistance seen from the output terminals with all voltage sources replaced by their internal resistances",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "In Norton's theorem, what is the Norton equivalent current source dependent on?",
+        "opt1": "The load resistor",
+        "opt2": "The voltage across the circuit",
+        "opt3": "The current through the circuit",
+        "opt4": "The total resistance of the circuit",
+        "correct_option": "The current through the circuit",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "How many steps are involved in applying Norton's theorem?",
+        "opt1": "Two",
+        "opt2": "Three",
+        "opt3": "Four",
+        "opt4": "Five",
+        "correct_option": "Five",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the main requirement for a circuit to be analyzed using Norton's theorem?",
+        "opt1": "It must be in steady-state conditions",
+        "opt2": "It must contain only resistors and voltage sources",
+        "opt3": "It must be a linear circuit",
+        "opt4": "It must contain only resistors and current sources",
+        "correct_option": "It must be a linear circuit",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the equivalent circuit obtained in Norton's theorem?",
+        "opt1": "A voltage source in series with a resistor",
+        "opt2": "A current source in series with a resistor",
+        "opt3": "A voltage source in parallel with a resistor",
+        "opt4": "A current source in parallel with a resistor",
+        "correct_option": "A current source in parallel with a resistor",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the purpose of the Norton equivalent circuit?",
+        "opt1": "To calculate the resistance of the circuit.",
+        "opt2": "To replace the original circuit with a simpler circuit.",
+        "opt3": "To provide a method for calculating the voltage at any point in the circuit.",
+        "opt4": "All of above",
+        "correct_option": "To replace the original circuit with a simpler circuit.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the maximum power transfer theorem?",
+        "opt1": "It states that the power transferred from a source to a load is maximum when the load impedance is equal to the source impedance.",
+        "opt2": "It states that the power transferred from a source to a load is maximum when the load impedance is greater than the source impedance.",
+        "opt3": "It states that the power transferred from a source to a load is maximum when the load impedance is less than the source impedance.",
+        "opt4": "None of the above.",
+        "correct_option": "It states that the power transferred from a source to a load is maximum when the load impedance is equal to the source impedance.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What type of circuits does the maximum power transfer theorem apply to?",
+        "opt1": "Linear circuits only.",
+        "opt2": "Non-linear circuits only.",
+        "opt3": "Both linear and non-linear circuits.",
+        "opt4": "None of the above.",
+        "correct_option": "Linear circuits only.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the advantage of applying the maximum power transfer theorem in a circuit?",
+        "opt1": "It reduces the power loss in the circuit.",
+        "opt2": "It increases the power loss in the circuit.",
+        "opt3": "It reduces the voltage and current in the circuit.",
+        "opt4": "None of the above.",
+        "correct_option": "It reduces the power loss in the circuit.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How does the maximum power transfer theorem help in designing power systems?",
+        "opt1": "It helps to optimize the power transfer in the system.",
+        "opt2": "It helps to increase the efficiency of the system.",
+        "opt3": "It helps to reduce the power loss in the system.",
+        "opt4": "All of the above.",
+        "correct_option": "All of the above.",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What happens when the load impedance is not equal to the source impedance in a circuit?",
+        "opt1": "The power transfer is maximum.",
+        "opt2": "The power transfer is minimum.",
+        "opt3": "The power transfer is zero.",
+        "opt4": "None of the above.",
+        "correct_option": "The power transfer is minimum.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Is the maximum power transfer theorem applicable to AC circuits?",
+        "opt1": "Yes, it is applicable to AC circuits.",
+        "opt2": "No, it is applicable only to DC circuits.",
+        "opt3": "It depends on the type of load.",
+        "opt4": "None of the above.",
+        "correct_option": "Yes, it is applicable to AC circuits.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the formula for calculating the maximum power transfer in a circuit?",
+        "opt1": "P=V*2/R",
+        "opt2": "P=I^2R",
+        "opt3": "P=V^2/2R",
+        "opt4": "P=V^2/R+L",
+        "correct_option": "P=I^2R",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Can the maximum power transfer occur at multiple values of load impedance?",
+        "opt1": "Yes, it can occur at multiple values of load impedance.",
+        "opt2": "No, it can occur at only one value of load impedance.",
+        "opt3": "It depends on the source impedance.",
+        "opt4": "None of the above.",
+        "correct_option": "No, it can occur at only one value of load impedance.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the condition for maximum power transfer in a circuit?",
+        "opt1": "The load impedance must be equal to the source impedance.",
+        "opt2": "The load impedance must be greater than the source impedance.",
+        "opt3": "The load impedance must be less than the source impedance.",
+        "opt4": "None of the above.",
+        "correct_option": "The load impedance must be equal to the source impedance.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the maximum efficiency that can be achieved in a circuit using the maximum power transfer theorem?",
+        "opt1": "100%",
+        "opt2": "50%",
+        "opt3": "25%",
+        "opt4": "It depends on the circuit.",
+        "correct_option": "50%",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "The maximum power transfer theorem is applicable to:",
+        "opt1": "Linear circuits only.",
+        "opt2": "Non-linear circuits only.",
+        "opt3": "Both linear and non-linear circuits.",
+        "opt4": "All of above",
+        "correct_option": "Linear circuits only.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "The maximum power transfer occurs when:",
+        "opt1": "The load impedance is zero.",
+        "opt2": "The load impedance is equal to the source impedance",
+        "opt3": "The load impedance is infinite.",
+        "opt4": "When load impedance is double of source impedance",
+        "correct_option": "The load impedance is equal to the source impedance",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the formula for calculating the maximum power transfer?",
+        "opt1": "Pmax=V*2",
+        "opt2": "Pmax=V^2 2",
+        "opt3": "Pmax=V^2/4R",
+        "opt4": "Pmax=V^2 2/(2R)",
+        "correct_option": "Pmax=V^2/4R",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "In which applications is the maximum power transfer theorem useful?",
+        "opt1": "Audio",
+        "opt2": "Power supplies",
+        "opt3": "Power transmission systems",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What happens when the load impedance is much larger than the source impedance?",
+        "opt1": "The power transfer is maximum",
+        "opt2": "The power transfer is minimum.",
+        "opt3": "The power transfer is zero",
+        "opt4": "None of above",
+        "correct_option": "The power transfer is minimum.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "The maximum power transfer theorem helps to:",
+        "opt1": "Minimize the amount of energy lost in transmission.",
+        "opt2": "Maximize the amount of energy lost in transmission.",
+        "opt3": "Have no effect on the amount of energy lost in transmission.",
+        "opt4": "Helps to distribute energy evenly in transmission.",
+        "correct_option": "Minimize the amount of energy lost in transmission.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "The maximum power transfer theorem is useful in designing and optimizing:",
+        "opt1": "Power systems",
+        "opt2": "Lighting systems",
+        "opt3": "Communication systems",
+        "opt4": "Both a and c",
+        "correct_option": "Power systems",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the time constant of an R-C circuit consisting of a 1 kΩ resistor and a 100 nF capacitor?",
+        "opt1": "1 ms",
+        "opt2": "100 µs",
+        "opt3": "10 µs",
+        "opt4": "10 ms",
+        "correct_option": "100 µs",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In an R-L circuit, the voltage across the inductor leads the current by how many degrees?",
+        "opt1": "0°",
+        "opt2": "45°",
+        "opt3": "90°",
+        "opt4": "180°",
+        "correct_option": "90°",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the resonant frequency of an R-L-C circuit with a 100 Ω resistor, 1 mH inductor, and a 100 nF capacitor?",
+        "opt1": "160 kHz",
+        "opt2": "16 kHz",
+        "opt3": "1.6 kHz",
+        "opt4": "1.6 MHz",
+        "correct_option": "16 kHz",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In an R-L-C circuit, what happens to the Impedance at resonance?",
+        "opt1": "It is zero",
+        "opt2": "It is at a minimum",
+        "opt3": "It is at a maximum",
+        "opt4": "It is infinite",
+        "correct_option": "It is infinite",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "A series R-C circuit has a resistor of 100 Ω and a capacitor of 10 µF. What is the cutoff frequency?",
+        "opt1": "15.9 Hz",
+        "opt2": "159 Hz",
+        "opt3": "1.59 kHz",
+        "opt4": "1.59 Hz",
+        "correct_option": "159 Hz",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In an R-L circuit, what happens to the impedance as the frequency increases?",
+        "opt1": "It increases",
+        "opt2": "It decreases",
+        "opt3": "It remains constant",
+        "opt4": "It oscillates",
+        "correct_option": "It increases",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the phase angle between the voltage and current in an R-L-C circuit at resonance?",
+        "opt1": "0°",
+        "opt2": "45°",
+        "opt3": "90°",
+        "opt4": "180°",
+        "correct_option": "0°",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the time constant of an R-L circuit consisting of a 100 Ω resistor and a 10 mH inductor?",
+        "opt1": "100 µs",
+        "opt2": "1 µs",
+        "opt3": "10 µs",
+        "opt4": "1 ms",
+        "correct_option": "100 µs",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In an R-L-C circuit, what happens to the bandwidth as the quality factor increases?",
+        "opt1": "It increases",
+        "opt2": "It decreases",
+        "opt3": "It remains constant",
+        "opt4": "It oscillates",
+        "correct_option": "It increases",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the cutoff (corner) frequency?",
+        "opt1": "15.92 Hz",
+        "opt2": "15.92 kHz",
+        "opt3": "159.2 Hz",
+        "opt4": "1.59 Hz",
+        "correct_option": "1.59 Hz",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which type of circuit contains an inductor and a resistor?",
+        "opt1": "R-L circuit",
+        "opt2": "R-C circuit",
+        "opt3": "R-L-C circuit",
+        "opt4": "None of the above",
+        "correct_option": "R-L circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the time constant of an R-C circuit?",
+        "opt1": "R/C",
+        "opt2": "CR",
+        "opt3": "RC",
+        "opt4": "1/RC",
+        "correct_option": "R/C",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the voltage across an inductor in an R-L circuit at steady state?",
+        "opt1": "Zero",
+        "opt2": "Infinite",
+        "opt3": "The same as the voltage across the resistor",
+        "opt4": "None of the above",
+        "correct_option": "Infinite",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What happens to the current in an R-L circuit if the inductance is increased?",
+        "opt1": "The current decreases",
+        "opt2": "The current increases",
+        "opt3": "The current remains the same",
+        "opt4": "The current becomes erratic",
+        "correct_option": "The current remains the same",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "In an R-C circuit, what happens to the current as the capacitor becomes fully charged?",
+        "opt1": "The current increases",
+        "opt2": "The current decreases",
+        "opt3": "The current remains the same",
+        "opt4": "The current becomes zero",
+        "correct_option": "The current becomes zero",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the resonance frequency of an R-L-C circuit?",
+        "opt1": "1/(2pisqrt(LC))",
+        "opt2": "2pisqrt(LC)",
+        "opt3": "1/(L*C)",
+        "opt4": "None of the above",
+        "correct_option": "1/(2pisqrt(LC))",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What happens to the impedance of an R-L-C circuit at resonance?",
+        "opt1": "The impedance is maximum",
+        "opt2": "The impedance is minimum",
+        "opt3": "The impedance is zero",
+        "opt4": "The impedance remains the same",
+        "correct_option": "The impedance is maximum",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In an R-L-C circuit, what happens to the phase angle at resonance?",
+        "opt1": "The phase angle is zero",
+        "opt2": "The phase angle is 180 degrees",
+        "opt3": "The phase angle is 90 degrees",
+        "opt4": "The phase angle remains the same",
+        "correct_option": "The phase angle is zero",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the resonant frequency of an AC series circuit consisting of a 20mH Inductor and a 10µF capacitor?",
+        "opt1": "159.15 Hz",
+        "opt2": "318.3 Hz",
+        "opt3": "500 Hz",
+        "opt4": "1000 Hz",
+        "correct_option": "159.15 Hz",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the resonant frequency of an AC parallel circuit consisting of a 10mH inductor and a capacitor 100µF?",
+        "opt1": "318.3 Hz",
+        "opt2": "1000 Hz",
+        "opt3": "159.15 Hz",
+        "opt4": "159.15 Hz",
+        "correct_option": "159.15 Hz",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What happens to the Impedance of an AC series resonant circuit at resonance?",
+        "opt1": "It is minimum",
+        "opt2": "It is maximum",
+        "opt3": "It is zero",
+        "opt4": "It is infinity",
+        "correct_option": "It is maximum",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What happens to the current in an AC parallel resonant circuit at resonance?",
+        "opt1": "It is minimum",
+        "opt2": "It is maximum",
+        "opt3": "It is zero",
+        "opt4": "It is infinity",
+        "correct_option": "It is maximum",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the power factor of an AC series resonant circuit at resonance?",
+        "opt1": "Unity",
+        "opt2": "Zero",
+        "opt3": "Negative",
+        "opt4": "Indeterminate",
+        "correct_option": "Zero",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the power factor of an AC parallel resonant circuit at resonance?",
+        "opt1": "Unity",
+        "opt2": "Zero",
+        "opt3": "Negative",
+        "opt4": "Indeterminate",
+        "correct_option": "Zero",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the phase angle between the voltage and current in an AC series resonant circuit at resonance?",
+        "opt1": "0 degrees",
+        "opt2": "45 degrees",
+        "opt3": "90 degrees",
+        "opt4": "180 degrees",
+        "correct_option": "0 degrees",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the phase angle between the voltage and current in an AC parallel resonant circuit at resonance?",
+        "opt1": "0 degrees",
+        "opt2": "45 degrees",
+        "opt3": "90 degrees",
+        "opt4": "180 degrees",
+        "correct_option": "0 degrees",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What happens to the voltage across the capacitor in an AC series resonant circuit at resonance?",
+        "opt1": "It is maximum",
+        "opt2": "It is minimum",
+        "opt3": "It is zero",
+        "opt4": "It is infinity",
+        "correct_option": "It is minimum",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In an AC series resonant circuit, at the resonant frequency, what is the power factor?",
+        "opt1": "Zero",
+        "opt2": "Unity",
+        "opt3": "Inductive",
+        "opt4": "Capacitive",
+        "correct_option": "Unity",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the resonant frequency of an AC series resonant circuit with an inductance of 5mH and a capacitance 10µF?",
+        "opt1": "3.18 kHz",
+        "opt2": "31.8 kHz",
+        "opt3": "318 kHz",
+        "opt4": "3.18 MHz",
+        "correct_option": "3.18 kHz",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In an AC parallel resonant circuit, at the resonant frequency, what is the impedance?",
+        "opt1": "Zero",
+        "opt2": "Infinite",
+        "opt3": "Minimum",
+        "opt4": "Maximum",
+        "correct_option": "Minimum",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 0.1µF?",
+        "opt1": "3.57 kHz",
+        "opt2": "35.7 kHz",
+        "opt3": "357 kHz",
+        "opt4": "3.57 MHz",
+        "correct_option": "3.57 kHz",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the phase relationship between the voltage across the capacitor and the voltage across the inductor in an AC series resonant circuit at resonance?",
+        "opt1": "They are in phase",
+        "opt2": "They are 180 degrees out of phase",
+        "opt3": "They cancel each other out",
+        "opt4": "None of the above",
+        "correct_option": "They are 180 degrees out of phase",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the phase relationship between the current and the voltage in an AC series resonant circuit at resonance?",
+        "opt1": "They are in phase",
+        "opt2": "They are 180 degrees out of phase",
+        "opt3": "They cancel each other out",
+        "opt4": "None of the above",
+        "correct_option": "They are in phase",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the unit of active power?",
+        "opt1": "Volt-amperes reactive (VAR)",
+        "opt2": "Watts (W)",
+        "opt3": "Volt-amperes (VA)",
+        "opt4": "None of the above",
+        "correct_option": "Watts (W)",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the formula for reactive power?",
+        "opt1": "Q=V*I",
+        "opt2": "Q=V*I*cos(theta)",
+        "opt3": "Q=V*I*sin(theta)",
+        "opt4": "None of the above",
+        "correct_option": "Q=V*I*sin(theta)",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the unit of reactive power?",
+        "opt1": "Volt-amperes reactive (VAR)",
+        "opt2": "Watts (W)",
+        "opt3": "Volt-amperes (VA)",
+        "opt4": "None of the above",
+        "correct_option": "Volt-amperes reactive (VAR)",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the formula for active power?",
+        "opt1": "P=V^2I",
+        "opt2": "P=V*I*cos(theta)",
+        "opt3": "P=V*I*sin(theta)",
+        "opt4": "None of the above",
+        "correct_option": "P=V*I*cos(theta)",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the unit of apparent power?",
+        "opt1": "Volt-amperes reactive (VAR)",
+        "opt2": "Watts (W)",
+        "opt3": "Volt-amperes (VA)",
+        "opt4": "None of the above",
+        "correct_option": "Volt-amperes (VA)",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the formula for power factor?",
+        "opt1": "pf=Q/S",
+        "opt2": "pf=P/Q",
+        "opt3": "pf=P/S",
+        "opt4": "None of the above",
+        "correct_option": "pf=P/S",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the unit of power factor?",
+        "opt1": "Volt-amperes reactive (VAR)",
+        "opt2": "Watts (W)",
+        "opt3": "Volt-amperes (VA)",
+        "opt4": "None of the above",
+        "correct_option": "None of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the relationship between active power and reactive power?",
+        "opt1": "They are the same thing",
+        "opt2": "Reactive power is always greater than active power",
+        "opt3": "Active power is always greater than reactive power",
+        "opt4": "They are two different types of power",
+        "correct_option": "They are the same thing",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the formula for apparent power?",
+        "opt1": "S=V",
+        "opt2": "S=V*I*cos(theta)",
+        "opt3": "S=V^2I*sin(theta)",
+        "opt4": "None of the above",
+        "correct_option": "S=V",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the significance of power factor in electrical circuits?",
+        "opt1": "It determines the maximum power that can be delivered to the circuit",
+        "opt2": "It measures the efficiency of the circuit in using the power delivered to it",
+        "opt3": "It is a measure of the resistance of the circuit",
+        "opt4": "None of the above",
+        "correct_option": "It measures the efficiency of the circuit in using the power delivered to it",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is a measure of how efficiently the circuit is using the power delivered to it?",
+        "opt1": "Active power",
+        "opt2": "Reactive power",
+        "opt3": "Apparent power",
+        "opt4": "Power factor",
+        "correct_option": "Power factor",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which type of power is used in the circuit to perform useful work?",
+        "opt1": "Active power",
+        "opt2": "Reactive power",
+        "opt3": "Apparent power",
+        "opt4": "None of the above",
+        "correct_option": "Active power",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of power is stored and released by the circuit?",
+        "opt1": "Active power",
+        "opt2": "Reactive power",
+        "opt3": "Apparent power",
+        "opt4": "None of the above",
+        "correct_option": "Reactive power",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the power factor of a circuit that has 100 W of active power and 120 VA of apparent power?",
+        "opt1": "0.83",
+        "opt2": "1.20",
+        "opt3": "0.20",
+        "opt4": "0.01",
+        "correct_option": "0.83",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What happens to the power factor of a circuit if the reactive power increases?",
+        "opt1": "It increases",
+        "opt2": "It decreases",
+        "opt3": "It remains the same",
+        "opt4": "Cannot be determined",
+        "correct_option": "It decreases",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is not a measure of power in an AC circuit?",
+        "opt1": "Volt-amperes reactive (VAR)",
+        "opt2": "Watts (W)",
+        "opt3": "Volt-amperes (VA)",
+        "opt4": "Hertz (Hz)",
+        "correct_option": "Hertz (Hz)",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the maximum efficiency that can be achieved in a circuit using the maximum power transfer theorem?",
+        "opt1": "100%",
+        "opt2": "50%",
+        "opt3": "25%",
+        "opt4": "It depends on the circuit.",
+        "correct_option": "50%",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the time constant of an R-C circuit consisting of a 1 kΩ resistor and a 100 nF capacitor?",
+        "opt1": "1 ms",
+        "opt2": "100 µs",
+        "opt3": "10 µs",
+        "opt4": "10 ms",
+        "correct_option": "100 µs",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In an R-L circuit, the voltage across the inductor leads the current by how many degrees?",
+        "opt1": "0°",
+        "opt2": "45°",
+        "opt3": "90°",
+        "opt4": "180°",
+        "correct_option": "90°",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the resonant frequency of an R-L-C circuit with a 100 Ω resistor, 1 mH inductor, and a 100 nF capacitor?",
+        "opt1": "160 kHz",
+        "opt2": "16 kHz",
+        "opt3": "1.6 kHz",
+        "opt4": "1.6 MHz",
+        "correct_option": "16 kHz",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In an R-L-C circuit, what happens to the Impedance at resonance?",
+        "opt1": "It is zero",
+        "opt2": "It is at a minimum",
+        "opt3": "It is at a maximum",
+        "opt4": "It is infinite",
+        "correct_option": "It is at a minimum",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the phase angle between the voltage and current in an R-L-C circuit at resonance?",
+        "opt1": "0°",
+        "opt2": "45°",
+        "opt3": "90°",
+        "opt4": "180°",
+        "correct_option": "0°",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the time constant of an R-L circuit consisting of a 100 Ω resistor and a 10 mH inductor?",
+        "opt1": "100 µs",
+        "opt2": "1 µs",
+        "opt3": "10 µs",
+        "opt4": "1 ms",
+        "correct_option": "100 µs",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In an R-L-C circuit, what happens to the bandwidth as the quality factor increases?",
+        "opt1": "It increases",
+        "opt2": "It decreases",
+        "opt3": "It remains constant",
+        "opt4": "It oscillates",
+        "correct_option": "It decreases",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the cutoff (corner) frequency?",
+        "opt1": "15.92 Hz",
+        "opt2": "15.92 kHz",
+        "opt3": "159.2 Hz",
+        "opt4": "1.59 Hz",
+        "correct_option": "1.59 Hz",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the time constant of an R-C circuit?",
+        "opt1": "R/C",
+        "opt2": "CR",
+        "opt3": "RC",
+        "opt4": "1/RC",
+        "correct_option": "RC",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the voltage across an inductor in an R-L circuit at steady state?",
+        "opt1": "Zero",
+        "opt2": "Infinite",
+        "opt3": "The same as the voltage across the resistor",
+        "opt4": "None of the above",
+        "correct_option": "Zero",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the resonance frequency of an R-L-C circuit?",
+        "opt1": "1/(2pisqrt(LC))",
+        "opt2": "2pisqrt(LC)",
+        "opt3": "1/(L*C)",
+        "opt4": "None of the above",
+        "correct_option": "1/(2pisqrt(LC))",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What happens to the impedance of an R-L-C circuit at resonance?",
+        "opt1": "The impedance is maximum",
+        "opt2": "The impedance is minimum",
+        "opt3": "The impedance is zero",
+        "opt4": "The impedance remains the same",
+        "correct_option": "The impedance is minimum",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What happens to the Impedance of an AC series resonant circuit at resonance?",
+        "opt1": "It is minimum",
+        "opt2": "It is maximum",
+        "opt3": "It is zero",
+        "opt4": "It is infinity",
+        "correct_option": "It is minimum",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What happens to the current in an AC parallel resonant circuit at resonance?",
+        "opt1": "It is minimum",
+        "opt2": "It is maximum",
+        "opt3": "It is zero",
+        "opt4": "It is infinity",
+        "correct_option": "It is minimum",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the power factor of an AC series resonant circuit at resonance?",
+        "opt1": "Unity",
+        "opt2": "Zero",
+        "opt3": "Negative",
+        "opt4": "Indeterminate",
+        "correct_option": "Unity",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the power factor of an AC parallel resonant circuit at resonance?",
+        "opt1": "Unity",
+        "opt2": "Zero",
+        "opt3": "Negative",
+        "opt4": "Indeterminate",
+        "correct_option": "Unity",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What happens to the voltage across the capacitor in an AC series resonant circuit at resonance?",
+        "opt1": "It is maximum",
+        "opt2": "It is minimum",
+        "opt3": "It is zero",
+        "opt4": "It is infinity",
+        "correct_option": "It is maximum",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In an AC parallel resonant circuit, at the resonant frequency, what is the impedance?",
+        "opt1": "Zero",
+        "opt2": "Infinite",
+        "opt3": "Minimum",
+        "opt4": "Maximum",
+        "correct_option": "Maximum",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 0.1µF?",
+        "opt1": "3.57 kHz",
+        "opt2": "35.7 kHz",
+        "opt3": "357 kHz",
+        "opt4": "3.57 MHz",
+        "correct_option": "3.57 kHz",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the relationship between active power and reactive power?",
+        "opt1": "They are the same thing",
+        "opt2": "Reactive power is always greater than active power",
+        "opt3": "Active power is always greater than reactive power",
+        "opt4": "They are two different types of power",
+        "correct_option": "They are two different types of power",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which BJT configuration has unity voltage gain?",
+        "opt1": "Common Emitter",
+        "opt2": "Common Base",
+        "opt3": "Common Collector",
+        "opt4": "Both A and B",
+        "correct_option": "Common Collector",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which biasing technique uses a fixed DC voltage applied to the base terminal with respect to the emitter terminal?",
+        "opt1": "Fixed Bias",
+        "opt2": "Self-Bias",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Fixed Bias",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which biasing technique uses a resistor in series with the base-emitter junction for negative feedback?",
+        "opt1": "Fixed Bias",
+        "opt2": "Self-Bias",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Self-Bias",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which BJT configuration has low voltage gain and high current gain?",
+        "opt1": "Common Emitter",
+        "opt2": "Common Base",
+        "opt3": "Common Collector",
+        "opt4": "Both A and B",
+        "correct_option": "Common Collector",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "In which BJT configuration is the collector terminal common to both input and output circuits?",
+        "opt1": "Common Emitter",
+        "opt2": "Common Base",
+        "opt3": "Common Collector",
+        "opt4": "Both b and c",
+        "correct_option": "Common Collector",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which biasing technique is stable with changes in temperature and transistor parameters?",
+        "opt1": "Fixed Bias",
+        "opt2": "Self-Bias",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Self-Bias",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which BJT configuration is commonly used in voltage amplifier circuits?",
+        "opt1": "Common Emitter",
+        "opt2": "Common Base",
+        "opt3": "Common Collector",
+        "opt4": "Both A and B",
+        "correct_option": "Common Emitter",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In which BJT configuration is the base terminal common to both input and output circuits?",
+        "opt1": "Common Emitter",
+        "opt2": "Common Base",
+        "opt3": "Common Collector",
+        "opt4": "Both A and B",
+        "correct_option": "Common Base",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which model is used to analyze a circuit's behavior when a small AC signal is applied?",
+        "opt1": "Large Signal Model",
+        "opt2": "Small Signal Model",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Small Signal Model",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which model is used to analyze a circuit's behavior when a large DC signal is applied?",
+        "opt1": "Large Signal Model",
+        "opt2": "Small Signal Model",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Large Signal Model",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which model uses linear circuit analysis techniques such as superposition, Thevenin's theorem, and Norton's theorem?",
+        "opt1": "Large Signal Model",
+        "opt2": "Small Signal Model",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Small Signal Model",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which model uses nonlinear circuit analysis techniques such as load-line analysis and graphical analysis?",
+        "opt1": "Large Signal Model",
+        "opt2": "Small Signal Model",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Large Signal Model",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which model represents the transistor as a voltage-controlled current source?",
+        "opt1": "Large Signal Model",
+        "opt2": "Small Signal Model",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Small Signal Model",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which model includes the effects of the nonlinear components such as diodes, transistors, and operational amplifiers?",
+        "opt1": "Large Signal Model",
+        "opt2": "Small Signal Model",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Large Signal Model",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which model is used to analyze switching circuits?",
+        "opt1": "Large Signal Model of BJT",
+        "opt2": "Small Signal Model of BJT",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Large Signal Model of BJT",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which model is used to design and analyze amplifier circuits?",
+        "opt1": "Large Signal Model of BJT",
+        "opt2": "Small Signal Model of BJT",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Small Signal Model of BJT",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which model uses the transistor parameters such as hfe, hie, and hoe to calculate the voltage gain and current gain of the circuit?",
+        "opt1": "Large Signal Model of BJT",
+        "opt2": "Small Signal Model of BJT",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Small Signal Model of BJT",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which model uses the transistor parameters such as saturation voltage, Vce(sat), and cut-off voltage, Vce(cut-off) to analyze the circuit's behavior?",
+        "opt1": "Large Signal Model of BJT",
+        "opt2": "Small Signal Model of BJT",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Large Signal Model of BJT",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What does MOSFET stand for?",
+        "opt1": "Metal-Oxide-Semiconductor Field-Effect Transistor",
+        "opt2": "Magnetic-Oscillation-Silicon Field-Effect Transistor",
+        "opt3": "Multi-Oscillator-Silicon Field-Effect Transistor",
+        "opt4": "None of above",
+        "correct_option": "Metal-Oxide-Semiconductor Field-Effect Transistor",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In which region of operation does the MOSFET act as a voltage-controlled resistor?",
+        "opt1": "Cut-off region",
+        "opt2": "Saturation region",
+        "opt3": "Triode region",
+        "opt4": "None of above",
+        "correct_option": "Triode region",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the threshold voltage of a MOSFET?",
+        "opt1": "The voltage required to turn on the MOSFET",
+        "opt2": "The voltage required to turn off the MOSFET",
+        "opt3": "The voltage at which the MOSFET conducts maximum current",
+        "opt4": "The voltage at which the MOSFET conducts minimum current",
+        "correct_option": "The voltage required to turn on the MOSFET",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of MOSFET has a lower on-resistance and higher switching speed?",
+        "opt1": "Enhancement-mode MOSFET",
+        "opt2": "Depletion-mode MOSFET",
+        "opt3": "Both have the same characteristics",
+        "opt4": "None of above",
+        "correct_option": "Enhancement-mode MOSFET",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the full form of CMOS?",
+        "opt1": "Complementary Metal-Oxide-Semiconductor",
+        "opt2": "Complex Metal-Oxide-Semiconductor",
+        "opt3": "Complementary Magnetic-Oscillation-Semiconductor",
+        "opt4": "Complementary Magnetic Oxide Semiconductor",
+        "correct_option": "Complementary Metal-Oxide-Semiconductor",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which logic family uses CMOS technology?",
+        "opt1": "TTL",
+        "opt2": "ECL",
+        "opt3": "CMOS",
+        "opt4": "All of above",
+        "correct_option": "CMOS",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of logic gate is used to implement the CMOS circuit?",
+        "opt1": "NAND gate",
+        "opt2": "NOR gate",
+        "opt3": "Both NAND and NOR gates",
+        "opt4": "None of above",
+        "correct_option": "Both NAND and NOR gates",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the main advantage of CMOS technology over other logic families?",
+        "opt1": "Low power consumption",
+        "opt2": "High speed",
+        "opt3": "Low cost",
+        "opt4": "All of above",
+        "correct_option": "Low power consumption",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of MOSFET is more commonly used in digital logic circuits?",
+        "opt1": "N-channel MOSFET",
+        "opt2": "P-channel MOSFET",
+        "opt3": "Both A and B are equally used",
+        "opt4": "None of above",
+        "correct_option": "N-channel MOSFET",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which application of MOSFET is used in power electronics?",
+        "opt1": "Switching",
+        "opt2": "Amplification",
+        "opt3": "Oscillation",
+        "opt4": "All of above",
+        "correct_option": "Switching",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following describes the working principle of a MOSFET?",
+        "opt1": "A voltage applied to the gate terminal creates an electric field that controls the current flow through the channel between the source and drain terminals.",
+        "opt2": "The current flow through the channel between the source and drain terminals controls the voltage applied to the gate terminal.",
+        "opt3": "The current flow through the channel between the source and drain terminals is independent of the voltage applied to the gate terminal.",
+        "opt4": "None of above",
+        "correct_option": "A voltage applied to the gate terminal creates an electric field that controls the current flow through the channel between the source and drain terminals.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the basic building block of a CMOS circuit?",
+        "opt1": "Bipolar Junction Transistor (BJT)",
+        "opt2": "Field Effect Transistor (FET)",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Field Effect Transistor (FET)",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following describes the working principle of a CMOS circuit?",
+        "opt1": "The output is a function of the input voltage and the current flowing through the transistor.",
+        "opt2": "The output is a function of the input voltage and the voltage level at the gate of the transistor.",
+        "opt3": "The output is a function of the input voltage and the logic level of the transistor",
+        "opt4": "None of above",
+        "correct_option": "The output is a function of the input voltage and the voltage level at the gate of the transistor.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following statements is true about MOSFETs?",
+        "opt1": "They have a high input impedance and a low output impedance.",
+        "opt2": "They have a low input impedance and a high output impedance.",
+        "opt3": "They have both high input and output impedances.",
+        "opt4": "All of above",
+        "correct_option": "They have a high input impedance and a low output impedance.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following describes the typical applications of MOSFETs?",
+        "opt1": "Digital logic circuits and memory devices",
+        "opt2": "Power amplifiers and switching circuits",
+        "opt3": "Power switching and amplification",
+        "opt4": "Both A and B",
+        "correct_option": "Both A and B",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is an advantage of CMOS technology?",
+        "opt1": "Low power consumption",
+        "opt2": "High speed operation",
+        "opt3": "High gain",
+        "opt4": "All of above",
+        "correct_option": "Low power consumption",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about CMOS circuits?",
+        "opt1": "They are sensitive to noise and interference.",
+        "opt2": "They have a higher power consumption compared to other technologies.",
+        "opt3": "They are immune to noise and interference and have low power consumption.",
+        "opt4": "None of above",
+        "correct_option": "They are immune to noise and interference and have low power consumption.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following describes the typical applications of CMOS circuits?",
+        "opt1": "Microprocessors and digital logic circuits",
+        "opt2": "Power amplifiers and switching circuits",
+        "opt3": "Both A and B",
+        "opt4": "None of above",
+        "correct_option": "Microprocessors and digital logic circuits",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about MOSFETs and CMOS circuits?",
+        "opt1": "MOSFETs are more suitable for digital logic circuits, while CMOS circuits are more suitable for power switching applications.",
+        "opt2": "Both MOSFETs and CMOS circuits can be used for power switching and digital logic circuits.",
+        "opt3": "MOSFETs are more suitable for power switching applications, while CMOS circuits are more suitable for digital logic circuits.",
+        "opt4": "None of above",
+        "correct_option": "MOSFETs are more suitable for power switching applications, while CMOS circuits are more suitable for digital logic circuits.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of oscillator uses a resistor and capacitor in a feedback circuit?",
+        "opt1": "RC oscillator",
+        "opt2": "LC oscillator",
+        "opt3": "Crystal oscillator",
+        "opt4": "None of the above",
+        "correct_option": "RC oscillator",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What determines the frequency of an RC oscillator?",
+        "opt1": "The time constant of the RC circuit",
+        "opt2": "The resonant frequency of the tank circuit",
+        "opt3": "The inductance of a coil",
+        "opt4": "The capacitance of a capacitor",
+        "correct_option": "The time constant of the RC circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of oscillator uses an inductor and capacitor in a feedback circuit?",
+        "opt1": "RC oscillator",
+        "opt2": "LC oscillator",
+        "opt3": "Crystal oscillator",
+        "opt4": "None of the above",
+        "correct_option": "LC oscillator",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What determines the frequency of an LC oscillator?",
+        "opt1": "The time constant of an RC circuit",
+        "opt2": "The resonant frequency of a tank circuit",
+        "opt3": "The inductance of a coil",
+        "opt4": "The capacitance of a capacitor",
+        "correct_option": "The resonant frequency of a tank circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of oscillator uses a quartz crystal as the resonant element in the feedback circuit?",
+        "opt1": "RC oscillator",
+        "opt2": "LC oscillator",
+        "opt3": "Crystal oscillator",
+        "opt4": "None of the above",
+        "correct_option": "Crystal oscillator",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the primary advantage of using a crystal oscillator?",
+        "opt1": "Low cost",
+        "opt2": "Simplicity",
+        "opt3": "High frequency stability and accuracy",
+        "opt4": "Low power consumption",
+        "correct_option": "High frequency stability and accuracy",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the role of the feedback circuit in an oscillator?",
+        "opt1": "To amplify the input signal",
+        "opt2": "To filter out unwanted frequencies",
+        "opt3": "To provide positive feedback to sustain oscillations",
+        "opt4": "To provide negative feedback to stabilize the oscillations",
+        "correct_option": "To provide positive feedback to sustain oscillations",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of oscillator is commonly used in digital circuits?",
+        "opt1": "RC oscillator",
+        "opt2": "LC oscillator",
+        "opt3": "Crystal oscillator",
+        "opt4": "Square wave generator",
+        "correct_option": "Crystal oscillator",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of oscillator is typically the most complex and expensive?",
+        "opt1": "RC oscillator",
+        "opt2": "LC oscillator",
+        "opt3": "Crystal oscillator",
+        "opt4": "None of the above",
+        "correct_option": "Crystal oscillator",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the resonant circuit in an oscillator?",
+        "opt1": "To amplify the input signal",
+        "opt2": "To filter out unwanted frequencies",
+        "opt3": "To provide positive feedback to sustain oscillations",
+        "opt4": "To provide negative feedback to stabilize the oscillations",
+        "correct_option": "To provide positive feedback to sustain oscillations",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is an RC oscillator?",
+        "opt1": "An oscillator that uses a resistor and capacitor in a feedback circuit",
+        "opt2": "An oscillator that uses an inductor and capacitor in a feedback circuit",
+        "opt3": "An oscillator that uses a quartz crystal in a feedback circuit",
+        "opt4": "An oscillator that uses a diode in a feedback circuit",
+        "correct_option": "An oscillator that uses a resistor and capacitor in a feedback circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the advantage of using an LC oscillator over an RC oscillator?",
+        "opt1": "Greater simplicity and lower cost",
+        "opt2": "Higher frequency stability and accuracy",
+        "opt3": "Higher power output",
+        "opt4": "Greater frequency range",
+        "correct_option": "Higher frequency stability and accuracy",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is a tank circuit in an LC oscillator?",
+        "opt1": "A circuit that filters out unwanted frequencies",
+        "opt2": "A circuit that amplifies the input signal",
+        "opt3": "A circuit that provides positive feedback",
+        "opt4": "A circuit that consists of an inductor and capacitor in a feedback circuit",
+        "correct_option": "A circuit that consists of an inductor and capacitor in a feedback circuit",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the resonant frequency of a crystal oscillator determined by?",
+        "opt1": "The time constant of the RC circuit",
+        "opt2": "The resonant frequency of the tank circuit",
+        "opt3": "The frequency of the crystal",
+        "opt4": "The input voltage of the oscillator",
+        "correct_option": "The frequency of the crystal",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the advantage of using a crystal oscillator over an LC oscillator?",
+        "opt1": "Greater simplicity and lower cost",
+        "opt2": "Higher frequency stability and accuracy",
+        "opt3": "Higher power output",
+        "opt4": "Greater frequency range",
+        "correct_option": "Higher frequency stability and accuracy",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of oscillator is typically used in clocks and digital circuits?",
+        "opt1": "RC oscillator",
+        "opt2": "LC oscillator",
+        "opt3": "Crystal oscillator",
+        "opt4": "Relaxation oscillator",
+        "correct_option": "Crystal oscillator",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of positive feedback in an oscillator?",
+        "opt1": "To amplify the input signal",
+        "opt2": "To provide a frequency-selective response",
+        "opt3": "To sustain oscillations",
+        "opt4": "To filter out unwanted frequencies",
+        "correct_option": "To sustain oscillations",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the role of the resonant circuit in an oscillator?",
+        "opt1": "To provide positive feedback",
+        "opt2": "To amplify the input signal",
+        "opt3": "To filter out unwanted frequencies",
+        "opt4": "To provide a frequency-selective response",
+        "correct_option": "To provide a frequency-selective response",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the advantage of using a high-Q resonant circuit in an oscillator?",
+        "opt1": "Greater simplicity and lower cost",
+        "opt2": "Higher frequency stability and accuracy",
+        "opt3": "Higher power output",
+        "opt4": "Greater frequency range",
+        "correct_option": "Higher frequency stability and accuracy",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the duty cycle of a square wave generator?",
+        "opt1": "The time period of the waveform",
+        "opt2": "The ratio of the pulse width to the time period",
+        "opt3": "The amplitude of the waveform",
+        "opt4": "The frequency of the waveform",
+        "correct_option": "The ratio of the pulse width to the time period",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What type of waveform is produced by a triangle wave generator?",
+        "opt1": "A waveform with constant amplitude and frequency",
+        "opt2": "A waveform with a linearly increasing or decreasing amplitude",
+        "opt3": "A waveform with a constant frequency and varying amplitude",
+        "opt4": "A waveform with random fluctuations in amplitude and frequency",
+        "correct_option": "A waveform with a linearly increasing or decreasing amplitude",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What type of circuit is commonly used to generate square wave signals?",
+        "opt1": "An op-amp circuit",
+        "opt2": "A transistor circuit",
+        "opt3": "A flip-flop circuit",
+        "opt4": "A filter circuit",
+        "correct_option": "An op-amp circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the advantage of using a relaxation oscillator for square wave generation?",
+        "opt1": "Simplicity and low cost",
+        "opt2": "High frequency stability and accuracy",
+        "opt3": "High power output",
+        "opt4": "Greater frequency range",
+        "correct_option": "Simplicity and low cost",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the role of a Schmitt trigger in a square wave generator circuit?",
+        "opt1": "To generate a clean and stable square wave signal",
+        "opt2": "To provide frequency-selective response",
+        "opt3": "To amplify the input signal",
+        "opt4": "To filter out unwanted frequencies",
+        "correct_option": "To generate a clean and stable square wave signal",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the frequency of a triangle wave generator determined by?",
+        "opt1": "The time constant of the RC circuit",
+        "opt2": "The resonant frequency of the tank circuit",
+        "opt3": "The frequency of the crystal",
+        "opt4": "The input voltage of the oscillator",
+        "correct_option": "The time constant of the RC circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the advantage of using a ramp generator for triangle wave generation?",
+        "opt1": "Simplicity and low cost",
+        "opt2": "High frequency stability and accuracy",
+        "opt3": "High power output",
+        "opt4": "Greater frequency range",
+        "correct_option": "Simplicity and low cost",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What type of circuit is commonly used to generate triangle wave signals?",
+        "opt1": "An op-amp circuit",
+        "opt2": "An integrator circuit",
+        "opt3": "A flip-flop circuit",
+        "opt4": "A transistor circuit",
+        "correct_option": "An integrator circuit",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the amplitude of a triangle wave generator determined by?",
+        "opt1": "The time constant of the RC circuit",
+        "opt2": "The resonant frequency of the tank circuit",
+        "opt3": "The frequency of the crystal",
+        "opt4": "The input voltage of the oscillator",
+        "correct_option": "The input voltage of the oscillator",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the advantage of using an op-amp circuit for triangle wave generation?",
+        "opt1": "Simplicity and low cost",
+        "opt2": "High frequency stability and accuracy",
+        "opt3": "High power output",
+        "opt4": "Greater frequency range",
+        "correct_option": "Simplicity and low cost",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which waveform generator is typically used for testing digital circuits?",
+        "opt1": "Sine wave generator",
+        "opt2": "Square wave generator",
+        "opt3": "Triangle wave generator",
+        "opt4": "Sawtooth wave generator",
+        "correct_option": "Square wave generator",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the duty cycle of a square wave?",
+        "opt1": "The time period of the wave",
+        "opt2": "The ratio of the pulse width to the time period",
+        "opt3": "The frequency of the wave",
+        "opt4": "The amplitude of the wave",
+        "correct_option": "The ratio of the pulse width to the time period",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the advantage of using a square wave generator over other types of waveform generators?",
+        "opt1": "Simplicity and low cost",
+        "opt2": "High frequency stability and accuracy",
+        "opt3": "High power output",
+        "opt4": "Wide range of frequency and waveform options",
+        "correct_option": "Simplicity and low cost",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which waveform generator is capable of producing more complex waveforms than a square wave generator?",
+        "opt1": "Sine wave generator",
+        "opt2": "Triangle wave generator",
+        "opt3": "Sawtooth wave generator",
+        "opt4": "Arbitrary waveform generator",
+        "correct_option": "Arbitrary waveform generator",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the shape of the waveform produced by a triangle wave generator?",
+        "opt1": "A series of pulses with a constant amplitude",
+        "opt2": "A smoothly varying waveform with a linear rise and fall",
+        "opt3": "A waveform with a rapidly changing rise and a slow fall",
+        "opt4": "A waveform with a rapidly changing fall and a slow rise",
+        "correct_option": "A smoothly varying waveform with a linear rise and fall",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the frequency of a triangle wave generator determined by?",
+        "opt1": "The time period of the waveform",
+        "opt2": "The amplitude of the waveform",
+        "opt3": "The duty cycle of the waveform",
+        "opt4": "The slope of the waveform",
+        "correct_option": "The slope of the waveform",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the advantage of using a triangle wave generator over a square wave generator?",
+        "opt1": "Greater simplicity and lower cost",
+        "opt2": "Higher frequency stability and accuracy",
+        "opt3": "Higher power output",
+        "opt4": "More gradual transitions and reduced harmonic content",
+        "correct_option": "More gradual transitions and reduced harmonic content",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which type of waveform generator is commonly used in audio applications?",
+        "opt1": "Sine wave generator",
+        "opt2": "Square wave generator",
+        "opt3": "Triangle wave generator",
+        "opt4": "Sawtooth wave generator",
+        "correct_option": "Sine wave generator",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the shape of the waveform produced by a sawtooth wave generator?",
+        "opt1": "A series of pulses with a constant amplitude",
+        "opt2": "A smoothly varying waveform with a linear rise and fall",
+        "opt3": "A waveform with a rapidly changing rise and a slow fall",
+        "opt4": "A waveform with a rapidly changing fall and a slow rise",
+        "correct_option": "A waveform with a rapidly changing rise and a slow fall",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the advantage of using an arbitrary waveform generator over other types of waveform generators?",
+        "opt1": "Greater simplicity and lower cost",
+        "opt2": "Higher frequency stability and accuracy",
+        "opt3": "Higher power output",
+        "opt4": "The ability to generate complex and customized waveforms",
+        "correct_option": "The ability to generate complex and customized waveforms",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the amplifying element used in a Class A output stage?",
+        "opt1": "Bipolar Junction Transistor",
+        "opt2": "Field-Effect Transistor",
+        "opt3": "Operational Amplifier",
+        "opt4": "Vacuum Tube",
+        "correct_option": "Bipolar Junction Transistor",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What causes crossover distortion in a Class B output stage?",
+        "opt1": "The amplifying element conducts for the entire input signal cycle",
+        "opt2": "The amplifying element is biased so that it conducts for less than half of the input signal cycle",
+        "opt3": "Two amplifying elements are used and each one conducts for half of the input signal cycle",
+        "opt4": "The switching between the amplifying elements causes a gap in the output signal.",
+        "correct_option": "The switching between the amplifying elements causes a gap in the output signal.",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the advantage of a Class AB output stage over a Class B output stage?",
+        "opt1": "Higher efficiency",
+        "opt2": "Lower distortion",
+        "opt3": "Reduced crossover distortion",
+        "opt4": "Lower cost",
+        "correct_option": "Reduced crossover distortion",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the operating mode of a Class C output stage?",
+        "opt1": "Linear",
+        "opt2": "Non-linear",
+        "opt3": "Saturated",
+        "opt4": "Reverse biased",
+        "correct_option": "Non-linear",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the advantage of a Class D output stage over other output stages?",
+        "opt1": "Low distortion",
+        "opt2": "High linearity",
+        "opt3": "High efficiency",
+        "opt4": "Low switching noise",
+        "correct_option": "High efficiency",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the primary disadvantage of a Class A output stage?",
+        "opt1": "High distortion",
+        "opt2": "Low efficiency",
+        "opt3": "High switching noise",
+        "opt4": "High cost",
+        "correct_option": "Low efficiency",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of output stage is suitable for RF amplifiers?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class C",
+        "correct_option": "Class C",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the biasing arrangement used in a Class AB output stage?",
+        "opt1": "The amplifying element is biased to conduct for the entire input signal cycle.",
+        "opt2": "The amplifying element is biased to conduct for less than half of the input signal cycle.",
+        "opt3": "The bias voltage is varied to adjust the conduction angle.",
+        "opt4": "Two amplifying elements are used and each one conducts for half of the input signal cycle.",
+        "correct_option": "The bias voltage is varied to adjust the conduction angle.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of output stage is used in audio power amplifiers?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class C",
+        "correct_option": "Class AB",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of output stage is commonly used in switch-mode power supplies?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class D",
+        "correct_option": "Class D",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a characteristic of a class A output stage?",
+        "opt1": "High efficiency",
+        "opt2": "Low distortion",
+        "opt3": "Crossover distortion",
+        "opt4": "Conducts for less than half of the input signal cycle",
+        "correct_option": "Low distortion",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following output stages uses two amplifying elements that conduct for half of the input signal cycle each?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class C",
+        "opt4": "Class AB",
+        "correct_option": "Class B",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following output stages is a combination of class A and class B?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class C",
+        "correct_option": "Class AB",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following output stages is suitable for RF amplifiers?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class C",
+        "correct_option": "Class C",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following output stages uses pulse width modulation to convert the input signal into a train of pulses?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class C",
+        "opt4": "Class D",
+        "correct_option": "Class D",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of a class B output stage?",
+        "opt1": "Low distortion",
+        "opt2": "High efficiency",
+        "opt3": "Crossover distortion",
+        "opt4": "Conducts for the entire input signal cycle",
+        "correct_option": "Crossover distortion",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following output stages is the most efficient?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class C",
+        "correct_option": "Class C",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following output stages is the least efficient?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class C",
+        "correct_option": "Class A",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following output stages has a biasing arrangement that allows the amplifying element to conduct slightly even when there is no input signal?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class C",
+        "correct_option": "Class AB",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following output stages is suitable for high power audio amplifiers?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class C",
+        "correct_option": "Class AB",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the main advantage of a Class A output stage?",
+        "opt1": "High efficiency",
+        "opt2": "Low distortion",
+        "opt3": "Low power consumption",
+        "opt4": "High output power",
+        "correct_option": "Low distortion",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the main disadvantage of a Class A output stage?",
+        "opt1": "High distortion",
+        "opt2": "Low efficiency",
+        "opt3": "High power consumption",
+        "opt4": "Low output power",
+        "correct_option": "Low efficiency",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What type of biasing is commonly used in Class A output stages?",
+        "opt1": "Fixed bias",
+        "opt2": "Self-bias",
+        "opt3": "Voltage divider bias",
+        "opt4": "Current mirror bias",
+        "correct_option": "Fixed bias",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the DC bias point of a Class A output stage?",
+        "opt1": "Equal to the positive supply voltage",
+        "opt2": "Halfway between the positive and negative supply voltage",
+        "opt3": "Equal to the negative supply voltage",
+        "opt4": "Zero",
+        "correct_option": "Halfway between the positive and negative supply voltage",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the maximum theoretical efficiency of a Class A output stage?",
+        "opt1": "25%",
+        "opt2": "50%",
+        "opt3": "75%",
+        "opt4": "100%",
+        "correct_option": "50%",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the typical output power of a Class A amplifier?",
+        "opt1": "Less than 1 watt",
+        "opt2": "1 watt to 10 watts",
+        "opt3": "10 watts to 100 watts",
+        "opt4": "More than 100 watts",
+        "correct_option": "1 watt to 10 watts",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What type of load is commonly used in Class A output stages?",
+        "opt1": "Resistive load",
+        "opt2": "Capacitive load",
+        "opt3": "Inductive load",
+        "opt4": "Reactive load",
+        "correct_option": "Resistive load",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the main advantage of a Class A output stage over other amplifier configurations?",
+        "opt1": "High efficiency",
+        "opt2": "High output power",
+        "opt3": "Low distortion",
+        "opt4": "Low power consumption",
+        "correct_option": "Low distortion",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What type of input signal is best suited for a Class A output stage?",
+        "opt1": "Sinusoidal signal",
+        "opt2": "Square wave signal",
+        "opt3": "Triangular wave signal",
+        "opt4": "Pulse signal",
+        "correct_option": "Sinusoidal signal",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the typical voltage gain of a Class A amplifier?",
+        "opt1": "Less than 10",
+        "opt2": "10 to 100",
+        "opt3": "100 to 1000",
+        "opt4": "More than 1000",
+        "correct_option": "10 to 100",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a Class A output stage, the amplifying device conducts for:",
+        "opt1": "Half of the input signal cycle",
+        "opt2": "Less than half of the input signal cycle",
+        "opt3": "More than half of the input signal cycle",
+        "opt4": "The entire input signal cycle",
+        "correct_option": "The entire input signal cycle",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "The efficiency of a Class A output stage is:",
+        "opt1": "High",
+        "opt2": "Low",
+        "opt3": "Moderate",
+        "opt4": "Not applicable",
+        "correct_option": "Low",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the advantage of a Class A output stage over other classes of amplifiers?",
+        "opt1": "Higher efficiency",
+        "opt2": "Lower distortion",
+        "opt3": "Lower cost",
+        "opt4": "Higher power output",
+        "correct_option": "Lower distortion",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the key feature of a Class A output stage?",
+        "opt1": "The amplifying device conducts for the entire input signal cycle",
+        "opt2": "The amplifying device conducts for only half of the input signal cycle",
+        "opt3": "The amplifying device conducts for less than half of the input signal cycle",
+        "opt4": "The amplifying device is biased to a cutoff state",
+        "correct_option": "The amplifying device conducts for the entire input signal cycle",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the typical efficiency of a Class A output stage?",
+        "opt1": "100%",
+        "opt2": "50%",
+        "opt3": "25%",
+        "opt4": "Less than 10%",
+        "correct_option": "25%",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of a Class A output stage?",
+        "opt1": "High efficiency",
+        "opt2": "High distortion",
+        "opt3": "High cost",
+        "opt4": "Low power output",
+        "correct_option": "Low power output",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which type of amplifying device is commonly used in Class A output stages?",
+        "opt1": "Bipolar Junction Transistor (BJT)",
+        "opt2": "Metal-Oxide-Semiconductor Field-Effect Transistor (MOSFET)",
+        "opt3": "Junction Field-Effect Transistor (JFET)",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the purpose of the biasing circuit in a Class A output stage?",
+        "opt1": "To set the operating point of the amplifying device",
+        "opt2": "To provide negative feedback",
+        "opt3": "To boost the output signal",
+        "opt4": "To reduce distortion",
+        "correct_option": "To set the operating point of the amplifying device",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the quiescent current of a Class A output stage?",
+        "opt1": "The maximum current the amplifying device can handle",
+        "opt2": "The current flowing through the load resistor when there is no input signal",
+        "opt3": "The current required to bias the amplifying device",
+        "opt4": "The current flowing through the amplifying device when there is no input signal",
+        "correct_option": "The current flowing through the amplifying device when there is no input signal",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a common application of a Class A output stage?",
+        "opt1": "Audio power amplifiers",
+        "opt2": "RF amplifiers",
+        "opt3": "Voltage regulators",
+        "opt4": "Digital circuits",
+        "correct_option": "Audio power amplifiers",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is a characteristic of the output signal of a Class A output stage?",
+        "opt1": "It is a square wave",
+        "opt2": "It is a sine wave",
+        "opt3": "It is a triangular wave",
+        "opt4": "It depends on the input signal",
+        "correct_option": "It depends on the input signal",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of a Class A output stage in terms of power efficiency?",
+        "opt1": "It generates more heat than other classes of amplifiers",
+        "opt2": "It consumes more power than other classes of amplifiers",
+        "opt3": "It is more expensive than other classes of amplifiers",
+        "opt4": "It has a lower power output than other classes of amplifiers",
+        "correct_option": "It generates more heat than other classes of amplifiers",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a Class B output stage in amplifiers?",
+        "opt1": "An amplifier configuration where the amplifying device conducts for the full input signal cycle",
+        "opt2": "An amplifier configuration where the amplifying device conducts only for half of the input signal cycle",
+        "opt3": "An amplifier configuration where the output signal is inverted with respect to the input signal",
+        "opt4": "An amplifier configuration where two input signals are combined to produce the output signal",
+        "correct_option": "An amplifier configuration where the amplifying device conducts only for half of the input signal cycle",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the advantage of a Class B output stage?",
+        "opt1": "High power efficiency",
+        "opt2": "Low distortion",
+        "opt3": "High linearity",
+        "opt4": "Large voltage gain",
+        "correct_option": "High power efficiency",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is crossover distortion in a Class B output stage?",
+        "opt1": "A reduction in the voltage gain of the amplifier",
+        "opt2": "A discontinuity in the output signal at the point where one device switches off and the other switches on",
+        "opt3": "A change in the phase shift of the output signal",
+        "opt4": "An increase in the noise level of the amplifier",
+        "correct_option": "A discontinuity in the output signal at the point where one device switches off and the other switches on",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How is crossover distortion reduced in a Class B output stage?",
+        "opt1": "By increasing the voltage gain of the amplifier",
+        "opt2": "By decreasing the load impedance of the amplifier",
+        "opt3": "By applying a small amount of bias current to the amplifying devices",
+        "opt4": "By using a feedback network in the amplifier",
+        "correct_option": "By applying a small amount of bias current to the amplifying devices",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the main application of Class B output stages?",
+        "opt1": "Audio power amplifiers",
+        "opt2": "Voltage amplifiers",
+        "opt3": "Current amplifiers",
+        "opt4": "Low noise amplifiers",
+        "correct_option": "Audio power amplifiers",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the main disadvantage of Class B output stages?",
+        "opt1": "Crossover distortion",
+        "opt2": "Low power efficiency",
+        "opt3": "High distortion",
+        "opt4": "Poor linearity",
+        "correct_option": "Crossover distortion",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of biasing in a Class B output stage?",
+        "opt1": "To keep the amplifying devices slightly conductive even when there is no input signal",
+        "opt2": "To increase the voltage gain of the amplifier",
+        "opt3": "To decrease the noise level of the amplifier",
+        "opt4": "To reduce the distortion of the amplifier",
+        "correct_option": "To keep the amplifying devices slightly conductive even when there is no input signal",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the output signal waveform of a Class B output stage?",
+        "opt1": "A square wave",
+        "opt2": "A sawtooth wave",
+        "opt3": "A sine wave",
+        "opt4": "A combination of the signals produced by each device",
+        "correct_option": "A combination of the signals produced by each device",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What type of load is typically used with a Class B output stage?",
+        "opt1": "Resistive load",
+        "opt2": "Capacitive load",
+        "opt3": "Inductive load",
+        "opt4": "None of the above",
+        "correct_option": "Resistive load",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the maximum theoretical efficiency of a Class B output stage?",
+        "opt1": "50%",
+        "opt2": "75%",
+        "opt3": "90%",
+        "opt4": "100%",
+        "correct_option": "75%",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a Class B output stage, how many amplifying devices are used?",
+        "opt1": "One",
+        "opt2": "Two",
+        "opt3": "Three",
+        "opt4": "Four",
+        "correct_option": "Two",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the key advantage of a Class B output stage?",
+        "opt1": "Low power consumption",
+        "opt2": "High distortion",
+        "opt3": "High power efficiency",
+        "opt4": "Low heat generation",
+        "correct_option": "High power efficiency",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the major disadvantage of a Class B output stage?",
+        "opt1": "Low power efficiency",
+        "opt2": "High power consumption",
+        "opt3": "High distortion",
+        "opt4": "Crossover distortion",
+        "correct_option": "Crossover distortion",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "How does bias current help to address the issue of crossover distortion in a Class B output stage?",
+        "opt1": "By increasing power consumption",
+        "opt2": "By reducing power efficiency",
+        "opt3": "By keeping the amplifying devices slightly conductive",
+        "opt4": "By increasing the gain of the amplifier",
+        "correct_option": "By keeping the amplifying devices slightly conductive",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which application is Class B output stage commonly used in?",
+        "opt1": "Low-distortion audio power amplifiers",
+        "opt2": "Low-power RF amplifiers",
+        "opt3": "High-distortion audio power amplifiers",
+        "opt4": "High-power RF amplifiers",
+        "correct_option": "High-power RF amplifiers",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the output signal of a Class B output stage?",
+        "opt1": "A combination of the input signal and the bias current",
+        "opt2": "A combination of two signals produced by each device",
+        "opt3": "A constant voltage signal",
+        "opt4": "A high distortion signal",
+        "correct_option": "A combination of two signals produced by each device",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of amplifiers produce less distortion than Class B amplifiers?",
+        "opt1": "Class A amplifiers",
+        "opt2": "Class AB amplifiers",
+        "opt3": "Class C amplifiers",
+        "opt4": "Class D amplifiers",
+        "correct_option": "Class AB amplifiers",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the function of the load resistor in a Class B output stage?",
+        "opt1": "To provide a bias current to the amplifying devices",
+        "opt2": "To reduce the power consumption of the amplifying devices",
+        "opt3": "To eliminate the crossover distortion",
+        "opt4": "To increase the gain of the amplifier",
+        "correct_option": "To eliminate the crossover distortion",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of distortion is commonly associated with Class B output stages?",
+        "opt1": "Harmonic distortion",
+        "opt2": "Frequency distortion",
+        "opt3": "Amplitude distortion",
+        "opt4": "Crossover distortion",
+        "correct_option": "Crossover distortion",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a limitation of using Class B amplifiers?",
+        "opt1": "High power efficiency",
+        "opt2": "Low distortion",
+        "opt3": "High linearity",
+        "opt4": "High power consumption",
+        "correct_option": "Low distortion",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the main advantage of a Class AB output stage over a Class B output stage?",
+        "opt1": "Higher power efficiency",
+        "opt2": "Lower distortion",
+        "opt3": "High distortion",
+        "opt4": "None of the above",
+        "correct_option": "Lower distortion",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of biasing both amplifying devices in a Class AB output stage?",
+        "opt1": "To eliminate crossover distortion",
+        "opt2": "To improve power efficiency",
+        "opt3": "To increase linearity",
+        "opt4": "None of the above",
+        "correct_option": "To eliminate crossover distortion",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is not a characteristic of Class AB output stages?",
+        "opt1": "High linearity",
+        "opt2": "High power efficiency",
+        "opt3": "Low distortion",
+        "opt4": "High bias",
+        "correct_option": "High bias",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "In which application are Class AB output stages commonly used?",
+        "opt1": "Low-power audio amplifiers",
+        "opt2": "High-fidelity audio amplifiers",
+        "opt3": "Power supplies",
+        "opt4": "None of the above",
+        "correct_option": "High-fidelity audio amplifiers",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of output stage offers the highest linearity?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "None of the above",
+        "correct_option": "Class A",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the disadvantage of Class AB output stages compared to Class B output stages?",
+        "opt1": "Lower power efficiency",
+        "opt2": "Higher distortion",
+        "opt3": "More complex design",
+        "opt4": "None of the above",
+        "correct_option": "Lower power efficiency",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is not a benefit of using a Class AB output stage?",
+        "opt1": "High power output",
+        "opt2": "Low distortion",
+        "opt3": "High power efficiency",
+        "opt4": "None of the above",
+        "correct_option": "None of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which type of output stage produces lower distortion than Class B output stages?",
+        "opt1": "Class A",
+        "opt2": "Class AB",
+        "opt3": "Class C",
+        "opt4": "Both A and B",
+        "correct_option": "Both A and B",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the key advantage of using a Class AB output stage?",
+        "opt1": "High power efficiency",
+        "opt2": "Low distortion",
+        "opt3": "High power efficiency and low distortion",
+        "opt4": "Low power efficiency and high distortion",
+        "correct_option": "High power efficiency and low distortion",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the main disadvantage of Class A output stages compared to Class AB output stages?",
+        "opt1": "Lower linearity",
+        "opt2": "Lower power efficiency",
+        "opt3": "Higher distortion",
+        "opt4": "None of the above",
+        "correct_option": "Lower power efficiency",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following statements is true about a Class AB output stage?",
+        "opt1": "It has high power efficiency and high distortion.",
+        "opt2": "It has low power efficiency and low distortion.",
+        "opt3": "It has high power efficiency and low distortion.",
+        "opt4": "It has low power efficiency and high distortion.",
+        "correct_option": "It has high power efficiency and low distortion.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of output stage is commonly used in power supplies?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "None of the above",
+        "correct_option": "Class B",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the main advantage of using a Class AB output stage in an audio amplifier?",
+        "opt1": "High distortion",
+        "opt2": "Low efficiency",
+        "opt3": "High efficiency and low distortion",
+        "opt4": "Low efficiency and high distortion",
+        "correct_option": "High efficiency and low distortion",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "In a Class AB output stage, both amplifying devices are biased to conduct a small amount of current even when there is no input signal. What is the purpose of this bias current?",
+        "opt1": "To increase distortion",
+        "opt2": "To reduce power efficiency",
+        "opt3": "To maintain high power efficiency",
+        "opt4": "To decrease linearity",
+        "correct_option": "To reduce power efficiency",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of output stage is commonly used in high-fidelity audio amplifiers?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class AB",
+        "opt4": "Class C",
+        "correct_option": "Class AB",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the process of gradual conduction transfer in a Class AB output stage known as?",
+        "opt1": "Crossover",
+        "opt2": "Biasing",
+        "opt3": "Amplification",
+        "opt4": "Distortion",
+        "correct_option": "Crossover",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of using a Class AB output stage?",
+        "opt1": "High distortion",
+        "opt2": "Low power efficiency",
+        "opt3": "Low linearity",
+        "opt4": "High cost",
+        "correct_option": "Low power efficiency",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a Class AB output stage, how do the amplifying devices behave when there is an input signal?",
+        "opt1": "They both conduct fully.",
+        "opt2": "One conducts fully and the other conducts partially.",
+        "opt3": "They both conduct partially.",
+        "opt4": "One conducts partially and the other is turned off.",
+        "correct_option": "One conducts fully and the other conducts partially.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the main purpose of a Class AB output stage?",
+        "opt1": "To reduce distortion",
+        "opt2": "To increase power efficiency",
+        "opt3": "To increase distortion",
+        "opt4": "To reduce power efficiency",
+        "correct_option": "To reduce distortion",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of biasing the Class AB output stage in amplifiers?",
+        "opt1": "To set the operating point of the amplifying devices",
+        "opt2": "To reduce distortion in the output signal",
+        "opt3": "To ensure that the amplifying devices operate in the active region of their characteristic curves",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is a common biasing technique for the Class AB output stage?",
+        "opt1": "Voltage divider network",
+        "opt2": "Diode biasing",
+        "opt3": "Transistor biasing",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "In a voltage divider biasing network, where is the bias voltage set?",
+        "opt1": "At the base or gate of the amplifying device",
+        "opt2": "At the power supply voltage",
+        "opt3": "At ground",
+        "opt4": "None of the above",
+        "correct_option": "At the base or gate of the amplifying device",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How does a diode biasing circuit work?",
+        "opt1": "By using a transistor configured as a voltage divider",
+        "opt2": "By connecting a diode in series with the base or gate of the amplifying device",
+        "opt3": "By using a voltage divider network",
+        "opt4": "None of the above",
+        "correct_option": "By connecting a diode in series with the base or gate of the amplifying device",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which biasing technique allows for fine-tuning of the operating point?",
+        "opt1": "Voltage divider network",
+        "opt2": "Diode biasing",
+        "opt3": "Transistor biasing",
+        "opt4": "None of the above",
+        "correct_option": "Voltage divider network",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the goal of biasing the Class AB stage?",
+        "opt1": "To maximize power efficiency",
+        "opt2": "To minimize power dissipation",
+        "opt3": "To ensure linear operation with low distortion",
+        "opt4": "None of the above",
+        "correct_option": "To ensure linear operation with low distortion",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of amplifying device is typically used in a Class AB output stage?",
+        "opt1": "Bipolar junction transistor (BJT)",
+        "opt2": "Field-effect transistor (FET)",
+        "opt3": "Operational amplifier (Op-amp)",
+        "opt4": "None of the above",
+        "correct_option": "Bipolar junction transistor (BJT)",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which biasing technique uses a transistor configured as a voltage divider?",
+        "opt1": "Voltage divider network",
+        "opt2": "Diode biasing",
+        "opt3": "Transistor biasing",
+        "opt4": "None of the above",
+        "correct_option": "Transistor biasing",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Why is biasing necessary for Class AB amplifiers?",
+        "opt1": "To prevent the amplifying devices from saturating",
+        "opt2": "To ensure that the amplifying devices operate in the active region",
+        "opt3": "To decrease the gain of the amplifier",
+        "opt4": "None of the above",
+        "correct_option": "To ensure that the amplifying devices operate in the active region",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the main advantage of using a Class AB output stage in amplifiers?",
+        "opt1": "High power efficiency",
+        "opt2": "Low power dissipation",
+        "opt3": "High linearity with low distortion",
+        "opt4": "None of the above",
+        "correct_option": "High linearity with low distortion",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the bias voltage typically set to in the Class AB output stage?",
+        "opt1": "The forward voltage drop of a diode",
+        "opt2": "The power supply voltage",
+        "opt3": "Zero volts",
+        "opt4": "The voltage across a capacitor",
+        "correct_option": "The forward voltage drop of a diode",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of using a diode biasing circuit?",
+        "opt1": "It is more complex than other biasing techniques",
+        "opt2": "It is less stable than other biasing techniques",
+        "opt3": "It requires more power to operate",
+        "opt4": "It is less accurate than other biasing techniques",
+        "correct_option": "It is less stable than other biasing techniques",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of using a transistor biasing circuit?",
+        "opt1": "To set the bias voltage",
+        "opt2": "To amplify the input signal",
+        "opt3": "To reduce distortion in the output signal",
+        "opt4": "To increase power efficiency",
+        "correct_option": "To set the bias voltage",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following biasing techniques is commonly used in Class AB amplifiers?",
+        "opt1": "Voltage divider network",
+        "opt2": "Diode biasing",
+        "opt3": "Transistor biasing",
+        "opt4": "All of the above",
+        "correct_option": "Diode biasing",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How does the choice of biasing technique affect the power efficiency of the amplifier?",
+        "opt1": "It has no effect on power efficiency",
+        "opt2": "It can increase power efficiency",
+        "opt3": "It can decrease power efficiency",
+        "opt4": "It can cause the amplifier to malfunction",
+        "correct_option": "It can decrease power efficiency",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the disadvantage of using an adjustable biasing network?",
+        "opt1": "It is less accurate than a fixed biasing network",
+        "opt2": "It is less stable than a fixed biasing network",
+        "opt3": "It is more complex than a fixed biasing network",
+        "opt4": "It is more expensive than a fixed biasing network",
+        "correct_option": "It is more complex than a fixed biasing network",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a key consideration when selecting a biasing technique for the Class AB output stage?",
+        "opt1": "Power efficiency",
+        "opt2": "Cost",
+        "opt3": "Stability",
+        "opt4": "Input impedance",
+        "correct_option": "Power efficiency",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the primary application of power BJTs in amplifier circuits?",
+        "opt1": "High frequency amplification",
+        "opt2": "Low noise amplification",
+        "opt3": "Power amplification",
+        "opt4": "Voltage amplification",
+        "correct_option": "Power amplification",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of power BJT is more commonly used in power amplifier circuits?",
+        "opt1": "PNP",
+        "opt2": "NPN",
+        "opt3": "Both are used equally",
+        "opt4": "None of the above",
+        "correct_option": "NPN",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the operating region of the power BJT?",
+        "opt1": "Saturation",
+        "opt2": "Cutoff",
+        "opt3": "Active",
+        "opt4": "Reverse breakdown",
+        "correct_option": "Active",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which configuration is most commonly used for low-power amplifiers?",
+        "opt1": "Class A",
+        "opt2": "Class AB",
+        "opt3": "Class B",
+        "opt4": "Class C",
+        "correct_option": "Class A",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the main advantage of power BJTs over small signal BJTs?",
+        "opt1": "Higher frequency response",
+        "opt2": "Lower noise",
+        "opt3": "Higher power handling capability",
+        "opt4": "Lower distortion",
+        "correct_option": "Higher power handling capability",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a common application of power BJTs?",
+        "opt1": "Voltage regulators",
+        "opt2": "Oscillators",
+        "opt3": "Audio amplifiers",
+        "opt4": "Digital circuits",
+        "correct_option": "Audio amplifiers",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the primary purpose of switching amplifiers?",
+        "opt1": "To increase power gain",
+        "opt2": "To reduce distortion",
+        "opt3": "To improve efficiency",
+        "opt4": "To increase frequency response",
+        "correct_option": "To improve efficiency",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of amplifier uses power MOSFETs to provide high efficiency?",
+        "opt1": "Class A",
+        "opt2": "Class B",
+        "opt3": "Class D",
+        "opt4": "Class AB",
+        "correct_option": "Class D",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is not a technique used to improve the efficiency of power amplifiers?",
+        "opt1": "Class G and H amplifiers",
+        "opt2": "Switching amplifiers",
+        "opt3": "Feedback amplifiers",
+        "opt4": "Class D amplifiers",
+        "correct_option": "Feedback amplifiers",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the main disadvantage of power BJTs in amplifier circuits?",
+        "opt1": "High distortion",
+        "opt2": "Low power handling capability",
+        "opt3": "Low frequency response",
+        "opt4": "High heat dissipation",
+        "correct_option": "High heat dissipation",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the primary function of power BJTs in amplifier circuits?",
+        "opt1": "To provide high voltage gain",
+        "opt2": "To provide low noise amplification",
+        "opt3": "To provide high power gain and efficiency",
+        "opt4": "To provide high frequency response",
+        "correct_option": "To provide high power gain and efficiency",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a commonly used configuration for power BJTs in low-power amplifiers?",
+        "opt1": "Class A",
+        "opt2": "Class AB",
+        "opt3": "Class B",
+        "opt4": "Class C",
+        "correct_option": "Class A",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which type of power BJT is commonly used in power amplifier circuits?",
+        "opt1": "PNP",
+        "opt2": "NPN",
+        "opt3": "JFET",
+        "opt4": "MOSFET",
+        "correct_option": "NPN",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In which region of operation does the power BJT operate?",
+        "opt1": "Saturation region",
+        "opt2": "Cutoff region",
+        "opt3": "Active region",
+        "opt4": "Reverse-bias region",
+        "correct_option": "Active region",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a technique used to improve the efficiency of power amplifiers?",
+        "opt1": "Class A amplification",
+        "opt2": "Switching amplifiers",
+        "opt3": "Class AB amplification",
+        "opt4": "Linear amplifiers",
+        "correct_option": "Switching amplifiers",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is an application of power BJTs?",
+        "opt1": "Audio amplifiers",
+        "opt2": "Radio receivers",
+        "opt3": "Logic gates",
+        "opt4": "Voltage regulators",
+        "correct_option": "Audio amplifiers",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the primary difference between small signal BJTs and power BJTs?",
+        "opt1": "Current gain",
+        "opt2": "Voltage gain",
+        "opt3": "Frequency response",
+        "opt4": "High power handling capability",
+        "correct_option": "High power handling capability",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which type of power BJT has a higher current gain?",
+        "opt1": "PNP",
+        "opt2": "NPN",
+        "opt3": "JFET",
+        "opt4": "MOSFET",
+        "correct_option": "NPN",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is a benefit of using power BJTs in amplifier circuits?",
+        "opt1": "High frequency response",
+        "opt2": "Low power consumption",
+        "opt3": "Low distortion",
+        "opt4": "High power gain",
+        "correct_option": "High power gain",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following amplifier configurations is commonly used in high-power amplifiers?",
+        "opt1": "Class A",
+        "opt2": "Class AB",
+        "opt3": "Class B",
+        "opt4": "Class D",
+        "correct_option": "Class D",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "In a transformer-coupled push-pull amplifier, the primary winding of the output transformer is connected to:",
+        "opt1": "The input signal",
+        "opt2": "The collector of the NPN transistor in the driver stage",
+        "opt3": "The base of the NPN transistor in the driver stage",
+        "opt4": "The collector of both transistors",
+        "correct_option": "The collector of both transistors",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "The transformer in a transformer-coupled push-pull amplifier is used to:",
+        "opt1": "Provide impedance matching between the driver and output stages",
+        "opt2": "Amplify the signal",
+        "opt3": "Provide voltage gain",
+        "opt4": "Provide current gain",
+        "correct_option": "Provide impedance matching between the driver and output stages",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In a transformer-coupled push-pull amplifier, the two output transistors are biased so that they conduct:",
+        "opt1": "Simultaneously",
+        "opt2": "Randomly",
+        "opt3": "Alternately",
+        "opt4": "None of the above",
+        "correct_option": "Alternately",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is an advantage of a transformer-coupled push-pull amplifier?",
+        "opt1": "High efficiency",
+        "opt2": "Low distortion",
+        "opt3": "High gain",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "The output of a transformer-coupled push-pull amplifier is taken from:",
+        "opt1": "The primary winding of the output transformer",
+        "opt2": "The secondary winding of the output transformer",
+        "opt3": "The center tap of the output transformer",
+        "opt4": "None of the above",
+        "correct_option": "The secondary winding of the output transformer",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "The load impedance in a transformer-coupled push-pull amplifier is:",
+        "opt1": "Always equal to the output impedance of the amplifier",
+        "opt2": "Always lower than the output impedance of the amplifier",
+        "opt3": "Always higher than the output impedance of the amplifier",
+        "opt4": "None of the above",
+        "correct_option": "Always equal to the output impedance of the amplifier",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "The DC bias voltage for the output transistors in a transformer-coupled push-pull amplifier is provided by:",
+        "opt1": "The input signal",
+        "opt2": "The driver stage",
+        "opt3": "A separate bias circuit",
+        "opt4": "None of the above",
+        "correct_option": "A separate bias circuit",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "The crossover distortion in a transformer-coupled push-pull amplifier is caused by:",
+        "opt1": "The mismatch between the two output transistors",
+        "opt2": "The bias voltage being too high",
+        "opt3": "The load impedance being too low",
+        "opt4": "None of the above",
+        "correct_option": "The mismatch between the two output transistors",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "The transformer in a transformer-coupled push-pull amplifier is usually:",
+        "opt1": "A step-up transformer",
+        "opt2": "A step-down transformer",
+        "opt3": "A transformer with a 1:1 turns ratio",
+        "opt4": "None of the above",
+        "correct_option": "A step-down transformer",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a transformer-coupled push-pull amplifier, the output transistors are typically:",
+        "opt1": "Darlington transistors",
+        "opt2": "Complementary pair transistors",
+        "opt3": "MOSFETs",
+        "opt4": "None of the above",
+        "correct_option": "None of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "In a transformer-coupled push-pull stage, two identical transistors are used with one conducting during the positive half-cycle of the input signal and the other conducting during the negative half-cycle. What is the main advantage of using two transistors in this configuration?",
+        "opt1": "Increased efficiency",
+        "opt2": "Increased voltage gain",
+        "opt3": "Reduced distortion",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following statements about the transformer-coupled push-pull stage is true?",
+        "opt1": "It is commonly used in audio power amplifiers",
+        "opt2": "It is a type of class A amplifier",
+        "opt3": "It requires a large amount of power for operation",
+        "opt4": "It has a low voltage gain",
+        "correct_option": "It is commonly used in audio power amplifiers",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "The transformer in a transformer-coupled push-pull stage is used to:",
+        "opt1": "Increase the voltage gain of the amplifier",
+        "opt2": "Couple the output signal to the load",
+        "opt3": "Provide impedance matching between the amplifier and the load",
+        "opt4": "All of the above",
+        "correct_option": "Provide impedance matching between the amplifier and the load",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "In a transformer-coupled push-pull stage, the transformer is typically wound with a center-tapped secondary winding. What is the purpose of the center tap?",
+        "opt1": "To provide a reference voltage for biasing the transistors",
+        "opt2": "To provide a means for adjusting the gain of the amplifier",
+        "opt3": "To provide a balanced load for the transistors",
+        "opt4": "None of the above",
+        "correct_option": "To provide a reference voltage for biasing the transistors",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "The transformer-coupled push-pull stage is a type of:",
+        "opt1": "Class A amplifier",
+        "opt2": "Class B amplifier",
+        "opt3": "Class AB amplifier",
+        "opt4": "None of the above",
+        "correct_option": "Class B amplifier",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is an advantage of using a transformer-coupled push-pull stage over a single-ended output stage?",
+        "opt1": "Higher efficiency",
+        "opt2": "Higher voltage gain",
+        "opt3": "Reduced distortion",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "The output of a transformer-coupled push-pull stage is taken from:",
+        "opt1": "The collector of one transistor",
+        "opt2": "The center tap of the transformer secondary winding",
+        "opt3": "The collector of both transistors",
+        "opt4": "The primary winding of the transformer",
+        "correct_option": "The center tap of the transformer secondary winding",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the main disadvantage of a transformer-coupled push-pull stage compared to other output stage configurations?",
+        "opt1": "Reduced efficiency",
+        "opt2": "Increased distortion",
+        "opt3": "Limited frequency response",
+        "opt4": "All of the above",
+        "correct_option": "Limited frequency response",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "The transformer in a transformer-coupled push-pull stage should be designed with:",
+        "opt1": "High primary-to-secondary turns ratio",
+        "opt2": "Low primary-to-secondary turns ratio",
+        "opt3": "High frequency response",
+        "opt4": "Low leakage inductance",
+        "correct_option": "Low leakage inductance",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the main advantage of using a transformer in a push-pull output stage?",
+        "opt1": "Increased voltage gain",
+        "opt2": "Impedance matching to the load",
+        "opt3": "Reduced distortion",
+        "opt4": "Increased efficiency",
+        "correct_option": "Impedance matching to the load",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the basic function of a tuned amplifier?",
+        "opt1": "To provide high power amplification",
+        "opt2": "To provide high selectivity and gain",
+        "opt3": "To filter out unwanted signals",
+        "opt4": "To provide high frequency stability",
+        "correct_option": "To provide high selectivity and gain",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of resonant circuit is typically used in tuned amplifiers?",
+        "opt1": "RC circuits",
+        "opt2": "RL circuits",
+        "opt3": "LC circuits",
+        "opt4": "RLC circuits",
+        "correct_option": "LC circuits",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the Q factor of a resonant circuit?",
+        "opt1": "The frequency at which the circuit resonates",
+        "opt2": "The voltage gain of the circuit",
+        "opt3": "The energy stored in the circuit",
+        "opt4": "The ratio of energy stored in the circuit to energy lost per cycle",
+        "correct_option": "The ratio of energy stored in the circuit to energy lost per cycle",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the difference between a single tuned amplifier and a double tuned amplifier?",
+        "opt1": "A single tuned amplifier is more selective than a double tuned amplifier.",
+        "opt2": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two.",
+        "opt3": "A double tuned amplifier provides more gain than a single tuned amplifier.",
+        "opt4": "A double tuned amplifier uses a transformer to couple the resonant circuits.",
+        "correct_option": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of amplifier is commonly used in radio receivers and transmitters?",
+        "opt1": "Class A amplifier",
+        "opt2": "Class B amplifier",
+        "opt3": "Class AB amplifier",
+        "opt4": "Tuned amplifier",
+        "correct_option": "Tuned amplifier",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which electronic device can be used as the active element in a tuned amplifier?",
+        "opt1": "Capacitor",
+        "opt2": "Resistor",
+        "opt3": "Inductor",
+        "opt4": "Transistor",
+        "correct_option": "Transistor",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the function of the Q multiplier in a tuned amplifier?",
+        "opt1": "To provide additional gain at the center frequency of the circuit",
+        "opt2": "To increase the bandwidth of the circuit",
+        "opt3": "To improve the stability of the circuit",
+        "opt4": "To reduce distortion in the output signal",
+        "correct_option": "To provide additional gain at the center frequency of the circuit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a tuned amplifier?",
+        "opt1": "An amplifier with no selectivity or gain",
+        "opt2": "An amplifier that only works with specific types of signals",
+        "opt3": "An amplifier that uses tuned circuits to achieve high selectivity and gain",
+        "opt4": "An amplifier that is not commonly used in electronic applications",
+        "correct_option": "An amplifier that uses tuned circuits to achieve high selectivity and gain",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What type of resonant circuits are used in tuned amplifiers?",
+        "opt1": "RC circuits",
+        "opt2": "LC circuits",
+        "opt3": "RL circuits",
+        "opt4": "RLC circuits",
+        "correct_option": "LC circuits",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is a key factor in determining the gain and selectivity of a tuned amplifier?",
+        "opt1": "The type of amplifier used",
+        "opt2": "The power supply voltage",
+        "opt3": "The Q factor of the resonant circuits",
+        "opt4": "The input signal frequency",
+        "correct_option": "The Q factor of the resonant circuits",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Where are tuned amplifiers commonly used?",
+        "opt1": "In power supplies",
+        "opt2": "In digital circuits",
+        "opt3": "In radio receivers and transmitters",
+        "opt4": "In microcontrollers",
+        "correct_option": "In radio receivers and transmitters",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which type of amplifying device can be used in tuned amplifiers?",
+        "opt1": "BJTs",
+        "opt2": "MOSFETs",
+        "opt3": "Vacuum tubes",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the purpose of a tuned amplifier in a radio receiver?",
+        "opt1": "To amplify all incoming signals equally",
+        "opt2": "To amplify only the desired signal while rejecting other signals",
+        "opt3": "To reduce the strength of the incoming signal",
+        "opt4": "To generate a new signal at a different frequency",
+        "correct_option": "To amplify only the desired signal while rejecting other signals",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the main advantage of a double tuned amplifier over a single tuned amplifier?",
+        "opt1": "Higher efficiency",
+        "opt2": "Higher gain",
+        "opt3": "Higher selectivity",
+        "opt4": "Lower distortion",
+        "correct_option": "Higher selectivity",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of tuned amplifiers?",
+        "opt1": "They are expensive to produce.",
+        "opt2": "They are large in size.",
+        "opt3": "They can be difficult to tune and adjust.",
+        "opt4": "They are not capable of providing high gain.",
+        "correct_option": "They can be difficult to tune and adjust.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What does op-amp stand for?",
+        "opt1": "Operational amplifier",
+        "opt2": "Optimal amplifier",
+        "opt3": "Organic amplifier",
+        "opt4": "Oscillating amplifier",
+        "correct_option": "Operational amplifier",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which configuration is most commonly used in op-amp circuits?",
+        "opt1": "Inverting amplifier",
+        "opt2": "Non-inverting amplifier",
+        "opt3": "Differential amplifier",
+        "opt4": "Voltage follower",
+        "correct_option": "Inverting amplifier",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the gain of an inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
+        "opt1": "-1",
+        "opt2": "-10",
+        "opt3": "10",
+        "opt4": "100",
+        "correct_option": "-10",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which parameter determines the maximum output voltage swing of an op-amp?",
+        "opt1": "Input offset voltage",
+        "opt2": "Gain-bandwidth product",
+        "opt3": "Slew rate",
+        "opt4": "Output saturation voltage",
+        "correct_option": "Output saturation voltage",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the purpose of a voltage follower op-amp circuit?",
+        "opt1": "To provide high gain",
+        "opt2": "To provide low gain",
+        "opt3": "To buffer a signal",
+        "opt4": "To invert a signal",
+        "correct_option": "To buffer a signal",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the transfer function of a non-inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
+        "opt1": "Vout = Vin",
+        "opt2": "Vout = -10Vin",
+        "opt3": "Vout = 10Vin",
+        "opt4": "Vout = (1 + 10kΩ/1kΩ)Vin",
+        "correct_option": "Vout = (1 + 10kΩ/1kΩ)Vin",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which op-amp parameter determines the rate at which the output can change in response to changes in the input?",
+        "opt1": "Input offset voltage",
+        "opt2": "Gain-bandwidth product",
+        "opt3": "Slew rate",
+        "opt4": "Input bias current",
+        "correct_option": "Slew rate",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of a differential amplifier?",
+        "opt1": "To amplify the difference between two input signals",
+        "opt2": "To amplify the sum of two input signals",
+        "opt3": "To invert a signal",
+        "opt4": "To provide a high-impedance input",
+        "correct_option": "To amplify the difference between two input signals",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which op-amp configuration is used to perform mathematical operations, such as addition and subtraction?",
+        "opt1": "Inverting amplifier",
+        "opt2": "Non-inverting amplifier",
+        "opt3": "Summing amplifier",
+        "opt4": "Differentiator",
+        "correct_option": "Summing amplifier",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the output voltage of an inverting amplifier with an input voltage of 2 V and a feedback resistor of 10 kΩ, assuming an ideal op-amp?",
+        "opt1": "-2V",
+        "opt2": "-20 V",
+        "opt3": "2V",
+        "opt4": "20 V",
+        "correct_option": "-20 V",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is a characteristic of an ideal operational amplifier?",
+        "opt1": "Infinite input impedance",
+        "opt2": "Infinite output impedance",
+        "opt3": "Infinite gain",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is not a type of operational amplifier?",
+        "opt1": "Differential amplifier",
+        "opt2": "Inverting amplifier",
+        "opt3": "Non-inverting amplifier",
+        "opt4": "Power amplifier",
+        "correct_option": "Power amplifier",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the function of a summing amplifier?",
+        "opt1": "To amplify a single input signal",
+        "opt2": "To sum multiple input signals and provide an amplified output signal",
+        "opt3": "To provide an inverted output signal",
+        "opt4": "To provide a non-inverted output signal",
+        "correct_option": "To sum multiple input signals and provide an amplified output signal",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the output voltage of an inverting amplifier with a gain of -10 if the input voltage is 2V?",
+        "opt1": "-10V",
+        "opt2": "-20V",
+        "opt3": "10V",
+        "opt4": "20V",
+        "correct_option": "-20V",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the function of a voltage follower?",
+        "opt1": "To amplify a voltage",
+        "opt2": "To provide a high input impedance",
+        "opt3": "To provide a low output impedance",
+        "opt4": "To provide unity gain and high input and output impedances",
+        "correct_option": "To provide unity gain and high input and output impedances",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the advantage of using an op-amp as a comparator?",
+        "opt1": "It has a very high input impedance",
+        "opt2": "It has a very low output impedance",
+        "opt3": "It has a very high gain",
+        "opt4": "It has a very low bandwidth",
+        "correct_option": "It has a very high gain",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the function of a differentiator circuit?",
+        "opt1": "To differentiate the input signal with respect to time",
+        "opt2": "To integrate the input signal with respect to time",
+        "opt3": "To amplify the input signal",
+        "opt4": "To provide a DC offset to the input signal",
+        "correct_option": "To differentiate the input signal with respect to time",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the function of an integrator circuit?",
+        "opt1": "To differentiate the input signal with respect to time",
+        "opt2": "To integrate the input signal with respect to time",
+        "opt3": "To amplify the input signal",
+        "opt4": "To provide a DC offset to the input signal",
+        "correct_option": "To integrate the input signal with respect to time",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the advantage of using a non-inverting amplifier instead of an inverting amplifier?",
+        "opt1": "The input signal is not inverted",
+        "opt2": "The output impedance is lower",
+        "opt3": "The gain is higher",
+        "opt4": "The bandwidth is wider",
+        "correct_option": "The input signal is not inverted",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the function of a Schmitt trigger circuit?",
+        "opt1": "To amplify a signal",
+        "opt2": "To filter a signal",
+        "opt3": "To generate a square wave signal from a triangular wave signal",
+        "opt4": "To provide hysteresis to a signal",
+        "correct_option": "To provide hysteresis to a signal",
+        "correct_option_index": 4
+    }
+]
diff --git a/frontend/public/data/books/ch10.json b/frontend/public/data/books/ch10.json
index d902eed..df9e4ae 100644
--- a/frontend/public/data/books/ch10.json
+++ b/frontend/public/data/books/ch10.json
@@ -1538,15 +1538,6 @@
     "correct_option": "one",
     "correct_option_index": 2
   },
-  {
-    "qsns": "Sinking fund is",
-    "opt1": "The fund for rebuilding a structure when its economic life is over",
-    "opt2": "Raised to meet maintenance costs",
-    "opt3": "The total sum to be paid to the municipal authorities by the tenants",
-    "opt4": "A part of the money kept in reserve for providing additional structures and structural modifications",
-    "correct_option": "The fund for rebuilding a structure when its economic life is over",
-    "correct_option_index": 1
-  },
   {
     "qsns": "The rules of Ethics are also called as a",
     "opt1": "Rules",
@@ -1583,15 +1574,6 @@
     "correct_option": "Evaluation of policy alternatives",
     "correct_option_index": 4
   },
-  {
-    "qsns": "Resource smoothing is",
-    "opt1": "An optimization and economical utilization of resources",
-    "opt2": "An adjustment of resources without affecting project duration",
-    "opt3": "A gradual increase in resources",
-    "opt4": "A gradual decrease in resources",
-    "correct_option": "An adjustment of resources without affecting project duration",
-    "correct_option_index": 2
-  },
   {
     "qsns": "The estimated time Te can be found if To. Tp and Tm are given in PERT activity as",
     "opt1": "Te=(To+Tp+2 Tm)/6",
@@ -2177,4 +2159,4 @@
     "correct_option": "same rate",
     "correct_option_index": 1
   }
-]
\ No newline at end of file
+]
diff --git a/frontend/public/data/books/ch2.json b/frontend/public/data/books/ch2.json
index 4ecdbc1..58a0cd9 100644
--- a/frontend/public/data/books/ch2.json
+++ b/frontend/public/data/books/ch2.json
@@ -1,6716 +1,2990 @@
 [
-    {
-        "qsns": "What is the base of the decimal number system?",
-        "opt1": "2",
-        "opt2": "8",
-        "opt3": "10",
-        "opt4": "16",
-        "correct_option": "10",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "How many digits are used in the binary number system?",
-        "opt1": "8",
-        "opt2": "10",
-        "opt3": "2",
-        "opt4": "16",
-        "correct_option": "2",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which number system is often used in computer programming to represent sets of 3 bits?",
-        "opt1": "Decimal",
-        "opt2": "Binary",
-        "opt3": "Octal",
-        "opt4": "Hexadecimal",
-        "correct_option": "Octal",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the base of the hexadecimal number system?",
-        "opt1": "2",
-        "opt2": "8",
-        "opt3": "10",
-        "opt4": "16",
-        "correct_option": "16",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the decimal equivalent of the binary number 1011?",
-        "opt1": "3",
-        "opt2": "7",
-        "opt3": "11",
-        "opt4": "13",
-        "correct_option": "11",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which number system is easy to represent using electronic devices like switches?",
-        "opt1": "Decimal",
-        "opt2": "Binary",
-        "opt3": "Octal",
-        "opt4": "Hexadecimal",
-        "correct_option": "Binary",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the octal equivalent of the decimal number 11?",
-        "opt1": "3",
-        "opt2": "7",
-        "opt3": "5",
-        "opt4": "13",
-        "correct_option": "13",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which number system is often used in computer science to represent memory addresses?",
-        "opt1": "Decimal",
-        "opt2": "Binary",
-        "opt3": "Octal",
-        "opt4": "Hexadecimal",
-        "correct_option": "Hexadecimal",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the binary equivalent of the decimal number 23?",
-        "opt1": "10111",
-        "opt2": "11011",
-        "opt3": "11101",
-        "opt4": "11110",
-        "correct_option": "10111",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the decimal equivalent of the hexadecimal number 2F?",
-        "opt1": "32",
-        "opt2": "45",
-        "opt3": "47",
-        "opt4": "52",
-        "correct_option": "47",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which number system has a base of 8?",
-        "opt1": "Decimal",
-        "opt2": "Binary",
-        "opt3": "Octal",
-        "opt4": "Hexadecimal",
-        "correct_option": "Octal",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the binary equivalent of the decimal number 17?",
-        "opt1": "10000",
-        "opt2": "10010",
-        "opt3": "10001",
-        "opt4": "10011",
-        "correct_option": "10001",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the hexadecimal equivalent of the binary number 1101?",
-        "opt1": "D",
-        "opt2": "E",
-        "opt3": "F",
-        "opt4": "10",
-        "correct_option": "D",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the base of the binary number system?",
-        "opt1": "2",
-        "opt2": "8",
-        "opt3": "10",
-        "opt4": "16",
-        "correct_option": "2",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the octal equivalent of the decimal number 27?",
-        "opt1": "33",
-        "opt2": "37",
-        "opt3": "43",
-        "opt4": "47",
-        "correct_option": "33",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the decimal equivalent of the hexadecimal number FF?",
-        "opt1": "255",
-        "opt2": "256",
-        "opt3": "257",
-        "opt4": "258",
-        "correct_option": "255",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the binary equivalent of the octal number 76?",
-        "opt1": "111011",
-        "opt2": "110110",
-        "opt3": "110111",
-        "opt4": "111000",
-        "correct_option": "111110",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which number system is used in digital electronics?",
-        "opt1": "Decimal",
-        "opt2": "Binary",
-        "opt3": "Octal",
-        "opt4": "Hexadecimal",
-        "correct_option": "Binary",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the hexadecimal equivalent of the binary number 101011?",
-        "opt1": "28",
-        "opt2": "20",
-        "opt3": "2F",
-        "opt4": "31",
-        "correct_option": "2B",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the decimal equivalent of the octal number 63?",
-        "opt1": "51",
-        "opt2": "53",
-        "opt3": "55",
-        "opt4": "57",
-        "correct_option": "51",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which logic family defines a voltage range of 0 V to 0.8 V for a logical 0 and 2 V to 5V for a logical 1?",
-        "opt1": "TTL",
-        "opt2": "CMOS",
-        "opt3": "ECL",
-        "opt4": "None of the above",
-        "correct_option": "TTL",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which logic family consumes less power than TTL?",
-        "opt1": "TTL",
-        "opt2": "CMOS",
-        "opt3": "ECL",
-        "opt4": "None of the above",
-        "correct_option": "CMOS",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the voltage range for a logical 0 in CMOS logic?",
-        "opt1": "0V to 0.5 V",
-        "opt2": "0V to 0.8 V",
-        "opt3": "0V to 1.5 V",
-        "opt4": "0V to 3.5 V",
-        "correct_option": "0V to 1.5 V",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the voltage range for a logical 1 in CMOS logic?",
-        "opt1": "0V to 1.5 V",
-        "opt2": "1.5 V to 3.5 V",
-        "opt3": "2V to 5V",
-        "opt4": "3.5 V to 5V",
-        "correct_option": "3.5 V to 5V",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which logic family is known for its high speed and low power consumption?",
-        "opt1": "TTL",
-        "opt2": "CMOS",
-        "opt3": "ECL",
-        "opt4": "None of the above",
-        "correct_option": "CMOS",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is true about logic levels?",
-        "opt1": "They determine the power consumption of a digital circuit.",
-        "opt2": "They determine the speed of a digital circuit.",
-        "opt3": "They determine how digital circuits interpret input signals.",
-        "opt4": "They determine the size of a digital circuit.",
-        "correct_option": "They determine how digital circuits interpret input signals.",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What happens if a signal voltage falls outside the specified range for a logical 0 or 1?",
-        "opt1": "The circuit will interpret it as a logical 0.",
-        "opt2": "The circuit will interpret it as a logical 1.",
-        "opt3": "The circuit may interpret it incorrectly, leading to errors or circuit failure.",
-        "opt4": "The circuit will ignore the signal.",
-        "correct_option": "The circuit may interpret it incorrectly, leading to errors or circuit failure.",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What are the two most common logic levels used in digital logic?",
-        "opt1": "Low and High",
-        "opt2": "0 and 1",
-        "opt3": "Negative and Positive",
-        "opt4": "True and False",
-        "correct_option": "0 and 1",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which logic level represents a logic 1 in a digital circuit?",
-        "opt1": "High",
-        "opt2": "Low",
-        "opt3": "Negative",
-        "opt4": "Positive",
-        "correct_option": "High",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is NOT a typical voltage range for a logic 0?",
-        "opt1": "0V to 0.8V",
-        "opt2": "0V to 1.0V",
-        "opt3": "0V to 1.5V",
-        "opt4": "0V to 2.0V",
-        "correct_option": "0V to 2.0V",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which logic level is represented by a voltage above the high threshold voltage and below the low threshold voltage?",
-        "opt1": "Positive",
-        "opt2": "Negative",
-        "opt3": "Indeterminate",
-        "opt4": "None of the above",
-        "correct_option": "Indeterminate",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following logic gates has a single input and an inverted output?",
-        "opt1": "NOT gate",
-        "opt2": "OR gate",
-        "opt3": "AND gate",
-        "opt4": "NAND gate",
-        "correct_option": "NOT gate",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following logic gates requires all inputs to be high in order to produce a high output?",
-        "opt1": "OR gate",
-        "opt2": "AND gate",
-        "opt3": "XOR gate",
-        "opt4": "NOR gate",
-        "correct_option": "AND gate",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following logic gates produces a high output only when all inputs are low?",
-        "opt1": "OR gate",
-        "opt2": "AND gate",
-        "opt3": "NOR gate",
-        "opt4": "XOR gate",
-        "correct_option": "NOR gate",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following logic gates has two or more inputs and produces a high output if any one input is high?",
-        "opt1": "NOR gate",
-        "opt2": "XOR gate",
-        "opt3": "AND gate",
-        "opt4": "OR gate",
-        "correct_option": "OR gate",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the output of an AND gate if one input is 1 and the other input is 0?",
-        "opt1": "0",
-        "opt2": "1",
-        "opt3": "Depends on the gate",
-        "opt4": "Cannot be determined",
-        "correct_option": "0",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the output of a NAND gate if one input is 1 and the other input is 0?",
-        "opt1": "0",
-        "opt2": "1",
-        "opt3": "Depends on the gate",
-        "opt4": "Cannot be determined",
-        "correct_option": "1",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following logic gates has an output that is the inverse of the input?",
-        "opt1": "NOT gate",
-        "opt2": "AND gate",
-        "opt3": "OR gate",
-        "opt4": "XOR gate",
-        "correct_option": "NOT gate",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following logic gates has an output that is the opposite of the OR gate?",
-        "opt1": "OR gate",
-        "opt2": "NAND gate",
-        "opt3": "NOR gate",
-        "opt4": "XOR gate",
-        "correct_option": "NOR gate",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following logic gates has two or more inputs and produces a high output only when all inputs are high?",
-        "opt1": "OR gate",
-        "opt2": "XOR gate",
-        "opt3": "AND gate",
-        "opt4": "NOR gate",
-        "correct_option": "AND gate",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the output of a XOR gate if both inputs are 1?",
-        "opt1": "0",
-        "opt2": "1",
-        "opt3": "Depends on the gate",
-        "opt4": "Cannot be determined",
-        "correct_option": "0",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which logic gate has the output opposite in logic level to its input?",
-        "opt1": "OR GATE",
-        "opt2": "AND gate",
-        "opt3": "NOT gate",
-        "opt4": "XOR gate",
-        "correct_option": "NOT gate",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which logic gate produces a high output only when all inputs are high?",
-        "opt1": "OR gate",
-        "opt2": "AND gate",
-        "opt3": "NOT gate",
-        "opt4": "XOR gate",
-        "correct_option": "AND gate",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which logic gate produces a high output when any input is high?",
-        "opt1": "OR gate",
-        "opt2": "AND gate",
-        "opt3": "NOT gate",
-        "opt4": "XOR gate",
-        "correct_option": "OR gate",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which logic gate produces a low output only when all inputs are low?",
-        "opt1": "OR gate",
-        "opt2": "AND gate",
-        "opt3": "NOT gate",
-        "opt4": "XOR gate",
-        "correct_option": "OR gate",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which logic gate produces a high output when the inputs are different?",
-        "opt1": "OR gate",
-        "opt2": "AND gate",
-        "opt3": "NOT gate",
-        "opt4": "XOR gate",
-        "correct_option": "XOR gate",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is NOT a basic operation in Boolean algebra?",
-        "opt1": "AND",
-        "opt2": "OR",
-        "opt3": "NOT",
-        "opt4": "XOR",
-        "correct_option": "XOR",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the Boolean expression for the NAND gate?",
-        "opt1": "A + B",
-        "opt2": "AB",
-        "opt3": "A' + B'",
-        "opt4": "A'B'",
-        "correct_option": "A' + B'",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following Boolean identities is NOT true?",
-        "opt1": "A + 0 = A",
-        "opt2": "A + A' = 1",
-        "opt3": "A + B = B + A",
-        "opt4": "A + A = A",
-        "correct_option": "A + A = A",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the Boolean expression for the NOR gate?",
-        "opt1": "A + B",
-        "opt2": "AB",
-        "opt3": "A' + B'",
-        "opt4": "A'B'",
-        "correct_option": "A'B'",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the complement of the Boolean expression A'B + AB'?",
-        "opt1": "A' + B'",
-        "opt2": "A + B",
-        "opt3": "A'B",
-        "opt4": "AB",
-        "correct_option": "A + B",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which Boolean operator has the highest precedence?",
-        "opt1": "NOT",
-        "opt2": "AND",
-        "opt3": "OR",
-        "opt4": "XOR",
-        "correct_option": "NOT",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which Boolean operator has the lowest precedence?",
-        "opt1": "NOT",
-        "opt2": "AND",
-        "opt3": "OR",
-        "opt4": "XOR",
-        "correct_option": "OR",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a Boolean operator?",
-        "opt1": "+",
-        "opt2": "*",
-        "opt3": "&",
-        "opt4": "/",
-        "correct_option": "/",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the Boolean expression for the OR gate?",
-        "opt1": "A+B",
-        "opt2": "A*B",
-        "opt3": "A/B",
-        "opt4": "A&B",
-        "correct_option": "A+B",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the Boolean expression for the AND gate?",
-        "opt1": "A+B",
-        "opt2": "A*B",
-        "opt3": "A/B",
-        "opt4": "A&B",
-        "correct_option": "A*B",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the Boolean expression for the NOT gate?",
-        "opt1": "A+B",
-        "opt2": "A*B",
-        "opt3": "A'",
-        "opt4": "A&B'",
-        "correct_option": "A'",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is an example of a Boolean equation?",
-        "opt1": "y=x+2",
-        "opt2": "y=x*2",
-        "opt3": "y=xORz",
-        "opt4": "y=xAND2",
-        "correct_option": "y=xAND2",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is a Boolean identity?",
-        "opt1": "A+0=A",
-        "opt2": "A/1=A",
-        "opt3": "A*0=A",
-        "opt4": "A-1=A",
-        "correct_option": "A+0=A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a Boolean simplification rule?",
-        "opt1": "A+A=A",
-        "opt2": "A*A=A",
-        "opt3": "A+B=B+A",
-        "opt4": "A*B=B*A",
-        "correct_option": "A+B=B+A",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the result of the Boolean operation A OR (B AND C)?",
-        "opt1": "A+B*C",
-        "opt2": "A+B+C",
-        "opt3": "A*B*C",
-        "opt4": "A*B+C",
-        "correct_option": "A+B*C",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the result of the Boolean operation (A OR B) AND (A OR C)?",
-        "opt1": "A+B+C",
-        "opt2": "A*B*C",
-        "opt3": "A+B*C",
-        "opt4": "A*B+C",
-        "correct_option": "A+B+C",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the Boolean expression for the exclusive-OR (XOR) gate?",
-        "opt1": "A+B",
-        "opt2": "A*B",
-        "opt3": "A/B",
-        "opt4": "AB",
-        "correct_option": "AB",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is Boolean algebra?",
-        "opt1": "A branch of mathematics that deals with logic gates",
-        "opt2": "A branch of mathematics that deals with Boolean functions",
-        "opt3": "A branch of mathematics that deals with calculus",
-        "opt4": "A branch of mathematics that deals with programming languages",
-        "correct_option": "A branch of mathematics that deals with Boolean functions",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is a Boolean variable?",
-        "opt1": "A variable that can take on any value, including true or false",
-        "opt2": "A variable that can only take on two values, true or false",
-        "opt3": "A variable that can take on multiple values at once",
-        "opt4": "A variable that is always true",
-        "correct_option": "A variable that can only take on two values, true or false",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is a Boolean expression?",
-        "opt1": "A mathematical expression that uses Boolean variables, operators, and constants",
-        "opt2": "A mathematical expression that uses only integers and operators",
-        "opt3": "A mathematical expression that uses real numbers and operators",
-        "opt4": "A mathematical expression that uses only constants and operators",
-        "correct_option": "A mathematical expression that uses Boolean variables, operators, and constants",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which Boolean operator represents logical AND?",
-        "opt1": "+",
-        "opt2": "*",
-        "opt3": ".",
-        "opt4": "-",
-        "correct_option": ".",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which Boolean operator represents logical OR?",
-        "opt1": "+",
-        "opt2": "*",
-        "opt3": "/",
-        "opt4": "-",
-        "correct_option": "+",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which Boolean operator represents logical NOT?",
-        "opt1": "+",
-        "opt2": "*",
-        "opt3": "'",
-        "opt4": "/",
-        "correct_option": "'",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the complement of A in Boolean algebra?",
-        "opt1": "A'",
-        "opt2": "A+",
-        "opt3": "A*",
-        "opt4": "A-",
-        "correct_option": "A'",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the simplified expression for A + AB?",
-        "opt1": "A",
-        "opt2": "B",
-        "opt3": "AB",
-        "opt4": "1",
-        "correct_option": "A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the simplified expression for AB + A'B?",
-        "opt1": "AB + A'",
-        "opt2": "AB",
-        "opt3": "A+B",
-        "opt4": "AB'",
-        "correct_option": "AB'",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the Sum-of-Products (SOP) method in digital logic?",
-        "opt1": "A technique used to simplify Boolean expressions",
-        "opt2": "A technique used to convert decimal numbers to binary",
-        "opt3": "A technique used to convert binary numbers to decimal",
-        "opt4": "A technique used to convert octal numbers to hexadecimal",
-        "correct_option": "A technique used to simplify Boolean expressions",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the first step in using the SOP method to simplify a Boolean expression?",
-        "opt1": "Create a truth table",
-        "opt2": "Write the expression in standard form",
-        "opt3": "Identify the rows where the expression evaluates to 1",
-        "opt4": "Combine the rows with an OR operator",
-        "correct_option": "Write the expression in standard form",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What are the Boolean operators used in the standard form of a Boolean expression?",
-        "opt1": "AND, OR, and XOR",
-        "opt2": "AND, OR, and NOT",
-        "opt3": "XOR, NAND, and NOR",
-        "opt4": "XOR, NOT, and NAND",
-        "correct_option": "AND, OR, and NOT",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In the SOP method, what is the next step after creating a truth table for the Boolean expression?",
-        "opt1": "Identify the rows where the expression evaluates to 0",
-        "opt2": "Identify the rows where the expression evaluates to 1",
-        "opt3": "Convert the binary inputs to decimal",
-        "opt4": "Simplify the expression using a Karnaugh map",
-        "correct_option": "Identify the rows where the expression evaluates to 1",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the final step in using the SOP method to simplify a Boolean expression?",
-        "opt1": "Combine the rows with an AND operator",
-        "opt2": "Combine the rows with an OR operator",
-        "opt3": "Convert the expression to hexadecimal",
-        "opt4": "Convert the expression to binary",
-        "correct_option": "Combine the rows with an OR operator",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an example of a Boolean expression that can be simplified using the SOP method?",
-        "opt1": "F=A+B",
-        "opt2": "F=A*B",
-        "opt3": "F=A XOR B",
-        "opt4": "F=AB+A'B+AB'",
-        "correct_option": "F=AB+A'B+AB'",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "How many rows are in the truth table for a Boolean expression with two input variables?",
-        "opt1": "2",
-        "opt2": "4",
-        "opt3": "6",
-        "opt4": "8",
-        "correct_option": "4",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of the SOP method in digital logic?",
-        "opt1": "To convert decimal numbers to binary",
-        "opt2": "To simplify complex Boolean expressions",
-        "opt3": "To implement logic gates using a truth table",
-        "opt4": "To convert binary numbers to hexadecimal",
-        "correct_option": "To simplify complex Boolean expressions",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the meaning of \"sum of products\" in the SOP method?",
-        "opt1": "The sum of the input variables in the Boolean expression",
-        "opt2": "The sum of the rows in the truth table where the expression evaluates to 1",
-        "opt3": "The sum of the Boolean operators used in the expression",
-        "opt4": "The sum of the binary values in the truth table",
-        "correct_option": "The sum of the rows in the truth table where the expression evaluates to 1",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the Sum-of-Products (SOP) method used for in digital logic?",
-        "opt1": "To create a truth table for a given Boolean expression",
-        "opt2": "To simplify a given Boolean expression",
-        "opt3": "To convert a decimal number to binary",
-        "opt4": "To perform arithmetic operations on binary numbers",
-        "correct_option": "To simplify a given Boolean expression",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the first step when using the SOP method to simplify a Boolean expression?",
-        "opt1": "Create a truth table for the expression",
-        "opt2": "Identify the rows where the expression evaluates to 1",
-        "opt3": "Write the expression in the standard form",
-        "opt4": "Combine the rows with an OR operator",
-        "correct_option": "Write the expression in the standard form",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the standard form of a Boolean expression?",
-        "opt1": "A form without parentheses",
-        "opt2": "A form without negation",
-        "opt3": "A form with parentheses and Boolean operators",
-        "opt4": "A form with only one variable",
-        "correct_option": "A form with parentheses and Boolean operators",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "How do you identify the rows in a truth table where the expression evaluates to 1 when using the SOP method?",
-        "opt1": "Identify the rows where all variables are 1",
-        "opt2": "Identify the rows where all variables are 0",
-        "opt3": "Identify the rows where the expression is true",
-        "opt4": "Identify the rows where the expression is false",
-        "correct_option": "Identify the rows where the expression is true",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In the SOP method, what is the next step after identifying the rows where the expression evaluates to 1?",
-        "opt1": "Write down each row in terms of the input variables",
-        "opt2": "Combine the rows with an AND operator",
-        "opt3": "Combine the rows with an OR operator",
-        "opt4": "Create a Karnaugh map",
-        "correct_option": "Write down each row in terms of the input variables",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What Boolean operator is used to combine the rows in the SOP method?",
-        "opt1": "AND",
-        "opt2": "OR",
-        "opt3": "NOT",
-        "opt4": "XOR",
-        "correct_option": "OR",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the final result of the SOP method?",
-        "opt1": "A simplified sum of products expression",
-        "opt2": "A simplified product of sums expression",
-        "opt3": "A truth table",
-        "opt4": "A Karnaugh map",
-        "correct_option": "A simplified sum of products expression",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "How is a row with a value of 0 represented in the SOP method?",
-        "opt1": "With the corresponding variable",
-        "opt2": "With the complement of the corresponding variable",
-        "opt3": "With the negation of the corresponding variable",
-        "opt4": "With a 0",
-        "correct_option": "With the complement of the corresponding variable",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main advantage of using the SOP method to simplify Boolean expressions?",
-        "opt1": "It results in a smaller truth table",
-        "opt2": "It is easier to understand than other methods",
-        "opt3": "It results in a more efficient circuit design",
-        "opt4": "It works for any type of Boolean expression",
-        "correct_option": "It results in a more efficient circuit design",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Can the SOP method be used to simplify any Boolean expression?",
-        "opt1": "Yes, it can be used for any expression",
-        "opt2": "No, it can only be used for expressions with three variables or fewer",
-        "opt3": "No, it can only be used for expressions in standard form",
-        "opt4": "No, it can only be used for expressions with a small number of terms",
-        "correct_option": "Yes, it can be used for any expression",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the Product-of-Sums (POS) method used for in digital logic?",
-        "opt1": "Generating truth tables",
-        "opt2": "Simplifying Boolean expressions",
-        "opt3": "Building digital circuits",
-        "opt4": "Converting binary to decimal",
-        "correct_option": "Simplifying Boolean expressions",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In the POS method, what is the first step in simplifying a Boolean expression?",
-        "opt1": "Identify the rows of the truth table where the expression evaluates to 0",
-        "opt2": "Group the variables into terms and combine them with OR operators",
-        "opt3": "Write the expression in the standard form",
-        "opt4": "Combine the terms using AND operators",
-        "correct_option": "Write the expression in the standard form",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In the POS method, what is the second step in simplifying a Boolean expression?",
-        "opt1": "Identify the rows of the truth table where the expression evaluates to 0",
-        "opt2": "Group the variables into terms and combine them with OR operators",
-        "opt3": "Write the expression in the standard form",
-        "opt4": "Combine the terms using AND operators",
-        "correct_option": "Identify the rows of the truth table where the expression evaluates to 0",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the final result of applying the POS method to a Boolean expression?",
-        "opt1": "A simplified sum of products expression",
-        "opt2": "A simplified product of sums expression",
-        "opt3": "A minimized truth table",
-        "opt4": "A circuit diagram",
-        "correct_option": "A simplified product of sums expression",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In the POS method, how are the rows of the truth table where the expression evaluates to 0 combined?",
-        "opt1": "Using AND operators",
-        "opt2": "Using OR operators",
-        "opt3": "Using XOR operators",
-        "opt4": "Using NOT operators",
-        "correct_option": "Using OR operators",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "When is the POS method particularly useful?",
-        "opt1": "When the expression contains few terms",
-        "opt2": "When the expression contains many terms",
-        "opt3": "When the expression contains only one variable",
-        "opt4": "When the expression contains only constants",
-        "correct_option": "When the expression contains many terms",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "To complement a Boolean expression using the POS method, what must be done to the final result?",
-        "opt1": "It must be inverted",
-        "opt2": "It must be negated",
-        "opt3": "It must be squared",
-        "opt4": "It must be cubed",
-        "correct_option": "It must be inverted",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a benefit of using the POS method in digital logic?",
-        "opt1": "It simplifies truth tables",
-        "opt2": "It reduces the size and complexity of digital circuits",
-        "opt3": "It converts decimal to binary",
-        "opt4": "It generates random binary numbers",
-        "correct_option": "It reduces the size and complexity of digital circuits",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the Product-of-Sums method in digital logic?",
-        "opt1": "A method for simplifying Boolean expressions by combining sums of variables",
-        "opt2": "A method for simplifying Boolean expressions by combining products of variables",
-        "opt3": "A method for generating truth tables from Boolean expressions",
-        "opt4": "A method for generating Boolean expressions from truth tables",
-        "correct_option": "A method for simplifying Boolean expressions by combining products of variables",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the dual of the Product-of-Sums method?",
-        "opt1": "Sum-of-Products method",
-        "opt2": "Combinational logic",
-        "opt3": "Sequential logic",
-        "opt4": "None of the above",
-        "correct_option": "Sum-of-Products method",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the first step in the Product-of-Sums method?",
-        "opt1": "Identify the rows where the expression evaluates to 1",
-        "opt2": "Identify the rows where the expression evaluates to 0",
-        "opt3": "Write the expression in terms of the input variables",
-        "opt4": "None of the above",
-        "correct_option": "Identify the rows where the expression evaluates to 0",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the second step in the Product-of-Sums method?",
-        "opt1": "Identify the rows where the expression evaluates to 1",
-        "opt2": "Identify the rows where the expression evaluates to 0",
-        "opt3": "Write the expression in terms of the input variables",
-        "opt4": "None of the above",
-        "correct_option": "Write the expression in terms of the input variables",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the final step in the Product-of-Sums method?",
-        "opt1": "Combine the rows using OR operators",
-        "opt2": "Simplify the expression using DeMorgan's theorem",
-        "opt3": "Combine the rows using AND operators",
-        "opt4": "None of the above",
-        "correct_option": "Combine the rows using OR operators",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is an advantage of using the Product-of-Sums method?",
-        "opt1": "It is faster than other simplification methods",
-        "opt2": "It is easier to understand than other simplification methods",
-        "opt3": "It is more accurate than other simplification methods",
-        "opt4": "It is useful in cases where the expression contains many terms",
-        "correct_option": "It is easier to understand than other simplification methods",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of applying the Product-of-Sums method to the complement of an expression?",
-        "opt1": "To generate a truth table for the expression",
-        "opt2": "To simplify the expression using DeMorgan's theorem",
-        "opt3": "To generate a simplified expression that is the complement of the original expression",
-        "opt4": "None of the above",
-        "correct_option": "To generate a simplified expression that is the complement of the original expression",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is true about the Product-of-Sums method?",
-        "opt1": "It can only be used with binary variables",
-        "opt2": "It can be used with any type of variable",
-        "opt3": "It can only be used with Boolean expressions that contain AND operators",
-        "opt4": "None of the above",
-        "correct_option": "It can be used with any type of variable",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of using the Product-of-Sums method over the Sum-of-Products method?",
-        "opt1": "The resulting expression is easier to understand",
-        "opt2": "The resulting expression is shorter and requires fewer gates",
-        "opt3": "The method is faster and requires less computation",
-        "opt4": "None of the above",
-        "correct_option": "The resulting expression is shorter and requires fewer gates",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an application of the Product-of-Sums method?",
-        "opt1": "Simplifying Boolean expressions in digital circuits",
-        "opt2": "Generating truth tables for digital circuits",
-        "opt3": "Designing sequential logic circuits",
-        "opt4": "None of the above",
-        "correct_option": "Simplifying Boolean expressions in digital circuits",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a graphical tool used to simplify Boolean expressions?",
-        "opt1": "Truth table",
-        "opt2": "Karnaugh map",
-        "opt3": "Logic gate",
-        "opt4": "Logic circuit",
-        "correct_option": "Karnaugh map",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How are cells identified in a Karnaugh map?",
-        "opt1": "By their input variable combinations",
-        "opt2": "By their output values",
-        "opt3": "By their row and column numbers",
-        "opt4": "By their position on the map",
-        "correct_option": "By their input variable combinations",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "In the Karnaugh map, which cells can be combined to form a simplified expression?",
-        "opt1": "Diagonal cells",
-        "opt2": "Horizontal cells",
-        "opt3": "Vertical cells",
-        "opt4": "Adjacent cells",
-        "correct_option": "Adjacent cells",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What does SOP stand for in the context of digital logic?",
-        "opt1": "Sum of Products",
-        "opt2": "Product of Sums",
-        "opt3": "Sum of Squares",
-        "opt4": "Product of Squares",
-        "correct_option": "Sum of Products",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is true for the cells of a Karnaugh map?",
-        "opt1": "Each cell can only contain a 0 or a 1",
-        "opt2": "Each cell can contain a 0, 1, or X",
-        "opt3": "Each cell can contain any value between 0 and 1",
-        "opt4": "Each cell can contain a 1, 2, or 3",
-        "correct_option": "Each cell can only contain a 0 or a 1",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is a Karnaugh map used for?",
-        "opt1": "To generate a truth table",
-        "opt2": "To simplify Boolean expressions",
-        "opt3": "To convert a Boolean expression to a logic circuit",
-        "opt4": "To convert a Boolean expression to a logic gate",
-        "correct_option": "To simplify Boolean expressions",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How many cells does a Karnaugh map have if the corresponding Boolean expression has three input variables?",
-        "opt1": "12",
-        "opt2": "8",
-        "opt3": "16",
-        "opt4": "4",
-        "correct_option": "8",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is not a valid combination of input variables in a Karnaugh map for a two-variable expression?",
-        "opt1": "00",
-        "opt2": "01",
-        "opt3": "10",
-        "opt4": "11",
-        "correct_option": "21",
-        "correct_option_index": 5
-    },
-    {
-        "qsns": "How are adjacent cells identified in a Karnaugh map?",
-        "opt1": "By diagonal lines",
-        "opt2": "By vertical lines",
-        "opt3": "By horizontal lines",
-        "opt4": "Both b and c",
-        "correct_option": "Both b and c",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is a simplified expression for the Karnaugh map shown below?",
-        "opt1": "AB + BC + AD",
-        "opt2": "AB + CD",
-        "opt3": "AC + BD",
-        "opt4": "ACD + BCD",
-        "correct_option": "AB + CD",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How is a truth table converted into a Karnaugh map?",
-        "opt1": "By graphing the data points",
-        "opt2": "By plotting the input and output values on a grid",
-        "opt3": "By counting the number of 0's and 1's",
-        "opt4": "By entering the data into a computer program",
-        "correct_option": "By plotting the input and output values on a grid",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following Boolean expressions is equivalent to the Karnaugh map shown below?",
-        "opt1": "AB + BC + AD",
-        "opt2": "AB + CD",
-        "opt3": "AC + BD",
-        "opt4": "ACD + BCD",
-        "correct_option": "AB + CD",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How many cells in a Karnaugh map can be combined to form a simplified expression?",
-        "opt1": "1",
-        "opt2": "2",
-        "opt3": "3",
-        "opt4": "Both A and B",
-        "correct_option": "Both A and B",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "How is a simplified expression converted back into a standard SOP or POS expression?",
-        "opt1": "By using De Morgan's theorem",
-        "opt2": "By applying the distributive property",
-        "opt3": "By factoring out common terms",
-        "opt4": "Both A and B",
-        "correct_option": "Both A and B",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the duty cycle of a square wave generator?",
-        "opt1": "The time period of the waveform",
-        "opt2": "The ratio of the pulse width to the time period",
-        "opt3": "The amplitude of the waveform",
-        "opt4": "The frequency of the waveform",
-        "correct_option": "The ratio of the pulse width to the time period",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What type of waveform is produced by a triangle wave generator?",
-        "opt1": "A waveform with constant amplitude and frequency",
-        "opt2": "A waveform with a linearly increasing or decreasing amplitude",
-        "opt3": "A waveform with a constant frequency and varying amplitude",
-        "opt4": "A waveform with random fluctuations in amplitude and frequency",
-        "correct_option": "A waveform with a linearly increasing or decreasing amplitude",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What type of circuit is commonly used to generate square wave signals?",
-        "opt1": "An op-amp circuit",
-        "opt2": "A transistor circuit",
-        "opt3": "A flip-flop circuit",
-        "opt4": "A filter circuit",
-        "correct_option": "An op-amp circuit",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the advantage of using a relaxation oscillator for square wave generation?",
-        "opt1": "Simplicity and low cost",
-        "opt2": "High frequency stability and accuracy",
-        "opt3": "High power output",
-        "opt4": "Greater frequency range",
-        "correct_option": "Simplicity and low cost",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the role of a Schmitt trigger in a square wave generator circuit?",
-        "opt1": "To generate a clean and stable square wave signal",
-        "opt2": "To provide frequency-selective response",
-        "opt3": "To amplify the input signal",
-        "opt4": "To filter out unwanted frequencies",
-        "correct_option": "To generate a clean and stable square wave signal",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the frequency of a triangle wave generator determined by?",
-        "opt1": "The time constant of the RC circuit",
-        "opt2": "The resonant frequency of the tank circuit",
-        "opt3": "The frequency of the crystal",
-        "opt4": "The input voltage of the oscillator",
-        "correct_option": "The time constant of the RC circuit",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the advantage of using a ramp generator for triangle wave generation?",
-        "opt1": "Simplicity and low cost",
-        "opt2": "High frequency stability and accuracy",
-        "opt3": "High power output",
-        "opt4": "Greater frequency range",
-        "correct_option": "Simplicity and low cost",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What type of circuit is commonly used to generate triangle wave signals?",
-        "opt1": "An op-amp circuit",
-        "opt2": "An integrator circuit",
-        "opt3": "A flip-flop circuit",
-        "opt4": "A transistor circuit",
-        "correct_option": "An integrator circuit",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the amplitude of a triangle wave generator determined by?",
-        "opt1": "The time constant of the RC circuit",
-        "opt2": "The resonant frequency of the tank circuit",
-        "opt3": "The frequency of the crystal",
-        "opt4": "The input voltage of the oscillator",
-        "correct_option": "The input voltage of the oscillator",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the advantage of using an op-amp circuit for triangle wave generation?",
-        "opt1": "Simplicity and low cost",
-        "opt2": "High frequency stability and accuracy",
-        "opt3": "High power output",
-        "opt4": "Greater frequency range",
-        "correct_option": "Simplicity and low cost",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which waveform generator is typically used for testing digital circuits?",
-        "opt1": "Sine wave generator",
-        "opt2": "Square wave generator",
-        "opt3": "Triangle wave generator",
-        "opt4": "Sawtooth wave generator",
-        "correct_option": "Square wave generator",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the duty cycle of a square wave?",
-        "opt1": "The time period of the wave",
-        "opt2": "The ratio of the pulse width to the time period",
-        "opt3": "The frequency of the wave",
-        "opt4": "The amplitude of the wave",
-        "correct_option": "The ratio of the pulse width to the time period",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of using a square wave generator over other types of waveform generators?",
-        "opt1": "Simplicity and low cost",
-        "opt2": "High frequency stability and accuracy",
-        "opt3": "High power output",
-        "opt4": "Wide range of frequency and waveform options",
-        "correct_option": "Simplicity and low cost",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which waveform generator is capable of producing more complex waveforms than a square wave generator?",
-        "opt1": "Sine wave generator",
-        "opt2": "Triangle wave generator",
-        "opt3": "Sawtooth wave generator",
-        "opt4": "Arbitrary waveform generator",
-        "correct_option": "Arbitrary waveform generator",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the shape of the waveform produced by a triangle wave generator?",
-        "opt1": "A series of pulses with a constant amplitude",
-        "opt2": "A smoothly varying waveform with a linear rise and fall",
-        "opt3": "A waveform with a rapidly changing rise and a slow fall",
-        "opt4": "A waveform with a rapidly changing fall and a slow rise",
-        "correct_option": "A smoothly varying waveform with a linear rise and fall",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the frequency of a triangle wave generator determined by?",
-        "opt1": "The time period of the waveform",
-        "opt2": "The amplitude of the waveform",
-        "opt3": "The duty cycle of the waveform",
-        "opt4": "The slope of the waveform",
-        "correct_option": "The slope of the waveform",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the advantage of using a triangle wave generator over a square wave generator?",
-        "opt1": "Greater simplicity and lower cost",
-        "opt2": "Higher frequency stability and accuracy",
-        "opt3": "Higher power output",
-        "opt4": "More gradual transitions and reduced harmonic content",
-        "correct_option": "More gradual transitions and reduced harmonic content",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which type of waveform generator is commonly used in audio applications?",
-        "opt1": "Sine wave generator",
-        "opt2": "Square wave generator",
-        "opt3": "Triangle wave generator",
-        "opt4": "Sawtooth wave generator",
-        "correct_option": "Sine wave generator",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the shape of the waveform produced by a sawtooth wave generator?",
-        "opt1": "A series of pulses with a constant amplitude",
-        "opt2": "A smoothly varying waveform with a linear rise and fall",
-        "opt3": "A waveform with a rapidly changing rise and a slow fall",
-        "opt4": "A waveform with a rapidly changing fall and a slow rise",
-        "correct_option": "A waveform with a rapidly changing rise and a slow fall",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the advantage of using an arbitrary waveform generator over other types of waveform generators?",
-        "opt1": "Greater simplicity and lower cost",
-        "opt2": "Higher frequency stability and accuracy",
-        "opt3": "Higher power output",
-        "opt4": "The ability to generate complex and customized waveforms",
-        "correct_option": "The ability to generate complex and customized waveforms",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the amplifying element used in a Class A output stage?",
-        "opt1": "Bipolar Junction Transistor",
-        "opt2": "Field-Effect Transistor",
-        "opt3": "Operational Amplifier",
-        "opt4": "Vacuum Tube",
-        "correct_option": "Bipolar Junction Transistor",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What causes crossover distortion in a Class B output stage?",
-        "opt1": "The amplifying element conducts for the entire input signal cycle",
-        "opt2": "The amplifying element is biased so that it conducts for less than half of the input signal cycle",
-        "opt3": "Two amplifying elements are used and each one conducts for half of the input signal cycle",
-        "opt4": "The switching between the amplifying elements causes a gap in the output signal.",
-        "correct_option": "The switching between the amplifying elements causes a gap in the output signal.",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the advantage of a Class AB output stage over a Class B output stage?",
-        "opt1": "Higher efficiency",
-        "opt2": "Lower distortion",
-        "opt3": "Reduced crossover distortion",
-        "opt4": "Lower cost",
-        "correct_option": "Reduced crossover distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the operating mode of a Class C output stage?",
-        "opt1": "Linear",
-        "opt2": "Non-linear",
-        "opt3": "Saturated",
-        "opt4": "Reverse biased",
-        "correct_option": "Non-linear",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of a Class D output stage over other output stages?",
-        "opt1": "Low distortion",
-        "opt2": "High linearity",
-        "opt3": "High efficiency",
-        "opt4": "Low switching noise",
-        "correct_option": "High efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the primary disadvantage of a Class A output stage?",
-        "opt1": "High distortion",
-        "opt2": "Low efficiency",
-        "opt3": "High switching noise",
-        "opt4": "High cost",
-        "correct_option": "Low efficiency",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which type of output stage is suitable for RF amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class C",
-        "correct_option": "Class C",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the biasing arrangement used in a Class AB output stage?",
-        "opt1": "The amplifying element is biased to conduct for the entire input signal cycle.",
-        "opt2": "The amplifying element is biased to conduct for less than half of the input signal cycle.",
-        "opt3": "The bias voltage is varied to adjust the conduction angle.",
-        "opt4": "Two amplifying elements are used and each one conducts for half of the input signal cycle.",
-        "correct_option": "The bias voltage is varied to adjust the conduction angle.",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of output stage is used in audio power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class C",
-        "correct_option": "Class AB",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of output stage is commonly used in switch-mode power supplies?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class D",
-        "correct_option": "Class D",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is a characteristic of a class A output stage?",
-        "opt1": "High efficiency",
-        "opt2": "Low distortion",
-        "opt3": "Crossover distortion",
-        "opt4": "Conducts for less than half of the input signal cycle",
-        "correct_option": "Low distortion",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following output stages uses two amplifying elements that conduct for half of the input signal cycle each?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class C",
-        "opt4": "Class AB",
-        "correct_option": "Class B",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following output stages is a combination of class A and class B?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class C",
-        "correct_option": "Class AB",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following output stages is suitable for RF amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class C",
-        "correct_option": "Class C",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following output stages uses pulse width modulation to convert the input signal into a train of pulses?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class C",
-        "opt4": "Class D",
-        "correct_option": "Class D",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of a class B output stage?",
-        "opt1": "Low distortion",
-        "opt2": "High efficiency",
-        "opt3": "Crossover distortion",
-        "opt4": "Conducts for the entire input signal cycle",
-        "correct_option": "Crossover distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following output stages is the most efficient?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class C",
-        "correct_option": "Class C",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following output stages is the least efficient?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class C",
-        "correct_option": "Class A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following output stages has a biasing arrangement that allows the amplifying element to conduct slightly even when there is no input signal?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class C",
-        "correct_option": "Class AB",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following output stages is suitable for high power audio amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class C",
-        "correct_option": "Class AB",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the main advantage of a Class A output stage?",
-        "opt1": "High efficiency",
-        "opt2": "Low distortion",
-        "opt3": "Low power consumption",
-        "opt4": "High output power",
-        "correct_option": "Low distortion",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main disadvantage of a Class A output stage?",
-        "opt1": "High distortion",
-        "opt2": "Low efficiency",
-        "opt3": "High power consumption",
-        "opt4": "Low output power",
-        "correct_option": "Low efficiency",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What type of biasing is commonly used in Class A output stages?",
-        "opt1": "Fixed bias",
-        "opt2": "Self-bias",
-        "opt3": "Voltage divider bias",
-        "opt4": "Current mirror bias",
-        "correct_option": "Fixed bias",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the DC bias point of a Class A output stage?",
-        "opt1": "Equal to the positive supply voltage",
-        "opt2": "Halfway between the positive and negative supply voltage",
-        "opt3": "Equal to the negative supply voltage",
-        "opt4": "Zero",
-        "correct_option": "Halfway between the positive and negative supply voltage",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the maximum theoretical efficiency of a Class A output stage?",
-        "opt1": "25%",
-        "opt2": "50%",
-        "opt3": "75%",
-        "opt4": "100%",
-        "correct_option": "50%",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the typical output power of a Class A amplifier?",
-        "opt1": "Less than 1 watt",
-        "opt2": "1 watt to 10 watts",
-        "opt3": "10 watts to 100 watts",
-        "opt4": "More than 100 watts",
-        "correct_option": "1 watt to 10 watts",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What type of load is commonly used in Class A output stages?",
-        "opt1": "Resistive load",
-        "opt2": "Capacitive load",
-        "opt3": "Inductive load",
-        "opt4": "Reactive load",
-        "correct_option": "Resistive load",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the main advantage of a Class A output stage over other amplifier configurations?",
-        "opt1": "High efficiency",
-        "opt2": "High output power",
-        "opt3": "Low distortion",
-        "opt4": "Low power consumption",
-        "correct_option": "Low distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What type of input signal is best suited for a Class A output stage?",
-        "opt1": "Sinusoidal signal",
-        "opt2": "Square wave signal",
-        "opt3": "Triangular wave signal",
-        "opt4": "Pulse signal",
-        "correct_option": "Sinusoidal signal",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the typical voltage gain of a Class A amplifier?",
-        "opt1": "Less than 10",
-        "opt2": "10 to 100",
-        "opt3": "100 to 1000",
-        "opt4": "More than 1000",
-        "correct_option": "10 to 100",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a characteristic of a Class A output stage?",
-        "opt1": "High efficiency",
-        "opt2": "Low distortion",
-        "opt3": "Crossover distortion",
-        "opt4": "Conducts for less than half of the input signal cycle",
-        "correct_option": "Low distortion",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In a Class A output stage, the amplifying device conducts for:",
-        "opt1": "Half of the input signal cycle",
-        "opt2": "Less than half of the input signal cycle",
-        "opt3": "More than half of the input signal cycle",
-        "opt4": "The entire input signal cycle",
-        "correct_option": "The entire input signal cycle",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The efficiency of a Class A output stage is:",
-        "opt1": "High",
-        "opt2": "Low",
-        "opt3": "Moderate",
-        "opt4": "Not applicable",
-        "correct_option": "Low",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of a Class A output stage over other classes of amplifiers?",
-        "opt1": "Higher efficiency",
-        "opt2": "Lower distortion",
-        "opt3": "Lower cost",
-        "opt4": "Higher power output",
-        "correct_option": "Lower distortion",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the key feature of a Class A output stage?",
-        "opt1": "The amplifying device conducts for the entire input signal cycle",
-        "opt2": "The amplifying device conducts for only half of the input signal cycle",
-        "opt3": "The amplifying device conducts for less than half of the input signal cycle",
-        "opt4": "The amplifying device is biased to a cutoff state",
-        "correct_option": "The amplifying device conducts for the entire input signal cycle",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the typical efficiency of a Class A output stage?",
-        "opt1": "100%",
-        "opt2": "50%",
-        "opt3": "25%",
-        "opt4": "Less than 10%",
-        "correct_option": "25%",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of a Class A output stage?",
-        "opt1": "High efficiency",
-        "opt2": "High distortion",
-        "opt3": "High cost",
-        "opt4": "Low power output",
-        "correct_option": "Low power output",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which type of amplifying device is commonly used in Class A output stages?",
-        "opt1": "Bipolar Junction Transistor (BJT)",
-        "opt2": "Metal-Oxide-Semiconductor Field-Effect Transistor (MOSFET)",
-        "opt3": "Junction Field-Effect Transistor (JFET)",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of the biasing circuit in a Class A output stage?",
-        "opt1": "To set the operating point of the amplifying device",
-        "opt2": "To provide negative feedback",
-        "opt3": "To boost the output signal",
-        "opt4": "To reduce distortion",
-        "correct_option": "To set the operating point of the amplifying device",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the quiescent current of a Class A output stage?",
-        "opt1": "The maximum current the amplifying device can handle",
-        "opt2": "The current flowing through the load resistor when there is no input signal",
-        "opt3": "The current required to bias the amplifying device",
-        "opt4": "The current flowing through the amplifying device when there is no input signal",
-        "correct_option": "The current flowing through the amplifying device when there is no input signal",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is a common application of a Class A output stage?",
-        "opt1": "Audio power amplifiers",
-        "opt2": "RF amplifiers",
-        "opt3": "Voltage regulators",
-        "opt4": "Digital circuits",
-        "correct_option": "Audio power amplifiers",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a characteristic of the output signal of a Class A output stage?",
-        "opt1": "It is a square wave",
-        "opt2": "It is a sine wave",
-        "opt3": "It is a triangular wave",
-        "opt4": "It depends on the input signal",
-        "correct_option": "It depends on the input signal",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of a Class A output stage in terms of power efficiency?",
-        "opt1": "It generates more heat than other classes of amplifiers",
-        "opt2": "It consumes more power than other classes of amplifiers",
-        "opt3": "It is more expensive than other classes of amplifiers",
-        "opt4": "It has a lower power output than other classes of amplifiers",
-        "correct_option": "It generates more heat than other classes of amplifiers",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is a Class B output stage in amplifiers?",
-        "opt1": "An amplifier configuration where the amplifying device conducts for the full input signal cycle",
-        "opt2": "An amplifier configuration where the amplifying device conducts only for half of the input signal cycle",
-        "opt3": "An amplifier configuration where the output signal is inverted with respect to the input signal",
-        "opt4": "An amplifier configuration where two input signals are combined to produce the output signal",
-        "correct_option": "An amplifier configuration where the amplifying device conducts only for half of the input signal cycle",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of a Class B output stage?",
-        "opt1": "High power efficiency",
-        "opt2": "Low distortion",
-        "opt3": "High linearity",
-        "opt4": "Large voltage gain",
-        "correct_option": "High power efficiency",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is crossover distortion in a Class B output stage?",
-        "opt1": "A reduction in the voltage gain of the amplifier",
-        "opt2": "A discontinuity in the output signal at the point where one device switches off and the other switches on",
-        "opt3": "A change in the phase shift of the output signal",
-        "opt4": "An increase in the noise level of the amplifier",
-        "correct_option": "A discontinuity in the output signal at the point where one device switches off and the other switches on",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How is crossover distortion reduced in a Class B output stage?",
-        "opt1": "By increasing the voltage gain of the amplifier",
-        "opt2": "By decreasing the load impedance of the amplifier",
-        "opt3": "By applying a small amount of bias current to the amplifying devices",
-        "opt4": "By using a feedback network in the amplifier",
-        "correct_option": "By applying a small amount of bias current to the amplifying devices",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the main application of Class B output stages?",
-        "opt1": "Audio power amplifiers",
-        "opt2": "Voltage amplifiers",
-        "opt3": "Current amplifiers",
-        "opt4": "Low noise amplifiers",
-        "correct_option": "Audio power amplifiers",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the main disadvantage of Class B output stages?",
-        "opt1": "Crossover distortion",
-        "opt2": "Low power efficiency",
-        "opt3": "High distortion",
-        "opt4": "Poor linearity",
-        "correct_option": "Crossover distortion",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the purpose of biasing in a Class B output stage?",
-        "opt1": "To keep the amplifying devices slightly conductive even when there is no input signal",
-        "opt2": "To increase the voltage gain of the amplifier",
-        "opt3": "To decrease the noise level of the amplifier",
-        "opt4": "To reduce the distortion of the amplifier",
-        "correct_option": "To keep the amplifying devices slightly conductive even when there is no input signal",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the output signal waveform of a Class B output stage?",
-        "opt1": "A square wave",
-        "opt2": "A sawtooth wave",
-        "opt3": "A sine wave",
-        "opt4": "A combination of the signals produced by each device",
-        "correct_option": "A combination of the signals produced by each device",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What type of load is typically used with a Class B output stage?",
-        "opt1": "Resistive load",
-        "opt2": "Capacitive load",
-        "opt3": "Inductive load",
-        "opt4": "None of the above",
-        "correct_option": "Resistive load",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the maximum theoretical efficiency of a Class B output stage?",
-        "opt1": "50%",
-        "opt2": "75%",
-        "opt3": "90%",
-        "opt4": "100%",
-        "correct_option": "75%",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In a Class B output stage, how many amplifying devices are used?",
-        "opt1": "One",
-        "opt2": "Two",
-        "opt3": "Three",
-        "opt4": "Four",
-        "correct_option": "Two",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the key advantage of a Class B output stage?",
-        "opt1": "Low power consumption",
-        "opt2": "High distortion",
-        "opt3": "High power efficiency",
-        "opt4": "Low heat generation",
-        "correct_option": "High power efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the major disadvantage of a Class B output stage?",
-        "opt1": "Low power efficiency",
-        "opt2": "High power consumption",
-        "opt3": "High distortion",
-        "opt4": "Crossover distortion",
-        "correct_option": "Crossover distortion",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "How does bias current help to address the issue of crossover distortion in a Class B output stage?",
-        "opt1": "By increasing power consumption",
-        "opt2": "By reducing power efficiency",
-        "opt3": "By keeping the amplifying devices slightly conductive",
-        "opt4": "By increasing the gain of the amplifier",
-        "correct_option": "By keeping the amplifying devices slightly conductive",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which application is Class B output stage commonly used in?",
-        "opt1": "Low-distortion audio power amplifiers",
-        "opt2": "Low-power RF amplifiers",
-        "opt3": "High-distortion audio power amplifiers",
-        "opt4": "High-power RF amplifiers",
-        "correct_option": "High-power RF amplifiers",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the output signal of a Class B output stage?",
-        "opt1": "A combination of the input signal and the bias current",
-        "opt2": "A combination of two signals produced by each device",
-        "opt3": "A constant voltage signal",
-        "opt4": "A high distortion signal",
-        "correct_option": "A combination of two signals produced by each device",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which type of amplifiers produce less distortion than Class B amplifiers?",
-        "opt1": "Class A amplifiers",
-        "opt2": "Class AB amplifiers",
-        "opt3": "Class C amplifiers",
-        "opt4": "Class D amplifiers",
-        "correct_option": "Class AB amplifiers",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the function of the load resistor in a Class B output stage?",
-        "opt1": "To provide a bias current to the amplifying devices",
-        "opt2": "To reduce the power consumption of the amplifying devices",
-        "opt3": "To eliminate the crossover distortion",
-        "opt4": "To increase the gain of the amplifier",
-        "correct_option": "To eliminate the crossover distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of distortion is commonly associated with Class B output stages?",
-        "opt1": "Harmonic distortion",
-        "opt2": "Frequency distortion",
-        "opt3": "Amplitude distortion",
-        "opt4": "Crossover distortion",
-        "correct_option": "Crossover distortion",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is a limitation of using Class B amplifiers?",
-        "opt1": "High power efficiency",
-        "opt2": "Low distortion",
-        "opt3": "High linearity",
-        "opt4": "High power consumption",
-        "correct_option": "Low distortion",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main advantage of a Class AB output stage over a Class B output stage?",
-        "opt1": "Higher power efficiency",
-        "opt2": "Lower distortion",
-        "opt3": "High distortion",
-        "opt4": "None of the above",
-        "correct_option": "Lower distortion",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of biasing both amplifying devices in a Class AB output stage?",
-        "opt1": "To eliminate crossover distortion",
-        "opt2": "To improve power efficiency",
-        "opt3": "To increase linearity",
-        "opt4": "None of the above",
-        "correct_option": "To eliminate crossover distortion",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is not a characteristic of Class AB output stages?",
-        "opt1": "High linearity",
-        "opt2": "High power efficiency",
-        "opt3": "Low distortion",
-        "opt4": "High bias",
-        "correct_option": "High bias",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In which application are Class AB output stages commonly used?",
-        "opt1": "Low-power audio amplifiers",
-        "opt2": "High-fidelity audio amplifiers",
-        "opt3": "Power supplies",
-        "opt4": "None of the above",
-        "correct_option": "High-fidelity audio amplifiers",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which type of output stage offers the highest linearity?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "None of the above",
-        "correct_option": "Class A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the disadvantage of Class AB output stages compared to Class B output stages?",
-        "opt1": "Lower power efficiency",
-        "opt2": "Higher distortion",
-        "opt3": "More complex design",
-        "opt4": "None of the above",
-        "correct_option": "Lower power efficiency",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is not a benefit of using a Class AB output stage?",
-        "opt1": "High power output",
-        "opt2": "Low distortion",
-        "opt3": "High power efficiency",
-        "opt4": "None of the above",
-        "correct_option": "None of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which type of output stage produces lower distortion than Class B output stages?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class C",
-        "opt4": "Both A and B",
-        "correct_option": "Both A and B",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the key advantage of using a Class AB output stage?",
-        "opt1": "High power efficiency",
-        "opt2": "Low distortion",
-        "opt3": "High power efficiency and low distortion",
-        "opt4": "Low power efficiency and high distortion",
-        "correct_option": "High power efficiency and low distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the main disadvantage of Class A output stages compared to Class AB output stages?",
-        "opt1": "Lower linearity",
-        "opt2": "Lower power efficiency",
-        "opt3": "Higher distortion",
-        "opt4": "None of the above",
-        "correct_option": "Lower power efficiency",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about a Class AB output stage?",
-        "opt1": "It has high power efficiency and high distortion.",
-        "opt2": "It has low power efficiency and low distortion.",
-        "opt3": "It has high power efficiency and low distortion.",
-        "opt4": "It has low power efficiency and high distortion.",
-        "correct_option": "It has high power efficiency and low distortion.",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of output stage is commonly used in power supplies?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "None of the above",
-        "correct_option": "Class B",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main advantage of using a Class AB output stage in an audio amplifier?",
-        "opt1": "High distortion",
-        "opt2": "Low efficiency",
-        "opt3": "High efficiency and low distortion",
-        "opt4": "Low efficiency and high distortion",
-        "correct_option": "High efficiency and low distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In a Class AB output stage, both amplifying devices are biased to conduct a small amount of current even when there is no input signal. What is the purpose of this bias current?",
-        "opt1": "To increase distortion",
-        "opt2": "To reduce power efficiency",
-        "opt3": "To maintain high power efficiency",
-        "opt4": "To decrease linearity",
-        "correct_option": "To reduce power efficiency",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which type of output stage is commonly used in high-fidelity audio amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class AB",
-        "opt4": "Class C",
-        "correct_option": "Class AB",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the process of gradual conduction transfer in a Class AB output stage known as?",
-        "opt1": "Crossover",
-        "opt2": "Biasing",
-        "opt3": "Amplification",
-        "opt4": "Distortion",
-        "correct_option": "Crossover",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of using a Class AB output stage?",
-        "opt1": "High distortion",
-        "opt2": "Low power efficiency",
-        "opt3": "Low linearity",
-        "opt4": "High cost",
-        "correct_option": "Low power efficiency",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In a Class AB output stage, how do the amplifying devices behave when there is an input signal?",
-        "opt1": "They both conduct fully.",
-        "opt2": "One conducts fully and the other conducts partially.",
-        "opt3": "They both conduct partially.",
-        "opt4": "One conducts partially and the other is turned off.",
-        "correct_option": "One conducts fully and the other conducts partially.",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main purpose of a Class AB output stage?",
-        "opt1": "To reduce distortion",
-        "opt2": "To increase power efficiency",
-        "opt3": "To increase distortion",
-        "opt4": "To reduce power efficiency",
-        "correct_option": "To reduce distortion",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the purpose of biasing the Class AB output stage in amplifiers?",
-        "opt1": "To set the operating point of the amplifying devices",
-        "opt2": "To reduce distortion in the output signal",
-        "opt3": "To ensure that the amplifying devices operate in the active region of their characteristic curves",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is a common biasing technique for the Class AB output stage?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a voltage divider biasing network, where is the bias voltage set?",
-        "opt1": "At the base or gate of the amplifying device",
-        "opt2": "At the power supply voltage",
-        "opt3": "At ground",
-        "opt4": "None of the above",
-        "correct_option": "At the base or gate of the amplifying device",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "How does a diode biasing circuit work?",
-        "opt1": "By using a transistor configured as a voltage divider",
-        "opt2": "By connecting a diode in series with the base or gate of the amplifying device",
-        "opt3": "By using a voltage divider network",
-        "opt4": "None of the above",
-        "correct_option": "By connecting a diode in series with the base or gate of the amplifying device",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which biasing technique allows for fine-tuning of the operating point?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "None of the above",
-        "correct_option": "Voltage divider network",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the goal of biasing the Class AB stage?",
-        "opt1": "To maximize power efficiency",
-        "opt2": "To minimize power dissipation",
-        "opt3": "To ensure linear operation with low distortion",
-        "opt4": "None of the above",
-        "correct_option": "To ensure linear operation with low distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of amplifying device is typically used in a Class AB output stage?",
-        "opt1": "Bipolar junction transistor (BJT)",
-        "opt2": "Field-effect transistor (FET)",
-        "opt3": "Operational amplifier (Op-amp)",
-        "opt4": "None of the above",
-        "correct_option": "Bipolar junction transistor (BJT)",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which biasing technique uses a transistor configured as a voltage divider?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "None of the above",
-        "correct_option": "Transistor biasing",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Why is biasing necessary for Class AB amplifiers?",
-        "opt1": "To prevent the amplifying devices from saturating",
-        "opt2": "To ensure that the amplifying devices operate in the active region",
-        "opt3": "To decrease the gain of the amplifier",
-        "opt4": "None of the above",
-        "correct_option": "To ensure that the amplifying devices operate in the active region",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main advantage of using a Class AB output stage in amplifiers?",
-        "opt1": "High power efficiency",
-        "opt2": "Low power dissipation",
-        "opt3": "High linearity with low distortion",
-        "opt4": "None of the above",
-        "correct_option": "High linearity with low distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the bias voltage typically set to in the Class AB output stage?",
-        "opt1": "The forward voltage drop of a diode",
-        "opt2": "The power supply voltage",
-        "opt3": "Zero volts",
-        "opt4": "The voltage across a capacitor",
-        "correct_option": "The forward voltage drop of a diode",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of using a diode biasing circuit?",
-        "opt1": "It is more complex than other biasing techniques",
-        "opt2": "It is less stable than other biasing techniques",
-        "opt3": "It requires more power to operate",
-        "opt4": "It is less accurate than other biasing techniques",
-        "correct_option": "It is less stable than other biasing techniques",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of using a transistor biasing circuit?",
-        "opt1": "To set the bias voltage",
-        "opt2": "To amplify the input signal",
-        "opt3": "To reduce distortion in the output signal",
-        "opt4": "To increase power efficiency",
-        "correct_option": "To set the bias voltage",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following biasing techniques is commonly used in Class AB amplifiers?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "All of the above",
-        "correct_option": "Diode biasing",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How does the choice of biasing technique affect the power efficiency of the amplifier?",
-        "opt1": "It has no effect on power efficiency",
-        "opt2": "It can increase power efficiency",
-        "opt3": "It can decrease power efficiency",
-        "opt4": "It can cause the amplifier to malfunction",
-        "correct_option": "It can decrease power efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the disadvantage of using an adjustable biasing network?",
-        "opt1": "It is less accurate than a fixed biasing network",
-        "opt2": "It is less stable than a fixed biasing network",
-        "opt3": "It is more complex than a fixed biasing network",
-        "opt4": "It is more expensive than a fixed biasing network",
-        "correct_option": "It is more complex than a fixed biasing network",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a key consideration when selecting a biasing technique for the Class AB output stage?",
-        "opt1": "Power efficiency",
-        "opt2": "Cost",
-        "opt3": "Stability",
-        "opt4": "Input impedance",
-        "correct_option": "Power efficiency",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the primary application of power BJTs in amplifier circuits?",
-        "opt1": "High frequency amplification",
-        "opt2": "Low noise amplification",
-        "opt3": "Power amplification",
-        "opt4": "Voltage amplification",
-        "correct_option": "Power amplification",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of power BJT is more commonly used in power amplifier circuits?",
-        "opt1": "PNP",
-        "opt2": "NPN",
-        "opt3": "Both are used equally",
-        "opt4": "None of the above",
-        "correct_option": "NPN",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the operating region of the power BJT?",
-        "opt1": "Saturation",
-        "opt2": "Cutoff",
-        "opt3": "Active",
-        "opt4": "Reverse breakdown",
-        "correct_option": "Active",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which configuration is most commonly used for low-power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class B",
-        "opt4": "Class C",
-        "correct_option": "Class A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the main advantage of power BJTs over small signal BJTs?",
-        "opt1": "Higher frequency response",
-        "opt2": "Lower noise",
-        "opt3": "Higher power handling capability",
-        "opt4": "Lower distortion",
-        "correct_option": "Higher power handling capability",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a common application of power BJTs?",
-        "opt1": "Voltage regulators",
-        "opt2": "Oscillators",
-        "opt3": "Audio amplifiers",
-        "opt4": "Digital circuits",
-        "correct_option": "Audio amplifiers",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the primary purpose of switching amplifiers?",
-        "opt1": "To increase power gain",
-        "opt2": "To reduce distortion",
-        "opt3": "To improve efficiency",
-        "opt4": "To increase frequency response",
-        "correct_option": "To improve efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of amplifier uses power MOSFETs to provide high efficiency?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class D",
-        "opt4": "Class AB",
-        "correct_option": "Class D",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is not a technique used to improve the efficiency of power amplifiers?",
-        "opt1": "Class G and H amplifiers",
-        "opt2": "Switching amplifiers",
-        "opt3": "Feedback amplifiers",
-        "opt4": "Class D amplifiers",
-        "correct_option": "Feedback amplifiers",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the main disadvantage of power BJTs in amplifier circuits?",
-        "opt1": "High distortion",
-        "opt2": "Low power handling capability",
-        "opt3": "Low frequency response",
-        "opt4": "High heat dissipation",
-        "correct_option": "High heat dissipation",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the primary function of power BJTs in amplifier circuits?",
-        "opt1": "To provide high voltage gain",
-        "opt2": "To provide low noise amplification",
-        "opt3": "To provide high power gain and efficiency",
-        "opt4": "To provide high frequency response",
-        "correct_option": "To provide high power gain and efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a commonly used configuration for power BJTs in low-power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class B",
-        "opt4": "Class C",
-        "correct_option": "Class A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which type of power BJT is commonly used in power amplifier circuits?",
-        "opt1": "PNP",
-        "opt2": "NPN",
-        "opt3": "JFET",
-        "opt4": "MOSFET",
-        "correct_option": "NPN",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In which region of operation does the power BJT operate?",
-        "opt1": "Saturation region",
-        "opt2": "Cutoff region",
-        "opt3": "Active region",
-        "opt4": "Reverse-bias region",
-        "correct_option": "Active region",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a technique used to improve the efficiency of power amplifiers?",
-        "opt1": "Class A amplification",
-        "opt2": "Switching amplifiers",
-        "opt3": "Class AB amplification",
-        "opt4": "Linear amplifiers",
-        "correct_option": "Switching amplifiers",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an application of power BJTs?",
-        "opt1": "Audio amplifiers",
-        "opt2": "Radio receivers",
-        "opt3": "Logic gates",
-        "opt4": "Voltage regulators",
-        "correct_option": "Audio amplifiers",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the primary difference between small signal BJTs and power BJTs?",
-        "opt1": "Current gain",
-        "opt2": "Voltage gain",
-        "opt3": "Frequency response",
-        "opt4": "High power handling capability",
-        "correct_option": "High power handling capability",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which type of power BJT has a higher current gain?",
-        "opt1": "PNP",
-        "opt2": "NPN",
-        "opt3": "JFET",
-        "opt4": "MOSFET",
-        "correct_option": "NPN",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a benefit of using power BJTs in amplifier circuits?",
-        "opt1": "High frequency response",
-        "opt2": "Low power consumption",
-        "opt3": "Low distortion",
-        "opt4": "High power gain",
-        "correct_option": "High power gain",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following amplifier configurations is commonly used in high-power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class B",
-        "opt4": "Class D",
-        "correct_option": "Class D",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull amplifier, the primary winding of the output transformer is connected to:",
-        "opt1": "The input signal",
-        "opt2": "The collector of the NPN transistor in the driver stage",
-        "opt3": "The base of the NPN transistor in the driver stage",
-        "opt4": "The collector of both transistors",
-        "correct_option": "The collector of both transistors",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull amplifier is used to:",
-        "opt1": "Provide impedance matching between the driver and output stages",
-        "opt2": "Amplify the signal",
-        "opt3": "Provide voltage gain",
-        "opt4": "Provide current gain",
-        "correct_option": "Provide impedance matching between the driver and output stages",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull amplifier, the two output transistors are biased so that they conduct:",
-        "opt1": "Simultaneously",
-        "opt2": "Randomly",
-        "opt3": "Alternately",
-        "opt4": "None of the above",
-        "correct_option": "Alternately",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is an advantage of a transformer-coupled push-pull amplifier?",
-        "opt1": "High efficiency",
-        "opt2": "Low distortion",
-        "opt3": "High gain",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The output of a transformer-coupled push-pull amplifier is taken from:",
-        "opt1": "The primary winding of the output transformer",
-        "opt2": "The secondary winding of the output transformer",
-        "opt3": "The center tap of the output transformer",
-        "opt4": "None of the above",
-        "correct_option": "The secondary winding of the output transformer",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "The load impedance in a transformer-coupled push-pull amplifier is:",
-        "opt1": "Always equal to the output impedance of the amplifier",
-        "opt2": "Always lower than the output impedance of the amplifier",
-        "opt3": "Always higher than the output impedance of the amplifier",
-        "opt4": "None of the above",
-        "correct_option": "Always equal to the output impedance of the amplifier",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The DC bias voltage for the output transistors in a transformer-coupled push-pull amplifier is provided by:",
-        "opt1": "The input signal",
-        "opt2": "The driver stage",
-        "opt3": "A separate bias circuit",
-        "opt4": "None of the above",
-        "correct_option": "A separate bias circuit",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "The crossover distortion in a transformer-coupled push-pull amplifier is caused by:",
-        "opt1": "The mismatch between the two output transistors",
-        "opt2": "The bias voltage being too high",
-        "opt3": "The load impedance being too low",
-        "opt4": "None of the above",
-        "correct_option": "The mismatch between the two output transistors",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull amplifier is usually:",
-        "opt1": "A step-up transformer",
-        "opt2": "A step-down transformer",
-        "opt3": "A transformer with a 1:1 turns ratio",
-        "opt4": "None of the above",
-        "correct_option": "A step-down transformer",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull amplifier, the output transistors are typically:",
-        "opt1": "Darlington transistors",
-        "opt2": "Complementary pair transistors",
-        "opt3": "MOSFETs",
-        "opt4": "None of the above",
-        "correct_option": "None of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull stage, two identical transistors are used with one conducting during the positive half-cycle of the input signal and the other conducting during the negative half-cycle. What is the main advantage of using two transistors in this configuration?",
-        "opt1": "Increased efficiency",
-        "opt2": "Increased voltage gain",
-        "opt3": "Reduced distortion",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following statements about the transformer-coupled push-pull stage is true?",
-        "opt1": "It is commonly used in audio power amplifiers",
-        "opt2": "It is a type of class A amplifier",
-        "opt3": "It requires a large amount of power for operation",
-        "opt4": "It has a low voltage gain",
-        "correct_option": "It is commonly used in audio power amplifiers",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull stage is used to:",
-        "opt1": "Increase the voltage gain of the amplifier",
-        "opt2": "Couple the output signal to the load",
-        "opt3": "Provide impedance matching between the amplifier and the load",
-        "opt4": "All of the above",
-        "correct_option": "Provide impedance matching between the amplifier and the load",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull stage, the transformer is typically wound with a center-tapped secondary winding. What is the purpose of the center tap?",
-        "opt1": "To provide a reference voltage for biasing the transistors",
-        "opt2": "To provide a means for adjusting the gain of the amplifier",
-        "opt3": "To provide a balanced load for the transistors",
-        "opt4": "None of the above",
-        "correct_option": "To provide a reference voltage for biasing the transistors",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The transformer-coupled push-pull stage is a type of:",
-        "opt1": "Class A amplifier",
-        "opt2": "Class B amplifier",
-        "opt3": "Class AB amplifier",
-        "opt4": "None of the above",
-        "correct_option": "Class B amplifier",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an advantage of using a transformer-coupled push-pull stage over a single-ended output stage?",
-        "opt1": "Higher efficiency",
-        "opt2": "Higher voltage gain",
-        "opt3": "Reduced distortion",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The output of a transformer-coupled push-pull stage is taken from:",
-        "opt1": "The collector of one transistor",
-        "opt2": "The center tap of the transformer secondary winding",
-        "opt3": "The collector of both transistors",
-        "opt4": "The primary winding of the transformer",
-        "correct_option": "The center tap of the transformer secondary winding",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main disadvantage of a transformer-coupled push-pull stage compared to other output stage configurations?",
-        "opt1": "Reduced efficiency",
-        "opt2": "Increased distortion",
-        "opt3": "Limited frequency response",
-        "opt4": "All of the above",
-        "correct_option": "Limited frequency response",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull stage should be designed with:",
-        "opt1": "High primary-to-secondary turns ratio",
-        "opt2": "Low primary-to-secondary turns ratio",
-        "opt3": "High frequency response",
-        "opt4": "Low leakage inductance",
-        "correct_option": "Low leakage inductance",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the main advantage of using a transformer in a push-pull output stage?",
-        "opt1": "Increased voltage gain",
-        "opt2": "Impedance matching to the load",
-        "opt3": "Reduced distortion",
-        "opt4": "Increased efficiency",
-        "correct_option": "Impedance matching to the load",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a Boolean operator?",
-        "opt1": "+",
-        "opt2": "*",
-        "opt3": "&",
-        "opt4": "/",
-        "correct_option": "/",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the Boolean expression for the OR gate?",
-        "opt1": "A+B",
-        "opt2": "A*B",
-        "opt3": "A/B",
-        "opt4": "A&B",
-        "correct_option": "A+B",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the Boolean expression for the AND gate?",
-        "opt1": "A+B",
-        "opt2": "A*B",
-        "opt3": "A/B",
-        "opt4": "A&B",
-        "correct_option": "A*B",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the Boolean expression for the NOT gate?",
-        "opt1": "A+B",
-        "opt2": "A*B",
-        "opt3": "A'",
-        "opt4": "A&B'",
-        "correct_option": "A'",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is an example of a Boolean equation?",
-        "opt1": "y=x+2",
-        "opt2": "y=x*2",
-        "opt3": "y=xORz",
-        "opt4": "y=xAND2",
-        "correct_option": "y=xAND2",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is a Boolean identity?",
-        "opt1": "A+0=A",
-        "opt2": "A/1=A",
-        "opt3": "A*0=A",
-        "opt4": "A-1=A",
-        "correct_option": "A+0=A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a Boolean simplification rule?",
-        "opt1": "A+A=A",
-        "opt2": "A*A=A",
-        "opt3": "A+B=B+A",
-        "opt4": "A*B=B*A",
-        "correct_option": "A+B=B+A",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the result of the Boolean operation A OR (B AND C)?",
-        "opt1": "A+B*C",
-        "opt2": "A+B+C",
-        "opt3": "A*B*C",
-        "opt4": "A*B+C",
-        "correct_option": "A+B*C",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the result of the Boolean operation (A OR B) AND (A OR C)?",
-        "opt1": "A+B+C",
-        "opt2": "A*B*C",
-        "opt3": "A+B*C",
-        "opt4": "A*B+C",
-        "correct_option": "A+B+C",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the Boolean expression for the exclusive-OR (XOR) gate?",
-        "opt1": "A+B",
-        "opt2": "A*B",
-        "opt3": "A/B",
-        "opt4": "AB",
-        "correct_option": "AB",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is Boolean algebra?",
-        "opt1": "A branch of mathematics that deals with logic gates",
-        "opt2": "A branch of mathematics that deals with Boolean functions",
-        "opt3": "A branch of mathematics that deals with calculus",
-        "opt4": "A branch of mathematics that deals with programming languages",
-        "correct_option": "A branch of mathematics that deals with Boolean functions",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is a Boolean variable?",
-        "opt1": "A variable that can take on any value, including true or false",
-        "opt2": "A variable that can only take on two values, true or false",
-        "opt3": "A variable that can take on multiple values at once",
-        "opt4": "A variable that is always true",
-        "correct_option": "A variable that can only take on two values, true or false",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is a Boolean expression?",
-        "opt1": "A mathematical expression that uses Boolean variables, operators, and constants",
-        "opt2": "A mathematical expression that uses only integers and operators",
-        "opt3": "A mathematical expression that uses real numbers and operators",
-        "opt4": "A mathematical expression that uses only constants and operators",
-        "correct_option": "A mathematical expression that uses Boolean variables, operators, and constants",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which Boolean operator represents logical AND?",
-        "opt1": "+",
-        "opt2": "*",
-        "opt3": ".",
-        "opt4": "-",
-        "correct_option": ".",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which Boolean operator represents logical OR?",
-        "opt1": "+",
-        "opt2": "*",
-        "opt3": "/",
-        "opt4": "-",
-        "correct_option": "+",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which Boolean operator represents logical NOT?",
-        "opt1": "+",
-        "opt2": "*",
-        "opt3": "'",
-        "opt4": "/",
-        "correct_option": "'",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the complement of A in Boolean algebra?",
-        "opt1": "A'",
-        "opt2": "A+",
-        "opt3": "A*",
-        "opt4": "A-",
-        "correct_option": "A'",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the simplified expression for A + AB?",
-        "opt1": "A",
-        "opt2": "B",
-        "opt3": "AB",
-        "opt4": "1",
-        "correct_option": "A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the simplified expression for AB + A'B?",
-        "opt1": "AB + A'",
-        "opt2": "AB",
-        "opt3": "A+B",
-        "opt4": "AB'",
-        "correct_option": "AB'",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the Sum-of-Products (SOP) method in digital logic?",
-        "opt1": "A technique used to simplify Boolean expressions",
-        "opt2": "A technique used to convert decimal numbers to binary",
-        "opt3": "A technique used to convert binary numbers to decimal",
-        "opt4": "A technique used to convert octal numbers to hexadecimal",
-        "correct_option": "A technique used to simplify Boolean expressions",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the first step in using the SOP method to simplify a Boolean expression?",
-        "opt1": "Create a truth table",
-        "opt2": "Write the expression in standard form",
-        "opt3": "Identify the rows where the expression evaluates to 1",
-        "opt4": "Combine the rows with an OR operator",
-        "correct_option": "Write the expression in standard form",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What are the Boolean operators used in the standard form of a Boolean expression?",
-        "opt1": "AND, OR, and XOR",
-        "opt2": "AND, OR, and NOT",
-        "opt3": "XOR, NAND, and NOR",
-        "opt4": "XOR, NOT, and NAND",
-        "correct_option": "AND, OR, and NOT",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In the SOP method, what is the next step after creating a truth table for the Boolean expression?",
-        "opt1": "Identify the rows where the expression evaluates to 0",
-        "opt2": "Identify the rows where the expression evaluates to 1",
-        "opt3": "Convert the binary inputs to decimal",
-        "opt4": "Simplify the expression using a Karnaugh map",
-        "correct_option": "Identify the rows where the expression evaluates to 1",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the final step in using the SOP method to simplify a Boolean expression?",
-        "opt1": "Combine the rows with an AND operator",
-        "opt2": "Combine the rows with an OR operator",
-        "opt3": "Convert the expression to hexadecimal",
-        "opt4": "Convert the expression to binary",
-        "correct_option": "Combine the rows with an OR operator",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an example of a Boolean expression that can be simplified using the SOP method?",
-        "opt1": "F=A+B",
-        "opt2": "F=A*B",
-        "opt3": "F=A XOR B",
-        "opt4": "F=AB+A'B+AB'",
-        "correct_option": "F=AB+A'B+AB'",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "How many rows are in the truth table for a Boolean expression with two input variables?",
-        "opt1": "2",
-        "opt2": "4",
-        "opt3": "6",
-        "opt4": "8",
-        "correct_option": "4",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of the SOP method in digital logic?",
-        "opt1": "To convert decimal numbers to binary",
-        "opt2": "To simplify complex Boolean expressions",
-        "opt3": "To implement logic gates using a truth table",
-        "opt4": "To convert binary numbers to hexadecimal",
-        "correct_option": "To simplify complex Boolean expressions",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the meaning of \"sum of products\" in the SOP method?",
-        "opt1": "The sum of the input variables in the Boolean expression",
-        "opt2": "The sum of the rows in the truth table where the expression evaluates to 1",
-        "opt3": "The sum of the Boolean operators used in the expression",
-        "opt4": "The sum of the binary values in the truth table",
-        "correct_option": "The sum of the rows in the truth table where the expression evaluates to 1",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the Sum-of-Products (SOP) method used for in digital logic?",
-        "opt1": "To create a truth table for a given Boolean expression",
-        "opt2": "To simplify a given Boolean expression",
-        "opt3": "To convert a decimal number to binary",
-        "opt4": "To perform arithmetic operations on binary numbers",
-        "correct_option": "To simplify a given Boolean expression",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the first step when using the SOP method to simplify a Boolean expression?",
-        "opt1": "Create a truth table for the expression",
-        "opt2": "Identify the rows where the expression evaluates to 1",
-        "opt3": "Write the expression in the standard form",
-        "opt4": "Combine the rows with an OR operator",
-        "correct_option": "Write the expression in the standard form",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the standard form of a Boolean expression?",
-        "opt1": "A form without parentheses",
-        "opt2": "A form without negation",
-        "opt3": "A form with parentheses and Boolean operators",
-        "opt4": "A form with only one variable",
-        "correct_option": "A form with parentheses and Boolean operators",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "How do you identify the rows in a truth table where the expression evaluates to 1 when using the SOP method?",
-        "opt1": "Identify the rows where all variables are 1",
-        "opt2": "Identify the rows where all variables are 0",
-        "opt3": "Identify the rows where the expression is true",
-        "opt4": "Identify the rows where the expression is false",
-        "correct_option": "Identify the rows where the expression is true",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In the SOP method, what is the next step after identifying the rows where the expression evaluates to 1?",
-        "opt1": "Write down each row in terms of the input variables",
-        "opt2": "Combine the rows with an AND operator",
-        "opt3": "Combine the rows with an OR operator",
-        "opt4": "Create a Karnaugh map",
-        "correct_option": "Write down each row in terms of the input variables",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What Boolean operator is used to combine the rows in the SOP method?",
-        "opt1": "AND",
-        "opt2": "OR",
-        "opt3": "NOT",
-        "opt4": "XOR",
-        "correct_option": "OR",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the final result of the SOP method?",
-        "opt1": "A simplified sum of products expression",
-        "opt2": "A simplified product of sums expression",
-        "opt3": "A truth table",
-        "opt4": "A Karnaugh map",
-        "correct_option": "A simplified sum of products expression",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "How is a row with a value of 0 represented in the SOP method?",
-        "opt1": "With the corresponding variable",
-        "opt2": "With the complement of the corresponding variable",
-        "opt3": "With the negation of the corresponding variable",
-        "opt4": "With a 0",
-        "correct_option": "With the complement of the corresponding variable",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main advantage of using the SOP method to simplify Boolean expressions?",
-        "opt1": "It results in a smaller truth table",
-        "opt2": "It is easier to understand than other methods",
-        "opt3": "It results in a more efficient circuit design",
-        "opt4": "It works for any type of Boolean expression",
-        "correct_option": "It results in a more efficient circuit design",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Can the SOP method be used to simplify any Boolean expression?",
-        "opt1": "Yes, it can be used for any expression",
-        "opt2": "No, it can only be used for expressions with three variables or fewer",
-        "opt3": "No, it can only be used for expressions in standard form",
-        "opt4": "No, it can only be used for expressions with a small number of terms",
-        "correct_option": "Yes, it can be used for any expression",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the Product-of-Sums (POS) method used for in digital logic?",
-        "opt1": "Generating truth tables",
-        "opt2": "Simplifying Boolean expressions",
-        "opt3": "Building digital circuits",
-        "opt4": "Converting binary to decimal",
-        "correct_option": "Simplifying Boolean expressions",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In the POS method, what is the first step in simplifying a Boolean expression?",
-        "opt1": "Identify the rows of the truth table where the expression evaluates to 0",
-        "opt2": "Group the variables into terms and combine them with OR operators",
-        "opt3": "Write the expression in the standard form",
-        "opt4": "Combine the terms using AND operators",
-        "correct_option": "Write the expression in the standard form",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In the POS method, what is the second step in simplifying a Boolean expression?",
-        "opt1": "Identify the rows of the truth table where the expression evaluates to 0",
-        "opt2": "Group the variables into terms and combine them with OR operators",
-        "opt3": "Write the expression in the standard form",
-        "opt4": "Combine the terms using AND operators",
-        "correct_option": "Identify the rows of the truth table where the expression evaluates to 0",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the final result of applying the POS method to a Boolean expression?",
-        "opt1": "A simplified sum of products expression",
-        "opt2": "A simplified product of sums expression",
-        "opt3": "A minimized truth table",
-        "opt4": "A circuit diagram",
-        "correct_option": "A simplified product of sums expression",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In the POS method, how are the rows of the truth table where the expression evaluates to 0 combined?",
-        "opt1": "Using AND operators",
-        "opt2": "Using OR operators",
-        "opt3": "Using XOR operators",
-        "opt4": "Using NOT operators",
-        "correct_option": "Using OR operators",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "When is the POS method particularly useful?",
-        "opt1": "When the expression contains few terms",
-        "opt2": "When the expression contains many terms",
-        "opt3": "When the expression contains only one variable",
-        "opt4": "When the expression contains only constants",
-        "correct_option": "When the expression contains many terms",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "To complement a Boolean expression using the POS method, what must be done to the final result?",
-        "opt1": "It must be inverted",
-        "opt2": "It must be negated",
-        "opt3": "It must be squared",
-        "opt4": "It must be cubed",
-        "correct_option": "It must be inverted",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a benefit of using the POS method in digital logic?",
-        "opt1": "It simplifies truth tables",
-        "opt2": "It reduces the size and complexity of digital circuits",
-        "opt3": "It converts decimal to binary",
-        "opt4": "It generates random binary numbers",
-        "correct_option": "It reduces the size and complexity of digital circuits",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the Product-of-Sums method in digital logic?",
-        "opt1": "A method for simplifying Boolean expressions by combining sums of variables",
-        "opt2": "A method for simplifying Boolean expressions by combining products of variables",
-        "opt3": "A method for generating truth tables from Boolean expressions",
-        "opt4": "A method for generating Boolean expressions from truth tables",
-        "correct_option": "A method for simplifying Boolean expressions by combining products of variables",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the dual of the Product-of-Sums method?",
-        "opt1": "Sum-of-Products method",
-        "opt2": "Combinational logic",
-        "opt3": "Sequential logic",
-        "opt4": "None of the above",
-        "correct_option": "Sum-of-Products method",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the first step in the Product-of-Sums method?",
-        "opt1": "Identify the rows where the expression evaluates to 1",
-        "opt2": "Identify the rows where the expression evaluates to 0",
-        "opt3": "Write the expression in terms of the input variables",
-        "opt4": "None of the above",
-        "correct_option": "Identify the rows where the expression evaluates to 0",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the second step in the Product-of-Sums method?",
-        "opt1": "Identify the rows where the expression evaluates to 1",
-        "opt2": "Identify the rows where the expression evaluates to 0",
-        "opt3": "Write the expression in terms of the input variables",
-        "opt4": "None of the above",
-        "correct_option": "Write the expression in terms of the input variables",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the final step in the Product-of-Sums method?",
-        "opt1": "Combine the rows using OR operators",
-        "opt2": "Simplify the expression using DeMorgan's theorem",
-        "opt3": "Combine the rows using AND operators",
-        "opt4": "None of the above",
-        "correct_option": "Combine the rows using OR operators",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is an advantage of using the Product-of-Sums method?",
-        "opt1": "It is faster than other simplification methods",
-        "opt2": "It is easier to understand than other simplification methods",
-        "opt3": "It is more accurate than other simplification methods",
-        "opt4": "It is useful in cases where the expression contains many terms",
-        "correct_option": "It is easier to understand than other simplification methods",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of applying the Product-of-Sums method to the complement of an expression?",
-        "opt1": "To generate a truth table for the expression",
-        "opt2": "To simplify the expression using DeMorgan's theorem",
-        "opt3": "To generate a simplified expression that is the complement of the original expression",
-        "opt4": "None of the above",
-        "correct_option": "To generate a simplified expression that is the complement of the original expression",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is true about the Product-of-Sums method?",
-        "opt1": "It can only be used with binary variables",
-        "opt2": "It can be used with any type of variable",
-        "opt3": "It can only be used with Boolean expressions that contain AND operators",
-        "opt4": "None of the above",
-        "correct_option": "It can be used with any type of variable",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of using the Product-of-Sums method over the Sum-of-Products method?",
-        "opt1": "The resulting expression is easier to understand",
-        "opt2": "The resulting expression is shorter and requires fewer gates",
-        "opt3": "The method is faster and requires less computation",
-        "opt4": "None of the above",
-        "correct_option": "The resulting expression is shorter and requires fewer gates",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an application of the Product-of-Sums method?",
-        "opt1": "Simplifying Boolean expressions in digital circuits",
-        "opt2": "Generating truth tables for digital circuits",
-        "opt3": "Designing sequential logic circuits",
-        "opt4": "None of the above",
-        "correct_option": "Simplifying Boolean expressions in digital circuits",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a graphical tool used to simplify Boolean expressions?",
-        "opt1": "Truth table",
-        "opt2": "Karnaugh map",
-        "opt3": "Logic gate",
-        "opt4": "Logic circuit",
-        "correct_option": "Karnaugh map",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How are cells identified in a Karnaugh map?",
-        "opt1": "By their input variable combinations",
-        "opt2": "By their output values",
-        "opt3": "By their row and column numbers",
-        "opt4": "By their position on the map",
-        "correct_option": "By their input variable combinations",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "In the Karnaugh map, which cells can be combined to form a simplified expression?",
-        "opt1": "Diagonal cells",
-        "opt2": "Horizontal cells",
-        "opt3": "Vertical cells",
-        "opt4": "Adjacent cells",
-        "correct_option": "Adjacent cells",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What does SOP stand for in the context of digital logic?",
-        "opt1": "Sum of Products",
-        "opt2": "Product of Sums",
-        "opt3": "Sum of Squares",
-        "opt4": "Product of Squares",
-        "correct_option": "Sum of Products",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is true for the cells of a Karnaugh map?",
-        "opt1": "Each cell can only contain a 0 or a 1",
-        "opt2": "Each cell can contain a 0, 1, or X",
-        "opt3": "Each cell can contain any value between 0 and 1",
-        "opt4": "Each cell can contain a 1, 2, or 3",
-        "correct_option": "Each cell can only contain a 0 or a 1",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is a Karnaugh map used for?",
-        "opt1": "To generate a truth table",
-        "opt2": "To simplify Boolean expressions",
-        "opt3": "To convert a Boolean expression to a logic circuit",
-        "opt4": "To convert a Boolean expression to a logic gate",
-        "correct_option": "To simplify Boolean expressions",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How many cells does a Karnaugh map have if the corresponding Boolean expression has three input variables?",
-        "opt1": "12",
-        "opt2": "8",
-        "opt3": "16",
-        "opt4": "4",
-        "correct_option": "8",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is not a valid combination of input variables in a Karnaugh map for a two-variable expression?",
-        "opt1": "00",
-        "opt2": "01",
-        "opt3": "10",
-        "opt4": "11",
-        "correct_option": "21",
-        "correct_option_index": 5
-    },
-    {
-        "qsns": "How are adjacent cells identified in a Karnaugh map?",
-        "opt1": "By diagonal lines",
-        "opt2": "By vertical lines",
-        "opt3": "By horizontal lines",
-        "opt4": "Both b and c",
-        "correct_option": "Both b and c",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is a simplified expression for the Karnaugh map shown below?",
-        "opt1": "AB + BC + AD",
-        "opt2": "AB + CD",
-        "opt3": "AC + BD",
-        "opt4": "ACD + BCD",
-        "correct_option": "AB + CD",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How is a truth table converted into a Karnaugh map?",
-        "opt1": "By graphing the data points",
-        "opt2": "By plotting the input and output values on a grid",
-        "opt3": "By counting the number of 0's and 1's",
-        "opt4": "By entering the data into a computer program",
-        "correct_option": "By plotting the input and output values on a grid",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following Boolean expressions is equivalent to the Karnaugh map shown below?",
-        "opt1": "AB + BC + AD",
-        "opt2": "AB + CD",
-        "opt3": "AC + BD",
-        "opt4": "ACD + BCD",
-        "correct_option": "AB + CD",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How many cells in a Karnaugh map can be combined to form a simplified expression?",
-        "opt1": "1",
-        "opt2": "2",
-        "opt3": "3",
-        "opt4": "Both A and B",
-        "correct_option": "Both A and B",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "How is a simplified expression converted back into a standard SOP or POS expression?",
-        "opt1": "By using De Morgan's theorem",
-        "opt2": "By applying the distributive property",
-        "opt3": "By factoring out common terms",
-        "opt4": "Both A and B",
-        "correct_option": "Both A and B",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is a gated flip-flop?",
-        "opt1": "A type of logic gate",
-        "opt2": "A type of sequential circuit",
-        "opt3": "A type of combinational circuit",
-        "opt4": "A type of adder",
-        "correct_option": "A type of sequential circuit",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which type of flip-flop uses an AND gate to control the clock input?",
-        "opt1": "D flip-flop",
-        "opt2": "T flip-flop",
-        "opt3": "JK flip-flop",
-        "opt4": "SR flip-flop",
-        "correct_option": "T flip-flop",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of using gated flip-flops?",
-        "opt1": "They are faster than regular flip-flops",
-        "opt2": "They use less power than regular flip-flops",
-        "opt3": "They can selectively enable or disable the clock input",
-        "opt4": "They can be used in parallel circuits",
-        "correct_option": "They can selectively enable or disable the clock input",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of flip-flop uses a NAND gate to control the J and K inputs?",
-        "opt1": "D flip-flop",
-        "opt2": "T flip-flop",
-        "opt3": "JK flip-flop",
-        "opt4": "SR flip-flop",
-        "correct_option": "JK flip-flop",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What happens to the output of a T gated flip-flop when the clock and gate inputs are both high?",
-        "opt1": "The output remains the same",
-        "opt2": "The output toggles between 0 and 1",
-        "opt3": "The output becomes 0",
-        "opt4": "The output becomes 1",
-        "correct_option": "The output toggles between 0 and 1",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is not a type of gated flip-flop?",
-        "opt1": "D flip-flop",
-        "opt2": "SR flip-flop",
-        "opt3": "T flip-flop",
-        "opt4": "JK flip-flop",
-        "correct_option": "SR flip-flop",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of biasing the Class AB output stage in amplifiers?",
-        "opt1": "To set the operating point of the amplifying devices",
-        "opt2": "To reduce distortion in the output signal",
-        "opt3": "To ensure that the amplifying devices operate in the active region of their characteristic curves",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is a common biasing technique for the Class AB output stage?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a voltage divider biasing network, where is the bias voltage set?",
-        "opt1": "At the base or gate of the amplifying device",
-        "opt2": "At the power supply voltage",
-        "opt3": "At ground",
-        "opt4": "None of the above",
-        "correct_option": "At the base or gate of the amplifying device",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "How does a diode biasing circuit work?",
-        "opt1": "By using a transistor configured as a voltage divider",
-        "opt2": "By connecting a diode in series with the base or gate of the amplifying device",
-        "opt3": "By using a voltage divider network",
-        "opt4": "None of the above",
-        "correct_option": "By connecting a diode in series with the base or gate of the amplifying device",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which biasing technique allows for fine-tuning of the operating point?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "None of the above",
-        "correct_option": "Voltage divider network",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the goal of biasing the Class AB stage?",
-        "opt1": "To maximize power efficiency",
-        "opt2": "To minimize power dissipation",
-        "opt3": "To ensure linear operation with low distortion",
-        "opt4": "None of the above",
-        "correct_option": "To ensure linear operation with low distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of amplifying device is typically used in a Class AB output stage?",
-        "opt1": "Bipolar junction transistor (BJT)",
-        "opt2": "Field-effect transistor (FET)",
-        "opt3": "Operational amplifier (Op-amp)",
-        "opt4": "None of the above",
-        "correct_option": "Bipolar junction transistor (BJT)",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which biasing technique uses a transistor configured as a voltage divider?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "None of the above",
-        "correct_option": "Transistor biasing",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Why is biasing necessary for Class AB amplifiers?",
-        "opt1": "To prevent the amplifying devices from saturating",
-        "opt2": "To ensure that the amplifying devices operate in the active region",
-        "opt3": "To decrease the gain of the amplifier",
-        "opt4": "None of the above",
-        "correct_option": "To ensure that the amplifying devices operate in the active region",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main advantage of using a Class AB output stage in amplifiers?",
-        "opt1": "High power efficiency",
-        "opt2": "Low power dissipation",
-        "opt3": "High linearity with low distortion",
-        "opt4": "None of the above",
-        "correct_option": "High linearity with low distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the bias voltage typically set to in the Class AB output stage?",
-        "opt1": "The forward voltage drop of a diode",
-        "opt2": "The power supply voltage",
-        "opt3": "Zero volts",
-        "opt4": "The voltage across a capacitor",
-        "correct_option": "The forward voltage drop of a diode",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of using a diode biasing circuit?",
-        "opt1": "It is more complex than other biasing techniques",
-        "opt2": "It is less stable than other biasing techniques",
-        "opt3": "It requires more power to operate",
-        "opt4": "It is less accurate than other biasing techniques",
-        "correct_option": "It is less stable than other biasing techniques",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of using a transistor biasing circuit?",
-        "opt1": "To set the bias voltage",
-        "opt2": "To amplify the input signal",
-        "opt3": "To reduce distortion in the output signal",
-        "opt4": "To increase power efficiency",
-        "correct_option": "To set the bias voltage",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following biasing techniques is commonly used in Class AB amplifiers?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "All of the above",
-        "correct_option": "Diode biasing",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How does the choice of biasing technique affect the power efficiency of the amplifier?",
-        "opt1": "It has no effect on power efficiency",
-        "opt2": "It can increase power efficiency",
-        "opt3": "It can decrease power efficiency",
-        "opt4": "It can cause the amplifier to malfunction",
-        "correct_option": "It can decrease power efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the disadvantage of using an adjustable biasing network?",
-        "opt1": "It is less accurate than a fixed biasing network",
-        "opt2": "It is less stable than a fixed biasing network",
-        "opt3": "It is more complex than a fixed biasing network",
-        "opt4": "It is more expensive than a fixed biasing network",
-        "correct_option": "It is more complex than a fixed biasing network",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a key consideration when selecting a biasing technique for the Class AB output stage?",
-        "opt1": "Power efficiency",
-        "opt2": "Cost",
-        "opt3": "Stability",
-        "opt4": "Input impedance",
-        "correct_option": "Power efficiency",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the primary application of power BJTs in amplifier circuits?",
-        "opt1": "High frequency amplification",
-        "opt2": "Low noise amplification",
-        "opt3": "Power amplification",
-        "opt4": "Voltage amplification",
-        "correct_option": "Power amplification",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of power BJT is more commonly used in power amplifier circuits?",
-        "opt1": "PNP",
-        "opt2": "NPN",
-        "opt3": "Both are used equally",
-        "opt4": "None of the above",
-        "correct_option": "NPN",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the operating region of the power BJT?",
-        "opt1": "Saturation",
-        "opt2": "Cutoff",
-        "opt3": "Active",
-        "opt4": "Reverse breakdown",
-        "correct_option": "Active",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which configuration is most commonly used for low-power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class B",
-        "opt4": "Class C",
-        "correct_option": "Class A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the main advantage of power BJTs over small signal BJTs?",
-        "opt1": "Higher frequency response",
-        "opt2": "Lower noise",
-        "opt3": "Higher power handling capability",
-        "opt4": "Lower distortion",
-        "correct_option": "Higher power handling capability",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a common application of power BJTs?",
-        "opt1": "Voltage regulators",
-        "opt2": "Oscillators",
-        "opt3": "Audio amplifiers",
-        "opt4": "Digital circuits",
-        "correct_option": "Audio amplifiers",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the primary purpose of switching amplifiers?",
-        "opt1": "To increase power gain",
-        "opt2": "To reduce distortion",
-        "opt3": "To improve efficiency",
-        "opt4": "To increase frequency response",
-        "correct_option": "To improve efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of amplifier uses power MOSFETs to provide high efficiency?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class D",
-        "opt4": "Class AB",
-        "correct_option": "Class D",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is not a technique used to improve the efficiency of power amplifiers?",
-        "opt1": "Class G and H amplifiers",
-        "opt2": "Switching amplifiers",
-        "opt3": "Feedback amplifiers",
-        "opt4": "Class D amplifiers",
-        "correct_option": "Feedback amplifiers",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the main disadvantage of power BJTs in amplifier circuits?",
-        "opt1": "High distortion",
-        "opt2": "Low power handling capability",
-        "opt3": "Low frequency response",
-        "opt4": "High heat dissipation",
-        "correct_option": "High heat dissipation",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the primary function of power BJTs in amplifier circuits?",
-        "opt1": "To provide high voltage gain",
-        "opt2": "To provide low noise amplification",
-        "opt3": "To provide high power gain and efficiency",
-        "opt4": "To provide high frequency response",
-        "correct_option": "To provide high power gain and efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a commonly used configuration for power BJTs in low-power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class B",
-        "opt4": "Class C",
-        "correct_option": "Class A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which type of power BJT is commonly used in power amplifier circuits?",
-        "opt1": "PNP",
-        "opt2": "NPN",
-        "opt3": "JFET",
-        "opt4": "MOSFET",
-        "correct_option": "NPN",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In which region of operation does the power BJT operate?",
-        "opt1": "Saturation region",
-        "opt2": "Cutoff region",
-        "opt3": "Active region",
-        "opt4": "Reverse-bias region",
-        "correct_option": "Active region",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a technique used to improve the efficiency of power amplifiers?",
-        "opt1": "Class A amplification",
-        "opt2": "Switching amplifiers",
-        "opt3": "Class AB amplification",
-        "opt4": "Linear amplifiers",
-        "correct_option": "Switching amplifiers",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an application of power BJTs?",
-        "opt1": "Audio amplifiers",
-        "opt2": "Radio receivers",
-        "opt3": "Logic gates",
-        "opt4": "Voltage regulators",
-        "correct_option": "Audio amplifiers",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the primary difference between small signal BJTs and power BJTs?",
-        "opt1": "Current gain",
-        "opt2": "Voltage gain",
-        "opt3": "Frequency response",
-        "opt4": "High power handling capability",
-        "correct_option": "High power handling capability",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which type of power BJT has a higher current gain?",
-        "opt1": "PNP",
-        "opt2": "NPN",
-        "opt3": "JFET",
-        "opt4": "MOSFET",
-        "correct_option": "NPN",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a benefit of using power BJTs in amplifier circuits?",
-        "opt1": "High frequency response",
-        "opt2": "Low power consumption",
-        "opt3": "Low distortion",
-        "opt4": "High power gain",
-        "correct_option": "High power gain",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following amplifier configurations is commonly used in high-power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class B",
-        "opt4": "Class D",
-        "correct_option": "Class D",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull amplifier, the primary winding of the output transformer is connected to:",
-        "opt1": "The input signal",
-        "opt2": "The collector of the NPN transistor in the driver stage",
-        "opt3": "The base of the NPN transistor in the driver stage",
-        "opt4": "The collector of both transistors",
-        "correct_option": "The collector of both transistors",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull amplifier is used to:",
-        "opt1": "Provide impedance matching between the driver and output stages",
-        "opt2": "Amplify the signal",
-        "opt3": "Provide voltage gain",
-        "opt4": "Provide current gain",
-        "correct_option": "Provide impedance matching between the driver and output stages",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull amplifier, the two output transistors are biased so that they conduct:",
-        "opt1": "Simultaneously",
-        "opt2": "Randomly",
-        "opt3": "Alternately",
-        "opt4": "None of the above",
-        "correct_option": "Alternately",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is an advantage of a transformer-coupled push-pull amplifier?",
-        "opt1": "High efficiency",
-        "opt2": "Low distortion",
-        "opt3": "High gain",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The output of a transformer-coupled push-pull amplifier is taken from:",
-        "opt1": "The primary winding of the output transformer",
-        "opt2": "The secondary winding of the output transformer",
-        "opt3": "The center tap of the output transformer",
-        "opt4": "None of the above",
-        "correct_option": "The secondary winding of the output transformer",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "The load impedance in a transformer-coupled push-pull amplifier is:",
-        "opt1": "Always equal to the output impedance of the amplifier",
-        "opt2": "Always lower than the output impedance of the amplifier",
-        "opt3": "Always higher than the output impedance of the amplifier",
-        "opt4": "None of the above",
-        "correct_option": "Always equal to the output impedance of the amplifier",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The DC bias voltage for the output transistors in a transformer-coupled push-pull amplifier is provided by:",
-        "opt1": "The input signal",
-        "opt2": "The driver stage",
-        "opt3": "A separate bias circuit",
-        "opt4": "None of the above",
-        "correct_option": "A separate bias circuit",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "The crossover distortion in a transformer-coupled push-pull amplifier is caused by:",
-        "opt1": "The mismatch between the two output transistors",
-        "opt2": "The bias voltage being too high",
-        "opt3": "The load impedance being too low",
-        "opt4": "None of the above",
-        "correct_option": "The mismatch between the two output transistors",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull amplifier is usually:",
-        "opt1": "A step-up transformer",
-        "opt2": "A step-down transformer",
-        "opt3": "A transformer with a 1:1 turns ratio",
-        "opt4": "None of the above",
-        "correct_option": "A step-down transformer",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull amplifier, the output transistors are typically:",
-        "opt1": "Darlington transistors",
-        "opt2": "Complementary pair transistors",
-        "opt3": "MOSFETs",
-        "opt4": "None of the above",
-        "correct_option": "None of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull stage, two identical transistors are used with one conducting during the positive half-cycle of the input signal and the other conducting during the negative half-cycle. What is the main advantage of using two transistors in this configuration?",
-        "opt1": "Increased efficiency",
-        "opt2": "Increased voltage gain",
-        "opt3": "Reduced distortion",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following statements about the transformer-coupled push-pull stage is true?",
-        "opt1": "It is commonly used in audio power amplifiers",
-        "opt2": "It is a type of class A amplifier",
-        "opt3": "It requires a large amount of power for operation",
-        "opt4": "It has a low voltage gain",
-        "correct_option": "It is commonly used in audio power amplifiers",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull stage is used to:",
-        "opt1": "Increase the voltage gain of the amplifier",
-        "opt2": "Couple the output signal to the load",
-        "opt3": "Provide impedance matching between the amplifier and the load",
-        "opt4": "All of the above",
-        "correct_option": "Provide impedance matching between the amplifier and the load",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull stage, the transformer is typically wound with a center-tapped secondary winding. What is the purpose of the center tap?",
-        "opt1": "To provide a reference voltage for biasing the transistors",
-        "opt2": "To provide a means for adjusting the gain of the amplifier",
-        "opt3": "To provide a balanced load for the transistors",
-        "opt4": "None of the above",
-        "correct_option": "To provide a reference voltage for biasing the transistors",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The transformer-coupled push-pull stage is a type of:",
-        "opt1": "Class A amplifier",
-        "opt2": "Class B amplifier",
-        "opt3": "Class AB amplifier",
-        "opt4": "None of the above",
-        "correct_option": "Class B amplifier",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an advantage of using a transformer-coupled push-pull stage over a single-ended output stage?",
-        "opt1": "Higher efficiency",
-        "opt2": "Higher voltage gain",
-        "opt3": "Reduced distortion",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The output of a transformer-coupled push-pull stage is taken from:",
-        "opt1": "The collector of one transistor",
-        "opt2": "The center tap of the transformer secondary winding",
-        "opt3": "The collector of both transistors",
-        "opt4": "The primary winding of the transformer",
-        "correct_option": "The center tap of the transformer secondary winding",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main disadvantage of a transformer-coupled push-pull stage compared to other output stage configurations?",
-        "opt1": "Reduced efficiency",
-        "opt2": "Increased distortion",
-        "opt3": "Limited frequency response",
-        "opt4": "All of the above",
-        "correct_option": "Limited frequency response",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull stage should be designed with:",
-        "opt1": "High primary-to-secondary turns ratio",
-        "opt2": "Low primary-to-secondary turns ratio",
-        "opt3": "High frequency response",
-        "opt4": "Low leakage inductance",
-        "correct_option": "Low leakage inductance",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the main advantage of using a transformer in a push-pull output stage?",
-        "opt1": "Increased voltage gain",
-        "opt2": "Impedance matching to the load",
-        "opt3": "Reduced distortion",
-        "opt4": "Increased efficiency",
-        "correct_option": "Impedance matching to the load",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the basic function of a tuned amplifier?",
-        "opt1": "To provide high power amplification",
-        "opt2": "To provide high selectivity and gain",
-        "opt3": "To filter out unwanted signals",
-        "opt4": "To provide high frequency stability",
-        "correct_option": "To provide high selectivity and gain",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which type of resonant circuit is typically used in tuned amplifiers?",
-        "opt1": "RC circuits",
-        "opt2": "RL circuits",
-        "opt3": "LC circuits",
-        "opt4": "RLC circuits",
-        "correct_option": "LC circuits",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the Q factor of a resonant circuit?",
-        "opt1": "The frequency at which the circuit resonates",
-        "opt2": "The voltage gain of the circuit",
-        "opt3": "The energy stored in the circuit",
-        "opt4": "The ratio of energy stored in the circuit to energy lost per cycle",
-        "correct_option": "The ratio of energy stored in the circuit to energy lost per cycle",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the difference between a single tuned amplifier and a double tuned amplifier?",
-        "opt1": "A single tuned amplifier is more selective than a double tuned amplifier.",
-        "opt2": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two.",
-        "opt3": "A double tuned amplifier provides more gain than a single tuned amplifier.",
-        "opt4": "A double tuned amplifier uses a transformer to couple the resonant circuits.",
-        "correct_option": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two.",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which type of amplifier is commonly used in radio receivers and transmitters?",
-        "opt1": "Class A amplifier",
-        "opt2": "Class B amplifier",
-        "opt3": "Class AB amplifier",
-        "opt4": "Tuned amplifier",
-        "correct_option": "Tuned amplifier",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which electronic device can be used as the active element in a tuned amplifier?",
-        "opt1": "Capacitor",
-        "opt2": "Resistor",
-        "opt3": "Inductor",
-        "opt4": "Transistor",
-        "correct_option": "Transistor",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the function of the Q multiplier in a tuned amplifier?",
-        "opt1": "To provide additional gain at the center frequency of the circuit",
-        "opt2": "To increase the bandwidth of the circuit",
-        "opt3": "To improve the stability of the circuit",
-        "opt4": "To reduce distortion in the output signal",
-        "correct_option": "To provide additional gain at the center frequency of the circuit",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is a tuned amplifier?",
-        "opt1": "An amplifier with no selectivity or gain",
-        "opt2": "An amplifier that only works with specific types of signals",
-        "opt3": "An amplifier that uses tuned circuits to achieve high selectivity and gain",
-        "opt4": "An amplifier that is not commonly used in electronic applications",
-        "correct_option": "An amplifier that uses tuned circuits to achieve high selectivity and gain",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What type of resonant circuits are used in tuned amplifiers?",
-        "opt1": "RC circuits",
-        "opt2": "LC circuits",
-        "opt3": "RL circuits",
-        "opt4": "RLC circuits",
-        "correct_option": "LC circuits",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a key factor in determining the gain and selectivity of a tuned amplifier?",
-        "opt1": "The type of amplifier used",
-        "opt2": "The power supply voltage",
-        "opt3": "The Q factor of the resonant circuits",
-        "opt4": "The input signal frequency",
-        "correct_option": "The Q factor of the resonant circuits",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the difference between a single tuned amplifier and a double tuned amplifier?",
-        "opt1": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two resonant circuits.",
-        "opt2": "A single tuned amplifier is only used in audio applications, while a double tuned amplifier is only used in radio applications.",
-        "opt3": "A single tuned amplifier is less efficient than a double tuned amplifier.",
-        "opt4": "A single tuned amplifier has a lower Q factor than a double tuned amplifier.",
-        "correct_option": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two resonant circuits.",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Where are tuned amplifiers commonly used?",
-        "opt1": "In power supplies",
-        "opt2": "In digital circuits",
-        "opt3": "In radio receivers and transmitters",
-        "opt4": "In microcontrollers",
-        "correct_option": "In radio receivers and transmitters",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the Q factor of a resonant circuit?",
-        "opt1": "The amount of power dissipated in the circuit",
-        "opt2": "The amount of power supplied to the circuit",
-        "opt3": "The ratio of energy stored in the circuit to energy lost per cycle",
-        "opt4": "The ratio of energy lost in the circuit to energy stored per cycle",
-        "correct_option": "The ratio of energy stored in the circuit to energy lost per cycle",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of amplifying device can be used in tuned amplifiers?",
-        "opt1": "BJTs",
-        "opt2": "MOSFETs",
-        "opt3": "Vacuum tubes",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of a tuned amplifier in a radio receiver?",
-        "opt1": "To amplify all incoming signals equally",
-        "opt2": "To amplify only the desired signal while rejecting other signals",
-        "opt3": "To reduce the strength of the incoming signal",
-        "opt4": "To generate a new signal at a different frequency",
-        "correct_option": "To amplify only the desired signal while rejecting other signals",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main advantage of a double tuned amplifier over a single tuned amplifier?",
-        "opt1": "Higher efficiency",
-        "opt2": "Higher gain",
-        "opt3": "Higher selectivity",
-        "opt4": "Lower distortion",
-        "correct_option": "Higher selectivity",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of tuned amplifiers?",
-        "opt1": "They are expensive to produce.",
-        "opt2": "They are large in size.",
-        "opt3": "They can be difficult to tune and adjust.",
-        "opt4": "They are not capable of providing high gain.",
-        "correct_option": "They can be difficult to tune and adjust.",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What does op-amp stand for?",
-        "opt1": "Operational amplifier",
-        "opt2": "Optimal amplifier",
-        "opt3": "Organic amplifier",
-        "opt4": "Oscillating amplifier",
-        "correct_option": "Operational amplifier",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which configuration is most commonly used in op-amp circuits?",
-        "opt1": "Inverting amplifier",
-        "opt2": "Non-inverting amplifier",
-        "opt3": "Differential amplifier",
-        "opt4": "Voltage follower",
-        "correct_option": "Inverting amplifier",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the gain of an inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
-        "opt1": "-1",
-        "opt2": "-10",
-        "opt3": "10",
-        "opt4": "100",
-        "correct_option": "-10",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which parameter determines the maximum output voltage swing of an op-amp?",
-        "opt1": "Input offset voltage",
-        "opt2": "Gain-bandwidth product",
-        "opt3": "Slew rate",
-        "opt4": "Output saturation voltage",
-        "correct_option": "Output saturation voltage",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of a voltage follower op-amp circuit?",
-        "opt1": "To provide high gain",
-        "opt2": "To provide low gain",
-        "opt3": "To buffer a signal",
-        "opt4": "To invert a signal",
-        "correct_option": "To buffer a signal",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the transfer function of a non-inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
-        "opt1": "Vout = Vin",
-        "opt2": "Vout = -10Vin",
-        "opt3": "Vout = 10Vin",
-        "opt4": "Vout = (1 + 10kΩ/1kΩ)Vin",
-        "correct_option": "Vout = (1 + 10kΩ/1kΩ)Vin",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which op-amp parameter determines the rate at which the output can change in response to changes in the input?",
-        "opt1": "Input offset voltage",
-        "opt2": "Gain-bandwidth product",
-        "opt3": "Slew rate",
-        "opt4": "Input bias current",
-        "correct_option": "Slew rate",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the purpose of a differential amplifier?",
-        "opt1": "To amplify the difference between two input signals",
-        "opt2": "To amplify the sum of two input signals",
-        "opt3": "To invert a signal",
-        "opt4": "To provide a high-impedance input",
-        "correct_option": "To amplify the difference between two input signals",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which op-amp configuration is used to perform mathematical operations, such as addition and subtraction?",
-        "opt1": "Inverting amplifier",
-        "opt2": "Non-inverting amplifier",
-        "opt3": "Summing amplifier",
-        "opt4": "Differentiator",
-        "correct_option": "Summing amplifier",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a characteristic of an ideal operational amplifier?",
-        "opt1": "Infinite input impedance",
-        "opt2": "Infinite output impedance",
-        "opt3": "Infinite gain",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the output voltage of an inverting amplifier with an input voltage of 2 V and a feedback resistor of 10 kΩ, assuming an ideal op-amp?",
-        "opt1": "-2V",
-        "opt2": "-20 V",
-        "opt3": "2V",
-        "opt4": "20 V",
-        "correct_option": "-20 V",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is not a type of operational amplifier?",
-        "opt1": "Differential amplifier",
-        "opt2": "Inverting amplifier",
-        "opt3": "Non-inverting amplifier",
-        "opt4": "Power amplifier",
-        "correct_option": "Power amplifier",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the function of a summing amplifier?",
-        "opt1": "To amplify a single input signal",
-        "opt2": "To sum multiple input signals and provide an amplified output signal",
-        "opt3": "To provide an inverted output signal",
-        "opt4": "To provide a non-inverted output signal",
-        "correct_option": "To sum multiple input signals and provide an amplified output signal",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the output voltage of an inverting amplifier with a gain of -10 if the input voltage is 2V?",
-        "opt1": "-10V",
-        "opt2": "-20V",
-        "opt3": "10V",
-        "opt4": "20V",
-        "correct_option": "-20V",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the function of a voltage follower?",
-        "opt1": "To amplify a voltage",
-        "opt2": "To provide a high input impedance",
-        "opt3": "To provide a low output impedance",
-        "opt4": "To provide unity gain and high input and output impedances",
-        "correct_option": "To provide unity gain and high input and output impedances",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the advantage of using an op-amp as a comparator?",
-        "opt1": "It has a very high input impedance",
-        "opt2": "It has a very low output impedance",
-        "opt3": "It has a very high gain",
-        "opt4": "It has a very low bandwidth",
-        "correct_option": "It has a very high gain",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the function of a differentiator circuit?",
-        "opt1": "To differentiate the input signal with respect to time",
-        "opt2": "To integrate the input signal with respect to time",
-        "opt3": "To amplify the input signal",
-        "opt4": "To provide a DC offset to the input signal",
-        "correct_option": "To differentiate the input signal with respect to time",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the function of an integrator circuit?",
-        "opt1": "To differentiate the input signal with respect to time",
-        "opt2": "To integrate the input signal with respect to time",
-        "opt3": "To amplify the input signal",
-        "opt4": "To provide a DC offset to the input signal",
-        "correct_option": "To integrate the input signal with respect to time",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of using a non-inverting amplifier instead of an inverting amplifier?",
-        "opt1": "The input signal is not inverted",
-        "opt2": "The output impedance is lower",
-        "opt3": "The gain is higher",
-        "opt4": "The bandwidth is wider",
-        "correct_option": "The input signal is not inverted",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the function of a Schmitt trigger circuit?",
-        "opt1": "To amplify a signal",
-        "opt2": "To filter a signal",
-        "opt3": "To generate a square wave signal from a triangular wave signal",
-        "opt4": "To provide hysteresis to a signal",
-        "correct_option": "To provide hysteresis to a signal",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of biasing the Class AB output stage in amplifiers?",
-        "opt1": "To set the operating point of the amplifying devices",
-        "opt2": "To reduce distortion in the output signal",
-        "opt3": "To ensure that the amplifying devices operate in the active region of their characteristic curves",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is a common biasing technique for the Class AB output stage?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a voltage divider biasing network, where is the bias voltage set?",
-        "opt1": "At the base or gate of the amplifying device",
-        "opt2": "At the power supply voltage",
-        "opt3": "At ground",
-        "opt4": "None of the above",
-        "correct_option": "At the base or gate of the amplifying device",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "How does a diode biasing circuit work?",
-        "opt1": "By using a transistor configured as a voltage divider",
-        "opt2": "By connecting a diode in series with the base or gate of the amplifying device",
-        "opt3": "By using a voltage divider network",
-        "opt4": "None of the above",
-        "correct_option": "By connecting a diode in series with the base or gate of the amplifying device",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which biasing technique allows for fine-tuning of the operating point?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "None of the above",
-        "correct_option": "Voltage divider network",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the goal of biasing the Class AB stage?",
-        "opt1": "To maximize power efficiency",
-        "opt2": "To minimize power dissipation",
-        "opt3": "To ensure linear operation with low distortion",
-        "opt4": "None of the above",
-        "correct_option": "To ensure linear operation with low distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of amplifying device is typically used in a Class AB output stage?",
-        "opt1": "Bipolar junction transistor (BJT)",
-        "opt2": "Field-effect transistor (FET)",
-        "opt3": "Operational amplifier (Op-amp)",
-        "opt4": "None of the above",
-        "correct_option": "Bipolar junction transistor (BJT)",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which biasing technique uses a transistor configured as a voltage divider?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "None of the above",
-        "correct_option": "Transistor biasing",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Why is biasing necessary for Class AB amplifiers?",
-        "opt1": "To prevent the amplifying devices from saturating",
-        "opt2": "To ensure that the amplifying devices operate in the active region",
-        "opt3": "To decrease the gain of the amplifier",
-        "opt4": "None of the above",
-        "correct_option": "To ensure that the amplifying devices operate in the active region",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main advantage of using a Class AB output stage in amplifiers?",
-        "opt1": "High power efficiency",
-        "opt2": "Low power dissipation",
-        "opt3": "High linearity with low distortion",
-        "opt4": "None of the above",
-        "correct_option": "High linearity with low distortion",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the bias voltage typically set to in the Class AB output stage?",
-        "opt1": "The forward voltage drop of a diode",
-        "opt2": "The power supply voltage",
-        "opt3": "Zero volts",
-        "opt4": "The voltage across a capacitor",
-        "correct_option": "The forward voltage drop of a diode",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of using a diode biasing circuit?",
-        "opt1": "It is more complex than other biasing techniques",
-        "opt2": "It is less stable than other biasing techniques",
-        "opt3": "It requires more power to operate",
-        "opt4": "It is less accurate than other biasing techniques",
-        "correct_option": "It is less stable than other biasing techniques",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of using a transistor biasing circuit?",
-        "opt1": "To set the bias voltage",
-        "opt2": "To amplify the input signal",
-        "opt3": "To reduce distortion in the output signal",
-        "opt4": "To increase power efficiency",
-        "correct_option": "To set the bias voltage",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following biasing techniques is commonly used in Class AB amplifiers?",
-        "opt1": "Voltage divider network",
-        "opt2": "Diode biasing",
-        "opt3": "Transistor biasing",
-        "opt4": "All of the above",
-        "correct_option": "Diode biasing",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How does the choice of biasing technique affect the power efficiency of the amplifier?",
-        "opt1": "It has no effect on power efficiency",
-        "opt2": "It can increase power efficiency",
-        "opt3": "It can decrease power efficiency",
-        "opt4": "It can cause the amplifier to malfunction",
-        "correct_option": "It can decrease power efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the disadvantage of using an adjustable biasing network?",
-        "opt1": "It is less accurate than a fixed biasing network",
-        "opt2": "It is less stable than a fixed biasing network",
-        "opt3": "It is more complex than a fixed biasing network",
-        "opt4": "It is more expensive than a fixed biasing network",
-        "correct_option": "It is more complex than a fixed biasing network",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a key consideration when selecting a biasing technique for the Class AB output stage?",
-        "opt1": "Power efficiency",
-        "opt2": "Cost",
-        "opt3": "Stability",
-        "opt4": "Input impedance",
-        "correct_option": "Power efficiency",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the primary application of power BJTs in amplifier circuits?",
-        "opt1": "High frequency amplification",
-        "opt2": "Low noise amplification",
-        "opt3": "Power amplification",
-        "opt4": "Voltage amplification",
-        "correct_option": "Power amplification",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of power BJT is more commonly used in power amplifier circuits?",
-        "opt1": "PNP",
-        "opt2": "NPN",
-        "opt3": "Both are used equally",
-        "opt4": "None of the above",
-        "correct_option": "NPN",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the operating region of the power BJT?",
-        "opt1": "Saturation",
-        "opt2": "Cutoff",
-        "opt3": "Active",
-        "opt4": "Reverse breakdown",
-        "correct_option": "Active",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which configuration is most commonly used for low-power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class B",
-        "opt4": "Class C",
-        "correct_option": "Class A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the main advantage of power BJTs over small signal BJTs?",
-        "opt1": "Higher frequency response",
-        "opt2": "Lower noise",
-        "opt3": "Higher power handling capability",
-        "opt4": "Lower distortion",
-        "correct_option": "Higher power handling capability",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a common application of power BJTs?",
-        "opt1": "Voltage regulators",
-        "opt2": "Oscillators",
-        "opt3": "Audio amplifiers",
-        "opt4": "Digital circuits",
-        "correct_option": "Audio amplifiers",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the primary purpose of switching amplifiers?",
-        "opt1": "To increase power gain",
-        "opt2": "To reduce distortion",
-        "opt3": "To improve efficiency",
-        "opt4": "To increase frequency response",
-        "correct_option": "To improve efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of amplifier uses power MOSFETs to provide high efficiency?",
-        "opt1": "Class A",
-        "opt2": "Class B",
-        "opt3": "Class D",
-        "opt4": "Class AB",
-        "correct_option": "Class D",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is not a technique used to improve the efficiency of power amplifiers?",
-        "opt1": "Class G and H amplifiers",
-        "opt2": "Switching amplifiers",
-        "opt3": "Feedback amplifiers",
-        "opt4": "Class D amplifiers",
-        "correct_option": "Feedback amplifiers",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the main disadvantage of power BJTs in amplifier circuits?",
-        "opt1": "High distortion",
-        "opt2": "Low power handling capability",
-        "opt3": "Low frequency response",
-        "opt4": "High heat dissipation",
-        "correct_option": "High heat dissipation",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the primary function of power BJTs in amplifier circuits?",
-        "opt1": "To provide high voltage gain",
-        "opt2": "To provide low noise amplification",
-        "opt3": "To provide high power gain and efficiency",
-        "opt4": "To provide high frequency response",
-        "correct_option": "To provide high power gain and efficiency",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a commonly used configuration for power BJTs in low-power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class B",
-        "opt4": "Class C",
-        "correct_option": "Class A",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which type of power BJT is commonly used in power amplifier circuits?",
-        "opt1": "PNP",
-        "opt2": "NPN",
-        "opt3": "JFET",
-        "opt4": "MOSFET",
-        "correct_option": "NPN",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In which region of operation does the power BJT operate?",
-        "opt1": "Saturation region",
-        "opt2": "Cutoff region",
-        "opt3": "Active region",
-        "opt4": "Reverse-bias region",
-        "correct_option": "Active region",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a technique used to improve the efficiency of power amplifiers?",
-        "opt1": "Class A amplification",
-        "opt2": "Switching amplifiers",
-        "opt3": "Class AB amplification",
-        "opt4": "Linear amplifiers",
-        "correct_option": "Switching amplifiers",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an application of power BJTs?",
-        "opt1": "Audio amplifiers",
-        "opt2": "Radio receivers",
-        "opt3": "Logic gates",
-        "opt4": "Voltage regulators",
-        "correct_option": "Audio amplifiers",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the primary difference between small signal BJTs and power BJTs?",
-        "opt1": "Current gain",
-        "opt2": "Voltage gain",
-        "opt3": "Frequency response",
-        "opt4": "High power handling capability",
-        "correct_option": "High power handling capability",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which type of power BJT has a higher current gain?",
-        "opt1": "PNP",
-        "opt2": "NPN",
-        "opt3": "JFET",
-        "opt4": "MOSFET",
-        "correct_option": "NPN",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a benefit of using power BJTs in amplifier circuits?",
-        "opt1": "High frequency response",
-        "opt2": "Low power consumption",
-        "opt3": "Low distortion",
-        "opt4": "High power gain",
-        "correct_option": "High power gain",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following amplifier configurations is commonly used in high-power amplifiers?",
-        "opt1": "Class A",
-        "opt2": "Class AB",
-        "opt3": "Class B",
-        "opt4": "Class D",
-        "correct_option": "Class D",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull amplifier, the primary winding of the output transformer is connected to:",
-        "opt1": "The input signal",
-        "opt2": "The collector of the NPN transistor in the driver stage",
-        "opt3": "The base of the NPN transistor in the driver stage",
-        "opt4": "The collector of both transistors",
-        "correct_option": "The collector of both transistors",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull amplifier is used to:",
-        "opt1": "Provide impedance matching between the driver and output stages",
-        "opt2": "Amplify the signal",
-        "opt3": "Provide voltage gain",
-        "opt4": "Provide current gain",
-        "correct_option": "Provide impedance matching between the driver and output stages",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull amplifier, the two output transistors are biased so that they conduct:",
-        "opt1": "Simultaneously",
-        "opt2": "Randomly",
-        "opt3": "Alternately",
-        "opt4": "None of the above",
-        "correct_option": "Alternately",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is an advantage of a transformer-coupled push-pull amplifier?",
-        "opt1": "High efficiency",
-        "opt2": "Low distortion",
-        "opt3": "High gain",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The output of a transformer-coupled push-pull amplifier is taken from:",
-        "opt1": "The primary winding of the output transformer",
-        "opt2": "The secondary winding of the output transformer",
-        "opt3": "The center tap of the output transformer",
-        "opt4": "None of the above",
-        "correct_option": "The secondary winding of the output transformer",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "The load impedance in a transformer-coupled push-pull amplifier is:",
-        "opt1": "Always equal to the output impedance of the amplifier",
-        "opt2": "Always lower than the output impedance of the amplifier",
-        "opt3": "Always higher than the output impedance of the amplifier",
-        "opt4": "None of the above",
-        "correct_option": "Always equal to the output impedance of the amplifier",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The DC bias voltage for the output transistors in a transformer-coupled push-pull amplifier is provided by:",
-        "opt1": "The input signal",
-        "opt2": "The driver stage",
-        "opt3": "A separate bias circuit",
-        "opt4": "None of the above",
-        "correct_option": "A separate bias circuit",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "The crossover distortion in a transformer-coupled push-pull amplifier is caused by:",
-        "opt1": "The mismatch between the two output transistors",
-        "opt2": "The bias voltage being too high",
-        "opt3": "The load impedance being too low",
-        "opt4": "None of the above",
-        "correct_option": "The mismatch between the two output transistors",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull amplifier is usually:",
-        "opt1": "A step-up transformer",
-        "opt2": "A step-down transformer",
-        "opt3": "A transformer with a 1:1 turns ratio",
-        "opt4": "None of the above",
-        "correct_option": "A step-down transformer",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull amplifier, the output transistors are typically:",
-        "opt1": "Darlington transistors",
-        "opt2": "Complementary pair transistors",
-        "opt3": "MOSFETs",
-        "opt4": "None of the above",
-        "correct_option": "None of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull stage, two identical transistors are used with one conducting during the positive half-cycle of the input signal and the other conducting during the negative half-cycle. What is the main advantage of using two transistors in this configuration?",
-        "opt1": "Increased efficiency",
-        "opt2": "Increased voltage gain",
-        "opt3": "Reduced distortion",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following statements about the transformer-coupled push-pull stage is true?",
-        "opt1": "It is commonly used in audio power amplifiers",
-        "opt2": "It is a type of class A amplifier",
-        "opt3": "It requires a large amount of power for operation",
-        "opt4": "It has a low voltage gain",
-        "correct_option": "It is commonly used in audio power amplifiers",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull stage is used to:",
-        "opt1": "Increase the voltage gain of the amplifier",
-        "opt2": "Couple the output signal to the load",
-        "opt3": "Provide impedance matching between the amplifier and the load",
-        "opt4": "All of the above",
-        "correct_option": "Provide impedance matching between the amplifier and the load",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In a transformer-coupled push-pull stage, the transformer is typically wound with a center-tapped secondary winding. What is the purpose of the center tap?",
-        "opt1": "To provide a reference voltage for biasing the transistors",
-        "opt2": "To provide a means for adjusting the gain of the amplifier",
-        "opt3": "To provide a balanced load for the transistors",
-        "opt4": "None of the above",
-        "correct_option": "To provide a reference voltage for biasing the transistors",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "The transformer-coupled push-pull stage is a type of:",
-        "opt1": "Class A amplifier",
-        "opt2": "Class B amplifier",
-        "opt3": "Class AB amplifier",
-        "opt4": "None of the above",
-        "correct_option": "Class B amplifier",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an advantage of using a transformer-coupled push-pull stage over a single-ended output stage?",
-        "opt1": "Higher efficiency",
-        "opt2": "Higher voltage gain",
-        "opt3": "Reduced distortion",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "The output of a transformer-coupled push-pull stage is taken from:",
-        "opt1": "The collector of one transistor",
-        "opt2": "The center tap of the transformer secondary winding",
-        "opt3": "The collector of both transistors",
-        "opt4": "The primary winding of the transformer",
-        "correct_option": "The center tap of the transformer secondary winding",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main disadvantage of a transformer-coupled push-pull stage compared to other output stage configurations?",
-        "opt1": "Reduced efficiency",
-        "opt2": "Increased distortion",
-        "opt3": "Limited frequency response",
-        "opt4": "All of the above",
-        "correct_option": "Limited frequency response",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "The transformer in a transformer-coupled push-pull stage should be designed with:",
-        "opt1": "High primary-to-secondary turns ratio",
-        "opt2": "Low primary-to-secondary turns ratio",
-        "opt3": "High frequency response",
-        "opt4": "Low leakage inductance",
-        "correct_option": "Low leakage inductance",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the main advantage of using a transformer in a push-pull output stage?",
-        "opt1": "Increased voltage gain",
-        "opt2": "Impedance matching to the load",
-        "opt3": "Reduced distortion",
-        "opt4": "Increased efficiency",
-        "correct_option": "Impedance matching to the load",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the basic function of a tuned amplifier?",
-        "opt1": "To provide high power amplification",
-        "opt2": "To provide high selectivity and gain",
-        "opt3": "To filter out unwanted signals",
-        "opt4": "To provide high frequency stability",
-        "correct_option": "To provide high selectivity and gain",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which type of resonant circuit is typically used in tuned amplifiers?",
-        "opt1": "RC circuits",
-        "opt2": "RL circuits",
-        "opt3": "LC circuits",
-        "opt4": "RLC circuits",
-        "correct_option": "LC circuits",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the Q factor of a resonant circuit?",
-        "opt1": "The frequency at which the circuit resonates",
-        "opt2": "The voltage gain of the circuit",
-        "opt3": "The energy stored in the circuit",
-        "opt4": "The ratio of energy stored in the circuit to energy lost per cycle",
-        "correct_option": "The ratio of energy stored in the circuit to energy lost per cycle",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the difference between a single tuned amplifier and a double tuned amplifier?",
-        "opt1": "A single tuned amplifier is more selective than a double tuned amplifier.",
-        "opt2": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two.",
-        "opt3": "A double tuned amplifier provides more gain than a single tuned amplifier.",
-        "opt4": "A double tuned amplifier uses a transformer to couple the resonant circuits.",
-        "correct_option": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two.",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which type of amplifier is commonly used in radio receivers and transmitters?",
-        "opt1": "Class A amplifier",
-        "opt2": "Class B amplifier",
-        "opt3": "Class AB amplifier",
-        "opt4": "Tuned amplifier",
-        "correct_option": "Tuned amplifier",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which electronic device can be used as the active element in a tuned amplifier?",
-        "opt1": "Capacitor",
-        "opt2": "Resistor",
-        "opt3": "Inductor",
-        "opt4": "Transistor",
-        "correct_option": "Transistor",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the function of the Q multiplier in a tuned amplifier?",
-        "opt1": "To provide additional gain at the center frequency of the circuit",
-        "opt2": "To increase the bandwidth of the circuit",
-        "opt3": "To improve the stability of the circuit",
-        "opt4": "To reduce distortion in the output signal",
-        "correct_option": "To provide additional gain at the center frequency of the circuit",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is a tuned amplifier?",
-        "opt1": "An amplifier with no selectivity or gain",
-        "opt2": "An amplifier that only works with specific types of signals",
-        "opt3": "An amplifier that uses tuned circuits to achieve high selectivity and gain",
-        "opt4": "An amplifier that is not commonly used in electronic applications",
-        "correct_option": "An amplifier that uses tuned circuits to achieve high selectivity and gain",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What type of resonant circuits are used in tuned amplifiers?",
-        "opt1": "RC circuits",
-        "opt2": "LC circuits",
-        "opt3": "RL circuits",
-        "opt4": "RLC circuits",
-        "correct_option": "LC circuits",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a key factor in determining the gain and selectivity of a tuned amplifier?",
-        "opt1": "The type of amplifier used",
-        "opt2": "The power supply voltage",
-        "opt3": "The Q factor of the resonant circuits",
-        "opt4": "The input signal frequency",
-        "correct_option": "The Q factor of the resonant circuits",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the difference between a single tuned amplifier and a double tuned amplifier?",
-        "opt1": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two resonant circuits.",
-        "opt2": "A single tuned amplifier is only used in audio applications, while a double tuned amplifier is only used in radio applications.",
-        "opt3": "A single tuned amplifier is less efficient than a double tuned amplifier.",
-        "opt4": "A single tuned amplifier has a lower Q factor than a double tuned amplifier.",
-        "correct_option": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two resonant circuits.",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Where are tuned amplifiers commonly used?",
-        "opt1": "In power supplies",
-        "opt2": "In digital circuits",
-        "opt3": "In radio receivers and transmitters",
-        "opt4": "In microcontrollers",
-        "correct_option": "In radio receivers and transmitters",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the Q factor of a resonant circuit?",
-        "opt1": "The amount of power dissipated in the circuit",
-        "opt2": "The amount of power supplied to the circuit",
-        "opt3": "The ratio of energy stored in the circuit to energy lost per cycle",
-        "opt4": "The ratio of energy lost in the circuit to energy stored per cycle",
-        "correct_option": "The ratio of energy stored in the circuit to energy lost per cycle",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of amplifying device can be used in tuned amplifiers?",
-        "opt1": "BJTs",
-        "opt2": "MOSFETs",
-        "opt3": "Vacuum tubes",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of a tuned amplifier in a radio receiver?",
-        "opt1": "To amplify all incoming signals equally",
-        "opt2": "To amplify only the desired signal while rejecting other signals",
-        "opt3": "To reduce the strength of the incoming signal",
-        "opt4": "To generate a new signal at a different frequency",
-        "correct_option": "To amplify only the desired signal while rejecting other signals",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the main advantage of a double tuned amplifier over a single tuned amplifier?",
-        "opt1": "Higher efficiency",
-        "opt2": "Higher gain",
-        "opt3": "Higher selectivity",
-        "opt4": "Lower distortion",
-        "correct_option": "Higher selectivity",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of tuned amplifiers?",
-        "opt1": "They are expensive to produce.",
-        "opt2": "They are large in size.",
-        "opt3": "They can be difficult to tune and adjust.",
-        "opt4": "They are not capable of providing high gain.",
-        "correct_option": "They can be difficult to tune and adjust.",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What does op-amp stand for?",
-        "opt1": "Operational amplifier",
-        "opt2": "Optimal amplifier",
-        "opt3": "Organic amplifier",
-        "opt4": "Oscillating amplifier",
-        "correct_option": "Operational amplifier",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which configuration is most commonly used in op-amp circuits?",
-        "opt1": "Inverting amplifier",
-        "opt2": "Non-inverting amplifier",
-        "opt3": "Differential amplifier",
-        "opt4": "Voltage follower",
-        "correct_option": "Inverting amplifier",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the gain of an inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
-        "opt1": "-1",
-        "opt2": "-10",
-        "opt3": "10",
-        "opt4": "100",
-        "correct_option": "-10",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which parameter determines the maximum output voltage swing of an op-amp?",
-        "opt1": "Input offset voltage",
-        "opt2": "Gain-bandwidth product",
-        "opt3": "Slew rate",
-        "opt4": "Output saturation voltage",
-        "correct_option": "Output saturation voltage",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of a voltage follower op-amp circuit?",
-        "opt1": "To provide high gain",
-        "opt2": "To provide low gain",
-        "opt3": "To buffer a signal",
-        "opt4": "To invert a signal",
-        "correct_option": "To buffer a signal",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the transfer function of a non-inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
-        "opt1": "Vout = Vin",
-        "opt2": "Vout = -10Vin",
-        "opt3": "Vout = 10Vin",
-        "opt4": "Vout = (1 + 10kΩ/1kΩ)Vin",
-        "correct_option": "Vout = (1 + 10kΩ/1kΩ)Vin",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which op-amp parameter determines the rate at which the output can change in response to changes in the input?",
-        "opt1": "Input offset voltage",
-        "opt2": "Gain-bandwidth product",
-        "opt3": "Slew rate",
-        "opt4": "Input bias current",
-        "correct_option": "Slew rate",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the purpose of a differential amplifier?",
-        "opt1": "To amplify the difference between two input signals",
-        "opt2": "To amplify the sum of two input signals",
-        "opt3": "To invert a signal",
-        "opt4": "To provide a high-impedance input",
-        "correct_option": "To amplify the difference between two input signals",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which op-amp configuration is used to perform mathematical operations, such as addition and subtraction?",
-        "opt1": "Inverting amplifier",
-        "opt2": "Non-inverting amplifier",
-        "opt3": "Summing amplifier",
-        "opt4": "Differentiator",
-        "correct_option": "Summing amplifier",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a characteristic of an ideal operational amplifier?",
-        "opt1": "Infinite input impedance",
-        "opt2": "Infinite output impedance",
-        "opt3": "Infinite gain",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the output voltage of an inverting amplifier with an input voltage of 2 V and a feedback resistor of 10 kΩ, assuming an ideal op-amp?",
-        "opt1": "-2V",
-        "opt2": "-20 V",
-        "opt3": "2V",
-        "opt4": "20 V",
-        "correct_option": "-20 V",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is not a type of operational amplifier?",
-        "opt1": "Differential amplifier",
-        "opt2": "Inverting amplifier",
-        "opt3": "Non-inverting amplifier",
-        "opt4": "Power amplifier",
-        "correct_option": "Power amplifier",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the function of a summing amplifier?",
-        "opt1": "To amplify a single input signal",
-        "opt2": "To sum multiple input signals and provide an amplified output signal",
-        "opt3": "To provide an inverted output signal",
-        "opt4": "To provide a non-inverted output signal",
-        "correct_option": "To sum multiple input signals and provide an amplified output signal",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the output voltage of an inverting amplifier with a gain of -10 if the input voltage is 2V?",
-        "opt1": "-10V",
-        "opt2": "-20V",
-        "opt3": "10V",
-        "opt4": "20V",
-        "correct_option": "-20V",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the function of a voltage follower?",
-        "opt1": "To amplify a voltage",
-        "opt2": "To provide a high input impedance",
-        "opt3": "To provide a low output impedance",
-        "opt4": "To provide unity gain and high input and output impedances",
-        "correct_option": "To provide unity gain and high input and output impedances",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the advantage of using an op-amp as a comparator?",
-        "opt1": "It has a very high input impedance",
-        "opt2": "It has a very low output impedance",
-        "opt3": "It has a very high gain",
-        "opt4": "It has a very low bandwidth",
-        "correct_option": "It has a very high gain",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the function of a differentiator circuit?",
-        "opt1": "To differentiate the input signal with respect to time",
-        "opt2": "To integrate the input signal with respect to time",
-        "opt3": "To amplify the input signal",
-        "opt4": "To provide a DC offset to the input signal",
-        "correct_option": "To differentiate the input signal with respect to time",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the function of an integrator circuit?",
-        "opt1": "To differentiate the input signal with respect to time",
-        "opt2": "To integrate the input signal with respect to time",
-        "opt3": "To amplify the input signal",
-        "opt4": "To provide a DC offset to the input signal",
-        "correct_option": "To integrate the input signal with respect to time",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of using a non-inverting amplifier instead of an inverting amplifier?",
-        "opt1": "The input signal is not inverted",
-        "opt2": "The output impedance is lower",
-        "opt3": "The gain is higher",
-        "opt4": "The bandwidth is wider",
-        "correct_option": "The input signal is not inverted",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the function of a Schmitt trigger circuit?",
-        "opt1": "To amplify a signal",
-        "opt2": "To filter a signal",
-        "opt3": "To generate a square wave signal from a triangular wave signal",
-        "opt4": "To provide hysteresis to a signal",
-        "correct_option": "To provide hysteresis to a signal",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the output of a binary decoder if the input code is all zeros?",
-        "opt1": "The first output line will be selected",
-        "opt2": "The last output line will be selected",
-        "opt3": "No output lines will be selected",
-        "opt4": "None of the above",
-        "correct_option": "The first output line will be selected",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which type of decoder is commonly used in digital clocks and calculators?",
-        "opt1": "Binary decoder",
-        "opt2": "BCD decoder",
-        "opt3": "Priority decoder",
-        "opt4": "None of the above",
-        "correct_option": "BCD decoder",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an advantage of a decoder?",
-        "opt1": "It can be used to convert any type of code into an output signal",
-        "opt2": "It is easy to implement and use",
-        "opt3": "It can be used in sequential circuits",
-        "opt4": "None of the above",
-        "correct_option": "It is easy to implement and use",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of an encoder?",
-        "opt1": "To convert an input signal into a coded output signal",
-        "opt2": "To store and retrieve digital data",
-        "opt3": "To perform arithmetic and logical operations on binary data",
-        "opt4": "To generate an output based on the input and the previous state",
-        "correct_option": "To convert an input signal into a coded output signal",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the difference between a binary encoder and a priority encoder?",
-        "opt1": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
-        "opt2": "A binary encoder generates a binary code corresponding to the highest priority input signal, while a priority encoder converts a binary input signal into an n-bit coded output signal.",
-        "opt3": "A binary encoder and a priority encoder are the same thing.",
-        "opt4": "A binary encoder and a priority encoder have no difference.",
-        "correct_option": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the advantage of using a priority encoder?",
-        "opt1": "It simplifies the design of complex digital circuits",
-        "opt2": "It reduces the number of input lines required",
-        "opt3": "It increases the speed of data processing",
-        "opt4": "All of the above",
-        "correct_option": "It simplifies the design of complex digital circuits",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is NOT a type of encoder?",
-        "opt1": "Binary encoder",
-        "opt2": "Priority encoder",
-        "opt3": "BCD encoder",
-        "opt4": "Multiplexer",
-        "correct_option": "Multiplexer",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of an encoder in digital logic?",
-        "opt1": "To convert a binary input signal into an n-bit coded output signal",
-        "opt2": "To generate a binary code corresponding to the highest priority input signal",
-        "opt3": "To convert a decimal input signal into a 4-bit BCD output signal",
-        "opt4": "To perform arithmetic operations on binary numbers",
-        "correct_option": "To convert a binary input signal into an n-bit coded output signal",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "How many input lines and output lines does a binary encoder have?",
-        "opt1": "n input lines and m output lines",
-        "opt2": "2^n input lines and n output lines",
-        "opt3": "n input lines and log2n output lines",
-        "opt4": "10 input lines and 4 output lines",
-        "correct_option": "2^n input lines and n output lines",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of a priority encoder in digital logic?",
-        "opt1": "To convert a binary input signal into an n-bit coded output signal",
-        "opt2": "To generate a binary code corresponding to the highest priority input signal",
-        "opt3": "To convert a decimal input signal into a 4-bit BCD output signal",
-        "opt4": "To perform arithmetic operations on binary numbers",
-        "correct_option": "To generate a binary code corresponding to the highest priority input signal",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How many input lines and output lines does a priority encoder have?",
-        "opt1": "n input lines and m output lines",
-        "opt2": "2^n input lines and n output lines",
-        "opt3": "n input lines and log2n output lines",
-        "opt4": "10 input lines and 4 output lines",
-        "correct_option": "n input lines and log2n output lines",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the purpose of a BCD encoder in digital logic?",
-        "opt1": "To convert a binary input signal into an n-bit coded output signal",
-        "opt2": "To generate a binary code corresponding to the highest priority input signal",
-        "opt3": "To convert a decimal input signal into a 4-bit BCD output signal",
-        "opt4": "To perform arithmetic operations on binary numbers",
-        "correct_option": "To convert a decimal input signal into a 4-bit BCD output signal",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "How many input lines and output lines does a BCD encoder have?",
-        "opt1": "n input lines and m output lines",
-        "opt2": "2^n input lines and n output lines",
-        "opt3": "n input lines and log2n output lines",
-        "opt4": "10 input lines and 4 output lines",
-        "correct_option": "10 input lines and 4 output lines",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the difference between a binary encoder and a priority encoder?",
-        "opt1": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
-        "opt2": "A binary encoder generates a binary code corresponding to the highest priority input signal, while a priority encoder converts a binary input signal into an n-bit coded output signal.",
-        "opt3": "A binary encoder converts a decimal input signal into a 4-bit BCD output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
-        "opt4": "A binary encoder has 2^n input lines and n output lines, while a priority encoder has n input lines and log2n output lines.",
-        "correct_option": "A binary encoder has 2^n input lines and n output lines, while a priority encoder has n input lines and log2n output lines.",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of using an encoder in data communication?",
-        "opt1": "To convert analog signals into digital signals",
-        "opt2": "To compress digital signals for efficient transmission",
-        "opt3": "To encrypt digital signals for secure transmission",
-        "opt4": "To convert digital signals into a coded output signal for transmission",
-        "correct_option": "To convert digital signals into a coded output signal for transmission",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of using a BCD encoder in digital signal processing?",
-        "opt1": "To convert a binary input signal into an n-bit coded output signal",
-        "opt2": "To generate a binary code corresponding to the highest priority input signal",
-        "opt3": "To convert a decimal input signal into a 4-bit BCD output signal",
-        "opt4": "To perform arithmetic operations on binary numbers",
-        "correct_option": "To convert a decimal input signal into a 4-bit BCD output signal",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the result of binary addition of 0110 and 0101?",
-        "opt1": "1101",
-        "opt2": "1111",
-        "opt3": "1011",
-        "opt4": "0011",
-        "correct_option": "1011",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is the correct binary addition of 1111 and 0011?",
-        "opt1": "11010",
-        "opt2": "10010",
-        "opt3": "10100",
-        "opt4": "10000",
-        "correct_option": "10010",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the binary addition of 10101 and 11111?",
-        "opt1": "110010",
-        "opt2": "110111",
-        "opt3": "110110",
-        "opt4": "100010",
-        "correct_option": "110100",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the binary addition of 1101 and 0110?",
-        "opt1": "1110",
-        "opt2": "10010",
-        "opt3": "10011",
-        "opt4": "1100",
-        "correct_option": "10011",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following represents the correct binary addition of 1010 and 0110?",
-        "opt1": "1000",
-        "opt2": "1011",
-        "opt3": "10000",
-        "opt4": "11111",
-        "correct_option": "10000",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the result of binary addition of 11111 and 00001?",
-        "opt1": "11110",
-        "opt2": "100000",
-        "opt3": "10000",
-        "opt4": "11111",
-        "correct_option": "100000",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following represents the correct binary addition of 111 and 101?",
-        "opt1": "1100",
-        "opt2": "1010",
-        "opt3": "1111",
-        "opt4": "1001",
-        "correct_option": "1100",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the result of binary addition of 0101 and 0010?",
-        "opt1": "0111",
-        "opt2": "1000",
-        "opt3": "1011",
-        "opt4": "1001",
-        "correct_option": "0111",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the binary sum of 1011 and 1101?",
-        "opt1": "10011",
-        "opt2": "10101",
-        "opt3": "0110",
-        "opt4": "0100",
-        "correct_option": "11000",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the binary sum of 1110 and 0111?",
-        "opt1": "10001",
-        "opt2": "10101",
-        "opt3": "1110",
-        "opt4": "100110",
-        "correct_option": "10101",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the binary sum of 10101010 and 11001100?",
-        "opt1": "10111111",
-        "opt2": "10110110",
-        "opt3": "1101-",
-        "opt4": "0100",
-        "correct_option": "101110110",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the binary sum of 11111111 and 00000001?",
-        "opt1": "11111110",
-        "opt2": "11111111",
-        "opt3": "10100100",
-        "opt4": "100000000",
-        "correct_option": "100000000",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following represents the correct binary addition of 1101 and 0011?",
-        "opt1": "1111",
-        "opt2": "1010",
-        "opt3": "10011100",
-        "opt4": "00000010",
-        "correct_option": "10000",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the binary addition of 1010 and 1101?",
-        "opt1": "1000",
-        "opt2": "1111",
-        "opt3": "10111",
-        "opt4": "00000000",
-        "correct_option": "10111",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the carry generated when adding 1101 and 1011?",
-        "opt1": "1",
-        "opt2": "0",
-        "opt3": "2",
-        "opt4": "3",
-        "correct_option": "1",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the binary sum of 111 and 101?",
-        "opt1": "1011",
-        "opt2": "1110",
-        "opt3": "110",
-        "opt4": "1001",
-        "correct_option": "1100",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the result of adding 1011 and 1110 using a full adder circuit?",
-        "opt1": "1101",
-        "opt2": "10000",
-        "opt3": "11001",
-        "opt4": "1010",
-        "correct_option": "11001",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the binary sum of 1111 and 0111 using a half adder circuit?",
-        "opt1": "1110",
-        "opt2": "1101",
-        "opt3": "1000",
-        "opt4": "10110",
-        "correct_option": "10110",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the result of adding 1011 and 1100 using a carry look-ahead adder (CLA) circuit?",
-        "opt1": "1101",
-        "opt2": "10100",
-        "opt3": "10111",
-        "opt4": "10011",
-        "correct_option": "10111",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the binary sum of 1001 and 0110?",
-        "opt1": "1011",
-        "opt2": "1110",
-        "opt3": "1111",
-        "opt4": "0011",
-        "correct_option": "1111",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the complement of the binary number 1111?",
-        "opt1": "1110",
-        "opt2": "0000",
-        "opt3": "0001",
-        "opt4": "1000",
-        "correct_option": "0000",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the complement of the binary number 0011?",
-        "opt1": "0010",
-        "opt2": "1101",
-        "opt3": "1100",
-        "opt4": "0100",
-        "correct_option": "1100",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the result of subtracting the binary number 0110 from the binary number 1011?",
-        "opt1": "1001",
-        "opt2": "0101",
-        "opt3": "0010",
-        "opt4": "1101",
-        "correct_option": "0101",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the complement of the binary number 0001?",
-        "opt1": "0000",
-        "opt2": "1110",
-        "opt3": "1111",
-        "opt4": "0010",
-        "correct_option": "1110",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the result of subtracting the binary number 1101 from the binary number 1110?",
-        "opt1": "0000",
-        "opt2": "0001",
-        "opt3": "0011",
-        "opt4": "0111",
-        "correct_option": "0001",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the complement of the binary number 0101?",
-        "opt1": "0100",
-        "opt2": "1010",
-        "opt3": "1011",
-        "opt4": "1001",
-        "correct_option": "1010",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the result of subtracting the binary number 0010 from the binary number 1111?",
-        "opt1": "0101",
-        "opt2": "1101",
-        "opt3": "0110",
-        "opt4": "1011",
-        "correct_option": "1101",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the complement of the binary number 1000?",
-        "opt1": "0111",
-        "opt2": "1011",
-        "opt3": "1001",
-        "opt4": "1001",
-        "correct_option": "0111",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the first step in binary subtraction?",
-        "opt1": "Find the complement of the minuend",
-        "opt2": "Invert all the bits of the minuend",
-        "opt3": "Find the complement of the subtrahend",
-        "opt4": "Invert all the bits of the subtrahend",
-        "correct_option": "Find the complement of the subtrahend",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the complement of the binary number 1011?",
-        "opt1": "1100",
-        "opt2": "0100",
-        "opt3": "1000",
-        "opt4": "0001",
-        "correct_option": "0100",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the binary equivalent of the decimal value 7?",
-        "opt1": "110",
-        "opt2": "101",
-        "opt3": "111",
-        "opt4": "1110",
-        "correct_option": "111",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the result of subtracting the binary number 1101 from the binary number 1111?",
-        "opt1": "0010",
-        "opt2": "0100",
-        "opt3": "0001",
-        "opt4": "1110",
-        "correct_option": "0010",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the second step in binary subtraction?",
-        "opt1": "Find the complement of the subtrahend",
-        "opt2": "Invert all the bits of the subtrahend",
-        "opt3": "Find the complement of the minuend",
-        "opt4": "Invert all the bits of the minuend",
-        "correct_option": "Invert all the bits of the subtrahend",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the binary equivalent of the decimal value 10?",
-        "opt1": "1010",
-        "opt2": "1100",
-        "opt3": "1110",
-        "opt4": "1001",
-        "correct_option": "1010",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the complement of the binary number 1001?",
-        "opt1": "0110",
-        "opt2": "0111",
-        "opt3": "1010",
-        "opt4": "1011",
-        "correct_option": "0110",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the result of subtracting the binary number 1111 from the binary number 1111?",
-        "opt1": "1111",
-        "opt2": "0000",
-        "opt3": "1110",
-        "opt4": "0001",
-        "correct_option": "0000",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the third step in binary subtraction?",
-        "opt1": "Add the complement to the minuend using binary subtraction",
-        "opt2": "Add the complement to the minuend using binary addition",
-        "opt3": "Subtract the complement from the minuend using binary subtraction",
-        "opt4": "Subtract the complement from the minuend using binary addition",
-        "correct_option": "Add the complement to the minuend using binary addition",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the binary equivalent of the decimal value 13?",
-        "opt1": "1011",
-        "opt2": "1101",
-        "opt3": "1110",
-        "opt4": "1001",
-        "correct_option": "1101",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the difference between unsigned and signed binary numbers?",
-        "opt1": "Unsigned binary numbers have a signed bit while signed binary numbers do not.",
-        "opt2": "Unsigned binary numbers can represent only positive numbers while signed binary numbers can represent both positive and negative numbers.",
-        "opt3": "Unsigned binary numbers use a different base than signed binary numbers.",
-        "opt4": "There is no difference between unsigned and signed binary numbers.",
-        "correct_option": "Unsigned binary numbers can represent only positive numbers while signed binary numbers can represent both positive and negative numbers.",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is the most significant bit in an 8-bit signed binary number?",
-        "opt1": "Bit 0",
-        "opt2": "Bit 1",
-        "opt3": "Bit 7",
-        "opt4": "There is no most significant bit",
-        "correct_option": "Bit 7",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the range of 8-bit signed binary numbers?",
-        "opt1": "0 to 255",
-        "opt2": "-128 to 127",
-        "opt3": "-127 to 127",
-        "opt4": "0 to 127",
-        "correct_option": "-128 to 127",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the range of unsigned 8-bit binary numbers?",
-        "opt1": "0 to 127",
-        "opt2": "-128 to 127",
-        "opt3": "-127 to 127",
-        "opt4": "0 to 255",
-        "correct_option": "0 to 255",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following operations can be performed on signed binary numbers but not on unsigned binary numbers?",
-        "opt1": "Addition",
-        "opt2": "Subtraction",
-        "opt3": "Multiplication",
-        "opt4": "Division",
-        "correct_option": "Subtraction",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following operations can be performed on unsigned binary numbers?",
-        "opt1": "Only addition",
-        "opt2": "Addition and subtraction",
-        "opt3": "Multiplication and division",
-        "opt4": "Only subtraction",
-        "correct_option": "Addition and subtraction",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is the correct representation of the unsigned binary number 1011 in decimal?",
-        "opt1": "10",
-        "opt2": "11",
-        "opt3": "12",
-        "opt4": "9",
-        "correct_option": "11",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the range of unsigned 8-bit binary numbers?",
-        "opt1": "-128 to 127",
-        "opt2": "0 to 256",
-        "opt3": "0 to 127",
-        "opt4": "0 to 128",
-        "correct_option": "0 to 255",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is the correct representation of the signed binary number 11111111 in decimal using two's complement?",
-        "opt1": "-127",
-        "opt2": "-128",
-        "opt3": "127",
-        "opt4": "-1",
-        "correct_option": "-1",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the range of signed 8-bit binary numbers using two's complement?",
-        "opt1": "-127 to 128",
-        "opt2": "-128 to 127",
-        "opt3": "-256 to 255",
-        "opt4": "-255 to 256",
-        "correct_option": "-128 to 127",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following operations can be performed on signed binary numbers using two's complement?",
-        "opt1": "Only addition",
-        "opt2": "Addition and subtraction",
-        "opt3": "Multiplication and division",
-        "opt4": "Only subtraction",
-        "correct_option": "Addition and subtraction",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the result of adding the signed binary numbers 0111 and 1010 using two's complement?",
-        "opt1": "0001",
-        "opt2": "1101",
-        "opt3": "1111",
-        "opt4": "1001",
-        "correct_option": "0001",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the result of subtracting the signed binary numbers 1010 and 0111 using two's complement?",
-        "opt1": "0001",
-        "opt2": "1101",
-        "opt3": "1001",
-        "opt4": "1111",
-        "correct_option": "0011",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is the correct representation of the signed binary number 11111000 in decimal using two's complement?",
-        "opt1": "-8",
-        "opt2": "-24",
-        "opt3": "8",
-        "opt4": "24",
-        "correct_option": "-8",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the complement of the binary number 1010?",
-        "opt1": "0100",
-        "opt2": "0010",
-        "opt3": "1001",
-        "opt4": "0110",
-        "correct_option": "0101",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the result of adding the signed binary numbers 0110 and 1011?",
-        "opt1": "1101",
-        "opt2": "1001",
-        "opt3": "0001",
-        "opt4": "0010",
-        "correct_option": "0001",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is the two's complement of the binary number 1101?",
-        "opt1": "0010",
-        "opt2": "0011",
-        "opt3": "0101",
-        "opt4": "0110",
-        "correct_option": "0011",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the result of multiplying the unsigned binary numbers 1010 and 0011?",
-        "opt1": "0010",
-        "opt2": "0110",
-        "opt3": "1110",
-        "opt4": "1011",
-        "correct_option": "11110",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the result of subtracting the signed binary number 0101 from the signed binary number 1010?",
-        "opt1": "1101",
-        "opt2": "1001",
-        "opt3": "0101",
-        "opt4": "0011",
-        "correct_option": "0101",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is the sign bit in an 8-bit signed binary number?",
-        "opt1": "Bit 0",
-        "opt2": "Bit 1",
-        "opt3": "Bit 7",
-        "opt4": "There is no sign bit",
-        "correct_option": "Bit 7",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following describes an asynchronous counter?",
-        "opt1": "A counter that uses external clock pulses to advance its count",
-        "opt2": "A counter that uses feedback to generate its own clock pulses",
-        "opt3": "A counter that counts in parallel",
-        "opt4": "A counter that counts in series",
-        "correct_option": "A counter that uses external clock pulses to advance its count",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which type of asynchronous counter is also known as a ripple counter?",
-        "opt1": "Synchronous counter",
-        "opt2": "Binary counter",
-        "opt3": "Johnson counter",
-        "opt4": "Modulus counter",
-        "correct_option": "Binary counter",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "How many flip-flops are needed to implement a 3-bit asynchronous counter?",
-        "opt1": "2",
-        "opt2": "3",
-        "opt3": "4",
-        "opt4": "5",
-        "correct_option": "3",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the maximum number of states a 4-bit asynchronous counter can have?",
-        "opt1": "4",
-        "opt2": "8",
-        "opt3": "12",
-        "opt4": "16",
-        "correct_option": "16",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In an asynchronous counter, which flip-flop receives the external clock signal?",
-        "opt1": "The first flip-flop",
-        "opt2": "The last flip-flop",
-        "opt3": "All flip-flops receive the external clock signal",
-        "opt4": "None of the flip-flops receive the external clock signal",
-        "correct_option": "The first flip-flop",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is an advantage of asynchronous counters over synchronous counters?",
-        "opt1": "Asynchronous counters are faster",
-        "opt2": "Asynchronous counters are more reliable",
-        "opt3": "Asynchronous counters require fewer components",
-        "opt4": "Asynchronous counters are easier to design",
-        "correct_option": "Asynchronous counters require fewer components",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In a 3-bit asynchronous counter, what is the maximum count sequence that can be generated?",
-        "opt1": "0,1,2,3,4,5,6,7",
-        "opt2": "0,1,2,3,2,1,0",
-        "opt3": "0,1,2, 1.0, 1.2,1.D",
-        "opt4": "0, 1, 0, 1 0, 1, 0, 1",
-        "correct_option": "0,1,2,3,4,5,6,7",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which type of asynchronous counter uses a series of D flip-flops?",
-        "opt1": "Binary counter",
-        "opt2": "Ripple counter",
-        "opt3": "Johnson counter",
-        "opt4": "Modulus counter",
-        "correct_option": "Johnson counter",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "In a Johnson counter, how many states are there for n flip-flops?",
-        "opt1": "2n",
-        "opt2": "n",
-        "opt3": "n/2",
-        "opt4": "2^n-1",
-        "correct_option": "2n",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the main disadvantage of asynchronous counters?",
-        "opt1": "They are slower than synchronous counters",
-        "opt2": "They suffer from glitches in the output waveform",
-        "opt3": "They are more complex to design than synchronous counters",
-        "opt4": "They are not suitable for use in digital circuits",
-        "correct_option": "They are slower than synchronous counters",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is an asynchronous counter?",
-        "opt1": "A counter that uses asynchronous clock",
-        "opt2": "A counter that uses synchronous clock pulses",
-        "opt3": "A counter that uses both synchronous and asynchronous clock pulses",
-        "opt4": "A counter that does not use clock pulses",
-        "correct_option": "A counter that uses asynchronous clock",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the basic building block of an asynchronous counter?",
-        "opt1": "Flip-flop",
-        "opt2": "Encoder",
-        "opt3": "Decoder",
-        "opt4": "Multiplexer",
-        "correct_option": "Flip-flop",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "How many flip-flops are required for a 3-bit asynchronous counter?",
-        "opt1": "1",
-        "opt2": "2",
-        "opt3": "3",
-        "opt4": "4",
-        "correct_option": "3",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of flip-flop is used in an asynchronous counter?",
-        "opt1": "D flip-flop",
-        "opt2": "T flip-flop",
-        "opt3": "JK flip-flop",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the maximum count for a 4-bit asynchronous counter?",
-        "opt1": "8",
-        "opt2": "16",
-        "opt3": "32",
-        "opt4": "64",
-        "correct_option": "16",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the advantage of using an asynchronous counter over a synchronous counter?",
-        "opt1": "Higher speed",
-        "opt2": "Lower power consumption",
-        "opt3": "Lower cost",
-        "opt4": "Simpler design",
-        "correct_option": "Simpler design",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In an asynchronous counter, what is the function of the enable input?",
-        "opt1": "To start the counting process",
-        "opt2": "To stop the counting process",
-        "opt3": "To reset the counter",
-        "opt4": "To enable or disable the counting process",
-        "correct_option": "To enable or disable the counting process",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the propagation delay of an asynchronous counter?",
-        "opt1": "The time it takes for the counter to start counting",
-        "opt2": "The time it takes for the counter to stop counting",
-        "opt3": "The time it takes for the output of one flip-flop to propagate to the input of the next flip-flop",
-        "opt4": "The time it takes for the clock pulse to propagate through the counter",
-        "correct_option": "The time it takes for the output of one flip-flop to propagate to the input of the next flip-flop",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the drawback of using an asynchronous counter?",
-        "opt1": "Higher power consumption",
-        "opt2": "Higher cost",
-        "opt3": "Limited speed",
-        "opt4": "Limited scalability",
-        "correct_option": "Limited speed",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is an example of an application that requires an asynchronous counter?",
-        "opt1": "Digital clock",
-        "opt2": "Traffic light controller",
-        "opt3": "Computer processor",
-        "opt4": "Wireless router",
-        "correct_option": "Digital clock",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is a synchronous counter?",
-        "opt1": "A counter that uses synchronous clock pulses",
-        "opt2": "A counter that uses asynchronous clock pulses",
-        "opt3": "A counter that uses both synchronous and asynchronous clock pulses",
-        "opt4": "A counter that does not use clock pulses",
-        "correct_option": "A counter that uses synchronous clock pulses",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the basic building block of a synchronous counter?",
-        "opt1": "Flip-flop",
-        "opt2": "Encoder",
-        "opt3": "Decoder",
-        "opt4": "Multiplexer",
-        "correct_option": "Flip-flop",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "How many flip-flops are required for a 4-bit synchronous counter?",
-        "opt1": "1",
-        "opt2": "2",
-        "opt3": "3",
-        "opt4": "4",
-        "correct_option": "4",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which type of flip-flop is used in a synchronous counter?",
-        "opt1": "D flip-flop",
-        "opt2": "T flip-flop",
-        "opt3": "JK flip-flop",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the maximum count for a 3-bit synchronous counter?",
-        "opt1": "4",
-        "opt2": "6",
-        "opt3": "8",
-        "opt4": "10",
-        "correct_option": "8",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the advantage of using a synchronous counter over an asynchronous counter?",
-        "opt1": "Simpler design",
-        "opt2": "Lower power consumption",
-        "opt3": "Lower cost",
-        "opt4": "Higher speed",
-        "correct_option": "Higher speed",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "In a synchronous counter, what is the function of the clock input?",
-        "opt1": "To start the counting process",
-        "opt2": "To stop the counting process",
-        "opt3": "To reset the counter",
-        "opt4": "To synchronize the counting process",
-        "correct_option": "To synchronize the counting process",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the propagation delay of a synchronous counter?",
-        "opt1": "The time it takes for the counter to start counting",
-        "opt2": "The time it takes for the counter to stop counting",
-        "opt3": "The time it takes for the output of one flip-flop to propagate to the input of the next flip-flop",
-        "opt4": "The time it takes for the clock pulse to propagate through the counter",
-        "correct_option": "The time it takes for the clock pulse to propagate through the counter",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the drawback of using a synchronous counter?",
-        "opt1": "Higher power consumption",
-        "opt2": "Higher cost",
-        "opt3": "Limited speed",
-        "opt4": "Limited scalability",
-        "correct_option": "Higher power consumption",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is an example of an application that requires a synchronous counter?",
-        "opt1": "Digital clock",
-        "opt2": "Traffic light controller",
-        "opt3": "Computer processor",
-        "opt4": "Wireless router",
-        "correct_option": "Computer processor",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is a microprocessor?",
-        "opt1": "A computer memory device",
-        "opt2": "A device that performs arithmetic and logical operations",
-        "opt3": "A device that stores data",
-        "opt4": "A device that displays data",
-        "correct_option": "A device that performs arithmetic and logical operations",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is not a component of the internal architecture of a microprocessor?",
-        "opt1": "Arithmetic and Logic Unit (ALU)",
-        "opt2": "Control Unit (CU)",
-        "opt3": "Memory Unit",
-        "opt4": "Input/Output Unit (IOU)",
-        "correct_option": "Input/Output Unit (IOU)",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the function of the Control Unit (CU) in a microprocessor?",
-        "opt1": "It performs arithmetic and logical operations",
-        "opt2": "It stores data",
-        "opt3": "It controls the flow of data within the microprocessor",
-        "opt4": "It interfaces with input/output devices",
-        "correct_option": "It controls the flow of data within the microprocessor",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the function of the Arithmetic and Logic Unit (ALU) in a microprocessor?",
-        "opt1": "It controls the flow of data within the microprocessor",
-        "opt2": "It performs arithmetic and logical operations",
-        "opt3": "It stores data",
-        "opt4": "It interfaces with Input/output devices",
-        "correct_option": "It performs arithmetic and logical operations",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is not a feature of a microprocessor?",
-        "opt1": "Interrupt handling capability",
-        "opt2": "Pipelining",
-        "opt3": "Cache memory",
-        "opt4": "Secondary storage",
-        "correct_option": "Secondary storage",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is pipelining in a microprocessor?",
-        "opt1": "The process of dividing instructions into smaller parts",
-        "opt2": "The process of executing multiple instructions simultaneously",
-        "opt3": "The process of storing frequently accessed data",
-        "opt4": "The process of handling interrupts",
-        "correct_option": "The process of executing multiple instructions simultaneously",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the function of the Memory Management Unit (MMU) in a microprocessor?",
-        "opt1": "It performs arithmetic and logical operations",
-        "opt2": "It stores data",
-        "opt3": "It manages the memory resources of the system",
-        "opt4": "It interfaces with input/output devices",
-        "correct_option": "It manages the memory resources of the system",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is an example of an instruction set architecture (ISA)?",
-        "opt1": "HTML",
-        "opt2": "x86",
-        "opt3": "Java",
-        "opt4": "Python",
-        "correct_option": "x86",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is cache memory in a microprocessor?",
-        "opt1": "A type of secondary storage",
-        "opt2": "A type of RAM",
-        "opt3": "A type of memory that stores frequently accessed data",
-        "opt4": "A type of input/output device",
-        "correct_option": "A type of memory that stores frequently accessed data",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a type of bus in a microprocessor?",
-        "opt1": "Address bus",
-        "opt2": "Data bus",
-        "opt3": "Control bus",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the function of the ALU in a microprocessor?",
-        "opt1": "To execute instructions",
-        "opt2": "To store data",
-        "opt3": "To perform arithmetic and logical operations",
-        "opt4": "To communicate with external devices",
-        "correct_option": "To perform arithmetic and logical operations",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is NOT a register in a microprocessor?",
-        "opt1": "Program Counter",
-        "opt2": "Instruction Register",
-        "opt3": "Data Memory Register",
-        "opt4": "Input Output Register",
-        "correct_option": "Input Output Register",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the function of the Program Counter in a microprocessor?",
-        "opt1": "To store data",
-        "opt2": "To execute instructions",
-        "opt3": "To perform arithmetic and logical operations",
-        "opt4": "To store the address of the next instruction to be executed",
-        "correct_option": "To store the address of the next instruction to be executed",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which bus is used to transfer data between the CPU and memory in a microprocessor?",
-        "opt1": "Address bus",
-        "opt2": "Data bus",
-        "opt3": "Control bus",
-        "opt4": "All of the above",
-        "correct_option": "Data bus",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is NOT a component of the Control Unit in a microprocessor?",
-        "opt1": "Instruction Decoder",
-        "opt2": "Clock Generator",
-        "opt3": "Address Register",
-        "opt4": "Control Logic",
-        "correct_option": "Address Register",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the function of the Instruction Register in a microprocessor?",
-        "opt1": "To store data",
-        "opt2": "To execute instructions",
-        "opt3": "To perform arithmetic and logical operations",
-        "opt4": "To store the current instruction being executed",
-        "correct_option": "To store the current instruction being executed",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of the Interrupt Controller in a microprocessor?",
-        "opt1": "To generate interrupts",
-        "opt2": "To handle interrupts",
-        "opt3": "To store interrupt vectors",
-        "opt4": "To communicate with external devices",
-        "correct_option": "To handle interrupts",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is NOT a feature of a microprocessor?",
-        "opt1": "Multitasking",
-        "opt2": "Multiprocessing",
-        "opt3": "Multithreading",
-        "opt4": "Multiuser",
-        "correct_option": "Multiuser",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following components is responsible for fetching instructions from memory in a microprocessor?",
-        "opt1": "Control Unit",
-        "opt2": "ALU",
-        "opt3": "Interrupt Controller",
-        "opt4": "Input/Output Controller",
-        "correct_option": "Control Unit",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is an example of a microprocessor?",
-        "opt1": "Intel Core i7",
-        "opt2": "Nvidia GeForce RTX 3080",
-        "opt3": "Raspberry Pi 4",
-        "opt4": "Apple M1",
-        "correct_option": "Intel Core i7",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is Assembly Language?",
-        "opt1": "A high-level programming language",
-        "opt2": "A low-level programming language",
-        "opt3": "An interpreted programming language",
-        "opt4": "An object-oriented programming language",
-        "correct_option": "A low-level programming language",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is NOT a basic data type in Assembly Language?",
-        "opt1": "Integer",
-        "opt2": "Floating-point",
-        "opt3": "Character",
-        "opt4": "Boolean",
-        "correct_option": "Boolean",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is the correct syntax to define a variable in Assembly Language?",
-        "opt1": "VAR name, data type, value",
-        "opt2": "name data type value",
-        "opt3": "data type name value",
-        "opt4": "NAME VAR data type, value",
-        "correct_option": "name data type value",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the function of the Assembler in Assembly Language Programming?",
-        "opt1": "To execute Assembly Language code",
-        "opt2": "To translate Assembly Language code into machine code",
-        "opt3": "To debug Assembly Language code",
-        "opt4": "To optimize Assembly Language code",
-        "correct_option": "To translate Assembly Language code into machine code",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which register is used to store the memory address in Assembly Language Programming?",
-        "opt1": "AX",
-        "opt2": "BX",
-        "opt3": "CX",
-        "opt4": "IP",
-        "correct_option": "BX",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is NOT a branch instruction in Assembly Language Programming?",
-        "opt1": "JMP",
-        "opt2": "JZ",
-        "opt3": "JNZ",
-        "opt4": "MOV",
-        "correct_option": "MOV",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the function of the RET instruction in Assembly Language Programming?",
-        "opt1": "To return a value from a function",
-        "opt2": "To jump to a memory address",
-        "opt3": "To store a value in a register",
-        "opt4": "To return from a subroutine",
-        "correct_option": "To return from a subroutine",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is the correct syntax for the ADD instruction in Assembly Language Programming?",
-        "opt1": "ADD source, destination",
-        "opt2": "ADD destination, source",
-        "opt3": "ADD source",
-        "opt4": "ADD destination",
-        "correct_option": "ADD destination, source",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an example of an addressing mode in Assembly Language Programming?",
-        "opt1": "Immediate",
-        "opt2": "Direct",
-        "opt3": "Indirect",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of the INT instruction in Assembly Language Programming?",
-        "opt1": "To perform an arithmetic operation",
-        "opt2": "To compare two values",
-        "opt3": "To generate a software interrupt",
-        "opt4": "To move data between registers",
-        "correct_option": "To generate a software interrupt",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is Assembly Language Programming?",
-        "opt1": "A high-level programming language",
-        "opt2": "A low-level programming language",
-        "opt3": "A scripting language",
-        "opt4": "A markup language",
-        "correct_option": "A low-level programming language",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is NOT a common Assembly Language instruction?",
-        "opt1": "MOV",
-        "opt2": "ADD",
-        "opt3": "PRINT",
-        "opt4": "JUMP",
-        "correct_option": "PRINT",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which instruction is used to move data from a register to memory in Assembly Language Programming?",
-        "opt1": "MOV",
-        "opt2": "ADD",
-        "opt3": "JMP",
-        "opt4": "PUSH",
-        "correct_option": "MOV",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which instruction is used to perform addition in Assembly Language Programming?",
-        "opt1": "MOV",
-        "opt2": "ADD",
-        "opt3": "JMP",
-        "opt4": "PUSH",
-        "correct_option": "ADD",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which instruction is used to jump to a specific memory location in Assembly Language Programming?",
-        "opt1": "MOV",
-        "opt2": "ADD",
-        "opt3": "JMP",
-        "opt4": "PUSH",
-        "correct_option": "JMP",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is NOT a register in Assembly Language Programming?",
-        "opt1": "A",
-        "opt2": "B",
-        "opt3": "C",
-        "opt4": "D",
-        "correct_option": "D",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which instruction is used to compare two values in Assembly Language Programming?",
-        "opt1": "CMP",
-        "opt2": "ADD",
-        "opt3": "JMP",
-        "opt4": "PUSH",
-        "correct_option": "CMP",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which instruction is used to perform multiplication in Assembly Language Programming?",
-        "opt1": "MUL",
-        "opt2": "ADD",
-        "opt3": "JMP",
-        "opt4": "POP",
-        "correct_option": "MUL",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which instruction is used to move data from memory to a register in Assembly Language Programming?",
-        "opt1": "MOV",
-        "opt2": "ADD",
-        "opt3": "JMP",
-        "opt4": "PUSH",
-        "correct_option": "MOV",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is NOT a common Assembly Language Directive?",
-        "opt1": "DB",
-        "opt2": "DW",
-        "opt3": "DS",
-        "opt4": "INPUT",
-        "correct_option": "INPUT",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which type of memory is used for long-term storage of data and programs even when the power is turned off?",
-        "opt1": "Primary Memory",
-        "opt2": "Secondary Memory",
-        "opt3": "Cache Memory",
-        "opt4": "Virtual Memory",
-        "correct_option": "Secondary Memory",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a type of non-volatile memory?",
-        "opt1": "Dynamic RAM (DRAM)",
-        "opt2": "Static RAM (SRAM)",
-        "opt3": "Flash Memory",
-        "opt4": "Synchronous DRAM (SDRAM)",
-        "correct_option": "Flash Memory",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which type of memory is used as an extension of primary memory when there is not enough space to store all the necessary programs and data?",
-        "opt1": "Primary Memory",
-        "opt2": "Secondary Memory",
-        "opt3": "Cache Memory",
-        "opt4": "Virtual Memory",
-        "correct_option": "Virtual Memory",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which type of memory has the fastest access time and is located closest to the CPU in the memory hierarchy?",
-        "opt1": "Primary Memory",
-        "opt2": "Secondary Memory",
-        "opt3": "Cache Memory",
-        "opt4": "Virtual Memory",
-        "correct_option": "Cache Memory",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is a type of Double Data Rate (DDR) synchronous dynamic RAM (SDRAM)?",
-        "opt1": "DDR2 SDRAM",
-        "opt2": "DDR3 SDRAM",
-        "opt3": "DDR5 SDRAM",
-        "opt4": "All of the above",
-        "correct_option": "All of the above",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the main difference between primary and secondary memory?",
-        "opt1": "Primary memory is faster than secondary memory",
-        "opt2": "Secondary memory is faster than primary memory",
-        "opt3": "Primary memory is volatile while secondary memory is non-volatile",
-        "opt4": "Secondary memory is volatile while primary memory is non-volatile",
-        "correct_option": "Primary memory is volatile while secondary memory is non-volatile",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is NOT a type of primary memory?",
-        "opt1": "ROM",
-        "opt2": "RAM",
-        "opt3": "Cache",
-        "opt4": "Hard Disk Drive",
-        "correct_option": "Hard Disk Drive",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is NOT a type of secondary memory?",
-        "opt1": "Hard Disk Drive",
-        "opt2": "Solid State Drive",
-        "opt3": "USB Drive",
-        "opt4": "CPU Cache",
-        "correct_option": "CPU Cache",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which memory device has the fastest access time in a microprocessor system?",
-        "opt1": "RAM",
-        "opt2": "ROM",
-        "opt3": "Cache",
-        "opt4": "Hard Disk Drive",
-        "correct_option": "Cache",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is NOT a characteristic of volatile memory?",
-        "opt1": "It is faster than non-volatile memory",
-        "opt2": "It requires constant power to retain data",
-        "opt3": "It is used for long-term storage",
-        "opt4": "It is typically smaller in capacity than non-volatile memory",
-        "correct_option": "It is used for long-term storage",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following is NOT a characteristic of non-volatile memory?",
-        "opt1": "It retains data even when power is removed",
-        "opt2": "It is typically used for long-term storage",
-        "opt3": "It is slower than volatile memory",
-        "opt4": "It is larger in capacity than volatile memory",
-        "correct_option": "It is larger in capacity than volatile memory",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is NOT a level of cache in a microprocessor system?",
-        "opt1": "L1",
-        "opt2": "L2",
-        "opt3": "L3",
-        "opt4": "L4",
-        "correct_option": "L4",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following is NOT a type of ROM?",
-        "opt1": "PROM",
-        "opt2": "EPROM",
-        "opt3": "EEPROM",
-        "opt4": "DRAM",
-        "correct_option": "DRAM",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is an interrupt service routine (ISR) in a microprocessor?",
-        "opt1": "A software routine that responds to a specific interrupt",
-        "opt2": "A hardware circuit that triggers an interrupt",
-        "opt3": "A type of memory used for storing interrupt data",
-        "opt4": "A type of instruction that modifies the contents of a register",
-        "correct_option": "A software routine that responds to a specific interrupt",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following statements is true about the execution of an ISR?",
-        "opt1": "It always starts from the beginning of the program",
-        "opt2": "It always resumes from the point where the interrupted program left off",
-        "opt3": "It may start from the beginning or resume from the point where the interrupted program left off, depending on microprocessor architecture",
-        "opt4": "It never resumes from the point where the interrupted program left off",
-        "correct_option": "It may start from the beginning or resume from the point where the interrupted program left off, depending on microprocessor architecture",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the purpose of saving the context of the interrupted program in an ISR?",
-        "opt1": "To allow the ISR to modify the state of the interrupted program",
-        "opt2": "To resume execution of the interrupted program after the ISR is finished",
-        "opt3": "To allow the ISR to save data for future use",
-        "opt4": "To allow the ISR to execute faster",
-        "correct_option": "To resume execution of the interrupted program after the ISR is finished",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about the priority of an ISR?",
-        "opt1": "The highest priority ISR is always executed first",
-        "opt2": "ISRs are executed in the order they are received",
-        "opt3": "The lowest priority ISR is always executed first",
-        "opt4": "ISRs are executed in the order of their priority",
-        "correct_option": "The highest priority ISR is always executed first",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following statements is true about re-entrant ISRs?",
-        "opt1": "They cannot be interrupted by other ISRs",
-        "opt2": "They can be interrupted by other ISRs",
-        "opt3": "They can only be called by other ISRs",
-        "opt4": "They can only be called by the main program",
-        "correct_option": "They can be interrupted by other ISRs",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of an exit routine in an ISR?",
-        "opt1": "To terminate the ISR",
-        "opt2": "To clear the interrupt flag",
-        "opt3": "To restore the context of the interrupted program",
-        "opt4": "To store data for future use",
-        "correct_option": "To restore the context of the interrupted program",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following statements is true about nested ISRs?",
-        "opt1": "They cannot occur in a microprocessor",
-        "opt2": "They occur when an ISR is triggered while another ISR is being serviced",
-        "opt3": "They occur when two ISRs are triggered simultaneously",
-        "opt4": "They occur when an ISR takes longer than expected to execute",
-        "correct_option": "They occur when an ISR is triggered while another ISR is being serviced",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about the use of global variables in ISRs?",
-        "opt1": "Global variables should not be used in ISRs",
-        "opt2": "Global variables are safe to use in ISRs",
-        "opt3": "Global variables should only be used in re-entrant ISRs",
-        "opt4": "Global variables should only be used in high-priority ISRs",
-        "correct_option": "Global variables should not be used in ISRs",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the purpose of a spinlock in an ISR?",
-        "opt1": "To prevent other ISRs from executing while the current ISR is running",
-        "opt2": "To allow other ISRs to execute while the current ISR is running",
-        "opt3": "To synchronize access to shared resources",
-        "opt4": "To optimize the performance of the ISR",
-        "correct_option": "To synchronize access to shared resources",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is an interrupt service routine (ISR)?",
-        "opt1": "A program that triggers an interrupt",
-        "opt2": "A program that executes when an interrupt is triggered",
-        "opt3": "A program that disables interrupts",
-        "opt4": "A program that clears interrupt flags",
-        "correct_option": "A program that executes when an interrupt is triggered",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is not a common task performed by an ISR?",
-        "opt1": "Reading data from an I/O device",
-        "opt2": "Updating the interrupt enable flag",
-        "opt3": "Saving and restoring the processor state",
-        "opt4": "Clearing the interrupt flag",
-        "correct_option": "Updating the interrupt enable flag",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about the stack in an ISR?",
-        "opt1": "The stack is not used in an ISR",
-        "opt2": "The stack is used to store data received from an I/O device",
-        "opt3": "The stack is used to store the return address and processor state",
-        "opt4": "The stack is used to store data that will be written to memory",
-        "correct_option": "The stack is used to store the return address and processor state",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the purpose of the return from interrupt (RTI) instruction?",
-        "opt1": "To return control to the ISR after an interrupt",
-        "opt2": "To return control to the main program after an interrupt",
-        "opt3": "To clear the interrupt flag",
-        "opt4": "To save the processor state and interrupt enable flag",
-        "correct_option": "To return control to the main program after an interrupt",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is an example of a non-maskable interrupt (NMI)?",
-        "opt1": "Keyboard interrupt",
-        "opt2": "Timer interrupt",
-        "opt3": "Power failure interrupt",
-        "opt4": "DMA interrupt",
-        "correct_option": "Power failure interrupt",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "Which of the following statements is true about nested interrupts?",
-        "opt1": "They are not allowed in most microprocessors",
-        "opt2": "They occur when an ISR triggers another interrupt",
-        "opt3": "They occur when multiple interrupts are triggered simultaneously",
-        "opt4": "They occur when an ISR takes too long to execute",
-        "correct_option": "They occur when an ISR triggers another interrupt",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of the interrupt enable flag in an ISR?",
-        "opt1": "To indicate that an interrupt has occurred",
-        "opt2": "To enable or disable interrupts",
-        "opt3": "To store the address of an ISR",
-        "opt4": "To clear the interrupt flag",
-        "correct_option": "To enable or disable interrupts",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is interrupt processing in a microprocessor?",
-        "opt1": "The process of interrupting a running program",
-        "opt2": "The process of handling an interrupt request from an external device",
-        "opt3": "The process of prioritizing interrupts",
-        "opt4": "The process of executing the interrupt service routine",
-        "correct_option": "The process of handling an interrupt request from an external device",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a common method of handling multiple interrupts in a microprocessor?",
-        "opt1": "Polling",
-        "opt2": "Queuing",
-        "opt3": "Sorting",
-        "opt4": "Multiplexing",
-        "correct_option": "Polling",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the purpose of an interrupt vector in a microprocessor?",
-        "opt1": "To store the interrupt priority levels",
-        "opt2": "To store the addresses of the interrupt service routines",
-        "opt3": "To store the status of the interrupt flag",
-        "opt4": "To store the current program counter",
-        "correct_option": "To store the addresses of the interrupt service routines",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about the interrupt priority levels in a microprocessor?",
-        "opt1": "Lower priority levels have higher priority",
-        "opt2": "Higher priority levels have higher priority",
-        "opt3": "The priority levels are not important in interrupt processing",
-        "opt4": "The priority levels are determined by the external devices",
-        "correct_option": "Higher priority levels have higher priority",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following is a disadvantage of using the polling method for interrupt processing?",
-        "opt1": "It is slower than other methods",
-        "opt2": "It requires more hardware resources",
-        "opt3": "It may cause a delay in responding to interrupts",
-        "opt4": "It may cause errors in the interrupt processing",
-        "correct_option": "It may cause a delay in responding to interrupts",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is the purpose of the interrupt enable bit in a microprocessor?",
-        "opt1": "To enable the interrupt processing",
-        "opt2": "To disable the interrupt processing",
-        "opt3": "To enable the interrupt request from external devices",
-        "opt4": "To disable the interrupt request from external devices",
-        "correct_option": "To enable the interrupt processing",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following is an advantage of using the interrupt method for interrupt processing?",
-        "opt1": "It requires less hardware resources",
-        "opt2": "It is faster than other methods",
-        "opt3": "It does not cause a delay in responding to interrupts",
-        "opt4": "It does not require interrupt vectors",
-        "correct_option": "It does not cause a delay in responding to interrupts",
-        "correct_option_index": 3
-    },
-    {
-        "qsns": "What is interrupt processing in a microprocessor?",
-        "opt1": "The process of generating interrupts",
-        "opt2": "The process of handling interrupts",
-        "opt3": "The process of disabling interrupts",
-        "opt4": "The process of prioritizing interrupts",
-        "correct_option": "The process of handling interrupts",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about interrupt processing time?",
-        "opt1": "It is always shorter than the interrupt response time",
-        "opt2": "It is always longer than the interrupt response time",
-        "opt3": "It is equal to the interrupt response time",
-        "opt4": "It depends on the complexity of the interrupt handling routine",
-        "correct_option": "It depends on the complexity of the interrupt handling routine",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of an interrupt vector table?",
-        "opt1": "To store the priority of each interrupt",
-        "opt2": "To store the memory location of the interrupt service routine (ISR) for each interrupt",
-        "opt3": "To store the interrupt mask for each interrupt",
-        "opt4": "To store the status of each interrupt",
-        "correct_option": "To store the memory location of the interrupt service routine (ISR) for each interrupt",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about interrupt latency?",
-        "opt1": "It is the time between the occurrence of an interrupt and the start of the ISR",
-        "opt2": "It is the time between the start of the ISR and the end of the ISR",
-        "opt3": "It is the time between the end of the ISR and the resumption of the interrupted program",
-        "opt4": "It is the time between the occurrence of an interrupt and the resumption of the interrupted program",
-        "correct_option": "It is the time between the occurrence of an interrupt and the start of the ISR",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following statements is true about interrupt nesting?",
-        "opt1": "It is the process of triggering multiple interrupts simultaneously",
-        "opt2": "It is the process of handling interrupts in the order they are received",
-        "opt3": "It is the process of disabling interrupts while an ISR is being executed",
-        "opt4": "It is the process of handling an interrupt while another ISR is being executed",
-        "correct_option": "It is the process of handling an interrupt while another ISR is being executed",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of an interrupt mask in a microprocessor?",
-        "opt1": "To enable or disable interrupts",
-        "opt2": "To prioritize interrupts",
-        "opt3": "To store the status of interrupts",
-        "opt4": "To store the memory location of ISRs",
-        "correct_option": "To enable or disable interrupts",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "Which of the following statements is true about interrupt handling in a multitasking environment?",
-        "opt1": "Interrupts should be enabled while a task is executing",
-        "opt2": "Interrupts should be disabled while a task is executing",
-        "opt3": "Interrupts should be ignored in a multitasking environment",
-        "opt4": "Interrupts should be prioritized based on the task being executed",
-        "correct_option": "Interrupts should be enabled while a task is executing",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the purpose of an interrupt acknowledgment signal?",
-        "opt1": "To enable or disable an interrupt",
-        "opt2": "To acknowledge the occurrence of an interrupt",
-        "opt3": "To trigger an interrupt",
-        "opt4": "To prioritize interrupts",
-        "correct_option": "To acknowledge the occurrence of an interrupt",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about edge-triggered interrupts?",
-        "opt1": "They are triggered by the presence of a signal for a specified period of time",
-        "opt2": "They are triggered by the rising or falling edge of a signal",
-        "opt3": "They are triggered by the amplitude of a signal",
-        "opt4": "They are triggered by the frequency of a signal",
-        "correct_option": "They are triggered by the rising or falling edge of a signal",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of an interrupt request (IRQ) line in a microprocessor?",
-        "opt1": "To trigger an interrupt",
-        "opt2": "To acknowledge an interrupt",
-        "opt3": "To prioritize interrupts",
-        "opt4": "To enable or disable interrupts",
-        "correct_option": "To trigger an interrupt",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the purpose of the interrupt acknowledge signal in a microprocessor?",
-        "opt1": "To request an interrupt from an external device",
-        "opt2": "To acknowledge receipt of an interrupt request from an external device",
-        "opt3": "To enable the interrupt processing",
-        "opt4": "To disable the interrupt processing",
-        "correct_option": "To acknowledge receipt of an interrupt request from an external device",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is an interrupt vector table in a microprocessor?",
-        "opt1": "A table that stores the priority of each interrupt",
-        "opt2": "A table that stores the address of each ISR",
-        "opt3": "A table that stores the context of the interrupted program",
-        "opt4": "A table that stores the status of each interrupt flag",
-        "correct_option": "A table that stores the address of each ISR",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about interrupt latency?",
-        "opt1": "It refers to the time required for an ISR to execute",
-        "opt2": "It refers to the time required for an interrupt to be detected and an ISR to be initiated",
-        "opt3": "It refers to the time required for the interrupted program to resume after an ISR is finished",
-        "opt4": "It refers to the time required for the microprocessor to switch between different ISRs",
-        "correct_option": "It refers to the time required for an interrupt to be detected and an ISR to be initiated",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about nested interrupts?",
-        "opt1": "They occur when an ISR is triggered while another ISR is being serviced",
-        "opt2": "They occur when two ISRs are triggered simultaneously",
-        "opt3": "They occur when an ISR takes longer than expected to execute",
-        "opt4": "They never occur in a microprocessor",
-        "correct_option": "They occur when an ISR is triggered while another ISR is being serviced",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the purpose of an interrupt enable flag in a microprocessor?",
-        "opt1": "To disable all interrupts",
-        "opt2": "To enable all interrupts",
-        "opt3": "To enable specific interrupts",
-        "opt4": "To disable specific interrupts",
-        "correct_option": "To enable all interrupts",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "What is the purpose of a maskable interrupt in a microprocessor?",
-        "opt1": "To disable all interrupts",
-        "opt2": "To enable all interrupts",
-        "opt3": "To enable specific interrupts",
-        "opt4": "To disable specific interrupts",
-        "correct_option": "To disable specific interrupts",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "Which of the following statements is true about non-maskable interrupts?",
-        "opt1": "They can be disabled by software",
-        "opt2": "They can be disabled by hardware",
-        "opt3": "They can be ignored by the microprocessor",
-        "opt4": "They cannot be ignored by the microprocessor",
-        "correct_option": "They cannot be ignored by the microprocessor",
-        "correct_option_index": 4
-    },
-    {
-        "qsns": "What is the purpose of an interrupt acknowledge signal in a microprocessor?",
-        "opt1": "To acknowledge the occurrence of an interrupt",
-        "opt2": "To acknowledge the receipt of an interrupt request",
-        "opt3": "To clear the interrupt enable flag",
-        "opt4": "To clear the interrupt flag",
-        "correct_option": "To acknowledge the receipt of an interrupt request",
-        "correct_option_index": 2
-    },
-    {
-        "qsns": "Which of the following statements is true about edge-triggered interrupts?",
-        "opt1": "They are triggered by a change in the interrupt request signal",
-        "opt2": "They are triggered by the level of the interrupt request signal",
-        "opt3": "They are not used in microprocessors",
-        "opt4": "They are always maskable interrupts",
-        "correct_option": "They are triggered by a change in the interrupt request signal",
-        "correct_option_index": 1
-    },
-    {
-        "qsns": "What is the purpose of a vectored interrupt in a microprocessor?",
-        "opt1": "To enable multiple interrupts to be serviced simultaneously",
-        "opt2": "To prioritize interrupts based on their importance",
-        "opt3": "To reduce interrupt latency",
-        "opt4": "To allow each interrupt to have a unique ISR address",
-        "correct_option": "To allow each interrupt to have a unique ISR address",
-        "correct_option_index": 4
-    }
-]
\ No newline at end of file
+        {
+                "qsns": "What is the base of the decimal number system?",
+                "opt1": "2",
+                "opt2": "8",
+                "opt3": "10",
+                "opt4": "16",
+                "correct_option": "10",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "How many digits are used in the binary number system?",
+                "opt1": "8",
+                "opt2": "10",
+                "opt3": "2",
+                "opt4": "16",
+                "correct_option": "2",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which number system is often used in computer programming to represent sets of 3 bits?",
+                "opt1": "Decimal",
+                "opt2": "Binary",
+                "opt3": "Octal",
+                "opt4": "Hexadecimal",
+                "correct_option": "Octal",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the base of the hexadecimal number system?",
+                "opt1": "2",
+                "opt2": "8",
+                "opt3": "10",
+                "opt4": "16",
+                "correct_option": "16",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the decimal equivalent of the binary number 1011?",
+                "opt1": "3",
+                "opt2": "7",
+                "opt3": "11",
+                "opt4": "13",
+                "correct_option": "11",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which number system is easy to represent using electronic devices like switches?",
+                "opt1": "Decimal",
+                "opt2": "Binary",
+                "opt3": "Octal",
+                "opt4": "Hexadecimal",
+                "correct_option": "Binary",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the octal equivalent of the decimal number 11?",
+                "opt1": "3",
+                "opt2": "7",
+                "opt3": "5",
+                "opt4": "13",
+                "correct_option": "13",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which number system is often used in computer science to represent memory addresses?",
+                "opt1": "Decimal",
+                "opt2": "Binary",
+                "opt3": "Octal",
+                "opt4": "Hexadecimal",
+                "correct_option": "Hexadecimal",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the binary equivalent of the decimal number 23?",
+                "opt1": "10111",
+                "opt2": "11011",
+                "opt3": "11101",
+                "opt4": "11110",
+                "correct_option": "10111",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the decimal equivalent of the hexadecimal number 2F?",
+                "opt1": "32",
+                "opt2": "45",
+                "opt3": "47",
+                "opt4": "52",
+                "correct_option": "47",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which number system has a base of 8?",
+                "opt1": "Decimal",
+                "opt2": "Binary",
+                "opt3": "Octal",
+                "opt4": "Hexadecimal",
+                "correct_option": "Octal",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the binary equivalent of the decimal number 17?",
+                "opt1": "10000",
+                "opt2": "10010",
+                "opt3": "10001",
+                "opt4": "10011",
+                "correct_option": "10001",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the hexadecimal equivalent of the binary number 1101?",
+                "opt1": "D",
+                "opt2": "E",
+                "opt3": "F",
+                "opt4": "10",
+                "correct_option": "D",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the base of the binary number system?",
+                "opt1": "2",
+                "opt2": "8",
+                "opt3": "10",
+                "opt4": "16",
+                "correct_option": "2",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the octal equivalent of the decimal number 27?",
+                "opt1": "33",
+                "opt2": "37",
+                "opt3": "43",
+                "opt4": "47",
+                "correct_option": "33",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the decimal equivalent of the hexadecimal number FF?",
+                "opt1": "255",
+                "opt2": "256",
+                "opt3": "257",
+                "opt4": "258",
+                "correct_option": "255",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the binary equivalent of the octal number 76?",
+                "opt1": "111011",
+                "opt2": "110110",
+                "opt3": "110111",
+                "opt4": "111000",
+                "correct_option": "111110",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which number system is used in digital electronics?",
+                "opt1": "Decimal",
+                "opt2": "Binary",
+                "opt3": "Octal",
+                "opt4": "Hexadecimal",
+                "correct_option": "Binary",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the hexadecimal equivalent of the binary number 101011?",
+                "opt1": "28",
+                "opt2": "20",
+                "opt3": "2F",
+                "opt4": "31",
+                "correct_option": "2B",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the decimal equivalent of the octal number 63?",
+                "opt1": "51",
+                "opt2": "53",
+                "opt3": "55",
+                "opt4": "57",
+                "correct_option": "51",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which logic family defines a voltage range of 0 V to 0.8 V for a logical 0 and 2 V to 5V for a logical 1?",
+                "opt1": "TTL",
+                "opt2": "CMOS",
+                "opt3": "ECL",
+                "opt4": "None of the above",
+                "correct_option": "TTL",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which logic family consumes less power than TTL?",
+                "opt1": "TTL",
+                "opt2": "CMOS",
+                "opt3": "ECL",
+                "opt4": "None of the above",
+                "correct_option": "CMOS",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the voltage range for a logical 0 in CMOS logic?",
+                "opt1": "0V to 0.5 V",
+                "opt2": "0V to 0.8 V",
+                "opt3": "0V to 1.5 V",
+                "opt4": "0V to 3.5 V",
+                "correct_option": "0V to 1.5 V",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the voltage range for a logical 1 in CMOS logic?",
+                "opt1": "0V to 1.5 V",
+                "opt2": "1.5 V to 3.5 V",
+                "opt3": "2V to 5V",
+                "opt4": "3.5 V to 5V",
+                "correct_option": "3.5 V to 5V",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which logic family is known for its high speed and low power consumption?",
+                "opt1": "TTL",
+                "opt2": "CMOS",
+                "opt3": "ECL",
+                "opt4": "None of the above",
+                "correct_option": "CMOS",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is true about logic levels?",
+                "opt1": "They determine the power consumption of a digital circuit.",
+                "opt2": "They determine the speed of a digital circuit.",
+                "opt3": "They determine how digital circuits interpret input signals.",
+                "opt4": "They determine the size of a digital circuit.",
+                "correct_option": "They determine how digital circuits interpret input signals.",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What happens if a signal voltage falls outside the specified range for a logical 0 or 1?",
+                "opt1": "The circuit will interpret it as a logical 0.",
+                "opt2": "The circuit will interpret it as a logical 1.",
+                "opt3": "The circuit may interpret it incorrectly, leading to errors or circuit failure.",
+                "opt4": "The circuit will ignore the signal.",
+                "correct_option": "The circuit may interpret it incorrectly, leading to errors or circuit failure.",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What are the two most common logic levels used in digital logic?",
+                "opt1": "Low and High",
+                "opt2": "0 and 1",
+                "opt3": "Negative and Positive",
+                "opt4": "True and False",
+                "correct_option": "0 and 1",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which logic level represents a logic 1 in a digital circuit?",
+                "opt1": "High",
+                "opt2": "Low",
+                "opt3": "Negative",
+                "opt4": "Positive",
+                "correct_option": "High",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is NOT a typical voltage range for a logic 0?",
+                "opt1": "0V to 0.8V",
+                "opt2": "0V to 1.0V",
+                "opt3": "0V to 1.5V",
+                "opt4": "0V to 2.0V",
+                "correct_option": "0V to 2.0V",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which logic level is represented by a voltage above the high threshold voltage and below the low threshold voltage?",
+                "opt1": "Positive",
+                "opt2": "Negative",
+                "opt3": "Indeterminate",
+                "opt4": "None of the above",
+                "correct_option": "Indeterminate",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following logic gates has a single input and an inverted output?",
+                "opt1": "NOT gate",
+                "opt2": "OR gate",
+                "opt3": "AND gate",
+                "opt4": "NAND gate",
+                "correct_option": "NOT gate",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following logic gates requires all inputs to be high in order to produce a high output?",
+                "opt1": "OR gate",
+                "opt2": "AND gate",
+                "opt3": "XOR gate",
+                "opt4": "NOR gate",
+                "correct_option": "AND gate",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following logic gates produces a high output only when all inputs are low?",
+                "opt1": "OR gate",
+                "opt2": "AND gate",
+                "opt3": "NOR gate",
+                "opt4": "XOR gate",
+                "correct_option": "NOR gate",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following logic gates has two or more inputs and produces a high output if any one input is high?",
+                "opt1": "NOR gate",
+                "opt2": "XOR gate",
+                "opt3": "AND gate",
+                "opt4": "OR gate",
+                "correct_option": "OR gate",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the output of an AND gate if one input is 1 and the other input is 0?",
+                "opt1": "0",
+                "opt2": "1",
+                "opt3": "Depends on the gate",
+                "opt4": "Cannot be determined",
+                "correct_option": "0",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the output of a NAND gate if one input is 1 and the other input is 0?",
+                "opt1": "0",
+                "opt2": "1",
+                "opt3": "Depends on the gate",
+                "opt4": "Cannot be determined",
+                "correct_option": "1",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following logic gates has an output that is the inverse of the input?",
+                "opt1": "NOT gate",
+                "opt2": "AND gate",
+                "opt3": "OR gate",
+                "opt4": "XOR gate",
+                "correct_option": "NOT gate",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following logic gates has an output that is the opposite of the OR gate?",
+                "opt1": "OR gate",
+                "opt2": "NAND gate",
+                "opt3": "NOR gate",
+                "opt4": "XOR gate",
+                "correct_option": "NOR gate",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following logic gates has two or more inputs and produces a high output only when all inputs are high?",
+                "opt1": "OR gate",
+                "opt2": "XOR gate",
+                "opt3": "AND gate",
+                "opt4": "NOR gate",
+                "correct_option": "AND gate",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the output of a XOR gate if both inputs are 1?",
+                "opt1": "0",
+                "opt2": "1",
+                "opt3": "Depends on the gate",
+                "opt4": "Cannot be determined",
+                "correct_option": "0",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which logic gate has the output opposite in logic level to its input?",
+                "opt1": "OR GATE",
+                "opt2": "AND gate",
+                "opt3": "NOT gate",
+                "opt4": "XOR gate",
+                "correct_option": "NOT gate",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which logic gate produces a high output only when all inputs are high?",
+                "opt1": "OR gate",
+                "opt2": "AND gate",
+                "opt3": "NOT gate",
+                "opt4": "XOR gate",
+                "correct_option": "AND gate",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which logic gate produces a high output when any input is high?",
+                "opt1": "OR gate",
+                "opt2": "AND gate",
+                "opt3": "NOT gate",
+                "opt4": "XOR gate",
+                "correct_option": "OR gate",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which logic gate produces a low output only when all inputs are low?",
+                "opt1": "OR gate",
+                "opt2": "AND gate",
+                "opt3": "NOT gate",
+                "opt4": "XOR gate",
+                "correct_option": "OR gate",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which logic gate produces a high output when the inputs are different?",
+                "opt1": "OR gate",
+                "opt2": "AND gate",
+                "opt3": "NOT gate",
+                "opt4": "XOR gate",
+                "correct_option": "XOR gate",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following is NOT a basic operation in Boolean algebra?",
+                "opt1": "AND",
+                "opt2": "OR",
+                "opt3": "NOT",
+                "opt4": "XOR",
+                "correct_option": "XOR",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the Boolean expression for the NAND gate?",
+                "opt1": "A + B",
+                "opt2": "AB",
+                "opt3": "A' + B'",
+                "opt4": "A'B'",
+                "correct_option": "A' + B'",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following Boolean identities is NOT true?",
+                "opt1": "A + 0 = A",
+                "opt2": "A + A' = 1",
+                "opt3": "A + B = B + A",
+                "opt4": "A + A = A",
+                "correct_option": "A + A = A",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the Boolean expression for the NOR gate?",
+                "opt1": "A + B",
+                "opt2": "AB",
+                "opt3": "A' + B'",
+                "opt4": "A'B'",
+                "correct_option": "A'B'",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the complement of the Boolean expression A'B + AB'?",
+                "opt1": "A' + B'",
+                "opt2": "A + B",
+                "opt3": "A'B",
+                "opt4": "AB",
+                "correct_option": "A + B",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which Boolean operator has the highest precedence?",
+                "opt1": "NOT",
+                "opt2": "AND",
+                "opt3": "OR",
+                "opt4": "XOR",
+                "correct_option": "NOT",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which Boolean operator has the lowest precedence?",
+                "opt1": "NOT",
+                "opt2": "AND",
+                "opt3": "OR",
+                "opt4": "XOR",
+                "correct_option": "OR",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is a Boolean operator?",
+                "opt1": "+",
+                "opt2": "*",
+                "opt3": "&",
+                "opt4": "/",
+                "correct_option": "/",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the Boolean expression for the OR gate?",
+                "opt1": "A+B",
+                "opt2": "A*B",
+                "opt3": "A/B",
+                "opt4": "A&B",
+                "correct_option": "A+B",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the Boolean expression for the AND gate?",
+                "opt1": "A+B",
+                "opt2": "A*B",
+                "opt3": "A/B",
+                "opt4": "A&B",
+                "correct_option": "A*B",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the Boolean expression for the NOT gate?",
+                "opt1": "A+B",
+                "opt2": "A*B",
+                "opt3": "A'",
+                "opt4": "A&B'",
+                "correct_option": "A'",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is an example of a Boolean equation?",
+                "opt1": "y=x+2",
+                "opt2": "y=x*2",
+                "opt3": "y=xORz",
+                "opt4": "y=xAND2",
+                "correct_option": "y=xAND2",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following is a Boolean identity?",
+                "opt1": "A+0=A",
+                "opt2": "A/1=A",
+                "opt3": "A*0=A",
+                "opt4": "A-1=A",
+                "correct_option": "A+0=A",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is a Boolean simplification rule?",
+                "opt1": "A+A=A",
+                "opt2": "A*A=A",
+                "opt3": "A+B=B+A",
+                "opt4": "A*B=B*A",
+                "correct_option": "A+B=B+A",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the result of the Boolean operation A OR (B AND C)?",
+                "opt1": "A+B*C",
+                "opt2": "A+B+C",
+                "opt3": "A*B*C",
+                "opt4": "A*B+C",
+                "correct_option": "A+B*C",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the result of the Boolean operation (A OR B) AND (A OR C)?",
+                "opt1": "A+B+C",
+                "opt2": "A*B*C",
+                "opt3": "A+B*C",
+                "opt4": "A*B+C",
+                "correct_option": "A+B+C",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the Boolean expression for the exclusive-OR (XOR) gate?",
+                "opt1": "A+B",
+                "opt2": "A*B",
+                "opt3": "A/B",
+                "opt4": "AB",
+                "correct_option": "AB",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is Boolean algebra?",
+                "opt1": "A branch of mathematics that deals with logic gates",
+                "opt2": "A branch of mathematics that deals with Boolean functions",
+                "opt3": "A branch of mathematics that deals with calculus",
+                "opt4": "A branch of mathematics that deals with programming languages",
+                "correct_option": "A branch of mathematics that deals with Boolean functions",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is a Boolean variable?",
+                "opt1": "A variable that can take on any value, including true or false",
+                "opt2": "A variable that can only take on two values, true or false",
+                "opt3": "A variable that can take on multiple values at once",
+                "opt4": "A variable that is always true",
+                "correct_option": "A variable that can only take on two values, true or false",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is a Boolean expression?",
+                "opt1": "A mathematical expression that uses Boolean variables, operators, and constants",
+                "opt2": "A mathematical expression that uses only integers and operators",
+                "opt3": "A mathematical expression that uses real numbers and operators",
+                "opt4": "A mathematical expression that uses only constants and operators",
+                "correct_option": "A mathematical expression that uses Boolean variables, operators, and constants",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which Boolean operator represents logical AND?",
+                "opt1": "+",
+                "opt2": "*",
+                "opt3": ".",
+                "opt4": "-",
+                "correct_option": ".",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which Boolean operator represents logical OR?",
+                "opt1": "+",
+                "opt2": "*",
+                "opt3": "/",
+                "opt4": "-",
+                "correct_option": "+",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which Boolean operator represents logical NOT?",
+                "opt1": "+",
+                "opt2": "*",
+                "opt3": "'",
+                "opt4": "/",
+                "correct_option": "'",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the complement of A in Boolean algebra?",
+                "opt1": "A'",
+                "opt2": "A+",
+                "opt3": "A*",
+                "opt4": "A-",
+                "correct_option": "A'",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the simplified expression for A + AB?",
+                "opt1": "A",
+                "opt2": "B",
+                "opt3": "AB",
+                "opt4": "1",
+                "correct_option": "A",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the simplified expression for AB + A'B?",
+                "opt1": "AB + A'",
+                "opt2": "AB",
+                "opt3": "A+B",
+                "opt4": "AB'",
+                "correct_option": "AB'",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the Sum-of-Products (SOP) method in digital logic?",
+                "opt1": "A technique used to simplify Boolean expressions",
+                "opt2": "A technique used to convert decimal numbers to binary",
+                "opt3": "A technique used to convert binary numbers to decimal",
+                "opt4": "A technique used to convert octal numbers to hexadecimal",
+                "correct_option": "A technique used to simplify Boolean expressions",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the first step in using the SOP method to simplify a Boolean expression?",
+                "opt1": "Create a truth table",
+                "opt2": "Write the expression in standard form",
+                "opt3": "Identify the rows where the expression evaluates to 1",
+                "opt4": "Combine the rows with an OR operator",
+                "correct_option": "Write the expression in standard form",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What are the Boolean operators used in the standard form of a Boolean expression?",
+                "opt1": "AND, OR, and XOR",
+                "opt2": "AND, OR, and NOT",
+                "opt3": "XOR, NAND, and NOR",
+                "opt4": "XOR, NOT, and NAND",
+                "correct_option": "AND, OR, and NOT",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "In the SOP method, what is the next step after creating a truth table for the Boolean expression?",
+                "opt1": "Identify the rows where the expression evaluates to 0",
+                "opt2": "Identify the rows where the expression evaluates to 1",
+                "opt3": "Convert the binary inputs to decimal",
+                "opt4": "Simplify the expression using a Karnaugh map",
+                "correct_option": "Identify the rows where the expression evaluates to 1",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the final step in using the SOP method to simplify a Boolean expression?",
+                "opt1": "Combine the rows with an AND operator",
+                "opt2": "Combine the rows with an OR operator",
+                "opt3": "Convert the expression to hexadecimal",
+                "opt4": "Convert the expression to binary",
+                "correct_option": "Combine the rows with an OR operator",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is an example of a Boolean expression that can be simplified using the SOP method?",
+                "opt1": "F=A+B",
+                "opt2": "F=A*B",
+                "opt3": "F=A XOR B",
+                "opt4": "F=AB+A'B+AB'",
+                "correct_option": "F=AB+A'B+AB'",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "How many rows are in the truth table for a Boolean expression with two input variables?",
+                "opt1": "2",
+                "opt2": "4",
+                "opt3": "6",
+                "opt4": "8",
+                "correct_option": "4",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the purpose of the SOP method in digital logic?",
+                "opt1": "To convert decimal numbers to binary",
+                "opt2": "To simplify complex Boolean expressions",
+                "opt3": "To implement logic gates using a truth table",
+                "opt4": "To convert binary numbers to hexadecimal",
+                "correct_option": "To simplify complex Boolean expressions",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the meaning of \"sum of products\" in the SOP method?",
+                "opt1": "The sum of the input variables in the Boolean expression",
+                "opt2": "The sum of the rows in the truth table where the expression evaluates to 1",
+                "opt3": "The sum of the Boolean operators used in the expression",
+                "opt4": "The sum of the binary values in the truth table",
+                "correct_option": "The sum of the rows in the truth table where the expression evaluates to 1",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the Sum-of-Products (SOP) method used for in digital logic?",
+                "opt1": "To create a truth table for a given Boolean expression",
+                "opt2": "To simplify a given Boolean expression",
+                "opt3": "To convert a decimal number to binary",
+                "opt4": "To perform arithmetic operations on binary numbers",
+                "correct_option": "To simplify a given Boolean expression",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the first step when using the SOP method to simplify a Boolean expression?",
+                "opt1": "Create a truth table for the expression",
+                "opt2": "Identify the rows where the expression evaluates to 1",
+                "opt3": "Write the expression in the standard form",
+                "opt4": "Combine the rows with an OR operator",
+                "correct_option": "Write the expression in the standard form",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the standard form of a Boolean expression?",
+                "opt1": "A form without parentheses",
+                "opt2": "A form without negation",
+                "opt3": "A form with parentheses and Boolean operators",
+                "opt4": "A form with only one variable",
+                "correct_option": "A form with parentheses and Boolean operators",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "How do you identify the rows in a truth table where the expression evaluates to 1 when using the SOP method?",
+                "opt1": "Identify the rows where all variables are 1",
+                "opt2": "Identify the rows where all variables are 0",
+                "opt3": "Identify the rows where the expression is true",
+                "opt4": "Identify the rows where the expression is false",
+                "correct_option": "Identify the rows where the expression is true",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "In the SOP method, what is the next step after identifying the rows where the expression evaluates to 1?",
+                "opt1": "Write down each row in terms of the input variables",
+                "opt2": "Combine the rows with an AND operator",
+                "opt3": "Combine the rows with an OR operator",
+                "opt4": "Create a Karnaugh map",
+                "correct_option": "Write down each row in terms of the input variables",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What Boolean operator is used to combine the rows in the SOP method?",
+                "opt1": "AND",
+                "opt2": "OR",
+                "opt3": "NOT",
+                "opt4": "XOR",
+                "correct_option": "OR",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the final result of the SOP method?",
+                "opt1": "A simplified sum of products expression",
+                "opt2": "A simplified product of sums expression",
+                "opt3": "A truth table",
+                "opt4": "A Karnaugh map",
+                "correct_option": "A simplified sum of products expression",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "How is a row with a value of 0 represented in the SOP method?",
+                "opt1": "With the corresponding variable",
+                "opt2": "With the complement of the corresponding variable",
+                "opt3": "With the negation of the corresponding variable",
+                "opt4": "With a 0",
+                "correct_option": "With the complement of the corresponding variable",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the main advantage of using the SOP method to simplify Boolean expressions?",
+                "opt1": "It results in a smaller truth table",
+                "opt2": "It is easier to understand than other methods",
+                "opt3": "It results in a more efficient circuit design",
+                "opt4": "It works for any type of Boolean expression",
+                "correct_option": "It results in a more efficient circuit design",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Can the SOP method be used to simplify any Boolean expression?",
+                "opt1": "Yes, it can be used for any expression",
+                "opt2": "No, it can only be used for expressions with three variables or fewer",
+                "opt3": "No, it can only be used for expressions in standard form",
+                "opt4": "No, it can only be used for expressions with a small number of terms",
+                "correct_option": "Yes, it can be used for any expression",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the Product-of-Sums (POS) method used for in digital logic?",
+                "opt1": "Generating truth tables",
+                "opt2": "Simplifying Boolean expressions",
+                "opt3": "Building digital circuits",
+                "opt4": "Converting binary to decimal",
+                "correct_option": "Simplifying Boolean expressions",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "In the POS method, what is the first step in simplifying a Boolean expression?",
+                "opt1": "Identify the rows of the truth table where the expression evaluates to 0",
+                "opt2": "Group the variables into terms and combine them with OR operators",
+                "opt3": "Write the expression in the standard form",
+                "opt4": "Combine the terms using AND operators",
+                "correct_option": "Write the expression in the standard form",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "In the POS method, what is the second step in simplifying a Boolean expression?",
+                "opt1": "Identify the rows of the truth table where the expression evaluates to 0",
+                "opt2": "Group the variables into terms and combine them with OR operators",
+                "opt3": "Write the expression in the standard form",
+                "opt4": "Combine the terms using AND operators",
+                "correct_option": "Identify the rows of the truth table where the expression evaluates to 0",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the final result of applying the POS method to a Boolean expression?",
+                "opt1": "A simplified sum of products expression",
+                "opt2": "A simplified product of sums expression",
+                "opt3": "A minimized truth table",
+                "opt4": "A circuit diagram",
+                "correct_option": "A simplified product of sums expression",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "In the POS method, how are the rows of the truth table where the expression evaluates to 0 combined?",
+                "opt1": "Using AND operators",
+                "opt2": "Using OR operators",
+                "opt3": "Using XOR operators",
+                "opt4": "Using NOT operators",
+                "correct_option": "Using OR operators",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "When is the POS method particularly useful?",
+                "opt1": "When the expression contains few terms",
+                "opt2": "When the expression contains many terms",
+                "opt3": "When the expression contains only one variable",
+                "opt4": "When the expression contains only constants",
+                "correct_option": "When the expression contains many terms",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "To complement a Boolean expression using the POS method, what must be done to the final result?",
+                "opt1": "It must be inverted",
+                "opt2": "It must be negated",
+                "opt3": "It must be squared",
+                "opt4": "It must be cubed",
+                "correct_option": "It must be inverted",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is a benefit of using the POS method in digital logic?",
+                "opt1": "It simplifies truth tables",
+                "opt2": "It reduces the size and complexity of digital circuits",
+                "opt3": "It converts decimal to binary",
+                "opt4": "It generates random binary numbers",
+                "correct_option": "It reduces the size and complexity of digital circuits",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the Product-of-Sums method in digital logic?",
+                "opt1": "A method for simplifying Boolean expressions by combining sums of variables",
+                "opt2": "A method for simplifying Boolean expressions by combining products of variables",
+                "opt3": "A method for generating truth tables from Boolean expressions",
+                "opt4": "A method for generating Boolean expressions from truth tables",
+                "correct_option": "A method for simplifying Boolean expressions by combining products of variables",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the dual of the Product-of-Sums method?",
+                "opt1": "Sum-of-Products method",
+                "opt2": "Combinational logic",
+                "opt3": "Sequential logic",
+                "opt4": "None of the above",
+                "correct_option": "Sum-of-Products method",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the first step in the Product-of-Sums method?",
+                "opt1": "Identify the rows where the expression evaluates to 1",
+                "opt2": "Identify the rows where the expression evaluates to 0",
+                "opt3": "Write the expression in terms of the input variables",
+                "opt4": "None of the above",
+                "correct_option": "Identify the rows where the expression evaluates to 0",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the second step in the Product-of-Sums method?",
+                "opt1": "Identify the rows where the expression evaluates to 1",
+                "opt2": "Identify the rows where the expression evaluates to 0",
+                "opt3": "Write the expression in terms of the input variables",
+                "opt4": "None of the above",
+                "correct_option": "Write the expression in terms of the input variables",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the final step in the Product-of-Sums method?",
+                "opt1": "Combine the rows using OR operators",
+                "opt2": "Simplify the expression using DeMorgan's theorem",
+                "opt3": "Combine the rows using AND operators",
+                "opt4": "None of the above",
+                "correct_option": "Combine the rows using OR operators",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is an advantage of using the Product-of-Sums method?",
+                "opt1": "It is faster than other simplification methods",
+                "opt2": "It is easier to understand than other simplification methods",
+                "opt3": "It is more accurate than other simplification methods",
+                "opt4": "It is useful in cases where the expression contains many terms",
+                "correct_option": "It is easier to understand than other simplification methods",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the purpose of applying the Product-of-Sums method to the complement of an expression?",
+                "opt1": "To generate a truth table for the expression",
+                "opt2": "To simplify the expression using DeMorgan's theorem",
+                "opt3": "To generate a simplified expression that is the complement of the original expression",
+                "opt4": "None of the above",
+                "correct_option": "To generate a simplified expression that is the complement of the original expression",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is true about the Product-of-Sums method?",
+                "opt1": "It can only be used with binary variables",
+                "opt2": "It can be used with any type of variable",
+                "opt3": "It can only be used with Boolean expressions that contain AND operators",
+                "opt4": "None of the above",
+                "correct_option": "It can be used with any type of variable",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the advantage of using the Product-of-Sums method over the Sum-of-Products method?",
+                "opt1": "The resulting expression is easier to understand",
+                "opt2": "The resulting expression is shorter and requires fewer gates",
+                "opt3": "The method is faster and requires less computation",
+                "opt4": "None of the above",
+                "correct_option": "The resulting expression is shorter and requires fewer gates",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is an application of the Product-of-Sums method?",
+                "opt1": "Simplifying Boolean expressions in digital circuits",
+                "opt2": "Generating truth tables for digital circuits",
+                "opt3": "Designing sequential logic circuits",
+                "opt4": "None of the above",
+                "correct_option": "Simplifying Boolean expressions in digital circuits",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is a graphical tool used to simplify Boolean expressions?",
+                "opt1": "Truth table",
+                "opt2": "Karnaugh map",
+                "opt3": "Logic gate",
+                "opt4": "Logic circuit",
+                "correct_option": "Karnaugh map",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "How are cells identified in a Karnaugh map?",
+                "opt1": "By their input variable combinations",
+                "opt2": "By their output values",
+                "opt3": "By their row and column numbers",
+                "opt4": "By their position on the map",
+                "correct_option": "By their input variable combinations",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "In the Karnaugh map, which cells can be combined to form a simplified expression?",
+                "opt1": "Diagonal cells",
+                "opt2": "Horizontal cells",
+                "opt3": "Vertical cells",
+                "opt4": "Adjacent cells",
+                "correct_option": "Adjacent cells",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What does SOP stand for in the context of digital logic?",
+                "opt1": "Sum of Products",
+                "opt2": "Product of Sums",
+                "opt3": "Sum of Squares",
+                "opt4": "Product of Squares",
+                "correct_option": "Sum of Products",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is true for the cells of a Karnaugh map?",
+                "opt1": "Each cell can only contain a 0 or a 1",
+                "opt2": "Each cell can contain a 0, 1, or X",
+                "opt3": "Each cell can contain any value between 0 and 1",
+                "opt4": "Each cell can contain a 1, 2, or 3",
+                "correct_option": "Each cell can only contain a 0 or a 1",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is a Karnaugh map used for?",
+                "opt1": "To generate a truth table",
+                "opt2": "To simplify Boolean expressions",
+                "opt3": "To convert a Boolean expression to a logic circuit",
+                "opt4": "To convert a Boolean expression to a logic gate",
+                "correct_option": "To simplify Boolean expressions",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "How many cells does a Karnaugh map have if the corresponding Boolean expression has three input variables?",
+                "opt1": "12",
+                "opt2": "8",
+                "opt3": "16",
+                "opt4": "4",
+                "correct_option": "8",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is not a valid combination of input variables in a Karnaugh map for a two-variable expression?",
+                "opt1": "00",
+                "opt2": "01",
+                "opt3": "10",
+                "opt4": "21",
+                "correct_option": "21",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "How are adjacent cells identified in a Karnaugh map?",
+                "opt1": "By diagonal lines",
+                "opt2": "By vertical lines",
+                "opt3": "By horizontal lines",
+                "opt4": "Both b and c",
+                "correct_option": "Both b and c",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following is a simplified expression for the Karnaugh map shown below?",
+                "opt1": "AB + BC + AD",
+                "opt2": "AB + CD",
+                "opt3": "AC + BD",
+                "opt4": "ACD + BCD",
+                "correct_option": "AB + CD",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "How is a truth table converted into a Karnaugh map?",
+                "opt1": "By graphing the data points",
+                "opt2": "By plotting the input and output values on a grid",
+                "opt3": "By counting the number of 0's and 1's",
+                "opt4": "By entering the data into a computer program",
+                "correct_option": "By plotting the input and output values on a grid",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following Boolean expressions is equivalent to the Karnaugh map shown below?",
+                "opt1": "AB + BC + AD",
+                "opt2": "AB + CD",
+                "opt3": "AC + BD",
+                "opt4": "ACD + BCD",
+                "correct_option": "AB + CD",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "How many cells in a Karnaugh map can be combined to form a simplified expression?",
+                "opt1": "1",
+                "opt2": "2",
+                "opt3": "3",
+                "opt4": "Both A and B",
+                "correct_option": "Both A and B",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "How is a simplified expression converted back into a standard SOP or POS expression?",
+                "opt1": "By using De Morgan's theorem",
+                "opt2": "By applying the distributive property",
+                "opt3": "By factoring out common terms",
+                "opt4": "Both A and B",
+                "correct_option": "Both A and B",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the frequency of a triangle wave generator determined by?",
+                "opt1": "The time constant of the RC circuit",
+                "opt2": "The resonant frequency of the tank circuit",
+                "opt3": "The frequency of the crystal",
+                "opt4": "The input voltage of the oscillator",
+                "correct_option": "The time constant of the RC circuit",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the frequency of a triangle wave generator determined by?",
+                "opt1": "The time period of the waveform",
+                "opt2": "The amplitude of the waveform",
+                "opt3": "The duty cycle of the waveform",
+                "opt4": "The slope of the waveform",
+                "correct_option": "The slope of the waveform",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following is not a valid combination of input variables in a Karnaugh map for a two-variable expression?",
+                "opt1": "00",
+                "opt2": "01",
+                "opt3": "10",
+                "opt4": "21",
+                "correct_option": "21",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is a gated flip-flop?",
+                "opt1": "A type of logic gate",
+                "opt2": "A type of sequential circuit",
+                "opt3": "A type of combinational circuit",
+                "opt4": "A type of adder",
+                "correct_option": "A type of sequential circuit",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which type of flip-flop uses an AND gate to control the clock input?",
+                "opt1": "D flip-flop",
+                "opt2": "T flip-flop",
+                "opt3": "JK flip-flop",
+                "opt4": "SR flip-flop",
+                "correct_option": "T flip-flop",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the advantage of using gated flip-flops?",
+                "opt1": "They are faster than regular flip-flops",
+                "opt2": "They use less power than regular flip-flops",
+                "opt3": "They can selectively enable or disable the clock input",
+                "opt4": "They can be used in parallel circuits",
+                "correct_option": "They can selectively enable or disable the clock input",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which type of flip-flop uses a NAND gate to control the J and K inputs?",
+                "opt1": "D flip-flop",
+                "opt2": "T flip-flop",
+                "opt3": "JK flip-flop",
+                "opt4": "SR flip-flop",
+                "correct_option": "JK flip-flop",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What happens to the output of a T gated flip-flop when the clock and gate inputs are both high?",
+                "opt1": "The output remains the same",
+                "opt2": "The output toggles between 0 and 1",
+                "opt3": "The output becomes 0",
+                "opt4": "The output becomes 1",
+                "correct_option": "The output toggles between 0 and 1",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is not a type of gated flip-flop?",
+                "opt1": "D flip-flop",
+                "opt2": "SR flip-flop",
+                "opt3": "T flip-flop",
+                "opt4": "JK flip-flop",
+                "correct_option": "SR flip-flop",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the output of a binary decoder if the input code is all zeros?",
+                "opt1": "The first output line will be selected",
+                "opt2": "The last output line will be selected",
+                "opt3": "No output lines will be selected",
+                "opt4": "None of the above",
+                "correct_option": "The first output line will be selected",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which type of decoder is commonly used in digital clocks and calculators?",
+                "opt1": "Binary decoder",
+                "opt2": "BCD decoder",
+                "opt3": "Priority decoder",
+                "opt4": "None of the above",
+                "correct_option": "BCD decoder",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is an advantage of a decoder?",
+                "opt1": "It can be used to convert any type of code into an output signal",
+                "opt2": "It is easy to implement and use",
+                "opt3": "It can be used in sequential circuits",
+                "opt4": "None of the above",
+                "correct_option": "It is easy to implement and use",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the purpose of an encoder?",
+                "opt1": "To convert an input signal into a coded output signal",
+                "opt2": "To store and retrieve digital data",
+                "opt3": "To perform arithmetic and logical operations on binary data",
+                "opt4": "To generate an output based on the input and the previous state",
+                "correct_option": "To convert an input signal into a coded output signal",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the difference between a binary encoder and a priority encoder?",
+                "opt1": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+                "opt2": "A binary encoder generates a binary code corresponding to the highest priority input signal, while a priority encoder converts a binary input signal into an n-bit coded output signal.",
+                "opt3": "A binary encoder and a priority encoder are the same thing.",
+                "opt4": "A binary encoder and a priority encoder have no difference.",
+                "correct_option": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the advantage of using a priority encoder?",
+                "opt1": "It simplifies the design of complex digital circuits",
+                "opt2": "It reduces the number of input lines required",
+                "opt3": "It increases the speed of data processing",
+                "opt4": "All of the above",
+                "correct_option": "It simplifies the design of complex digital circuits",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is NOT a type of encoder?",
+                "opt1": "Binary encoder",
+                "opt2": "Priority encoder",
+                "opt3": "BCD encoder",
+                "opt4": "Multiplexer",
+                "correct_option": "Multiplexer",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the purpose of an encoder in digital logic?",
+                "opt1": "To convert a binary input signal into an n-bit coded output signal",
+                "opt2": "To generate a binary code corresponding to the highest priority input signal",
+                "opt3": "To convert a decimal input signal into a 4-bit BCD output signal",
+                "opt4": "To perform arithmetic operations on binary numbers",
+                "correct_option": "To convert a binary input signal into an n-bit coded output signal",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "How many input lines and output lines does a binary encoder have?",
+                "opt1": "n input lines and m output lines",
+                "opt2": "2^n input lines and n output lines",
+                "opt3": "n input lines and log2n output lines",
+                "opt4": "10 input lines and 4 output lines",
+                "correct_option": "2^n input lines and n output lines",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the purpose of a priority encoder in digital logic?",
+                "opt1": "To convert a binary input signal into an n-bit coded output signal",
+                "opt2": "To generate a binary code corresponding to the highest priority input signal",
+                "opt3": "To convert a decimal input signal into a 4-bit BCD output signal",
+                "opt4": "To perform arithmetic operations on binary numbers",
+                "correct_option": "To generate a binary code corresponding to the highest priority input signal",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "How many input lines and output lines does a priority encoder have?",
+                "opt1": "n input lines and m output lines",
+                "opt2": "2^n input lines and n output lines",
+                "opt3": "n input lines and log2n output lines",
+                "opt4": "10 input lines and 4 output lines",
+                "correct_option": "n input lines and log2n output lines",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the purpose of a BCD encoder in digital logic?",
+                "opt1": "To convert a binary input signal into an n-bit coded output signal",
+                "opt2": "To generate a binary code corresponding to the highest priority input signal",
+                "opt3": "To convert a decimal input signal into a 4-bit BCD output signal",
+                "opt4": "To perform arithmetic operations on binary numbers",
+                "correct_option": "To convert a decimal input signal into a 4-bit BCD output signal",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "How many input lines and output lines does a BCD encoder have?",
+                "opt1": "n input lines and m output lines",
+                "opt2": "2^n input lines and n output lines",
+                "opt3": "n input lines and log2n output lines",
+                "opt4": "10 input lines and 4 output lines",
+                "correct_option": "10 input lines and 4 output lines",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the difference between a binary encoder and a priority encoder?",
+                "opt1": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+                "opt2": "A binary encoder generates a binary code corresponding to the highest priority input signal, while a priority encoder converts a binary input signal into an n-bit coded output signal.",
+                "opt3": "A binary encoder converts a decimal input signal into a 4-bit BCD output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+                "opt4": "A binary encoder has 2^n input lines and n output lines, while a priority encoder has n input lines and log2n output lines.",
+                "correct_option": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the purpose of using an encoder in data communication?",
+                "opt1": "To convert analog signals into digital signals",
+                "opt2": "To compress digital signals for efficient transmission",
+                "opt3": "To encrypt digital signals for secure transmission",
+                "opt4": "To convert digital signals into a coded output signal for transmission",
+                "correct_option": "To convert digital signals into a coded output signal for transmission",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the purpose of using a BCD encoder in digital signal processing?",
+                "opt1": "To convert a binary input signal into an n-bit coded output signal",
+                "opt2": "To generate a binary code corresponding to the highest priority input signal",
+                "opt3": "To convert a decimal input signal into a 4-bit BCD output signal",
+                "opt4": "To perform arithmetic operations on binary numbers",
+                "correct_option": "To convert a decimal input signal into a 4-bit BCD output signal",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the result of binary addition of 0110 and 0101?",
+                "opt1": "1101",
+                "opt2": "1111",
+                "opt3": "1011",
+                "opt4": "0011",
+                "correct_option": "1011",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is the correct binary addition of 1111 and 0011?",
+                "opt1": "11010",
+                "opt2": "10010",
+                "opt3": "10100",
+                "opt4": "10000",
+                "correct_option": "10010",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the binary addition of 10101 and 11111?",
+                "opt1": "110010",
+                "opt2": "110111",
+                "opt3": "110110",
+                "opt4": "100010",
+                "correct_option": "110100",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the binary addition of 1101 and 0110?",
+                "opt1": "1110",
+                "opt2": "10010",
+                "opt3": "10011",
+                "opt4": "1100",
+                "correct_option": "10011",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following represents the correct binary addition of 1010 and 0110?",
+                "opt1": "1000",
+                "opt2": "1011",
+                "opt3": "10000",
+                "opt4": "11111",
+                "correct_option": "10000",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the result of binary addition of 11111 and 00001?",
+                "opt1": "11110",
+                "opt2": "100000",
+                "opt3": "10000",
+                "opt4": "11111",
+                "correct_option": "100000",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following represents the correct binary addition of 111 and 101?",
+                "opt1": "1100",
+                "opt2": "1010",
+                "opt3": "1111",
+                "opt4": "1001",
+                "correct_option": "1100",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the result of binary addition of 0101 and 0010?",
+                "opt1": "0111",
+                "opt2": "1000",
+                "opt3": "1011",
+                "opt4": "1001",
+                "correct_option": "0111",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the binary sum of 1011 and 1101?",
+                "opt1": "10011",
+                "opt2": "10101",
+                "opt3": "0110",
+                "opt4": "0100",
+                "correct_option": "11000",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the binary sum of 1110 and 0111?",
+                "opt1": "10001",
+                "opt2": "10101",
+                "opt3": "1110",
+                "opt4": "100110",
+                "correct_option": "10101",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the binary sum of 10101010 and 11001100?",
+                "opt1": "10111111",
+                "opt2": "10110110",
+                "opt3": "1101-",
+                "opt4": "0100",
+                "correct_option": "101110110",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the binary sum of 11111111 and 00000001?",
+                "opt1": "11111110",
+                "opt2": "11111111",
+                "opt3": "10100100",
+                "opt4": "100000000",
+                "correct_option": "100000000",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following represents the correct binary addition of 1101 and 0011?",
+                "opt1": "1111",
+                "opt2": "1010",
+                "opt3": "10011100",
+                "opt4": "00000010",
+                "correct_option": "10000",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the binary addition of 1010 and 1101?",
+                "opt1": "1000",
+                "opt2": "1111",
+                "opt3": "10111",
+                "opt4": "00000000",
+                "correct_option": "10111",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the carry generated when adding 1101 and 1011?",
+                "opt1": "1",
+                "opt2": "0",
+                "opt3": "2",
+                "opt4": "3",
+                "correct_option": "1",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the binary sum of 111 and 101?",
+                "opt1": "1011",
+                "opt2": "1110",
+                "opt3": "110",
+                "opt4": "1001",
+                "correct_option": "1100",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the result of adding 1011 and 1110 using a full adder circuit?",
+                "opt1": "1101",
+                "opt2": "10000",
+                "opt3": "11001",
+                "opt4": "1010",
+                "correct_option": "11001",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the binary sum of 1111 and 0111 using a half adder circuit?",
+                "opt1": "1110",
+                "opt2": "1101",
+                "opt3": "1000",
+                "opt4": "10110",
+                "correct_option": "10110",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the result of adding 1011 and 1100 using a carry look-ahead adder (CLA) circuit?",
+                "opt1": "1101",
+                "opt2": "10100",
+                "opt3": "10111",
+                "opt4": "10011",
+                "correct_option": "10111",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the binary sum of 1001 and 0110?",
+                "opt1": "1011",
+                "opt2": "1110",
+                "opt3": "1111",
+                "opt4": "0011",
+                "correct_option": "1111",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the complement of the binary number 1111?",
+                "opt1": "1110",
+                "opt2": "0000",
+                "opt3": "0001",
+                "opt4": "1000",
+                "correct_option": "0000",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the complement of the binary number 0011?",
+                "opt1": "0010",
+                "opt2": "1101",
+                "opt3": "1100",
+                "opt4": "0100",
+                "correct_option": "1100",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the result of subtracting the binary number 0110 from the binary number 1011?",
+                "opt1": "1001",
+                "opt2": "0101",
+                "opt3": "0010",
+                "opt4": "1101",
+                "correct_option": "0101",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the complement of the binary number 0001?",
+                "opt1": "0000",
+                "opt2": "1110",
+                "opt3": "1111",
+                "opt4": "0010",
+                "correct_option": "1110",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the result of subtracting the binary number 1101 from the binary number 1110?",
+                "opt1": "0000",
+                "opt2": "0001",
+                "opt3": "0011",
+                "opt4": "0111",
+                "correct_option": "0001",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the complement of the binary number 0101?",
+                "opt1": "0100",
+                "opt2": "1010",
+                "opt3": "1011",
+                "opt4": "1001",
+                "correct_option": "1010",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the result of subtracting the binary number 0010 from the binary number 1111?",
+                "opt1": "0101",
+                "opt2": "1101",
+                "opt3": "0110",
+                "opt4": "1011",
+                "correct_option": "1101",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the complement of the binary number 1000?",
+                "opt1": "0111",
+                "opt2": "1011",
+                "opt3": "1001",
+                "opt4": "1001",
+                "correct_option": "0111",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the first step in binary subtraction?",
+                "opt1": "Find the complement of the minuend",
+                "opt2": "Invert all the bits of the minuend",
+                "opt3": "Find the complement of the subtrahend",
+                "opt4": "Invert all the bits of the subtrahend",
+                "correct_option": "Find the complement of the subtrahend",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the complement of the binary number 1011?",
+                "opt1": "1100",
+                "opt2": "0100",
+                "opt3": "1000",
+                "opt4": "0001",
+                "correct_option": "0100",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the binary equivalent of the decimal value 7?",
+                "opt1": "110",
+                "opt2": "101",
+                "opt3": "111",
+                "opt4": "1110",
+                "correct_option": "111",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the result of subtracting the binary number 1101 from the binary number 1111?",
+                "opt1": "0010",
+                "opt2": "0100",
+                "opt3": "0001",
+                "opt4": "1110",
+                "correct_option": "0010",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the second step in binary subtraction?",
+                "opt1": "Find the complement of the subtrahend",
+                "opt2": "Invert all the bits of the subtrahend",
+                "opt3": "Find the complement of the minuend",
+                "opt4": "Invert all the bits of the minuend",
+                "correct_option": "Invert all the bits of the subtrahend",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the binary equivalent of the decimal value 10?",
+                "opt1": "1010",
+                "opt2": "1100",
+                "opt3": "1110",
+                "opt4": "1001",
+                "correct_option": "1010",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the complement of the binary number 1001?",
+                "opt1": "0110",
+                "opt2": "0111",
+                "opt3": "1010",
+                "opt4": "1011",
+                "correct_option": "0110",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the result of subtracting the binary number 1111 from the binary number 1111?",
+                "opt1": "1111",
+                "opt2": "0000",
+                "opt3": "1110",
+                "opt4": "0001",
+                "correct_option": "0000",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the third step in binary subtraction?",
+                "opt1": "Add the complement to the minuend using binary subtraction",
+                "opt2": "Add the complement to the minuend using binary addition",
+                "opt3": "Subtract the complement from the minuend using binary subtraction",
+                "opt4": "Subtract the complement from the minuend using binary addition",
+                "correct_option": "Add the complement to the minuend using binary addition",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the binary equivalent of the decimal value 13?",
+                "opt1": "1011",
+                "opt2": "1101",
+                "opt3": "1110",
+                "opt4": "1001",
+                "correct_option": "1101",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the difference between unsigned and signed binary numbers?",
+                "opt1": "Unsigned binary numbers have a signed bit while signed binary numbers do not.",
+                "opt2": "Unsigned binary numbers can represent only positive numbers while signed binary numbers can represent both positive and negative numbers.",
+                "opt3": "Unsigned binary numbers use a different base than signed binary numbers.",
+                "opt4": "There is no difference between unsigned and signed binary numbers.",
+                "correct_option": "Unsigned binary numbers can represent only positive numbers while signed binary numbers can represent both positive and negative numbers.",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is the most significant bit in an 8-bit signed binary number?",
+                "opt1": "Bit 0",
+                "opt2": "Bit 1",
+                "opt3": "Bit 7",
+                "opt4": "There is no most significant bit",
+                "correct_option": "Bit 7",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the range of 8-bit signed binary numbers?",
+                "opt1": "0 to 255",
+                "opt2": "-128 to 127",
+                "opt3": "-127 to 127",
+                "opt4": "0 to 127",
+                "correct_option": "-128 to 127",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the range of unsigned 8-bit binary numbers?",
+                "opt1": "0 to 127",
+                "opt2": "-128 to 127",
+                "opt3": "-127 to 127",
+                "opt4": "0 to 255",
+                "correct_option": "0 to 255",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following operations can be performed on signed binary numbers but not on unsigned binary numbers?",
+                "opt1": "Addition",
+                "opt2": "Subtraction",
+                "opt3": "Multiplication",
+                "opt4": "Division",
+                "correct_option": "Subtraction",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following operations can be performed on unsigned binary numbers?",
+                "opt1": "Only addition",
+                "opt2": "Addition and subtraction",
+                "opt3": "Multiplication and division",
+                "opt4": "Only subtraction",
+                "correct_option": "Addition and subtraction",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is the correct representation of the unsigned binary number 1011 in decimal?",
+                "opt1": "10",
+                "opt2": "11",
+                "opt3": "12",
+                "opt4": "9",
+                "correct_option": "11",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the range of unsigned 8-bit binary numbers?",
+                "opt1": "-128 to 127",
+                "opt2": "0 to 255",
+                "opt3": "0 to 127",
+                "opt4": "0 to 128",
+                "correct_option": "0 to 255",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is the correct representation of the signed binary number 11111111 in decimal using two's complement?",
+                "opt1": "-127",
+                "opt2": "-128",
+                "opt3": "127",
+                "opt4": "-1",
+                "correct_option": "-1",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the range of signed 8-bit binary numbers using two's complement?",
+                "opt1": "-127 to 128",
+                "opt2": "-128 to 127",
+                "opt3": "-256 to 255",
+                "opt4": "-255 to 256",
+                "correct_option": "-128 to 127",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following operations can be performed on signed binary numbers using two's complement?",
+                "opt1": "Only addition",
+                "opt2": "Addition and subtraction",
+                "opt3": "Multiplication and division",
+                "opt4": "Only subtraction",
+                "correct_option": "Addition and subtraction",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the result of adding the signed binary numbers 0111 and 1010 using two's complement?",
+                "opt1": "0001",
+                "opt2": "1101",
+                "opt3": "1111",
+                "opt4": "1001",
+                "correct_option": "0001",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the result of subtracting the signed binary numbers 1010 and 0111 using two's complement?",
+                "opt1": "0001",
+                "opt2": "1101",
+                "opt3": "1001",
+                "opt4": "1111",
+                "correct_option": "0011",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is the correct representation of the signed binary number 11111000 in decimal using two's complement?",
+                "opt1": "-8",
+                "opt2": "-24",
+                "opt3": "8",
+                "opt4": "24",
+                "correct_option": "-8",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the complement of the binary number 1010?",
+                "opt1": "0100",
+                "opt2": "0010",
+                "opt3": "1001",
+                "opt4": "0110",
+                "correct_option": "0101",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the result of adding the signed binary numbers 0110 and 1011?",
+                "opt1": "1101",
+                "opt2": "1001",
+                "opt3": "0001",
+                "opt4": "0010",
+                "correct_option": "0001",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is the two's complement of the binary number 1101?",
+                "opt1": "0010",
+                "opt2": "0011",
+                "opt3": "0101",
+                "opt4": "0110",
+                "correct_option": "0011",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the result of multiplying the unsigned binary numbers 1010 and 0011?",
+                "opt1": "0010",
+                "opt2": "0110",
+                "opt3": "1110",
+                "opt4": "1011",
+                "correct_option": "11110",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the result of subtracting the signed binary number 0101 from the signed binary number 1010?",
+                "opt1": "1101",
+                "opt2": "1001",
+                "opt3": "0101",
+                "opt4": "0011",
+                "correct_option": "0101",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is the sign bit in an 8-bit signed binary number?",
+                "opt1": "Bit 0",
+                "opt2": "Bit 1",
+                "opt3": "Bit 7",
+                "opt4": "There is no sign bit",
+                "correct_option": "Bit 7",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following describes an asynchronous counter?",
+                "opt1": "A counter that uses external clock pulses to advance its count",
+                "opt2": "A counter that uses feedback to generate its own clock pulses",
+                "opt3": "A counter that counts in parallel",
+                "opt4": "A counter that counts in series",
+                "correct_option": "A counter that uses external clock pulses to advance its count",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which type of asynchronous counter is also known as a ripple counter?",
+                "opt1": "Synchronous counter",
+                "opt2": "Binary counter",
+                "opt3": "Johnson counter",
+                "opt4": "Modulus counter",
+                "correct_option": "Binary counter",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "How many flip-flops are needed to implement a 3-bit asynchronous counter?",
+                "opt1": "2",
+                "opt2": "3",
+                "opt3": "4",
+                "opt4": "5",
+                "correct_option": "3",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the maximum number of states a 4-bit asynchronous counter can have?",
+                "opt1": "4",
+                "opt2": "8",
+                "opt3": "12",
+                "opt4": "16",
+                "correct_option": "16",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "In an asynchronous counter, which flip-flop receives the external clock signal?",
+                "opt1": "The first flip-flop",
+                "opt2": "The last flip-flop",
+                "opt3": "All flip-flops receive the external clock signal",
+                "opt4": "None of the flip-flops receive the external clock signal",
+                "correct_option": "The first flip-flop",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is an advantage of asynchronous counters over synchronous counters?",
+                "opt1": "Asynchronous counters are faster",
+                "opt2": "Asynchronous counters are more reliable",
+                "opt3": "Asynchronous counters require fewer components",
+                "opt4": "Asynchronous counters are easier to design",
+                "correct_option": "Asynchronous counters require fewer components",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "In a 3-bit asynchronous counter, what is the maximum count sequence that can be generated?",
+                "opt1": "0,1,2,3,4,5,6,7",
+                "opt2": "0,1,2,3,2,1,0",
+                "opt3": "0,1,2, 1.0, 1.2,1.D",
+                "opt4": "0, 1, 0, 1 0, 1, 0, 1",
+                "correct_option": "0,1,2,3,4,5,6,7",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which type of asynchronous counter uses a series of D flip-flops?",
+                "opt1": "Binary counter",
+                "opt2": "Ripple counter",
+                "opt3": "Johnson counter",
+                "opt4": "Modulus counter",
+                "correct_option": "Johnson counter",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "In a Johnson counter, how many states are there for n flip-flops?",
+                "opt1": "2n",
+                "opt2": "n",
+                "opt3": "n/2",
+                "opt4": "2^n-1",
+                "correct_option": "2n",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the main disadvantage of asynchronous counters?",
+                "opt1": "They are slower than synchronous counters",
+                "opt2": "They suffer from glitches in the output waveform",
+                "opt3": "They are more complex to design than synchronous counters",
+                "opt4": "They are not suitable for use in digital circuits",
+                "correct_option": "They are slower than synchronous counters",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is an asynchronous counter?",
+                "opt1": "A counter that uses asynchronous clock",
+                "opt2": "A counter that uses synchronous clock pulses",
+                "opt3": "A counter that uses both synchronous and asynchronous clock pulses",
+                "opt4": "A counter that does not use clock pulses",
+                "correct_option": "A counter that uses asynchronous clock",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the basic building block of an asynchronous counter?",
+                "opt1": "Flip-flop",
+                "opt2": "Encoder",
+                "opt3": "Decoder",
+                "opt4": "Multiplexer",
+                "correct_option": "Flip-flop",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "How many flip-flops are required for a 3-bit asynchronous counter?",
+                "opt1": "1",
+                "opt2": "2",
+                "opt3": "3",
+                "opt4": "4",
+                "correct_option": "3",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which type of flip-flop is used in an asynchronous counter?",
+                "opt1": "D flip-flop",
+                "opt2": "T flip-flop",
+                "opt3": "JK flip-flop",
+                "opt4": "All of the above",
+                "correct_option": "All of the above",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the maximum count for a 4-bit asynchronous counter?",
+                "opt1": "8",
+                "opt2": "16",
+                "opt3": "32",
+                "opt4": "64",
+                "correct_option": "16",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the advantage of using an asynchronous counter over a synchronous counter?",
+                "opt1": "Higher speed",
+                "opt2": "Lower power consumption",
+                "opt3": "Lower cost",
+                "opt4": "Simpler design",
+                "correct_option": "Simpler design",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "In an asynchronous counter, what is the function of the enable input?",
+                "opt1": "To start the counting process",
+                "opt2": "To stop the counting process",
+                "opt3": "To reset the counter",
+                "opt4": "To enable or disable the counting process",
+                "correct_option": "To enable or disable the counting process",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the propagation delay of an asynchronous counter?",
+                "opt1": "The time it takes for the counter to start counting",
+                "opt2": "The time it takes for the counter to stop counting",
+                "opt3": "The time it takes for the output of one flip-flop to propagate to the input of the next flip-flop",
+                "opt4": "The time it takes for the clock pulse to propagate through the counter",
+                "correct_option": "The time it takes for the output of one flip-flop to propagate to the input of the next flip-flop",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the drawback of using an asynchronous counter?",
+                "opt1": "Higher power consumption",
+                "opt2": "Higher cost",
+                "opt3": "Limited speed",
+                "opt4": "Limited scalability",
+                "correct_option": "Limited speed",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is an example of an application that requires an asynchronous counter?",
+                "opt1": "Digital clock",
+                "opt2": "Traffic light controller",
+                "opt3": "Computer processor",
+                "opt4": "Wireless router",
+                "correct_option": "Digital clock",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is a synchronous counter?",
+                "opt1": "A counter that uses synchronous clock pulses",
+                "opt2": "A counter that uses asynchronous clock pulses",
+                "opt3": "A counter that uses both synchronous and asynchronous clock pulses",
+                "opt4": "A counter that does not use clock pulses",
+                "correct_option": "A counter that uses synchronous clock pulses",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the basic building block of a synchronous counter?",
+                "opt1": "Flip-flop",
+                "opt2": "Encoder",
+                "opt3": "Decoder",
+                "opt4": "Multiplexer",
+                "correct_option": "Flip-flop",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "How many flip-flops are required for a 4-bit synchronous counter?",
+                "opt1": "1",
+                "opt2": "2",
+                "opt3": "3",
+                "opt4": "4",
+                "correct_option": "4",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which type of flip-flop is used in a synchronous counter?",
+                "opt1": "D flip-flop",
+                "opt2": "T flip-flop",
+                "opt3": "JK flip-flop",
+                "opt4": "All of the above",
+                "correct_option": "All of the above",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the maximum count for a 3-bit synchronous counter?",
+                "opt1": "4",
+                "opt2": "6",
+                "opt3": "8",
+                "opt4": "10",
+                "correct_option": "8",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the advantage of using a synchronous counter over an asynchronous counter?",
+                "opt1": "Simpler design",
+                "opt2": "Lower power consumption",
+                "opt3": "Lower cost",
+                "opt4": "Higher speed",
+                "correct_option": "Higher speed",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "In a synchronous counter, what is the function of the clock input?",
+                "opt1": "To start the counting process",
+                "opt2": "To stop the counting process",
+                "opt3": "To reset the counter",
+                "opt4": "To synchronize the counting process",
+                "correct_option": "To synchronize the counting process",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the propagation delay of a synchronous counter?",
+                "opt1": "The time it takes for the counter to start counting",
+                "opt2": "The time it takes for the counter to stop counting",
+                "opt3": "The time it takes for the output of one flip-flop to propagate to the input of the next flip-flop",
+                "opt4": "The time it takes for the clock pulse to propagate through the counter",
+                "correct_option": "The time it takes for the clock pulse to propagate through the counter",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the drawback of using a synchronous counter?",
+                "opt1": "Higher power consumption",
+                "opt2": "Higher cost",
+                "opt3": "Limited speed",
+                "opt4": "Limited scalability",
+                "correct_option": "Higher power consumption",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is an example of an application that requires a synchronous counter?",
+                "opt1": "Digital clock",
+                "opt2": "Traffic light controller",
+                "opt3": "Computer processor",
+                "opt4": "Wireless router",
+                "correct_option": "Computer processor",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is a microprocessor?",
+                "opt1": "A computer memory device",
+                "opt2": "A device that performs arithmetic and logical operations",
+                "opt3": "A device that stores data",
+                "opt4": "A device that displays data",
+                "correct_option": "A device that performs arithmetic and logical operations",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is not a component of the internal architecture of a microprocessor?",
+                "opt1": "Arithmetic and Logic Unit (ALU)",
+                "opt2": "Control Unit (CU)",
+                "opt3": "Memory Unit",
+                "opt4": "Input/Output Unit (IOU)",
+                "correct_option": "Input/Output Unit (IOU)",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the function of the Control Unit (CU) in a microprocessor?",
+                "opt1": "It performs arithmetic and logical operations",
+                "opt2": "It stores data",
+                "opt3": "It controls the flow of data within the microprocessor",
+                "opt4": "It interfaces with input/output devices",
+                "correct_option": "It controls the flow of data within the microprocessor",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the function of the Arithmetic and Logic Unit (ALU) in a microprocessor?",
+                "opt1": "It controls the flow of data within the microprocessor",
+                "opt2": "It performs arithmetic and logical operations",
+                "opt3": "It stores data",
+                "opt4": "It interfaces with Input/output devices",
+                "correct_option": "It performs arithmetic and logical operations",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is not a feature of a microprocessor?",
+                "opt1": "Interrupt handling capability",
+                "opt2": "Pipelining",
+                "opt3": "Cache memory",
+                "opt4": "Secondary storage",
+                "correct_option": "Secondary storage",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is pipelining in a microprocessor?",
+                "opt1": "The process of dividing instructions into smaller parts",
+                "opt2": "The process of executing multiple instructions simultaneously",
+                "opt3": "The process of storing frequently accessed data",
+                "opt4": "The process of handling interrupts",
+                "correct_option": "The process of executing multiple instructions simultaneously",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the function of the Memory Management Unit (MMU) in a microprocessor?",
+                "opt1": "It performs arithmetic and logical operations",
+                "opt2": "It stores data",
+                "opt3": "It manages the memory resources of the system",
+                "opt4": "It interfaces with input/output devices",
+                "correct_option": "It manages the memory resources of the system",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is an example of an instruction set architecture (ISA)?",
+                "opt1": "HTML",
+                "opt2": "x86",
+                "opt3": "Java",
+                "opt4": "Python",
+                "correct_option": "x86",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is cache memory in a microprocessor?",
+                "opt1": "A type of secondary storage",
+                "opt2": "A type of RAM",
+                "opt3": "A type of memory that stores frequently accessed data",
+                "opt4": "A type of input/output device",
+                "correct_option": "A type of memory that stores frequently accessed data",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is a type of bus in a microprocessor?",
+                "opt1": "Address bus",
+                "opt2": "Data bus",
+                "opt3": "Control bus",
+                "opt4": "All of the above",
+                "correct_option": "All of the above",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the function of the ALU in a microprocessor?",
+                "opt1": "To execute instructions",
+                "opt2": "To store data",
+                "opt3": "To perform arithmetic and logical operations",
+                "opt4": "To communicate with external devices",
+                "correct_option": "To perform arithmetic and logical operations",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is NOT a register in a microprocessor?",
+                "opt1": "Program Counter",
+                "opt2": "Instruction Register",
+                "opt3": "Data Memory Register",
+                "opt4": "Input Output Register",
+                "correct_option": "Input Output Register",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the function of the Program Counter in a microprocessor?",
+                "opt1": "To store data",
+                "opt2": "To execute instructions",
+                "opt3": "To perform arithmetic and logical operations",
+                "opt4": "To store the address of the next instruction to be executed",
+                "correct_option": "To store the address of the next instruction to be executed",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which bus is used to transfer data between the CPU and memory in a microprocessor?",
+                "opt1": "Address bus",
+                "opt2": "Data bus",
+                "opt3": "Control bus",
+                "opt4": "All of the above",
+                "correct_option": "Data bus",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is NOT a component of the Control Unit in a microprocessor?",
+                "opt1": "Instruction Decoder",
+                "opt2": "Clock Generator",
+                "opt3": "Address Register",
+                "opt4": "Control Logic",
+                "correct_option": "Address Register",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the function of the Instruction Register in a microprocessor?",
+                "opt1": "To store data",
+                "opt2": "To execute instructions",
+                "opt3": "To perform arithmetic and logical operations",
+                "opt4": "To store the current instruction being executed",
+                "correct_option": "To store the current instruction being executed",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the purpose of the Interrupt Controller in a microprocessor?",
+                "opt1": "To generate interrupts",
+                "opt2": "To handle interrupts",
+                "opt3": "To store interrupt vectors",
+                "opt4": "To communicate with external devices",
+                "correct_option": "To handle interrupts",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is NOT a feature of a microprocessor?",
+                "opt1": "Multitasking",
+                "opt2": "Multiprocessing",
+                "opt3": "Multithreading",
+                "opt4": "Multiuser",
+                "correct_option": "Multiuser",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following components is responsible for fetching instructions from memory in a microprocessor?",
+                "opt1": "Control Unit",
+                "opt2": "ALU",
+                "opt3": "Interrupt Controller",
+                "opt4": "Input/Output Controller",
+                "correct_option": "Control Unit",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is an example of a microprocessor?",
+                "opt1": "Intel Core i7",
+                "opt2": "Nvidia GeForce RTX 3080",
+                "opt3": "Raspberry Pi 4",
+                "opt4": "Apple M1",
+                "correct_option": "Intel Core i7",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is Assembly Language?",
+                "opt1": "A high-level programming language",
+                "opt2": "A low-level programming language",
+                "opt3": "An interpreted programming language",
+                "opt4": "An object-oriented programming language",
+                "correct_option": "A low-level programming language",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is NOT a basic data type in Assembly Language?",
+                "opt1": "Integer",
+                "opt2": "Floating-point",
+                "opt3": "Character",
+                "opt4": "Boolean",
+                "correct_option": "Boolean",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following is the correct syntax to define a variable in Assembly Language?",
+                "opt1": "VAR name, data type, value",
+                "opt2": "name data type value",
+                "opt3": "data type name value",
+                "opt4": "NAME VAR data type, value",
+                "correct_option": "name data type value",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the function of the Assembler in Assembly Language Programming?",
+                "opt1": "To execute Assembly Language code",
+                "opt2": "To translate Assembly Language code into machine code",
+                "opt3": "To debug Assembly Language code",
+                "opt4": "To optimize Assembly Language code",
+                "correct_option": "To translate Assembly Language code into machine code",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which register is used to store the memory address in Assembly Language Programming?",
+                "opt1": "AX",
+                "opt2": "BX",
+                "opt3": "CX",
+                "opt4": "IP",
+                "correct_option": "BX",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is NOT a branch instruction in Assembly Language Programming?",
+                "opt1": "JMP",
+                "opt2": "JZ",
+                "opt3": "JNZ",
+                "opt4": "MOV",
+                "correct_option": "MOV",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the function of the RET instruction in Assembly Language Programming?",
+                "opt1": "To return a value from a function",
+                "opt2": "To jump to a memory address",
+                "opt3": "To store a value in a register",
+                "opt4": "To return from a subroutine",
+                "correct_option": "To return from a subroutine",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following is the correct syntax for the ADD instruction in Assembly Language Programming?",
+                "opt1": "ADD source, destination",
+                "opt2": "ADD destination, source",
+                "opt3": "ADD source",
+                "opt4": "ADD destination",
+                "correct_option": "ADD destination, source",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is an example of an addressing mode in Assembly Language Programming?",
+                "opt1": "Immediate",
+                "opt2": "Direct",
+                "opt3": "Indirect",
+                "opt4": "All of the above",
+                "correct_option": "All of the above",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the purpose of the INT instruction in Assembly Language Programming?",
+                "opt1": "To perform an arithmetic operation",
+                "opt2": "To compare two values",
+                "opt3": "To generate a software interrupt",
+                "opt4": "To move data between registers",
+                "correct_option": "To generate a software interrupt",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is Assembly Language Programming?",
+                "opt1": "A high-level programming language",
+                "opt2": "A low-level programming language",
+                "opt3": "A scripting language",
+                "opt4": "A markup language",
+                "correct_option": "A low-level programming language",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is NOT a common Assembly Language instruction?",
+                "opt1": "MOV",
+                "opt2": "ADD",
+                "opt3": "PRINT",
+                "opt4": "JUMP",
+                "correct_option": "PRINT",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which instruction is used to move data from a register to memory in Assembly Language Programming?",
+                "opt1": "MOV",
+                "opt2": "ADD",
+                "opt3": "JMP",
+                "opt4": "PUSH",
+                "correct_option": "MOV",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which instruction is used to perform addition in Assembly Language Programming?",
+                "opt1": "MOV",
+                "opt2": "ADD",
+                "opt3": "JMP",
+                "opt4": "PUSH",
+                "correct_option": "ADD",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which instruction is used to jump to a specific memory location in Assembly Language Programming?",
+                "opt1": "MOV",
+                "opt2": "ADD",
+                "opt3": "JMP",
+                "opt4": "PUSH",
+                "correct_option": "JMP",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is NOT a register in Assembly Language Programming?",
+                "opt1": "A",
+                "opt2": "B",
+                "opt3": "C",
+                "opt4": "D",
+                "correct_option": "D",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which instruction is used to compare two values in Assembly Language Programming?",
+                "opt1": "CMP",
+                "opt2": "ADD",
+                "opt3": "JMP",
+                "opt4": "PUSH",
+                "correct_option": "CMP",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which instruction is used to perform multiplication in Assembly Language Programming?",
+                "opt1": "MUL",
+                "opt2": "ADD",
+                "opt3": "JMP",
+                "opt4": "POP",
+                "correct_option": "MUL",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which instruction is used to move data from memory to a register in Assembly Language Programming?",
+                "opt1": "MOV",
+                "opt2": "ADD",
+                "opt3": "JMP",
+                "opt4": "PUSH",
+                "correct_option": "MOV",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is NOT a common Assembly Language Directive?",
+                "opt1": "DB",
+                "opt2": "DW",
+                "opt3": "DS",
+                "opt4": "INPUT",
+                "correct_option": "INPUT",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which type of memory is used for long-term storage of data and programs even when the power is turned off?",
+                "opt1": "Primary Memory",
+                "opt2": "Secondary Memory",
+                "opt3": "Cache Memory",
+                "opt4": "Virtual Memory",
+                "correct_option": "Secondary Memory",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is a type of non-volatile memory?",
+                "opt1": "Dynamic RAM (DRAM)",
+                "opt2": "Static RAM (SRAM)",
+                "opt3": "Flash Memory",
+                "opt4": "Synchronous DRAM (SDRAM)",
+                "correct_option": "Flash Memory",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which type of memory is used as an extension of primary memory when there is not enough space to store all the necessary programs and data?",
+                "opt1": "Primary Memory",
+                "opt2": "Secondary Memory",
+                "opt3": "Cache Memory",
+                "opt4": "Virtual Memory",
+                "correct_option": "Virtual Memory",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which type of memory has the fastest access time and is located closest to the CPU in the memory hierarchy?",
+                "opt1": "Primary Memory",
+                "opt2": "Secondary Memory",
+                "opt3": "Cache Memory",
+                "opt4": "Virtual Memory",
+                "correct_option": "Cache Memory",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is a type of Double Data Rate (DDR) synchronous dynamic RAM (SDRAM)?",
+                "opt1": "DDR2 SDRAM",
+                "opt2": "DDR3 SDRAM",
+                "opt3": "DDR5 SDRAM",
+                "opt4": "All of the above",
+                "correct_option": "All of the above",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the main difference between primary and secondary memory?",
+                "opt1": "Primary memory is faster than secondary memory",
+                "opt2": "Secondary memory is faster than primary memory",
+                "opt3": "Primary memory is volatile while secondary memory is non-volatile",
+                "opt4": "Secondary memory is volatile while primary memory is non-volatile",
+                "correct_option": "Primary memory is volatile while secondary memory is non-volatile",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is NOT a type of primary memory?",
+                "opt1": "ROM",
+                "opt2": "RAM",
+                "opt3": "Cache",
+                "opt4": "Hard Disk Drive",
+                "correct_option": "Hard Disk Drive",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following is NOT a type of secondary memory?",
+                "opt1": "Hard Disk Drive",
+                "opt2": "Solid State Drive",
+                "opt3": "USB Drive",
+                "opt4": "CPU Cache",
+                "correct_option": "CPU Cache",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which memory device has the fastest access time in a microprocessor system?",
+                "opt1": "RAM",
+                "opt2": "ROM",
+                "opt3": "Cache",
+                "opt4": "Hard Disk Drive",
+                "correct_option": "Cache",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is NOT a characteristic of volatile memory?",
+                "opt1": "It is faster than non-volatile memory",
+                "opt2": "It requires constant power to retain data",
+                "opt3": "It is used for long-term storage",
+                "opt4": "It is typically smaller in capacity than non-volatile memory",
+                "correct_option": "It is used for long-term storage",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following is NOT a characteristic of non-volatile memory?",
+                "opt1": "It retains data even when power is removed",
+                "opt2": "It is typically used for long-term storage",
+                "opt3": "It is slower than volatile memory",
+                "opt4": "It is larger in capacity than volatile memory",
+                "correct_option": "It is larger in capacity than volatile memory",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following is NOT a level of cache in a microprocessor system?",
+                "opt1": "L1",
+                "opt2": "L2",
+                "opt3": "L3",
+                "opt4": "L4",
+                "correct_option": "L4",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following is NOT a type of ROM?",
+                "opt1": "PROM",
+                "opt2": "EPROM",
+                "opt3": "EEPROM",
+                "opt4": "DRAM",
+                "correct_option": "DRAM",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is an interrupt service routine (ISR) in a microprocessor?",
+                "opt1": "A software routine that responds to a specific interrupt",
+                "opt2": "A hardware circuit that triggers an interrupt",
+                "opt3": "A type of memory used for storing interrupt data",
+                "opt4": "A type of instruction that modifies the contents of a register",
+                "correct_option": "A software routine that responds to a specific interrupt",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following statements is true about the execution of an ISR?",
+                "opt1": "It always starts from the beginning of the program",
+                "opt2": "It always resumes from the point where the interrupted program left off",
+                "opt3": "It may start from the beginning or resume from the point where the interrupted program left off, depending on microprocessor architecture",
+                "opt4": "It never resumes from the point where the interrupted program left off",
+                "correct_option": "It may start from the beginning or resume from the point where the interrupted program left off, depending on microprocessor architecture",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the purpose of saving the context of the interrupted program in an ISR?",
+                "opt1": "To allow the ISR to modify the state of the interrupted program",
+                "opt2": "To resume execution of the interrupted program after the ISR is finished",
+                "opt3": "To allow the ISR to save data for future use",
+                "opt4": "To allow the ISR to execute faster",
+                "correct_option": "To resume execution of the interrupted program after the ISR is finished",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about the priority of an ISR?",
+                "opt1": "The highest priority ISR is always executed first",
+                "opt2": "ISRs are executed in the order they are received",
+                "opt3": "The lowest priority ISR is always executed first",
+                "opt4": "ISRs are executed in the order of their priority",
+                "correct_option": "The highest priority ISR is always executed first",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following statements is true about re-entrant ISRs?",
+                "opt1": "They cannot be interrupted by other ISRs",
+                "opt2": "They can be interrupted by other ISRs",
+                "opt3": "They can only be called by other ISRs",
+                "opt4": "They can only be called by the main program",
+                "correct_option": "They can be interrupted by other ISRs",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the purpose of an exit routine in an ISR?",
+                "opt1": "To terminate the ISR",
+                "opt2": "To clear the interrupt flag",
+                "opt3": "To restore the context of the interrupted program",
+                "opt4": "To store data for future use",
+                "correct_option": "To restore the context of the interrupted program",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following statements is true about nested ISRs?",
+                "opt1": "They cannot occur in a microprocessor",
+                "opt2": "They occur when an ISR is triggered while another ISR is being serviced",
+                "opt3": "They occur when two ISRs are triggered simultaneously",
+                "opt4": "They occur when an ISR takes longer than expected to execute",
+                "correct_option": "They occur when an ISR is triggered while another ISR is being serviced",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about the use of global variables in ISRs?",
+                "opt1": "Global variables should not be used in ISRs",
+                "opt2": "Global variables are safe to use in ISRs",
+                "opt3": "Global variables should only be used in re-entrant ISRs",
+                "opt4": "Global variables should only be used in high-priority ISRs",
+                "correct_option": "Global variables should not be used in ISRs",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the purpose of a spinlock in an ISR?",
+                "opt1": "To prevent other ISRs from executing while the current ISR is running",
+                "opt2": "To allow other ISRs to execute while the current ISR is running",
+                "opt3": "To synchronize access to shared resources",
+                "opt4": "To optimize the performance of the ISR",
+                "correct_option": "To synchronize access to shared resources",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is an interrupt service routine (ISR)?",
+                "opt1": "A program that triggers an interrupt",
+                "opt2": "A program that executes when an interrupt is triggered",
+                "opt3": "A program that disables interrupts",
+                "opt4": "A program that clears interrupt flags",
+                "correct_option": "A program that executes when an interrupt is triggered",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is not a common task performed by an ISR?",
+                "opt1": "Reading data from an I/O device",
+                "opt2": "Updating the interrupt enable flag",
+                "opt3": "Saving and restoring the processor state",
+                "opt4": "Clearing the interrupt flag",
+                "correct_option": "Updating the interrupt enable flag",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about the stack in an ISR?",
+                "opt1": "The stack is not used in an ISR",
+                "opt2": "The stack is used to store data received from an I/O device",
+                "opt3": "The stack is used to store the return address and processor state",
+                "opt4": "The stack is used to store data that will be written to memory",
+                "correct_option": "The stack is used to store the return address and processor state",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the purpose of the return from interrupt (RTI) instruction?",
+                "opt1": "To return control to the ISR after an interrupt",
+                "opt2": "To return control to the main program after an interrupt",
+                "opt3": "To clear the interrupt flag",
+                "opt4": "To save the processor state and interrupt enable flag",
+                "correct_option": "To return control to the main program after an interrupt",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is an example of a non-maskable interrupt (NMI)?",
+                "opt1": "Keyboard interrupt",
+                "opt2": "Timer interrupt",
+                "opt3": "Power failure interrupt",
+                "opt4": "DMA interrupt",
+                "correct_option": "Power failure interrupt",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "Which of the following statements is true about nested interrupts?",
+                "opt1": "They are not allowed in most microprocessors",
+                "opt2": "They occur when an ISR triggers another interrupt",
+                "opt3": "They occur when multiple interrupts are triggered simultaneously",
+                "opt4": "They occur when an ISR takes too long to execute",
+                "correct_option": "They occur when an ISR triggers another interrupt",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the purpose of the interrupt enable flag in an ISR?",
+                "opt1": "To indicate that an interrupt has occurred",
+                "opt2": "To enable or disable interrupts",
+                "opt3": "To store the address of an ISR",
+                "opt4": "To clear the interrupt flag",
+                "correct_option": "To enable or disable interrupts",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is interrupt processing in a microprocessor?",
+                "opt1": "The process of interrupting a running program",
+                "opt2": "The process of handling an interrupt request from an external device",
+                "opt3": "The process of prioritizing interrupts",
+                "opt4": "The process of executing the interrupt service routine",
+                "correct_option": "The process of handling an interrupt request from an external device",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is a common method of handling multiple interrupts in a microprocessor?",
+                "opt1": "Polling",
+                "opt2": "Queuing",
+                "opt3": "Sorting",
+                "opt4": "Multiplexing",
+                "correct_option": "Polling",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the purpose of an interrupt vector in a microprocessor?",
+                "opt1": "To store the interrupt priority levels",
+                "opt2": "To store the addresses of the interrupt service routines",
+                "opt3": "To store the status of the interrupt flag",
+                "opt4": "To store the current program counter",
+                "correct_option": "To store the addresses of the interrupt service routines",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about the interrupt priority levels in a microprocessor?",
+                "opt1": "Lower priority levels have higher priority",
+                "opt2": "Higher priority levels have higher priority",
+                "opt3": "The priority levels are not important in interrupt processing",
+                "opt4": "The priority levels are determined by the external devices",
+                "correct_option": "Higher priority levels have higher priority",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following is a disadvantage of using the polling method for interrupt processing?",
+                "opt1": "It is slower than other methods",
+                "opt2": "It requires more hardware resources",
+                "opt3": "It may cause a delay in responding to interrupts",
+                "opt4": "It may cause errors in the interrupt processing",
+                "correct_option": "It may cause a delay in responding to interrupts",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is the purpose of the interrupt enable bit in a microprocessor?",
+                "opt1": "To enable the interrupt processing",
+                "opt2": "To disable the interrupt processing",
+                "opt3": "To enable the interrupt request from external devices",
+                "opt4": "To disable the interrupt request from external devices",
+                "correct_option": "To enable the interrupt processing",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following is an advantage of using the interrupt method for interrupt processing?",
+                "opt1": "It requires less hardware resources",
+                "opt2": "It is faster than other methods",
+                "opt3": "It does not cause a delay in responding to interrupts",
+                "opt4": "It does not require interrupt vectors",
+                "correct_option": "It does not cause a delay in responding to interrupts",
+                "correct_option_index": 3
+        },
+        {
+                "qsns": "What is interrupt processing in a microprocessor?",
+                "opt1": "The process of generating interrupts",
+                "opt2": "The process of handling interrupts",
+                "opt3": "The process of disabling interrupts",
+                "opt4": "The process of prioritizing interrupts",
+                "correct_option": "The process of handling interrupts",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about interrupt processing time?",
+                "opt1": "It is always shorter than the interrupt response time",
+                "opt2": "It is always longer than the interrupt response time",
+                "opt3": "It is equal to the interrupt response time",
+                "opt4": "It depends on the complexity of the interrupt handling routine",
+                "correct_option": "It depends on the complexity of the interrupt handling routine",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the purpose of an interrupt vector table?",
+                "opt1": "To store the priority of each interrupt",
+                "opt2": "To store the memory location of the interrupt service routine (ISR) for each interrupt",
+                "opt3": "To store the interrupt mask for each interrupt",
+                "opt4": "To store the status of each interrupt",
+                "correct_option": "To store the memory location of the interrupt service routine (ISR) for each interrupt",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about interrupt latency?",
+                "opt1": "It is the time between the occurrence of an interrupt and the start of the ISR",
+                "opt2": "It is the time between the start of the ISR and the end of the ISR",
+                "opt3": "It is the time between the end of the ISR and the resumption of the interrupted program",
+                "opt4": "It is the time between the occurrence of an interrupt and the resumption of the interrupted program",
+                "correct_option": "It is the time between the occurrence of an interrupt and the start of the ISR",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following statements is true about interrupt nesting?",
+                "opt1": "It is the process of triggering multiple interrupts simultaneously",
+                "opt2": "It is the process of handling interrupts in the order they are received",
+                "opt3": "It is the process of disabling interrupts while an ISR is being executed",
+                "opt4": "It is the process of handling an interrupt while another ISR is being executed",
+                "correct_option": "It is the process of handling an interrupt while another ISR is being executed",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the purpose of an interrupt mask in a microprocessor?",
+                "opt1": "To enable or disable interrupts",
+                "opt2": "To prioritize interrupts",
+                "opt3": "To store the status of interrupts",
+                "opt4": "To store the memory location of ISRs",
+                "correct_option": "To enable or disable interrupts",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "Which of the following statements is true about interrupt handling in a multitasking environment?",
+                "opt1": "Interrupts should be enabled while a task is executing",
+                "opt2": "Interrupts should be disabled while a task is executing",
+                "opt3": "Interrupts should be ignored in a multitasking environment",
+                "opt4": "Interrupts should be prioritized based on the task being executed",
+                "correct_option": "Interrupts should be enabled while a task is executing",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the purpose of an interrupt acknowledgment signal?",
+                "opt1": "To enable or disable an interrupt",
+                "opt2": "To acknowledge the occurrence of an interrupt",
+                "opt3": "To trigger an interrupt",
+                "opt4": "To prioritize interrupts",
+                "correct_option": "To acknowledge the occurrence of an interrupt",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about edge-triggered interrupts?",
+                "opt1": "They are triggered by the presence of a signal for a specified period of time",
+                "opt2": "They are triggered by the rising or falling edge of a signal",
+                "opt3": "They are triggered by the amplitude of a signal",
+                "opt4": "They are triggered by the frequency of a signal",
+                "correct_option": "They are triggered by the rising or falling edge of a signal",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the purpose of an interrupt request (IRQ) line in a microprocessor?",
+                "opt1": "To trigger an interrupt",
+                "opt2": "To acknowledge an interrupt",
+                "opt3": "To prioritize interrupts",
+                "opt4": "To enable or disable interrupts",
+                "correct_option": "To trigger an interrupt",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the purpose of the interrupt acknowledge signal in a microprocessor?",
+                "opt1": "To request an interrupt from an external device",
+                "opt2": "To acknowledge receipt of an interrupt request from an external device",
+                "opt3": "To enable the interrupt processing",
+                "opt4": "To disable the interrupt processing",
+                "correct_option": "To acknowledge receipt of an interrupt request from an external device",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is an interrupt vector table in a microprocessor?",
+                "opt1": "A table that stores the priority of each interrupt",
+                "opt2": "A table that stores the address of each ISR",
+                "opt3": "A table that stores the context of the interrupted program",
+                "opt4": "A table that stores the status of each interrupt flag",
+                "correct_option": "A table that stores the address of each ISR",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about interrupt latency?",
+                "opt1": "It refers to the time required for an ISR to execute",
+                "opt2": "It refers to the time required for an interrupt to be detected and an ISR to be initiated",
+                "opt3": "It refers to the time required for the interrupted program to resume after an ISR is finished",
+                "opt4": "It refers to the time required for the microprocessor to switch between different ISRs",
+                "correct_option": "It refers to the time required for an interrupt to be detected and an ISR to be initiated",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about nested interrupts?",
+                "opt1": "They occur when an ISR is triggered while another ISR is being serviced",
+                "opt2": "They occur when two ISRs are triggered simultaneously",
+                "opt3": "They occur when an ISR takes longer than expected to execute",
+                "opt4": "They never occur in a microprocessor",
+                "correct_option": "They occur when an ISR is triggered while another ISR is being serviced",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the purpose of an interrupt enable flag in a microprocessor?",
+                "opt1": "To disable all interrupts",
+                "opt2": "To enable all interrupts",
+                "opt3": "To enable specific interrupts",
+                "opt4": "To disable specific interrupts",
+                "correct_option": "To enable all interrupts",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "What is the purpose of a maskable interrupt in a microprocessor?",
+                "opt1": "To disable all interrupts",
+                "opt2": "To enable all interrupts",
+                "opt3": "To enable specific interrupts",
+                "opt4": "To disable specific interrupts",
+                "correct_option": "To disable specific interrupts",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "Which of the following statements is true about non-maskable interrupts?",
+                "opt1": "They can be disabled by software",
+                "opt2": "They can be disabled by hardware",
+                "opt3": "They can be ignored by the microprocessor",
+                "opt4": "They cannot be ignored by the microprocessor",
+                "correct_option": "They cannot be ignored by the microprocessor",
+                "correct_option_index": 4
+        },
+        {
+                "qsns": "What is the purpose of an interrupt acknowledge signal in a microprocessor?",
+                "opt1": "To acknowledge the occurrence of an interrupt",
+                "opt2": "To acknowledge the receipt of an interrupt request",
+                "opt3": "To clear the interrupt enable flag",
+                "opt4": "To clear the interrupt flag",
+                "correct_option": "To acknowledge the receipt of an interrupt request",
+                "correct_option_index": 2
+        },
+        {
+                "qsns": "Which of the following statements is true about edge-triggered interrupts?",
+                "opt1": "They are triggered by a change in the interrupt request signal",
+                "opt2": "They are triggered by the level of the interrupt request signal",
+                "opt3": "They are not used in microprocessors",
+                "opt4": "They are always maskable interrupts",
+                "correct_option": "They are triggered by a change in the interrupt request signal",
+                "correct_option_index": 1
+        },
+        {
+                "qsns": "What is the purpose of a vectored interrupt in a microprocessor?",
+                "opt1": "To enable multiple interrupts to be serviced simultaneously",
+                "opt2": "To prioritize interrupts based on their importance",
+                "opt3": "To reduce interrupt latency",
+                "opt4": "To allow each interrupt to have a unique ISR address",
+                "correct_option": "To allow each interrupt to have a unique ISR address",
+                "correct_option_index": 4
+        }
+]
diff --git a/frontend/public/data/books/ch3.json b/frontend/public/data/books/ch3.json
index 10ba99c..4e9bc95 100644
--- a/frontend/public/data/books/ch3.json
+++ b/frontend/public/data/books/ch3.json
@@ -1,3591 +1,3521 @@
 [
-  {
-    "qsns": "What is an Identifier in C programming?",
-    "opt1": "A keyword that has a specific meaning in the language",
-    "opt2": "A symbol used to represent a variable, function, or structure in a C program",
-    "opt3": "A constant value that cannot be changed during program execution",
-    "opt4": "None of above",
-    "correct_option": "A symbol used to represent a variable, function, or structure in a C program",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is a constant in C programming?",
-    "opt1": "A keyword that has a specific meaning in the language",
-    "opt2": "A symbol used to represent a variable, function, or structure in a C program",
-    "opt3": "A value that cannot be changed during program execution",
-    "opt4": "All of above",
-    "correct_option": "A value that cannot be changed during program execution",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is an operator in C programming?",
-    "opt1": "A symbol used to perform operations on variables, constants, and expressions",
-    "opt2": "A symbol used to define variables, functions, and structures",
-    "opt3": "A symbol used to control the flow of a program",
-    "opt4": "None of above",
-    "correct_option": "A symbol used to perform operations on variables, constants, and expressions",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What are some examples of operators in C programming?",
-    "opt1": "Arithmetic, relational, logical, and bitwise operators",
-    "opt2": "Assignment, conditional, and loop operators",
-    "opt3": "Structural, pointer, and memory operators",
-    "opt4": "All of above",
-    "correct_option": "Arithmetic, relational, logical, and bitwise operators",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a keyword in C programming?",
-    "opt1": "A symbol used to perform operations on variables, constants, and expressions",
-    "opt2": "A symbol used to define variables, functions, and structures",
-    "opt3": "A word that has a specific meaning in the language and cannot be used as an identifier",
-    "opt4": "None of above",
-    "correct_option": "A word that has a specific meaning in the language and cannot be used as an identifier",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What are some examples of keywords in C programming?",
-    "opt1": "int, float, char, if, for, while",
-    "opt2": "add, subtract, multiply, divide, modulus",
-    "opt3": "input, output, execute, stop",
-    "opt4": "Both a and b",
-    "correct_option": "int, float, char, if, for, while",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between keywords and identifiers in C programming?",
-    "opt1": "Keywords have a specific meaning in the language, while identifiers do not",
-    "opt2": "Keywords are used to define variables, functions, and structures, while identifiers are not",
-    "opt3": "Keywords cannot be used as identifiers, while identifiers can be used as keywords",
-    "opt4": "All of above",
-    "correct_option": "Keywords cannot be used as identifiers, while identifiers can be used as keywords",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the difference between constants and variables in C programming?",
-    "opt1": "Constants have a fixed value that cannot be changed, while variables have a value that can be changed",
-    "opt2": "Constants are used to perform operations, while variables are used to store data",
-    "opt3": "Constants are used to define functions, while variables are used to define structures",
-    "opt4": "All of above",
-    "correct_option": "Constants have a fixed value that cannot be changed, while variables have a value that can be changed",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between an operator and a function in C programming?",
-    "opt1": "An operator performs an operation on one or more operands, while a function performs a set of operations on input data",
-    "opt2": "A function performs an operation on one or more operands, while an operator performs a set of operations on input data",
-    "opt3": "Operators are written in uppercase, while functions are not",
-    "opt4": "Functions are written in uppercase, while operators are not",
-    "correct_option": "An operator performs an operation on one or more operands, while a function performs a set of operations on input data",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of a semicolon at the end of a statement in C programming?",
-    "opt1": "To indicate the end of a statement",
-    "opt2": "To separate two statements",
-    "opt3": "To define a function",
-    "opt4": "To declare a variable",
-    "correct_option": "To indicate the end of a statement",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a token in C programming?",
-    "opt1": "A symbol or keyword used in a C program",
-    "opt2": "A variable used in a C program",
-    "opt3": "A function used in a C program",
-    "opt4": "A structure used in a C program",
-    "correct_option": "A symbol or keyword used in a C program",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What are some examples of tokens in C programming?",
-    "opt1": "Keywords, identifiers, constants, and operators",
-    "opt2": "Functions, loops, and conditionals",
-    "opt3": "Variables, arrays, and structures",
-    "opt4": "All of above",
-    "correct_option": "Keywords, identifiers, constants, and operators",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of arithmetic operators in C programming?",
-    "opt1": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
-    "opt2": "To compare values and make decisions based on the comparison results",
-    "opt3": "To manipulate bits and perform bitwise operations on binary data",
-    "opt4": "All of above",
-    "correct_option": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of relational operators in C programming?",
-    "opt1": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
-    "opt2": "To compare values and make decisions based on the comparison results",
-    "opt3": "To manipulate bits and perform bitwise operations on binary data",
-    "opt4": "All of above",
-    "correct_option": "To compare values and make decisions based on the comparison results",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of logical operators in C programming?",
-    "opt1": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
-    "opt2": "To compare values and make decisions based on the comparison results",
-    "opt3": "To perform logical operations such as AND, OR, and NOT on boolean values",
-    "opt4": "All of above",
-    "correct_option": "To perform logical operations such as AND, OR, and NOT on boolean values",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of bitwise operators in C programming?",
-    "opt1": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
-    "opt2": "To compare values and make decisions based on the comparison results",
-    "opt3": "To manipulate bits and perform bitwise operations on binary data",
-    "opt4": "All of above",
-    "correct_option": "To manipulate bits and perform bitwise operations on binary data",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the difference between the logical AND operator (&&) and the bitwise AND operator (&) in C programming?",
-    "opt1": "The logical AND operator performs a logical operation on boolean values, while the bitwise AND operator performs a bitwise operation on binary data",
-    "opt2": "The logical AND operator performs a bitwise operation on boolean values, while the bitwise AND operator performs a logical operation on binary data",
-    "opt3": "There is no difference between the logical AND operator and the bitwise AND operator in C programming",
-    "opt4": "All of above",
-    "correct_option": "The logical AND operator performs a logical operation on boolean values, while the bitwise AND operator performs a bitwise operation on binary data",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between the logical OR operator (||) and the bitwise OR operator (|) in C programming?",
-    "opt1": "The logical OR operator performs a logical operation on boolean values, while the bitwise OR operator performs a bitwise operation on binary data",
-    "opt2": "The logical OR operator performs a bitwise operation on boolean values, while the bitwise OR operator performs a logical operation on binary data",
-    "opt3": "There is no difference between the logical OR operator and the bitwise OR operator in C programming",
-    "opt4": "All of above",
-    "correct_option": "The logical OR operator performs a logical operation on boolean values, while the bitwise OR operator performs a bitwise operation on binary data",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the result of the following expression: 5 & 6",
-    "opt1": "5",
-    "opt2": "6",
-    "opt3": "4",
-    "opt4": "1",
-    "correct_option": "4",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the result of the following expression: 5<6",
-    "opt1": "0",
-    "opt2": "1",
-    "opt3": "True",
-    "opt4": "False",
-    "correct_option": "1",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of the conditional operator (?:) in C programming?",
-    "opt1": "To perform a conditional operation based on the value of a condition",
-    "opt2": "To perform arithmetic operations",
-    "opt3": "To declare a variable",
-    "opt4": "To assign a value to a variable",
-    "correct_option": "To perform a conditional operation based on the value of a condition",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between the bitwise AND operator (&) and the bitwise OR operator (|) in C programming?",
-    "opt1": "The bitwise AND operator performs a bitwise AND operation, while the bitwise OR operator performs a bitwise OR operation",
-    "opt2": "The bitwise OR operator performs a bitwise AND operation, while the bitwise AND operator performs a bitwise OR operation",
-    "opt3": "Bitwise AND operators are written in uppercase, while bitwise OR operators are not",
-    "opt4": "Bitwise OR operators are written in uppercase, while bitwise AND operators are not",
-    "correct_option": "The bitwise AND operator performs a bitwise AND operation, while the bitwise OR operator performs a bitwise OR operation",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the assignment operator (=) in C programming?",
-    "opt1": "To compare two values",
-    "opt2": "To assign a value to a variable",
-    "opt3": "To perform mathematical operations",
-    "opt4": "To declare a variable",
-    "correct_option": "To assign a value to a variable",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the result of the following expression: 5 + 7 * 2",
-    "opt1": "19",
-    "opt2": "26",
-    "opt3": "16",
-    "opt4": "9",
-    "correct_option": "19",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between formatted and unformatted input/output in C programming?",
-    "opt1": "Formatted input/output is used to input/output data in a specific format, while unformatted input/output is used to input/output data without any format.",
-    "opt2": "Formatted input/output is used to input/output data without any format, while unformatted input/output is used to input/output data in a specific format.",
-    "opt3": "There is no difference between formatted and unformatted input/output in C programming.",
-    "opt4": "None of above",
-    "correct_option": "Formatted input/output is used to input/output data in a specific format, while unformatted input/output is used to input/output data without any format.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What are some examples of formatted input functions in C programming?",
-    "opt1": "scanf(), gets(), and fscanf()",
-    "opt2": "getchar(), gets(), and fgetc()",
-    "opt3": "printf(), puts(), and fprintf()",
-    "opt4": "All of above",
-    "correct_option": "scanf(), gets(), and fscanf()",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What are some examples of formatted output functions in C programming?",
-    "opt1": "scanf(), gets(), and fscanf()",
-    "opt2": "getchar(), gets(), and fgetc()",
-    "opt3": "printf(), puts(), and fprintf()",
-    "opt4": "All of above",
-    "correct_option": "printf(), puts(), and fprintf()",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the scanf() function in C programming?",
-    "opt1": "To output data to the standard output device",
-    "opt2": "To input data from the standard input device",
-    "opt3": "To input/output data to/from a file",
-    "opt4": "All of above",
-    "correct_option": "To input data from the standard input device",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of the printf() function in C programming?",
-    "opt1": "To output data to the standard output device",
-    "opt2": "To input data from the standard input device",
-    "opt3": "To input/output data to/from a file",
-    "opt4": "All of above",
-    "correct_option": "To output data to the standard output device",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between the gets() and scanf() functions in C programming?",
-    "opt1": "The gets() function inputs data without any format, while the scanf() function inputs data in a specific format.",
-    "opt2": "The gets() function inputs data in a specific format, while the scanf() function inputs data without any format.",
-    "opt3": "There is no difference between the gets() and scanf() functions in C programming.",
-    "opt4": "Both a and b",
-    "correct_option": "The gets() function inputs data without any format, while the scanf() function inputs data in a specific format.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between the puts() and printf() functions in C programming?",
-    "opt1": "The puts() function outputs data without any format, while the printf() function outputs data in a specific format.",
-    "opt2": "The puts() function outputs data in a specific format, while the printf() function outputs data without any format.",
-    "opt3": "There is no difference between the puts() and printf() functions in C programming.",
-    "opt4": "Both a and b",
-    "correct_option": "The puts() function outputs data without any format, while the printf() function outputs data in a specific format.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the fscanf() function in C programming?",
-    "opt1": "To input data from the standard input device",
-    "opt2": "To output data to the standard output device",
-    "opt3": "To input/output data to/from a file",
-    "opt4": "All of above",
-    "correct_option": "To input/output data to/from a file",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the standard library function used to read a string from the user in C?",
-    "opt1": "scanf()",
-    "opt2": "gets()",
-    "opt3": "fgets()",
-    "opt4": "sprintf()",
-    "correct_option": "gets()",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following functions is used to print a string to the screen in C?",
-    "opt1": "puts()",
-    "opt2": "printf()",
-    "opt3": "fprintf()",
-    "opt4": "getchar()",
-    "correct_option": "puts()",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between scanf() and fscanf() in C?",
-    "opt1": "scanf() reads from the standard input and fscanf() reads from a file",
-    "opt2": "scanf() reads from a file and fscanf() reads from the standard input",
-    "opt3": "Both functions have the same functionality",
-    "opt4": "None of the above",
-    "correct_option": "scanf() reads from the standard input and fscanf() reads from a file",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the %d format specifier in the printf() function in C?",
-    "opt1": "To print an integer",
-    "opt2": "To print a string",
-    "opt3": "To print a float",
-    "opt4": "To print a double",
-    "correct_option": "To print an integer",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the %f format specifier in the printf() function in C?",
-    "opt1": "To print an integer",
-    "opt2": "To print a string",
-    "opt3": "To print a float",
-    "opt4": "To print a double",
-    "correct_option": "To print a float",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the %lf format specifier in the printf() function in C?",
-    "opt1": "To print a string",
-    "opt2": "To print an integer",
-    "opt3": "To print a float",
-    "opt4": "To print a double",
-    "correct_option": "To print a double",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following functions is used to read a single character from the standard input in C?",
-    "opt1": "scanf()",
-    "opt2": "gets()",
-    "opt3": "getchar()",
-    "opt4": "fgetc()",
-    "correct_option": "getchar()",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the fopen() function in C?",
-    "opt1": "To open a file for reading",
-    "opt2": "To open a file for writing",
-    "opt3": "To open a file for reading and writing",
-    "opt4": "None of the above",
-    "correct_option": "To open a file for reading",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the fclose() function in C?",
-    "opt1": "To close a file that was opened for reading",
-    "opt2": "To close a file that was opened for writing",
-    "opt3": "To close a file that was opened for reading and writing",
-    "opt4": "None of the above",
-    "correct_option": "To close a file that was opened for reading and writing",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the difference between fprintf() and sprintf() in C?",
-    "opt1": "fprintf() writes to a file and sprintf() writes to a string",
-    "opt2": "fprintf() writes to a string and sprintf() writes to a file",
-    "opt3": "Both functions have the same functionality",
-    "opt4": "None of the above",
-    "correct_option": "fprintf() writes to a file and sprintf() writes to a string",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the if statement in C programming?",
-    "opt1": "To execute a block of code only if a certain condition is met",
-    "opt2": "To execute a block of code only if a certain condition is not met",
-    "opt3": "To execute a block of code if a certain condition is true",
-    "opt4": "None of the above",
-    "correct_option": "To execute a block of code if a certain condition is true",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the else statement in C programming?",
-    "opt1": "To execute a block of code regardless of the condition",
-    "opt2": "To execute a block of code if a condition is false",
-    "opt3": "To terminate the program if a condition is false",
-    "opt4": "To skip a block of code if a condition is true",
-    "correct_option": "To execute a block of code if a condition is false",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of the switch statement in C programming?",
-    "opt1": "To execute one of several blocks of code based on the value of an expression",
-    "opt2": "To execute all of the blocks of code in a switch statement",
-    "opt3": "To execute only the first block of code in a switch statement",
-    "opt4": "None of the above",
-    "correct_option": "To execute one of several blocks of code based on the value of an expression",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the break statement in C programming?",
-    "opt1": "To exit a loop",
-    "opt2": "To exit a switch statement",
-    "opt3": "To exit a function",
-    "opt4": "To exit the program",
-    "correct_option": "To exit a switch statement",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of the continue statement in C programming?",
-    "opt1": "To exit a loop",
-    "opt2": "To exit a switch statement",
-    "opt3": "To skip an iteration of a loop",
-    "opt4": "To exit the program",
-    "correct_option": "To skip an iteration of a loop",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the for loop in C programming?",
-    "opt1": "To execute a block of code a specified number of times",
-    "opt2": "To execute a block of code indefinitely",
-    "opt3": "To execute a block of code based on a condition",
-    "opt4": "None of the above",
-    "correct_option": "To execute a block of code a specified number of times",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the while loop in C programming?",
-    "opt1": "To execute a block of code a specified number of times",
-    "opt2": "To execute a block of code indefinitely until a condition is met",
-    "opt3": "To execute a block of code based on a condition",
-    "opt4": "None of the above",
-    "correct_option": "To execute a block of code indefinitely until a condition is met",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is an if statement in C programming used for?",
-    "opt1": "To execute a block of code only if a certain condition is met",
-    "opt2": "To execute a block of code only if a certain condition is not met",
-    "opt3": "To execute a block of code if a certain condition is met, and execute another block of code if the condition is not met",
-    "opt4": "To declare variables",
-    "correct_option": "To execute a block of code if a certain condition is met, and execute another block of code if the condition is not met",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the do-while loop in C programming?",
-    "opt1": "To execute a block of code a specified number of times",
-    "opt2": "To execute a block of code indefinitely until a condition is met",
-    "opt3": "To execute a block of code at least once, and then repeatedly until a condition is met",
-    "opt4": "None of the above",
-    "correct_option": "To execute a block of code at least once, and then repeatedly until a condition is met",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the difference between the for loop and the while loop in C programming?",
-    "opt1": "The for loop is used for a specified number of iterations, while the while loop is used until a condition is met",
-    "opt2": "The for loop is used until a condition is met, while the while loop is used for a specified number of iterations",
-    "opt3": "Both loops have the same functionality",
-    "opt4": "None of the above",
-    "correct_option": "The for loop is used for a specified number of iterations, while the while loop is used until a condition is met",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What does the \"if\" statement in C do?",
-    "opt1": "Executes a block of code if a condition is true",
-    "opt2": "Executes a block of code regardless of the condition",
-    "opt3": "Skips a block of code if a condition is false",
-    "opt4": "Terminates the program if a condition is true",
-    "correct_option": "Executes a block of code if a condition is true",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the syntax of the \"if\" statement in C?",
-    "opt1": "if (condition) { statements }",
-    "opt2": "if condition { statements }",
-    "opt3": "if {condition} (statements)",
-    "opt4": "if (condition) { statements };",
-    "correct_option": "if (condition) { statements }",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the \"else\" statement in C?",
-    "opt1": "To execute a block of code if a condition is false",
-    "opt2": "To execute a block of code regardless of the condition",
-    "opt3": "To execute a block of code if the condition in the if statement is true",
-    "opt4": "To execute a block of code if the condition in the if statement is false",
-    "correct_option": "To execute a block of code if the condition in the if statement is false",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the syntax of the \"switch\" statement in C?",
-    "opt1": "switch (expression) { case constant-expression: statements; break; default: statements; }",
-    "opt2": "switch expression { case constant-expression: statements; break; default: statements; }",
-    "opt3": "switch (expression) case constant-expression: statements; break; default: statements;",
-    "opt4": "switch expression case constant-expression: statements; break; default: statements;",
-    "correct_option": "switch (expression) { case constant-expression: statements; break; default: statements; }",
-    "correct_option_index": 1
-  },
-  
-  {
-    "qsns": "What is the index of the first element in a one-dimensional array in C?",
-    "opt1": "0",
-    "opt2": "1",
-    "opt3": "2",
-    "opt4": "3",
-    "correct_option": "0",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the syntax for declaring a two-dimensional integer array of size 3x4 in C?",
-    "opt1": "int arr[3][4];",
-    "opt2": "int arr[4][3];",
-    "opt3": "int arr[3,4];",
-    "opt4": "int arr[4,3];",
-    "correct_option": "int arr[3][4];",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How can you access the value of the 3rd element of the 2nd row of a two-dimensional array in C?",
-    "opt1": "arr[1][2]",
-    "opt2": "arr[2][1]",
-    "opt3": "arr[2][3]",
-    "opt4": "arr[3][2]",
-    "correct_option": "arr[1][2]",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between a one-dimensional array and a two-dimensional array in C?",
-    "opt1": "A one-dimensional array has one row and multiple columns, whereas a two-dimensional array has multiple rows and multiple columns.",
-    "opt2": "A one-dimensional array has multiple rows and multiple columns, whereas a two-dimensional array has one row and multiple columns.",
-    "opt3": "A one-dimensional array has multiple rows and one column, whereas a two-dimensional array has one row and one column.",
-    "opt4": "A one-dimensional array has one row and one column, whereas a two-dimensional array has multiple rows and multiple columns.",
-    "correct_option": "A one-dimensional array has one row and multiple columns, whereas a two-dimensional array has multiple rows and multiple columns.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the syntax for initializing a one-dimensional array in C?",
-    "opt1": "int arr[] = {1,2,3,4,5};",
-    "opt2": "int arr[5] = (1,2,3,4,5);",
-    "opt3": "int arr[5] = {1,2,3,4};",
-    "opt4": "int arr = {1, 2, 3, 4, 5};",
-    "correct_option": "int arr[] = {1,2,3,4,5};",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How can you find the number of elements in a one-dimensional array in C?",
-    "opt1": "sizeof(arr)",
-    "opt2": "sizeof(arr[0])",
-    "opt3": "sizeof(arr)/sizeof(arr[0])",
-    "opt4": "sizeof(arr[])/sizeof(arr[0])",
-    "correct_option": "sizeof(arr)/sizeof(arr[0])",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the syntax for declaring a multidimensional array in C?",
-    "opt1": "int arr[][][];",
-    "opt2": "int arr;",
-    "opt3": "int arr[];",
-    "opt4": "int arr[...][...][...];",
-    "correct_option": "int arr[...][...][...];",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the use of the strlen() function in C when working with arrays?",
-    "opt1": "To find the length of a one-dimensional array",
-    "opt2": "To find the length of a two-dimensional array",
-    "opt3": "To find the length of a string",
-    "opt4": "To find the length of a multidimensional array",
-    "correct_option": "To find the length of a string",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is a one-dimensional array in C?",
-    "opt1": "A set of values of the same data type stored in a contiguous block of memory",
-    "opt2": "A set of values of different data types stored in a contiguous block of memory",
-    "opt3": "A set of values of the same data type stored in non-contiguous memory locations",
-    "opt4": "A set of values of different data types stored in non-contiguous memory locations",
-    "correct_option": "A set of values of the same data type stored in a contiguous block of memory",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How can you access the value at the third position of a one-dimensional array named \"array\"?",
-    "opt1": "array[2]",
-    "opt2": "array[3]",
-    "opt3": "array[0]",
-    "opt4": "array[1]",
-    "correct_option": "array[2]",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a two-dimensional array in C?",
-    "opt1": "An array of arrays",
-    "opt2": "A set of values of the same data type stored in non-contiguous memory locations",
-    "opt3": "A set of values of different data types stored in a contiguous block of memory",
-    "opt4": "A set of values of the same data type stored in a single contiguous block of memory",
-    "correct_option": "An array of arrays",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How can you access the value at the first row and second column of a two-dimensional array named \"array\"?",
-    "opt1": "array[0][1]",
-    "opt2": "array[1][0]",
-    "opt3": "array[1][2]",
-    "opt4": "array[2][1]",
-    "correct_option": "array[0][1]",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a multidimensional array in C?",
-    "opt1": "An array of arrays of arrays",
-    "opt2": "A set of values of different data types stored in non-contiguous memory locations",
-    "opt3": "A set of values of the same data type stored in a single contiguous block of memory",
-    "opt4": "A set of values of different data types stored in a single contiguous block of memory",
-    "correct_option": "An array of arrays of arrays",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between a one-dimensional array and a two-dimensional array in C?",
-    "opt1": "A two-dimensional array has more dimensions than a one-dimensional array",
-    "opt2": "A one-dimensional array has more dimensions than a two-dimensional array",
-    "opt3": "There is no difference between a one-dimensional array and a two-dimensional array",
-    "opt4": "A two-dimensional array can store more values than a one-dimensional array",
-    "correct_option": "A two-dimensional array has more dimensions than a one-dimensional array",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the \"malloc\" function in C programming?",
-    "opt1": "To free memory",
-    "opt2": "To allocate memory",
-    "opt3": "To initialize memory",
-    "opt4": "To reset memory",
-    "correct_option": "To allocate memory",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of the \"free\" function in C programming?",
-    "opt1": "To allocate memory",
-    "opt2": "To free memory",
-    "opt3": "To initialize memory",
-    "opt4": "To reset memory",
-    "correct_option": "To free memory",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the difference between an array and a pointer in C programming?",
-    "opt1": "An array is a set of values stored in a contiguous block of memory, while a pointer is a variable that stores the address of another variable",
-    "opt2": "A pointer is a set of values stored in a contiguous block of memory, while an array is a variable that stores the address of another variable",
-    "opt3": "There is no difference between an array and a pointer in C programming",
-    "opt4": "An array is a variable that stores the address of another variable, while a pointer is a set of values stored in a contiguous block of memory",
-    "correct_option": "An array is a set of values stored in a contiguous block of memory, while a pointer is a variable that stores the address of another variable",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a string in C programming?",
-    "opt1": "A sequence of characters enclosed in quotes",
-    "opt2": "An array of characters",
-    "opt3": "A single character",
-    "opt4": "None of above",
-    "correct_option": "An array of characters",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How can you find the length of a string in C programming?",
-    "opt1": "By using the length() function",
-    "opt2": "By using the strlen() function",
-    "opt3": "By using the sizeof() operator",
-    "opt4": "None of above",
-    "correct_option": "By using the strlen() function",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How can you concatenate two strings in C programming?",
-    "opt1": "By using the + operator",
-    "opt2": "By using the strcat() function",
-    "opt3": "By using the strcpy() function",
-    "opt4": "None of above",
-    "correct_option": "By using the strcat() function",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What does the strcpy() function do in C programming?",
-    "opt1": "Copies one string to another",
-    "opt2": "Concatenates two strings",
-    "opt3": "Compares two strings",
-    "opt4": "None of above",
-    "correct_option": "Copies one string to another",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between the strcpy() and strcat() functions in C programming?",
-    "opt1": "strcpy() copies one string to another, while strcat() concatenates two strings",
-    "opt2": "strcpy() concatenates two strings, while strcat() copies one string to another",
-    "opt3": "Both functions copy one string to another",
-    "opt4": "None of above",
-    "correct_option": "strcpy() copies one string to another, while strcat() concatenates two strings",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How can you compare two strings in C programming?",
-    "opt1": "By using the strcmp() function",
-    "opt2": "By using the strcat() function",
-    "opt3": "By using the strcpy() function",
-    "opt4": "Both a and b",
-    "correct_option": "By using the strcmp() function",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the return value of the strcmp() function when two strings are equal?",
-    "opt1": "0",
-    "opt2": "1",
-    "opt3": "-1",
-    "opt4": "null",
-    "correct_option": "0",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the return value of the strcmp() function when the first string is greater than the second string?",
-    "opt1": "0",
-    "opt2": "1",
-    "opt3": "-1",
-    "opt4": "null",
-    "correct_option": "1",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the return value of the strcmp() function when the first string is less than the second string?",
-    "opt1": "0",
-    "opt2": "1",
-    "opt3": "-1",
-    "opt4": "null",
-    "correct_option": "-1",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "How can you reverse a string in C programming?",
-    "opt1": "By using the strrev() function",
-    "opt2": "By using a loop and swapping characters",
-    "opt3": "There is no built-in function to reverse a string in C programming",
-    "opt4": "None of above",
-    "correct_option": "By using a loop and swapping characters",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of the strcat() function in C programming?",
-    "opt1": "To copy a string to another string.",
-    "opt2": "To concatenate two strings.",
-    "opt3": "To find the length of a string.",
-    "opt4": "To compare two strings.",
-    "correct_option": "To concatenate two strings.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of the strcmp() function in C programming?",
-    "opt1": "To copy a string to another string.",
-    "opt2": "To find the length of a string.",
-    "opt3": "To concatenate two strings.",
-    "opt4": "To compare two strings.",
-    "correct_option": "To compare two strings.",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the purpose of the strcpy() function in C programming?",
-    "opt1": "To copy a string to another string.",
-    "opt2": "To find the length of a string.",
-    "opt3": "To concatenate two strings.",
-    "opt4": "To compare two strings.",
-    "correct_option": "To copy a string to another string.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the strlen() function in C programming?",
-    "opt1": "To compare two strings.",
-    "opt2": "To concatenate two strings.",
-    "opt3": "To find the length of a string.",
-    "opt4": "To copy a string to another string.",
-    "correct_option": "To find the length of a string.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the strstr() function in C programming?",
-    "opt1": "To find a substring in a string.",
-    "opt2": "To compare two strings.",
-    "opt3": "To find the first occurrence of a character in a string.",
-    "opt4": "To reverse a string.",
-    "correct_option": "To find a substring in a string.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How can you reverse a string in C programming?",
-    "opt1": "By using the strrev() function.",
-    "opt2": "By using a loop and swapping characters.",
-    "opt3": "By using the strcat() function.",
-    "opt4": "By using the strcmp() function.",
-    "correct_option": "By using a loop and swapping characters.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How can you convert a string to uppercase in C programming?",
-    "opt1": "By using the toupper() function.",
-    "opt2": "By using a loop and converting each character.",
-    "opt3": "By using the strcat() function.",
-    "opt4": "By using the strcmp() function.",
-    "correct_option": "By using a loop and converting each character.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How can you convert a string to lowercase in C programming?",
-    "opt1": "By using the tolower() function.",
-    "opt2": "By using a loop and converting each character.",
-    "opt3": "By using the strcat() function.",
-    "opt4": "By using the strcmp() function.",
-    "correct_option": "By using a loop and converting each character.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of the sprintf() function in C programming?",
-    "opt1": "To format and store a string in a buffer.",
-    "opt2": "To concatenate two string",
-    "opt3": "To find the length of a string.",
-    "opt4": "To compare two strings.",
-    "correct_option": "To format and store a string in a buffer.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the sscanf() function in C programming?",
-    "opt1": "To read formatted input from a string.",
-    "opt2": "To concatenate two strings.",
-    "opt3": "To find the length of a string.",
-    "opt4": "To compare two strings.",
-    "correct_option": "To read formatted input from a string.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the output of the following code? int a = 10; int *p = &a; printf(\"%p\", p);",
-    "opt1": "10",
-    "opt2": "0",
-    "opt3": "Address of a",
-    "opt4": "Undefined",
-    "correct_option": "Address of a",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the output of the following code? int a = 10; int *p = &a; printf(\"%d\", *p);",
-    "opt1": "10",
-    "opt2": "0",
-    "opt3": "Address of a",
-    "opt4": "Undefined",
-    "correct_option": "10",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the correct way to declare a pointer to a character in C?",
-    "opt1": "char *str;",
-    "opt2": "char *str();",
-    "opt3": "char str*;",
-    "opt4": "char (*str)();",
-    "correct_option": "char *str;",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the output of the following code? int arr[5] = {1, 2, 3, 4, 5}; int *p = arr; printf(\"%d\", *(p+3));",
-    "opt1": "4",
-    "opt2": "3",
-    "opt3": "5",
-    "opt4": "Undefined",
-    "correct_option": "4",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the output of the following code? int arr[5] = {1, 2, 3, 4, 5}; int *p = arr + 2; printf(\"%d\", *(p-1));",
-    "opt1": "2",
-    "opt2": "3",
-    "opt3": "4",
-    "opt4": "Undefined",
-    "correct_option": "2",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the output of the following code? int a = 10; int *p = &a; int **q = &p; printf(\"%d\", **q);",
-    "opt1": "10",
-    "opt2": "0",
-    "opt3": "Address of a",
-    "opt4": "Undefined",
-    "correct_option": "10",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is a valid way to declare a pointer to an integer array of size 5?",
-    "opt1": "int (*arr)[5];",
-    "opt2": "int *arr[5];",
-    "opt3": "int **arr[5];",
-    "opt4": "int arr*[5];",
-    "correct_option": "int (*arr)[5];",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr + 1; printf(\"%d\", *(p--));",
-    "opt1": "2",
-    "opt2": "1",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "2",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr + 2; printf(\"%d\", *(--p));",
-    "opt1": "2",
-    "opt2": "1",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "2",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the output of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr; printf(\"%d\", *p++);",
-    "opt1": "1",
-    "opt2": "2",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "1",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true about pointer arithmetic in C?",
-    "opt1": "Addition and subtraction operations can be performed on pointers",
-    "opt2": "Multiplication and division operations can be performed on pointers",
-    "opt3": "Bitwise AND and OR operations can be performed on pointers",
-    "opt4": "None of the above",
-    "correct_option": "Addition and subtraction operations can be performed on pointers",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "If 'ptr' is a pointer to an integer variable, what will be the output of the following code? printf(\"%d\", ptr+1);",
-    "opt1": "The memory address of ptr",
-    "opt2": "The value of ptr",
-    "opt3": "The memory address of the integer variable ptr is pointing to",
-    "opt4": "The value of the integer variable ptr+1 is pointing to",
-    "correct_option": "The value of the integer variable ptr+1 is pointing to",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "If 'ptr' is a pointer to an integer variable, what will be the output of the following code? printf(\"%d\", *(ptr+1));",
-    "opt1": "The memory address of ptr",
-    "opt2": "The value of ptr",
-    "opt3": "The memory address of the integer variable ptr is pointing to",
-    "opt4": "The value of the integer variable ptr+1 is pointing to",
-    "correct_option": "The value of the integer variable ptr+1 is pointing to",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr; printf(\"%d\", *(p++));",
-    "opt1": "1",
-    "opt2": "2",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "1",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr; printf(\"%d\", *(p-2));",
-    "opt1": "1",
-    "opt2": "2",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "Undefined",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr; printf(\"%d\", *(p+4));",
-    "opt1": "1",
-    "opt2": "3",
-    "opt3": "4",
-    "opt4": "Undefined",
-    "correct_option": "Undefined",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the result of the following code? int a = 5, b = 10; int *p1 = &a; int *p2 = &b; int *temp; temp = p1; p1 = p2; p2 = temp; printf(\"%d %d\", *p1, *p2);",
-    "opt1": "5 10",
-    "opt2": "10 5",
-    "opt3": "Undefined",
-    "opt4": "Error",
-    "correct_option": "10 5",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the output of the following code? int a = 10; int *p = &a; (*p)++; printf(\"%d\", a);",
-    "opt1": "9",
-    "opt2": "10",
-    "opt3": "11",
-    "opt4": "Undefined",
-    "correct_option": "11",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr + 2; printf(\"%d\", p[-1]);",
-    "opt1": "1",
-    "opt2": "2",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "2",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4, 5}; int *p = arr + 2; printf(\"%d\", *p);",
-    "opt1": "1",
-    "opt2": "2",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "3",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the data type of the pointer variable in the following code? char *p;",
-    "opt1": "char",
-    "opt2": "int",
-    "opt3": "float",
-    "opt4": "double",
-    "correct_option": "char",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the result of the following code? int x = 10, y = 20, z; int *p = &x, *q = &y; z = *p + (*q)++; printf(\"%d %d %d\", x, y, z);",
-    "opt1": "11 20 30",
-    "opt2": "10 21 31",
-    "opt3": "11 21 30",
-    "opt4": "10 20 31",
-    "correct_option": "10 21 30",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4, 5}; int *p = &arr[3]; printf(\"%d\", *(p-2));",
-    "opt1": "1",
-    "opt2": "2",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "2",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4, 5}; int *p = arr; printf(\"%d\", *(++p));",
-    "opt1": "1",
-    "opt2": "2",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "2",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4, 5}; int *p = arr; printf(\"%d\", *(p+2));",
-    "opt1": "1",
-    "opt2": "2",
-    "opt3": "3",
-    "opt4": "4",
-    "correct_option": "3",
-    "correct_option_index": 3
-  },
-  
-  {
-    "qsns": "Which of the following is true about structures in C?",
-    "opt1": "Structures can contain only variables of the same data type",
-    "opt2": "Structures can contain variables of different data types",
-    "opt3": "Structures cannot be passed as function arguments",
-    "opt4": "Structures cannot be returned by functions",
-    "correct_option": "Structures can contain variables of different data types",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How do you declare a structure in C?",
-    "opt1": "struct {name, age};",
-    "opt2": "struct (name, age);",
-    "opt3": "struct person { char name[20]; int age; };",
-    "opt4": "struct {person name, person age};",
-    "correct_option": "struct person { char name[20]; int age; };",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is used to access the members of a structure?",
-    "opt1": "&",
-    "opt2": ".",
-    "opt3": ":",
-    "opt4": "->",
-    "correct_option": ".",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How do you assign values to members of a structure in C?",
-    "opt1": "using the assignment operator",
-    "opt2": "using the dot operator",
-    "opt3": "using the arrow operator ->",
-    "opt4": "using the asterisk operator*",
-    "correct_option": "using the assignment operator",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of typedef in C structures?",
-    "opt1": "to declare a new variable",
-    "opt2": "to define a new data type",
-    "opt3": "to initialize a structure",
-    "opt4": "to allocate memory for a structure",
-    "correct_option": "to define a new data type",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following statements is true regarding the size of a structure in C?",
-    "opt1": "The size of a structure is the sum of the sizes of its members",
-    "opt2": "The size of a structure is always 4 bytes",
-    "opt3": "The size of a structure is the size of its largest member",
-    "opt4": "The size of a structure is the size of its smallest member",
-    "correct_option": "The size of a structure is the sum of the sizes of its members",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the operator used to dynamically allocate memory for a structure in C?",
-    "opt1": ".",
-    "opt2": "&",
-    "opt3": "->",
-    "opt4": "malloc()",
-    "correct_option": "malloc()",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the operator used to deallocate memory allocated for a structure in C?",
-    "opt1": "&",
-    "opt2": ".",
-    "opt3": "free()",
-    "opt4": "calloc()",
-    "correct_option": "free()",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of a union in C?",
-    "opt1": "to combine multiple structures",
-    "opt2": "to create a new data type",
-    "opt3": "to declare a variable",
-    "opt4": "to share the same memory location for different data types",
-    "correct_option": "to share the same memory location for different data types",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is true about nested structures in C?",
-    "opt1": "Nested structures are not allowed in C",
-    "opt2": "Nested structures can only contain variables of the same data type",
-    "opt3": "Nested structures can be defined inside another structure",
-    "opt4": "Nested structures can only contain pointers to other structures",
-    "correct_option": "Nested structures can be defined inside another structure",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is a structure in C programming?",
-    "opt1": "A data type that groups variables of different types",
-    "opt2": "A data type that groups variables of the same type",
-    "opt3": "A data type that groups variables of the same size",
-    "opt4": "A data type that groups variables of different sizes",
-    "correct_option": "A data type that groups variables of different types",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the correct syntax to access a member of a nested structure?",
-    "opt1": "outer_structure.inner_structure.member_name",
-    "opt2": "inner_structure.member_name.outer_structure",
-    "opt3": "member_name.outer_structure.inner_structure",
-    "opt4": "None of the above",
-    "correct_option": "outer_structure.inner_structure.member_name",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the size of an empty structure in C programming?",
-    "opt1": "0 bytes",
-    "opt2": "1 byte",
-    "opt3": "4 bytes",
-    "opt4": "8 bytes",
-    "correct_option": "0 bytes",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is not a valid way to initialize a structure variable in C programming?",
-    "opt1": "struct book b = {\"C Programming\", \"John Doe\", 100};",
-    "opt2": "struct book b = {.name = \"C Programming\", .author = \"John Doe\", .price = 100};",
-    "opt3": "struct book b = {\"C Programming\", price=100};",
-    "opt4": "struct book b; b = {\"C Programming\", \"John Doe\", 100};",
-    "correct_option": "struct book b; b = {\"C Programming\", \"John Doe\", 100};",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is a nested structure in C programming?",
-    "opt1": "A structure that has no members",
-    "opt2": "A structure that is defined inside another structure",
-    "opt3": "A structure that has only one member",
-    "opt4": "A structure that has members of different data types",
-    "correct_option": "A structure that is defined inside another structure",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In C programming, which keyword is used to define a structure?",
-    "opt1": "typedef",
-    "opt2": "define",
-    "opt3": "structdef",
-    "opt4": "struct",
-    "correct_option": "struct",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following statements is true about passing a structure to a function in C programming?",
-    "opt1": "Structures cannot be passed to a function.",
-    "opt2": "Structures are passed by value to a function.",
-    "opt3": "Structures are passed by reference to a function.",
-    "opt4": "Structures are passed as arrays to a function.",
-    "correct_option": "Structures are passed by value to a function.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is not a valid way to declare a pointer to a structure in C programming?",
-    "opt1": "struct *book b;",
-    "opt2": "struct book *b;",
-    "opt3": "typedef struct book *bookptr;",
-    "opt4": "typedef struct book booktype;",
-    "correct_option": "struct *book b;",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the keyword used to access the address of a structure variable in C programming?",
-    "opt1": "&",
-    "opt2": "*",
-    "opt3": "#",
-    "opt4": "$",
-    "correct_option": "&",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the main difference between a structure and a union in C programming?",
-    "opt1": "A structure allows for multiple members to be accessed at once, while a union only allows for one member to be accessed at a time.",
-    "opt2": "A union allows for multiple members to be accessed at once, while a structure only allows for one member to be accessed at a time.",
-    "opt3": "There is no difference between a structure and a union in C programming.",
-    "opt4": "None of above",
-    "correct_option": "A structure allows for multiple members to be accessed at once, while a union only allows for one member to be accessed at a time.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is the correct way to access a structure member using a pointer to a structure?",
-    "opt1": "structure_pointer->member_name",
-    "opt2": "*structure_pointer.member_name",
-    "opt3": "structure_pointer.member_name",
-    "opt4": "None of the above",
-    "correct_option": "structure_pointer->member_name",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between passing a structure by value and passing a structure by pointer in C?",
-    "opt1": "When a structure is passed by value, any modifications made to it in the function are lost when the function returns. When a structure is passed by pointer, the modifications are retained.",
-    "opt2": "When a structure is passed by value, any modifications made to it in the function are retained when the function returns. When a structure is passed by pointer, the modifications are lost.",
-    "opt3": "There is no difference between passing a structure by value and passing a structure by pointer in C.",
-    "opt4": "None of the above",
-    "correct_option": "When a structure is passed by value, any modifications made to it in the function are lost when the function returns. When a structure is passed by pointer, the modifications are retained.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In a structure, what is the default visibility of its members?",
-    "opt1": "Private",
-    "opt2": "Public",
-    "opt3": "Protected",
-    "opt4": "None of the above",
-    "correct_option": "Public",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "In a union, how much memory is allocated for the union itself?",
-    "opt1": "The size of the largest member",
-    "opt2": "The size of all members combined",
-    "opt3": "The size of the smallest member",
-    "opt4": "The size of the union is not allocated in memory",
-    "correct_option": "The size of the largest member",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the main advantage of using a union over a structure?",
-    "opt1": "It uses less memory",
-    "opt2": "It is easier to declare and use",
-    "opt3": "It can hold more types of data",
-    "opt4": "It is faster to access its members",
-    "correct_option": "It uses less memory",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In a union, can two or more members be accessed simultaneously?",
-    "opt1": "Yes, always",
-    "opt2": "Yes, but only if they are of the same type",
-    "opt3": "No, only one member can be accessed at a time",
-    "opt4": "Yes, but only if the member is a pointer",
-    "correct_option": "No, only one member can be accessed at a time",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of declaring a bit field in a structure?",
-    "opt1": "To save memory",
-    "opt2": "To improve performance",
-    "opt3": "To store binary data",
-    "opt4": "To limit the number of possible values for a member",
-    "correct_option": "To save memory",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a structure or union contain a member that is itself a structure or union?",
-    "opt1": "Yes, there is no restriction on the type of members",
-    "opt2": "No, structures and unions cannot contain other structures or unions",
-    "opt3": "Yes, but only if the member is declared as static",
-    "opt4": "None of above",
-    "correct_option": "Yes, there is no restriction on the type of members",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How do you access a member of a structure or union using a pointer?",
-    "opt1": "-> operator",
-    "opt2": ". operator",
-    "opt3": "& operator",
-    "opt4": "* operator",
-    "correct_option": "-> operator",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In a union, what is the value of a member that was not explicitly set?",
-    "opt1": "Zero",
-    "opt2": "Garbage value",
-    "opt3": "Undefined",
-    "opt4": "The value of the previous member",
-    "correct_option": "Garbage value",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following statements is true about the size of a structure or union in C programming?",
-    "opt1": "The size of a structure or union is the sum of the sizes of its members",
-    "opt2": "The size of a structure or union is always a multiple of the size of its largest member",
-    "opt3": "The size of a structure or union depends on the alignment requirements of its members",
-    "opt4": "The size of a structure or union is always equal to the size of its largest member",
-    "correct_option": "The size of a structure or union depends on the alignment requirements of its members",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the difference between a structure and a union in C programming?",
-    "opt1": "A structure allows for multiple members to be accessed at once, while a union only allows for one member to be accessed at a time.",
-    "opt2": "A union allows for multiple members to be accessed at once, while a structure only allows for one member to be accessed at a time.",
-    "opt3": "There is no difference between a structure and a union in C programming.",
-    "opt4": "None of above",
-    "correct_option": "A structure allows for multiple members to be accessed at once, while a union only allows for one member to be accessed at a time.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the size of a structure in C programming?",
-    "opt1": "The size of a structure is equal to the sum of the sizes of its members.",
-    "opt2": "The size of a structure is equal to the size of its largest member.",
-    "opt3": "The size of a structure is equal to the size of its smallest member.",
-    "opt4": "None of above",
-    "correct_option": "The size of a structure is equal to the sum of the sizes of its members.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How do you access a member of a structure in C programming?",
-    "opt1": "Using the dot (.) operator.",
-    "opt2": "Using the arrow (->) operator.",
-    "opt3": "Using the asterisk (*) operator.",
-    "opt4": "None of above",
-    "correct_option": "Using the dot (.) operator.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the keyword used to define a structure in C programming?",
-    "opt1": "struct",
-    "opt2": "union",
-    "opt3": "typedef",
-    "opt4": "None of above",
-    "correct_option": "struct",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements about unions is true in C programming?",
-    "opt1": "Unions can contain members of different types.",
-    "opt2": "Unions cannot contain members.",
-    "opt3": "Unions can only contain members of the same type.",
-    "opt4": "None of above",
-    "correct_option": "Unions can contain members of different types.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between a structure and a typedef struct in C programming?",
-    "opt1": "There is no difference.",
-    "opt2": "Typedef struct can only be used to define new data types.",
-    "opt3": "Typedef struct is a faster way to create a new structure type.",
-    "opt4": "None of above",
-    "correct_option": "Typedef struct is a faster way to create a new structure type.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Can a structure contain a pointer to itself in C programming?",
-    "opt1": "Yes",
-    "opt2": "No",
-    "opt3": "It depends on the compiler used.",
-    "opt4": "It depends on Interpreter used.",
-    "correct_option": "Yes",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about the alignment of structure members in C programming?",
-    "opt1": "Members of a structure are always aligned to the nearest byte boundary.",
-    "opt2": "Members of a structure are aligned based on their size and type.",
-    "opt3": "Members of a structure are not aligned in C programming.",
-    "opt4": "None of above",
-    "correct_option": "Members of a structure are aligned based on their size and type.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of a bit-field in a structure in C programming?",
-    "opt1": "To allow the structure to store more data than its size would normally allow.",
-    "opt2": "To create a member that is only one bit in size.",
-    "opt3": "To allow the structure to be accessed in a bit-wise manner.",
-    "opt4": "None of above",
-    "correct_option": "To create a member that is only one bit in size.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is an example of a valid structure declaration in C programming?",
-    "opt1": "struct person {char name[50]; int age;}",
-    "opt2": "struct person (char name[50]; int age;)",
-    "opt3": "person_struct {char name[50]; int age;}",
-    "opt4": "None of above",
-    "correct_option": "struct person {char name[50]; int age;}",
-    "correct_option_index": 1
-  },
-  
-  {
-    "qsns": "What is the syntax for declaring an array of structures in C?",
-    "opt1": "struct array_name[size];",
-    "opt2": "array_name[size] struct;",
-    "opt3": "array_name[size] struct;",
-    "opt4": "struct[size] array_name;",
-    "correct_option": "struct array_name[size];",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In C programming, how do you access a particular member of a structure within an array of structures?",
-    "opt1": "array_name[index].member_name",
-    "opt2": "member_name.array_name[index]",
-    "opt3": "struct.array_name[index].member_name",
-    "opt4": "member_name[index].array_name",
-    "correct_option": "array_name[index].member_name",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of using an array of structures in C?",
-    "opt1": "To group similar data types together in a single entity.",
-    "opt2": "To group different data types together in a single entity.",
-    "opt3": "To make the code easier to read and maintain.",
-    "opt4": "To create a single variable that can hold multiple values.",
-    "correct_option": "To group similar data types together in a single entity.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How do you initialize an array of structures in C?",
-    "opt1": "By setting each member of the array individually.",
-    "opt2": "By setting the values of the first member of the array, which automatically sets the values of the rest of the members.",
-    "opt3": "By using a loop to set the values of each member of the array.",
-    "opt4": "By using a pointer to set the values of each member of the array.",
-    "correct_option": "By setting each member of the array individually.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the maximum number of dimensions that an array of structures can have in C?",
-    "opt1": "One",
-    "opt2": "Two",
-    "opt3": "Three",
-    "opt4": "There is no limit",
-    "correct_option": "There is no limit",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the purpose of using a typedef with an array of structures in C?",
-    "opt1": "To make it easier to declare variables of that type.",
-    "opt2": "To make the code more readable.",
-    "opt3": "To make it easier to access the members of the array.",
-    "opt4": "To create a new data type.",
-    "correct_option": "To create a new data type.",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a valid way to access a member of a structure within an array of structures in C?",
-    "opt1": "array_name.member_name[index]",
-    "opt2": "array_name[index].member_name",
-    "opt3": "member_name.array_name[index]",
-    "opt4": "struct.array_name[index].member_name",
-    "correct_option": "array_name[index].member_name",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How do you declare a pointer to an array of structures in C?",
-    "opt1": "struct *array_name[size];",
-    "opt2": "struct (*array_name)[size];",
-    "opt3": "struct *array_name[size];",
-    "opt4": "struct (*array_name)[size];",
-    "correct_option": "struct (*array_name)[size];",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "In C programming, how do you access a particular member of a structure within a pointer to an array of structures?",
-    "opt1": "pointer_name->member_name[index]",
-    "opt2": "pointer_name[index]->member_name",
-    "opt3": "pointer_name.member_name[index]",
-    "opt4": "pointer_name[index].member_name",
-    "correct_option": "pointer_name[index].member_name",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "How do you dynamically allocate memory for an array of structures in C?",
-    "opt1": "By using the malloc() function.",
-    "opt2": "By using the calloc() function.",
-    "opt3": "By using the realloc() function.",
-    "opt4": "By using the free() function.",
-    "correct_option": "By using the malloc() function.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How do you declare an array of structures in C?",
-    "opt1": "struct Array = {...}",
-    "opt2": "struct *Array = {...}",
-    "opt3": "struct Array[] = {...}",
-    "opt4": "struct Array {...}",
-    "correct_option": "struct Array[] = {...}",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the correct syntax for accessing the member variable \"age\" of the first structure in an array of structures named \"people\"?",
-    "opt1": "people.age[0]",
-    "opt2": "people[0].age",
-    "opt3": "people.age->0",
-    "opt4": "age[0].people",
-    "correct_option": "people[0].age",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the maximum number of elements that can be stored in an array of structures?",
-    "opt1": "There is no maximum number",
-    "opt2": "The maximum number is determined by the size of each element",
-    "opt3": "The maximum number is 1024",
-    "opt4": "The maximum number is determined by the amount of available memory",
-    "correct_option": "The maximum number is determined by the amount of available memory",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a valid way to initialize an array of structures in C?",
-    "opt1": "struct person[] = {{1, \"John\"}, {2, \"Jane\"}}",
-    "opt2": "struct person[] = { 1, \"John\" , {2, \"Jane\"}, {3, \"Bob\"}}",
-    "opt3": "struct person = [1] = {1, \"John\"}, [2]= {2, \"Jane\"}",
-    "opt4": "All of the above",
-    "correct_option": "struct person[] = {{1, \"John\"}, {2, \"Jane\"}}",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the size of the following structure? struct student { char name[50]; int age; float gpa; };",
-    "opt1": "54 bytes",
-    "opt2": "60 bytes",
-    "opt3": "62 bytes",
-    "opt4": "64 bytes",
-    "correct_option": "60 bytes",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which operator is used to access a member of a structure through a pointer to the structure?",
-    "opt1": ".",
-    "opt2": "->",
-    "opt3": "*",
-    "opt4": "&",
-    "correct_option": "->",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the correct syntax for declaring a pointer to a structure?",
-    "opt1": "struct *p;",
-    "opt2": "struct p;",
-    "opt3": "struct pointer;",
-    "opt4": "struct person *p;",
-    "correct_option": "struct person *p;",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "How can you dynamically allocate memory for an array of structures in C?",
-    "opt1": "struct array = (struct *) malloc(sizeof(struct) * n);",
-    "opt2": "struct array = (struct**) malloc(n * sizeof(struct));",
-    "opt3": "struct array = (struct*) malloc(n);",
-    "opt4": "struct array = (struct*) malloc(sizeof(struct));",
-    "correct_option": "struct array = (struct *) malloc(sizeof(struct) * n);",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How can you access the last element in an array of structures with n elements?",
-    "opt1": "arr[n]",
-    "opt2": "arr[n-1]",
-    "opt3": "arr.last",
-    "opt4": "arr.end",
-    "correct_option": "arr[n-1]",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is an advantage of using an array of structures instead of multiple individual structures?",
-    "opt1": "Easier to manage",
-    "opt2": "Easier to pass to functions",
-    "opt3": "Requires less memory",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the syntax for passing a structure to a function in C?",
-    "opt1": "function(struct s)",
-    "opt2": "function(struct *s)",
-    "opt3": "function(*s)",
-    "opt4": "function(&s)",
-    "correct_option": "function(struct s)",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How do you declare a function that takes a structure as an argument in C?",
-    "opt1": "void myFunction(struct myStruct);",
-    "opt2": "void myFunction(struct myStruct *);",
-    "opt3": "void myFunction(*myStruct);",
-    "opt4": "void myFunction(&myStruct);",
-    "correct_option": "void myFunction(struct myStruct);",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can you pass an array of structures to a function in C?",
-    "opt1": "No, C does not support passing arrays of structures to functions",
-    "opt2": "Yes, you can pass an array of structures to a function using a pointer",
-    "opt3": "Yes, you can pass an array of structures to a function by value",
-    "opt4": "Yes, you can pass an array of structures to a function using the & operator",
-    "correct_option": "Yes, you can pass an array of structures to a function using a pointer",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How does passing a structure to a function by reference (i.e. using a pointer) differ from passing it by value?",
-    "opt1": "Passing by reference creates a copy of the structure, while passing by value does not",
-    "opt2": "Passing by reference allows the function to modify the original structure, while passing by value does not",
-    "opt3": "Passing by reference is slower than passing by value",
-    "opt4": "Passing by reference is not allowed in C",
-    "correct_option": "Passing by reference allows the function to modify the original structure, while passing by value does not",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the advantage of passing a structure to a function by reference instead of by value?",
-    "opt1": "Passing by reference is faster",
-    "opt2": "Passing by reference allows the function to modify the original structure",
-    "opt3": "Passing by reference is easier to write",
-    "opt4": "Passing by reference requires less memory",
-    "correct_option": "Passing by reference is faster",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How do you access a structure member inside a function that takes a pointer to the structure as an argument?",
-    "opt1": "s.member",
-    "opt2": "(*s).member",
-    "opt3": "&s->member",
-    "opt4": "s->member",
-    "correct_option": "s->member",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the correct way to pass a structure to a function by reference?",
-    "opt1": "function(struct s)",
-    "opt2": "function(struct *s)",
-    "opt3": "function(&s)",
-    "opt4": "function(*s)",
-    "correct_option": "function(&s)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Can a function return a structure in C?",
-    "opt1": "Yes, by using the & operator",
-    "opt2": "Yes, but it requires passing a pointer to the structure as an argument",
-    "opt3": "Yes, by returning a pointer to the structure",
-    "opt4": "No, C does not support returning structures from functions",
-    "correct_option": "Yes, by returning a pointer to the structure",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "How do you initialize a structure variable inside a function?",
-    "opt1": "struct s = {...}",
-    "opt2": "s = {...}",
-    "opt3": "Pass by value",
-    "opt4": "Pass by reference",
-    "correct_option": "struct s = {...}",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the advantage of passing a structure by pointer to a function in C?",
-    "opt1": "It reduces the size of the structure",
-    "opt2": "It increases the speed of the program",
-    "opt3": "It allows the function to modify the original structure",
-    "opt4": "None of the above",
-    "correct_option": "It allows the function to modify the original structure",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is the correct syntax to pass a structure by value to a function in C?",
-    "opt1": "function_name(&structure_variable)",
-    "opt2": "function_name(*structure_variable)",
-    "opt3": "function_name(structure_variable)",
-    "opt4": "function_name(structure_pointer)",
-    "correct_option": "function_name(structure_variable)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is the correct syntax to pass a structure by reference to a function in C?",
-    "opt1": "function_name(&structure_variable)",
-    "opt2": "function_name(*structure_variable)",
-    "opt3": "function_name(structure_variable)",
-    "opt4": "function_name(structure_pointer)",
-    "correct_option": "function_name(&structure_variable)",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is the correct syntax to pass a structure by pointer to a function in C?",
-    "opt1": "function_name(&structure_variable)",
-    "opt2": "function_name(structure_variable)",
-    "opt3": "function_name(structure_pointer)",
-    "opt4": "function_name(*structure_variable)",
-    "correct_option": "function_name(structure_pointer)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is the correct way to access a structure member using a pointer to a structure?",
-    "opt1": "structure_pointer->member_name",
-    "opt2": "*structure_pointer.member_name",
-    "opt3": "structure_pointer.member_name",
-    "opt4": "None of the above",
-    "correct_option": "structure_pointer->member_name",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the difference between passing a structure by value and passing a structure by pointer in C?",
-    "opt1": "When a structure is passed by value, any modifications made to it in the function are lost when the function returns. When a structure is passed by pointer, the modifications are retained.",
-    "opt2": "When a structure is passed by value, any modifications made to it in the function are retained when the function returns. When a structure is passed by pointer, the modifications are lost.",
-    "opt3": "There is no difference between passing a structure by value and passing a structure by pointer in C.",
-    "opt4": "None of the above",
-    "correct_option": "When a structure is passed by value, any modifications made to it in the function are lost when the function returns. When a structure is passed by pointer, the modifications are retained.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a namespace in C++?",
-    "opt1": "It is a block of code that is used to group related variables and functions",
-    "opt2": "It is a feature that allows a class to inherit from multiple base classes",
-    "opt3": "It is a mechanism for managing the scope of identifiers in large programs",
-    "opt4": "It is a type of loop in C++",
-    "correct_option": "It is a mechanism for managing the scope of identifiers in large programs",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which keyword is used to define a namespace in C++?",
-    "opt1": "namespace",
-    "opt2": "define",
-    "opt3": "namespace scope",
-    "opt4": "using namespace",
-    "correct_option": "namespace",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true regarding namespaces in C++?",
-    "opt1": "You can have multiple namespaces with the same name in the same program",
-    "opt2": "Namespaces can only contain function declarations",
-    "opt3": "You can define a namespace within a function",
-    "opt4": "The contents of a namespace can be accessed using the dot operator",
-    "correct_option": "You can have multiple namespaces with the same name in the same program",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of using the using keyword with namespaces in C++?",
-    "opt1": "To create an alias for a namespace",
-    "opt2": "To bring all the members of a namespace into the current scope",
-    "opt3": "To hide certain members of a namespace",
-    "opt4": "To define a new namespace within an existing namespace",
-    "correct_option": "To bring all the members of a namespace into the current scope",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the scope resolution operator in C++?",
-    "opt1": ":",
-    "opt2": "::",
-    "opt3": "->",
-    "opt4": "#",
-    "correct_option": "::",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is true regarding the scope resolution operator in C++?",
-    "opt1": "It is used to access the members of a namespace",
-    "opt2": "It is used to access the members of a class",
-    "opt3": "It is used to access the elements of an array",
-    "opt4": "It is used to access the elements of a linked list",
-    "correct_option": "It is used to access the members of a namespace",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the unnamed namespace in C++?",
-    "opt1": "To make a function or variable global",
-    "opt2": "To limit the visibility of a function or variable to a single source file",
-    "opt3": "To create a new namespace within an existing namespace",
-    "opt4": "To create a namespace with a name that cannot be accessed by the user",
-    "correct_option": "To limit the visibility of a function or variable to a single source file",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is a benefit of using namespaces in C++?",
-    "opt1": "They prevent naming conflicts between classes",
-    "opt2": "They allow you to define variables with the same name in different functions",
-    "opt3": "They improve the performance of the program",
-    "opt4": "They allow you to define variables with the same name in the same scope",
-    "correct_option": "They prevent naming conflicts between classes",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of using namespaces in C++?",
-    "opt1": "They can make the code more difficult to read and understand",
-    "opt2": "They increase the size of the executable file",
-    "opt3": "They make it more difficult to reuse code in different projects",
-    "opt4": "They increase the likelihood of naming conflicts between classes",
-    "correct_option": "They can make the code more difficult to read and understand",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true regarding the global namespace in C++?",
-    "opt1": "All variables and functions defined outside of a namespace belong to the global namespace",
-    "opt2": "The global namespace is automatically included in every program",
-    "opt3": "The global namespace can be used to define variables and functions that can be accessed from any part of the program",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is a namespace in C++?",
-    "opt1": "A container that holds a group of related variables and functions",
-    "opt2": "A type of loop that iterates over a collection of elements",
-    "opt3": "A method of creating a new object from an existing object",
-    "opt4": "A way to specify the data type of a variable",
-    "correct_option": "A container that holds a group of related variables and functions",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which keyword is used to define a namespace in C++?",
-    "opt1": "using",
-    "opt2": "namespace",
-    "opt3": "define",
-    "opt4": "typedef",
-    "correct_option": "namespace",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following statements is true regarding namespaces in C++?",
-    "opt1": "Nested namespaces are not allowed",
-    "opt2": "A namespace can only contain functions",
-    "opt3": "Namespaces are only used in object-oriented programming",
-    "opt4": "Namespace members are accessed using the :: operator",
-    "correct_option": "Namespace members are accessed using the :: operator",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the purpose of using a namespace in C++?",
-    "opt1": "To avoid naming conflicts between variables and functions",
-    "opt2": "To allocate memory dynamically",
-    "opt3": "To overload operators for a class",
-    "opt4": "To declare a global variable",
-    "correct_option": "To avoid naming conflicts between variables and functions",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the default namespace in C++?",
-    "opt1": "std",
-    "opt2": "default",
-    "opt3": "main",
-    "opt4": "none of the above",
-    "correct_option": "std",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a namespace be defined across multiple files in C++?",
-    "opt1": "Yes, by using the using directive",
-    "opt2": "Yes, by using the namespace keyword",
-    "opt3": "No, a namespace must be defined in a single file",
-    "opt4": "No, a namespace can only be defined within a function",
-    "correct_option": "Yes, by using the namespace keyword",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is a valid way to alias a namespace in C++?",
-    "opt1": "namespace A::B",
-    "opt2": "using A::B",
-    "opt3": "namespace B = A",
-    "opt4": "using namespace A::B",
-    "correct_option": "namespace B = A",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is an advantage of using namespaces in C++?",
-    "opt1": "They allow for faster program execution",
-    "opt2": "They make it easier to reuse code",
-    "opt3": "They help to reduce the size of the program",
-    "opt4": "They prevent type conversion errors",
-    "correct_option": "They make it easier to reuse code",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is true regarding the scope of a namespace in C++?",
-    "opt1": "A namespace can be used anywhere in the program",
-    "opt2": "A namespace can only be used within the file it is defined in",
-    "opt3": "A namespace can only be used within the class it is defined in",
-    "opt4": "A namespace can only be used within the function it is defined in",
-    "correct_option": "A namespace can be used anywhere in the program",
-    "correct_option_index": 1
-  },
-  
-  {
-    "qsns": "Which of the following statements is true about function overloading in C++?",
-    "opt1": "Only the function name should be the same for overloaded functions",
-    "opt2": "Overloaded functions can differ in the number of parameters",
-    "opt3": "Overloaded functions cannot have the same return type",
-    "opt4": "All of the above",
-    "correct_option": "Overloaded functions can differ in the number of parameters",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which operator cannot be overloaded in C++?",
-    "opt1": "&& and ||",
-    "opt2": ":: and ->",
-    "opt3": "+ and -",
-    "opt4": "All of the above",
-    "correct_option": ":: and ->",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is not a valid way of differentiating between overloaded functions?",
-    "opt1": "Number of parameters",
-    "opt2": "Order of parameters",
-    "opt3": "Return type",
-    "opt4": "None of the above",
-    "correct_option": "Return type",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following statements is true about function overloading in C++? (Repeated concept)",
-    "opt1": "Overloaded functions must have the same access level",
-    "opt2": "Access levels do not affect function overloading",
-    "opt3": "Overloaded functions must have different access levels",
-    "opt4": "None of the above",
-    "correct_option": "Access levels do not affect function overloading",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the benefit of function overloading in C++?",
-    "opt1": "It reduces the number of functions in a program",
-    "opt2": "It makes the code easier to read and understand",
-    "opt3": "It allows the same function name to be used for different operations",
-    "opt4": "All of the above",
-    "correct_option": "It allows the same function name to be used for different operations",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is true about function overloading? (Repeated concept)",
-    "opt1": "Overloaded functions can have different names",
-    "opt2": "Overloaded functions can have the same number and types of parameters",
-    "opt3": "Overloaded functions must have the same return type",
-    "opt4": "None of the above",
-    "correct_option": "None of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is an example of function overloading in C++?",
-    "opt1": "int add(int a, int b)",
-    "opt2": "float add(float a, float b)",
-    "opt3": "void add(int a, int b)",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is function overloading in C++?",
-    "opt1": "Defining a function with the same name and same parameters as an existing function",
-    "opt2": "Defining a function with the same name but different parameters as an existing function",
-    "opt3": "Defining a function with a different name but the same parameters as an existing function",
-    "opt4": "Defining a function with a different name and different parameters as an existing function",
-    "correct_option": "Defining a function with the same name but different parameters as an existing function",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is not a valid way to overload a function in C++?",
-    "opt1": "Changing the number of parameters in the function",
-    "opt2": "Changing the return type of the function",
-    "opt3": "Changing the order of the parameters in the function",
-    "opt4": "Changing the type of the parameters in the function",
-    "correct_option": "Changing the return type of the function",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of function overloading in C++?",
-    "opt1": "To create new functions with different names",
-    "opt2": "To create functions that have different return types",
-    "opt3": "To allow functions to work with different types of data",
-    "opt4": "To allow functions to be used with different sets of parameters",
-    "correct_option": "To allow functions to be used with different sets of parameters",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is an example of function overloading in C++? (Repeated concept)",
-    "opt1": "int add(int x, int y)",
-    "opt2": "float add(float x, float y)",
-    "opt3": "char add(char x, char y)",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Can two functions in C++ have the same name and the same set of parameters?",
-    "opt1": "Yes, as long as they have different return types",
-    "opt2": "Yes, as long as they are declared in different namespaces",
-    "opt3": "No, it is not allowed in C++",
-    "opt4": "Yes, as long as they are declared in different classes",
-    "correct_option": "No, it is not allowed in C++",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is true about function overloading in C++? (Repeated concept)",
-    "opt1": "Overloaded functions must have the same name",
-    "opt2": "Overloaded functions must have different return types",
-    "opt3": "Overloaded functions must have the same number of parameters",
-    "opt4": "Overloaded functions must have different parameter types or different number of parameters",
-    "correct_option": "Overloaded functions must have different parameter types or different number of parameters",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the benefit of using function overloading in C++?",
-    "opt1": "It allows you to create functions with different names",
-    "opt2": "It allows you to create functions with different return types",
-    "opt3": "It allows you to write more efficient code",
-    "opt4": "It allows you to create more versatile functions",
-    "correct_option": "It allows you to create more versatile functions",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following operators can be overloaded in C++?",
-    "opt1": "+",
-    "opt2": "=",
-    "opt3": "[]",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Can you overload a member function in C++?",
-    "opt1": "Yes, you can overload both member and non-member functions in C++",
-    "opt2": "No, member functions cannot be overloaded in C++",
-    "opt3": "Yes, but only if the functions have different return types",
-    "opt4": "Yes, but only if the functions have different parameters",
-    "correct_option": "Yes, you can overload both member and non-member functions in C++",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is an example of function overloading?",
-    "opt1": "int add(int x, int y) { return x + y; } int add(int x, int y, int z) { return x+y+z;}",
-    "opt2": "int add(int x, int y) { return x + y; } float add(int x, int y) { return x + y;}",
-    "opt3": "int add(int x, int y) { return x + y; } int subtract(int x, int y) { return x - y; }",
-    "opt4": "All of the above",
-    "correct_option": "int add(int x, int y) { return x + y; } int add(int x, int y, int z) { return x+y+z;}",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is an inline function in C++?",
-    "opt1": "A function that takes an argument of type inline",
-    "opt2": "A function that is defined with the inline keyword",
-    "opt3": "A function that is executed sequentially",
-    "opt4": "A function that is expanded inline by the compiler",
-    "correct_option": "A function that is defined with the inline keyword",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the advantage of using an inline function?",
-    "opt1": "It reduces the size of the program",
-    "opt2": "It reduces the function call overhead",
-    "opt3": "It increases the performance of the program",
-    "opt4": "It allows for recursion",
-    "correct_option": "It reduces the function call overhead",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which keyword is used to declare an inline function in C++?",
-    "opt1": "function",
-    "opt2": "inline",
-    "opt3": "def",
-    "opt4": "define",
-    "correct_option": "inline",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Can a function that returns void be inline in C++?",
-    "opt1": "Yes, any function can be declared inline",
-    "opt2": "No, only functions that return a value can be inline",
-    "opt3": "It depends on the implementation",
-    "opt4": "None of the above",
-    "correct_option": "Yes, any function can be declared inline",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about inline functions in C++?",
-    "opt1": "Inline functions cannot be recursive",
-    "opt2": "Inline functions cannot contain loops",
-    "opt3": "Inline functions cannot be overloaded",
-    "opt4": "Inline functions cannot have default arguments",
-    "correct_option": "Inline functions cannot be recursive",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How does the compiler treat inline functions in C++?",
-    "opt1": "It generates a separate function call for each call to the inline function",
-    "opt2": "It replaces the function call with the actual function code at the point of the call",
-    "opt3": "It generates an error if the function is not defined inline",
-    "opt4": "It generates a jump instruction to the function code at the point of the call",
-    "correct_option": "It replaces the function call with the actual function code at the point of the call",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Can a function that is defined in a separate source file be inline in C++?",
-    "opt1": "Yes, as long as the function is declared inline in the header file",
-    "opt2": "No, inline functions must be defined in the same source file as the caller",
-    "opt3": "It depends on the implementation of the compiler",
-    "opt4": "None of the above",
-    "correct_option": "No, inline functions must be defined in the same source file as the caller",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is an example of an inline function in C++?",
-    "opt1": "int add(int a, int b) { return a + b; }",
-    "opt2": "void print_hello() { std::cout << \"Hello, world!\" << std::endl; }",
-    "opt3": "double square(double x) {return x*x;}",
-    "opt4": "class Rectangle { public: inline int area() { return width * height; } };",
-    "correct_option": "class Rectangle { public: inline int area() { return width * height; } };",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of using inline functions in C++?",
-    "opt1": "It can increase the size of the program",
-    "opt2": "It can decrease the performance of the program",
-    "opt3": "It can lead to code bloat",
-    "opt4": "It can lead to name collisions",
-    "correct_option": "It can increase the size of the program",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is a good candidate for an inline function in C++?",
-    "opt1": "A function that performs complex calculations",
-    "opt2": "A function that is called frequently and has a short body",
-    "opt3": "A function that takes a long time to execute",
-    "opt4": "A function that is rarely called and has a long body",
-    "correct_option": "A function that is called frequently and has a short body",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is an inline function in C++? (Repeated concept)",
-    "opt1": "A function defined with the \"inline\" keyword, which is a suggestion to the compiler to perform inline expansion of the function",
-    "opt2": "A function defined with the \"inline\" keyword, which is a requirement for the compiler to perform inline expansion of the function",
-    "opt3": "A function that is always expanded inline by the compiler, regardless of how it is defined",
-    "opt4": "A function that is never expanded inline by the compiler, regardless of how it is defined",
-    "correct_option": "A function defined with the \"inline\" keyword, which is a suggestion to the compiler to perform inline expansion of the function",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the advantage of using inline functions in C++? (Repeated concept)",
-    "opt1": "They are faster than regular functions",
-    "opt2": "They reduce the executable size of a program",
-    "opt3": "They can be used to define function templates",
-    "opt4": "They make it easier to overload functions",
-    "correct_option": "They are faster than regular functions",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "When should you use an inline function in C++?",
-    "opt1": "When the function is small and simple",
-    "opt2": "When the function is called frequently",
-    "opt3": "When the function has a lot of parameters",
-    "opt4": "When the function is large and complex",
-    "correct_option": "When the function is small and simple",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a virtual function be inline in C++?",
-    "opt1": "When the function is used in only one place in the program",
-    "opt2": "No, virtual functions cannot be inline in C++",
-    "opt3": "Yes, as long as it is defined with the \"inline\" keyword only",
-    "opt4": "It depends on the compiler",
-    "correct_option": "No, virtual functions cannot be inline in C++",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the syntax for defining an inline function in C++?",
-    "opt1": "inline int function_name(int param1, int param2) {}",
-    "opt2": "void inline function_name(int param1, int param2) {}",
-    "opt3": "int inline function_name(int param1, int param2) {}",
-    "opt4": "inline function_name(int param1, int param2) {}",
-    "correct_option": "inline int function_name(int param1, int param2) {}",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a member function of a class be inline in C++?",
-    "opt1": "Yes, as long as it is defined with the \"inline\" keyword",
-    "opt2": "No, member functions cannot be inline in C++",
-    "opt3": "Yes, as long as it is defined with the \"inline\" keyword and the function body is defined inside the class definition",
-    "opt4": "It depends on the implementation",
-    "correct_option": "Yes, as long as it is defined with the \"inline\" keyword and the function body is defined inside the class definition",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the \"inline\" keyword in C++?",
-    "opt1": "To indicate that a function is a friend of a class",
-    "opt2": "To require the compiler to perform inline expansion of a function",
-    "opt3": "To suggest to the compiler to perform inline expansion of a function",
-    "opt4": "To indicate that a function is a virtual function",
-    "correct_option": "To suggest to the compiler to perform inline expansion of a function",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a disadvantage of using inline functions in C++? (Repeated concept)",
-    "opt1": "They can increase the size of the executable code",
-    "opt2": "They can slow down the program execution",
-    "opt3": "They can make debugging more difficult",
-    "opt4": "There are no disadvantages to using inline functions",
-    "correct_option": "They can increase the size of the executable code",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a function defined in a header file be inline in C++?",
-    "opt1": "Yes, as long as it is defined with the \"inline\" keyword",
-    "opt2": "No, functions defined in header files cannot be inline in C++",
-    "opt3": "Yes, as long as it is defined with the \"inline\" keyword and the function body is defined inside the header file",
-    "opt4": "It depends on the compiler",
-    "correct_option": "Yes, as long as it is defined with the \"inline\" keyword and the function body is defined inside the header file",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is a default argument in C++?",
-    "opt1": "An argument that is automatically assigned the value 0",
-    "opt2": "An argument that is assigned the value of the previous argument",
-    "opt3": "An argument that is assigned a value if no other value is provided",
-    "opt4": "An argument that is assigned a random value",
-    "correct_option": "An argument that is assigned a value if no other value is provided",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is true about default arguments?",
-    "opt1": "They must be specified in the function declaration and definition",
-    "opt2": "They can only be of basic data types such as int and float",
-    "opt3": "They must always come at the beginning of the argument list",
-    "opt4": "They cannot be of array types",
-    "correct_option": "They must be specified in the function declaration and definition",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is an example of a function that uses a default argument?",
-    "opt1": "int add(int x, int y)",
-    "opt2": "float divide(float a, float b, float c = 1.0)",
-    "opt3": "void print()",
-    "opt4": "char getChar(char c = 'a')",
-    "correct_option": "float divide(float a, float b, float c = 1.0)",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the order in which arguments are passed to a function?",
-    "opt1": "Regular arguments first, followed by default arguments",
-    "opt2": "Default arguments first, followed by regular arguments",
-    "opt3": "Random order",
-    "opt4": "None of the above",
-    "correct_option": "Regular arguments first, followed by default arguments",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true about default arguments in relation to function overloading?",
-    "opt1": "Default arguments are not allowed in function overloading",
-    "opt2": "Default arguments must be the same for all functions in an overload set",
-    "opt3": "Default arguments are allowed, but only for one function in an overload set",
-    "opt4": "Default arguments must be different for all functions in an overload set",
-    "correct_option": "Default arguments are allowed, but only for one function in an overload set",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the benefit of using default arguments?",
-    "opt1": "It makes the code more efficient",
-    "opt2": "It allows for fewer function overloads",
-    "opt3": "It improves code readability",
-    "opt4": "It allows for more complex programs",
-    "correct_option": "It allows for fewer function overloads",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What happens if a default argument is specified in both the function declaration and definition?",
-    "opt1": "The code will not compile",
-    "opt2": "The argument specified in the definition will be used",
-    "opt3": "The argument specified in the declaration will be used",
-    "opt4": "The default argument will be ignored",
-    "correct_option": "The code will not compile",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true about default arguments and templates?",
-    "opt1": "Default arguments are not allowed in templates",
-    "opt2": "Default arguments can be used in templates, but only for one parameter",
-    "opt3": "Default arguments can be used in templates for any number of parameters",
-    "opt4": "Default arguments in templates must be the same for all instantiations",
-    "correct_option": "Default arguments can be used in templates for any number of parameters",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What are default arguments in C++? (Repeated concept)",
-    "opt1": "Arguments that are automatically initialized with a default value.",
-    "opt2": "Arguments that are passed by value.",
-    "opt3": "Arguments that are passed by reference.",
-    "opt4": "Arguments that are passed by pointer.",
-    "correct_option": "Arguments that are automatically initialized with a default value.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Where should default arguments be specified in a function declaration?",
-    "opt1": "Before the function name.",
-    "opt2": "After the function name.",
-    "opt3": "Before the return type.",
-    "opt4": "After the return type.",
-    "correct_option": "After the function name.",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of default arguments? (Repeated concept)",
-    "opt1": "To make functions more efficient.",
-    "opt2": "To make it easier to pass arguments to a function.",
-    "opt3": "To allow a function to be overloaded.",
-    "opt4": "To provide a default value for a parameter if one is not specified.",
-    "correct_option": "To provide a default value for a parameter if one is not specified.",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "When are default arguments evaluated?",
-    "opt1": "At runtime.",
-    "opt2": "At compile time.",
-    "opt3": "At link time.",
-    "opt4": "At load time.",
-    "correct_option": "At runtime.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What happens if a default argument is specified in both the function declaration and the function definition? (Repeated concept)",
-    "opt1": "The program will not compile.",
-    "opt2": "The default argument specified in the function definition will be used.",
-    "opt3": "The default argument specified in the function declaration will be used.",
-    "opt4": "Both default arguments will be used.",
-    "correct_option": "The program will not compile.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the syntax for specifying a default argument?",
-    "opt1": "argumentType argumentName = defaultValue",
-    "opt2": "argumentType defaultValue argumentName",
-    "opt3": "defaultValue argumentType argumentName",
-    "opt4": "argumentName = defaultValue",
-    "correct_option": "argumentType argumentName = defaultValue",
-    "correct_option_index": 1
-  },
-  
-  {
-    "qsns": "Which of the following is true about classes in C++?",
-    "opt1": "A class is a blueprint for objects",
-    "opt2": "A class is an object",
-    "opt3": "A class is a function",
-    "opt4": "A class is a data type",
-    "correct_option": "A class is a blueprint for objects",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following keywords is used to create an object of a class?",
-    "opt1": "new",
-    "opt2": "this",
-    "opt3": "object",
-    "opt4": "none of the above",
-    "correct_option": "new",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following access specifiers is used to make class members accessible only within the same class?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "none of the above",
-    "correct_option": "private",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is a constructor?",
-    "opt1": "A function that is used to create an object of a class",
-    "opt2": "A function that is used to destroy an object of a class",
-    "opt3": "A function that is used to allocate memory for an object of a class",
-    "opt4": "A function that is used to deallocate memory for an object of a class",
-    "correct_option": "A function that is used to create an object of a class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is encapsulation in C++?",
-    "opt1": "Combining data members and member functions in a single unit",
-    "opt2": "Making class members accessible only within the same class",
-    "opt3": "Creating objects of a class",
-    "opt4": "None of the above",
-    "correct_option": "Combining data members and member functions in a single unit",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a class in C++?",
-    "opt1": "A user-defined data type",
-    "opt2": "A built-in data type",
-    "opt3": "A function",
-    "opt4": "A pointer to a variable",
-    "correct_option": "A user-defined data type",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true about a static member of a class?",
-    "opt1": "It is shared by all objects of the class",
-    "opt2": "It is specific to each object of the class",
-    "opt3": "It can be accessed using the object of the class",
-    "opt4": "It cannot be accessed using the object of the class",
-    "correct_option": "It is shared by all objects of the class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is used to create a copy of an object in C++?",
-    "opt1": "Object cloning",
-    "opt2": "Object duplication",
-    "opt3": "Object copying",
-    "opt4": "Object creation",
-    "correct_option": "Object copying",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is used to initialize the data members of an object of a class?",
-    "opt1": "Constructors",
-    "opt2": "Destructors",
-    "opt3": "assignment operators",
-    "opt4": "Copy constructors",
-    "correct_option": "Constructors",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true about friend functions in C++?",
-    "opt1": "Friend functions are class members",
-    "opt2": "Friend functions can access private and protected members of a class",
-    "opt3": "Friend functions can be called using an object of the class",
-    "opt4": "Friend functions cannot be defined outside the class",
-    "correct_option": "Friend functions can access private and protected members of a class",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is an object in C++?",
-    "opt1": "An instance of a class",
-    "opt2": "A type of data",
-    "opt3": "A function",
-    "opt4": "A pointer to a variable",
-    "correct_option": "An instance of a class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following access specifiers in C++ allows the member to be accessed by any function or class in the program?",
-    "opt1": "Private",
-    "opt2": "Protected",
-    "opt3": "Public",
-    "opt4": "Friend",
-    "correct_option": "Public",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which access specifier in C++ allows a member function or variable to be accessed only by the same class and its friends?",
-    "opt1": "Private",
-    "opt2": "Public",
-    "opt3": "Protected",
-    "opt4": "Friend",
-    "correct_option": "Private",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which access specifier in C++ allows a member function or variable to be accessed by the same class, its derived classes, and its friends?",
-    "opt1": "Private",
-    "opt2": "Public",
-    "opt3": "Protected",
-    "opt4": "Friend",
-    "correct_option": "Protected",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is true about access specifiers in C++?",
-    "opt1": "They determine the visibility of a member outside of the class.",
-    "opt2": "They determine the data type of a member.",
-    "opt3": "They determine the scope of a member within the class.",
-    "opt4": "They determine the storage location of a member.",
-    "correct_option": "They determine the visibility of a member outside of the class.",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following access specifiers is used to hide the implementation details of a class from the user?",
-    "opt1": "Private",
-    "opt2": "Public",
-    "opt3": "Protected",
-    "opt4": "Friend",
-    "correct_option": "Private",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which access specifier in C++ allows a member function or variable to be accessed by any class or function that is declared as a friend of the class?",
-    "opt1": "Private",
-    "opt2": "Public",
-    "opt3": "Protected",
-    "opt4": "Friend",
-    "correct_option": "Friend",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which access specifier in C++ allows a member function or variable to be accessed by the same class and its derived classes?",
-    "opt1": "Private",
-    "opt2": "Public",
-    "opt3": "Protected",
-    "opt4": "Friend",
-    "correct_option": "Protected",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which access specifier in C++ allows a member function or variable to be accessed by any function or class within the same namespace?",
-    "opt1": "Private",
-    "opt2": "Public",
-    "opt3": "Protected",
-    "opt4": "Friend",
-    "correct_option": "Public",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following access specifiers in C++ is used to prevent a member from being accessed outside of the class definition?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "private",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which access specifier allows access to a class member only within the class definition?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "private",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which access specifier allows access to a class member from any function outside the class definition?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "public",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which access specifier allows a derived class to access the protected members of its base class?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "protected",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which access specifier allows access to a class member from a derived class?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "protected",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which access specifier allows a member function to access all members of a class?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "private",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the default access specifier for a class in C++?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "private",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which access specifier allows a friend function to access all members of a class?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "friend",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which access specifier allows access to a class member from any class?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "public",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which access specifier should be used for class members that need to be accessed by functions outside the class definition?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "public",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which access specifier should be used for class members that should only be accessed within the class definition?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "friend",
-    "correct_option": "private",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the dot operator used for in C++?",
-    "opt1": "To declare objects",
-    "opt2": "To access a member of an object",
-    "opt3": "To access a function of a class",
-    "opt4": "To access a class variable",
-    "correct_option": "To access a member of an object",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is an example of an object?",
-    "opt1": "int x;",
-    "opt2": "string s;",
-    "opt3": "MyClass obj;",
-    "opt4": "double y;",
-    "correct_option": "MyClass obj;",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following operators is used to access a member of an object?",
-    "opt1": ".",
-    "opt2": "->",
-    "opt3": "::",
-    "opt4": ":",
-    "correct_option": ".",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is used to initialize an object?",
-    "opt1": "The constructor",
-    "opt2": "The destructor",
-    "opt3": "The copy constructor",
-    "opt4": "The assignment operator",
-    "correct_option": "The constructor",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following access specifiers allows a member to be accessed from any function?",
-    "opt1": "Public",
-    "opt2": "Private",
-    "opt3": "Protected",
-    "opt4": "Friend",
-    "correct_option": "Public",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the keyword used to declare a class in C++?",
-    "opt1": "class",
-    "opt2": "object",
-    "opt3": "struct",
-    "opt4": "member",
-    "correct_option": "class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is used to destroy an object?",
-    "opt1": "The constructor",
-    "opt2": "The destructor",
-    "opt3": "The copy constructor",
-    "opt4": "The assignment operator",
-    "correct_option": "The destructor",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is true about an object in C++?",
-    "opt1": "It is an instance of a class",
-    "opt2": "It cannot be passed as a parameter to a function",
-    "opt3": "It does not have any data members or member functions",
-    "opt4": "It can be created without a class definition",
-    "correct_option": "It is an instance of a class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following operators can be overloaded to provide custom member access behavior?",
-    "opt1": ".",
-    "opt2": "->",
-    "opt3": "::",
-    "opt4": ":",
-    "correct_option": "->",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the difference between the dot operator (.) and the arrow operator (->) in C++?",
-    "opt1": "The dot operator is used with pointers, while the arrow operator is used with objects.",
-    "opt2": "The dot operator is used to access static members, while the arrow operator is used to access non-static members.",
-    "opt3": "The dot operator is used to access non-static members, while the arrow operator is used with pointers to access non-static members.",
-    "opt4": "The dot operator is used to access public members, while the arrow operator is used to access private members.",
-    "correct_option": "The dot operator is used to access non-static members, while the arrow operator is used with pointers to access non-static members.",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which operator is used to access the members of an object in C++?",
-    "opt1": ".",
-    "opt2": "&",
-    "opt3": "->",
-    "opt4": "::",
-    "correct_option": ".",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which keyword is used to define a member function outside the class definition in C++?",
-    "opt1": "here",
-    "opt2": "that",
-    "opt3": "this",
-    "opt4": "none of the above",
-    "correct_option": "none of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is true about object-oriented programming in C++?",
-    "opt1": "It is a procedural programming language",
-    "opt2": "Objects encapsulate data and behavior",
-    "opt3": "It supports only single inheritance",
-    "opt4": "All of the above",
-    "correct_option": "Objects encapsulate data and behavior",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is true about a member function in C++?",
-    "opt1": "It can be defined inside or outside the class definition",
-    "opt2": "It can only be defined inside the class definition",
-    "opt3": "It can only be defined outside the class definition",
-    "opt4": "None of the above",
-    "correct_option": "It can be defined inside or outside the class definition",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which keyword is used to access the data members of an object inside a member function in C++?",
-    "opt1": "private",
-    "opt2": "public",
-    "opt3": "protected",
-    "opt4": "this",
-    "correct_option": "this",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is true about object creation in C++?",
-    "opt1": "It is done using the new operator",
-    "opt2": "It is done using the malloc() function",
-    "opt3": "It is done using the class constructor",
-    "opt4": "None of the above",
-    "correct_option": "It is done using the class constructor",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is true about constructors in C++?",
-    "opt1": "They are used to allocate memory for objects",
-    "opt2": "They are used to initialize the data members of an object",
-    "opt3": "They are used to deallocate memory for objects",
-    "opt4": "None of the above",
-    "correct_option": "They are used to initialize the data members of an object",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is true about destructors in C++?",
-    "opt1": "They are used to allocate memory for objects",
-    "opt2": "They are used to initialize the data members of an object",
-    "opt3": "They are used to deallocate memory for objects",
-    "opt4": "None of the above",
-    "correct_option": "They are used to deallocate memory for objects",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is true about static member functions in C++?",
-    "opt1": "They can access only static data members of a class",
-    "opt2": "They can access only non-static data members of a class",
-    "opt3": "They can access both static and non-static data members of a class",
-    "opt4": "None of the above",
-    "correct_option": "They can access only static data members of a class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true about friend functions in C++?",
-    "opt1": "They are member functions of a class",
-    "opt2": "They can access private and protected members of a class",
-    "opt3": "They can access only public members of a class",
-    "opt4": "None of the above",
-    "correct_option": "They can access private and protected members of a class",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is a member function in C++?",
-    "opt1": "A function that can only be used outside of a class",
-    "opt2": "A function that belongs to a class",
-    "opt3": "A function that can only be used inside of a class",
-    "opt4": "A function that belongs to the global namespace",
-    "correct_option": "A function that belongs to a class",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How are member functions defined in C++?",
-    "opt1": "Inside the class definition",
-    "opt2": "Outside the class definition",
-    "opt3": "Both A and B",
-    "opt4": "Neither A nor B",
-    "correct_option": "Both A and B",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which keyword is used to define a member function outside of a class in C++?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "none of the above",
-    "correct_option": "none of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is a valid syntax for defining a member function outside of a class in C++?",
-    "opt1": "void MyClass::myFunction() {}",
-    "opt2": "MyClass: void myFunction() {}",
-    "opt3": "void myFunction() ::MyClass {}",
-    "opt4": "None of the above",
-    "correct_option": "void MyClass::myFunction() {}",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true about member functions in C++?",
-    "opt1": "They have access to the private data members of a class",
-    "opt2": "They can only access public data members of a class",
-    "opt3": "They cannot access any data members of a class",
-    "opt4": "None of the above",
-    "correct_option": "They have access to the private data members of a class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the implicit parameter in a member function in C++?",
-    "opt1": "A pointer to the object that called the function",
-    "opt2": "A pointer to the object that contains the function",
-    "opt3": "A pointer to the object that was passed as an argument to the function",
-    "opt4": "None of the above",
-    "correct_option": "A pointer to the object that called the function",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which keyword is used to access the implicit parameter in a member function in C++?",
-    "opt1": "this",
-    "opt2": "that",
-    "opt3": "here",
-    "opt4": "none of the above",
-    "correct_option": "this",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true about the this pointer in C++?",
-    "opt1": "It is a constant pointer",
-    "opt2": "It points to the object that called the member function",
-    "opt3": "It is an integer value that represents the memory address of the object",
-    "opt4": "None of the above",
-    "correct_option": "It points to the object that called the member function",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following is true about inline member functions in C++?",
-    "opt1": "They are defined outside the class definition",
-    "opt2": "They are always faster than non-inline member functions",
-    "opt3": "They are used for small functions that are called frequently",
-    "opt4": "None of the above",
-    "correct_option": "They are used for small functions that are called frequently",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is true about const member functions in C++?",
-    "opt1": "They cannot modify the data members of a class",
-    "opt2": "They are declared using the const keyword after the parameter list",
-    "opt3": "They can only be used inside the class definition",
-    "opt4": "None of the above",
-    "correct_option": "They cannot modify the data members of a class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a member function in C++? (Repeated Question)",
-    "opt1": "A function that is defined inside a class definition",
-    "opt2": "A function that is defined outside a class definition",
-    "opt3": "A function that is not related to any class",
-    "opt4": "None of the above",
-    "correct_option": "A function that is defined inside a class definition",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How is a member function defined inside a class definition in C++?",
-    "opt1": "using the :: operator",
-    "opt2": "using the -> operator",
-    "opt3": "using the . operator",
-    "opt4": "using the function name and parameter list",
-    "correct_option": "using the function name and parameter list",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the purpose of the \"this\" pointer in C++?",
-    "opt1": "It points to the object on which the member function is called",
-    "opt2": "It points to the class definition",
-    "opt3": "It points to the current function",
-    "opt4": "None of the above",
-    "correct_option": "It points to the object on which the member function is called",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How is a member function defined outside a class definition in C++?",
-    "opt1": "using the function name and parameter list",
-    "opt2": "using the scope resolution operator and the class name",
-    "opt3": "using the class name and parameter list",
-    "opt4": "None of the above",
-    "correct_option": "using the scope resolution operator and the class name",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the syntax for calling a member function of an object in C++?",
-    "opt1": "object.member_function()",
-    "opt2": "object->member_function()",
-    "opt3": "both A and B",
-    "opt4": "None of the above",
-    "correct_option": "both A and B",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the default access specifier for a member function in C++?",
-    "opt1": "public",
-    "opt2": "private",
-    "opt3": "protected",
-    "opt4": "None of the above",
-    "correct_option": "private",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Can a member function be overloaded in C++?",
-    "opt1": "Yes",
-    "opt2": "No",
-    "opt3": "It depends on the access specifier",
-    "opt4": "None of the above",
-    "correct_option": "Yes",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a member function be declared inside a class definition and defined outside the class definition in C++?",
-    "opt1": "Yes",
-    "opt2": "No",
-    "opt3": "It depends on the access specifier",
-    "opt4": "None of the above",
-    "correct_option": "Yes",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a member function access the private data members of a class in C++?",
-    "opt1": "Yes",
-    "opt2": "No",
-    "opt3": "depends on the access specifier",
-    "opt4": "None of the above",
-    "correct_option": "Yes",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the const keyword in a member function declaration in C++?",
-    "opt1": "It indicates that the function is a constructor",
-    "opt2": "It indicates that the function is a destructor",
-    "opt3": "It indicates that the function does not modify the object on which it is called",
-    "opt4": "None of the above",
-    "correct_option": "It indicates that the function does not modify the object on which it is called",
-    "correct_option_index": 3
-  },
-  
-  {
-    "qsns": "What is a constructor in C++?",
-    "opt1": "A function that is used to allocate memory for an object",
-    "opt2": "A function that is used to initialize the data members of an object",
-    "opt3": "A function that is used to deallocate memory for an object",
-    "opt4": "None of the above",
-    "correct_option": "A function that is used to initialize the data members of an object",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the name of the constructor function in C++?",
-    "opt1": "init()",
-    "opt2": "constructor()",
-    "opt3": "the same as the class name",
-    "opt4": "None of the above",
-    "correct_option": "the same as the class name",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "How many constructors can a class have in C++?",
-    "opt1": "Only one",
-    "opt2": "More than one",
-    "opt3": "It depends on the size of the class",
-    "opt4": "None of the above",
-    "correct_option": "More than one",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which type of constructor is called automatically when an object is created in C++?",
-    "opt1": "Copy constructor",
-    "opt2": "Parameterized constructor",
-    "opt3": "Default constructor",
-    "opt4": "None of the above",
-    "correct_option": "Default constructor",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the purpose of the copy constructor in C++?",
-    "opt1": "It is used to create a copy of an existing object",
-    "opt2": "It is used to allocate memory for an object",
-    "opt3": "It is used to delete an existing object",
-    "opt4": "None of the above",
-    "correct_option": "It is used to create a copy of an existing object",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a constructor be declared as private in C++?",
-    "opt1": "Yes",
-    "opt2": "No",
-    "opt3": "It depends on the type of constructor",
-    "opt4": "None of the above",
-    "correct_option": "Yes",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following is true about the default constructor in C++?",
-    "opt1": "It takes no arguments",
-    "opt2": "It has an empty body",
-    "opt3": "It is provided by the compiler if no other constructor is defined",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following is true about the parameterized constructor in C++?",
-    "opt1": "It takes no arguments",
-    "opt2": "It has an empty body",
-    "opt3": "It takes one or more arguments",
-    "opt4": "None of the above",
-    "correct_option": "It takes one or more arguments",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the syntax for calling a constructor in C++?",
-    "opt1": "class_name.constructor_name()",
-    "opt2": "class_name::constructor_name()",
-    "opt3": "class_name object_name(argument_list)",
-    "opt4": "None of the above",
-    "correct_option": "class_name object_name(argument_list)",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is true about the destructor in C++?",
-    "opt1": "It is used to allocate memory for an object",
-    "opt2": "It is used to deallocate memory for an object",
-    "opt3": "It is used to initialize the data members of an object",
-    "opt4": "None of the above",
-    "correct_option": "It is used to deallocate memory for an object",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the this pointer in C++?",
-    "opt1": "A pointer to the current object",
-    "opt2": "A pointer to the current function",
-    "opt3": "A pointer to the current class",
-    "opt4": "None of the above",
-    "correct_option": "A pointer to the current object",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the purpose of the this pointer in C++?",
-    "opt1": "To refer to the object's own data members",
-    "opt2": "To refer to a different object's data members",
-    "opt3": "To refer to a different function",
-    "opt4": "None of the above",
-    "correct_option": "To refer to the object's own data members",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the syntax for using the this pointer in C++?",
-    "opt1": "this->data_member;",
-    "opt2": "(*this).data_member",
-    "opt3": "Both A and B",
-    "opt4": "None of the above",
-    "correct_option": "Both A and B",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Can the this pointer be modified in C++?",
-    "opt1": "Yes, it can be modified like any other pointer",
-    "opt2": "No, it is a constant pointer",
-    "opt3": "It can be modified only within the same class",
-    "opt4": "None of above",
-    "correct_option": "No, it is a constant pointer",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the data type of the this pointer in C++?",
-    "opt1": "Class type pointer",
-    "opt2": "Integer pointer",
-    "opt3": "Void pointer",
-    "opt4": "None of the above",
-    "correct_option": "Class type pointer",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What happens if a member function does not use the this pointer in C++?",
-    "opt1": "It can cause a compile-time error",
-    "opt2": "It may still work, but it will not be able to access the object's data members",
-    "opt3": "The program will crash at runtime",
-    "opt4": "None of the above",
-    "correct_option": "None of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "How is the this pointer passed to a member function in C++?",
-    "opt1": "It is implicitly passed to the function",
-    "opt2": "It is passed as an argument to the function",
-    "opt3": "It is not passed to the function",
-    "opt4": "None of above",
-    "correct_option": "It is implicitly passed to the function",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the size of the this pointer in C++?",
-    "opt1": "It is always 4 bytes",
-    "opt2": "It is always 8 bytes",
-    "opt3": "It depends on the size of the object",
-    "opt4": "None of the above",
-    "correct_option": "It depends on the size of the object",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Can the this pointer be used in static member functions in C++?",
-    "opt1": "No, the this pointer is not applicable to static member functions",
-    "opt2": "Yes, but only if the static function takes an object as a parameter",
-    "opt3": "It can be used only within the same class",
-    "opt4": "None of above",
-    "correct_option": "No, the this pointer is not applicable to static member functions",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In which operator overload function can the this pointer be used in C++?",
-    "opt1": "Overloading the assignment operator",
-    "opt2": "Overloading the equality operator",
-    "opt3": "Both A and B",
-    "opt4": "None of the above",
-    "correct_option": "Both A and B",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is this pointer in C++?",
-    "opt1": "It is a pointer to the current object",
-    "opt2": "It is a pointer to the current function",
-    "opt3": "It is a pointer to the base class",
-    "opt4": "None of the above",
-    "correct_option": "It is a pointer to the current object",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "In which part of a C++ class is this pointer implicitly passed?",
-    "opt1": "Constructor",
-    "opt2": "Destructor",
-    "opt3": "Member functions",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the type of this pointer in C++?",
-    "opt1": "void",
-    "opt2": "int",
-    "opt3": "ClassName",
-    "opt4": "None of the above",
-    "correct_option": "ClassName",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following is a valid use of this pointer in C++?",
-    "opt1": "To access member variables of the current object",
-    "opt2": "To access member functions of the current object",
-    "opt3": "To access static variables of the current object",
-    "opt4": "All of the above",
-    "correct_option": "All of the above",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the purpose of this pointer in C++?",
-    "opt1": "To resolve naming conflicts between member variables and parameters of a function",
-    "opt2": "To access private member variables of a class",
-    "opt3": "To access static member variables of a class",
-    "opt4": "None of the above",
-    "correct_option": "To resolve naming conflicts between member variables and parameters of a function",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about this pointer in C++?",
-    "opt1": "It can be modified by the programmer",
-    "opt2": "It cannot be modified by the programmer",
-    "opt3": "It can be null",
-    "opt4": "None of the above",
-    "correct_option": "It cannot be modified by the programmer",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What happens if this pointer is dereferenced when it is null?",
-    "opt1": "A compile-time error occurs",
-    "opt2": "A runtime error occurs",
-    "opt3": "Undefined behavior occurs",
-    "opt4": "None of the above",
-    "correct_option": "Undefined behavior occurs",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "What is the use of this pointer in operator overloading in C++?",
-    "opt1": "To overload the -> operator",
-    "opt2": "To overload the . operator",
-    "opt3": "Both A and B",
-    "opt4": "None of the above",
-    "correct_option": "To overload the -> operator",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the output of the following code?",
-    "opt1": "The address of obj1 and obj2 are the same",
-    "opt2": "The address of obj1 and obj2 are different",
-    "opt3": "The program will not compile",
-    "opt4": "The program will crash at runtime",
-    "correct_option": "The address of obj1 and obj2 are different",
-    "correct_option_index": 2
-  },
-  
-  {
-    "qsns": "What is a static data member in C++?",
-    "opt1": "A data member that is unique to each instance of a class",
-    "opt2": "A data member that is shared among all instances of a class",
-    "opt3": "A data member that can be accessed only by static functions",
-    "opt4": "A data member that cannot be accessed from outside the class",
-    "correct_option": "A data member that is shared among all instances of a class",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How is a static data member declared in C++?",
-    "opt1": "Using the keyword static before the data type",
-    "opt2": "Using the keyword static before the class name",
-    "opt3": "Using the keyword static after the data type",
-    "opt4": "None of the above",
-    "correct_option": "Using the keyword static before the data type",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about static data members in C++?",
-    "opt1": "They are not initialized by default",
-    "opt2": "They are initialized to 0 by default",
-    "opt3": "They are initialized to 1 by default",
-    "opt4": "None of the above",
-    "correct_option": "They are initialized to 0 by default",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How is a static function declared in C++?",
-    "opt1": "Using the keyword static before the return type",
-    "opt2": "Using the keyword static before the function name",
-    "opt3": "Using the keyword static after the return type",
-    "opt4": "None of the above",
-    "correct_option": "Using the keyword static before the return type",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about static functions in C++?",
-    "opt1": "They can access only static data members of the class",
-    "opt2": "They can access only non-static data members of the class",
-    "opt3": "They cannot access any data members of the class",
-    "opt4": "None of the above",
-    "correct_option": "They can access only static data members of the class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a static function in C++ access non-static data members of the class?",
-    "opt1": "Yes, using the this pointer",
-    "opt2": "Yes, using the static_cast operator",
-    "opt3": "No, static functions cannot access non-static data members",
-    "opt4": "None of the above",
-    "correct_option": "No, static functions cannot access non-static data members",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following statements is true about static data members in C++?",
-    "opt1": "They can be initialized inside the class definition",
-    "opt2": "They must be initialized inside the class definition",
-    "opt3": "They can be initialized only outside the class definition",
-    "opt4": "None of the above",
-    "correct_option": "They can be initialized only outside the class definition",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following statements is true about static functions in C++?",
-    "opt1": "They cannot access non-static data members",
-    "opt2": "They can access non-static data members",
-    "opt3": "They can be virtual",
-    "opt4": "They can be called using an instance of the class",
-    "correct_option": "They cannot access non-static data members",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about static data members in C++?",
-    "opt1": "They can be accessed using the object of the class",
-    "opt2": "They can be accessed using the class name and the scope resolution operator",
-    "opt3": "They can be accessed using the pointer to the object of the class",
-    "opt4": "All of the above are true",
-    "correct_option": "All of the above are true",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "What is the output of the following code? (Code involves MyClass::count++, incrementCount called twice)",
-    "opt1": "Count: 2",
-    "opt2": "Count: 0",
-    "opt3": "Count: 1",
-    "opt4": "None of the above",
-    "correct_option": "Count: 2",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a static data member in C++?",
-    "opt1": "A data member that can be accessed only by static functions",
-    "opt2": "A data member that belongs to the class and not to any instance of the class",
-    "opt3": "A data member that is created dynamically at runtime",
-    "opt4": "None of the above",
-    "correct_option": "A data member that belongs to the class and not to any instance of the class",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How is a static data member declared In C++?",
-    "opt1": "With the keyword 'static' and the name of the member",
-    "opt2": "With the keyword 'static' and the data type of the member",
-    "opt3": "With the keyword 'static' and the access specifier of the member",
-    "opt4": "None of the above",
-    "correct_option": "With the keyword 'static' and the data type of the member",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following statements is true about static data members in C++?",
-    "opt1": "They are initialized to zero by default",
-    "opt2": "They cannot be initialized inside the class declaration",
-    "opt3": "They are initialized to their default values by default",
-    "opt4": "None of the above",
-    "correct_option": "They are initialized to zero by default",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a static function in C++?",
-    "opt1": "A function that can be accessed only by static data members",
-    "opt2": "A function that belongs to the class and not to any instance of the class",
-    "opt3": "A function that is created dynamically at runtime",
-    "opt4": "None of the above",
-    "correct_option": "A function that belongs to the class and not to any instance of the class",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "How is a static function declared in C++?",
-    "opt1": "With the keyword 'static' and the return type of the function",
-    "opt2": "With the keyword 'static' and the access specifier of the function",
-    "opt3": "With the keyword 'static' and the name of the function",
-    "opt4": "None of the above",
-    "correct_option": "With the keyword 'static' and the return type of the function",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about static functions in C++?",
-    "opt1": "They can be virtual",
-    "opt2": "They cannot be virtual",
-    "opt3": "They can be pure virtual",
-    "opt4": "None of the above",
-    "correct_option": "They cannot be virtual",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is the purpose of static data members and static functions in C++?",
-    "opt1": "To save memory by sharing data across all instances of the class",
-    "opt2": "To make the code more modular and easier to maintain",
-    "opt3": "To create multiple instances of the class with different data",
-    "opt4": "None of the above",
-    "correct_option": "To save memory by sharing data across all instances of the class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about the scope of a static data member in C++?",
-    "opt1": "It has class scope and can be accessed using the class name and the scope resolution operator (::)",
-    "opt2": "It has instance scope and can be accessed using the instance name and the dot operator (.)",
-    "opt3": "It has global scope and can be accessed from any part of the program",
-    "opt4": "None of the above",
-    "correct_option": "It has class scope and can be accessed using the class name and the scope resolution operator (::)",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about the initialization of a static data member in C++?",
-    "opt1": "It can be initialized Inside the class declaration using an assignment statement",
-    "opt2": "It must be initialized outside the class declaration using an assignment statement",
-    "opt3": "It cannot be initialized",
-    "opt4": "None of the above",
-    "correct_option": "It must be initialized outside the class declaration using an assignment statement",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "What is a constant member function in C++?",
-    "opt1": "A member function that cannot modify any data members of the class",
-    "opt2": "A member function that can modify any data members of the class",
-    "opt3": "A member function that cannot be called by const objects of the class",
-    "opt4": "None of the above",
-    "correct_option": "A member function that cannot modify any data members of the class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How is a constant member function declared in C++?",
-    "opt1": "Using the keyword const after the function declaration",
-    "opt2": "Using the keyword const before the function declaration",
-    "opt3": "Using the keyword const before the return type",
-    "opt4": "None of the above",
-    "correct_option": "Using the keyword const after the function declaration",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about constant member functions in C++?",
-    "opt1": "They can be called only by constant objects of the class",
-    "opt2": "They can be called only by non-constant objects of the class",
-    "opt3": "They can be called by both constant and non-constant objects of the class",
-    "opt4": "None of the above",
-    "correct_option": "They can be called by both constant and non-constant objects of the class",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Can a constant member function modify a static data member of the class?",
-    "opt1": "Yes, as long as the static data member is declared as mutable",
-    "opt2": "Yes, as long as the static data member is declared as const",
-    "opt3": "No, constant member functions cannot modify any data members of the class",
-    "opt4": "Yes, because static members are not part of the object's state",
-    "correct_option": "Yes, because static members are not part of the object's state",
-    "correct_option_index": 4
-  },
-  {
-    "qsns": "Which of the following statements is true about constant objects in C++?",
-    "opt1": "They cannot modify any data members of the class",
-    "opt2": "They can modify only constant data members of the class",
-    "opt3": "They can modify any data members of the class",
-    "opt4": "None of the above",
-    "correct_option": "They cannot modify any data members of the class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How is a constant object declared in C++?",
-    "opt1": "Using the keyword const before the object name",
-    "opt2": "Using the keyword const after the object name",
-    "opt3": "Using the keyword const before the class name",
-    "opt4": "None of the above",
-    "correct_option": "Using the keyword const before the object name",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about constant member functions in C++? (Overloading)",
-    "opt1": "They can be overloaded with non-constant member functions of the same name",
-    "opt2": "They cannot be overloaded with non-constant member functions of the same name",
-    "opt3": "They can be overloaded only with other constant member functions of the same name",
-    "opt4": "None of the above",
-    "correct_option": "They can be overloaded with non-constant member functions of the same name",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the output of the following code? (const MyClass obj = {5}; obj.value = 10;)",
-    "opt1": "5 followed by a compilation error",
-    "opt2": "5 followed by 10",
-    "opt3": "Compilation error followed by 5",
-    "opt4": "None of the above",
-    "correct_option": "5 followed by a compilation error",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is a constant member function in C++?",
-    "opt1": "A member function that cannot be modified",
-    "opt2": "A member function that can be called on a constant object only",
-    "opt3": "A member function that does not have any return type",
-    "opt4": "None of the above",
-    "correct_option": "A member function that cannot be modified",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "How is a constant member function declared in C++?",
-    "opt1": "Using the keyword const after the function name",
-    "opt2": "Using the keyword const after the return type",
-    "opt3": "Using the keyword const before the function name",
-    "opt4": "None of the above",
-    "correct_option": "Using the keyword const after the function name",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about constant objects in C++?",
-    "opt1": "They cannot modify the data members of the class",
-    "opt2": "They can modify the data members of the class",
-    "opt3": "They can modify the data members of the class only if they are declared mutable",
-    "opt4": "None of the above",
-    "correct_option": "They cannot modify the data members of the class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Can a non-constant member function be called on a constant object in C++?",
-    "opt1": "Yes, but only if the function does not modify any data members of the class",
-    "opt2": "No, a non-constant member function cannot be called on a constant object",
-    "opt3": "Yes, but only if the function is declared const",
-    "opt4": "None of the above",
-    "correct_option": "No, a non-constant member function cannot be called on a constant object",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following statements is true about constant objects in C++?",
-    "opt1": "They can be created using the const keyword before the class name",
-    "opt2": "They can be created using the const keyword after the object name",
-    "opt3": "They can be created using the const keyword before the object name",
-    "opt4": "None of the above",
-    "correct_option": "They can be created using the const keyword before the object name",
-    "correct_option_index": 3
-  },
-  {
-    "qsns": "Which of the following statements is true about constant objects in C++?",
-    "opt1": "They can call non-constant member functions of the class",
-    "opt2": "They cannot call non-constant member functions of the class",
-    "opt3": "They can call non-constant member functions of the class only if the functions are declared const",
-    "opt4": "None of the above",
-    "correct_option": "They cannot call non-constant member functions of the class",
-    "correct_option_index": 2
-  },
-  {
-    "qsns": "Which of the following statements is true about constant objects in C++?",
-    "opt1": "They can access only constant member functions of the class",
-    "opt2": "They can access only non-constant member functions of the class",
-    "opt3": "They can access both constant and non-constant member functions of the class",
-    "opt4": "None of the above",
-    "correct_option": "They can access only constant member functions of the class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "Which of the following statements is true about constant member functions in C++? (Duplicate logic)",
-    "opt1": "They cannot modify the data members of the class",
-    "opt2": "They can modify the data members of the class only if they are declared mutable",
-    "opt3": "They can modify the data members of the class",
-    "opt4": "None of the above",
-    "correct_option": "They cannot modify the data members of the class",
-    "correct_option_index": 1
-  },
-  {
-    "qsns": "What is the output of the following code? (const MyClass obj = {10}; obj.printValue();)",
-    "opt1": "Value: 10",
-    "opt2": "Value: 0",
-    "opt3": "The code will not compile because the object is declared const",
-    "opt4": "None of the above",
-    "correct_option": "Value: 10",
-    "correct_option_index": 1
-  }
-]
\ No newline at end of file
+    {
+        "qsns": "What is an Identifier in C programming?",
+        "opt1": "A keyword that has a specific meaning in the language",
+        "opt2": "A symbol used to represent a variable, function, or structure in a C program",
+        "opt3": "A constant value that cannot be changed during program execution",
+        "opt4": "None of above",
+        "correct_option": "A symbol used to represent a variable, function, or structure in a C program",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is a constant in C programming?",
+        "opt1": "A keyword that has a specific meaning in the language",
+        "opt2": "A symbol used to represent a variable, function, or structure in a C program",
+        "opt3": "A value that cannot be changed during program execution",
+        "opt4": "All of above",
+        "correct_option": "A value that cannot be changed during program execution",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is an operator in C programming?",
+        "opt1": "A symbol used to perform operations on variables, constants, and expressions",
+        "opt2": "A symbol used to define variables, functions, and structures",
+        "opt3": "A symbol used to control the flow of a program",
+        "opt4": "None of above",
+        "correct_option": "A symbol used to perform operations on variables, constants, and expressions",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What are some examples of operators in C programming?",
+        "opt1": "Arithmetic, relational, logical, and bitwise operators",
+        "opt2": "Assignment, conditional, and loop operators",
+        "opt3": "Structural, pointer, and memory operators",
+        "opt4": "All of above",
+        "correct_option": "Arithmetic, relational, logical, and bitwise operators",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a keyword in C programming?",
+        "opt1": "A symbol used to perform operations on variables, constants, and expressions",
+        "opt2": "A symbol used to define variables, functions, and structures",
+        "opt3": "A word that has a specific meaning in the language and cannot be used as an identifier",
+        "opt4": "None of above",
+        "correct_option": "A word that has a specific meaning in the language and cannot be used as an identifier",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What are some examples of keywords in C programming?",
+        "opt1": "int, float, char, if, for, while",
+        "opt2": "add, subtract, multiply, divide, modulus",
+        "opt3": "input, output, execute, stop",
+        "opt4": "Both a and b",
+        "correct_option": "int, float, char, if, for, while",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between keywords and identifiers in C programming?",
+        "opt1": "Keywords have a specific meaning in the language, while identifiers do not",
+        "opt2": "Keywords are used to define variables, functions, and structures, while identifiers are not",
+        "opt3": "Keywords cannot be used as identifiers, while identifiers can be used as keywords",
+        "opt4": "All of above",
+        "correct_option": "Keywords cannot be used as identifiers, while identifiers can be used as keywords",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the difference between constants and variables in C programming?",
+        "opt1": "Constants have a fixed value that cannot be changed, while variables have a value that can be changed",
+        "opt2": "Constants are used to perform operations, while variables are used to store data",
+        "opt3": "Constants are used to define functions, while variables are used to define structures",
+        "opt4": "All of above",
+        "correct_option": "Constants have a fixed value that cannot be changed, while variables have a value that can be changed",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between an operator and a function in C programming?",
+        "opt1": "An operator performs an operation on one or more operands, while a function performs a set of operations on input data",
+        "opt2": "A function performs an operation on one or more operands, while an operator performs a set of operations on input data",
+        "opt3": "Operators are written in uppercase, while functions are not",
+        "opt4": "Functions are written in uppercase, while operators are not",
+        "correct_option": "An operator performs an operation on one or more operands, while a function performs a set of operations on input data",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of a semicolon at the end of a statement in C programming?",
+        "opt1": "To indicate the end of a statement",
+        "opt2": "To separate two statements",
+        "opt3": "To define a function",
+        "opt4": "To declare a variable",
+        "correct_option": "To indicate the end of a statement",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a token in C programming?",
+        "opt1": "A symbol or keyword used in a C program",
+        "opt2": "A variable used in a C program",
+        "opt3": "A function used in a C program",
+        "opt4": "A structure used in a C program",
+        "correct_option": "A symbol or keyword used in a C program",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What are some examples of tokens in C programming?",
+        "opt1": "Keywords, identifiers, constants, and operators",
+        "opt2": "Functions, loops, and conditionals",
+        "opt3": "Variables, arrays, and structures",
+        "opt4": "All of above",
+        "correct_option": "Keywords, identifiers, constants, and operators",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of arithmetic operators in C programming?",
+        "opt1": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
+        "opt2": "To compare values and make decisions based on the comparison results",
+        "opt3": "To manipulate bits and perform bitwise operations on binary data",
+        "opt4": "All of above",
+        "correct_option": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of relational operators in C programming?",
+        "opt1": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
+        "opt2": "To compare values and make decisions based on the comparison results",
+        "opt3": "To manipulate bits and perform bitwise operations on binary data",
+        "opt4": "All of above",
+        "correct_option": "To compare values and make decisions based on the comparison results",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of logical operators in C programming?",
+        "opt1": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
+        "opt2": "To compare values and make decisions based on the comparison results",
+        "opt3": "To perform logical operations such as AND, OR, and NOT on boolean values",
+        "opt4": "All of above",
+        "correct_option": "To perform logical operations such as AND, OR, and NOT on boolean values",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of bitwise operators in C programming?",
+        "opt1": "To perform basic mathematical operations such as addition, subtraction, multiplication, and division",
+        "opt2": "To compare values and make decisions based on the comparison results",
+        "opt3": "To manipulate bits and perform bitwise operations on binary data",
+        "opt4": "All of above",
+        "correct_option": "To manipulate bits and perform bitwise operations on binary data",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the difference between the logical AND operator (&&) and the bitwise AND operator (&) in C programming?",
+        "opt1": "The logical AND operator performs a logical operation on boolean values, while the bitwise AND operator performs a bitwise operation on binary data",
+        "opt2": "The logical AND operator performs a bitwise operation on boolean values, while the bitwise AND operator performs a logical operation on binary data",
+        "opt3": "There is no difference between the logical AND operator and the bitwise AND operator in C programming",
+        "opt4": "All of above",
+        "correct_option": "The logical AND operator performs a logical operation on boolean values, while the bitwise AND operator performs a bitwise operation on binary data",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between the logical OR operator (||) and the bitwise OR operator (|) in C programming?",
+        "opt1": "The logical OR operator performs a logical operation on boolean values, while the bitwise OR operator performs a bitwise operation on binary data",
+        "opt2": "The logical OR operator performs a bitwise operation on boolean values, while the bitwise OR operator performs a logical operation on binary data",
+        "opt3": "There is no difference between the logical OR operator and the bitwise OR operator in C programming",
+        "opt4": "All of above",
+        "correct_option": "The logical OR operator performs a logical operation on boolean values, while the bitwise OR operator performs a bitwise operation on binary data",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the result of the following expression: 5 & 6",
+        "opt1": "5",
+        "opt2": "6",
+        "opt3": "4",
+        "opt4": "1",
+        "correct_option": "4",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the result of the following expression: 5<6",
+        "opt1": "0",
+        "opt2": "1",
+        "opt3": "True",
+        "opt4": "False",
+        "correct_option": "1",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of the conditional operator (?:) in C programming?",
+        "opt1": "To perform a conditional operation based on the value of a condition",
+        "opt2": "To perform arithmetic operations",
+        "opt3": "To declare a variable",
+        "opt4": "To assign a value to a variable",
+        "correct_option": "To perform a conditional operation based on the value of a condition",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between the bitwise AND operator (&) and the bitwise OR operator (|) in C programming?",
+        "opt1": "The bitwise AND operator performs a bitwise AND operation, while the bitwise OR operator performs a bitwise OR operation",
+        "opt2": "The bitwise OR operator performs a bitwise AND operation, while the bitwise AND operator performs a bitwise OR operation",
+        "opt3": "Bitwise AND operators are written in uppercase, while bitwise OR operators are not",
+        "opt4": "Bitwise OR operators are written in uppercase, while bitwise AND operators are not",
+        "correct_option": "The bitwise AND operator performs a bitwise AND operation, while the bitwise OR operator performs a bitwise OR operation",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the assignment operator (=) in C programming?",
+        "opt1": "To compare two values",
+        "opt2": "To assign a value to a variable",
+        "opt3": "To perform mathematical operations",
+        "opt4": "To declare a variable",
+        "correct_option": "To assign a value to a variable",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the result of the following expression: 5 + 7 * 2",
+        "opt1": "19",
+        "opt2": "26",
+        "opt3": "16",
+        "opt4": "9",
+        "correct_option": "19",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between formatted and unformatted input/output in C programming?",
+        "opt1": "Formatted input/output is used to input/output data in a specific format, while unformatted input/output is used to input/output data without any format.",
+        "opt2": "Formatted input/output is used to input/output data without any format, while unformatted input/output is used to input/output data in a specific format.",
+        "opt3": "There is no difference between formatted and unformatted input/output in C programming.",
+        "opt4": "None of above",
+        "correct_option": "Formatted input/output is used to input/output data in a specific format, while unformatted input/output is used to input/output data without any format.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What are some examples of formatted input functions in C programming?",
+        "opt1": "scanf(), gets(), and fscanf()",
+        "opt2": "getchar(), gets(), and fgetc()",
+        "opt3": "printf(), puts(), and fprintf()",
+        "opt4": "All of above",
+        "correct_option": "scanf(), gets(), and fscanf()",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What are some examples of formatted output functions in C programming?",
+        "opt1": "scanf(), gets(), and fscanf()",
+        "opt2": "getchar(), gets(), and fgetc()",
+        "opt3": "printf(), puts(), and fprintf()",
+        "opt4": "All of above",
+        "correct_option": "printf(), puts(), and fprintf()",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the scanf() function in C programming?",
+        "opt1": "To output data to the standard output device",
+        "opt2": "To input data from the standard input device",
+        "opt3": "To input/output data to/from a file",
+        "opt4": "All of above",
+        "correct_option": "To input data from the standard input device",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of the printf() function in C programming?",
+        "opt1": "To output data to the standard output device",
+        "opt2": "To input data from the standard input device",
+        "opt3": "To input/output data to/from a file",
+        "opt4": "All of above",
+        "correct_option": "To output data to the standard output device",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between the gets() and scanf() functions in C programming?",
+        "opt1": "The gets() function inputs data without any format, while the scanf() function inputs data in a specific format.",
+        "opt2": "The gets() function inputs data in a specific format, while the scanf() function inputs data without any format.",
+        "opt3": "There is no difference between the gets() and scanf() functions in C programming.",
+        "opt4": "Both a and b",
+        "correct_option": "The gets() function inputs data without any format, while the scanf() function inputs data in a specific format.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between the puts() and printf() functions in C programming?",
+        "opt1": "The puts() function outputs data without any format, while the printf() function outputs data in a specific format.",
+        "opt2": "The puts() function outputs data in a specific format, while the printf() function outputs data without any format.",
+        "opt3": "There is no difference between the puts() and printf() functions in C programming.",
+        "opt4": "Both a and b",
+        "correct_option": "The puts() function outputs data without any format, while the printf() function outputs data in a specific format.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the fscanf() function in C programming?",
+        "opt1": "To input data from the standard input device",
+        "opt2": "To output data to the standard output device",
+        "opt3": "To input/output data to/from a file",
+        "opt4": "All of above",
+        "correct_option": "To input/output data to/from a file",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the standard library function used to read a string from the user in C?",
+        "opt1": "scanf()",
+        "opt2": "gets()",
+        "opt3": "fgets()",
+        "opt4": "sprintf()",
+        "correct_option": "gets()",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following functions is used to print a string to the screen in C?",
+        "opt1": "puts()",
+        "opt2": "printf()",
+        "opt3": "fprintf()",
+        "opt4": "getchar()",
+        "correct_option": "puts()",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between scanf() and fscanf() in C?",
+        "opt1": "scanf() reads from the standard input and fscanf() reads from a file",
+        "opt2": "scanf() reads from a file and fscanf() reads from the standard input",
+        "opt3": "Both functions have the same functionality",
+        "opt4": "None of the above",
+        "correct_option": "scanf() reads from the standard input and fscanf() reads from a file",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the %d format specifier in the printf() function in C?",
+        "opt1": "To print an integer",
+        "opt2": "To print a string",
+        "opt3": "To print a float",
+        "opt4": "To print a double",
+        "correct_option": "To print an integer",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the %f format specifier in the printf() function in C?",
+        "opt1": "To print an integer",
+        "opt2": "To print a string",
+        "opt3": "To print a float",
+        "opt4": "To print a double",
+        "correct_option": "To print a float",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the %lf format specifier in the printf() function in C?",
+        "opt1": "To print a string",
+        "opt2": "To print an integer",
+        "opt3": "To print a float",
+        "opt4": "To print a double",
+        "correct_option": "To print a double",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following functions is used to read a single character from the standard input in C?",
+        "opt1": "scanf()",
+        "opt2": "gets()",
+        "opt3": "getchar()",
+        "opt4": "fgetc()",
+        "correct_option": "getchar()",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the fopen() function in C?",
+        "opt1": "To open a file for reading",
+        "opt2": "To open a file for writing",
+        "opt3": "To open a file for reading and writing",
+        "opt4": "None of the above",
+        "correct_option": "To open a file for reading",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the fclose() function in C?",
+        "opt1": "To close a file that was opened for reading",
+        "opt2": "To close a file that was opened for writing",
+        "opt3": "To close a file that was opened for reading and writing",
+        "opt4": "None of the above",
+        "correct_option": "To close a file that was opened for reading and writing",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the difference between fprintf() and sprintf() in C?",
+        "opt1": "fprintf() writes to a file and sprintf() writes to a string",
+        "opt2": "fprintf() writes to a string and sprintf() writes to a file",
+        "opt3": "Both functions have the same functionality",
+        "opt4": "None of the above",
+        "correct_option": "fprintf() writes to a file and sprintf() writes to a string",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the if statement in C programming?",
+        "opt1": "To execute a block of code only if a certain condition is met",
+        "opt2": "To execute a block of code only if a certain condition is not met",
+        "opt3": "To execute a block of code if a certain condition is true",
+        "opt4": "None of the above",
+        "correct_option": "To execute a block of code if a certain condition is true",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the else statement in C programming?",
+        "opt1": "To execute a block of code regardless of the condition",
+        "opt2": "To execute a block of code if a condition is false",
+        "opt3": "To terminate the program if a condition is false",
+        "opt4": "To skip a block of code if a condition is true",
+        "correct_option": "To execute a block of code if a condition is false",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of the switch statement in C programming?",
+        "opt1": "To execute one of several blocks of code based on the value of an expression",
+        "opt2": "To execute all of the blocks of code in a switch statement",
+        "opt3": "To execute only the first block of code in a switch statement",
+        "opt4": "None of the above",
+        "correct_option": "To execute one of several blocks of code based on the value of an expression",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the break statement in C programming?",
+        "opt1": "To exit a loop",
+        "opt2": "To exit a switch statement",
+        "opt3": "To exit a function",
+        "opt4": "To exit the program",
+        "correct_option": "To exit a switch statement",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of the continue statement in C programming?",
+        "opt1": "To exit a loop",
+        "opt2": "To exit a switch statement",
+        "opt3": "To skip an iteration of a loop",
+        "opt4": "To exit the program",
+        "correct_option": "To skip an iteration of a loop",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the for loop in C programming?",
+        "opt1": "To execute a block of code a specified number of times",
+        "opt2": "To execute a block of code indefinitely",
+        "opt3": "To execute a block of code based on a condition",
+        "opt4": "None of the above",
+        "correct_option": "To execute a block of code a specified number of times",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the while loop in C programming?",
+        "opt1": "To execute a block of code a specified number of times",
+        "opt2": "To execute a block of code indefinitely until a condition is met",
+        "opt3": "To execute a block of code based on a condition",
+        "opt4": "None of the above",
+        "correct_option": "To execute a block of code indefinitely until a condition is met",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is an if statement in C programming used for?",
+        "opt1": "To execute a block of code only if a certain condition is met",
+        "opt2": "To execute a block of code only if a certain condition is not met",
+        "opt3": "To execute a block of code if a certain condition is met, and execute another block of code if the condition is not met",
+        "opt4": "To declare variables",
+        "correct_option": "To execute a block of code if a certain condition is met, and execute another block of code if the condition is not met",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the do-while loop in C programming?",
+        "opt1": "To execute a block of code a specified number of times",
+        "opt2": "To execute a block of code indefinitely until a condition is met",
+        "opt3": "To execute a block of code at least once, and then repeatedly until a condition is met",
+        "opt4": "None of the above",
+        "correct_option": "To execute a block of code at least once, and then repeatedly until a condition is met",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the difference between the for loop and the while loop in C programming?",
+        "opt1": "The for loop is used for a specified number of iterations, while the while loop is used until a condition is met",
+        "opt2": "The for loop is used until a condition is met, while the while loop is used for a specified number of iterations",
+        "opt3": "Both loops have the same functionality",
+        "opt4": "None of the above",
+        "correct_option": "The for loop is used for a specified number of iterations, while the while loop is used until a condition is met",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What does the \"if\" statement in C do?",
+        "opt1": "Executes a block of code if a condition is true",
+        "opt2": "Executes a block of code regardless of the condition",
+        "opt3": "Skips a block of code if a condition is false",
+        "opt4": "Terminates the program if a condition is true",
+        "correct_option": "Executes a block of code if a condition is true",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the syntax of the \"if\" statement in C?",
+        "opt1": "if (condition) { statements }",
+        "opt2": "if condition { statements }",
+        "opt3": "if {condition} (statements)",
+        "opt4": "if (condition) { statements };",
+        "correct_option": "if (condition) { statements }",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the \"else\" statement in C?",
+        "opt1": "To execute a block of code if a condition is false",
+        "opt2": "To execute a block of code regardless of the condition",
+        "opt3": "To execute a block of code if the condition in the if statement is true",
+        "opt4": "To execute a block of code if the condition in the if statement is false",
+        "correct_option": "To execute a block of code if the condition in the if statement is false",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the syntax of the \"switch\" statement in C?",
+        "opt1": "switch (expression) { case constant-expression: statements; break; default: statements; }",
+        "opt2": "switch expression { case constant-expression: statements; break; default: statements; }",
+        "opt3": "switch (expression) case constant-expression: statements; break; default: statements;",
+        "opt4": "switch expression case constant-expression: statements; break; default: statements;",
+        "correct_option": "switch (expression) { case constant-expression: statements; break; default: statements; }",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the index of the first element in a one-dimensional array in C?",
+        "opt1": "0",
+        "opt2": "1",
+        "opt3": "2",
+        "opt4": "3",
+        "correct_option": "0",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the syntax for declaring a two-dimensional integer array of size 3x4 in C?",
+        "opt1": "int arr[3][4];",
+        "opt2": "int arr[4][3];",
+        "opt3": "int arr[3,4];",
+        "opt4": "int arr[4,3];",
+        "correct_option": "int arr[3][4];",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How can you access the value of the 3rd element of the 2nd row of a two-dimensional array in C?",
+        "opt1": "arr[1][2]",
+        "opt2": "arr[2][1]",
+        "opt3": "arr[2][3]",
+        "opt4": "arr[3][2]",
+        "correct_option": "arr[1][2]",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between a one-dimensional array and a two-dimensional array in C?",
+        "opt1": "A one-dimensional array has one row and multiple columns, whereas a two-dimensional array has multiple rows and multiple columns.",
+        "opt2": "A one-dimensional array has multiple rows and multiple columns, whereas a two-dimensional array has one row and multiple columns.",
+        "opt3": "A one-dimensional array has multiple rows and one column, whereas a two-dimensional array has one row and one column.",
+        "opt4": "A one-dimensional array has one row and one column, whereas a two-dimensional array has multiple rows and multiple columns.",
+        "correct_option": "A one-dimensional array has one row and multiple columns, whereas a two-dimensional array has multiple rows and multiple columns.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the syntax for initializing a one-dimensional array in C?",
+        "opt1": "int arr[] = {1,2,3,4,5};",
+        "opt2": "int arr[5] = (1,2,3,4,5);",
+        "opt3": "int arr[5] = {1,2,3,4};",
+        "opt4": "int arr = {1, 2, 3, 4, 5};",
+        "correct_option": "int arr[] = {1,2,3,4,5};",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How can you find the number of elements in a one-dimensional array in C?",
+        "opt1": "sizeof(arr)",
+        "opt2": "sizeof(arr[0])",
+        "opt3": "sizeof(arr)/sizeof(arr[0])",
+        "opt4": "sizeof(arr[])/sizeof(arr[0])",
+        "correct_option": "sizeof(arr)/sizeof(arr[0])",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the syntax for declaring a multidimensional array in C?",
+        "opt1": "int arr[][][];",
+        "opt2": "int arr;",
+        "opt3": "int arr[];",
+        "opt4": "int arr[...][...][...];",
+        "correct_option": "int arr[...][...][...];",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the use of the strlen() function in C when working with arrays?",
+        "opt1": "To find the length of a one-dimensional array",
+        "opt2": "To find the length of a two-dimensional array",
+        "opt3": "To find the length of a string",
+        "opt4": "To find the length of a multidimensional array",
+        "correct_option": "To find the length of a string",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is a one-dimensional array in C?",
+        "opt1": "A set of values of the same data type stored in a contiguous block of memory",
+        "opt2": "A set of values of different data types stored in a contiguous block of memory",
+        "opt3": "A set of values of the same data type stored in non-contiguous memory locations",
+        "opt4": "A set of values of different data types stored in non-contiguous memory locations",
+        "correct_option": "A set of values of the same data type stored in a contiguous block of memory",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How can you access the value at the third position of a one-dimensional array named \"array\"?",
+        "opt1": "array[2]",
+        "opt2": "array[3]",
+        "opt3": "array[0]",
+        "opt4": "array[1]",
+        "correct_option": "array[2]",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a two-dimensional array in C?",
+        "opt1": "An array of arrays",
+        "opt2": "A set of values of the same data type stored in non-contiguous memory locations",
+        "opt3": "A set of values of different data types stored in a contiguous block of memory",
+        "opt4": "A set of values of the same data type stored in a single contiguous block of memory",
+        "correct_option": "An array of arrays",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How can you access the value at the first row and second column of a two-dimensional array named \"array\"?",
+        "opt1": "array[0][1]",
+        "opt2": "array[1][0]",
+        "opt3": "array[1][2]",
+        "opt4": "array[2][1]",
+        "correct_option": "array[0][1]",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a multidimensional array in C?",
+        "opt1": "An array of arrays of arrays",
+        "opt2": "A set of values of different data types stored in non-contiguous memory locations",
+        "opt3": "A set of values of the same data type stored in a single contiguous block of memory",
+        "opt4": "A set of values of different data types stored in a single contiguous block of memory",
+        "correct_option": "An array of arrays of arrays",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between a one-dimensional array and a two-dimensional array in C?",
+        "opt1": "A two-dimensional array has more dimensions than a one-dimensional array",
+        "opt2": "A one-dimensional array has more dimensions than a two-dimensional array",
+        "opt3": "There is no difference between a one-dimensional array and a two-dimensional array",
+        "opt4": "A two-dimensional array can store more values than a one-dimensional array",
+        "correct_option": "A two-dimensional array has more dimensions than a one-dimensional array",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the \"malloc\" function in C programming?",
+        "opt1": "To free memory",
+        "opt2": "To allocate memory",
+        "opt3": "To initialize memory",
+        "opt4": "To reset memory",
+        "correct_option": "To allocate memory",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of the \"free\" function in C programming?",
+        "opt1": "To allocate memory",
+        "opt2": "To free memory",
+        "opt3": "To initialize memory",
+        "opt4": "To reset memory",
+        "correct_option": "To free memory",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the difference between an array and a pointer in C programming?",
+        "opt1": "An array is a set of values stored in a contiguous block of memory, while a pointer is a variable that stores the address of another variable",
+        "opt2": "A pointer is a set of values stored in a contiguous block of memory, while an array is a variable that stores the address of another variable",
+        "opt3": "There is no difference between an array and a pointer in C programming",
+        "opt4": "An array is a variable that stores the address of another variable, while a pointer is a set of values stored in a contiguous block of memory",
+        "correct_option": "An array is a set of values stored in a contiguous block of memory, while a pointer is a variable that stores the address of another variable",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a string in C programming?",
+        "opt1": "A sequence of characters enclosed in quotes",
+        "opt2": "An array of characters",
+        "opt3": "A single character",
+        "opt4": "None of above",
+        "correct_option": "An array of characters",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How can you find the length of a string in C programming?",
+        "opt1": "By using the length() function",
+        "opt2": "By using the strlen() function",
+        "opt3": "By using the sizeof() operator",
+        "opt4": "None of above",
+        "correct_option": "By using the strlen() function",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How can you concatenate two strings in C programming?",
+        "opt1": "By using the + operator",
+        "opt2": "By using the strcat() function",
+        "opt3": "By using the strcpy() function",
+        "opt4": "None of above",
+        "correct_option": "By using the strcat() function",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What does the strcpy() function do in C programming?",
+        "opt1": "Copies one string to another",
+        "opt2": "Concatenates two strings",
+        "opt3": "Compares two strings",
+        "opt4": "None of above",
+        "correct_option": "Copies one string to another",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between the strcpy() and strcat() functions in C programming?",
+        "opt1": "strcpy() copies one string to another, while strcat() concatenates two strings",
+        "opt2": "strcpy() concatenates two strings, while strcat() copies one string to another",
+        "opt3": "Both functions copy one string to another",
+        "opt4": "None of above",
+        "correct_option": "strcpy() copies one string to another, while strcat() concatenates two strings",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How can you compare two strings in C programming?",
+        "opt1": "By using the strcmp() function",
+        "opt2": "By using the strcat() function",
+        "opt3": "By using the strcpy() function",
+        "opt4": "Both a and b",
+        "correct_option": "By using the strcmp() function",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the return value of the strcmp() function when two strings are equal?",
+        "opt1": "0",
+        "opt2": "1",
+        "opt3": "-1",
+        "opt4": "null",
+        "correct_option": "0",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the return value of the strcmp() function when the first string is greater than the second string?",
+        "opt1": "0",
+        "opt2": "1",
+        "opt3": "-1",
+        "opt4": "null",
+        "correct_option": "1",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the return value of the strcmp() function when the first string is less than the second string?",
+        "opt1": "0",
+        "opt2": "1",
+        "opt3": "-1",
+        "opt4": "null",
+        "correct_option": "-1",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "How can you reverse a string in C programming?",
+        "opt1": "By using the strrev() function",
+        "opt2": "By using a loop and swapping characters",
+        "opt3": "There is no built-in function to reverse a string in C programming",
+        "opt4": "None of above",
+        "correct_option": "By using a loop and swapping characters",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of the strcat() function in C programming?",
+        "opt1": "To copy a string to another string.",
+        "opt2": "To concatenate two strings.",
+        "opt3": "To find the length of a string.",
+        "opt4": "To compare two strings.",
+        "correct_option": "To concatenate two strings.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of the strcmp() function in C programming?",
+        "opt1": "To copy a string to another string.",
+        "opt2": "To find the length of a string.",
+        "opt3": "To concatenate two strings.",
+        "opt4": "To compare two strings.",
+        "correct_option": "To compare two strings.",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the purpose of the strcpy() function in C programming?",
+        "opt1": "To copy a string to another string.",
+        "opt2": "To find the length of a string.",
+        "opt3": "To concatenate two strings.",
+        "opt4": "To compare two strings.",
+        "correct_option": "To copy a string to another string.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the strlen() function in C programming?",
+        "opt1": "To compare two strings.",
+        "opt2": "To concatenate two strings.",
+        "opt3": "To find the length of a string.",
+        "opt4": "To copy a string to another string.",
+        "correct_option": "To find the length of a string.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the strstr() function in C programming?",
+        "opt1": "To find a substring in a string.",
+        "opt2": "To compare two strings.",
+        "opt3": "To find the first occurrence of a character in a string.",
+        "opt4": "To reverse a string.",
+        "correct_option": "To find a substring in a string.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How can you convert a string to uppercase in C programming?",
+        "opt1": "By using the toupper() function.",
+        "opt2": "By using a loop and converting each character.",
+        "opt3": "By using the strcat() function.",
+        "opt4": "By using the strcmp() function.",
+        "correct_option": "By using a loop and converting each character.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How can you convert a string to lowercase in C programming?",
+        "opt1": "By using the tolower() function.",
+        "opt2": "By using a loop and converting each character.",
+        "opt3": "By using the strcat() function.",
+        "opt4": "By using the strcmp() function.",
+        "correct_option": "By using a loop and converting each character.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of the sprintf() function in C programming?",
+        "opt1": "To format and store a string in a buffer.",
+        "opt2": "To concatenate two string",
+        "opt3": "To find the length of a string.",
+        "opt4": "To compare two strings.",
+        "correct_option": "To format and store a string in a buffer.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the sscanf() function in C programming?",
+        "opt1": "To read formatted input from a string.",
+        "opt2": "To concatenate two strings.",
+        "opt3": "To find the length of a string.",
+        "opt4": "To compare two strings.",
+        "correct_option": "To read formatted input from a string.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the output of the following code? int a = 10; int *p = &a; printf(\"%p\", p);",
+        "opt1": "10",
+        "opt2": "0",
+        "opt3": "Address of a",
+        "opt4": "Undefined",
+        "correct_option": "Address of a",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the output of the following code? int a = 10; int *p = &a; printf(\"%d\", *p);",
+        "opt1": "10",
+        "opt2": "0",
+        "opt3": "Address of a",
+        "opt4": "Undefined",
+        "correct_option": "10",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the correct way to declare a pointer to a character in C?",
+        "opt1": "char *str;",
+        "opt2": "char *str();",
+        "opt3": "char str*;",
+        "opt4": "char (*str)();",
+        "correct_option": "char *str;",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the output of the following code? int arr[5] = {1, 2, 3, 4, 5}; int *p = arr; printf(\"%d\", *(p+3));",
+        "opt1": "4",
+        "opt2": "3",
+        "opt3": "5",
+        "opt4": "Undefined",
+        "correct_option": "4",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the output of the following code? int arr[5] = {1, 2, 3, 4, 5}; int *p = arr + 2; printf(\"%d\", *(p-1));",
+        "opt1": "2",
+        "opt2": "3",
+        "opt3": "4",
+        "opt4": "Undefined",
+        "correct_option": "2",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the output of the following code? int a = 10; int *p = &a; int **q = &p; printf(\"%d\", **q);",
+        "opt1": "10",
+        "opt2": "0",
+        "opt3": "Address of a",
+        "opt4": "Undefined",
+        "correct_option": "10",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is a valid way to declare a pointer to an integer array of size 5?",
+        "opt1": "int (*arr)[5];",
+        "opt2": "int *arr[5];",
+        "opt3": "int **arr[5];",
+        "opt4": "int arr*[5];",
+        "correct_option": "int (*arr)[5];",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr + 1; printf(\"%d\", *(p--));",
+        "opt1": "2",
+        "opt2": "1",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "2",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr + 2; printf(\"%d\", *(--p));",
+        "opt1": "2",
+        "opt2": "1",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "2",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the output of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr; printf(\"%d\", *p++);",
+        "opt1": "1",
+        "opt2": "2",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "1",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true about pointer arithmetic in C?",
+        "opt1": "Addition and subtraction operations can be performed on pointers",
+        "opt2": "Multiplication and division operations can be performed on pointers",
+        "opt3": "Bitwise AND and OR operations can be performed on pointers",
+        "opt4": "None of the above",
+        "correct_option": "Addition and subtraction operations can be performed on pointers",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "If 'ptr' is a pointer to an integer variable, what will be the output of the following code? printf(\"%d\", ptr+1);",
+        "opt1": "The memory address of ptr",
+        "opt2": "The value of ptr",
+        "opt3": "The memory address of the integer variable ptr is pointing to",
+        "opt4": "The value of the integer variable ptr+1 is pointing to",
+        "correct_option": "The value of the integer variable ptr+1 is pointing to",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr; printf(\"%d\", *(p++));",
+        "opt1": "1",
+        "opt2": "2",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "1",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr; printf(\"%d\", *(p-2));",
+        "opt1": "1",
+        "opt2": "2",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "Undefined",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr; printf(\"%d\", *(p+4));",
+        "opt1": "1",
+        "opt2": "3",
+        "opt3": "4",
+        "opt4": "Undefined",
+        "correct_option": "Undefined",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the result of the following code? int a = 5, b = 10; int *p1 = &a; int *p2 = &b; int *temp; temp = p1; p1 = p2; p2 = temp; printf(\"%d %d\", *p1, *p2);",
+        "opt1": "5 10",
+        "opt2": "10 5",
+        "opt3": "Undefined",
+        "opt4": "Error",
+        "correct_option": "10 5",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the output of the following code? int a = 10; int *p = &a; (*p)++; printf(\"%d\", a);",
+        "opt1": "9",
+        "opt2": "10",
+        "opt3": "11",
+        "opt4": "Undefined",
+        "correct_option": "11",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4}; int *p = arr + 2; printf(\"%d\", p[-1]);",
+        "opt1": "1",
+        "opt2": "2",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "2",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4, 5}; int *p = arr + 2; printf(\"%d\", *p);",
+        "opt1": "1",
+        "opt2": "2",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "3",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the data type of the pointer variable in the following code? char *p;",
+        "opt1": "char",
+        "opt2": "int",
+        "opt3": "float",
+        "opt4": "double",
+        "correct_option": "char",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the result of the following code? int x = 10, y = 20, z; int *p = &x, *q = &y; z = *p + (*q)++; printf(\"%d %d %d\", x, y, z);",
+        "opt1": "11 20 30",
+        "opt2": "10 21 31",
+        "opt3": "11 21 30",
+        "opt4": "10 20 31",
+        "correct_option": "10 21 30",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4, 5}; int *p = &arr[3]; printf(\"%d\", *(p-2));",
+        "opt1": "1",
+        "opt2": "2",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "2",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4, 5}; int *p = arr; printf(\"%d\", *(++p));",
+        "opt1": "1",
+        "opt2": "2",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "2",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the result of the following code? int arr[] = {1, 2, 3, 4, 5}; int *p = arr; printf(\"%d\", *(p+2));",
+        "opt1": "1",
+        "opt2": "2",
+        "opt3": "3",
+        "opt4": "4",
+        "correct_option": "3",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true about structures in C?",
+        "opt1": "Structures can contain only variables of the same data type",
+        "opt2": "Structures can contain variables of different data types",
+        "opt3": "Structures cannot be passed as function arguments",
+        "opt4": "Structures cannot be returned by functions",
+        "correct_option": "Structures can contain variables of different data types",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How do you declare a structure in C?",
+        "opt1": "struct {name, age};",
+        "opt2": "struct (name, age);",
+        "opt3": "struct person { char name[20]; int age; };",
+        "opt4": "struct {person name, person age};",
+        "correct_option": "struct person { char name[20]; int age; };",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is used to access the members of a structure?",
+        "opt1": "&",
+        "opt2": ".",
+        "opt3": ":",
+        "opt4": "->",
+        "correct_option": ".",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How do you assign values to members of a structure in C?",
+        "opt1": "using the assignment operator",
+        "opt2": "using the dot operator",
+        "opt3": "using the arrow operator ->",
+        "opt4": "using the asterisk operator*",
+        "correct_option": "using the assignment operator",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of typedef in C structures?",
+        "opt1": "to declare a new variable",
+        "opt2": "to define a new data type",
+        "opt3": "to initialize a structure",
+        "opt4": "to allocate memory for a structure",
+        "correct_option": "to define a new data type",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following statements is true regarding the size of a structure in C?",
+        "opt1": "The size of a structure is the sum of the sizes of its members",
+        "opt2": "The size of a structure is always 4 bytes",
+        "opt3": "The size of a structure is the size of its largest member",
+        "opt4": "The size of a structure is the size of its smallest member",
+        "correct_option": "The size of a structure is the sum of the sizes of its members",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the operator used to dynamically allocate memory for a structure in C?",
+        "opt1": ".",
+        "opt2": "&",
+        "opt3": "->",
+        "opt4": "malloc()",
+        "correct_option": "malloc()",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the operator used to deallocate memory allocated for a structure in C?",
+        "opt1": "&",
+        "opt2": ".",
+        "opt3": "free()",
+        "opt4": "calloc()",
+        "correct_option": "free()",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of a union in C?",
+        "opt1": "to combine multiple structures",
+        "opt2": "to create a new data type",
+        "opt3": "to declare a variable",
+        "opt4": "to share the same memory location for different data types",
+        "correct_option": "to share the same memory location for different data types",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is true about nested structures in C?",
+        "opt1": "Nested structures are not allowed in C",
+        "opt2": "Nested structures can only contain variables of the same data type",
+        "opt3": "Nested structures can be defined inside another structure",
+        "opt4": "Nested structures can only contain pointers to other structures",
+        "correct_option": "Nested structures can be defined inside another structure",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is a structure in C programming?",
+        "opt1": "A data type that groups variables of different types",
+        "opt2": "A data type that groups variables of the same type",
+        "opt3": "A data type that groups variables of the same size",
+        "opt4": "A data type that groups variables of different sizes",
+        "correct_option": "A data type that groups variables of different types",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the correct syntax to access a member of a nested structure?",
+        "opt1": "outer_structure.inner_structure.member_name",
+        "opt2": "inner_structure.member_name.outer_structure",
+        "opt3": "member_name.outer_structure.inner_structure",
+        "opt4": "None of the above",
+        "correct_option": "outer_structure.inner_structure.member_name",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the size of an empty structure in C programming?",
+        "opt1": "0 bytes",
+        "opt2": "1 byte",
+        "opt3": "4 bytes",
+        "opt4": "8 bytes",
+        "correct_option": "0 bytes",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is not a valid way to initialize a structure variable in C programming?",
+        "opt1": "struct book b = {\"C Programming\", \"John Doe\", 100};",
+        "opt2": "struct book b = {.name = \"C Programming\", .author = \"John Doe\", .price = 100};",
+        "opt3": "struct book b = {\"C Programming\", price=100};",
+        "opt4": "struct book b; b = {\"C Programming\", \"John Doe\", 100};",
+        "correct_option": "struct book b; b = {\"C Programming\", \"John Doe\", 100};",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is a nested structure in C programming?",
+        "opt1": "A structure that has no members",
+        "opt2": "A structure that is defined inside another structure",
+        "opt3": "A structure that has only one member",
+        "opt4": "A structure that has members of different data types",
+        "correct_option": "A structure that is defined inside another structure",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In C programming, which keyword is used to define a structure?",
+        "opt1": "typedef",
+        "opt2": "define",
+        "opt3": "structdef",
+        "opt4": "struct",
+        "correct_option": "struct",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following statements is true about passing a structure to a function in C programming?",
+        "opt1": "Structures cannot be passed to a function.",
+        "opt2": "Structures are passed by value to a function.",
+        "opt3": "Structures are passed by reference to a function.",
+        "opt4": "Structures are passed as arrays to a function.",
+        "correct_option": "Structures are passed by value to a function.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is not a valid way to declare a pointer to a structure in C programming?",
+        "opt1": "struct *book b;",
+        "opt2": "struct book *b;",
+        "opt3": "typedef struct book *bookptr;",
+        "opt4": "typedef struct book booktype;",
+        "correct_option": "struct *book b;",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the keyword used to access the address of a structure variable in C programming?",
+        "opt1": "&",
+        "opt2": "*",
+        "opt3": "#",
+        "opt4": "$",
+        "correct_option": "&",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the main difference between a structure and a union in C programming?",
+        "opt1": "A structure allows for multiple members to be accessed at once, while a union only allows for one member to be accessed at a time.",
+        "opt2": "A union allows for multiple members to be accessed at once, while a structure only allows for one member to be accessed at a time.",
+        "opt3": "There is no difference between a structure and a union in C programming.",
+        "opt4": "None of above",
+        "correct_option": "A structure allows for multiple members to be accessed at once, while a union only allows for one member to be accessed at a time.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is the correct way to access a structure member using a pointer to a structure?",
+        "opt1": "structure_pointer->member_name",
+        "opt2": "*structure_pointer.member_name",
+        "opt3": "structure_pointer.member_name",
+        "opt4": "None of the above",
+        "correct_option": "structure_pointer->member_name",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between passing a structure by value and passing a structure by pointer in C?",
+        "opt1": "When a structure is passed by value, any modifications made to it in the function are lost when the function returns. When a structure is passed by pointer, the modifications are retained.",
+        "opt2": "When a structure is passed by value, any modifications made to it in the function are retained when the function returns. When a structure is passed by pointer, the modifications are lost.",
+        "opt3": "There is no difference between passing a structure by value and passing a structure by pointer in C.",
+        "opt4": "None of the above",
+        "correct_option": "When a structure is passed by value, any modifications made to it in the function are lost when the function returns. When a structure is passed by pointer, the modifications are retained.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In a structure, what is the default visibility of its members?",
+        "opt1": "Private",
+        "opt2": "Public",
+        "opt3": "Protected",
+        "opt4": "None of the above",
+        "correct_option": "Public",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "In a union, how much memory is allocated for the union itself?",
+        "opt1": "The size of the largest member",
+        "opt2": "The size of all members combined",
+        "opt3": "The size of the smallest member",
+        "opt4": "The size of the union is not allocated in memory",
+        "correct_option": "The size of the largest member",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the main advantage of using a union over a structure?",
+        "opt1": "It uses less memory",
+        "opt2": "It is easier to declare and use",
+        "opt3": "It can hold more types of data",
+        "opt4": "It is faster to access its members",
+        "correct_option": "It uses less memory",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In a union, can two or more members be accessed simultaneously?",
+        "opt1": "Yes, always",
+        "opt2": "Yes, but only if they are of the same type",
+        "opt3": "No, only one member can be accessed at a time",
+        "opt4": "Yes, but only if the member is a pointer",
+        "correct_option": "No, only one member can be accessed at a time",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of declaring a bit field in a structure?",
+        "opt1": "To save memory",
+        "opt2": "To improve performance",
+        "opt3": "To store binary data",
+        "opt4": "To limit the number of possible values for a member",
+        "correct_option": "To save memory",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a structure or union contain a member that is itself a structure or union?",
+        "opt1": "Yes, there is no restriction on the type of members",
+        "opt2": "No, structures and unions cannot contain other structures or unions",
+        "opt3": "Yes, but only if the member is declared as static",
+        "opt4": "None of above",
+        "correct_option": "Yes, there is no restriction on the type of members",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How do you access a member of a structure or union using a pointer?",
+        "opt1": "-> operator",
+        "opt2": ". operator",
+        "opt3": "& operator",
+        "opt4": "* operator",
+        "correct_option": "-> operator",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In a union, what is the value of a member that was not explicitly set?",
+        "opt1": "Zero",
+        "opt2": "Garbage value",
+        "opt3": "Undefined",
+        "opt4": "The value of the previous member",
+        "correct_option": "Garbage value",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following statements is true about the size of a structure or union in C programming?",
+        "opt1": "The size of a structure or union is the sum of the sizes of its members",
+        "opt2": "The size of a structure or union is always a multiple of the size of its largest member",
+        "opt3": "The size of a structure or union depends on the alignment requirements of its members",
+        "opt4": "The size of a structure or union is always equal to the size of its largest member",
+        "correct_option": "The size of a structure or union depends on the alignment requirements of its members",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the difference between a structure and a union in C programming?",
+        "opt1": "A structure allows for multiple members to be accessed at once, while a union only allows for one member to be accessed at a time.",
+        "opt2": "A union allows for multiple members to be accessed at once, while a structure only allows for one member to be accessed at a time.",
+        "opt3": "There is no difference between a structure and a union in C programming.",
+        "opt4": "None of above",
+        "correct_option": "A structure allows for multiple members to be accessed at once, while a union only allows for one member to be accessed at a time.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the size of a structure in C programming?",
+        "opt1": "The size of a structure is equal to the sum of the sizes of its members.",
+        "opt2": "The size of a structure is equal to the size of its largest member.",
+        "opt3": "The size of a structure is equal to the size of its smallest member.",
+        "opt4": "None of above",
+        "correct_option": "The size of a structure is equal to the sum of the sizes of its members.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How do you access a member of a structure in C programming?",
+        "opt1": "Using the dot (.) operator.",
+        "opt2": "Using the arrow (->) operator.",
+        "opt3": "Using the asterisk (*) operator.",
+        "opt4": "None of above",
+        "correct_option": "Using the dot (.) operator.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the keyword used to define a structure in C programming?",
+        "opt1": "struct",
+        "opt2": "union",
+        "opt3": "typedef",
+        "opt4": "None of above",
+        "correct_option": "struct",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements about unions is true in C programming?",
+        "opt1": "Unions can contain members of different types.",
+        "opt2": "Unions cannot contain members.",
+        "opt3": "Unions can only contain members of the same type.",
+        "opt4": "None of above",
+        "correct_option": "Unions can contain members of different types.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the difference between a structure and a typedef struct in C programming?",
+        "opt1": "There is no difference.",
+        "opt2": "Typedef struct can only be used to define new data types.",
+        "opt3": "Typedef struct is a faster way to create a new structure type.",
+        "opt4": "None of above",
+        "correct_option": "Typedef struct is a faster way to create a new structure type.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Can a structure contain a pointer to itself in C programming?",
+        "opt1": "Yes",
+        "opt2": "No",
+        "opt3": "It depends on the compiler used.",
+        "opt4": "It depends on Interpreter used.",
+        "correct_option": "Yes",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about the alignment of structure members in C programming?",
+        "opt1": "Members of a structure are always aligned to the nearest byte boundary.",
+        "opt2": "Members of a structure are aligned based on their size and type.",
+        "opt3": "Members of a structure are not aligned in C programming.",
+        "opt4": "None of above",
+        "correct_option": "Members of a structure are aligned based on their size and type.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of a bit-field in a structure in C programming?",
+        "opt1": "To allow the structure to store more data than its size would normally allow.",
+        "opt2": "To create a member that is only one bit in size.",
+        "opt3": "To allow the structure to be accessed in a bit-wise manner.",
+        "opt4": "None of above",
+        "correct_option": "To create a member that is only one bit in size.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is an example of a valid structure declaration in C programming?",
+        "opt1": "struct person {char name[50]; int age;}",
+        "opt2": "struct person (char name[50]; int age;)",
+        "opt3": "person_struct {char name[50]; int age;}",
+        "opt4": "None of above",
+        "correct_option": "struct person {char name[50]; int age;}",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the syntax for declaring an array of structures in C?",
+        "opt1": "struct array_name[size];",
+        "opt2": "array_name[size] struct;",
+        "opt3": "array_name[size] struct;",
+        "opt4": "struct[size] array_name;",
+        "correct_option": "struct array_name[size];",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In C programming, how do you access a particular member of a structure within an array of structures?",
+        "opt1": "array_name[index].member_name",
+        "opt2": "member_name.array_name[index]",
+        "opt3": "struct.array_name[index].member_name",
+        "opt4": "member_name[index].array_name",
+        "correct_option": "array_name[index].member_name",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of using an array of structures in C?",
+        "opt1": "To group similar data types together in a single entity.",
+        "opt2": "To group different data types together in a single entity.",
+        "opt3": "To make the code easier to read and maintain.",
+        "opt4": "To create a single variable that can hold multiple values.",
+        "correct_option": "To group similar data types together in a single entity.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How do you initialize an array of structures in C?",
+        "opt1": "By setting each member of the array individually.",
+        "opt2": "By setting the values of the first member of the array, which automatically sets the values of the rest of the members.",
+        "opt3": "By using a loop to set the values of each member of the array.",
+        "opt4": "By using a pointer to set the values of each member of the array.",
+        "correct_option": "By setting each member of the array individually.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the maximum number of dimensions that an array of structures can have in C?",
+        "opt1": "One",
+        "opt2": "Two",
+        "opt3": "Three",
+        "opt4": "There is no limit",
+        "correct_option": "There is no limit",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the purpose of using a typedef with an array of structures in C?",
+        "opt1": "To make it easier to declare variables of that type.",
+        "opt2": "To make the code more readable.",
+        "opt3": "To make it easier to access the members of the array.",
+        "opt4": "To create a new data type.",
+        "correct_option": "To create a new data type.",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a valid way to access a member of a structure within an array of structures in C?",
+        "opt1": "array_name.member_name[index]",
+        "opt2": "array_name[index].member_name",
+        "opt3": "member_name.array_name[index]",
+        "opt4": "struct.array_name[index].member_name",
+        "correct_option": "array_name[index].member_name",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How do you declare a pointer to an array of structures in C?",
+        "opt1": "struct *array_name[size];",
+        "opt2": "struct (*array_name)[size];",
+        "opt3": "struct *array_name[size];",
+        "opt4": "struct (*array_name)[size];",
+        "correct_option": "struct (*array_name)[size];",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "In C programming, how do you access a particular member of a structure within a pointer to an array of structures?",
+        "opt1": "pointer_name->member_name[index]",
+        "opt2": "pointer_name[index]->member_name",
+        "opt3": "pointer_name.member_name[index]",
+        "opt4": "pointer_name[index].member_name",
+        "correct_option": "pointer_name[index].member_name",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "How do you dynamically allocate memory for an array of structures in C?",
+        "opt1": "By using the malloc() function.",
+        "opt2": "By using the calloc() function.",
+        "opt3": "By using the realloc() function.",
+        "opt4": "By using the free() function.",
+        "correct_option": "By using the malloc() function.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How do you declare an array of structures in C?",
+        "opt1": "struct Array = {...}",
+        "opt2": "struct *Array = {...}",
+        "opt3": "struct Array[] = {...}",
+        "opt4": "struct Array {...}",
+        "correct_option": "struct Array[] = {...}",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the correct syntax for accessing the member variable \"age\" of the first structure in an array of structures named \"people\"?",
+        "opt1": "people.age[0]",
+        "opt2": "people[0].age",
+        "opt3": "people.age->0",
+        "opt4": "age[0].people",
+        "correct_option": "people[0].age",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the maximum number of elements that can be stored in an array of structures?",
+        "opt1": "There is no maximum number",
+        "opt2": "The maximum number is determined by the size of each element",
+        "opt3": "The maximum number is 1024",
+        "opt4": "The maximum number is determined by the amount of available memory",
+        "correct_option": "The maximum number is determined by the amount of available memory",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a valid way to initialize an array of structures in C?",
+        "opt1": "struct person[] = {{1, \"John\"}, {2, \"Jane\"}}",
+        "opt2": "struct person[] = { 1, \"John\" , {2, \"Jane\"}, {3, \"Bob\"}}",
+        "opt3": "struct person = [1] = {1, \"John\"}, [2]= {2, \"Jane\"}",
+        "opt4": "All of the above",
+        "correct_option": "struct person[] = {{1, \"John\"}, {2, \"Jane\"}}",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the size of the following structure? struct student { char name[50]; int age; float gpa; };",
+        "opt1": "54 bytes",
+        "opt2": "60 bytes",
+        "opt3": "62 bytes",
+        "opt4": "64 bytes",
+        "correct_option": "60 bytes",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which operator is used to access a member of a structure through a pointer to the structure?",
+        "opt1": ".",
+        "opt2": "->",
+        "opt3": "*",
+        "opt4": "&",
+        "correct_option": "->",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the correct syntax for declaring a pointer to a structure?",
+        "opt1": "struct *p;",
+        "opt2": "struct p;",
+        "opt3": "struct pointer;",
+        "opt4": "struct person *p;",
+        "correct_option": "struct person *p;",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "How can you dynamically allocate memory for an array of structures in C?",
+        "opt1": "struct array = (struct *) malloc(sizeof(struct) * n);",
+        "opt2": "struct array = (struct**) malloc(n * sizeof(struct));",
+        "opt3": "struct array = (struct*) malloc(n);",
+        "opt4": "struct array = (struct*) malloc(sizeof(struct));",
+        "correct_option": "struct array = (struct *) malloc(sizeof(struct) * n);",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How can you access the last element in an array of structures with n elements?",
+        "opt1": "arr[n]",
+        "opt2": "arr[n-1]",
+        "opt3": "arr.last",
+        "opt4": "arr.end",
+        "correct_option": "arr[n-1]",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is an advantage of using an array of structures instead of multiple individual structures?",
+        "opt1": "Easier to manage",
+        "opt2": "Easier to pass to functions",
+        "opt3": "Requires less memory",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the syntax for passing a structure to a function in C?",
+        "opt1": "function(struct s)",
+        "opt2": "function(struct *s)",
+        "opt3": "function(*s)",
+        "opt4": "function(&s)",
+        "correct_option": "function(struct s)",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How do you declare a function that takes a structure as an argument in C?",
+        "opt1": "void myFunction(struct myStruct);",
+        "opt2": "void myFunction(struct myStruct *);",
+        "opt3": "void myFunction(*myStruct);",
+        "opt4": "void myFunction(&myStruct);",
+        "correct_option": "void myFunction(struct myStruct);",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can you pass an array of structures to a function in C?",
+        "opt1": "No, C does not support passing arrays of structures to functions",
+        "opt2": "Yes, you can pass an array of structures to a function using a pointer",
+        "opt3": "Yes, you can pass an array of structures to a function by value",
+        "opt4": "Yes, you can pass an array of structures to a function using the & operator",
+        "correct_option": "Yes, you can pass an array of structures to a function using a pointer",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How does passing a structure to a function by reference (i.e. using a pointer) differ from passing it by value?",
+        "opt1": "Passing by reference creates a copy of the structure, while passing by value does not",
+        "opt2": "Passing by reference allows the function to modify the original structure, while passing by value does not",
+        "opt3": "Passing by reference is slower than passing by value",
+        "opt4": "Passing by reference is not allowed in C",
+        "correct_option": "Passing by reference allows the function to modify the original structure, while passing by value does not",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the advantage of passing a structure to a function by reference instead of by value?",
+        "opt1": "Passing by reference is faster",
+        "opt2": "Passing by reference allows the function to modify the original structure",
+        "opt3": "Passing by reference is easier to write",
+        "opt4": "Passing by reference requires less memory",
+        "correct_option": "Passing by reference is faster",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How do you access a structure member inside a function that takes a pointer to the structure as an argument?",
+        "opt1": "s.member",
+        "opt2": "(*s).member",
+        "opt3": "&s->member",
+        "opt4": "s->member",
+        "correct_option": "s->member",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the correct way to pass a structure to a function by reference?",
+        "opt1": "function(struct s)",
+        "opt2": "function(struct *s)",
+        "opt3": "function(&s)",
+        "opt4": "function(*s)",
+        "correct_option": "function(&s)",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Can a function return a structure in C?",
+        "opt1": "Yes, by using the & operator",
+        "opt2": "Yes, but it requires passing a pointer to the structure as an argument",
+        "opt3": "Yes, by returning a pointer to the structure",
+        "opt4": "No, C does not support returning structures from functions",
+        "correct_option": "Yes, by returning a pointer to the structure",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "How do you initialize a structure variable inside a function?",
+        "opt1": "struct s = {...}",
+        "opt2": "s = {...}",
+        "opt3": "Pass by value",
+        "opt4": "Pass by reference",
+        "correct_option": "struct s = {...}",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the advantage of passing a structure by pointer to a function in C?",
+        "opt1": "It reduces the size of the structure",
+        "opt2": "It increases the speed of the program",
+        "opt3": "It allows the function to modify the original structure",
+        "opt4": "None of the above",
+        "correct_option": "It allows the function to modify the original structure",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is the correct syntax to pass a structure by value to a function in C?",
+        "opt1": "function_name(&structure_variable)",
+        "opt2": "function_name(*structure_variable)",
+        "opt3": "function_name(structure_variable)",
+        "opt4": "function_name(structure_pointer)",
+        "correct_option": "function_name(structure_variable)",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is the correct syntax to pass a structure by reference to a function in C?",
+        "opt1": "function_name(&structure_variable)",
+        "opt2": "function_name(*structure_variable)",
+        "opt3": "function_name(structure_variable)",
+        "opt4": "function_name(structure_pointer)",
+        "correct_option": "function_name(&structure_variable)",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is the correct syntax to pass a structure by pointer to a function in C?",
+        "opt1": "function_name(&structure_variable)",
+        "opt2": "function_name(structure_variable)",
+        "opt3": "function_name(structure_pointer)",
+        "opt4": "function_name(*structure_variable)",
+        "correct_option": "function_name(structure_pointer)",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is a namespace in C++?",
+        "opt1": "It is a block of code that is used to group related variables and functions",
+        "opt2": "It is a feature that allows a class to inherit from multiple base classes",
+        "opt3": "It is a mechanism for managing the scope of identifiers in large programs",
+        "opt4": "It is a type of loop in C++",
+        "correct_option": "It is a mechanism for managing the scope of identifiers in large programs",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which keyword is used to define a namespace in C++?",
+        "opt1": "namespace",
+        "opt2": "define",
+        "opt3": "namespace scope",
+        "opt4": "using namespace",
+        "correct_option": "namespace",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true regarding namespaces in C++?",
+        "opt1": "You can have multiple namespaces with the same name in the same program",
+        "opt2": "Namespaces can only contain function declarations",
+        "opt3": "You can define a namespace within a function",
+        "opt4": "The contents of a namespace can be accessed using the dot operator",
+        "correct_option": "You can have multiple namespaces with the same name in the same program",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of using the using keyword with namespaces in C++?",
+        "opt1": "To create an alias for a namespace",
+        "opt2": "To bring all the members of a namespace into the current scope",
+        "opt3": "To hide certain members of a namespace",
+        "opt4": "To define a new namespace within an existing namespace",
+        "correct_option": "To bring all the members of a namespace into the current scope",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the scope resolution operator in C++?",
+        "opt1": ":",
+        "opt2": "::",
+        "opt3": "->",
+        "opt4": "#",
+        "correct_option": "::",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is true regarding the scope resolution operator in C++?",
+        "opt1": "It is used to access the members of a namespace",
+        "opt2": "It is used to access the members of a class",
+        "opt3": "It is used to access the elements of an array",
+        "opt4": "It is used to access the elements of a linked list",
+        "correct_option": "It is used to access the members of a namespace",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the unnamed namespace in C++?",
+        "opt1": "To make a function or variable global",
+        "opt2": "To limit the visibility of a function or variable to a single source file",
+        "opt3": "To create a new namespace within an existing namespace",
+        "opt4": "To create a namespace with a name that cannot be accessed by the user",
+        "correct_option": "To limit the visibility of a function or variable to a single source file",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is a benefit of using namespaces in C++?",
+        "opt1": "They prevent naming conflicts between classes",
+        "opt2": "They allow you to define variables with the same name in different functions",
+        "opt3": "They improve the performance of the program",
+        "opt4": "They allow you to define variables with the same name in the same scope",
+        "correct_option": "They prevent naming conflicts between classes",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of using namespaces in C++?",
+        "opt1": "They can make the code more difficult to read and understand",
+        "opt2": "They increase the size of the executable file",
+        "opt3": "They make it more difficult to reuse code in different projects",
+        "opt4": "They increase the likelihood of naming conflicts between classes",
+        "correct_option": "They can make the code more difficult to read and understand",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true regarding the global namespace in C++?",
+        "opt1": "All variables and functions defined outside of a namespace belong to the global namespace",
+        "opt2": "The global namespace is automatically included in every program",
+        "opt3": "The global namespace can be used to define variables and functions that can be accessed from any part of the program",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is a namespace in C++?",
+        "opt1": "A container that holds a group of related variables and functions",
+        "opt2": "A type of loop that iterates over a collection of elements",
+        "opt3": "A method of creating a new object from an existing object",
+        "opt4": "A way to specify the data type of a variable",
+        "correct_option": "A container that holds a group of related variables and functions",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true regarding namespaces in C++?",
+        "opt1": "Nested namespaces are not allowed",
+        "opt2": "A namespace can only contain functions",
+        "opt3": "Namespaces are only used in object-oriented programming",
+        "opt4": "Namespace members are accessed using the :: operator",
+        "correct_option": "Namespace members are accessed using the :: operator",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the purpose of using a namespace in C++?",
+        "opt1": "To avoid naming conflicts between variables and functions",
+        "opt2": "To allocate memory dynamically",
+        "opt3": "To overload operators for a class",
+        "opt4": "To declare a global variable",
+        "correct_option": "To avoid naming conflicts between variables and functions",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the default namespace in C++?",
+        "opt1": "std",
+        "opt2": "default",
+        "opt3": "main",
+        "opt4": "none of the above",
+        "correct_option": "std",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a namespace be defined across multiple files in C++?",
+        "opt1": "Yes, by using the using directive",
+        "opt2": "Yes, by using the namespace keyword",
+        "opt3": "No, a namespace must be defined in a single file",
+        "opt4": "No, a namespace can only be defined within a function",
+        "correct_option": "Yes, by using the namespace keyword",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is a valid way to alias a namespace in C++?",
+        "opt1": "namespace A::B",
+        "opt2": "using A::B",
+        "opt3": "namespace B = A",
+        "opt4": "using namespace A::B",
+        "correct_option": "namespace B = A",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is an advantage of using namespaces in C++?",
+        "opt1": "They allow for faster program execution",
+        "opt2": "They make it easier to reuse code",
+        "opt3": "They help to reduce the size of the program",
+        "opt4": "They prevent type conversion errors",
+        "correct_option": "They make it easier to reuse code",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is true regarding the scope of a namespace in C++?",
+        "opt1": "A namespace can be used anywhere in the program",
+        "opt2": "A namespace can only be used within the file it is defined in",
+        "opt3": "A namespace can only be used within the class it is defined in",
+        "opt4": "A namespace can only be used within the function it is defined in",
+        "correct_option": "A namespace can be used anywhere in the program",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about function overloading in C++?",
+        "opt1": "Only the function name should be the same for overloaded functions",
+        "opt2": "Overloaded functions can differ in the number of parameters",
+        "opt3": "Overloaded functions cannot have the same return type",
+        "opt4": "All of the above",
+        "correct_option": "Overloaded functions can differ in the number of parameters",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which operator cannot be overloaded in C++?",
+        "opt1": "&& and ||",
+        "opt2": ":: and ->",
+        "opt3": "+ and -",
+        "opt4": "All of the above",
+        "correct_option": ":: and ->",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is not a valid way of differentiating between overloaded functions?",
+        "opt1": "Number of parameters",
+        "opt2": "Order of parameters",
+        "opt3": "Return type",
+        "opt4": "None of the above",
+        "correct_option": "Return type",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following statements is true about function overloading in C++? (Repeated concept)",
+        "opt1": "Overloaded functions must have the same access level",
+        "opt2": "Access levels do not affect function overloading",
+        "opt3": "Overloaded functions must have different access levels",
+        "opt4": "None of the above",
+        "correct_option": "Access levels do not affect function overloading",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the benefit of function overloading in C++?",
+        "opt1": "It reduces the number of functions in a program",
+        "opt2": "It makes the code easier to read and understand",
+        "opt3": "It allows the same function name to be used for different operations",
+        "opt4": "All of the above",
+        "correct_option": "It allows the same function name to be used for different operations",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true about function overloading? (Repeated concept)",
+        "opt1": "Overloaded functions can have different names",
+        "opt2": "Overloaded functions can have the same number and types of parameters",
+        "opt3": "Overloaded functions must have the same return type",
+        "opt4": "None of the above",
+        "correct_option": "None of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is an example of function overloading in C++?",
+        "opt1": "int add(int a, int b)",
+        "opt2": "float add(float a, float b)",
+        "opt3": "void add(int a, int b)",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is function overloading in C++?",
+        "opt1": "Defining a function with the same name and same parameters as an existing function",
+        "opt2": "Defining a function with the same name but different parameters as an existing function",
+        "opt3": "Defining a function with a different name but the same parameters as an existing function",
+        "opt4": "Defining a function with a different name and different parameters as an existing function",
+        "correct_option": "Defining a function with the same name but different parameters as an existing function",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is not a valid way to overload a function in C++?",
+        "opt1": "Changing the number of parameters in the function",
+        "opt2": "Changing the return type of the function",
+        "opt3": "Changing the order of the parameters in the function",
+        "opt4": "Changing the type of the parameters in the function",
+        "correct_option": "Changing the return type of the function",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of function overloading in C++?",
+        "opt1": "To create new functions with different names",
+        "opt2": "To create functions that have different return types",
+        "opt3": "To allow functions to work with different types of data",
+        "opt4": "To allow functions to be used with different sets of parameters",
+        "correct_option": "To allow functions to be used with different sets of parameters",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is an example of function overloading in C++? (Repeated concept)",
+        "opt1": "int add(int x, int y)",
+        "opt2": "float add(float x, float y)",
+        "opt3": "char add(char x, char y)",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Can two functions in C++ have the same name and the same set of parameters?",
+        "opt1": "Yes, as long as they have different return types",
+        "opt2": "Yes, as long as they are declared in different namespaces",
+        "opt3": "No, it is not allowed in C++",
+        "opt4": "Yes, as long as they are declared in different classes",
+        "correct_option": "No, it is not allowed in C++",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true about function overloading in C++? (Repeated concept)",
+        "opt1": "Overloaded functions must have the same name",
+        "opt2": "Overloaded functions must have different return types",
+        "opt3": "Overloaded functions must have the same number of parameters",
+        "opt4": "Overloaded functions must have different parameter types or different number of parameters",
+        "correct_option": "Overloaded functions must have different parameter types or different number of parameters",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the benefit of using function overloading in C++?",
+        "opt1": "It allows you to create functions with different names",
+        "opt2": "It allows you to create functions with different return types",
+        "opt3": "It allows you to write more efficient code",
+        "opt4": "It allows you to create more versatile functions",
+        "correct_option": "It allows you to create more versatile functions",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following operators can be overloaded in C++?",
+        "opt1": "+",
+        "opt2": "=",
+        "opt3": "[]",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Can you overload a member function in C++?",
+        "opt1": "Yes, you can overload both member and non-member functions in C++",
+        "opt2": "No, member functions cannot be overloaded in C++",
+        "opt3": "Yes, but only if the functions have different return types",
+        "opt4": "Yes, but only if the functions have different parameters",
+        "correct_option": "Yes, you can overload both member and non-member functions in C++",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is an example of function overloading?",
+        "opt1": "int add(int x, int y) { return x + y; } int add(int x, int y, int z) { return x+y+z;}",
+        "opt2": "int add(int x, int y) { return x + y; } float add(int x, int y) { return x + y;}",
+        "opt3": "int add(int x, int y) { return x + y; } int subtract(int x, int y) { return x - y; }",
+        "opt4": "All of the above",
+        "correct_option": "int add(int x, int y) { return x + y; } int add(int x, int y, int z) { return x+y+z;}",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is an inline function in C++?",
+        "opt1": "A function that takes an argument of type inline",
+        "opt2": "A function that is defined with the inline keyword",
+        "opt3": "A function that is executed sequentially",
+        "opt4": "A function that is expanded inline by the compiler",
+        "correct_option": "A function that is defined with the inline keyword",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the advantage of using an inline function?",
+        "opt1": "It reduces the size of the program",
+        "opt2": "It reduces the function call overhead",
+        "opt3": "It increases the performance of the program",
+        "opt4": "It allows for recursion",
+        "correct_option": "It reduces the function call overhead",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which keyword is used to declare an inline function in C++?",
+        "opt1": "function",
+        "opt2": "inline",
+        "opt3": "def",
+        "opt4": "define",
+        "correct_option": "inline",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Can a function that returns void be inline in C++?",
+        "opt1": "Yes, any function can be declared inline",
+        "opt2": "No, only functions that return a value can be inline",
+        "opt3": "It depends on the implementation",
+        "opt4": "None of the above",
+        "correct_option": "Yes, any function can be declared inline",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about inline functions in C++?",
+        "opt1": "Inline functions cannot be recursive",
+        "opt2": "Inline functions cannot contain loops",
+        "opt3": "Inline functions cannot be overloaded",
+        "opt4": "Inline functions cannot have default arguments",
+        "correct_option": "Inline functions cannot be recursive",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How does the compiler treat inline functions in C++?",
+        "opt1": "It generates a separate function call for each call to the inline function",
+        "opt2": "It replaces the function call with the actual function code at the point of the call",
+        "opt3": "It generates an error if the function is not defined inline",
+        "opt4": "It generates a jump instruction to the function code at the point of the call",
+        "correct_option": "It replaces the function call with the actual function code at the point of the call",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Can a function that is defined in a separate source file be inline in C++?",
+        "opt1": "Yes, as long as the function is declared inline in the header file",
+        "opt2": "No, inline functions must be defined in the same source file as the caller",
+        "opt3": "It depends on the implementation of the compiler",
+        "opt4": "None of the above",
+        "correct_option": "No, inline functions must be defined in the same source file as the caller",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is an example of an inline function in C++?",
+        "opt1": "int add(int a, int b) { return a + b; }",
+        "opt2": "void print_hello() { std::cout << \"Hello, world!\" << std::endl; }",
+        "opt3": "double square(double x) {return x*x;}",
+        "opt4": "class Rectangle { public: inline int area() { return width * height; } };",
+        "correct_option": "class Rectangle { public: inline int area() { return width * height; } };",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of using inline functions in C++?",
+        "opt1": "It can increase the size of the program",
+        "opt2": "It can decrease the performance of the program",
+        "opt3": "It can lead to code bloat",
+        "opt4": "It can lead to name collisions",
+        "correct_option": "It can increase the size of the program",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is a good candidate for an inline function in C++?",
+        "opt1": "A function that performs complex calculations",
+        "opt2": "A function that is called frequently and has a short body",
+        "opt3": "A function that takes a long time to execute",
+        "opt4": "A function that is rarely called and has a long body",
+        "correct_option": "A function that is called frequently and has a short body",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is an inline function in C++? (Repeated concept)",
+        "opt1": "A function defined with the \"inline\" keyword, which is a suggestion to the compiler to perform inline expansion of the function",
+        "opt2": "A function defined with the \"inline\" keyword, which is a requirement for the compiler to perform inline expansion of the function",
+        "opt3": "A function that is always expanded inline by the compiler, regardless of how it is defined",
+        "opt4": "A function that is never expanded inline by the compiler, regardless of how it is defined",
+        "correct_option": "A function defined with the \"inline\" keyword, which is a suggestion to the compiler to perform inline expansion of the function",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the advantage of using inline functions in C++? (Repeated concept)",
+        "opt1": "They are faster than regular functions",
+        "opt2": "They reduce the executable size of a program",
+        "opt3": "They can be used to define function templates",
+        "opt4": "They make it easier to overload functions",
+        "correct_option": "They are faster than regular functions",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "When should you use an inline function in C++?",
+        "opt1": "When the function is small and simple",
+        "opt2": "When the function is called frequently",
+        "opt3": "When the function has a lot of parameters",
+        "opt4": "When the function is large and complex",
+        "correct_option": "When the function is small and simple",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a virtual function be inline in C++?",
+        "opt1": "When the function is used in only one place in the program",
+        "opt2": "No, virtual functions cannot be inline in C++",
+        "opt3": "Yes, as long as it is defined with the \"inline\" keyword only",
+        "opt4": "It depends on the compiler",
+        "correct_option": "No, virtual functions cannot be inline in C++",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the syntax for defining an inline function in C++?",
+        "opt1": "inline int function_name(int param1, int param2) {}",
+        "opt2": "void inline function_name(int param1, int param2) {}",
+        "opt3": "int inline function_name(int param1, int param2) {}",
+        "opt4": "inline function_name(int param1, int param2) {}",
+        "correct_option": "inline int function_name(int param1, int param2) {}",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a member function of a class be inline in C++?",
+        "opt1": "Yes, as long as it is defined with the \"inline\" keyword",
+        "opt2": "No, member functions cannot be inline in C++",
+        "opt3": "Yes, as long as it is defined with the \"inline\" keyword and the function body is defined inside the class definition",
+        "opt4": "It depends on the implementation",
+        "correct_option": "Yes, as long as it is defined with the \"inline\" keyword and the function body is defined inside the class definition",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the \"inline\" keyword in C++?",
+        "opt1": "To indicate that a function is a friend of a class",
+        "opt2": "To require the compiler to perform inline expansion of a function",
+        "opt3": "To suggest to the compiler to perform inline expansion of a function",
+        "opt4": "To indicate that a function is a virtual function",
+        "correct_option": "To suggest to the compiler to perform inline expansion of a function",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a disadvantage of using inline functions in C++? (Repeated concept)",
+        "opt1": "They can increase the size of the executable code",
+        "opt2": "They can slow down the program execution",
+        "opt3": "They can make debugging more difficult",
+        "opt4": "There are no disadvantages to using inline functions",
+        "correct_option": "They can increase the size of the executable code",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a function defined in a header file be inline in C++?",
+        "opt1": "Yes, as long as it is defined with the \"inline\" keyword",
+        "opt2": "No, functions defined in header files cannot be inline in C++",
+        "opt3": "Yes, as long as it is defined with the \"inline\" keyword and the function body is defined inside the header file",
+        "opt4": "It depends on the compiler",
+        "correct_option": "Yes, as long as it is defined with the \"inline\" keyword and the function body is defined inside the header file",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is a default argument in C++?",
+        "opt1": "An argument that is automatically assigned the value 0",
+        "opt2": "An argument that is assigned the value of the previous argument",
+        "opt3": "An argument that is assigned a value if no other value is provided",
+        "opt4": "An argument that is assigned a random value",
+        "correct_option": "An argument that is assigned a value if no other value is provided",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true about default arguments?",
+        "opt1": "They must be specified in the function declaration and definition",
+        "opt2": "They can only be of basic data types such as int and float",
+        "opt3": "They must always come at the beginning of the argument list",
+        "opt4": "They cannot be of array types",
+        "correct_option": "They must be specified in the function declaration and definition",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is an example of a function that uses a default argument?",
+        "opt1": "int add(int x, int y)",
+        "opt2": "float divide(float a, float b, float c = 1.0)",
+        "opt3": "void print()",
+        "opt4": "char getChar(char c = 'a')",
+        "correct_option": "float divide(float a, float b, float c = 1.0)",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the order in which arguments are passed to a function?",
+        "opt1": "Regular arguments first, followed by default arguments",
+        "opt2": "Default arguments first, followed by regular arguments",
+        "opt3": "Random order",
+        "opt4": "None of the above",
+        "correct_option": "Regular arguments first, followed by default arguments",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true about default arguments in relation to function overloading?",
+        "opt1": "Default arguments are not allowed in function overloading",
+        "opt2": "Default arguments must be the same for all functions in an overload set",
+        "opt3": "Default arguments are allowed, but only for one function in an overload set",
+        "opt4": "Default arguments must be different for all functions in an overload set",
+        "correct_option": "Default arguments are allowed, but only for one function in an overload set",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the benefit of using default arguments?",
+        "opt1": "It makes the code more efficient",
+        "opt2": "It allows for fewer function overloads",
+        "opt3": "It improves code readability",
+        "opt4": "It allows for more complex programs",
+        "correct_option": "It allows for fewer function overloads",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What happens if a default argument is specified in both the function declaration and definition?",
+        "opt1": "The code will not compile",
+        "opt2": "The argument specified in the definition will be used",
+        "opt3": "The argument specified in the declaration will be used",
+        "opt4": "The default argument will be ignored",
+        "correct_option": "The code will not compile",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true about default arguments and templates?",
+        "opt1": "Default arguments are not allowed in templates",
+        "opt2": "Default arguments can be used in templates, but only for one parameter",
+        "opt3": "Default arguments can be used in templates for any number of parameters",
+        "opt4": "Default arguments in templates must be the same for all instantiations",
+        "correct_option": "Default arguments can be used in templates for any number of parameters",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What are default arguments in C++? (Repeated concept)",
+        "opt1": "Arguments that are automatically initialized with a default value.",
+        "opt2": "Arguments that are passed by value.",
+        "opt3": "Arguments that are passed by reference.",
+        "opt4": "Arguments that are passed by pointer.",
+        "correct_option": "Arguments that are automatically initialized with a default value.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Where should default arguments be specified in a function declaration?",
+        "opt1": "Before the function name.",
+        "opt2": "After the function name.",
+        "opt3": "Before the return type.",
+        "opt4": "After the return type.",
+        "correct_option": "After the function name.",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of default arguments? (Repeated concept)",
+        "opt1": "To make functions more efficient.",
+        "opt2": "To make it easier to pass arguments to a function.",
+        "opt3": "To allow a function to be overloaded.",
+        "opt4": "To provide a default value for a parameter if one is not specified.",
+        "correct_option": "To provide a default value for a parameter if one is not specified.",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "When are default arguments evaluated?",
+        "opt1": "At runtime.",
+        "opt2": "At compile time.",
+        "opt3": "At link time.",
+        "opt4": "At load time.",
+        "correct_option": "At runtime.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What happens if a default argument is specified in both the function declaration and the function definition? (Repeated concept)",
+        "opt1": "The program will not compile.",
+        "opt2": "The default argument specified in the function definition will be used.",
+        "opt3": "The default argument specified in the function declaration will be used.",
+        "opt4": "Both default arguments will be used.",
+        "correct_option": "The program will not compile.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the syntax for specifying a default argument?",
+        "opt1": "argumentType argumentName = defaultValue",
+        "opt2": "argumentType defaultValue argumentName",
+        "opt3": "defaultValue argumentType argumentName",
+        "opt4": "argumentName = defaultValue",
+        "correct_option": "argumentType argumentName = defaultValue",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true about classes in C++?",
+        "opt1": "A class is a blueprint for objects",
+        "opt2": "A class is an object",
+        "opt3": "A class is a function",
+        "opt4": "A class is a data type",
+        "correct_option": "A class is a blueprint for objects",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following keywords is used to create an object of a class?",
+        "opt1": "new",
+        "opt2": "this",
+        "opt3": "object",
+        "opt4": "none of the above",
+        "correct_option": "new",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following access specifiers is used to make class members accessible only within the same class?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "none of the above",
+        "correct_option": "private",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is a constructor?",
+        "opt1": "A function that is used to create an object of a class",
+        "opt2": "A function that is used to destroy an object of a class",
+        "opt3": "A function that is used to allocate memory for an object of a class",
+        "opt4": "A function that is used to deallocate memory for an object of a class",
+        "correct_option": "A function that is used to create an object of a class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is encapsulation in C++?",
+        "opt1": "Combining data members and member functions in a single unit",
+        "opt2": "Making class members accessible only within the same class",
+        "opt3": "Creating objects of a class",
+        "opt4": "None of the above",
+        "correct_option": "Combining data members and member functions in a single unit",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a class in C++?",
+        "opt1": "A user-defined data type",
+        "opt2": "A built-in data type",
+        "opt3": "A function",
+        "opt4": "A pointer to a variable",
+        "correct_option": "A user-defined data type",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true about a static member of a class?",
+        "opt1": "It is shared by all objects of the class",
+        "opt2": "It is specific to each object of the class",
+        "opt3": "It can be accessed using the object of the class",
+        "opt4": "It cannot be accessed using the object of the class",
+        "correct_option": "It is shared by all objects of the class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is used to create a copy of an object in C++?",
+        "opt1": "Object cloning",
+        "opt2": "Object duplication",
+        "opt3": "Object copying",
+        "opt4": "Object creation",
+        "correct_option": "Object copying",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is used to initialize the data members of an object of a class?",
+        "opt1": "Constructors",
+        "opt2": "Destructors",
+        "opt3": "assignment operators",
+        "opt4": "Copy constructors",
+        "correct_option": "Constructors",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true about friend functions in C++?",
+        "opt1": "Friend functions are class members",
+        "opt2": "Friend functions can access private and protected members of a class",
+        "opt3": "Friend functions can be called using an object of the class",
+        "opt4": "Friend functions cannot be defined outside the class",
+        "correct_option": "Friend functions can access private and protected members of a class",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is an object in C++?",
+        "opt1": "An instance of a class",
+        "opt2": "A type of data",
+        "opt3": "A function",
+        "opt4": "A pointer to a variable",
+        "correct_option": "An instance of a class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following access specifiers in C++ allows the member to be accessed by any function or class in the program?",
+        "opt1": "Private",
+        "opt2": "Protected",
+        "opt3": "Public",
+        "opt4": "Friend",
+        "correct_option": "Public",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which access specifier in C++ allows a member function or variable to be accessed only by the same class and its friends?",
+        "opt1": "Private",
+        "opt2": "Public",
+        "opt3": "Protected",
+        "opt4": "Friend",
+        "correct_option": "Private",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which access specifier in C++ allows a member function or variable to be accessed by the same class, its derived classes, and its friends?",
+        "opt1": "Private",
+        "opt2": "Public",
+        "opt3": "Protected",
+        "opt4": "Friend",
+        "correct_option": "Protected",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true about access specifiers in C++?",
+        "opt1": "They determine the visibility of a member outside of the class.",
+        "opt2": "They determine the data type of a member.",
+        "opt3": "They determine the scope of a member within the class.",
+        "opt4": "They determine the storage location of a member.",
+        "correct_option": "They determine the visibility of a member outside of the class.",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following access specifiers is used to hide the implementation details of a class from the user?",
+        "opt1": "Private",
+        "opt2": "Public",
+        "opt3": "Protected",
+        "opt4": "Friend",
+        "correct_option": "Private",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which access specifier in C++ allows a member function or variable to be accessed by any class or function that is declared as a friend of the class?",
+        "opt1": "Private",
+        "opt2": "Public",
+        "opt3": "Protected",
+        "opt4": "Friend",
+        "correct_option": "Friend",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which access specifier in C++ allows a member function or variable to be accessed by the same class and its derived classes?",
+        "opt1": "Private",
+        "opt2": "Public",
+        "opt3": "Protected",
+        "opt4": "Friend",
+        "correct_option": "Protected",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which access specifier in C++ allows a member function or variable to be accessed by any function or class within the same namespace?",
+        "opt1": "Private",
+        "opt2": "Public",
+        "opt3": "Protected",
+        "opt4": "Friend",
+        "correct_option": "Public",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following access specifiers in C++ is used to prevent a member from being accessed outside of the class definition?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "private",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which access specifier allows access to a class member only within the class definition?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "private",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which access specifier allows access to a class member from any function outside the class definition?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "public",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which access specifier allows a derived class to access the protected members of its base class?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "protected",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which access specifier allows access to a class member from a derived class?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "protected",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which access specifier allows a member function to access all members of a class?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "private",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the default access specifier for a class in C++?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "private",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which access specifier allows a friend function to access all members of a class?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "friend",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which access specifier allows access to a class member from any class?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "public",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which access specifier should be used for class members that need to be accessed by functions outside the class definition?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "public",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which access specifier should be used for class members that should only be accessed within the class definition?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "friend",
+        "correct_option": "private",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the dot operator used for in C++?",
+        "opt1": "To declare objects",
+        "opt2": "To access a member of an object",
+        "opt3": "To access a function of a class",
+        "opt4": "To access a class variable",
+        "correct_option": "To access a member of an object",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is an example of an object?",
+        "opt1": "int x;",
+        "opt2": "string s;",
+        "opt3": "MyClass obj;",
+        "opt4": "double y;",
+        "correct_option": "MyClass obj;",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following operators is used to access a member of an object?",
+        "opt1": ".",
+        "opt2": "->",
+        "opt3": "::",
+        "opt4": ":",
+        "correct_option": ".",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is used to initialize an object?",
+        "opt1": "The constructor",
+        "opt2": "The destructor",
+        "opt3": "The copy constructor",
+        "opt4": "The assignment operator",
+        "correct_option": "The constructor",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following access specifiers allows a member to be accessed from any function?",
+        "opt1": "Public",
+        "opt2": "Private",
+        "opt3": "Protected",
+        "opt4": "Friend",
+        "correct_option": "Public",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the keyword used to declare a class in C++?",
+        "opt1": "class",
+        "opt2": "object",
+        "opt3": "struct",
+        "opt4": "member",
+        "correct_option": "class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is used to destroy an object?",
+        "opt1": "The constructor",
+        "opt2": "The destructor",
+        "opt3": "The copy constructor",
+        "opt4": "The assignment operator",
+        "correct_option": "The destructor",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is true about an object in C++?",
+        "opt1": "It is an instance of a class",
+        "opt2": "It cannot be passed as a parameter to a function",
+        "opt3": "It does not have any data members or member functions",
+        "opt4": "It can be created without a class definition",
+        "correct_option": "It is an instance of a class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following operators can be overloaded to provide custom member access behavior?",
+        "opt1": ".",
+        "opt2": "->",
+        "opt3": "::",
+        "opt4": ":",
+        "correct_option": "->",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the difference between the dot operator (.) and the arrow operator (->) in C++?",
+        "opt1": "The dot operator is used with pointers, while the arrow operator is used with objects.",
+        "opt2": "The dot operator is used to access static members, while the arrow operator is used to access non-static members.",
+        "opt3": "The dot operator is used to access non-static members, while the arrow operator is used with pointers to access non-static members.",
+        "opt4": "The dot operator is used to access public members, while the arrow operator is used to access private members.",
+        "correct_option": "The dot operator is used to access non-static members, while the arrow operator is used with pointers to access non-static members.",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which operator is used to access the members of an object in C++?",
+        "opt1": ".",
+        "opt2": "&",
+        "opt3": "->",
+        "opt4": "::",
+        "correct_option": ".",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which keyword is used to define a member function outside the class definition in C++?",
+        "opt1": "here",
+        "opt2": "that",
+        "opt3": "this",
+        "opt4": "none of the above",
+        "correct_option": "none of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is true about object-oriented programming in C++?",
+        "opt1": "It is a procedural programming language",
+        "opt2": "Objects encapsulate data and behavior",
+        "opt3": "It supports only single inheritance",
+        "opt4": "All of the above",
+        "correct_option": "Objects encapsulate data and behavior",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is true about a member function in C++?",
+        "opt1": "It can be defined inside or outside the class definition",
+        "opt2": "It can only be defined inside the class definition",
+        "opt3": "It can only be defined outside the class definition",
+        "opt4": "None of the above",
+        "correct_option": "It can be defined inside or outside the class definition",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which keyword is used to access the data members of an object inside a member function in C++?",
+        "opt1": "private",
+        "opt2": "public",
+        "opt3": "protected",
+        "opt4": "this",
+        "correct_option": "this",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is true about object creation in C++?",
+        "opt1": "It is done using the new operator",
+        "opt2": "It is done using the malloc() function",
+        "opt3": "It is done using the class constructor",
+        "opt4": "None of the above",
+        "correct_option": "It is done using the class constructor",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true about constructors in C++?",
+        "opt1": "They are used to allocate memory for objects",
+        "opt2": "They are used to initialize the data members of an object",
+        "opt3": "They are used to deallocate memory for objects",
+        "opt4": "None of the above",
+        "correct_option": "They are used to initialize the data members of an object",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is true about destructors in C++?",
+        "opt1": "They are used to allocate memory for objects",
+        "opt2": "They are used to initialize the data members of an object",
+        "opt3": "They are used to deallocate memory for objects",
+        "opt4": "None of the above",
+        "correct_option": "They are used to deallocate memory for objects",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true about static member functions in C++?",
+        "opt1": "They can access only static data members of a class",
+        "opt2": "They can access only non-static data members of a class",
+        "opt3": "They can access both static and non-static data members of a class",
+        "opt4": "None of the above",
+        "correct_option": "They can access only static data members of a class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a member function in C++?",
+        "opt1": "A function that can only be used outside of a class",
+        "opt2": "A function that belongs to a class",
+        "opt3": "A function that can only be used inside of a class",
+        "opt4": "A function that belongs to the global namespace",
+        "correct_option": "A function that belongs to a class",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How are member functions defined in C++?",
+        "opt1": "Inside the class definition",
+        "opt2": "Outside the class definition",
+        "opt3": "Both A and B",
+        "opt4": "Neither A nor B",
+        "correct_option": "Both A and B",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which keyword is used to define a member function outside of a class in C++?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "none of the above",
+        "correct_option": "none of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is a valid syntax for defining a member function outside of a class in C++?",
+        "opt1": "void MyClass::myFunction() {}",
+        "opt2": "MyClass: void myFunction() {}",
+        "opt3": "void myFunction() ::MyClass {}",
+        "opt4": "None of the above",
+        "correct_option": "void MyClass::myFunction() {}",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true about member functions in C++?",
+        "opt1": "They have access to the private data members of a class",
+        "opt2": "They can only access public data members of a class",
+        "opt3": "They cannot access any data members of a class",
+        "opt4": "None of the above",
+        "correct_option": "They have access to the private data members of a class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the implicit parameter in a member function in C++?",
+        "opt1": "A pointer to the object that called the function",
+        "opt2": "A pointer to the object that contains the function",
+        "opt3": "A pointer to the object that was passed as an argument to the function",
+        "opt4": "None of the above",
+        "correct_option": "A pointer to the object that called the function",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which keyword is used to access the implicit parameter in a member function in C++?",
+        "opt1": "this",
+        "opt2": "that",
+        "opt3": "here",
+        "opt4": "none of the above",
+        "correct_option": "this",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true about the this pointer in C++?",
+        "opt1": "It is a constant pointer",
+        "opt2": "It points to the object that called the member function",
+        "opt3": "It is an integer value that represents the memory address of the object",
+        "opt4": "None of the above",
+        "correct_option": "It points to the object that called the member function",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following is true about inline member functions in C++?",
+        "opt1": "They are defined outside the class definition",
+        "opt2": "They are always faster than non-inline member functions",
+        "opt3": "They are used for small functions that are called frequently",
+        "opt4": "None of the above",
+        "correct_option": "They are used for small functions that are called frequently",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true about const member functions in C++?",
+        "opt1": "They cannot modify the data members of a class",
+        "opt2": "They are declared using the const keyword after the parameter list",
+        "opt3": "They can only be used inside the class definition",
+        "opt4": "None of the above",
+        "correct_option": "They cannot modify the data members of a class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a member function in C++? (Repeated Question)",
+        "opt1": "A function that is defined inside a class definition",
+        "opt2": "A function that is defined outside a class definition",
+        "opt3": "A function that is not related to any class",
+        "opt4": "None of the above",
+        "correct_option": "A function that is defined inside a class definition",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How is a member function defined inside a class definition in C++?",
+        "opt1": "using the :: operator",
+        "opt2": "using the -> operator",
+        "opt3": "using the . operator",
+        "opt4": "using the function name and parameter list",
+        "correct_option": "using the function name and parameter list",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the purpose of the \"this\" pointer in C++?",
+        "opt1": "It points to the object on which the member function is called",
+        "opt2": "It points to the class definition",
+        "opt3": "It points to the current function",
+        "opt4": "None of the above",
+        "correct_option": "It points to the object on which the member function is called",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How is a member function defined outside a class definition in C++?",
+        "opt1": "using the function name and parameter list",
+        "opt2": "using the scope resolution operator and the class name",
+        "opt3": "using the class name and parameter list",
+        "opt4": "None of the above",
+        "correct_option": "using the scope resolution operator and the class name",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the syntax for calling a member function of an object in C++?",
+        "opt1": "object.member_function()",
+        "opt2": "object->member_function()",
+        "opt3": "both A and B",
+        "opt4": "None of the above",
+        "correct_option": "both A and B",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the default access specifier for a member function in C++?",
+        "opt1": "public",
+        "opt2": "private",
+        "opt3": "protected",
+        "opt4": "None of the above",
+        "correct_option": "private",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Can a member function be overloaded in C++?",
+        "opt1": "Yes",
+        "opt2": "No",
+        "opt3": "It depends on the access specifier",
+        "opt4": "None of the above",
+        "correct_option": "Yes",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a member function be declared inside a class definition and defined outside the class definition in C++?",
+        "opt1": "Yes",
+        "opt2": "No",
+        "opt3": "It depends on the access specifier",
+        "opt4": "None of the above",
+        "correct_option": "Yes",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a member function access the private data members of a class in C++?",
+        "opt1": "Yes",
+        "opt2": "No",
+        "opt3": "depends on the access specifier",
+        "opt4": "None of the above",
+        "correct_option": "Yes",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the const keyword in a member function declaration in C++?",
+        "opt1": "It indicates that the function is a constructor",
+        "opt2": "It indicates that the function is a destructor",
+        "opt3": "It indicates that the function does not modify the object on which it is called",
+        "opt4": "None of the above",
+        "correct_option": "It indicates that the function does not modify the object on which it is called",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is a constructor in C++?",
+        "opt1": "A function that is used to allocate memory for an object",
+        "opt2": "A function that is used to initialize the data members of an object",
+        "opt3": "A function that is used to deallocate memory for an object",
+        "opt4": "None of the above",
+        "correct_option": "A function that is used to initialize the data members of an object",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the name of the constructor function in C++?",
+        "opt1": "init()",
+        "opt2": "constructor()",
+        "opt3": "the same as the class name",
+        "opt4": "None of the above",
+        "correct_option": "the same as the class name",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "How many constructors can a class have in C++?",
+        "opt1": "Only one",
+        "opt2": "More than one",
+        "opt3": "It depends on the size of the class",
+        "opt4": "None of the above",
+        "correct_option": "More than one",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which type of constructor is called automatically when an object is created in C++?",
+        "opt1": "Copy constructor",
+        "opt2": "Parameterized constructor",
+        "opt3": "Default constructor",
+        "opt4": "None of the above",
+        "correct_option": "Default constructor",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the purpose of the copy constructor in C++?",
+        "opt1": "It is used to create a copy of an existing object",
+        "opt2": "It is used to allocate memory for an object",
+        "opt3": "It is used to delete an existing object",
+        "opt4": "None of the above",
+        "correct_option": "It is used to create a copy of an existing object",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a constructor be declared as private in C++?",
+        "opt1": "Yes",
+        "opt2": "No",
+        "opt3": "It depends on the type of constructor",
+        "opt4": "None of the above",
+        "correct_option": "Yes",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following is true about the default constructor in C++?",
+        "opt1": "It takes no arguments",
+        "opt2": "It has an empty body",
+        "opt3": "It is provided by the compiler if no other constructor is defined",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following is true about the parameterized constructor in C++?",
+        "opt1": "It takes no arguments",
+        "opt2": "It has an empty body",
+        "opt3": "It takes one or more arguments",
+        "opt4": "None of the above",
+        "correct_option": "It takes one or more arguments",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the syntax for calling a constructor in C++?",
+        "opt1": "class_name.constructor_name()",
+        "opt2": "class_name::constructor_name()",
+        "opt3": "class_name object_name(argument_list)",
+        "opt4": "None of the above",
+        "correct_option": "class_name object_name(argument_list)",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is true about the destructor in C++?",
+        "opt1": "It is used to allocate memory for an object",
+        "opt2": "It is used to deallocate memory for an object",
+        "opt3": "It is used to initialize the data members of an object",
+        "opt4": "None of the above",
+        "correct_option": "It is used to deallocate memory for an object",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the this pointer in C++?",
+        "opt1": "A pointer to the current object",
+        "opt2": "A pointer to the current function",
+        "opt3": "A pointer to the current class",
+        "opt4": "None of the above",
+        "correct_option": "A pointer to the current object",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the purpose of the this pointer in C++?",
+        "opt1": "To refer to the object's own data members",
+        "opt2": "To refer to a different object's data members",
+        "opt3": "To refer to a different function",
+        "opt4": "None of the above",
+        "correct_option": "To refer to the object's own data members",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the syntax for using the this pointer in C++?",
+        "opt1": "this->data_member;",
+        "opt2": "(*this).data_member",
+        "opt3": "Both A and B",
+        "opt4": "None of the above",
+        "correct_option": "Both A and B",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Can the this pointer be modified in C++?",
+        "opt1": "Yes, it can be modified like any other pointer",
+        "opt2": "No, it is a constant pointer",
+        "opt3": "It can be modified only within the same class",
+        "opt4": "None of above",
+        "correct_option": "No, it is a constant pointer",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the data type of the this pointer in C++?",
+        "opt1": "Class type pointer",
+        "opt2": "Integer pointer",
+        "opt3": "Void pointer",
+        "opt4": "None of the above",
+        "correct_option": "Class type pointer",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What happens if a member function does not use the this pointer in C++?",
+        "opt1": "It can cause a compile-time error",
+        "opt2": "It may still work, but it will not be able to access the object's data members",
+        "opt3": "The program will crash at runtime",
+        "opt4": "None of the above",
+        "correct_option": "None of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "How is the this pointer passed to a member function in C++?",
+        "opt1": "It is implicitly passed to the function",
+        "opt2": "It is passed as an argument to the function",
+        "opt3": "It is not passed to the function",
+        "opt4": "None of above",
+        "correct_option": "It is implicitly passed to the function",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the size of the this pointer in C++?",
+        "opt1": "It is always 4 bytes",
+        "opt2": "It is always 8 bytes",
+        "opt3": "It depends on the size of the object",
+        "opt4": "None of the above",
+        "correct_option": "It depends on the size of the object",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Can the this pointer be used in static member functions in C++?",
+        "opt1": "No, the this pointer is not applicable to static member functions",
+        "opt2": "Yes, but only if the static function takes an object as a parameter",
+        "opt3": "It can be used only within the same class",
+        "opt4": "None of above",
+        "correct_option": "No, the this pointer is not applicable to static member functions",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In which operator overload function can the this pointer be used in C++?",
+        "opt1": "Overloading the assignment operator",
+        "opt2": "Overloading the equality operator",
+        "opt3": "Both A and B",
+        "opt4": "None of the above",
+        "correct_option": "Both A and B",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is this pointer in C++?",
+        "opt1": "It is a pointer to the current object",
+        "opt2": "It is a pointer to the current function",
+        "opt3": "It is a pointer to the base class",
+        "opt4": "None of the above",
+        "correct_option": "It is a pointer to the current object",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "In which part of a C++ class is this pointer implicitly passed?",
+        "opt1": "Constructor",
+        "opt2": "Destructor",
+        "opt3": "Member functions",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the type of this pointer in C++?",
+        "opt1": "void",
+        "opt2": "int",
+        "opt3": "ClassName",
+        "opt4": "None of the above",
+        "correct_option": "ClassName",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following is a valid use of this pointer in C++?",
+        "opt1": "To access member variables of the current object",
+        "opt2": "To access member functions of the current object",
+        "opt3": "To access static variables of the current object",
+        "opt4": "All of the above",
+        "correct_option": "All of the above",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the purpose of this pointer in C++?",
+        "opt1": "To resolve naming conflicts between member variables and parameters of a function",
+        "opt2": "To access private member variables of a class",
+        "opt3": "To access static member variables of a class",
+        "opt4": "None of the above",
+        "correct_option": "To resolve naming conflicts between member variables and parameters of a function",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about this pointer in C++?",
+        "opt1": "It can be modified by the programmer",
+        "opt2": "It cannot be modified by the programmer",
+        "opt3": "It can be null",
+        "opt4": "None of the above",
+        "correct_option": "It cannot be modified by the programmer",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What happens if this pointer is dereferenced when it is null?",
+        "opt1": "A compile-time error occurs",
+        "opt2": "A runtime error occurs",
+        "opt3": "Undefined behavior occurs",
+        "opt4": "None of the above",
+        "correct_option": "Undefined behavior occurs",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "What is the use of this pointer in operator overloading in C++?",
+        "opt1": "To overload the -> operator",
+        "opt2": "To overload the . operator",
+        "opt3": "Both A and B",
+        "opt4": "None of the above",
+        "correct_option": "To overload the -> operator",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the output of the following code?",
+        "opt1": "The address of obj1 and obj2 are the same",
+        "opt2": "The address of obj1 and obj2 are different",
+        "opt3": "The program will not compile",
+        "opt4": "The program will crash at runtime",
+        "correct_option": "The address of obj1 and obj2 are different",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is a static data member in C++?",
+        "opt1": "A data member that is unique to each instance of a class",
+        "opt2": "A data member that is shared among all instances of a class",
+        "opt3": "A data member that can be accessed only by static functions",
+        "opt4": "A data member that cannot be accessed from outside the class",
+        "correct_option": "A data member that is shared among all instances of a class",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How is a static data member declared in C++?",
+        "opt1": "Using the keyword static before the data type",
+        "opt2": "Using the keyword static before the class name",
+        "opt3": "Using the keyword static after the data type",
+        "opt4": "None of the above",
+        "correct_option": "Using the keyword static before the data type",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about the default initial value of static data members in C++?",
+        "opt1": "They are not initialized by default",
+        "opt2": "They are initialized to 0 by default",
+        "opt3": "They are initialized to 1 by default",
+        "opt4": "None of the above",
+        "correct_option": "They are initialized to 0 by default",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How is a static function declared in C++?",
+        "opt1": "Using the keyword static before the return type",
+        "opt2": "Using the keyword static before the function name",
+        "opt3": "Using the keyword static after the return type",
+        "opt4": "None of the above",
+        "correct_option": "Using the keyword static before the return type",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about static functions in C++?",
+        "opt1": "They can access only static data members of the class",
+        "opt2": "They can access only non-static data members of the class",
+        "opt3": "They cannot access any data members of the class",
+        "opt4": "None of the above",
+        "correct_option": "They can access only static data members of the class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a static function in C++ access non-static data members of the class?",
+        "opt1": "Yes, using the this pointer",
+        "opt2": "Yes, using the static_cast operator",
+        "opt3": "No, static functions cannot access non-static data members",
+        "opt4": "None of the above",
+        "correct_option": "No, static functions cannot access non-static data members",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following statements is true about where a static data member of a C++ class must be initialized?",
+        "opt1": "They can be initialized inside the class definition",
+        "opt2": "They must be initialized inside the class definition",
+        "opt3": "They can be initialized only outside the class definition",
+        "opt4": "None of the above",
+        "correct_option": "They can be initialized only outside the class definition",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following statements is true about static functions in C++?",
+        "opt1": "They cannot access non-static data members",
+        "opt2": "They can access non-static data members",
+        "opt3": "They can be virtual",
+        "opt4": "They can be called using an instance of the class",
+        "correct_option": "They cannot access non-static data members",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about how static data members in C++ can be accessed?",
+        "opt1": "They can be accessed using the object of the class",
+        "opt2": "They can be accessed using the class name and the scope resolution operator",
+        "opt3": "They can be accessed using the pointer to the object of the class",
+        "opt4": "All of the above are true",
+        "correct_option": "All of the above are true",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "What is the output of the following code? (Code involves MyClass::count++, incrementCount called twice)",
+        "opt1": "Count: 2",
+        "opt2": "Count: 0",
+        "opt3": "Count: 1",
+        "opt4": "None of the above",
+        "correct_option": "Count: 2",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a static data member in C++?",
+        "opt1": "A data member that can be accessed only by static functions",
+        "opt2": "A data member that belongs to the class and not to any instance of the class",
+        "opt3": "A data member that is created dynamically at runtime",
+        "opt4": "None of the above",
+        "correct_option": "A data member that belongs to the class and not to any instance of the class",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How is a static data member declared In C++?",
+        "opt1": "With the keyword 'static' and the name of the member",
+        "opt2": "With the keyword 'static' and the data type of the member",
+        "opt3": "With the keyword 'static' and the access specifier of the member",
+        "opt4": "None of the above",
+        "correct_option": "With the keyword 'static' and the data type of the member",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following statements is true about static data members in C++?",
+        "opt1": "They are initialized to zero by default",
+        "opt2": "They cannot be initialized inside the class declaration",
+        "opt3": "They are initialized to their default values by default",
+        "opt4": "None of the above",
+        "correct_option": "They are initialized to zero by default",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a static function in C++?",
+        "opt1": "A function that can be accessed only by static data members",
+        "opt2": "A function that belongs to the class and not to any instance of the class",
+        "opt3": "A function that is created dynamically at runtime",
+        "opt4": "None of the above",
+        "correct_option": "A function that belongs to the class and not to any instance of the class",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "How is a static function declared in C++?",
+        "opt1": "With the keyword 'static' and the return type of the function",
+        "opt2": "With the keyword 'static' and the access specifier of the function",
+        "opt3": "With the keyword 'static' and the name of the function",
+        "opt4": "None of the above",
+        "correct_option": "With the keyword 'static' and the return type of the function",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about static functions in C++?",
+        "opt1": "They can be virtual",
+        "opt2": "They cannot be virtual",
+        "opt3": "They can be pure virtual",
+        "opt4": "None of the above",
+        "correct_option": "They cannot be virtual",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is the purpose of static data members and static functions in C++?",
+        "opt1": "To save memory by sharing data across all instances of the class",
+        "opt2": "To make the code more modular and easier to maintain",
+        "opt3": "To create multiple instances of the class with different data",
+        "opt4": "None of the above",
+        "correct_option": "To save memory by sharing data across all instances of the class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about the scope of a static data member in C++?",
+        "opt1": "It has class scope and can be accessed using the class name and the scope resolution operator (::)",
+        "opt2": "It has instance scope and can be accessed using the instance name and the dot operator (.)",
+        "opt3": "It has global scope and can be accessed from any part of the program",
+        "opt4": "None of the above",
+        "correct_option": "It has class scope and can be accessed using the class name and the scope resolution operator (::)",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about the initialization of a static data member in C++?",
+        "opt1": "It can be initialized Inside the class declaration using an assignment statement",
+        "opt2": "It must be initialized outside the class declaration using an assignment statement",
+        "opt3": "It cannot be initialized",
+        "opt4": "None of the above",
+        "correct_option": "It must be initialized outside the class declaration using an assignment statement",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "What is a constant member function in C++?",
+        "opt1": "A member function that cannot modify any data members of the class",
+        "opt2": "A member function that can modify any data members of the class",
+        "opt3": "A member function that cannot be called by const objects of the class",
+        "opt4": "None of the above",
+        "correct_option": "A member function that cannot modify any data members of the class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How is a constant member function declared in C++?",
+        "opt1": "Using the keyword const after the function declaration",
+        "opt2": "Using the keyword const before the function declaration",
+        "opt3": "Using the keyword const before the return type",
+        "opt4": "None of the above",
+        "correct_option": "Using the keyword const after the function declaration",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about constant member functions in C++?",
+        "opt1": "They can be called only by constant objects of the class",
+        "opt2": "They can be called only by non-constant objects of the class",
+        "opt3": "They can be called by both constant and non-constant objects of the class",
+        "opt4": "None of the above",
+        "correct_option": "They can be called by both constant and non-constant objects of the class",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Can a constant member function modify a static data member of the class?",
+        "opt1": "Yes, as long as the static data member is declared as mutable",
+        "opt2": "Yes, as long as the static data member is declared as const",
+        "opt3": "No, constant member functions cannot modify any data members of the class",
+        "opt4": "Yes, because static members are not part of the object's state",
+        "correct_option": "Yes, because static members are not part of the object's state",
+        "correct_option_index": 4
+    },
+    {
+        "qsns": "Which of the following statements is true about constant objects in C++?",
+        "opt1": "They cannot modify any data members of the class",
+        "opt2": "They can modify only constant data members of the class",
+        "opt3": "They can modify any data members of the class",
+        "opt4": "None of the above",
+        "correct_option": "They cannot modify any data members of the class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "How is a constant object declared in C++?",
+        "opt1": "Using the keyword const before the object name",
+        "opt2": "Using the keyword const after the object name",
+        "opt3": "Using the keyword const before the class name",
+        "opt4": "None of the above",
+        "correct_option": "Using the keyword const before the object name",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about constant member functions in C++? (Overloading)",
+        "opt1": "They can be overloaded with non-constant member functions of the same name",
+        "opt2": "They cannot be overloaded with non-constant member functions of the same name",
+        "opt3": "They can be overloaded only with other constant member functions of the same name",
+        "opt4": "None of the above",
+        "correct_option": "They can be overloaded with non-constant member functions of the same name",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the output of the following code? (const MyClass obj = {5}; obj.value = 10;)",
+        "opt1": "5 followed by a compilation error",
+        "opt2": "5 followed by 10",
+        "opt3": "Compilation error followed by 5",
+        "opt4": "None of the above",
+        "correct_option": "5 followed by a compilation error",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is a constant member function in C++?",
+        "opt1": "A member function that cannot be modified",
+        "opt2": "A member function that can be called on a constant object only",
+        "opt3": "A member function that does not have any return type",
+        "opt4": "None of the above",
+        "correct_option": "A member function that cannot be modified",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about constant objects in C++?",
+        "opt1": "They cannot modify the data members of the class",
+        "opt2": "They can modify the data members of the class",
+        "opt3": "They can modify the data members of the class only if they are declared mutable",
+        "opt4": "None of the above",
+        "correct_option": "They cannot modify the data members of the class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Can a non-constant member function be called on a constant object in C++?",
+        "opt1": "Yes, but only if the function does not modify any data members of the class",
+        "opt2": "No, a non-constant member function cannot be called on a constant object",
+        "opt3": "Yes, but only if the function is declared const",
+        "opt4": "None of the above",
+        "correct_option": "No, a non-constant member function cannot be called on a constant object",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following statements is true about constant objects in C++?",
+        "opt1": "They can be created using the const keyword before the class name",
+        "opt2": "They can be created using the const keyword after the object name",
+        "opt3": "They can be created using the const keyword before the object name",
+        "opt4": "None of the above",
+        "correct_option": "They can be created using the const keyword before the object name",
+        "correct_option_index": 3
+    },
+    {
+        "qsns": "Which of the following statements is true about constant objects in C++?",
+        "opt1": "They can call non-constant member functions of the class",
+        "opt2": "They cannot call non-constant member functions of the class",
+        "opt3": "They can call non-constant member functions of the class only if the functions are declared const",
+        "opt4": "None of the above",
+        "correct_option": "They cannot call non-constant member functions of the class",
+        "correct_option_index": 2
+    },
+    {
+        "qsns": "Which of the following statements is true about constant objects in C++?",
+        "opt1": "They can access only constant member functions of the class",
+        "opt2": "They can access only non-constant member functions of the class",
+        "opt3": "They can access both constant and non-constant member functions of the class",
+        "opt4": "None of the above",
+        "correct_option": "They can access only constant member functions of the class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "Which of the following statements is true about constant member functions in C++? (Duplicate logic)",
+        "opt1": "They cannot modify the data members of the class",
+        "opt2": "They can modify the data members of the class only if they are declared mutable",
+        "opt3": "They can modify the data members of the class",
+        "opt4": "None of the above",
+        "correct_option": "They cannot modify the data members of the class",
+        "correct_option_index": 1
+    },
+    {
+        "qsns": "What is the output of the following code? (const MyClass obj = {10}; obj.printValue();)",
+        "opt1": "Value: 10",
+        "opt2": "Value: 0",
+        "opt3": "The code will not compile because the object is declared const",
+        "opt4": "None of the above",
+        "correct_option": "Value: 10",
+        "correct_option_index": 1
+    }
+]
diff --git a/frontend/public/data/books/ch4.json b/frontend/public/data/books/ch4.json
index d40f7b9..03da0fe 100644
--- a/frontend/public/data/books/ch4.json
+++ b/frontend/public/data/books/ch4.json
@@ -512,7 +512,6 @@
     "correct_option": "Mutex is owned by a thread and only that thread can release it",
     "correct_option_index": 3
   },
-  
   {
     "qsns": "What is the main purpose of the Memory Control Unit (MCU) in a computer system?",
     "opt1": "To store instructions that the CPU can execute",
@@ -855,15 +854,6 @@
     "correct_option": "Logic gates and flip-flops",
     "correct_option_index": 2
   },
-  {
-    "qsns": "Which of the following is not a component of a control unit?",
-    "opt1": "Instruction register",
-    "opt2": "Control register",
-    "opt3": "Decoder",
-    "opt4": "Arithmetic logic unit",
-    "correct_option": "Arithmetic logic unit",
-    "correct_option_index": 4
-  },
   {
     "qsns": "The control unit is responsible for:",
     "opt1": "Fetching instructions from memory",
@@ -2439,15 +2429,6 @@
     "correct_option": "Cycle-stealing",
     "correct_option_index": 1
   },
-  {
-    "qsns": "What is the purpose of DMA in a computer system?",
-    "opt1": "To manage the memory",
-    "opt2": "To control the CPU",
-    "opt3": "To communicate with peripheral devices",
-    "opt4": "To transfer data between memory and peripheral devices without CPU intervention",
-    "correct_option": "To transfer data between memory and peripheral devices without CPU intervention",
-    "correct_option_index": 4
-  },
   {
     "qsns": "Which of the following is not a mode of transfer used by DMA?",
     "opt1": "Cycle stealing",
@@ -3267,9 +3248,6 @@
     "correct_option": "They are optimized for a specific application.",
     "correct_option_index": 3
   },
-
-
-
   {
     "qsns": "What is the primary advantage of using a custom single-purpose processor over a general-purpose processor in an embedded system?",
     "opt1": "Lower power consumption",
diff --git a/frontend/public/data/books/ch7.json b/frontend/public/data/books/ch7.json
index 2bcf53d..cf6460a 100644
--- a/frontend/public/data/books/ch7.json
+++ b/frontend/public/data/books/ch7.json
@@ -404,15 +404,6 @@
     "correct_option": "Only one process can access a shared resource at a time",
     "correct_option_index": 2
   },
-  {
-    "qsns": "A semaphore is used for:",
-    "opt1": "Process creation",
-    "opt2": "Memory allocation",
-    "opt3": "Process synchronization",
-    "opt4": "File management",
-    "correct_option": "Process synchronization",
-    "correct_option_index": 3
-  },
   {
     "qsns": "The difference between a mutex and a semaphore is:",
     "opt1": "A mutex can only be used for mutual exclusion, while a semaphore can be used for both mutual exclusion and synchronization",
@@ -620,4 +611,4 @@
     "correct_option": "Merge Sort",
     "correct_option_index": 4
   }
-]
\ No newline at end of file
+]
diff --git a/frontend/public/data/books/ch8.json b/frontend/public/data/books/ch8.json
index fea1ea6..65b7899 100644
--- a/frontend/public/data/books/ch8.json
+++ b/frontend/public/data/books/ch8.json
@@ -800,15 +800,6 @@
     "correct_option": "Users",
     "correct_option_index": 3
   },
-  {
-    "qsns": "The testing in which code is checked",
-    "opt1": "Black box testing",
-    "opt2": "White box testing",
-    "opt3": "Red box testing",
-    "opt4": "Green box testing",
-    "correct_option": "White box testing",
-    "correct_option_index": 2
-  },
   {
     "qsns": "Testing done without planning and Documentation is called",
     "opt1": "Unit testing",
@@ -1178,4 +1169,4 @@
     "correct_option": "Cyclomatic Complexity",
     "correct_option_index": 4
   }
-]
\ No newline at end of file
+]
diff --git a/frontend/public/icons/icon-192.png b/frontend/public/icons/icon-192.png
new file mode 100644
index 0000000..0c88043
Binary files /dev/null and b/frontend/public/icons/icon-192.png differ
diff --git a/frontend/public/icons/icon-512.png b/frontend/public/icons/icon-512.png
new file mode 100644
index 0000000..376e83d
Binary files /dev/null and b/frontend/public/icons/icon-512.png differ
diff --git a/frontend/public/icons/maskable-192.png b/frontend/public/icons/maskable-192.png
new file mode 100644
index 0000000..bcb948d
Binary files /dev/null and b/frontend/public/icons/maskable-192.png differ
diff --git a/frontend/public/icons/maskable-512.png b/frontend/public/icons/maskable-512.png
new file mode 100644
index 0000000..23b95dd
Binary files /dev/null and b/frontend/public/icons/maskable-512.png differ
diff --git a/frontend/public/icons/maskable.svg b/frontend/public/icons/maskable.svg
new file mode 100644
index 0000000..f19efc8
--- /dev/null
+++ b/frontend/public/icons/maskable.svg
@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <rect width="100" height="100" fill="#4F46E5"/>
+  <g transform="translate(13,12) scale(2)">
+    <path d="M16 9 C13 9 10 10 8 11.5 L8 23 C10 21.5 13 21 16 21 C19 21 22 21.5 24 23 L24 11.5 C22 10 19 9 16 9Z" fill="none" stroke="white" stroke-width="1.5" stroke-linejoin="round"/>
+    <line x1="16" y1="9" x2="16" y2="21" stroke="white" stroke-width="1.5"/>
+    <circle cx="11" cy="15" r="1" fill="white" opacity="0.7"/>
+    <circle cx="13.5" cy="13" r="1" fill="white" opacity="0.7"/>
+    <line x1="11" y1="15" x2="13.5" y2="13" stroke="white" stroke-width="0.8" opacity="0.7"/>
+    <circle cx="24" cy="24" r="5" fill="#22C55E"/>
+    <polyline points="21.5,24 23.2,25.8 26.5,22.5" fill="none" stroke="white" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+  </g>
+</svg>
diff --git a/frontend/src/App.css b/frontend/src/App.css
index 4cc266c..bf6babe 100644
--- a/frontend/src/App.css
+++ b/frontend/src/App.css
@@ -32,15 +32,7 @@ body {
 }
 
 /* ===== Loading Screen ===== */
-.loading-screen {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  height: 100vh;
-  background: var(--bg-primary);
-  gap: 1rem;
-}
+
 
 .loading-spinner {
   width: 50px;
@@ -91,21 +83,9 @@ body {
   background-clip: text;
 }
 
-.btn-signin {
-  padding: 0.75rem 1.5rem;
-  background: transparent;
-  border: 1px solid var(--accent-primary);
-  color: var(--accent-primary);
-  border-radius: 8px;
-  cursor: pointer;
-  font-weight: 500;
-  transition: all 0.3s ease;
-}
 
-.btn-signin:hover {
-  background: var(--accent-primary);
-  color: white;
-}
+
+
 
 /* ===== Hero Section ===== */
 .landing-page {
@@ -332,14 +312,39 @@ body {
   font-size: 0.95rem;
 }
 
-/* ===== Stats Section ===== */
+/* ===== Stats / Goals Section ===== */
 .stats-section {
   padding: 4rem 2rem;
 }
 
-.stats-container {
+.stats-wrapper {
   max-width: 1000px;
   margin: 0 auto;
+}
+
+.stats-eyebrow {
+  margin: 0 0 1rem;
+  text-align: center;
+  font-size: 0.8rem;
+  font-weight: 600;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--text-secondary);
+}
+
+.stats-live {
+  margin: 1.25rem auto 0;
+  text-align: center;
+  font-size: 0.9rem;
+  color: var(--text-secondary);
+}
+
+.stats-live strong {
+  color: var(--text-primary);
+  font-weight: 600;
+}
+
+.stats-container {
   display: flex;
   justify-content: center;
   align-items: center;
@@ -437,119 +442,35 @@ body {
 }
 
 /* ===== Sign In Page ===== */
-.signin-page {
-  min-height: 100vh;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding: 2rem;
-}
 
-.signin-container {
-  width: 100%;
-  max-width: 450px;
-  z-index: 10;
-}
 
-.signin-card {
-  padding: 3rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 24px;
-  backdrop-filter: blur(20px);
-}
 
-.signin-logo {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.75rem;
-  margin-bottom: 2rem;
-}
 
-.signin-logo-text {
-  font-size: 1.75rem;
-  font-weight: 700;
-  background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
-}
 
-.signin-welcome {
-  text-align: center;
-  margin-bottom: 2rem;
-}
 
-.signin-welcome h2 {
-  font-size: 1.5rem;
-  font-weight: 600;
-  margin-bottom: 0.5rem;
-}
 
-.signin-welcome p {
-  color: var(--text-secondary);
-}
 
-.btn-google {
-  width: 100%;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 0.75rem;
-  padding: 1rem;
-  background: white;
-  color: #333;
-  border: none;
-  border-radius: 12px;
-  font-size: 1rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: all 0.3s ease;
-}
 
-.google-icon {
-  width: 24px;
-  height: 24px;
-}
 
-.signin-divider {
-  text-align: center;
-  margin: 2rem 0;
-  color: var(--text-muted);
-  font-size: 0.85rem;
-}
 
-.signin-features {
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-  margin-bottom: 2rem;
-}
 
-.signin-feature {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  font-size: 0.9rem;
-  color: var(--text-secondary);
-}
 
-.feature-check {
-  color: var(--accent-green);
-  font-weight: 600;
-}
 
-.btn-back {
-  width: 100%;
-  padding: 0.75rem;
-  background: transparent;
-  border: none;
-  color: var(--text-secondary);
-  font-size: 0.9rem;
-  cursor: pointer;
-  transition: all 0.3s ease;
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /* ===== Dashboard Page ===== */
 .dashboard-page {
@@ -612,38 +533,18 @@ body {
   gap: 0.5rem;
 }
 
-.nav-item {
-  display: flex;
-  align-items: center;
-  gap: 1rem;
-  padding: 0.875rem 1rem;
-  background: transparent;
-  border: none;
-  border-radius: 10px;
-  color: var(--text-secondary);
-  font-size: 0.95rem;
-  cursor: pointer;
-  transition: all 0.3s ease;
-  white-space: nowrap;
-}
 
-.nav-item:hover {
-  color: var(--text-primary);
-}
 
-.nav-item.active {
-  background: rgba(99, 102, 241, 0.15);
-  color: var(--accent-primary);
-}
+
+
+
 
 .sidebar-footer {
   padding: 1rem;
   border-top: 1px solid var(--border-color);
 }
 
-.nav-item.logout:hover {
-  color: #ef4444;
-}
+
 
 /* Main Content */
 .main-content {
@@ -657,23 +558,9 @@ body {
 }
 
 /* Top Bar */
-.top-bar {
-  position: sticky;
-  top: 0;
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: 1rem 2rem;
-  background: rgba(10, 10, 15, 0.9);
-  backdrop-filter: blur(20px);
-  border-bottom: 1px solid var(--border-color);
-  z-index: 50;
-}
 
-.search-container {
-  flex: 1;
-  max-width: 400px;
-}
+
+
 
 .search-input {
   width: 100%;
@@ -695,36 +582,13 @@ body {
   color: var(--text-muted);
 }
 
-.top-bar-actions {
-  display: flex;
-  align-items: center;
-  gap: 1rem;
-}
 
-.icon-btn {
-  padding: 0.625rem;
-  background: var(--bg-secondary);
-  border: 1px solid var(--border-color);
-  border-radius: 10px;
-  color: var(--text-secondary);
-  cursor: pointer;
-  transition: all 0.3s ease;
-}
 
-.icon-btn:hover {
-  border-color: var(--accent-primary);
-  color: var(--accent-primary);
-}
 
-.user-profile {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  padding: 0.5rem 1rem 0.5rem 0.5rem;
-  background: var(--bg-secondary);
-  border: 1px solid var(--border-color);
-  border-radius: 50px;
-}
+
+
+
+
 
 .user-avatar {
   width: 32px;
@@ -750,21 +614,10 @@ body {
 }
 
 /* Page Content */
-.page-content {
-  padding: 2rem;
-  max-width: 1400px;
-  margin: 0 auto;
-}
+
 
 /* Welcome Section */
-.welcome-section {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  margin-bottom: 2rem;
-  flex-wrap: wrap;
-  gap: 1rem;
-}
+
 
 .welcome-text h1 {
   font-size: 1.75rem;
@@ -808,30 +661,15 @@ body {
   border-radius: 12px;
 }
 
-.stat-icon-purple {
-  background: rgba(99, 102, 241, 0.15);
-  color: var(--accent-primary);
-}
 
-.stat-icon-green {
-  background: rgba(34, 197, 94, 0.15);
-  color: var(--accent-green);
-}
 
-.stat-icon-yellow {
-  background: rgba(251, 191, 36, 0.15);
-  color: var(--accent-yellow);
-}
 
-.stat-icon-pink {
-  background: rgba(236, 72, 153, 0.15);
-  color: var(--accent-pink);
-}
 
-.stat-info {
-  display: flex;
-  flex-direction: column;
-}
+
+
+
+
+
 
 .stat-card .stat-value {
   font-size: 1.75rem;
@@ -854,11 +692,7 @@ body {
   margin-bottom: 1.25rem;
 }
 
-.action-cards {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-  gap: 1.5rem;
-}
+
 
 .action-card {
   position: relative;
@@ -868,23 +702,13 @@ body {
   overflow: hidden;
 }
 
-.action-study {
-  background: linear-gradient(135deg, rgba(99, 102, 241, 0.2), rgba(139, 92, 246, 0.1));
-  border: 1px solid rgba(99, 102, 241, 0.3);
-}
 
-.action-study svg {
-  color: var(--accent-primary);
-}
 
-.action-practice {
-  background: linear-gradient(135deg, rgba(6, 182, 212, 0.2), rgba(34, 197, 94, 0.1));
-  border: 1px solid rgba(6, 182, 212, 0.3);
-}
 
-.action-practice svg {
-  color: var(--accent-cyan);
-}
+
+
+
+
 
 .action-card h3 {
   font-size: 1.25rem;
@@ -908,9 +732,7 @@ body {
 }
 
 /* Progress Section */
-.progress-section {
-  margin-bottom: 2.5rem;
-}
+
 
 .section-header {
   display: flex;
@@ -924,21 +746,9 @@ body {
   font-weight: 600;
 }
 
-.btn-view-all {
-  padding: 0.5rem 1rem;
-  background: transparent;
-  border: 1px solid var(--border-color);
-  border-radius: 8px;
-  color: var(--text-secondary);
-  font-size: 0.85rem;
-  cursor: pointer;
-  transition: all 0.3s ease;
-}
 
-.btn-view-all:hover {
-  border-color: var(--accent-primary);
-  color: var(--accent-primary);
-}
+
+
 
 .progress-grid {
   display: grid;
@@ -976,75 +786,31 @@ body {
   transition: width 0.5s ease;
 }
 
-.progress-info {
-  display: flex;
-  justify-content: space-between;
-  font-size: 0.8rem;
-  color: var(--text-muted);
-}
+
 
 /* Activity Section */
-.activity-section {
-  margin-bottom: 2rem;
-}
 
-.activity-list {
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-}
 
-.activity-item {
-  display: flex;
-  align-items: center;
-  gap: 1rem;
-  padding: 1rem 1.25rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 12px;
-}
 
-.activity-icon {
-  padding: 0.625rem;
-  border-radius: 10px;
-}
 
-.activity-icon.practice {
-  background: rgba(6, 182, 212, 0.15);
-  color: var(--accent-cyan);
-}
 
-.activity-icon.study {
-  background: rgba(99, 102, 241, 0.15);
-  color: var(--accent-primary);
-}
 
-.activity-details {
-  flex: 1;
-  display: flex;
-  flex-direction: column;
-}
 
-.activity-title {
-  font-weight: 500;
-  font-size: 0.9rem;
-}
 
-.activity-meta {
-  color: var(--text-muted);
-  font-size: 0.8rem;
-}
 
-.activity-time {
-  color: var(--text-muted);
-  font-size: 0.8rem;
-}
+
+
+
+
+
+
+
+
+
+
 
 /* Study & Practice Content */
-.study-content,
-.practice-content {
-  animation: fadeIn 0.3s ease;
-}
+
 
 @keyframes fadeIn {
   from { opacity: 0; transform: translateY(10px); }
@@ -1068,79 +834,23 @@ body {
   color: var(--text-secondary);
 }
 
-.subjects-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-  gap: 1.25rem;
-}
 
-.subject-card {
-  padding: 1.5rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 16px;
-  cursor: pointer;
-  transition: all 0.3s ease;
-}
 
-.subject-icon {
-  display: inline-flex;
-  padding: 0.875rem;
-  background: rgba(99, 102, 241, 0.15);
-  border-radius: 12px;
-  color: var(--accent-primary);
-  margin-bottom: 1rem;
-}
 
-.subject-card h3 {
-  font-size: 1rem;
-  font-weight: 600;
-  margin-bottom: 1rem;
-  line-height: 1.4;
-}
 
-.subject-progress {
-  margin-bottom: 1rem;
-}
 
-.subject-progress span {
-  display: block;
-  color: var(--text-muted);
-  font-size: 0.8rem;
-  margin-top: 0.5rem;
-}
 
-.subject-stats {
-  display: flex;
-  gap: 0.5rem;
-  color: var(--text-muted);
-  font-size: 0.85rem;
-  margin-bottom: 1rem;
-}
 
-.btn-continue,
-.btn-practice {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 0.5rem;
-  width: 100%;
-  padding: 0.75rem;
-  background: transparent;
-  border: 1px solid var(--accent-primary);
-  border-radius: 10px;
-  color: var(--accent-primary);
-  font-size: 0.9rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: all 0.3s ease;
-}
 
-.btn-continue:hover,
-.btn-practice:hover {
-  background: var(--accent-primary);
-  color: white;
-}
+
+
+
+
+
+
+
+
+
 
 /* Practice Modes */
 .practice-modes {
@@ -1167,14 +877,9 @@ body {
   color: var(--accent-yellow);
 }
 
-.mode-full {
-  background: linear-gradient(135deg, rgba(99, 102, 241, 0.15), rgba(139, 92, 246, 0.05));
-  border: 1px solid rgba(99, 102, 241, 0.3);
-}
 
-.mode-full svg {
-  color: var(--accent-primary);
-}
+
+
 
 .mode-custom {
   background: linear-gradient(135deg, rgba(236, 72, 153, 0.15), rgba(219, 39, 119, 0.05));
@@ -1213,11 +918,7 @@ body {
   border-color: rgba(255, 255, 255, 0.3);
 }
 
-.subject-practice h2 {
-  font-size: 1.25rem;
-  font-weight: 600;
-  margin-bottom: 1.5rem;
-}
+
 
 /* Responsive Styles */
 @media (max-width: 1024px) {
@@ -1260,22 +961,13 @@ body {
     padding: 1rem;
   }
   
-  .page-content {
-    padding: 1.5rem 1rem;
-  }
   
-  .top-bar {
-    padding: 1rem;
-  }
   
-  .search-container {
-    display: none;
-  }
   
-  .welcome-section {
-    flex-direction: column;
-    align-items: flex-start;
-  }
+  
+  
+  
+  
 }
 
 /* ===== Screen Reader Only ===== */
@@ -1292,293 +984,91 @@ body {
 }
 
 /* ===== Auth Loading Screen ===== */
-.auth-loading-screen {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 100vh;
-  background: var(--bg-primary);
-}
 
-.auth-loading-content {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 1.5rem;
-}
 
-.auth-loading-spinner {
-  width: 48px;
-  height: 48px;
-  color: var(--accent-primary);
-}
 
-.spinner-svg {
-  animation: spin 1s linear infinite;
-}
 
-.auth-loading-text {
-  color: var(--text-secondary);
-  font-size: 0.95rem;
-}
+
+
+
+
+
 
 /* ===== Login Page ===== */
-.login-page {
-  min-height: 100vh;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding: 2rem;
-  background: var(--bg-primary);
-}
 
-.login-container {
-  width: 100%;
-  max-width: 420px;
-}
 
-.login-card {
-  padding: 2.5rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 20px;
-}
 
-.login-logo {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.5rem;
-  margin-bottom: 2rem;
-  text-decoration: none;
-  color: inherit;
-}
 
-.login-logo-icon {
-  width: 48px;
-  height: 48px;
-  color: var(--accent-primary);
-}
 
-.login-logo-text {
-  font-size: 1.5rem;
-  font-weight: 700;
-  background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
-}
 
-.login-header {
-  text-align: center;
-  margin-bottom: 2rem;
-}
 
-.login-header h1 {
-  font-size: 1.5rem;
-  font-weight: 600;
-  margin-bottom: 0.5rem;
-}
 
-.login-header p {
-  color: var(--text-secondary);
-  font-size: 0.95rem;
-}
 
-.login-loading {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 300px;
-}
 
-.login-spinner {
-  width: 40px;
-  height: 40px;
-  border: 3px solid var(--border-color);
-  border-top-color: var(--accent-primary);
-  border-radius: 50%;
-  animation: spin 1s linear infinite;
-}
 
-/* Login Error */
-.login-error {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  padding: 1rem;
-  margin-bottom: 1.5rem;
-  background: rgba(239, 68, 68, 0.1);
-  border: 1px solid rgba(239, 68, 68, 0.3);
-  border-radius: 12px;
-  font-size: 0.9rem;
-  color: #fca5a5;
-}
 
-.login-error-icon {
-  flex-shrink: 0;
-  width: 20px;
-  height: 20px;
-}
 
-.login-error-dismiss {
-  flex-shrink: 0;
-  padding: 0.25rem;
-  background: transparent;
-  border: none;
-  color: inherit;
-  cursor: pointer;
-  opacity: 0.7;
-  transition: opacity 0.2s;
-}
 
-.login-error-dismiss:hover {
-  opacity: 1;
-}
 
-.login-error-dismiss svg {
-  width: 16px;
-  height: 16px;
-}
 
-/* Login Google Button */
-.login-btn-google {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 0.75rem;
-  width: 100%;
-  padding: 0.875rem 1rem;
-  background: white;
-  border: none;
-  border-radius: 12px;
-  color: #333;
-  font-size: 1rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: all 0.2s;
-}
 
-.login-btn-google:hover:not(:disabled) {
-  background: #f5f5f5;
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
-}
 
-.login-btn-google:disabled {
-  opacity: 0.7;
-  cursor: not-allowed;
-}
 
-.login-google-icon {
-  width: 20px;
-  height: 20px;
-}
 
-.login-btn-spinner {
-  width: 20px;
-  height: 20px;
-  border: 2px solid #ddd;
-  border-top-color: #333;
-  border-radius: 50%;
-  animation: spin 1s linear infinite;
-}
 
-.login-btn-redirect {
-  display: block;
-  width: 100%;
-  margin-top: 0.75rem;
-  padding: 0.75rem;
-  background: transparent;
-  border: 1px solid var(--border-color);
-  border-radius: 10px;
-  color: var(--text-secondary);
-  font-size: 0.9rem;
-  cursor: pointer;
-  transition: all 0.2s;
-}
 
-.login-btn-redirect:hover {
-  border-color: var(--accent-primary);
-  color: var(--accent-primary);
-}
+/* Login Error */
+
+
+
+
+
+
+
+
+
+
+/* Login Google Button */
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /* Login Security Note */
-.login-security-note {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 0.5rem;
-  margin: 1.5rem 0;
-  color: var(--text-muted);
-  font-size: 0.8rem;
-}
 
-.login-security-icon {
-  width: 14px;
-  height: 14px;
-}
+
+
 
 /* Login Legal */
-.login-legal {
-  text-align: center;
-  margin-bottom: 1.5rem;
-  padding: 0 1rem;
-}
 
-.login-legal p {
-  color: var(--text-muted);
-  font-size: 0.8rem;
-  line-height: 1.5;
-}
 
-.login-legal-link {
-  color: var(--accent-primary);
-  text-decoration: none;
-}
 
-.login-legal-link:hover {
-  text-decoration: underline;
-}
+
+
+
+
 
 /* Login Back Link */
-.login-back-link {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 0.5rem;
-  color: var(--text-secondary);
-  font-size: 0.9rem;
-  text-decoration: none;
-  transition: color 0.2s;
-}
 
-.login-back-link:hover {
-  color: var(--accent-primary);
-}
 
-.login-back-link svg {
-  width: 16px;
-  height: 16px;
-}
 
-.login-description {
-  color: var(--text-secondary);
-  text-align: center;
-  margin-bottom: 1.5rem;
-  font-size: 0.95rem;
-}
 
-.login-actions {
-  display: flex;
-  justify-content: center;
-  gap: 0.75rem;
-  margin-bottom: 1rem;
-}
 
-.login-actions .btn-secondary {
-  border-radius: 12px;
-  padding: 0.85rem 1.75rem;
-}
+
+
+
+
+
+
 
 /* ===== App Shell ===== */
 .app-shell {
@@ -1821,21 +1311,9 @@ body {
   height: 20px;
 }
 
-.search-container {
-  position: relative;
-  max-width: 400px;
-  flex: 1;
-}
 
-.search-container svg {
-  position: absolute;
-  left: 0.875rem;
-  top: 50%;
-  transform: translateY(-50%);
-  width: 18px;
-  height: 18px;
-  color: var(--text-muted);
-}
+
+
 
 .search-input {
   width: 100%;
@@ -1862,25 +1340,11 @@ body {
   gap: 0.75rem;
 }
 
-.topbar-btn {
-  padding: 0.5rem;
-  background: var(--bg-secondary);
-  border: 1px solid var(--border-color);
-  border-radius: 10px;
-  color: var(--text-secondary);
-  cursor: pointer;
-  transition: all 0.2s;
-}
 
-.topbar-btn:hover {
-  border-color: var(--accent-primary);
-  color: var(--accent-primary);
-}
 
-.topbar-btn svg {
-  width: 20px;
-  height: 20px;
-}
+
+
+
 
 /* User Menu */
 .user-menu-container {
@@ -2275,40 +1739,15 @@ body {
   margin-bottom: 1rem;
 }
 
-.activity-list {
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-}
 
-.activity-empty {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  padding: 3rem 1rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 12px;
-  text-align: center;
-}
 
-.activity-empty svg {
-  width: 48px;
-  height: 48px;
-  color: var(--text-muted);
-  margin-bottom: 1rem;
-}
 
-.activity-empty p {
-  font-weight: 500;
-  margin-bottom: 0.25rem;
-}
 
-.activity-empty span {
-  color: var(--text-muted);
-  font-size: 0.875rem;
-}
+
+
+
+
+
 
 /* ===== Practice Hub Page ===== */
 .practice-hub-page,
@@ -2699,143 +2138,48 @@ body {
 }
 
 /* Question Card */
-.question-card {
-  padding: 2rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 16px;
-}
 
-.question-number {
-  display: inline-block;
-  padding: 0.375rem 0.875rem;
-  background: rgba(99, 102, 241, 0.15);
-  border-radius: 20px;
-  color: var(--accent-primary);
-  font-size: 0.8rem;
-  font-weight: 500;
-  margin-bottom: 1rem;
-}
 
-.question-text {
-  font-size: 1.125rem;
-  font-weight: 500;
-  line-height: 1.6;
-  margin-bottom: 1.5rem;
-}
+
+
+
 
 /* Options */
-.options-list {
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-  margin-bottom: 1.5rem;
-}
 
-.option-btn {
-  display: flex;
-  align-items: center;
-  gap: 1rem;
-  width: 100%;
-  padding: 1rem 1.25rem;
-  background: rgba(255, 255, 255, 0.03);
-  border: 1px solid var(--border-color);
-  border-radius: 12px;
-  color: var(--text-primary);
-  font-size: 0.95rem;
-  text-align: left;
-  cursor: pointer;
-  transition: all 0.2s;
-}
 
-.option-btn:hover:not(:disabled) {
-  border-color: var(--accent-primary);
-  background: rgba(99, 102, 241, 0.1);
-}
 
-.option-btn.selected {
-  border-color: var(--accent-primary);
-  background: rgba(99, 102, 241, 0.15);
-}
 
-.option-btn.correct {
-  border-color: var(--accent-green);
-  background: rgba(34, 197, 94, 0.15);
-}
 
-.option-btn.incorrect {
-  border-color: #ef4444;
-  background: rgba(239, 68, 68, 0.15);
-}
 
-.option-btn:disabled {
-  cursor: default;
-}
 
-.option-letter {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 32px;
-  height: 32px;
-  background: rgba(255, 255, 255, 0.1);
-  border-radius: 8px;
-  font-weight: 600;
-  font-size: 0.875rem;
-}
 
-.option-text {
-  flex: 1;
-}
 
-.result-icon {
-  width: 24px;
-  height: 24px;
-  margin-left: auto;
-}
 
-.result-icon.correct {
-  color: var(--accent-green);
-}
 
-.result-icon.incorrect {
-  color: #ef4444;
-}
+
+
+
+
+
+
+
+
+
+
+
+
 
 /* Result Message */
-.result-message {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  padding: 1rem 1.25rem;
-  border-radius: 12px;
-  font-size: 0.95rem;
-  margin-bottom: 1.5rem;
-}
 
-.result-message.correct {
-  background: rgba(34, 197, 94, 0.15);
-  border: 1px solid rgba(34, 197, 94, 0.3);
-  color: var(--accent-green);
-}
 
-.result-message.incorrect {
-  background: rgba(239, 68, 68, 0.15);
-  border: 1px solid rgba(239, 68, 68, 0.3);
-  color: #fca5a5;
-}
 
-.result-message svg {
-  width: 20px;
-  height: 20px;
-}
+
+
+
+
 
 /* Question Actions */
-.question-actions {
-  display: flex;
-  justify-content: space-between;
-  gap: 1rem;
-}
+
 
 .btn-primary,
 .btn-secondary {
@@ -2888,18 +2232,9 @@ body {
 }
 
 /* Question Navigator */
-.question-navigator {
-  padding: 1.25rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 14px;
-}
 
-.question-navigator h3 {
-  font-size: 0.9rem;
-  font-weight: 600;
-  margin-bottom: 1rem;
-}
+
+
 
 .navigator-grid {
   display: flex;
@@ -3263,14 +2598,7 @@ body {
   gap: 0.5rem;
 }
 
-.btn-spinner {
-  width: 18px;
-  height: 18px;
-  border: 2px solid rgba(255, 255, 255, 0.3);
-  border-top-color: white;
-  border-radius: 50%;
-  animation: spin 1s linear infinite;
-}
+
 
 /* ===== Chapters List ===== */
 .chapters-section h2 {
@@ -3561,11 +2889,7 @@ body {
   margin-bottom: 1rem;
 }
 
-.topics-list {
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-}
+
 
 .topic-progress-card {
   padding: 1rem 1.25rem;
@@ -3600,40 +2924,15 @@ body {
 }
 
 /* Activity Chart */
-.activity-section h2 {
-  font-size: 1.125rem;
-  font-weight: 600;
-  margin-bottom: 1rem;
-}
 
-.activity-chart-placeholder {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  padding: 4rem 2rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 14px;
-  text-align: center;
-}
 
-.activity-chart-placeholder svg {
-  width: 48px;
-  height: 48px;
-  color: var(--text-muted);
-  margin-bottom: 1rem;
-}
 
-.activity-chart-placeholder p {
-  font-weight: 500;
-  margin-bottom: 0.25rem;
-}
 
-.activity-chart-placeholder span {
-  color: var(--text-muted);
-  font-size: 0.875rem;
-}
+
+
+
+
+
 
 /* ===== Bookmarks Page ===== */
 .bookmarks-page {
@@ -4043,18 +3342,9 @@ body {
   overflow: hidden;
 }
 
-.setting-item {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 1rem;
-  padding: 1rem 1.25rem;
-  border-bottom: 1px solid var(--border-color);
-}
 
-.setting-item:last-child {
-  border-bottom: none;
-}
+
+
 
 .setting-info {
   display: flex;
@@ -4087,20 +3377,9 @@ body {
   background: var(--accent-primary);
 }
 
-.toggle-slider {
-  position: absolute;
-  top: 3px;
-  left: 3px;
-  width: 20px;
-  height: 20px;
-  background: white;
-  border-radius: 50%;
-  transition: transform 0.2s;
-}
 
-.toggle.on .toggle-slider {
-  transform: translateX(22px);
-}
+
+
 
 /* Setting Action */
 .setting-action {
@@ -4236,126 +3515,41 @@ body {
   padding: 2rem;
 }
 
-.quiz-complete-card {
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 20px;
-  padding: 2.5rem 2rem;
-  text-align: center;
-  width: 100%;
-  max-width: 420px;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.5rem;
-}
 
-.complete-icon {
-  font-size: 3rem;
-  line-height: 1;
-  margin-bottom: 0.5rem;
-}
 
-.quiz-complete-card h2 {
-  font-size: 1.6rem;
-  font-weight: 700;
-}
 
-.complete-topic {
-  color: var(--text-secondary);
-  font-size: 0.9rem;
-  margin-bottom: 0.25rem;
-}
 
-.complete-score {
-  display: flex;
-  align-items: baseline;
-  gap: 0.25rem;
-  margin: 0.5rem 0;
-}
 
-.score-number {
-  font-size: 3.5rem;
-  font-weight: 800;
-  color: var(--accent-primary);
-  line-height: 1;
-}
 
-.score-total {
-  font-size: 1.5rem;
-  color: var(--text-muted);
-}
 
-.complete-pct {
-  font-size: 1.1rem;
-  font-weight: 600;
-  color: var(--text-secondary);
-}
 
-.complete-actions {
-  display: flex;
-  gap: 0.75rem;
-  margin-top: 1.25rem;
-  flex-wrap: wrap;
-  justify-content: center;
-}
+
+
+
+
+
+
+
+
+
 
 /* ===== Question Progress Bar ===== */
 
-.question-progress-bar {
-  height: 4px;
-  background: rgba(255, 255, 255, 0.08);
-  border-radius: 4px;
-  overflow: hidden;
-}
 
-.qpb-fill {
-  height: 100%;
-  background: var(--accent-primary);
-  border-radius: 4px;
-  transition: width 0.35s ease;
-}
+
+
 
 /* ===== Question Header / Bookmark ===== */
 
-.question-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  margin-bottom: 1rem;
-}
 
-.bookmark-btn {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 36px;
-  height: 36px;
-  border-radius: 8px;
-  border: 1px solid var(--border-color);
-  background: transparent;
-  color: var(--text-muted);
-  cursor: pointer;
-  transition: all 0.2s;
-  padding: 0;
-  flex-shrink: 0;
-}
 
-.bookmark-btn svg {
-  width: 18px;
-  height: 18px;
-}
 
-.bookmark-btn:hover {
-  border-color: var(--accent-primary);
-  color: var(--accent-primary);
-}
 
-.bookmark-btn.bookmarked {
-  border-color: var(--accent-primary);
-  color: var(--accent-primary);
-  background: rgba(99, 102, 241, 0.1);
-}
+
+
+
+
+
 
 /* ===== Custom Practice Config ===== */
 
@@ -4534,55 +3728,17 @@ body {
   gap: 1.5rem;
 }
 
-.mock-quiz-header {
-  display: flex;
-  align-items: flex-start;
-  justify-content: space-between;
-  gap: 1.5rem;
-  flex-wrap: wrap;
-  padding: 1.25rem 1.5rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 16px;
-}
 
-.quiz-header-info h1 {
-  font-size: 1.2rem;
-  font-weight: 700;
-  margin-bottom: 0.25rem;
-}
 
-.quiz-meta {
-  font-size: 0.82rem;
-  color: var(--text-secondary);
-}
 
-.quiz-timer {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  font-size: 1.4rem;
-  font-weight: 700;
-  color: var(--accent-primary);
-  letter-spacing: 0.04em;
-  padding: 0.5rem 1rem;
-  background: rgba(99, 102, 241, 0.1);
-  border-radius: 10px;
-  border: 1px solid rgba(99, 102, 241, 0.2);
-  transition: all 0.3s;
-}
 
-.quiz-timer svg {
-  width: 20px;
-  height: 20px;
-}
 
-.quiz-timer.low {
-  color: #ef4444;
-  background: rgba(239, 68, 68, 0.12);
-  border-color: rgba(239, 68, 68, 0.3);
-  animation: pulse-timer 1s ease-in-out infinite;
-}
+
+
+
+
+
+
 
 @keyframes pulse-timer {
   0%, 100% { opacity: 1; }
@@ -4590,154 +3746,44 @@ body {
 }
 
 /* Question cards (paginated list) */
-.mock-questions-list {
-  display: flex;
-  flex-direction: column;
-  gap: 1.25rem;
-}
 
-.mock-question-card {
-  padding: 1.5rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 16px;
-  transition: border-color 0.2s;
-}
 
-.mock-q-header {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  margin-bottom: 0.875rem;
-}
 
-.mock-q-num {
-  display: inline-block;
-  padding: 0.3rem 0.8rem;
-  background: rgba(99, 102, 241, 0.12);
-  border-radius: 20px;
-  color: var(--accent-primary);
-  font-size: 0.78rem;
-  font-weight: 600;
-}
 
-.mock-q-answered-badge {
-  font-size: 0.72rem;
-  font-weight: 500;
-  padding: 0.2rem 0.6rem;
-  border-radius: 10px;
-  background: rgba(34, 197, 94, 0.15);
-  color: var(--accent-green);
-  border: 1px solid rgba(34, 197, 94, 0.25);
-}
 
-.mock-q-text {
-  font-size: 1rem;
-  font-weight: 500;
-  line-height: 1.6;
-  margin-bottom: 1.25rem;
-  color: var(--text-primary);
-}
 
-.mock-options {
-  display: flex;
-  flex-direction: column;
-  gap: 0.6rem;
-}
 
-.mock-opt-btn {
-  display: flex;
-  align-items: center;
-  gap: 0.875rem;
-  width: 100%;
-  padding: 0.875rem 1.125rem;
-  background: rgba(255, 255, 255, 0.03);
-  border: 1px solid var(--border-color);
-  border-radius: 10px;
-  color: var(--text-primary);
-  font-size: 0.93rem;
-  text-align: left;
-  cursor: pointer;
-  transition: all 0.15s;
-}
 
-.mock-opt-btn:hover {
-  border-color: var(--accent-primary);
-  background: rgba(99, 102, 241, 0.08);
-}
 
-.mock-opt-btn.selected {
-  border-color: var(--accent-primary);
-  background: rgba(99, 102, 241, 0.15);
-}
+
+
+
+
+
+
+
+
+
+
 
 /* Page navigation */
-.mock-page-nav {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 1rem;
-  padding: 1rem 1.25rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 14px;
-  flex-wrap: wrap;
-}
 
-.mock-page-dots {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  flex-wrap: wrap;
-  justify-content: center;
-}
 
-.page-dot {
-  width: 10px;
-  height: 10px;
-  border-radius: 50%;
-  border: none;
-  background: rgba(255, 255, 255, 0.15);
-  cursor: pointer;
-  padding: 0;
-  transition: all 0.2s;
-}
 
-.page-dot:hover {
-  background: rgba(255, 255, 255, 0.3);
-}
 
-.page-dot.done {
-  background: rgba(34, 197, 94, 0.5);
-}
 
-.page-dot.active {
-  background: var(--accent-primary);
-  transform: scale(1.4);
-}
 
-.page-dot.active.done {
-  background: var(--accent-green);
-}
 
-.btn-submit {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.5rem;
-  padding: 0.75rem 1.75rem;
-  border-radius: 10px;
-  font-size: 0.9rem;
-  font-weight: 600;
-  cursor: pointer;
-  background: var(--accent-green);
-  border: none;
-  color: white;
-  transition: all 0.2s;
-}
 
-.btn-submit:hover {
-  filter: brightness(1.1);
-}
+
+
+
+
+
+
+
+
+
 
 /* ===== Mock Test Results ===== */
 
@@ -4747,91 +3793,33 @@ body {
   gap: 1.5rem;
 }
 
-.results-summary-card {
-  padding: 2rem;
-  background: var(--bg-card);
-  border: 1px solid var(--border-color);
-  border-radius: 20px;
-  text-align: center;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.5rem;
-}
 
-.results-summary-card .complete-icon {
-  font-size: 3rem;
-  line-height: 1;
-}
 
-.results-summary-card h2 {
-  font-size: 1.6rem;
-  font-weight: 700;
-  margin-top: 0.5rem;
-}
 
-.results-summary-card .complete-topic {
-  color: var(--text-secondary);
-  font-size: 0.9rem;
-}
 
-.results-summary-card .complete-score {
-  display: flex;
-  align-items: baseline;
-  gap: 0.25rem;
-  margin-top: 0.5rem;
-}
 
-.results-summary-card .score-number {
-  font-size: 3.5rem;
-  font-weight: 800;
-  color: var(--accent-primary);
-  line-height: 1;
-}
 
-.results-summary-card .score-total {
-  font-size: 1.5rem;
-  color: var(--text-muted);
-}
 
-.results-summary-card .complete-pct {
-  font-size: 1.1rem;
-  font-weight: 600;
-  color: var(--text-secondary);
-}
 
-.results-stats-row {
-  display: flex;
-  gap: 2rem;
-  margin-top: 0.75rem;
-}
 
-.rs-stat {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.2rem;
-  font-size: 0.8rem;
-  font-weight: 500;
-  color: var(--text-secondary);
-}
 
-.rs-stat span {
-  font-size: 1.6rem;
-  font-weight: 700;
-}
 
-.rs-stat.correct span  { color: var(--accent-green); }
-.rs-stat.incorrect span { color: #ef4444; }
-.rs-stat.skipped span  { color: var(--text-muted); }
 
-.complete-actions {
-  display: flex;
-  gap: 1rem;
-  margin-top: 1rem;
-  flex-wrap: wrap;
-  justify-content: center;
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 .detailed-review-heading {
   font-size: 1.1rem;
@@ -5004,9 +3992,7 @@ body {
     justify-content: space-around;
   }
   
-  .question-actions {
-    flex-direction: column;
-  }
+  
   
   .flashcard {
     aspect-ratio: 4 / 3;
@@ -5643,34 +4629,11 @@ body {
   height: 16px;
 }
 
-.upload-hint {
-  margin-top: 2.5rem;
-  display: flex;
-  align-items: flex-start;
-  gap: 0.75rem;
-  padding: 1rem 1.25rem;
-  background: rgba(255, 255, 255, 0.03);
-  border: 1px dashed rgba(255, 255, 255, 0.15);
-  border-radius: 12px;
-  color: rgba(255, 255, 255, 0.5);
-  font-size: 0.85rem;
-  line-height: 1.55;
-}
 
-.upload-hint svg {
-  width: 20px;
-  height: 20px;
-  flex-shrink: 0;
-  margin-top: 2px;
-}
 
-.upload-hint code {
-  background: rgba(255, 255, 255, 0.08);
-  padding: 0.1rem 0.35rem;
-  border-radius: 4px;
-  font-family: monospace;
-  font-size: 0.82rem;
-}
+
+
+
 
 /* ===== Recent Quizzes (Dashboard) ===== */
 .recent-quizzes-list {
@@ -6173,3 +5136,67 @@ body {
   color: var(--text-muted, #94a3b8);
 }
 
+
+/* ===== Mock test resume notice ===== */
+.mock-resume-notice {
+  max-width: 900px;
+  margin: 0 auto 1.25rem;
+  padding: 0.75rem 1rem;
+  border: 1px solid rgba(34, 197, 94, 0.35);
+  border-radius: 10px;
+  background: rgba(34, 197, 94, 0.08);
+  color: var(--text-primary);
+  font-size: 0.9rem;
+}
+
+/* Footer legal links. Google consent screen links to /privacy, so the page
+   has to be findable from the site too - a policy reachable only by a URL
+   handed to Google is not one a student can find. */
+.footer-legal {
+  margin: 0.5rem 0 0;
+  font-size: 0.85rem;
+}
+
+.footer-legal a {
+  color: inherit;
+  text-decoration: underline;
+}
+
+.footer-disclaimer {
+  margin: 0.5rem 0 0;
+  font-size: 0.8rem;
+  opacity: 0.75;
+}
+
+/* Sign-in entry point in the landing nav. The login page existed at /signin
+   and nothing linked to it, so the only way in was to type the URL. */
+.nav-actions {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.nav-signin {
+  display: inline-flex;
+  align-items: center;
+  /* 44px, so it is a real target on a phone rather than a word to pinch at. */
+  min-height: 44px;
+  padding: 0 1rem;
+  border: 1px solid var(--color-border-strong, rgba(255, 255, 255, 0.25));
+  border-radius: 999px;
+  color: inherit;
+  font-size: 0.95rem;
+  font-weight: 600;
+  text-decoration: none;
+  white-space: nowrap;
+}
+
+.nav-signin:hover {
+  border-color: currentColor;
+}
+
+.nav-content {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 1404d61..bc707a1 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1,13 +1,26 @@
 import { BrowserRouter as Router } from 'react-router-dom';
 import AppRoutes from './routes/AppRoutes';
 import { UserProvider } from './context/UserContext';
+import { AuthProvider } from './auth/AuthContext';
 import './App.css';
 
+/**
+ * `AuthProvider` sits inside the Router because the sign-in flow navigates,
+ * and outside the routes because the guard on `/app` reads it.
+ *
+ * It does NOT replace `UserProvider`, which holds only a locally-stored
+ * display name used for the dashboard greeting. The two answer different
+ * questions — "what shall we call you" versus "who are you to the server" —
+ * and the local one still works in a build with no backend configured. The
+ * server's `displayName` wins where both exist; see AppShell.
+ */
 function App() {
   return (
     <UserProvider>
       <Router>
-        <AppRoutes />
+        <AuthProvider>
+          <AppRoutes />
+        </AuthProvider>
       </Router>
     </UserProvider>
   );
diff --git a/frontend/src/auth/AuthContext.tsx b/frontend/src/auth/AuthContext.tsx
new file mode 100644
index 0000000..2057853
--- /dev/null
+++ b/frontend/src/auth/AuthContext.tsx
@@ -0,0 +1,177 @@
+/**
+ * Who the current visitor is.
+ *
+ * Every endpoint on the Worker except the content reads needs a session, so
+ * this is the gate the rest of the integration goes through. It is also the
+ * one piece that has to work when there is NO backend: the app has shipped
+ * local-only until now, and a build with `VITE_API_BASE_URL` unset must keep
+ * working rather than show a login wall it cannot satisfy.
+ *
+ * THREE STATES, NOT TWO
+ * ---------------------
+ * `status` distinguishes them because conflating any two produces a bug:
+ *
+ *   'loading'  -- the session probe is in flight. Route guards must WAIT here,
+ *                 not redirect: treating it as signed-out bounces a
+ *                 signed-in user to the sign-in page on every refresh.
+ *   'ready'    -- the probe finished. `user` is the answer, and `null` means
+ *                 genuinely signed out.
+ *   'disabled' -- no backend is configured. Not an error and not signed-out:
+ *                 the app runs on local data and nothing should prompt for
+ *                 credentials.
+ *
+ * THE SESSION IS AN HttpOnly COOKIE
+ * ---------------------------------
+ * There is no token in JavaScript, so there is nothing here to persist, and
+ * nothing for XSS to read. `user` is a cache of what the server last said, not
+ * the credential. That is why sign-out calls the server rather than clearing
+ * local state: clearing a cache the browser can refill from a still-valid
+ * cookie would log nobody out.
+ *
+ * ANONYMOUS IS A REAL IDENTITY
+ * ----------------------------
+ * `startGuest()` creates a server-side user whose id survives being upgraded
+ * in place (`upgrade()`), so a candidate can sit a paper, then sign up, and
+ * keep that attempt. The alternative - making them sign up first - throws away
+ * the only session where they were actually willing to start.
+ *
+ * The context, its types and the hooks live in `auth-context.ts`; this file
+ * exports only the provider so Fast Refresh can swap it.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
+import { api, isBackendConfigured } from '../services/api';
+import type { ApiError, SessionUser } from '../services/api';
+import { AuthContext, type AuthContextValue, type AuthState } from './auth-context';
+
+/**
+ * The state before anything has been asked.
+ *
+ * A function rather than a module-level constant. `isBackendConfigured()`
+ * reads a build-time value in production, so either would behave identically
+ * there — but freezing it at module scope means the status is decided by
+ * whenever this file first happened to be imported, which is both arbitrary
+ * and untestable. Reading it when the provider actually mounts is the honest
+ * version, and it still settles before the first paint, so a local-only build
+ * shows no flash of 'loading'.
+ */
+function initialState(): AuthState {
+  return {
+    status: isBackendConfigured() ? 'loading' : 'disabled',
+    user: null,
+    expiresAt: null,
+    error: null,
+    busy: false,
+  };
+}
+
+/** What the four session-establishing endpoints have in common. */
+type SessionAttempt =
+  | { ok: true; data: { user: SessionUser | null; sessionExpiresAt: number | null } }
+  | { ok: false; error: ApiError };
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  const [state, setState] = useState<AuthState>(initialState);
+
+  // Guards against a response landing after unmount.
+  const alive = useRef(true);
+  useEffect(() => {
+    alive.current = true;
+    return () => {
+      alive.current = false;
+    };
+  }, []);
+
+  const applySession = useCallback((user: SessionUser | null, expiresAt: number | null) => {
+    if (!alive.current) return;
+    setState((prev) => ({ ...prev, status: 'ready', user, expiresAt, busy: false }));
+  }, []);
+
+  const refresh = useCallback(async () => {
+    if (!isBackendConfigured()) return;
+    const result = await api.getSession();
+    if (!alive.current) return;
+    if (result.ok) {
+      applySession(result.data.user, result.data.sessionExpiresAt);
+      return;
+    }
+    // A failed probe is not a failed sign-in: it means we do not know who this
+    // is. Reporting it as an auth error would show "could not sign in" to
+    // someone who never tried. The app degrades to signed-out.
+    setState((prev) => ({ ...prev, status: 'ready', user: null, expiresAt: null, busy: false }));
+  }, [applySession]);
+
+  // One probe on mount. The cookie travels automatically, so this is how a
+  // refreshed tab discovers it is still signed in.
+  //
+  // The work is deferred into a promise rather than called straight from the
+  // effect body: a synchronous setState during an effect cascades an extra
+  // render pass, and here it would also mean the very first paint could not
+  // show the 'loading' state the route guard depends on.
+  useEffect(() => {
+    if (!isBackendConfigured()) return;
+    let cancelled = false;
+    void Promise.resolve().then(async () => {
+      if (cancelled) return;
+      await refresh();
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [refresh]);
+
+  const attempt = useCallback(
+    async (run: () => Promise<SessionAttempt>): Promise<boolean> => {
+      setState((prev) => ({ ...prev, busy: true, error: null }));
+      const result = await run();
+      if (!alive.current) return false;
+      if (!result.ok) {
+        setState((prev) => ({ ...prev, busy: false, error: result.error }));
+        return false;
+      }
+      applySession(result.data.user, result.data.sessionExpiresAt);
+      return true;
+    },
+    [applySession],
+  );
+
+  const login = useCallback(
+    (email: string, password: string) => attempt(() => api.login({ email, password })),
+    [attempt],
+  );
+
+  const signup = useCallback(
+    (email: string, password: string, displayName?: string) =>
+      attempt(() => api.signup({ email, password, displayName })),
+    [attempt],
+  );
+
+  const startGuest = useCallback(() => attempt(() => api.startAnonymousSession()), [attempt]);
+
+  const upgrade = useCallback(
+    (email: string, password: string, displayName?: string) =>
+      attempt(() => api.upgradeAnonymous({ email, password, displayName })),
+    [attempt],
+  );
+
+  const logout = useCallback(async () => {
+    setState((prev) => ({ ...prev, busy: true, error: null }));
+    // The server revokes the session and clears the cookie. Dropping `user`
+    // locally without this would leave a live cookie that the next probe
+    // happily restores.
+    await api.logout();
+    if (!alive.current) return;
+    setState((prev) => ({ ...prev, status: 'ready', user: null, expiresAt: null, busy: false }));
+  }, []);
+
+  const clearError = useCallback(() => {
+    setState((prev) => (prev.error === null ? prev : { ...prev, error: null }));
+  }, []);
+
+  const value = useMemo<AuthContextValue>(
+    () => ({ ...state, login, signup, startGuest, upgrade, logout, refresh, clearError }),
+    [state, login, signup, startGuest, upgrade, logout, refresh, clearError],
+  );
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+}
diff --git a/frontend/src/auth/RequireSession.tsx b/frontend/src/auth/RequireSession.tsx
new file mode 100644
index 0000000..c7f18b3
--- /dev/null
+++ b/frontend/src/auth/RequireSession.tsx
@@ -0,0 +1,61 @@
+/**
+ * Route guard for everything behind `/app`.
+ *
+ * THE BUG THIS IS WRITTEN TO AVOID
+ * --------------------------------
+ * The session lives in an HttpOnly cookie, so on a fresh page load the app
+ * does not yet know who the visitor is — it has to ask the server. A guard
+ * that treats "don't know yet" as "signed out" redirects every signed-in user
+ * to the sign-in page on every refresh, and then back again once the probe
+ * lands. So `status === 'loading'` renders a spinner and decides nothing.
+ *
+ * A LOCAL-ONLY BUILD IS NOT LOCKED OUT
+ * ------------------------------------
+ * With `VITE_API_BASE_URL` unset there is no session to have and no sign-in
+ * that could succeed, so `status === 'disabled'` passes straight through. That
+ * is the deployment that shipped until now and it must keep working.
+ *
+ * A GUEST COUNTS AS SIGNED IN
+ * ---------------------------
+ * `useIsAuthenticated()` is true for an anonymous identity, because a guest
+ * has a real server-side user whose attempts are recorded and who can upgrade
+ * in place. Gating practice behind a full account would throw away the session
+ * where the candidate was actually willing to start.
+ *
+ * THE ATTEMPTED PATH SURVIVES
+ * ---------------------------
+ * The redirect carries `from` in location state, so a deep link into a mock
+ * test comes back to that mock test after signing in rather than dumping the
+ * visitor on the dashboard.
+ */
+
+import { Navigate, useLocation } from 'react-router-dom';
+import type { ReactNode } from 'react';
+import { useAuth, useIsAuthenticated } from './auth-context';
+
+export default function RequireSession({ children }: { children: ReactNode }) {
+  const { status } = useAuth();
+  const authenticated = useIsAuthenticated();
+  const location = useLocation();
+
+  if (status === 'loading') {
+    return (
+      <div className="loading-container" role="status" aria-live="polite">
+        <div className="loading-spinner" />
+        <p>Checking your session…</p>
+      </div>
+    );
+  }
+
+  if (!authenticated) {
+    return (
+      <Navigate
+        to="/signin"
+        replace
+        state={{ from: location.pathname + location.search }}
+      />
+    );
+  }
+
+  return <>{children}</>;
+}
diff --git a/frontend/src/auth/__tests__/auth.test.tsx b/frontend/src/auth/__tests__/auth.test.tsx
new file mode 100644
index 0000000..3d314d1
--- /dev/null
+++ b/frontend/src/auth/__tests__/auth.test.tsx
@@ -0,0 +1,345 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import type { ReactNode } from 'react';
+import type { SessionUser } from '../../services/api';
+
+/**
+ * The auth layer, which is the gate every other endpoint goes through.
+ *
+ * The cases below are the ones where getting it wrong is invisible in manual
+ * testing but wrong for real users:
+ *
+ *   * The session is an HttpOnly cookie, so on a fresh load the app has to ASK
+ *     the server who this is. A guard that reads "don't know yet" as "signed
+ *     out" bounces every signed-in user to the sign-in page on refresh.
+ *   * A build with no `VITE_API_BASE_URL` has no session to have. It must not
+ *     show a login wall it cannot satisfy.
+ *   * Signing out has to reach the server. Clearing local state leaves a live
+ *     cookie that the next page load turns back into a signed-in user.
+ *   * A guest is a real identity, not a logged-out visitor.
+ */
+
+// --- Mock the API client ----------------------------------------------------
+//
+// `isBackendConfigured()` reads a build-time constant, so the only way to
+// exercise both the configured and the local-only paths in one suite is to
+// control the module. Everything else is the real code.
+
+const mockApi = {
+  getSession: vi.fn(),
+  login: vi.fn(),
+  signup: vi.fn(),
+  startAnonymousSession: vi.fn(),
+  upgradeAnonymous: vi.fn(),
+  logout: vi.fn(),
+  // A plain function, not a spy: it is a pure URL builder with no round trip,
+  // and the test cares about the URL it produces.
+  googleSignInUrl: (redirectTo?: string): string =>
+    `https://api.test/api/auth/google/start${redirectTo ? `?redirect_to=${encodeURIComponent(redirectTo)}` : ''}`,
+};
+let backendConfigured = true;
+
+vi.mock('../../services/api', () => ({
+  api: mockApi,
+  isBackendConfigured: () => backendConfigured,
+  apiBaseUrl: () => (backendConfigured ? 'https://api.test' : ''),
+  newIdempotencyKey: () => 'test-key',
+}));
+
+// Imported after the mock is registered.
+const { AuthProvider } = await import('../AuthContext');
+const { useAuth } = await import('../auth-context');
+const RequireSession = (await import('../RequireSession')).default;
+const SignIn = (await import('../../pages/auth/SignIn')).default;
+
+const GUEST: SessionUser = {
+  id: 'usr_guest',
+  email: null,
+  displayName: null,
+  role: 'student' as const,
+  isAnonymous: true,
+  hasPassword: false,
+  createdAt: 1,
+};
+
+const MEMBER: SessionUser = { ...GUEST, id: 'usr_1', email: 'a@b.test', displayName: 'Asha', isAnonymous: false, hasPassword: true };
+
+const sessionOk = (user: SessionUser | null) => ({
+  ok: true as const,
+  data: { user, sessionExpiresAt: user ? 2_000 : null, serverNow: 1_000 },
+});
+
+const failure = (code: string, message: string) => ({
+  ok: false as const,
+  error: { code, message },
+});
+
+/** Reads the context out so assertions can be made on it directly. */
+function Probe() {
+  const { status, user, busy, error } = useAuth();
+  return (
+    <div>
+      <span data-testid="status">{status}</span>
+      <span data-testid="user">{user ? user.id : 'none'}</span>
+      <span data-testid="busy">{String(busy)}</span>
+      <span data-testid="error">{error ? error.code : 'none'}</span>
+    </div>
+  );
+}
+
+function wrap(children: ReactNode, entries = ['/']) {
+  return render(
+    <MemoryRouter initialEntries={entries}>
+      <AuthProvider>{children}</AuthProvider>
+    </MemoryRouter>,
+  );
+}
+
+beforeEach(() => {
+  backendConfigured = true;
+  // googleSignInUrl is a plain function, not a spy, so it has nothing to
+  // reset and must be skipped rather than cast away.
+  for (const fn of Object.values(mockApi)) {
+    if ('mockReset' in fn) fn.mockReset();
+  }
+  mockApi.getSession.mockResolvedValue(sessionOk(null));
+  mockApi.logout.mockResolvedValue({ ok: true, data: { ok: true } });
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('AuthProvider', () => {
+  it('probes the server once on mount and reports the answer', async () => {
+    mockApi.getSession.mockResolvedValue(sessionOk(MEMBER));
+    wrap(<Probe />);
+
+    // Starts as 'loading' — the cookie is HttpOnly, so the answer can only
+    // come from the server.
+    expect(screen.getByTestId('status')).toHaveTextContent('loading');
+
+    await waitFor(() => expect(screen.getByTestId('status')).toHaveTextContent('ready'));
+    expect(screen.getByTestId('user')).toHaveTextContent('usr_1');
+    expect(mockApi.getSession).toHaveBeenCalledTimes(1);
+  });
+
+  it('is disabled, not signed-out, when no backend is configured', async () => {
+    backendConfigured = false;
+    wrap(<Probe />);
+
+    expect(screen.getByTestId('status')).toHaveTextContent('disabled');
+    // And crucially it never asks: a local-only build makes no requests.
+    await waitFor(() => expect(mockApi.getSession).not.toHaveBeenCalled());
+  });
+
+  it('treats a failed probe as signed-out, not as a sign-in error', async () => {
+    mockApi.getSession.mockResolvedValue(failure('NETWORK_UNAVAILABLE', 'Could not reach the server.'));
+    wrap(<Probe />);
+
+    await waitFor(() => expect(screen.getByTestId('status')).toHaveTextContent('ready'));
+    expect(screen.getByTestId('user')).toHaveTextContent('none');
+    // Showing "could not sign in" to somebody who never tried is wrong.
+    expect(screen.getByTestId('error')).toHaveTextContent('none');
+  });
+
+  it('surfaces a real sign-in failure as an error', async () => {
+    mockApi.login.mockResolvedValue(failure('INVALID_CREDENTIALS', 'Email or password is incorrect.'));
+
+    function LoginButton() {
+      const { login } = useAuth();
+      return (
+        <button type="button" onClick={() => void login('a@b.test', 'password123')}>
+          go
+        </button>
+      );
+    }
+
+    const user = userEvent.setup();
+    wrap(
+      <>
+        <Probe />
+        <LoginButton />
+      </>,
+    );
+    await waitFor(() => expect(screen.getByTestId('status')).toHaveTextContent('ready'));
+
+    await user.click(screen.getByRole('button', { name: 'go' }));
+    await waitFor(() => expect(screen.getByTestId('error')).toHaveTextContent('INVALID_CREDENTIALS'));
+    expect(screen.getByTestId('user')).toHaveTextContent('none');
+    // The spinner has to stop even on failure.
+    expect(screen.getByTestId('busy')).toHaveTextContent('false');
+  });
+
+  it('asks the server to revoke the session on sign-out', async () => {
+    mockApi.getSession.mockResolvedValue(sessionOk(MEMBER));
+
+    function LogoutButton() {
+      const { logout } = useAuth();
+      return (
+        <button type="button" onClick={() => void logout()}>
+          out
+        </button>
+      );
+    }
+
+    const user = userEvent.setup();
+    wrap(
+      <>
+        <Probe />
+        <LogoutButton />
+      </>,
+    );
+    await waitFor(() => expect(screen.getByTestId('user')).toHaveTextContent('usr_1'));
+
+    await user.click(screen.getByRole('button', { name: 'out' }));
+    await waitFor(() => expect(screen.getByTestId('user')).toHaveTextContent('none'));
+    // The cookie is HttpOnly: without this call the next probe signs them
+    // straight back in.
+    expect(mockApi.logout).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('RequireSession', () => {
+  const guarded = (
+    <Routes>
+      <Route
+        path="/app"
+        element={
+          <RequireSession>
+            <h1>Protected</h1>
+          </RequireSession>
+        }
+      />
+      <Route path="/signin" element={<h1>Sign in page</h1>} />
+    </Routes>
+  );
+
+  it('waits for the probe instead of redirecting a signed-in user', async () => {
+    let resolve: ((value: unknown) => void) | undefined;
+    mockApi.getSession.mockReturnValue(
+      new Promise((r) => {
+        resolve = r;
+      }),
+    );
+
+    wrap(guarded, ['/app']);
+
+    // Mid-probe: neither the protected page nor a redirect. This is the bug
+    // the three-state status exists to prevent — a refresh must not bounce a
+    // signed-in user to the sign-in page.
+    expect(screen.getByText(/Checking your session/i)).toBeInTheDocument();
+    expect(screen.queryByText('Sign in page')).not.toBeInTheDocument();
+
+    resolve?.(sessionOk(MEMBER));
+    await waitFor(() => expect(screen.getByText('Protected')).toBeInTheDocument());
+  });
+
+  it('redirects to sign-in once the probe says nobody is signed in', async () => {
+    mockApi.getSession.mockResolvedValue(sessionOk(null));
+    wrap(guarded, ['/app']);
+    await waitFor(() => expect(screen.getByText('Sign in page')).toBeInTheDocument());
+  });
+
+  it('lets a guest through, because a guest is a real identity', async () => {
+    mockApi.getSession.mockResolvedValue(sessionOk(GUEST));
+    wrap(guarded, ['/app']);
+    await waitFor(() => expect(screen.getByText('Protected')).toBeInTheDocument());
+  });
+
+  it('lets everyone through when no backend is configured', async () => {
+    backendConfigured = false;
+    wrap(guarded, ['/app']);
+    // No wall in a build that has no sign-in to offer.
+    expect(screen.getByText('Protected')).toBeInTheDocument();
+    expect(mockApi.getSession).not.toHaveBeenCalled();
+  });
+});
+
+describe('SignIn', () => {
+  const page = (
+    <Routes>
+      <Route path="/signin" element={<SignIn />} />
+      <Route path="/signup" element={<SignIn initialMode="signup" />} />
+      <Route path="/app" element={<h1>App</h1>} />
+    </Routes>
+  );
+
+  it('offers the guest path as the primary action', async () => {
+    mockApi.startAnonymousSession.mockResolvedValue(sessionOk(GUEST));
+    const user = userEvent.setup();
+    wrap(page, ['/signin']);
+    await waitFor(() => expect(screen.getByRole('button', { name: /continue as guest/i })).toBeEnabled());
+
+    await user.click(screen.getByRole('button', { name: /continue as guest/i }));
+    await waitFor(() => expect(screen.getByText('App')).toBeInTheDocument());
+    expect(mockApi.startAnonymousSession).toHaveBeenCalledTimes(1);
+  });
+
+  it('enforces the password minimum when creating an account', async () => {
+    const user = userEvent.setup();
+    wrap(page, ['/signup']);
+    await waitFor(() => expect(screen.getByRole('heading', { name: /create an account/i })).toBeInTheDocument());
+
+    await user.type(screen.getByLabelText(/email/i), 'a@b.test');
+    await user.type(screen.getByLabelText(/password/i), 'short');
+    expect(screen.getByRole('button', { name: /create account/i })).toBeDisabled();
+
+    await user.type(screen.getByLabelText(/password/i), 'enough');
+    expect(screen.getByRole('button', { name: /create account/i })).toBeEnabled();
+  });
+
+  it('does NOT impose a length minimum on sign-in', async () => {
+    // The server's login schema has no minimum on purpose: rejecting a short
+    // password would tell an attacker their guess was too short to be
+    // anyone's. A client-side minimum would reintroduce that signal and lock
+    // out any account whose password predates the current rule.
+    const user = userEvent.setup();
+    wrap(page, ['/signin']);
+    await waitFor(() => expect(screen.getByRole('heading', { name: /^sign in$/i })).toBeInTheDocument());
+
+    await user.type(screen.getByLabelText(/email/i), 'a@b.test');
+    await user.type(screen.getByLabelText(/password/i), 'abc');
+    expect(screen.getByRole('button', { name: /^sign in$/i })).toBeEnabled();
+  });
+
+  it('clears a stale failure when switching mode', async () => {
+    mockApi.login.mockResolvedValue(failure('INVALID_CREDENTIALS', 'Email or password is incorrect.'));
+    const user = userEvent.setup();
+    wrap(page, ['/signin']);
+    await waitFor(() => expect(screen.getByRole('heading', { name: /^sign in$/i })).toBeInTheDocument());
+
+    await user.type(screen.getByLabelText(/email/i), 'a@b.test');
+    await user.type(screen.getByLabelText(/password/i), 'password123');
+    await user.click(screen.getByRole('button', { name: /^sign in$/i }));
+    await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent(/incorrect/i));
+
+    // "Email or password is incorrect" under a "Create an account" heading
+    // reads as though the account already exists.
+    await user.click(screen.getByRole('button', { name: /create one/i }));
+    await waitFor(() => expect(screen.getByRole('alert')).toBeEmptyDOMElement());
+  });
+
+  it('offers Google as a real navigation, carrying the return path', async () => {
+    // The OAuth flow leaves this origin, so the control must be an anchor
+    // rather than a fetch — middle-click and Back have to work, and there is
+    // nothing to await.
+    wrap(page, ['/signin']);
+    const link = await screen.findByRole('link', { name: /continue with google/i });
+    expect(link).toHaveAttribute(
+      'href',
+      expect.stringContaining('/api/auth/google/start'),
+    );
+    // The guard stashes the attempted path; it has to survive the round trip
+    // through Google or a deep link lands on the dashboard instead.
+    expect(link.getAttribute('href')).toContain('redirect_to=');
+  });
+
+  it('sends an already-signed-in visitor straight on', async () => {
+    mockApi.getSession.mockResolvedValue(sessionOk(MEMBER));
+    wrap(page, ['/signin']);
+    await waitFor(() => expect(screen.getByText('App')).toBeInTheDocument());
+  });
+});
diff --git a/frontend/src/auth/auth-context.ts b/frontend/src/auth/auth-context.ts
new file mode 100644
index 0000000..02bd8ed
--- /dev/null
+++ b/frontend/src/auth/auth-context.ts
@@ -0,0 +1,69 @@
+/**
+ * The auth context, its types, and the hooks that read it.
+ *
+ * Split from `AuthContext.tsx` because that file exports a component and this
+ * one does not. React Fast Refresh can only swap a module whose exports are
+ * all components, so mixing the provider with its hooks costs a full reload on
+ * every edit — the same reason `context/user-context.ts` is separate from
+ * `context/UserContext.tsx`.
+ */
+
+import { createContext, useContext } from 'react';
+import type { ApiError, SessionUser } from '../services/api';
+
+export type AuthStatus = 'loading' | 'ready' | 'disabled';
+
+export interface AuthState {
+  status: AuthStatus;
+  user: SessionUser | null;
+  /** Epoch ms the session expires, when the server told us. */
+  expiresAt: number | null;
+  /** Last failure from a sign-in attempt. Cleared on the next attempt. */
+  error: ApiError | null;
+  /** True while a sign-in, sign-up or sign-out request is in flight. */
+  busy: boolean;
+}
+
+export interface AuthActions {
+  login(email: string, password: string): Promise<boolean>;
+  signup(email: string, password: string, displayName?: string): Promise<boolean>;
+  /** Creates a guest identity whose attempts survive a later sign-up. */
+  startGuest(): Promise<boolean>;
+  /** Turns the CURRENT guest into a full account, keeping its id and history. */
+  upgrade(email: string, password: string, displayName?: string): Promise<boolean>;
+  logout(): Promise<void>;
+  /** Re-reads the session from the server. */
+  refresh(): Promise<void>;
+  clearError(): void;
+}
+
+export type AuthContextValue = AuthState & AuthActions;
+
+export const AuthContext = createContext<AuthContextValue | null>(null);
+
+/**
+ * Read the auth state.
+ *
+ * Throws outside a provider rather than returning a plausible default: a
+ * component that silently believes nobody is signed in is far harder to debug
+ * than one that fails on first render.
+ */
+export function useAuth(): AuthContextValue {
+  const value = useContext(AuthContext);
+  if (!value) {
+    throw new Error('useAuth must be used inside <AuthProvider>.');
+  }
+  return value;
+}
+
+/**
+ * True when the app should behave as a signed-in experience.
+ *
+ * A guest counts: they have a server-side identity, their attempts are
+ * recorded, and they can upgrade in place. `'disabled'` also counts, because a
+ * local-only build has no sign-in to offer and must not gate anything.
+ */
+export function useIsAuthenticated(): boolean {
+  const { status, user } = useAuth();
+  return status === 'disabled' || user !== null;
+}
diff --git a/frontend/src/components/ThreeBackground.tsx b/frontend/src/components/ThreeBackground.tsx
deleted file mode 100644
index 462ef31..0000000
--- a/frontend/src/components/ThreeBackground.tsx
+++ /dev/null
@@ -1,155 +0,0 @@
-import { useRef, useMemo } from 'react';
-import { Canvas, useFrame } from '@react-three/fiber';
-import { Points, PointMaterial } from '@react-three/drei';
-import * as THREE from 'three';
-
-function ParticleField() {
-  const ref = useRef<THREE.Points>(null);
-  
-  const particlesCount = 5000;
-  const positions = useMemo(() => {
-    const positions = new Float32Array(particlesCount * 3);
-    for (let i = 0; i < particlesCount; i++) {
-      const x = (Math.random() - 0.5) * 20;
-      const y = (Math.random() - 0.5) * 20;
-      const z = (Math.random() - 0.5) * 20;
-      positions[i * 3] = x;
-      positions[i * 3 + 1] = y;
-      positions[i * 3 + 2] = z;
-    }
-    return positions;
-  }, []);
-
-  useFrame((state) => {
-    if (ref.current) {
-      ref.current.rotation.x = state.clock.getElapsedTime() * 0.05;
-      ref.current.rotation.y = state.clock.getElapsedTime() * 0.08;
-    }
-  });
-
-  return (
-    <Points ref={ref} positions={positions} stride={3} frustumCulled={false}>
-      <PointMaterial
-        transparent
-        color="#6366f1"
-        size={0.02}
-        sizeAttenuation={true}
-        depthWrite={false}
-      />
-    </Points>
-  );
-}
-
-function FloatingGeometry() {
-  const meshRef = useRef<THREE.Mesh>(null);
-  const torusRef = useRef<THREE.Mesh>(null);
-  const octaRef = useRef<THREE.Mesh>(null);
-
-  useFrame((state) => {
-    const time = state.clock.getElapsedTime();
-    
-    if (meshRef.current) {
-      meshRef.current.rotation.x = time * 0.3;
-      meshRef.current.rotation.y = time * 0.2;
-      meshRef.current.position.y = Math.sin(time * 0.5) * 0.5;
-    }
-    
-    if (torusRef.current) {
-      torusRef.current.rotation.x = time * 0.4;
-      torusRef.current.rotation.z = time * 0.2;
-      torusRef.current.position.y = Math.sin(time * 0.5 + 1) * 0.3;
-    }
-    
-    if (octaRef.current) {
-      octaRef.current.rotation.y = time * 0.5;
-      octaRef.current.rotation.z = time * 0.3;
-      octaRef.current.position.y = Math.sin(time * 0.5 + 2) * 0.4;
-    }
-  });
-
-  return (
-    <>
-      <mesh ref={meshRef} position={[-3, 0, -2]}>
-        <icosahedronGeometry args={[1, 1]} />
-        <meshStandardMaterial
-          color="#8b5cf6"
-          wireframe
-          transparent
-          opacity={0.6}
-        />
-      </mesh>
-      
-      <mesh ref={torusRef} position={[3, 0, -3]}>
-        <torusGeometry args={[0.8, 0.3, 16, 50]} />
-        <meshStandardMaterial
-          color="#06b6d4"
-          wireframe
-          transparent
-          opacity={0.6}
-        />
-      </mesh>
-      
-      <mesh ref={octaRef} position={[0, 2, -4]}>
-        <octahedronGeometry args={[0.8]} />
-        <meshStandardMaterial
-          color="#f472b6"
-          wireframe
-          transparent
-          opacity={0.6}
-        />
-      </mesh>
-    </>
-  );
-}
-
-function GlowingSphere() {
-  const sphereRef = useRef<THREE.Mesh>(null);
-
-  useFrame((state) => {
-    if (sphereRef.current) {
-      const time = state.clock.getElapsedTime();
-      sphereRef.current.scale.setScalar(1 + Math.sin(time * 2) * 0.1);
-    }
-  });
-
-  return (
-    <mesh ref={sphereRef} position={[0, 0, -5]}>
-      <sphereGeometry args={[2, 64, 64]} />
-      <meshStandardMaterial
-        color="#4f46e5"
-        emissive="#4f46e5"
-        emissiveIntensity={0.2}
-        wireframe
-        transparent
-        opacity={0.3}
-      />
-    </mesh>
-  );
-}
-
-export default function ThreeBackground() {
-  return (
-    <div className="three-container">
-      <Canvas
-        camera={{ position: [0, 0, 5], fov: 75 }}
-        style={{
-          position: 'fixed',
-          top: 0,
-          left: 0,
-          width: '100%',
-          height: '100%',
-          zIndex: -1,
-        }}
-      >
-        <color attach="background" args={['#0a0a0f']} />
-        <fog attach="fog" args={['#0a0a0f', 5, 25]} />
-        <ambientLight intensity={0.5} />
-        <pointLight position={[10, 10, 10]} intensity={1} color="#6366f1" />
-        <pointLight position={[-10, -10, -10]} intensity={0.5} color="#8b5cf6" />
-        <ParticleField />
-        <FloatingGeometry />
-        <GlowingSphere />
-      </Canvas>
-    </div>
-  );
-}
diff --git a/frontend/src/components/ui/Badge.module.css b/frontend/src/components/ui/Badge.module.css
new file mode 100644
index 0000000..a02f579
--- /dev/null
+++ b/frontend/src/components/ui/Badge.module.css
@@ -0,0 +1,56 @@
+.badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3125rem;
+  font-weight: 600;
+  line-height: 1.3;
+  white-space: nowrap;
+  border: 1px solid transparent;
+  border-radius: var(--radius-full, 999px);
+}
+
+.sm {
+  padding: 0.0625rem 0.4375rem;
+  font-size: 0.6875rem;
+}
+
+.md {
+  padding: 0.1875rem 0.5625rem;
+  font-size: 0.75rem;
+}
+
+.neutral {
+  color: var(--color-fg-muted, #5b6169);
+  background-color: var(--color-surface-2, #f4f5f7);
+  border-color: var(--color-border, #e3e5e8);
+}
+
+.accent {
+  color: var(--color-accent, #2f6bff);
+  background-color: color-mix(in srgb, var(--color-accent, #2f6bff) 12%, transparent);
+  border-color: color-mix(in srgb, var(--color-accent, #2f6bff) 30%, transparent);
+}
+
+.success {
+  color: var(--color-success-500, #16a34a);
+  background-color: color-mix(in srgb, var(--color-success-500, #16a34a) 12%, transparent);
+  border-color: color-mix(in srgb, var(--color-success-500, #16a34a) 30%, transparent);
+}
+
+.warning {
+  color: var(--color-warning-500, #d97706);
+  background-color: color-mix(in srgb, var(--color-warning-500, #d97706) 14%, transparent);
+  border-color: color-mix(in srgb, var(--color-warning-500, #d97706) 30%, transparent);
+}
+
+.danger {
+  color: var(--color-danger-500, #dc2626);
+  background-color: color-mix(in srgb, var(--color-danger-500, #dc2626) 12%, transparent);
+  border-color: color-mix(in srgb, var(--color-danger-500, #dc2626) 30%, transparent);
+}
+
+.info {
+  color: var(--color-info-500, #0284c7);
+  background-color: color-mix(in srgb, var(--color-info-500, #0284c7) 12%, transparent);
+  border-color: color-mix(in srgb, var(--color-info-500, #0284c7) 30%, transparent);
+}
diff --git a/frontend/src/components/ui/Badge.tsx b/frontend/src/components/ui/Badge.tsx
new file mode 100644
index 0000000..ca42272
--- /dev/null
+++ b/frontend/src/components/ui/Badge.tsx
@@ -0,0 +1,45 @@
+import { forwardRef } from 'react';
+import type { HTMLAttributes, ReactNode } from 'react';
+import { cx } from './cx';
+import { VisuallyHidden } from './VisuallyHidden';
+import styles from './Badge.module.css';
+
+export type BadgeTone = 'neutral' | 'accent' | 'success' | 'warning' | 'danger' | 'info';
+
+export interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+  tone?: BadgeTone;
+  size?: 'sm' | 'md';
+  /** Leading glyph. Rendered `aria-hidden`. */
+  icon?: ReactNode;
+  /**
+   * Context a sighted user infers from colour or placement but a screen
+   * reader would not, e.g. `"Status:"` before a `"Passed"` badge.
+   */
+  srPrefix?: string;
+}
+
+/**
+ * Static, non-interactive status label. Colour is never the only carrier of
+ * meaning — the badge always contains text, and `srPrefix` adds the context
+ * that position or hue would otherwise imply.
+ */
+export const Badge = forwardRef<HTMLSpanElement, BadgeProps>(function Badge(
+  { tone = 'neutral', size = 'md', icon, srPrefix, className, children, ...rest },
+  ref,
+) {
+  return (
+    <span
+      ref={ref}
+      {...rest}
+      className={cx(styles.badge, styles[tone], styles[size], className)}
+    >
+      {srPrefix !== undefined && <VisuallyHidden>{`${srPrefix} `}</VisuallyHidden>}
+      {icon !== undefined && (
+        <span aria-hidden="true" style={{ display: 'inline-flex' }}>
+          {icon}
+        </span>
+      )}
+      {children}
+    </span>
+  );
+});
diff --git a/frontend/src/components/ui/Button.module.css b/frontend/src/components/ui/Button.module.css
new file mode 100644
index 0000000..36ad496
--- /dev/null
+++ b/frontend/src/components/ui/Button.module.css
@@ -0,0 +1,141 @@
+.button {
+  /* Every size keeps a >=44px hit area per WCAG 2.5.5 Target Size. */
+  --button-min-size: 44px;
+
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  min-height: var(--button-min-size);
+  box-sizing: border-box;
+  margin: 0;
+  font: inherit;
+  font-weight: 600;
+  line-height: 1.2;
+  text-align: center;
+  text-decoration: none;
+  white-space: nowrap;
+  border: 1px solid transparent;
+  border-radius: var(--radius-md, 10px);
+  cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+  transition:
+    background-color var(--duration-fast, 120ms) ease,
+    border-color var(--duration-fast, 120ms) ease,
+    color var(--duration-fast, 120ms) ease,
+    box-shadow var(--duration-fast, 120ms) ease,
+    transform var(--duration-fast, 120ms) ease;
+}
+
+.button:focus-visible {
+  outline: 2px solid var(--color-ring, #2f6bff);
+  outline-offset: 2px;
+}
+
+.button:active:not(.inert) {
+  transform: translateY(1px);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .button {
+    transition: none;
+  }
+  .button:active:not(.inert) {
+    transform: none;
+  }
+}
+
+/* Sizes change padding and type scale, never the 44px floor. */
+.sm {
+  padding: 0 0.75rem;
+  font-size: 0.8125rem;
+}
+
+.md {
+  padding: 0 1rem;
+  font-size: 0.9375rem;
+}
+
+.lg {
+  --button-min-size: 52px;
+  padding: 0 1.375rem;
+  font-size: 1.0625rem;
+  border-radius: var(--radius-lg, 14px);
+}
+
+.primary {
+  background-color: var(--color-accent, #2f6bff);
+  border-color: var(--color-accent, #2f6bff);
+  color: #fff;
+}
+
+.primary:hover:not(.inert) {
+  filter: brightness(1.07);
+}
+
+.secondary {
+  background-color: var(--color-surface, #fff);
+  border-color: var(--color-border-strong, #c7cbd1);
+  color: var(--color-fg, #15171a);
+}
+
+.secondary:hover:not(.inert) {
+  background-color: var(--color-surface-2, #f4f5f7);
+}
+
+.ghost {
+  background-color: transparent;
+  border-color: transparent;
+  color: var(--color-fg-muted, #5b6169);
+}
+
+.ghost:hover:not(.inert) {
+  background-color: var(--color-surface-2, #f4f5f7);
+  color: var(--color-fg, #15171a);
+}
+
+.danger {
+  background-color: var(--color-danger-500, #dc2626);
+  border-color: var(--color-danger-500, #dc2626);
+  color: #fff;
+}
+
+.danger:hover:not(.inert) {
+  filter: brightness(1.07);
+}
+
+.fullWidth {
+  width: 100%;
+}
+
+/* Square hit area; `padding: 0` would let a 16px glyph shrink the target. */
+.iconOnly {
+  gap: 0;
+  padding: 0;
+  min-width: var(--button-min-size);
+  width: var(--button-min-size);
+}
+
+.inert {
+  cursor: not-allowed;
+  opacity: 0.55;
+}
+
+/* `loading` uses aria-disabled, not [disabled], so the control keeps focus
+   and the busy state stays announceable. Pointer events stay enabled so the
+   cursor still communicates the state. */
+.loading {
+  cursor: progress;
+}
+
+.icon {
+  display: inline-flex;
+  flex: 0 0 auto;
+  align-items: center;
+  justify-content: center;
+}
+
+.label {
+  display: inline-block;
+}
diff --git a/frontend/src/components/ui/Button.tsx b/frontend/src/components/ui/Button.tsx
new file mode 100644
index 0000000..c4e1d1d
--- /dev/null
+++ b/frontend/src/components/ui/Button.tsx
@@ -0,0 +1,120 @@
+import { forwardRef } from 'react';
+import type { ButtonHTMLAttributes, MouseEvent, ReactNode } from 'react';
+import { cx } from './cx';
+import { Spinner } from './Spinner';
+import { VisuallyHidden } from './VisuallyHidden';
+import styles from './Button.module.css';
+
+export type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger';
+export type ButtonSize = 'sm' | 'md' | 'lg';
+
+type NativeButtonProps = Omit<
+  ButtonHTMLAttributes<HTMLButtonElement>,
+  'aria-label' | 'children'
+>;
+
+export interface ButtonBaseProps extends NativeButtonProps {
+  variant?: ButtonVariant;
+  size?: ButtonSize;
+  /**
+   * Busy state. Implemented with `aria-busy` + `aria-disabled` rather than
+   * the `disabled` attribute so the button keeps focus while the request is
+   * in flight — a `disabled` button drops out of the tab order and silently
+   * throws focus to `<body>`.
+   */
+  loading?: boolean;
+  /** Visually hidden text announced while `loading`. */
+  loadingLabel?: string;
+  fullWidth?: boolean;
+  leadingIcon?: ReactNode;
+  trailingIcon?: ReactNode;
+  children?: ReactNode;
+}
+
+/**
+ * Icon-only buttons have no text to name them, so the type system requires an
+ * `aria-label`. `<Button iconOnly><X /></Button>` is a compile error.
+ */
+export type ButtonProps = ButtonBaseProps &
+  (
+    | { iconOnly: true; 'aria-label': string }
+    | { iconOnly?: false | undefined; 'aria-label'?: string }
+  );
+
+type ResolvedButtonProps = ButtonBaseProps & {
+  iconOnly?: boolean;
+  'aria-label'?: string;
+};
+
+export const Button = forwardRef<HTMLButtonElement, ButtonProps>(function Button(props, ref) {
+  const {
+    variant = 'primary',
+    size = 'md',
+    loading = false,
+    loadingLabel,
+    fullWidth = false,
+    iconOnly = false,
+    leadingIcon,
+    trailingIcon,
+    className,
+    children,
+    disabled = false,
+    type = 'button',
+    onClick,
+    ...rest
+  } = props as ResolvedButtonProps;
+
+  const inert = disabled || loading;
+  const spinnerSize = size === 'lg' ? 20 : size === 'sm' ? 14 : 16;
+
+  function handleClick(event: MouseEvent<HTMLButtonElement>) {
+    if (loading) {
+      // aria-disabled does not block activation the way [disabled] does.
+      event.preventDefault();
+      event.stopPropagation();
+      return;
+    }
+    onClick?.(event);
+  }
+
+  return (
+    <button
+      ref={ref}
+      {...rest}
+      type={type}
+      disabled={disabled}
+      aria-busy={loading || undefined}
+      aria-disabled={loading || undefined}
+      onClick={handleClick}
+      className={cx(
+        styles.button,
+        styles[variant],
+        styles[size],
+        iconOnly && styles.iconOnly,
+        fullWidth && styles.fullWidth,
+        inert && styles.inert,
+        loading && styles.loading,
+        className,
+      )}
+    >
+      {loading ? (
+        <span className={styles.icon}>
+          <Spinner size={spinnerSize} />
+        </span>
+      ) : (
+        leadingIcon !== undefined && <span className={styles.icon}>{leadingIcon}</span>
+      )}
+      {iconOnly ? (
+        loading ? null : (
+          <span className={styles.icon}>{children}</span>
+        )
+      ) : (
+        children !== undefined && <span className={styles.label}>{children}</span>
+      )}
+      {!iconOnly && trailingIcon !== undefined && (
+        <span className={styles.icon}>{trailingIcon}</span>
+      )}
+      {loading && loadingLabel !== undefined && <VisuallyHidden>{loadingLabel}</VisuallyHidden>}
+    </button>
+  );
+});
diff --git a/frontend/src/components/ui/Card.module.css b/frontend/src/components/ui/Card.module.css
new file mode 100644
index 0000000..495989c
--- /dev/null
+++ b/frontend/src/components/ui/Card.module.css
@@ -0,0 +1,62 @@
+.card {
+  display: block;
+  min-width: 0;
+  box-sizing: border-box;
+  background-color: var(--color-surface, #fff);
+  color: var(--color-fg, #15171a);
+  border: 1px solid var(--color-border, #e3e5e8);
+  border-radius: var(--radius-lg, 14px);
+}
+
+.none {
+  padding: 0;
+}
+
+.sm {
+  padding: 0.75rem;
+}
+
+.md {
+  padding: 1rem;
+}
+
+.lg {
+  padding: 1.5rem;
+}
+
+.raised {
+  box-shadow: var(--shadow-sm, 0 1px 3px rgb(9 11 15 / 8%));
+  border-color: transparent;
+}
+
+.flat {
+  background-color: var(--color-surface-2, #f4f5f7);
+  border-color: transparent;
+}
+
+/* `interactive` only supplies the affordance styling. The card must still be
+   rendered as (or contain) a real button or link — a clickable <div> is not
+   keyboard reachable. */
+.interactive {
+  cursor: pointer;
+  transition:
+    border-color var(--duration-fast, 120ms) ease,
+    box-shadow var(--duration-fast, 120ms) ease,
+    transform var(--duration-fast, 120ms) ease;
+}
+
+.interactive:hover {
+  border-color: var(--color-border-strong, #c7cbd1);
+  box-shadow: var(--shadow-md, 0 6px 16px -6px rgb(9 11 15 / 16%));
+}
+
+.interactive:focus-visible {
+  outline: 2px solid var(--color-ring, #2f6bff);
+  outline-offset: 2px;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .interactive {
+    transition: none;
+  }
+}
diff --git a/frontend/src/components/ui/Card.tsx b/frontend/src/components/ui/Card.tsx
new file mode 100644
index 0000000..2eae7e6
--- /dev/null
+++ b/frontend/src/components/ui/Card.tsx
@@ -0,0 +1,39 @@
+import { forwardRef } from 'react';
+import type { HTMLAttributes } from 'react';
+import { cx } from './cx';
+import styles from './Card.module.css';
+
+export type CardPadding = 'none' | 'sm' | 'md' | 'lg';
+export type CardVariant = 'outlined' | 'raised' | 'flat';
+
+export interface CardProps extends HTMLAttributes<HTMLDivElement> {
+  padding?: CardPadding;
+  variant?: CardVariant;
+  /**
+   * Adds hover/focus affordance styling only. The card still has to *be* a
+   * real control: render the whole card as a `<button>`/`<a>` via `asChild`
+   * patterns in the consumer, or put a focusable control inside it. A
+   * clickable `<div>` is not keyboard reachable and this prop does not make
+   * one.
+   */
+  interactive?: boolean;
+}
+
+export const Card = forwardRef<HTMLDivElement, CardProps>(function Card(
+  { padding = 'md', variant = 'outlined', interactive = false, className, ...rest },
+  ref,
+) {
+  return (
+    <div
+      ref={ref}
+      {...rest}
+      className={cx(
+        styles.card,
+        styles[padding],
+        variant !== 'outlined' && styles[variant],
+        interactive && styles.interactive,
+        className,
+      )}
+    />
+  );
+});
diff --git a/frontend/src/components/ui/Dialog.module.css b/frontend/src/components/ui/Dialog.module.css
new file mode 100644
index 0000000..aab6e71
--- /dev/null
+++ b/frontend/src/components/ui/Dialog.module.css
@@ -0,0 +1,103 @@
+.backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 1000;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 1rem;
+  background-color: rgb(9 11 15 / 55%);
+  overflow-y: auto;
+  animation: dialogFade var(--duration-base, 200ms) ease both;
+}
+
+.panel {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+  width: 100%;
+  max-width: 28rem;
+  max-height: calc(100vh - 2rem);
+  overflow-y: auto;
+  padding: 1.25rem;
+  box-sizing: border-box;
+  background-color: var(--color-surface, #fff);
+  color: var(--color-fg, #15171a);
+  border: 1px solid var(--color-border, #e3e5e8);
+  border-radius: var(--radius-xl, 20px);
+  box-shadow: var(--shadow-lg, 0 24px 48px -12px rgb(9 11 15 / 35%));
+  animation: dialogIn var(--duration-base, 200ms) cubic-bezier(0.2, 0.8, 0.2, 1) both;
+}
+
+.panel:focus-visible {
+  outline: 2px solid var(--color-ring, #2f6bff);
+  outline-offset: 2px;
+}
+
+.sm {
+  max-width: 22rem;
+}
+
+.md {
+  max-width: 28rem;
+}
+
+.lg {
+  max-width: 40rem;
+}
+
+.header {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.75rem;
+}
+
+.heading {
+  flex: 1 1 auto;
+  margin: 0;
+  font-size: 1.0625rem;
+  font-weight: 700;
+  line-height: 1.35;
+}
+
+.description {
+  margin: 0;
+  font-size: 0.875rem;
+  line-height: 1.5;
+  color: var(--color-fg-muted, #5b6169);
+}
+
+.body {
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+}
+
+.footer {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  justify-content: flex-end;
+  margin-top: 0.25rem;
+}
+
+@keyframes dialogFade {
+  from {
+    opacity: 0;
+  }
+}
+
+@keyframes dialogIn {
+  from {
+    opacity: 0;
+    transform: translateY(8px) scale(0.98);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .backdrop,
+  .panel {
+    animation: none;
+  }
+}
diff --git a/frontend/src/components/ui/Dialog.tsx b/frontend/src/components/ui/Dialog.tsx
new file mode 100644
index 0000000..2e22cec
--- /dev/null
+++ b/frontend/src/components/ui/Dialog.tsx
@@ -0,0 +1,232 @@
+import { forwardRef, useCallback, useEffect, useId, useRef } from 'react';
+import { createPortal } from 'react-dom';
+import { X } from 'lucide-react';
+import type { HTMLAttributes, KeyboardEvent, MouseEvent, ReactNode, RefObject } from 'react';
+import { useComposedRef } from './compose-refs';
+import { cx } from './cx';
+import { getFocusableElements } from './focusable';
+import { IconButton } from './IconButton';
+import { lockBodyScroll, unlockBodyScroll } from './scroll-lock';
+import styles from './Dialog.module.css';
+
+export type DialogSize = 'sm' | 'md' | 'lg';
+
+export interface DialogProps
+  extends Omit<HTMLAttributes<HTMLDivElement>, 'role' | 'title' | 'children'> {
+  open: boolean;
+  /** Called for Escape, backdrop click and the close button. */
+  onClose: () => void;
+  /** Accessible name. Wired to the panel through `aria-labelledby`. */
+  title: ReactNode;
+  /** Optional supporting copy. Wired through `aria-describedby`. */
+  description?: ReactNode;
+  children?: ReactNode;
+  footer?: ReactNode;
+  size?: DialogSize;
+  /** Where focus should land on open. Defaults to the first tabbable node. */
+  initialFocusRef?: RefObject<HTMLElement | null>;
+  /** Default true. */
+  closeOnEscape?: boolean;
+  /** Default true. */
+  closeOnBackdropClick?: boolean;
+  /** Default true. */
+  showCloseButton?: boolean;
+  closeLabel?: string;
+  className?: string;
+  backdropClassName?: string;
+  /** Portal host. Defaults to `document.body`. */
+  container?: HTMLElement | null;
+}
+
+/**
+ * Modal dialog implementing the WAI-ARIA dialog (modal) pattern:
+ * `role="dialog"` + `aria-modal`, a name from its title, a Tab/Shift+Tab
+ * focus trap, initial focus, Escape to dismiss, focus restoration to whatever
+ * was focused before opening, and a reference-counted body scroll lock.
+ */
+export const Dialog = forwardRef<HTMLDivElement, DialogProps>(function Dialog(
+  {
+    open,
+    onClose,
+    title,
+    description,
+    children,
+    footer,
+    size = 'md',
+    initialFocusRef,
+    closeOnEscape = true,
+    closeOnBackdropClick = true,
+    showCloseButton = true,
+    closeLabel = 'Close dialog',
+    className,
+    backdropClassName,
+    container,
+    onKeyDown,
+    ...rest
+  },
+  forwardedRef,
+) {
+  const panelRef = useRef<HTMLDivElement | null>(null);
+  const setPanelRef = useComposedRef(forwardedRef, panelRef);
+  const baseId = useId();
+  const titleId = `${baseId}-title`;
+  const descriptionId = `${baseId}-description`;
+
+  // Keep the latest onClose without re-running the focus/scroll effect, which
+  // would restore focus mid-interaction every time the parent re-renders.
+  const onCloseRef = useRef(onClose);
+  useEffect(() => {
+    onCloseRef.current = onClose;
+  }, [onClose]);
+
+  /**
+   * One effect owns the whole open/close lifecycle so the teardown order is
+   * guaranteed: unlock scroll, then hand focus back to the opener.
+   */
+  useEffect(() => {
+    if (!open) return;
+
+    const previouslyFocused =
+      document.activeElement instanceof HTMLElement ? document.activeElement : null;
+
+    lockBodyScroll();
+
+    const panel = panelRef.current;
+    const explicit = initialFocusRef?.current ?? null;
+    const target = explicit ?? getFocusableElements(panel)[0] ?? panel;
+    target?.focus();
+
+    return () => {
+      unlockBodyScroll();
+      // Focus restoration: without this, dismissing the dialog drops focus to
+      // <body> and keyboard users lose their place on the page.
+      if (previouslyFocused && previouslyFocused.isConnected) {
+        previouslyFocused.focus();
+      }
+    };
+  }, [open, initialFocusRef]);
+
+  useEffect(() => {
+    if (!open || !closeOnEscape) return;
+    function handleDocumentKeyDown(event: globalThis.KeyboardEvent) {
+      if (event.key !== 'Escape') return;
+      event.stopPropagation();
+      onCloseRef.current();
+    }
+    // Listen on the document so Escape works even if focus has drifted out.
+    document.addEventListener('keydown', handleDocumentKeyDown, true);
+    return () => document.removeEventListener('keydown', handleDocumentKeyDown, true);
+  }, [open, closeOnEscape]);
+
+  const handlePanelKeyDown = useCallback(
+    (event: KeyboardEvent<HTMLDivElement>) => {
+      onKeyDown?.(event);
+      if (event.defaultPrevented) return;
+      if (event.key !== 'Tab') return;
+
+      const panel = panelRef.current;
+      const focusables = getFocusableElements(panel);
+
+      if (focusables.length === 0) {
+        // Nothing to tab to: keep focus pinned on the panel itself.
+        event.preventDefault();
+        panel?.focus();
+        return;
+      }
+
+      const first = focusables[0];
+      const last = focusables[focusables.length - 1];
+      const active = document.activeElement;
+      const inside = panel ? panel.contains(active) : false;
+
+      if (event.shiftKey) {
+        if (!inside || active === first) {
+          event.preventDefault();
+          last.focus();
+        }
+        return;
+      }
+      if (!inside || active === last) {
+        event.preventDefault();
+        first.focus();
+      }
+    },
+    [onKeyDown],
+  );
+
+  /**
+   * Backdrop dismissal is split across mousedown and click on purpose.
+   *
+   * mousedown records that the press *started* on the backdrop, so a text
+   * selection that begins inside the panel and ends outside it does not
+   * dismiss the dialog. It also calls `preventDefault()`: the default action
+   * of mousedown on a non-focusable element is to move focus to the body,
+   * which would land after our dismissal and throw away the focus we just
+   * restored to the trigger.
+   */
+  const backdropPressRef = useRef(false);
+
+  const handleBackdropMouseDown = useCallback(
+    (event: MouseEvent<HTMLDivElement>) => {
+      const onBackdrop = closeOnBackdropClick && event.target === event.currentTarget;
+      backdropPressRef.current = onBackdrop;
+      if (onBackdrop) event.preventDefault();
+    },
+    [closeOnBackdropClick],
+  );
+
+  const handleBackdropClick = useCallback((event: MouseEvent<HTMLDivElement>) => {
+    if (!backdropPressRef.current) return;
+    backdropPressRef.current = false;
+    if (event.target !== event.currentTarget) return;
+    onCloseRef.current();
+  }, []);
+
+  if (!open) return null;
+  if (typeof document === 'undefined') return null;
+
+  const host = container ?? document.body;
+
+  return createPortal(
+    <div
+      className={cx(styles.backdrop, backdropClassName)}
+      onMouseDown={handleBackdropMouseDown}
+      onClick={handleBackdropClick}
+    >
+      <div
+        ref={setPanelRef}
+        {...rest}
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={titleId}
+        aria-describedby={description !== undefined ? descriptionId : rest['aria-describedby']}
+        tabIndex={-1}
+        onKeyDown={handlePanelKeyDown}
+        className={cx(styles.panel, styles[size], className)}
+      >
+        <div className={styles.header}>
+          <h2 id={titleId} className={styles.heading}>
+            {title}
+          </h2>
+          {showCloseButton && (
+            <IconButton
+              variant="ghost"
+              size="sm"
+              aria-label={closeLabel}
+              onClick={() => onCloseRef.current()}
+              icon={<X size={18} aria-hidden="true" />}
+            />
+          )}
+        </div>
+        {description !== undefined && (
+          <p id={descriptionId} className={styles.description}>
+            {description}
+          </p>
+        )}
+        {children !== undefined && <div className={styles.body}>{children}</div>}
+        {footer !== undefined && <div className={styles.footer}>{footer}</div>}
+      </div>
+    </div>,
+    host,
+  );
+});
diff --git a/frontend/src/components/ui/EmptyState.module.css b/frontend/src/components/ui/EmptyState.module.css
new file mode 100644
index 0000000..16ac2dc
--- /dev/null
+++ b/frontend/src/components/ui/EmptyState.module.css
@@ -0,0 +1,50 @@
+.root {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 0.625rem;
+  padding: 2.5rem 1.25rem;
+  text-align: center;
+  box-sizing: border-box;
+}
+
+.compact {
+  padding: 1.25rem 1rem;
+}
+
+.icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 48px;
+  height: 48px;
+  margin-bottom: 0.25rem;
+  color: var(--color-fg-subtle, #8b9098);
+  background-color: var(--color-surface-2, #f4f5f7);
+  border-radius: var(--radius-full, 999px);
+}
+
+.title {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 700;
+  line-height: 1.35;
+  color: var(--color-fg, #15171a);
+}
+
+.description {
+  margin: 0;
+  max-width: 34ch;
+  font-size: 0.875rem;
+  line-height: 1.55;
+  color: var(--color-fg-muted, #5b6169);
+}
+
+.actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  justify-content: center;
+  margin-top: 0.5rem;
+}
diff --git a/frontend/src/components/ui/EmptyState.tsx b/frontend/src/components/ui/EmptyState.tsx
new file mode 100644
index 0000000..6a3e364
--- /dev/null
+++ b/frontend/src/components/ui/EmptyState.tsx
@@ -0,0 +1,48 @@
+import { createElement, forwardRef } from 'react';
+import type { HTMLAttributes, ReactNode } from 'react';
+import { cx } from './cx';
+import styles from './EmptyState.module.css';
+
+export interface EmptyStateProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+  /** Decorative glyph. Rendered inside an `aria-hidden` wrapper. */
+  icon?: ReactNode;
+  title: ReactNode;
+  description?: ReactNode;
+  /** Usually a `Button`. */
+  action?: ReactNode;
+  /**
+   * Heading level for `title`. Must fit the surrounding document outline —
+   * skipping levels breaks heading navigation. Default 3.
+   */
+  headingLevel?: 2 | 3 | 4 | 5;
+  compact?: boolean;
+}
+
+export const EmptyState = forwardRef<HTMLDivElement, EmptyStateProps>(function EmptyState(
+  {
+    icon,
+    title,
+    description,
+    action,
+    headingLevel = 3,
+    compact = false,
+    className,
+    children,
+    ...rest
+  },
+  ref,
+) {
+  return (
+    <div ref={ref} {...rest} className={cx(styles.root, compact && styles.compact, className)}>
+      {icon !== undefined && (
+        <span className={styles.icon} aria-hidden="true">
+          {icon}
+        </span>
+      )}
+      {createElement(`h${headingLevel}`, { className: styles.title }, title)}
+      {description !== undefined && <p className={styles.description}>{description}</p>}
+      {children}
+      {action !== undefined && <div className={styles.actions}>{action}</div>}
+    </div>
+  );
+});
diff --git a/frontend/src/components/ui/IconButton.tsx b/frontend/src/components/ui/IconButton.tsx
new file mode 100644
index 0000000..a1073c6
--- /dev/null
+++ b/frontend/src/components/ui/IconButton.tsx
@@ -0,0 +1,27 @@
+import { forwardRef } from 'react';
+import type { ReactNode } from 'react';
+import type { ButtonBaseProps } from './Button';
+import { Button } from './Button';
+
+export interface IconButtonProps
+  extends Omit<ButtonBaseProps, 'children' | 'leadingIcon' | 'trailingIcon'> {
+  /** The glyph. Rendered `aria-hidden` is unnecessary — the button's name comes from `aria-label`. */
+  icon: ReactNode;
+  /** Required: an icon has no text, so this is the control's only accessible name. */
+  'aria-label': string;
+}
+
+/**
+ * Thin wrapper over `Button` in icon-only mode. Exists so the 44x44 target
+ * and the mandatory `aria-label` cannot be forgotten at the call site.
+ */
+export const IconButton = forwardRef<HTMLButtonElement, IconButtonProps>(function IconButton(
+  { icon, 'aria-label': ariaLabel, ...rest },
+  ref,
+) {
+  return (
+    <Button ref={ref} {...rest} iconOnly aria-label={ariaLabel}>
+      {icon}
+    </Button>
+  );
+});
diff --git a/frontend/src/components/ui/Progress.module.css b/frontend/src/components/ui/Progress.module.css
new file mode 100644
index 0000000..fecff40
--- /dev/null
+++ b/frontend/src/components/ui/Progress.module.css
@@ -0,0 +1,138 @@
+.barRoot {
+  display: flex;
+  flex-direction: column;
+  gap: 0.375rem;
+  min-width: 0;
+}
+
+.barHeader {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 0.75rem;
+  font-size: 0.8125rem;
+  color: var(--color-fg-muted, #5b6169);
+}
+
+.barLabel {
+  font-weight: 600;
+  color: var(--color-fg, #15171a);
+}
+
+.barTrack {
+  position: relative;
+  width: 100%;
+  overflow: hidden;
+  background-color: var(--color-surface-2, #f4f5f7);
+  border-radius: var(--radius-full, 999px);
+}
+
+.barFill {
+  height: 100%;
+  border-radius: inherit;
+  background-color: var(--color-accent, #2f6bff);
+  transition: width var(--duration-slow, 320ms) cubic-bezier(0.2, 0.8, 0.2, 1);
+}
+
+.success .barFill {
+  background-color: var(--color-success-500, #16a34a);
+}
+
+.warning .barFill {
+  background-color: var(--color-warning-500, #d97706);
+}
+
+.danger .barFill {
+  background-color: var(--color-danger-500, #dc2626);
+}
+
+.info .barFill {
+  background-color: var(--color-info-500, #0284c7);
+}
+
+/* Indeterminate: a sliding sliver instead of a width-driven fill. */
+.indeterminate .barFill {
+  width: 40%;
+  animation: barSlide 1.4s ease-in-out infinite;
+}
+
+@keyframes barSlide {
+  0% {
+    transform: translateX(-100%);
+  }
+  100% {
+    transform: translateX(250%);
+  }
+}
+
+.ringRoot {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  line-height: 1;
+}
+
+.ringSvg {
+  display: block;
+  transform: rotate(-90deg);
+}
+
+.ringTrack {
+  stroke: var(--color-surface-2, #f4f5f7);
+}
+
+.ringFill {
+  stroke: var(--color-accent, #2f6bff);
+  transition: stroke-dashoffset var(--duration-slow, 320ms) cubic-bezier(0.2, 0.8, 0.2, 1);
+}
+
+.success .ringFill {
+  stroke: var(--color-success-500, #16a34a);
+}
+
+.warning .ringFill {
+  stroke: var(--color-warning-500, #d97706);
+}
+
+.danger .ringFill {
+  stroke: var(--color-danger-500, #dc2626);
+}
+
+.info .ringFill {
+  stroke: var(--color-info-500, #0284c7);
+}
+
+.ringCenter {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 0.8125rem;
+  font-weight: 700;
+  color: var(--color-fg, #15171a);
+}
+
+.ringSpin {
+  animation: ringRotate 1.1s linear infinite;
+}
+
+@keyframes ringRotate {
+  to {
+    transform: rotate(270deg);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .barFill,
+  .ringFill {
+    transition: none;
+  }
+  .indeterminate .barFill {
+    animation-duration: 3s;
+  }
+  .ringSpin {
+    animation-duration: 3s;
+  }
+}
diff --git a/frontend/src/components/ui/Progress.tsx b/frontend/src/components/ui/Progress.tsx
new file mode 100644
index 0000000..22efb0c
--- /dev/null
+++ b/frontend/src/components/ui/Progress.tsx
@@ -0,0 +1,214 @@
+import { forwardRef, useId } from 'react';
+import type { HTMLAttributes, ReactNode } from 'react';
+import { cx } from './cx';
+import styles from './Progress.module.css';
+
+export type ProgressTone = 'accent' | 'success' | 'warning' | 'danger' | 'info';
+
+function clampFraction(value: number, min: number, max: number): number {
+  if (max <= min) return 0;
+  const fraction = (value - min) / (max - min);
+  if (Number.isNaN(fraction)) return 0;
+  return Math.min(1, Math.max(0, fraction));
+}
+
+interface ProgressSharedProps {
+  /** Current value. Ignored when `indeterminate`. */
+  value?: number;
+  min?: number;
+  max?: number;
+  tone?: ProgressTone;
+  /**
+   * Work is happening but the amount is unknown. Drops `aria-valuenow`, which
+   * is how assistive tech recognises an indeterminate progressbar.
+   */
+  indeterminate?: boolean;
+  /**
+   * The accessible text alternative, exposed as `aria-valuetext`. Defaults to
+   * a percentage, or `"<value> of <max>"` when the range is not 0-100.
+   */
+  valueText?: string;
+}
+
+function defaultValueText(value: number, min: number, max: number, indeterminate: boolean): string {
+  if (indeterminate) return 'In progress';
+  if (min === 0 && max === 100) return `${Math.round(value)}%`;
+  return `${value} of ${max}`;
+}
+
+type NativeBarProps = Omit<
+  HTMLAttributes<HTMLDivElement>,
+  'role' | 'children' | 'aria-valuenow' | 'aria-valuemin' | 'aria-valuemax' | 'aria-valuetext'
+>;
+
+export interface ProgressBarBaseProps extends NativeBarProps, ProgressSharedProps {
+  /** Visible label above the track. Also names the progressbar. */
+  label?: ReactNode;
+  /** Visible text on the right of the label row, e.g. `"12 / 40"`. */
+  hint?: ReactNode;
+  /** Track thickness in px. Default 8. */
+  thickness?: number;
+}
+
+/**
+ * A progressbar has no implicit accessible name. Supply visible `label` text,
+ * or an ARIA label when surrounding content already explains what is
+ * progressing.
+ */
+export type ProgressBarProps = ProgressBarBaseProps &
+  ({ label: ReactNode } | { 'aria-label': string } | { 'aria-labelledby': string });
+
+export const ProgressBar = forwardRef<HTMLDivElement, ProgressBarProps>(
+  function ProgressBar(props, ref) {
+    const {
+      value = 0,
+      min = 0,
+      max = 100,
+      tone = 'accent',
+      indeterminate = false,
+      valueText,
+      label,
+      hint,
+      thickness = 8,
+      className,
+      style,
+      ...rest
+    } = props as ProgressBarBaseProps;
+
+    const generatedId = useId();
+    const labelId = `${generatedId}-label`;
+    const fraction = clampFraction(value, min, max);
+    const spoken = valueText ?? defaultValueText(value, min, max, indeterminate);
+
+    return (
+      <div className={cx(styles.barRoot, className)}>
+        {(label !== undefined || hint !== undefined) && (
+          <div className={styles.barHeader}>
+            {label !== undefined && (
+              <span id={labelId} className={styles.barLabel}>
+                {label}
+              </span>
+            )}
+            {hint !== undefined && <span>{hint}</span>}
+          </div>
+        )}
+        <div
+          ref={ref}
+          {...rest}
+          role="progressbar"
+          aria-valuenow={indeterminate ? undefined : value}
+          aria-valuemin={min}
+          aria-valuemax={max}
+          aria-valuetext={spoken}
+          aria-labelledby={
+            rest['aria-labelledby'] ??
+            (label !== undefined && rest['aria-label'] === undefined ? labelId : undefined)
+          }
+          className={cx(styles.barTrack, styles[tone], indeterminate && styles.indeterminate)}
+          style={{ height: `${thickness}px`, ...style }}
+        >
+          {/* progressbar is "children presentational" in ARIA, so this fill is
+              invisible to assistive tech either way. */}
+          <div
+            className={styles.barFill}
+            style={indeterminate ? undefined : { width: `${fraction * 100}%` }}
+          />
+        </div>
+      </div>
+    );
+  },
+);
+
+type NativeRingProps = Omit<
+  HTMLAttributes<HTMLDivElement>,
+  'role' | 'aria-valuenow' | 'aria-valuemin' | 'aria-valuemax' | 'aria-valuetext'
+>;
+
+export interface ProgressRingBaseProps extends NativeRingProps, ProgressSharedProps {
+  /** Outer diameter in px. Default 56. */
+  size?: number;
+  /** Stroke width in px. Default 6. */
+  thickness?: number;
+  /**
+   * Content in the middle of the ring. Rendered `aria-hidden`; the spoken
+   * value comes from `aria-valuetext`.
+   */
+  children?: ReactNode;
+}
+
+/** Same naming requirement as `ProgressBar`. */
+export type ProgressRingProps = ProgressRingBaseProps &
+  ({ 'aria-label': string } | { 'aria-labelledby': string });
+
+export const ProgressRing = forwardRef<HTMLDivElement, ProgressRingProps>(
+  function ProgressRing(props, ref) {
+    const {
+      value = 0,
+      min = 0,
+      max = 100,
+      tone = 'accent',
+      indeterminate = false,
+      valueText,
+      size = 56,
+      thickness = 6,
+      className,
+      style,
+      children,
+      ...rest
+    } = props as ProgressRingBaseProps;
+
+    const fraction = clampFraction(value, min, max);
+    const spoken = valueText ?? defaultValueText(value, min, max, indeterminate);
+    const radius = (size - thickness) / 2;
+    const circumference = 2 * Math.PI * radius;
+    const dashOffset = indeterminate ? circumference * 0.75 : circumference * (1 - fraction);
+
+    return (
+      <div
+        ref={ref}
+        {...rest}
+        role="progressbar"
+        aria-valuenow={indeterminate ? undefined : value}
+        aria-valuemin={min}
+        aria-valuemax={max}
+        aria-valuetext={spoken}
+        className={cx(styles.ringRoot, styles[tone], className)}
+        style={{ width: `${size}px`, height: `${size}px`, ...style }}
+      >
+        <svg
+          className={cx(styles.ringSvg, indeterminate && styles.ringSpin)}
+          width={size}
+          height={size}
+          viewBox={`0 0 ${size} ${size}`}
+          aria-hidden="true"
+          focusable="false"
+        >
+          <circle
+            className={styles.ringTrack}
+            cx={size / 2}
+            cy={size / 2}
+            r={radius}
+            fill="none"
+            strokeWidth={thickness}
+          />
+          <circle
+            className={styles.ringFill}
+            cx={size / 2}
+            cy={size / 2}
+            r={radius}
+            fill="none"
+            strokeWidth={thickness}
+            strokeLinecap="round"
+            strokeDasharray={circumference}
+            strokeDashoffset={dashOffset}
+          />
+        </svg>
+        {children !== undefined && (
+          <span className={styles.ringCenter} aria-hidden="true">
+            {children}
+          </span>
+        )}
+      </div>
+    );
+  },
+);
diff --git a/frontend/src/components/ui/README.md b/frontend/src/components/ui/README.md
new file mode 100644
index 0000000..1825dff
--- /dev/null
+++ b/frontend/src/components/ui/README.md
@@ -0,0 +1,367 @@
+# UI primitives
+
+Accessible, dependency-light building blocks. Import from the barrel:
+
+```tsx
+import { Button, Dialog, RadioGroup, Radio } from '@/components/ui';
+// or, in this repo's current setup:
+import { Button, Dialog, RadioGroup, Radio } from '../components/ui';
+```
+
+## What every primitive guarantees
+
+| Guarantee | How |
+| --- | --- |
+| Visible focus indicator | `:focus-visible { outline: 2px solid var(--color-ring) }` with a 2px offset on every focusable element. Never `outline: none`. |
+| Minimum 44x44px target | `min-height: 44px` on all interactive primitives at every size; icon-only buttons also get `min-width: 44px`. Size variants change padding and type scale, never the floor. (WCAG 2.5.5) |
+| Reduced motion | Every animation and transition is disabled or de-emphasised under `@media (prefers-reduced-motion: reduce)`. Spinners swap rotation for an opacity pulse so "busy" is still conveyed. |
+| `className` passthrough | Merged **after** the component's own classes, so consumer rules win at equal specificity. |
+| Forwarded ref | Every component is a `forwardRef` onto the real DOM element. |
+| Styling | CSS Modules reading `var(--color-…)` / `var(--radius-…)` / `var(--shadow-…)` / `var(--duration-…)` tokens, each with a hard-coded fallback so the components render correctly even before the token layer lands. No Tailwind utility classes are assumed. |
+| Colour is never the only signal | State is always paired with a glyph and/or visually hidden text (WCAG 1.4.1). |
+
+Zero runtime dependencies beyond `react`, `react-dom` and `lucide-react` (icons only).
+
+### A note on `disabled`
+
+Across this folder, "unavailable" is expressed as `aria-disabled` rather than the
+`disabled` attribute wherever the control still needs to be **readable**. A
+`disabled` element is removed from the tab order and, in several
+browser/screen-reader combinations, effectively from the accessibility tree.
+`Button` is the exception: an explicitly `disabled` Button really is `disabled`,
+because that is what callers expect from a form control. Even there, `loading`
+uses `aria-disabled` + `aria-busy` so focus is not thrown to `<body>` mid-request.
+
+---
+
+## Button
+
+```tsx
+<Button variant="primary" size="md" loading={saving} leadingIcon={<Save size={16} />}>
+  Save attempt
+</Button>
+
+<Button iconOnly aria-label="Bookmark question">
+  <Bookmark size={18} />
+</Button>
+```
+
+| Prop | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `variant` | `'primary' \| 'secondary' \| 'ghost' \| 'danger'` | `'primary'` | |
+| `size` | `'sm' \| 'md' \| 'lg'` | `'md'` | All sizes keep the 44px floor. |
+| `loading` | `boolean` | `false` | `aria-busy` + `aria-disabled`, spinner replaces `leadingIcon`, clicks swallowed, **stays focusable**. |
+| `loadingLabel` | `string` | — | Visually hidden text appended while loading. |
+| `iconOnly` | `boolean` | `false` | Square 44x44 target. **Requires `aria-label`.** |
+| `fullWidth` | `boolean` | `false` | |
+| `leadingIcon` / `trailingIcon` | `ReactNode` | — | Wrapped in a flex span. |
+| `disabled` | `boolean` | `false` | Real `disabled` attribute. |
+
+**a11y guarantees** — native `<button type="button">`, so Space and Enter
+activation come from the platform. `loading` never removes the button from the
+tab order. The type system rejects an icon-only button with no accessible name:
+
+```tsx
+<Button iconOnly><X /></Button>
+// ✗ Property ''aria-label'' is missing in type ... but required in type
+//   '{ iconOnly: true; 'aria-label': string; }'
+```
+
+## IconButton
+
+```tsx
+<IconButton aria-label="Close dialog" icon={<X size={18} />} variant="ghost" />
+```
+
+Thin wrapper over `Button` in icon-only mode. `icon` and `aria-label` are both
+required props, so the 44x44 target and the accessible name cannot be forgotten
+at the call site.
+
+## RadioGroup + Radio
+
+The full WAI-ARIA [radiogroup](https://www.w3.org/WAI/ARIA/apg/patterns/radio/)
+pattern. This is the one to reach for for quiz options.
+
+```tsx
+<RadioGroup
+  aria-label="Answer options"
+  value={selected}
+  onValueChange={setSelected}
+  readOnly={submitted}
+>
+  {options.map((option, index) => (
+    <Radio
+      key={option.id}
+      value={option.id}
+      state={
+        !submitted ? undefined
+        : index === correctIndex ? 'correct'
+        : option.id === selected ? 'incorrect'
+        : 'neutral'
+      }
+    >
+      {option.text}
+    </Radio>
+  ))}
+</RadioGroup>
+```
+
+### RadioGroup props
+
+| Prop | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `value` | `string \| null` | — | Controlled. `null` = nothing chosen. |
+| `defaultValue` | `string \| null` | `null` | Uncontrolled. |
+| `onValueChange` | `(value: string) => void` | — | Fires for clicks and arrow-key selection. |
+| `readOnly` | `boolean` | `false` | Review mode — see below. |
+| `disabled` | `boolean` | `false` | Whole group inert, via `aria-disabled`. |
+| `orientation` | `'vertical' \| 'horizontal'` | `'vertical'` | Sets `aria-orientation`. Both axes of arrow key work either way. |
+| `name` | `string` | — | Emits a hidden input for form submission. |
+| `required` | `boolean` | `false` | Sets `aria-required`. |
+| `aria-label` **or** `aria-labelledby` | `string` | — | **One is required by the type system.** |
+
+### Radio props
+
+| Prop | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `value` | `string` | — | Required. Mirrored to `data-value` for navigation. |
+| `state` | `'neutral' \| 'selected' \| 'correct' \| 'incorrect'` | derived | Defaults to `selected` when checked, else `neutral`. |
+| `stateLabel` | `string \| null` | `'Correct answer'` / `'Incorrect answer'` | Visually hidden text so the revealed state is **announced**, not colour-only. `null` suppresses. |
+| `description` | `ReactNode` | — | Secondary line. |
+| `disabled` | `boolean` | `false` | This option only, via `aria-disabled`. |
+| `showIndicator` | `boolean` | `true` | The leading bullet/tick/cross. |
+
+### Keyboard interactions
+
+| Key | Behaviour |
+| --- | --- |
+| `Tab` / `Shift+Tab` | Enters or leaves the group as **one single tab stop**. |
+| `↓` / `→` | Move focus to the next option (wrapping) **and select it**. |
+| `↑` / `←` | Move focus to the previous option (wrapping) **and select it**. |
+| `Home` | Move focus to the first option and select it. |
+| `End` | Move focus to the last option and select it. |
+| `Space` / `Enter` | Select the focused option without moving focus (native button activation). |
+| Any arrow + `Ctrl`/`Alt`/`Meta` | Ignored, so browser and screen-reader shortcuts keep working. |
+
+Typeahead is deliberately not implemented — it is not part of the radiogroup pattern.
+
+**Roving tabindex.** Exactly one option is tabbable at any moment: the selected
+one, or the first option when nothing is selected yet. Options always *render*
+`tabIndex={-1}` — a constant, so React never patches the attribute after mount —
+and a layout effect on the group owns the single `0`. Option order comes from a
+DOM query, so arrow-key order always matches visual order even when options are
+wrapped, reordered or conditionally rendered.
+
+**`readOnly` (post-answer review).** Selection is locked, but:
+
+- options keep `aria-disabled`, **never** the `disabled` attribute, so the
+  revealed correct answer stays in the accessibility tree;
+- every option stays focusable and reachable with the arrow keys and `Home`/`End`;
+- the group is marked `aria-readonly="true"`;
+- `correct` / `incorrect` carry visually hidden text, so the outcome does not
+  depend on seeing green and red;
+- the tab stop stays on the locked answer.
+
+## Dialog
+
+WAI-ARIA modal dialog, rendered through a portal.
+
+```tsx
+<Dialog
+  open={open}
+  onClose={() => setOpen(false)}
+  title="What should we call you?"
+  description="Only used to personalise your report."
+  initialFocusRef={inputRef}
+  footer={<Button onClick={save}>Save</Button>}
+>
+  <input ref={inputRef} aria-label="Your name" />
+</Dialog>
+```
+
+| Prop | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `open` | `boolean` | — | Returns `null` when false; nothing is mounted. |
+| `onClose` | `() => void` | — | Escape, backdrop and close button. |
+| `title` | `ReactNode` | — | Rendered as an `<h2>` and wired via `aria-labelledby`. |
+| `description` | `ReactNode` | — | Wired via `aria-describedby`. |
+| `footer` | `ReactNode` | — | Right-aligned action row. |
+| `size` | `'sm' \| 'md' \| 'lg'` | `'md'` | |
+| `initialFocusRef` | `RefObject<HTMLElement \| null>` | — | Defaults to the first tabbable node. |
+| `closeOnEscape` | `boolean` | `true` | |
+| `closeOnBackdropClick` | `boolean` | `true` | |
+| `showCloseButton` | `boolean` | `true` | |
+| `closeLabel` | `string` | `'Close dialog'` | |
+| `container` | `HTMLElement \| null` | `document.body` | Portal host. |
+
+### Keyboard interactions
+
+| Key | Behaviour |
+| --- | --- |
+| `Escape` | Closes (document-level capture listener, so it works even if focus has drifted). |
+| `Tab` | Moves through the dialog's tabbable nodes; from the **last** one it wraps to the first. |
+| `Shift+Tab` | Moves backwards; from the **first** one it wraps to the last. |
+| `Tab` with focus outside the panel | Pulled back to the first tabbable node. |
+| `Tab` with nothing tabbable inside | Focus is pinned on the panel itself. |
+
+**a11y guarantees** — `role="dialog"` + `aria-modal="true"`, named by its title.
+On open: the previously focused element is recorded, body scroll is locked
+(reference-counted, so stacked overlays behave), and focus moves inside. On
+close: scroll unlocks and focus returns to the element that opened the dialog —
+checked with `isConnected` so a removed trigger does not throw. Backdrop
+dismissal is split across `mousedown` (records that the press started on the
+backdrop, and `preventDefault()`s the default body-focus) and `click`, so a text
+selection dragged out of the panel does not dismiss, and the restored focus is
+not immediately blurred.
+
+## Switch
+
+```tsx
+<Switch checked={darkMode} onCheckedChange={setDarkMode}>Dark mode</Switch>
+<Switch aria-label="Timer" defaultChecked />
+```
+
+| Prop | Type | Default |
+| --- | --- | --- |
+| `checked` / `defaultChecked` | `boolean` | `false` |
+| `onCheckedChange` | `(checked: boolean) => void` | — |
+| `size` | `'sm' \| 'md'` | `'md'` |
+| `disabled` | `boolean` | `false` |
+| `children` | `ReactNode` | — |
+
+**a11y guarantees** — real `role="switch"` with `aria-checked` on a native
+`<button>`. **Space** activation comes from the platform (a `<button>` does not
+scroll the page on Space); **Enter** is wired explicitly with `preventDefault()`
+so it cannot double-toggle. Tested for exactly one toggle per press on both
+keys. The type system requires either visible `children` or an ARIA label.
+`disabled` uses `aria-disabled`, keeping the control focusable and its state
+announceable.
+
+## Tabs
+
+```tsx
+<Tabs defaultValue="all">
+  <TabList aria-label="Bookmark filters">
+    <Tab value="all">All</Tab>
+    <Tab value="flagged">Flagged</Tab>
+  </TabList>
+  <TabPanel value="all">…</TabPanel>
+  <TabPanel value="flagged">…</TabPanel>
+</Tabs>
+```
+
+| Component | Props |
+| --- | --- |
+| `Tabs` | `value` + `onValueChange` (controlled) **or** `defaultValue` (uncontrolled) — one is required by the type system; `orientation` (`'horizontal'`), `activationMode` (`'automatic' \| 'manual'`, default `automatic`). |
+| `TabList` | `aria-label` **or** `aria-labelledby` — one required. |
+| `Tab` | `value` (required), `disabled`. |
+| `TabPanel` | `value` (required), `keepMounted` (default `false`). |
+
+### Keyboard interactions
+
+| Key | Behaviour |
+| --- | --- |
+| `→` / `←` (horizontal) or `↓` / `↑` (vertical) | Move focus to the next/previous enabled tab, wrapping. In `automatic` mode this also selects it. |
+| `Home` / `End` | First / last enabled tab. |
+| `Space` / `Enter` | Selects the focused tab (needed in `manual` mode). |
+| `Tab` | Leaves the tablist and lands on the active panel. |
+
+**a11y guarantees** — `role="tablist"` (with `aria-orientation`) / `role="tab"`
+(with `aria-selected` and `aria-controls`) / `role="tabpanel"` (with
+`aria-labelledby`), ids generated with `useId` and slugified from the tab value.
+Roving tabindex makes the whole tablist one tab stop. The panel carries
+`tabIndex={0}` so keyboard users reach non-focusable panel content. Disabled
+tabs use `aria-disabled` and are skipped by the arrow keys. The strip scrolls
+horizontally with `scroll-snap-type: x proximity` and a hidden scrollbar, and
+the newly focused tab is scrolled into view.
+
+## ProgressBar / ProgressRing
+
+```tsx
+<ProgressBar label="Chapter progress" value={12} max={40} hint="12 / 40" />
+<ProgressRing aria-label="Mock test score" value={82}>82%</ProgressRing>
+```
+
+| Prop | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `value` | `number` | `0` | |
+| `min` / `max` | `number` | `0` / `100` | |
+| `indeterminate` | `boolean` | `false` | Drops `aria-valuenow`, which is how AT recognises an indeterminate bar. |
+| `valueText` | `string` | `"42%"` or `"12 of 40"` | The accessible text alternative (`aria-valuetext`). |
+| `tone` | `'accent' \| 'success' \| 'warning' \| 'danger' \| 'info'` | `'accent'` | |
+| `label` / `hint` (bar) | `ReactNode` | — | Visible label row; `label` also names the bar. |
+| `thickness` | `number` | `8` (bar) / `6` (ring) | px |
+| `size` (ring) | `number` | `56` | px diameter |
+| `children` (ring) | `ReactNode` | — | Centre content, rendered `aria-hidden`. |
+
+**a11y guarantees** — `role="progressbar"` with `aria-valuenow`/`-valuemin`/
+`-valuemax`/`-valuetext`. A name is required by the type system: visible `label`
+text (bar) or an ARIA label. Out-of-range values are clamped visually rather
+than overflowing the track. Fill elements are not labelled, since `progressbar`
+is "children presentational" in ARIA.
+
+## Toast + useToast
+
+```tsx
+<ToastProvider duration={5000} placement="topRight">
+  <App />
+</ToastProvider>
+
+const { toast, dismiss, dismissAll } = useToast();
+toast({ title: 'Attempt saved', description: 'Synced to your profile', tone: 'success' });
+```
+
+| `ToastProvider` prop | Type | Default |
+| --- | --- | --- |
+| `placement` | `'topRight' \| 'topCenter' \| 'bottomRight' \| 'bottomCenter'` | `'topRight'` |
+| `duration` | `number` (ms, `0` = sticky) | `5000` |
+| `max` | `number` | `4` |
+| `dismissLabel` | `string` | `'Dismiss notification'` |
+| `container` | `HTMLElement \| null` | `document.body` |
+
+| `toast(options)` | Type | Notes |
+| --- | --- | --- |
+| `title` / `description` | `ReactNode` | |
+| `tone` | `'neutral' \| 'success' \| 'warning' \| 'danger' \| 'info'` | |
+| `duration` | `number` | Overrides the provider default. `0` = sticky. |
+| `action` | `ReactNode` | Usually a `Button`. |
+| `politeness` | `'polite' \| 'assertive'` | `polite` by default; `assertive` only for blocking errors. |
+
+**a11y guarantees** — two live regions (`role="status"` / `aria-live="polite"`
+and `role="alert"` / `aria-live="assertive"`) are kept **permanently mounted**,
+because a live region has to exist before content is inserted into it or the
+insertion is not announced. Auto-dismiss pauses while the toast is hovered *or*
+while focus is anywhere inside it, and resumes with the unspent time banked
+(WCAG 2.2.1 Timing Adjustable) — so a toast with an action never disappears
+mid-reach. The viewport is `pointer-events: none` with `pointer-events: auto`
+on each toast, so it never blocks the page beneath. `useToast()` throws outside
+a provider rather than silently swallowing notifications.
+
+## Badge / Card / Skeleton / Spinner / EmptyState / Separator / VisuallyHidden
+
+| Component | Key props | a11y notes |
+| --- | --- | --- |
+| `Badge` | `tone`, `size`, `icon`, `srPrefix` | Static text, never interactive. `srPrefix` adds the context that colour or position would otherwise imply (e.g. `"Status:"`). `icon` is `aria-hidden`. |
+| `Card` | `padding`, `variant`, `interactive` | `interactive` adds hover/focus affordance **styling only** — it does not make a `<div>` keyboard reachable. Render a real `<button>`/`<a>`, or put a focusable control inside. |
+| `Skeleton` | `variant`, `width`, `height`, `lines` | Always `aria-hidden`: a shimmering box means nothing to a screen reader, and a dozen of them is noise. Announce loading once on the owning region. Shimmer stops under reduced motion. |
+| `Spinner` | `size`, `thickness`, `label` | With `label` it is a `role="status"` live region; without, it is `aria-hidden` and decorative (correct when a parent already carries `aria-busy`). Rotation becomes an opacity pulse under reduced motion. |
+| `EmptyState` | `icon`, `title`, `description`, `action`, `headingLevel`, `compact` | Renders a real heading (`h2`–`h5` via `headingLevel`, default `3`) so it appears in heading navigation. Pick the level that fits the surrounding outline — skipping levels breaks it. |
+| `Separator` | `orientation`, `decorative`, `label` | `decorative` (default `true`) renders `role="none"` so it adds no meaningless screen-reader stop; `decorative={false}` renders `role="separator"` with `aria-orientation`. A `label` forces a meaningful separator. |
+| `VisuallyHidden` | — | Clip-path recipe: off-screen visually, present in the accessibility tree and in copied text. |
+
+## Helpers
+
+`cx(...classes)` — class joiner. `getFocusableElements(root)` — tabbable
+descendants in document order (deliberately not `offsetParent`-based, so it
+works under jsdom). `lockBodyScroll()` / `unlockBodyScroll()` —
+reference-counted scroll lock. `useComposedRef(forwardedRef, localRef)` — keep
+an internal ref while honouring a forwarded one. `tabId` / `tabPanelId` — the
+id scheme used to wire tabs to panels.
+
+## Tests
+
+`__tests__/RadioGroup.test.tsx`, `__tests__/Dialog.test.tsx` and
+`__tests__/primitives.test.tsx` — 65 tests, run with `npx vitest run src/components/ui`.
+The RadioGroup and Dialog suites exist because those two patterns fail
+*silently*: a missing roving tabindex or a broken focus trap looks completely
+fine on screen.
diff --git a/frontend/src/components/ui/RadioGroup.module.css b/frontend/src/components/ui/RadioGroup.module.css
new file mode 100644
index 0000000..ed8f520
--- /dev/null
+++ b/frontend/src/components/ui/RadioGroup.module.css
@@ -0,0 +1,136 @@
+.group {
+  display: flex;
+  flex-direction: column;
+  gap: 0.625rem;
+}
+
+.horizontal {
+  flex-direction: row;
+  flex-wrap: wrap;
+}
+
+.radio {
+  /* 44px floor applies to the option row too — these are the primary touch
+     targets of the whole quiz surface. */
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  width: 100%;
+  min-height: 44px;
+  box-sizing: border-box;
+  padding: 0.75rem 1rem;
+  margin: 0;
+  font: inherit;
+  font-size: 0.9375rem;
+  line-height: 1.45;
+  text-align: left;
+  color: var(--color-fg, #15171a);
+  background-color: var(--color-surface, #fff);
+  border: 1px solid var(--color-border, #e3e5e8);
+  border-radius: var(--radius-md, 10px);
+  cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+  transition:
+    background-color var(--duration-fast, 120ms) ease,
+    border-color var(--duration-fast, 120ms) ease,
+    box-shadow var(--duration-fast, 120ms) ease;
+}
+
+.radio:focus-visible {
+  outline: 2px solid var(--color-ring, #2f6bff);
+  outline-offset: 2px;
+}
+
+.radio:hover:not(.inert) {
+  border-color: var(--color-border-strong, #c7cbd1);
+  background-color: var(--color-surface-2, #f4f5f7);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .radio {
+    transition: none;
+  }
+}
+
+.horizontal .radio {
+  width: auto;
+}
+
+/* --- visual states -------------------------------------------------------
+   Each state pairs colour with a glyph in the indicator, so the state is not
+   conveyed by hue alone (WCAG 1.4.1 Use of Color). */
+
+.selected {
+  border-color: var(--color-accent, #2f6bff);
+  background-color: var(--color-surface, #fff);
+  box-shadow: inset 0 0 0 1px var(--color-accent, #2f6bff);
+}
+
+.correct {
+  border-color: var(--color-success-500, #16a34a);
+  box-shadow: inset 0 0 0 1px var(--color-success-500, #16a34a);
+}
+
+.incorrect {
+  border-color: var(--color-danger-500, #dc2626);
+  box-shadow: inset 0 0 0 1px var(--color-danger-500, #dc2626);
+}
+
+/* aria-disabled styling. Intentionally NOT `pointer-events: none` and never
+   the [disabled] attribute: the revealed answer must stay focusable and
+   readable after submission. */
+.inert {
+  cursor: default;
+}
+
+.disabledOption {
+  opacity: 0.55;
+  cursor: not-allowed;
+}
+
+.indicator {
+  display: inline-flex;
+  flex: 0 0 auto;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  font-size: 12px;
+  font-weight: 700;
+  line-height: 1;
+  color: transparent;
+  border: 1.5px solid var(--color-border-strong, #c7cbd1);
+  border-radius: var(--radius-full, 999px);
+  background-color: var(--color-surface, #fff);
+}
+
+.selected .indicator {
+  border-color: var(--color-accent, #2f6bff);
+  background-color: var(--color-accent, #2f6bff);
+  color: #fff;
+}
+
+.correct .indicator {
+  border-color: var(--color-success-500, #16a34a);
+  background-color: var(--color-success-500, #16a34a);
+  color: #fff;
+}
+
+.incorrect .indicator {
+  border-color: var(--color-danger-500, #dc2626);
+  background-color: var(--color-danger-500, #dc2626);
+  color: #fff;
+}
+
+.content {
+  display: flex;
+  flex-direction: column;
+  gap: 0.125rem;
+  min-width: 0;
+}
+
+.description {
+  font-size: 0.8125rem;
+  font-weight: 400;
+  color: var(--color-fg-muted, #5b6169);
+}
diff --git a/frontend/src/components/ui/RadioGroup.tsx b/frontend/src/components/ui/RadioGroup.tsx
new file mode 100644
index 0000000..7562e26
--- /dev/null
+++ b/frontend/src/components/ui/RadioGroup.tsx
@@ -0,0 +1,320 @@
+import {
+  createContext,
+  forwardRef,
+  useCallback,
+  useContext,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+import type { ButtonHTMLAttributes, HTMLAttributes, KeyboardEvent, ReactNode } from 'react';
+import { useComposedRef } from './compose-refs';
+import { cx } from './cx';
+import { VisuallyHidden } from './VisuallyHidden';
+import styles from './RadioGroup.module.css';
+
+export type RadioVisualState = 'neutral' | 'selected' | 'correct' | 'incorrect';
+
+interface RadioGroupContextValue {
+  value: string | null;
+  readOnly: boolean;
+  groupDisabled: boolean;
+  select: (value: string) => void;
+}
+
+const RadioGroupContext = createContext<RadioGroupContextValue | null>(null);
+
+/**
+ * Options in document order. The group reads the DOM rather than keeping a
+ * registry so arrow-key order always matches visual order, even when options
+ * are wrapped, reordered or conditionally rendered.
+ */
+function getRadios(root: HTMLElement | null): HTMLElement[] {
+  if (!root) return [];
+  return Array.from(root.querySelectorAll<HTMLElement>('[role="radio"]'));
+}
+
+type NativeGroupProps = Omit<
+  HTMLAttributes<HTMLDivElement>,
+  'role' | 'onChange' | 'aria-label' | 'aria-labelledby' | 'defaultValue'
+>;
+
+export interface RadioGroupBaseProps extends NativeGroupProps {
+  /** Controlled selection. `null` means "nothing chosen yet". */
+  value?: string | null;
+  /** Uncontrolled initial selection. */
+  defaultValue?: string | null;
+  onValueChange?: (value: string) => void;
+  /** Emits a hidden input so the group can participate in form submission. */
+  name?: string;
+  orientation?: 'horizontal' | 'vertical';
+  /**
+   * Review mode. Options stay focusable and in the accessibility tree
+   * (`aria-disabled`, never `disabled`) but selection no longer changes, so a
+   * revealed correct answer can still be reached and read.
+   */
+  readOnly?: boolean;
+  /** Whole group unavailable. Still uses `aria-disabled`, not `disabled`. */
+  disabled?: boolean;
+  required?: boolean;
+  children?: ReactNode;
+}
+
+/** A radiogroup must be named. One of the two ARIA labelling props is required. */
+export type RadioGroupProps = RadioGroupBaseProps &
+  (
+    | { 'aria-label': string; 'aria-labelledby'?: undefined }
+    | { 'aria-labelledby': string; 'aria-label'?: undefined }
+  );
+
+type ResolvedRadioGroupProps = RadioGroupBaseProps & {
+  'aria-label'?: string;
+  'aria-labelledby'?: string;
+};
+
+export const RadioGroup = forwardRef<HTMLDivElement, RadioGroupProps>(
+  function RadioGroup(props, forwardedRef) {
+    const {
+      value,
+      defaultValue = null,
+      onValueChange,
+      name,
+      orientation = 'vertical',
+      readOnly = false,
+      disabled = false,
+      required = false,
+      className,
+      children,
+      onKeyDown,
+      'aria-label': ariaLabel,
+      'aria-labelledby': ariaLabelledBy,
+      ...rest
+    } = props as ResolvedRadioGroupProps;
+
+    const groupRef = useRef<HTMLDivElement | null>(null);
+    const setRef = useComposedRef(forwardedRef, groupRef);
+
+    const [uncontrolledValue, setUncontrolledValue] = useState<string | null>(defaultValue);
+    const isControlled = value !== undefined;
+    const currentValue = value !== undefined ? value : uncontrolledValue;
+
+    const select = useCallback(
+      (next: string) => {
+        if (!isControlled) setUncontrolledValue(next);
+        onValueChange?.(next);
+      },
+      [isControlled, onValueChange],
+    );
+
+    /**
+     * Roving tabindex. Exactly one option is tabbable: the selected one, or
+     * the first option when nothing is selected yet. Options always *render*
+     * `tabIndex={-1}` (a constant, so React never patches the attribute
+     * afterwards) and this effect owns the single `0`.
+     */
+    useLayoutEffect(() => {
+      const radios = getRadios(groupRef.current);
+      if (radios.length === 0) return;
+      let activeIndex = radios.findIndex((radio) => radio.dataset.value === currentValue);
+      if (activeIndex < 0) activeIndex = 0;
+      radios.forEach((radio, index) => {
+        radio.tabIndex = index === activeIndex ? 0 : -1;
+      });
+    });
+
+    const moveTo = useCallback(
+      (radios: HTMLElement[], index: number) => {
+        const target = radios[index];
+        if (!target) return;
+        target.focus();
+        // Arrow keys both move and select, per the WAI-ARIA radiogroup
+        // pattern — except in review/disabled mode where focus may move but
+        // the answer is locked.
+        if (readOnly || disabled) return;
+        if (target.getAttribute('aria-disabled') === 'true') return;
+        const nextValue = target.dataset.value;
+        if (nextValue !== undefined) select(nextValue);
+      },
+      [disabled, readOnly, select],
+    );
+
+    const handleKeyDown = useCallback(
+      (event: KeyboardEvent<HTMLDivElement>) => {
+        onKeyDown?.(event);
+        if (event.defaultPrevented) return;
+        if (event.ctrlKey || event.metaKey || event.altKey) return;
+
+        const radios = getRadios(groupRef.current);
+        if (radios.length === 0) return;
+
+        const active = document.activeElement;
+        const currentIndex = radios.findIndex(
+          (radio) => radio === active || radio.contains(active),
+        );
+
+        let nextIndex: number;
+        switch (event.key) {
+          case 'ArrowDown':
+          case 'ArrowRight':
+            nextIndex = currentIndex < 0 ? 0 : (currentIndex + 1) % radios.length;
+            break;
+          case 'ArrowUp':
+          case 'ArrowLeft':
+            nextIndex =
+              currentIndex < 0
+                ? radios.length - 1
+                : (currentIndex - 1 + radios.length) % radios.length;
+            break;
+          case 'Home':
+            nextIndex = 0;
+            break;
+          case 'End':
+            nextIndex = radios.length - 1;
+            break;
+          default:
+            return;
+        }
+
+        // Stop the arrow keys from scrolling the page.
+        event.preventDefault();
+        moveTo(radios, nextIndex);
+      },
+      [moveTo, onKeyDown],
+    );
+
+    const contextValue = useMemo<RadioGroupContextValue>(
+      () => ({ value: currentValue, readOnly, groupDisabled: disabled, select }),
+      [currentValue, disabled, readOnly, select],
+    );
+
+    return (
+      <div
+        ref={setRef}
+        {...rest}
+        role="radiogroup"
+        aria-label={ariaLabel}
+        aria-labelledby={ariaLabelledBy}
+        aria-orientation={orientation}
+        aria-required={required || undefined}
+        aria-readonly={readOnly || undefined}
+        aria-disabled={disabled || undefined}
+        onKeyDown={handleKeyDown}
+        className={cx(styles.group, orientation === 'horizontal' && styles.horizontal, className)}
+      >
+        <RadioGroupContext.Provider value={contextValue}>{children}</RadioGroupContext.Provider>
+        {name !== undefined && <input type="hidden" name={name} value={currentValue ?? ''} />}
+      </div>
+    );
+  },
+);
+
+type NativeRadioProps = Omit<
+  ButtonHTMLAttributes<HTMLButtonElement>,
+  'value' | 'type' | 'disabled' | 'role' | 'aria-checked' | 'tabIndex'
+>;
+
+export interface RadioProps extends NativeRadioProps {
+  /** Stable identity of this option. Also mirrored to `data-value` for navigation. */
+  value: string;
+  /** This option alone is unavailable. Rendered with `aria-disabled`. */
+  disabled?: boolean;
+  /**
+   * Visual state. Defaults to `selected` when checked and `neutral`
+   * otherwise. Pass `correct`/`incorrect` for post-answer review.
+   */
+  state?: RadioVisualState;
+  /**
+   * Visually hidden text that makes `correct`/`incorrect` audible rather than
+   * colour-only. Defaults to "Correct answer" / "Incorrect answer"; pass
+   * `null` to suppress.
+   */
+  stateLabel?: string | null;
+  /** Secondary line under the option label. */
+  description?: ReactNode;
+  /** Set false to drop the leading radio bullet (e.g. for lettered options). */
+  showIndicator?: boolean;
+  children?: ReactNode;
+}
+
+const DEFAULT_STATE_LABELS: Record<RadioVisualState, string | null> = {
+  neutral: null,
+  selected: null,
+  correct: 'Correct answer',
+  incorrect: 'Incorrect answer',
+};
+
+const INDICATOR_GLYPH: Record<RadioVisualState, string> = {
+  neutral: '',
+  selected: '•',
+  correct: '✓',
+  incorrect: '✕',
+};
+
+export const Radio = forwardRef<HTMLButtonElement, RadioProps>(function Radio(
+  {
+    value,
+    disabled = false,
+    state,
+    stateLabel,
+    description,
+    showIndicator = true,
+    className,
+    children,
+    onClick,
+    ...rest
+  },
+  ref,
+) {
+  const group = useContext(RadioGroupContext);
+  if (!group) {
+    throw new Error('<Radio> must be rendered inside a <RadioGroup>.');
+  }
+
+  const checked = group.value === value;
+  const optionDisabled = disabled || group.groupDisabled;
+  // `inert` means "not actionable". It never becomes the `disabled`
+  // attribute, which would strip the option from the accessibility tree.
+  const inert = optionDisabled || group.readOnly;
+  const visualState: RadioVisualState = state ?? (checked ? 'selected' : 'neutral');
+  const resolvedStateLabel =
+    stateLabel === undefined ? DEFAULT_STATE_LABELS[visualState] : stateLabel;
+
+  return (
+    <button
+      ref={ref}
+      {...rest}
+      type="button"
+      role="radio"
+      aria-checked={checked}
+      aria-disabled={inert || undefined}
+      data-value={value}
+      data-state={visualState}
+      tabIndex={-1}
+      onClick={(event) => {
+        onClick?.(event);
+        if (event.defaultPrevented) return;
+        if (inert) return;
+        group.select(value);
+      }}
+      className={cx(
+        styles.radio,
+        styles[visualState],
+        inert && styles.inert,
+        optionDisabled && styles.disabledOption,
+        className,
+      )}
+    >
+      {showIndicator && (
+        <span className={styles.indicator} aria-hidden="true">
+          {INDICATOR_GLYPH[visualState]}
+        </span>
+      )}
+      <span className={styles.content}>
+        <span>{children}</span>
+        {description !== undefined && <span className={styles.description}>{description}</span>}
+      </span>
+      {resolvedStateLabel !== null && <VisuallyHidden>{resolvedStateLabel}</VisuallyHidden>}
+    </button>
+  );
+});
diff --git a/frontend/src/components/ui/Separator.module.css b/frontend/src/components/ui/Separator.module.css
new file mode 100644
index 0000000..c6b3ccd
--- /dev/null
+++ b/frontend/src/components/ui/Separator.module.css
@@ -0,0 +1,39 @@
+.separator {
+  flex: 0 0 auto;
+  border: 0;
+  margin: 0;
+  background-color: var(--color-border, #e3e5e8);
+}
+
+.horizontal {
+  width: 100%;
+  height: 1px;
+}
+
+.vertical {
+  width: 1px;
+  /* Stretch inside a flex row; the explicit height is the fallback. */
+  align-self: stretch;
+  height: auto;
+  min-height: 1rem;
+}
+
+.withLabel {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  width: 100%;
+  font-size: 0.75rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--color-fg-subtle, #8b9098);
+}
+
+.withLabel::before,
+.withLabel::after {
+  content: '';
+  flex: 1 1 auto;
+  height: 1px;
+  background-color: var(--color-border, #e3e5e8);
+}
diff --git a/frontend/src/components/ui/Separator.tsx b/frontend/src/components/ui/Separator.tsx
new file mode 100644
index 0000000..d3665f5
--- /dev/null
+++ b/frontend/src/components/ui/Separator.tsx
@@ -0,0 +1,49 @@
+import { forwardRef } from 'react';
+import type { HTMLAttributes, ReactNode } from 'react';
+import { cx } from './cx';
+import styles from './Separator.module.css';
+
+export interface SeparatorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'role'> {
+  orientation?: 'horizontal' | 'vertical';
+  /**
+   * Default true. A purely visual rule is `role="none"` so it does not add a
+   * meaningless stop to screen-reader navigation. Set false when the line
+   * genuinely separates groups of content.
+   */
+  decorative?: boolean;
+  /** Text rendered inside the rule, e.g. "or". Forces a meaningful separator. */
+  label?: ReactNode;
+}
+
+export const Separator = forwardRef<HTMLDivElement, SeparatorProps>(function Separator(
+  { orientation = 'horizontal', decorative = true, label, className, ...rest },
+  ref,
+) {
+  if (label !== undefined) {
+    return (
+      <div
+        ref={ref}
+        {...rest}
+        role="separator"
+        aria-orientation="horizontal"
+        className={cx(styles.withLabel, className)}
+      >
+        {label}
+      </div>
+    );
+  }
+
+  return (
+    <div
+      ref={ref}
+      {...rest}
+      role={decorative ? 'none' : 'separator'}
+      aria-orientation={decorative ? undefined : orientation}
+      className={cx(
+        styles.separator,
+        orientation === 'vertical' ? styles.vertical : styles.horizontal,
+        className,
+      )}
+    />
+  );
+});
diff --git a/frontend/src/components/ui/Skeleton.module.css b/frontend/src/components/ui/Skeleton.module.css
new file mode 100644
index 0000000..ac841cb
--- /dev/null
+++ b/frontend/src/components/ui/Skeleton.module.css
@@ -0,0 +1,45 @@
+.skeleton {
+  display: block;
+  flex: 0 0 auto;
+  background-color: var(--color-surface-2, #f4f5f7);
+  background-image: linear-gradient(
+    90deg,
+    transparent 0%,
+    color-mix(in srgb, var(--color-fg, #15171a) 7%, transparent) 50%,
+    transparent 100%
+  );
+  background-size: 200% 100%;
+  background-repeat: no-repeat;
+  animation: skeletonShimmer 1.4s ease-in-out infinite;
+}
+
+.text {
+  height: 0.75em;
+  border-radius: var(--radius-sm, 6px);
+}
+
+.rect {
+  border-radius: var(--radius-md, 10px);
+}
+
+.circle {
+  border-radius: var(--radius-full, 999px);
+}
+
+@keyframes skeletonShimmer {
+  from {
+    background-position: 150% 0;
+  }
+  to {
+    background-position: -50% 0;
+  }
+}
+
+/* A travelling shimmer is exactly the kind of looping motion reduced-motion
+   users ask us to stop; fall back to a static block. */
+@media (prefers-reduced-motion: reduce) {
+  .skeleton {
+    animation: none;
+    background-image: none;
+  }
+}
diff --git a/frontend/src/components/ui/Skeleton.tsx b/frontend/src/components/ui/Skeleton.tsx
new file mode 100644
index 0000000..8232e8f
--- /dev/null
+++ b/frontend/src/components/ui/Skeleton.tsx
@@ -0,0 +1,65 @@
+import { forwardRef } from 'react';
+import type { HTMLAttributes } from 'react';
+import { cx } from './cx';
+import styles from './Skeleton.module.css';
+
+export interface SkeletonProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+  variant?: 'text' | 'rect' | 'circle';
+  width?: number | string;
+  height?: number | string;
+  /** Number of stacked lines for `variant="text"`. Default 1. */
+  lines?: number;
+}
+
+function toCssSize(value: number | string | undefined): string | undefined {
+  if (value === undefined) return undefined;
+  return typeof value === 'number' ? `${value}px` : value;
+}
+
+/**
+ * Loading placeholder. Always `aria-hidden`: a shimmering box has no meaning
+ * to a screen reader, and announcing a dozen of them is noise. Announce the
+ * loading state once, on the region that owns it (`aria-busy`, or a
+ * `role="status"` message).
+ */
+export const Skeleton = forwardRef<HTMLSpanElement, SkeletonProps>(function Skeleton(
+  { variant = 'text', width, height, lines = 1, className, style, ...rest },
+  ref,
+) {
+  const resolvedStyle = {
+    width: toCssSize(width) ?? (variant === 'text' ? '100%' : undefined),
+    height: toCssSize(height),
+    ...style,
+  };
+
+  if (variant === 'text' && lines > 1) {
+    return (
+      <span
+        ref={ref}
+        {...rest}
+        aria-hidden="true"
+        className={className}
+        style={{ display: 'flex', flexDirection: 'column', gap: '0.5rem', ...style }}
+      >
+        {Array.from({ length: lines }, (_, index) => (
+          <span
+            key={index}
+            className={cx(styles.skeleton, styles.text)}
+            // Ragged last line reads as text rather than a solid block.
+            style={{ width: index === lines - 1 ? '65%' : '100%', height: toCssSize(height) }}
+          />
+        ))}
+      </span>
+    );
+  }
+
+  return (
+    <span
+      ref={ref}
+      {...rest}
+      aria-hidden="true"
+      className={cx(styles.skeleton, styles[variant], className)}
+      style={resolvedStyle}
+    />
+  );
+});
diff --git a/frontend/src/components/ui/Spinner.module.css b/frontend/src/components/ui/Spinner.module.css
new file mode 100644
index 0000000..0c047b7
--- /dev/null
+++ b/frontend/src/components/ui/Spinner.module.css
@@ -0,0 +1,35 @@
+.spinner {
+  display: inline-block;
+  flex: 0 0 auto;
+  border-radius: var(--radius-full, 999px);
+  border: 2px solid currentColor;
+  border-top-color: transparent;
+  border-right-color: transparent;
+  animation: spinnerRotate 0.7s linear infinite;
+  vertical-align: middle;
+}
+
+@keyframes spinnerRotate {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@keyframes spinnerPulse {
+  0%,
+  100% {
+    opacity: 0.35;
+  }
+  50% {
+    opacity: 1;
+  }
+}
+
+/* Rotation is vestibular-trigger motion. Under reduced motion we still need a
+   "work is happening" signal, so swap to a slow opacity pulse. */
+@media (prefers-reduced-motion: reduce) {
+  .spinner {
+    animation: spinnerPulse 1.6s ease-in-out infinite;
+    border-right-color: currentColor;
+  }
+}
diff --git a/frontend/src/components/ui/Spinner.tsx b/frontend/src/components/ui/Spinner.tsx
new file mode 100644
index 0000000..d922968
--- /dev/null
+++ b/frontend/src/components/ui/Spinner.tsx
@@ -0,0 +1,49 @@
+import { forwardRef } from 'react';
+import type { CSSProperties, HTMLAttributes } from 'react';
+import { cx } from './cx';
+import { VisuallyHidden } from './VisuallyHidden';
+import styles from './Spinner.module.css';
+
+export interface SpinnerProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+  /** Diameter in px. Default 16. */
+  size?: number;
+  /** Stroke width in px. Default 2. */
+  thickness?: number;
+  /**
+   * When set, the spinner becomes a `role="status"` live region announcing
+   * this text. When omitted the spinner is purely decorative
+   * (`aria-hidden="true"`) — the right choice when a surrounding control
+   * already carries `aria-busy`, which is how `Button` uses it.
+   */
+  label?: string;
+}
+
+export const Spinner = forwardRef<HTMLSpanElement, SpinnerProps>(function Spinner(
+  { size = 16, thickness = 2, label, className, style, ...rest },
+  ref,
+) {
+  const circleStyle: CSSProperties = {
+    width: `${size}px`,
+    height: `${size}px`,
+    borderWidth: `${thickness}px`,
+  };
+
+  if (!label) {
+    return (
+      <span
+        ref={ref}
+        {...rest}
+        className={cx(styles.spinner, className)}
+        style={{ ...circleStyle, ...style }}
+        aria-hidden="true"
+      />
+    );
+  }
+
+  return (
+    <span ref={ref} {...rest} className={className} style={style} role="status">
+      <span className={styles.spinner} style={circleStyle} aria-hidden="true" />
+      <VisuallyHidden>{label}</VisuallyHidden>
+    </span>
+  );
+});
diff --git a/frontend/src/components/ui/Switch.module.css b/frontend/src/components/ui/Switch.module.css
new file mode 100644
index 0000000..a47e9ff
--- /dev/null
+++ b/frontend/src/components/ui/Switch.module.css
@@ -0,0 +1,83 @@
+.root {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.75rem;
+  /* 44px floor even though the painted track is shorter. */
+  min-height: 44px;
+  padding: 0 0.25rem;
+  margin: 0;
+  background: none;
+  border: 0;
+  border-radius: var(--radius-sm, 6px);
+  font: inherit;
+  font-size: 0.9375rem;
+  color: var(--color-fg, #15171a);
+  cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.root:focus-visible {
+  outline: 2px solid var(--color-ring, #2f6bff);
+  outline-offset: 2px;
+}
+
+.inert {
+  cursor: not-allowed;
+  opacity: 0.55;
+}
+
+.track {
+  position: relative;
+  flex: 0 0 auto;
+  width: 44px;
+  height: 26px;
+  border-radius: var(--radius-full, 999px);
+  background-color: var(--color-border-strong, #c7cbd1);
+  transition: background-color var(--duration-base, 200ms) ease;
+}
+
+.checked .track {
+  background-color: var(--color-accent, #2f6bff);
+}
+
+.thumb {
+  position: absolute;
+  top: 3px;
+  left: 3px;
+  width: 20px;
+  height: 20px;
+  border-radius: var(--radius-full, 999px);
+  background-color: #fff;
+  box-shadow: var(--shadow-sm, 0 1px 3px rgb(9 11 15 / 25%));
+  transition: transform var(--duration-base, 200ms) cubic-bezier(0.2, 0.8, 0.2, 1);
+}
+
+.checked .thumb {
+  transform: translateX(18px);
+}
+
+.sm .track {
+  width: 36px;
+  height: 22px;
+}
+
+.sm .thumb {
+  width: 16px;
+  height: 16px;
+}
+
+.sm.checked .thumb {
+  transform: translateX(14px);
+}
+
+.label {
+  text-align: left;
+  line-height: 1.4;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .track,
+  .thumb {
+    transition: none;
+  }
+}
diff --git a/frontend/src/components/ui/Switch.tsx b/frontend/src/components/ui/Switch.tsx
new file mode 100644
index 0000000..fb537a1
--- /dev/null
+++ b/frontend/src/components/ui/Switch.tsx
@@ -0,0 +1,105 @@
+import { forwardRef, useCallback, useState } from 'react';
+import type { ButtonHTMLAttributes, KeyboardEvent, MouseEvent, ReactNode } from 'react';
+import { cx } from './cx';
+import styles from './Switch.module.css';
+
+type NativeSwitchProps = Omit<
+  ButtonHTMLAttributes<HTMLButtonElement>,
+  'role' | 'aria-checked' | 'type' | 'value' | 'children' | 'onChange' | 'disabled'
+>;
+
+export interface SwitchBaseProps extends NativeSwitchProps {
+  /** Controlled state. */
+  checked?: boolean;
+  /** Uncontrolled initial state. */
+  defaultChecked?: boolean;
+  onCheckedChange?: (checked: boolean) => void;
+  size?: 'sm' | 'md';
+  /**
+   * Unavailable. Rendered as `aria-disabled` rather than the `disabled`
+   * attribute so the control stays focusable and its state announceable;
+   * activation is blocked in the handlers instead.
+   */
+  disabled?: boolean;
+  /** Visible text rendered next to the track; also names the control. */
+  children?: ReactNode;
+}
+
+/** A switch needs an accessible name: visible label text, or an ARIA label. */
+export type SwitchProps = SwitchBaseProps &
+  ({ children: ReactNode } | { 'aria-label': string } | { 'aria-labelledby': string });
+
+export const Switch = forwardRef<HTMLButtonElement, SwitchProps>(function Switch(props, ref) {
+  const {
+    checked,
+    defaultChecked = false,
+    onCheckedChange,
+    size = 'md',
+    className,
+    children,
+    disabled = false,
+    onClick,
+    onKeyDown,
+    ...rest
+  } = props as SwitchBaseProps;
+
+  const [uncontrolledChecked, setUncontrolledChecked] = useState(defaultChecked);
+  const isControlled = checked !== undefined;
+  const isChecked = checked !== undefined ? checked : uncontrolledChecked;
+
+  const toggle = useCallback(() => {
+    if (disabled) return;
+    const next = !isChecked;
+    if (!isControlled) setUncontrolledChecked(next);
+    onCheckedChange?.(next);
+  }, [disabled, isChecked, isControlled, onCheckedChange]);
+
+  const handleClick = useCallback(
+    (event: MouseEvent<HTMLButtonElement>) => {
+      onClick?.(event);
+      if (event.defaultPrevented) return;
+      toggle();
+    },
+    [onClick, toggle],
+  );
+
+  const handleKeyDown = useCallback(
+    (event: KeyboardEvent<HTMLButtonElement>) => {
+      onKeyDown?.(event);
+      if (event.defaultPrevented) return;
+      if (event.key !== 'Enter') return;
+      // Enter is not a native activation key for every UA/AT combination on a
+      // role-overridden button, so wire it explicitly. Space already
+      // activates a <button> natively and does not scroll the page, so it is
+      // left to the platform to avoid a double toggle.
+      event.preventDefault();
+      toggle();
+    },
+    [onKeyDown, toggle],
+  );
+
+  return (
+    <button
+      ref={ref}
+      {...rest}
+      type="button"
+      role="switch"
+      aria-checked={isChecked}
+      aria-disabled={disabled || undefined}
+      onClick={handleClick}
+      onKeyDown={handleKeyDown}
+      className={cx(
+        styles.root,
+        size === 'sm' && styles.sm,
+        isChecked && styles.checked,
+        disabled && styles.inert,
+        className,
+      )}
+    >
+      <span className={styles.track} aria-hidden="true">
+        <span className={styles.thumb} />
+      </span>
+      {children !== undefined && <span className={styles.label}>{children}</span>}
+    </button>
+  );
+});
diff --git a/frontend/src/components/ui/Tabs.module.css b/frontend/src/components/ui/Tabs.module.css
new file mode 100644
index 0000000..1d9989a
--- /dev/null
+++ b/frontend/src/components/ui/Tabs.module.css
@@ -0,0 +1,107 @@
+.tabs {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  min-width: 0;
+}
+
+/* Horizontal overflow scrolling with snap, so a long tab strip stays usable
+   on narrow screens instead of wrapping or clipping. */
+.list {
+  display: flex;
+  flex-direction: row;
+  gap: 0.375rem;
+  min-width: 0;
+  padding: 0.25rem;
+  overflow-x: auto;
+  overflow-y: hidden;
+  scroll-snap-type: x proximity;
+  scroll-padding-inline: 0.25rem;
+  -webkit-overflow-scrolling: touch;
+  scrollbar-width: none;
+  overscroll-behavior-x: contain;
+  background-color: var(--color-surface-2, #f4f5f7);
+  border-radius: var(--radius-lg, 14px);
+}
+
+.list::-webkit-scrollbar {
+  display: none;
+}
+
+.listVertical {
+  flex-direction: column;
+  overflow-x: visible;
+  scroll-snap-type: none;
+}
+
+.tab {
+  display: inline-flex;
+  flex: 0 0 auto;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  /* 44px floor per WCAG 2.5.5. */
+  min-height: 44px;
+  padding: 0 0.875rem;
+  margin: 0;
+  scroll-snap-align: center;
+  font: inherit;
+  font-size: 0.875rem;
+  font-weight: 600;
+  white-space: nowrap;
+  color: var(--color-fg-muted, #5b6169);
+  background-color: transparent;
+  border: 1px solid transparent;
+  border-radius: var(--radius-md, 10px);
+  cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+  transition:
+    background-color var(--duration-fast, 120ms) ease,
+    color var(--duration-fast, 120ms) ease;
+}
+
+.tab:focus-visible {
+  outline: 2px solid var(--color-ring, #2f6bff);
+  outline-offset: 2px;
+}
+
+.tab:hover:not(.tabSelected):not(.tabInert) {
+  color: var(--color-fg, #15171a);
+}
+
+.tabSelected {
+  color: var(--color-fg, #15171a);
+  background-color: var(--color-surface, #fff);
+  border-color: var(--color-border, #e3e5e8);
+  box-shadow: var(--shadow-xs, 0 1px 2px rgb(9 11 15 / 8%));
+}
+
+.tabInert {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.count {
+  font-size: 0.75rem;
+  font-weight: 700;
+  color: var(--color-fg-subtle, #8b9098);
+}
+
+.panel {
+  min-width: 0;
+}
+
+.panel:focus-visible {
+  outline: 2px solid var(--color-ring, #2f6bff);
+  outline-offset: 4px;
+  border-radius: var(--radius-sm, 6px);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .tab {
+    transition: none;
+  }
+  .list {
+    scroll-behavior: auto;
+  }
+}
diff --git a/frontend/src/components/ui/Tabs.tsx b/frontend/src/components/ui/Tabs.tsx
new file mode 100644
index 0000000..0832b8d
--- /dev/null
+++ b/frontend/src/components/ui/Tabs.tsx
@@ -0,0 +1,298 @@
+import {
+  createContext,
+  forwardRef,
+  useCallback,
+  useContext,
+  useId,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+import type { ButtonHTMLAttributes, HTMLAttributes, KeyboardEvent, ReactNode } from 'react';
+import { useComposedRef } from './compose-refs';
+import { cx } from './cx';
+import { tabId, tabPanelId } from './tab-ids';
+import styles from './Tabs.module.css';
+
+export type TabsOrientation = 'horizontal' | 'vertical';
+export type TabsActivationMode = 'automatic' | 'manual';
+
+interface TabsContextValue {
+  value: string;
+  select: (value: string) => void;
+  baseId: string;
+  orientation: TabsOrientation;
+  activationMode: TabsActivationMode;
+}
+
+const TabsContext = createContext<TabsContextValue | null>(null);
+
+function useTabsContext(component: string): TabsContextValue {
+  const context = useContext(TabsContext);
+  if (!context) {
+    throw new Error(`<${component}> must be rendered inside <Tabs>.`);
+  }
+  return context;
+}
+
+export interface TabsBaseProps extends Omit<HTMLAttributes<HTMLDivElement>, 'defaultValue'> {
+  orientation?: TabsOrientation;
+  /**
+   * `automatic` (default, and what APG recommends for cheap panels) selects
+   * on arrow-key focus. `manual` moves focus only; Enter/Space selects.
+   */
+  activationMode?: TabsActivationMode;
+  children?: ReactNode;
+}
+
+/**
+ * Either controlled (`value` + `onValueChange`) or uncontrolled
+ * (`defaultValue`). One is required: a tablist with no selected tab has no
+ * valid roving-tabindex entry point.
+ */
+export type TabsProps = TabsBaseProps &
+  (
+    | { value: string; onValueChange: (value: string) => void; defaultValue?: undefined }
+    | { defaultValue: string; value?: undefined; onValueChange?: (value: string) => void }
+  );
+
+type ResolvedTabsProps = TabsBaseProps & {
+  value?: string;
+  defaultValue?: string;
+  onValueChange?: (value: string) => void;
+};
+
+export const Tabs = forwardRef<HTMLDivElement, TabsProps>(function Tabs(props, ref) {
+  const {
+    value,
+    defaultValue,
+    onValueChange,
+    orientation = 'horizontal',
+    activationMode = 'automatic',
+    className,
+    children,
+    ...rest
+  } = props as ResolvedTabsProps;
+
+  const baseId = useId();
+  const [uncontrolledValue, setUncontrolledValue] = useState(defaultValue ?? '');
+  const isControlled = value !== undefined;
+  const currentValue = value !== undefined ? value : uncontrolledValue;
+
+  const select = useCallback(
+    (next: string) => {
+      if (!isControlled) setUncontrolledValue(next);
+      onValueChange?.(next);
+    },
+    [isControlled, onValueChange],
+  );
+
+  const contextValue = useMemo<TabsContextValue>(
+    () => ({ value: currentValue, select, baseId, orientation, activationMode }),
+    [activationMode, baseId, currentValue, orientation, select],
+  );
+
+  return (
+    <div ref={ref} {...rest} className={cx(styles.tabs, className)}>
+      <TabsContext.Provider value={contextValue}>{children}</TabsContext.Provider>
+    </div>
+  );
+});
+
+type NativeListProps = Omit<
+  HTMLAttributes<HTMLDivElement>,
+  'role' | 'aria-label' | 'aria-labelledby'
+>;
+
+export interface TabListBaseProps extends NativeListProps {
+  children?: ReactNode;
+}
+
+/** A tablist must be named. */
+export type TabListProps = TabListBaseProps &
+  (
+    | { 'aria-label': string; 'aria-labelledby'?: undefined }
+    | { 'aria-labelledby': string; 'aria-label'?: undefined }
+  );
+
+type ResolvedTabListProps = TabListBaseProps & {
+  'aria-label'?: string;
+  'aria-labelledby'?: string;
+};
+
+function getTabs(root: HTMLElement | null): HTMLElement[] {
+  if (!root) return [];
+  return Array.from(root.querySelectorAll<HTMLElement>('[role="tab"]')).filter(
+    (tab) => tab.getAttribute('aria-disabled') !== 'true',
+  );
+}
+
+export const TabList = forwardRef<HTMLDivElement, TabListProps>(function TabList(
+  props,
+  forwardedRef,
+) {
+  const {
+    className,
+    children,
+    onKeyDown,
+    'aria-label': ariaLabel,
+    'aria-labelledby': ariaLabelledBy,
+    ...rest
+  } = props as ResolvedTabListProps;
+
+  const { orientation, activationMode, select } = useTabsContext('TabList');
+  const listRef = useRef<HTMLDivElement | null>(null);
+  const setRef = useComposedRef(forwardedRef, listRef);
+
+  const handleKeyDown = useCallback(
+    (event: KeyboardEvent<HTMLDivElement>) => {
+      onKeyDown?.(event);
+      if (event.defaultPrevented) return;
+      if (event.ctrlKey || event.metaKey || event.altKey) return;
+
+      const tabs = getTabs(listRef.current);
+      if (tabs.length === 0) return;
+
+      const active = document.activeElement;
+      const currentIndex = tabs.findIndex((tab) => tab === active || tab.contains(active));
+
+      const next = orientation === 'horizontal' ? 'ArrowRight' : 'ArrowDown';
+      const previous = orientation === 'horizontal' ? 'ArrowLeft' : 'ArrowUp';
+
+      let nextIndex: number;
+      switch (event.key) {
+        case next:
+          nextIndex = currentIndex < 0 ? 0 : (currentIndex + 1) % tabs.length;
+          break;
+        case previous:
+          nextIndex =
+            currentIndex < 0 ? tabs.length - 1 : (currentIndex - 1 + tabs.length) % tabs.length;
+          break;
+        case 'Home':
+          nextIndex = 0;
+          break;
+        case 'End':
+          nextIndex = tabs.length - 1;
+          break;
+        default:
+          return;
+      }
+
+      event.preventDefault();
+      const target = tabs[nextIndex];
+      target.focus();
+      // Keep the newly focused tab inside the scroll viewport. jsdom has no
+      // layout and does not implement scrollIntoView, hence the guard.
+      if (typeof target.scrollIntoView === 'function') {
+        target.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+      }
+      if (activationMode === 'automatic') {
+        const nextValue = target.dataset.value;
+        if (nextValue !== undefined) select(nextValue);
+      }
+    },
+    [activationMode, onKeyDown, orientation, select],
+  );
+
+  return (
+    <div
+      ref={setRef}
+      {...rest}
+      role="tablist"
+      aria-label={ariaLabel}
+      aria-labelledby={ariaLabelledBy}
+      aria-orientation={orientation}
+      onKeyDown={handleKeyDown}
+      className={cx(styles.list, orientation === 'vertical' && styles.listVertical, className)}
+    >
+      {children}
+    </div>
+  );
+});
+
+type NativeTabProps = Omit<
+  ButtonHTMLAttributes<HTMLButtonElement>,
+  'role' | 'aria-selected' | 'aria-controls' | 'type' | 'value' | 'id' | 'disabled'
+>;
+
+export interface TabProps extends NativeTabProps {
+  value: string;
+  /** Rendered as `aria-disabled`; the tab stays in the accessibility tree. */
+  disabled?: boolean;
+  children?: ReactNode;
+}
+
+export const Tab = forwardRef<HTMLButtonElement, TabProps>(function Tab(
+  { value, disabled = false, className, children, onClick, ...rest },
+  ref,
+) {
+  const { value: selectedValue, select, baseId } = useTabsContext('Tab');
+  const selected = selectedValue === value;
+
+  return (
+    <button
+      ref={ref}
+      {...rest}
+      type="button"
+      role="tab"
+      id={tabId(baseId, value)}
+      aria-selected={selected}
+      aria-controls={tabPanelId(baseId, value)}
+      aria-disabled={disabled || undefined}
+      data-value={value}
+      // Roving tabindex: the tablist is a single tab stop.
+      tabIndex={selected ? 0 : -1}
+      onClick={(event) => {
+        onClick?.(event);
+        if (event.defaultPrevented) return;
+        if (disabled) return;
+        select(value);
+      }}
+      className={cx(
+        styles.tab,
+        selected && styles.tabSelected,
+        disabled && styles.tabInert,
+        className,
+      )}
+    >
+      {children}
+    </button>
+  );
+});
+
+export interface TabPanelProps extends Omit<HTMLAttributes<HTMLDivElement>, 'role' | 'id'> {
+  value: string;
+  /**
+   * Keep the panel mounted while hidden (preserves scroll position and form
+   * state). Default false.
+   */
+  keepMounted?: boolean;
+  children?: ReactNode;
+}
+
+export const TabPanel = forwardRef<HTMLDivElement, TabPanelProps>(function TabPanel(
+  { value, keepMounted = false, className, children, ...rest },
+  ref,
+) {
+  const { value: selectedValue, baseId } = useTabsContext('TabPanel');
+  const selected = selectedValue === value;
+
+  if (!selected && !keepMounted) return null;
+
+  return (
+    <div
+      ref={ref}
+      {...rest}
+      role="tabpanel"
+      id={tabPanelId(baseId, value)}
+      aria-labelledby={tabId(baseId, value)}
+      hidden={!selected}
+      // APG: give the panel itself a tab stop so keyboard users can reach
+      // non-focusable panel content right after the tablist.
+      tabIndex={0}
+      className={cx(styles.panel, className)}
+    >
+      {children}
+    </div>
+  );
+});
diff --git a/frontend/src/components/ui/Toast.module.css b/frontend/src/components/ui/Toast.module.css
new file mode 100644
index 0000000..86092db
--- /dev/null
+++ b/frontend/src/components/ui/Toast.module.css
@@ -0,0 +1,104 @@
+.viewport {
+  position: fixed;
+  z-index: 1100;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  width: min(24rem, calc(100vw - 2rem));
+  padding: 0;
+  margin: 0;
+  list-style: none;
+  /* The viewport itself must never swallow clicks on the page beneath it. */
+  pointer-events: none;
+}
+
+.topRight {
+  top: 1rem;
+  right: 1rem;
+}
+
+.topCenter {
+  top: 1rem;
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+.bottomRight {
+  bottom: 1rem;
+  right: 1rem;
+}
+
+.bottomCenter {
+  bottom: 1rem;
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+.toast {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.75rem;
+  padding: 0.75rem;
+  box-sizing: border-box;
+  pointer-events: auto;
+  background-color: var(--color-surface, #fff);
+  color: var(--color-fg, #15171a);
+  border: 1px solid var(--color-border, #e3e5e8);
+  border-left: 3px solid var(--color-border-strong, #c7cbd1);
+  border-radius: var(--radius-md, 10px);
+  box-shadow: var(--shadow-md, 0 6px 16px -6px rgb(9 11 15 / 20%));
+  animation: toastIn var(--duration-base, 200ms) cubic-bezier(0.2, 0.8, 0.2, 1) both;
+}
+
+.success {
+  border-left-color: var(--color-success-500, #16a34a);
+}
+
+.warning {
+  border-left-color: var(--color-warning-500, #d97706);
+}
+
+.danger {
+  border-left-color: var(--color-danger-500, #dc2626);
+}
+
+.info {
+  border-left-color: var(--color-info-500, #0284c7);
+}
+
+.body {
+  display: flex;
+  flex: 1 1 auto;
+  flex-direction: column;
+  gap: 0.1875rem;
+  min-width: 0;
+}
+
+.title {
+  font-size: 0.875rem;
+  font-weight: 700;
+  line-height: 1.35;
+}
+
+.description {
+  font-size: 0.8125rem;
+  line-height: 1.5;
+  color: var(--color-fg-muted, #5b6169);
+}
+
+.action {
+  margin-top: 0.375rem;
+}
+
+@keyframes toastIn {
+  from {
+    opacity: 0;
+    transform: translateY(-6px);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .toast {
+    animation: none;
+  }
+}
diff --git a/frontend/src/components/ui/Toast.tsx b/frontend/src/components/ui/Toast.tsx
new file mode 100644
index 0000000..c748d32
--- /dev/null
+++ b/frontend/src/components/ui/Toast.tsx
@@ -0,0 +1,207 @@
+import { forwardRef, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { X } from 'lucide-react';
+import type { HTMLAttributes, ReactNode } from 'react';
+import { cx } from './cx';
+import { IconButton } from './IconButton';
+import { ToastContext } from './toast-context';
+import type { ToastContextValue, ToastOptions, ToastRecord, ToastTone } from './toast-context';
+import styles from './Toast.module.css';
+
+export type ToastPlacement = 'topRight' | 'topCenter' | 'bottomRight' | 'bottomCenter';
+
+const TONE_CLASS: Record<ToastTone, string | undefined> = {
+  neutral: undefined,
+  success: styles.success,
+  warning: styles.warning,
+  danger: styles.danger,
+  info: styles.info,
+};
+
+export interface ToastProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title' | 'children'> {
+  title?: ReactNode;
+  description?: ReactNode;
+  tone?: ToastTone;
+  action?: ReactNode;
+  onDismiss?: () => void;
+  dismissLabel?: string;
+}
+
+/**
+ * The presentational toast. Rendered inside a live region by
+ * `ToastProvider`; exported separately so it can also be used as a static
+ * inline notification.
+ */
+export const Toast = forwardRef<HTMLDivElement, ToastProps>(function Toast(
+  {
+    title,
+    description,
+    tone = 'neutral',
+    action,
+    onDismiss,
+    dismissLabel = 'Dismiss notification',
+    className,
+    ...rest
+  },
+  ref,
+) {
+  return (
+    <div ref={ref} {...rest} className={cx(styles.toast, TONE_CLASS[tone], className)}>
+      <div className={styles.body}>
+        {title !== undefined && <span className={styles.title}>{title}</span>}
+        {description !== undefined && <span className={styles.description}>{description}</span>}
+        {action !== undefined && <span className={styles.action}>{action}</span>}
+      </div>
+      {onDismiss !== undefined && (
+        <IconButton
+          variant="ghost"
+          size="sm"
+          aria-label={dismissLabel}
+          onClick={onDismiss}
+          icon={<X size={16} aria-hidden="true" />}
+        />
+      )}
+    </div>
+  );
+});
+
+/** Resume with at least this long on the clock, so a toast is never re-shown for 5ms. */
+const MIN_RESUME_MS = 400;
+
+interface ToastItemProps {
+  record: ToastRecord;
+  onDismiss: (id: string) => void;
+  dismissLabel: string;
+}
+
+function ToastItem({ record, onDismiss, dismissLabel }: ToastItemProps) {
+  const [hovered, setHovered] = useState(false);
+  const [focused, setFocused] = useState(false);
+  const remainingRef = useRef(record.duration ?? 0);
+  const paused = hovered || focused;
+
+  useEffect(() => {
+    const remaining = remainingRef.current;
+    // duration <= 0 means "sticky": dismissed only by the user.
+    if (paused || remaining <= 0) return;
+
+    const startedAt = Date.now();
+    const timer = window.setTimeout(() => onDismiss(record.id), remaining);
+    return () => {
+      window.clearTimeout(timer);
+      // Bank the unspent time so hovering pauses rather than restarts.
+      const spent = Date.now() - startedAt;
+      remainingRef.current = Math.max(MIN_RESUME_MS, remaining - spent);
+    };
+  }, [paused, onDismiss, record.id]);
+
+  const handleDismiss = useCallback(() => onDismiss(record.id), [onDismiss, record.id]);
+
+  return (
+    <Toast
+      title={record.title}
+      description={record.description}
+      tone={record.tone ?? 'neutral'}
+      action={record.action}
+      onDismiss={handleDismiss}
+      dismissLabel={dismissLabel}
+      // Pause the auto-dismiss clock whenever the user is reading or
+      // keyboard-navigating the toast, so the action never vanishes
+      // mid-reach. WCAG 2.2.1 Timing Adjustable.
+      onMouseEnter={() => setHovered(true)}
+      onMouseLeave={() => setHovered(false)}
+      onFocus={() => setFocused(true)}
+      onBlur={() => setFocused(false)}
+    />
+  );
+}
+
+export interface ToastProviderProps {
+  children?: ReactNode;
+  placement?: ToastPlacement;
+  /** Default auto-dismiss in ms. Default 5000. Pass 0 for sticky toasts. */
+  duration?: number;
+  /** Oldest toasts beyond this are dropped. Default 4. */
+  max?: number;
+  dismissLabel?: string;
+  /** Portal host. Defaults to `document.body`. */
+  container?: HTMLElement | null;
+}
+
+/**
+ * Owns the toast queue and renders the live regions. Two regions are kept
+ * permanently mounted (polite and assertive) because a live region has to
+ * exist *before* content is inserted into it, otherwise the insertion is not
+ * announced.
+ */
+export function ToastProvider({
+  children,
+  placement = 'topRight',
+  duration = 5000,
+  max = 4,
+  dismissLabel = 'Dismiss notification',
+  container,
+}: ToastProviderProps) {
+  const [toasts, setToasts] = useState<ToastRecord[]>([]);
+  const counterRef = useRef(0);
+
+  const toast = useCallback(
+    (options: ToastOptions) => {
+      counterRef.current += 1;
+      const id = `toast-${counterRef.current}`;
+      const record: ToastRecord = { duration, politeness: 'polite', ...options, id };
+      setToasts((previous) => {
+        const next = [...previous, record];
+        return next.length > max ? next.slice(next.length - max) : next;
+      });
+      return id;
+    },
+    [duration, max],
+  );
+
+  const dismiss = useCallback((id: string) => {
+    setToasts((previous) => previous.filter((entry) => entry.id !== id));
+  }, []);
+
+  const dismissAll = useCallback(() => setToasts([]), []);
+
+  const contextValue = useMemo<ToastContextValue>(
+    () => ({ toasts, toast, dismiss, dismissAll }),
+    [dismiss, dismissAll, toast, toasts],
+  );
+
+  const polite = toasts.filter((entry) => entry.politeness !== 'assertive');
+  const assertive = toasts.filter((entry) => entry.politeness === 'assertive');
+
+  const viewport = (
+    <div className={cx(styles.viewport, styles[placement])}>
+      <div role="status" aria-live="polite" aria-relevant="additions text">
+        {polite.map((entry) => (
+          <ToastItem
+            key={entry.id}
+            record={entry}
+            onDismiss={dismiss}
+            dismissLabel={dismissLabel}
+          />
+        ))}
+      </div>
+      <div role="alert" aria-live="assertive">
+        {assertive.map((entry) => (
+          <ToastItem
+            key={entry.id}
+            record={entry}
+            onDismiss={dismiss}
+            dismissLabel={dismissLabel}
+          />
+        ))}
+      </div>
+    </div>
+  );
+
+  return (
+    <ToastContext.Provider value={contextValue}>
+      {children}
+      {typeof document !== 'undefined' && createPortal(viewport, container ?? document.body)}
+    </ToastContext.Provider>
+  );
+}
diff --git a/frontend/src/components/ui/VisuallyHidden.module.css b/frontend/src/components/ui/VisuallyHidden.module.css
new file mode 100644
index 0000000..1710ad8
--- /dev/null
+++ b/frontend/src/components/ui/VisuallyHidden.module.css
@@ -0,0 +1,13 @@
+/* The clip-path + 1px box recipe: removed from the visual layer but kept in
+   the accessibility tree and in the text selection/copy flow. */
+.visuallyHidden {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  margin: -1px;
+  padding: 0;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border: 0;
+}
diff --git a/frontend/src/components/ui/VisuallyHidden.tsx b/frontend/src/components/ui/VisuallyHidden.tsx
new file mode 100644
index 0000000..83fda74
--- /dev/null
+++ b/frontend/src/components/ui/VisuallyHidden.tsx
@@ -0,0 +1,17 @@
+import { forwardRef } from 'react';
+import type { HTMLAttributes } from 'react';
+import { cx } from './cx';
+import styles from './VisuallyHidden.module.css';
+
+export type VisuallyHiddenProps = HTMLAttributes<HTMLSpanElement>;
+
+/**
+ * Renders text that is invisible on screen but announced by screen readers.
+ * Use it for the accessible name of an icon-only control, or to narrate a
+ * state change that is otherwise communicated with colour alone.
+ */
+export const VisuallyHidden = forwardRef<HTMLSpanElement, VisuallyHiddenProps>(
+  function VisuallyHidden({ className, ...rest }, ref) {
+    return <span ref={ref} className={cx(styles.visuallyHidden, className)} {...rest} />;
+  },
+);
diff --git a/frontend/src/components/ui/__tests__/Dialog.test.tsx b/frontend/src/components/ui/__tests__/Dialog.test.tsx
new file mode 100644
index 0000000..f9c325a
--- /dev/null
+++ b/frontend/src/components/ui/__tests__/Dialog.test.tsx
@@ -0,0 +1,232 @@
+import { useRef, useState } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Dialog } from '../Dialog';
+
+/**
+ * The app's existing name-entry modal sets `aria-modal` but has no focus
+ * trap, no initial focus, no Escape handler and no scroll lock — so Tab
+ * walks straight out of the modal into the page behind it, and screen reader
+ * users are told the rest of the page is unavailable while their focus sits
+ * in it. These tests pin the real behaviour.
+ */
+
+function Fixture({
+  onClose,
+  withInitialFocus = false,
+  closeOnEscape = true,
+}: {
+  onClose?: () => void;
+  withInitialFocus?: boolean;
+  closeOnEscape?: boolean;
+}) {
+  const [open, setOpen] = useState(false);
+  const secondRef = useRef<HTMLButtonElement | null>(null);
+
+  return (
+    <div>
+      <button type="button" onClick={() => setOpen(true)}>
+        Open dialog
+      </button>
+      <button type="button">Behind the dialog</button>
+      <Dialog
+        open={open}
+        onClose={() => {
+          setOpen(false);
+          onClose?.();
+        }}
+        closeOnEscape={closeOnEscape}
+        title="Enter your name"
+        description="We use it to personalise your report."
+        initialFocusRef={withInitialFocus ? secondRef : undefined}
+        footer={
+          <>
+            <button type="button">Cancel</button>
+            <button type="button">Save</button>
+          </>
+        }
+      >
+        <input aria-label="Your name" />
+        <button type="button" ref={secondRef}>
+          Middle action
+        </button>
+      </Dialog>
+    </div>
+  );
+}
+
+async function openDialog(user: ReturnType<typeof userEvent.setup>) {
+  await user.click(screen.getByRole('button', { name: 'Open dialog' }));
+  return screen.getByRole('dialog');
+}
+
+describe('Dialog — semantics', () => {
+  it('renders nothing while closed', () => {
+    render(<Fixture />);
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('is a modal dialog named by its title and described by its description', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+    const dialog = await openDialog(user);
+
+    expect(dialog).toHaveAttribute('aria-modal', 'true');
+    expect(dialog).toHaveAccessibleName('Enter your name');
+    expect(dialog).toHaveAccessibleDescription('We use it to personalise your report.');
+  });
+
+  it('renders into a portal on document.body, outside the triggering subtree', async () => {
+    const user = userEvent.setup();
+    const { container } = render(<Fixture />);
+    const dialog = await openDialog(user);
+
+    expect(container).not.toContainElement(dialog);
+    expect(document.body).toContainElement(dialog);
+  });
+});
+
+describe('Dialog — initial focus', () => {
+  it('focuses the first tabbable element by default', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+    await openDialog(user);
+
+    expect(screen.getByRole('button', { name: 'Close dialog' })).toHaveFocus();
+  });
+
+  it('honours initialFocusRef', async () => {
+    const user = userEvent.setup();
+    render(<Fixture withInitialFocus />);
+    await openDialog(user);
+
+    expect(screen.getByRole('button', { name: 'Middle action' })).toHaveFocus();
+  });
+});
+
+describe('Dialog — focus trap', () => {
+  it('wraps Tab from the last tabbable element back to the first', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+    await openDialog(user);
+
+    const close = screen.getByRole('button', { name: 'Close dialog' });
+    const save = screen.getByRole('button', { name: 'Save' });
+
+    save.focus();
+    await user.tab();
+
+    expect(save).not.toHaveFocus();
+    expect(close).toHaveFocus();
+  });
+
+  it('wraps Shift+Tab from the first tabbable element to the last', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+    await openDialog(user);
+
+    const close = screen.getByRole('button', { name: 'Close dialog' });
+    const save = screen.getByRole('button', { name: 'Save' });
+
+    close.focus();
+    await user.tab({ shift: true });
+
+    expect(save).toHaveFocus();
+  });
+
+  it('never lets Tab reach the page behind the dialog', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+    const dialog = await openDialog(user);
+
+    const behind = screen.getByRole('button', { name: 'Behind the dialog' });
+    for (let step = 0; step < 8; step += 1) {
+      await user.tab();
+      expect(behind).not.toHaveFocus();
+      expect(dialog).toContainElement(document.activeElement as HTMLElement);
+    }
+  });
+});
+
+describe('Dialog — Escape', () => {
+  it('closes on Escape', async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+    render(<Fixture onClose={onClose} />);
+    await openDialog(user);
+
+    await user.keyboard('{Escape}');
+
+    expect(onClose).toHaveBeenCalledTimes(1);
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('respects closeOnEscape={false}', async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+    render(<Fixture onClose={onClose} closeOnEscape={false} />);
+    await openDialog(user);
+
+    await user.keyboard('{Escape}');
+
+    expect(onClose).not.toHaveBeenCalled();
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+  });
+});
+
+describe('Dialog — focus restoration', () => {
+  it('returns focus to the trigger after closing with Escape', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+    const trigger = screen.getByRole('button', { name: 'Open dialog' });
+
+    await user.click(trigger);
+    expect(trigger).not.toHaveFocus();
+
+    await user.keyboard('{Escape}');
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(trigger).toHaveFocus();
+  });
+
+  it('returns focus to the trigger after closing with the close button', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+    const trigger = screen.getByRole('button', { name: 'Open dialog' });
+
+    await user.click(trigger);
+    await user.click(screen.getByRole('button', { name: 'Close dialog' }));
+
+    expect(trigger).toHaveFocus();
+  });
+
+  it('returns focus to the trigger after a backdrop dismissal', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+    const trigger = screen.getByRole('button', { name: 'Open dialog' });
+
+    await user.click(trigger);
+    const dialog = screen.getByRole('dialog');
+    const backdrop = dialog.parentElement as HTMLElement;
+    await user.click(backdrop);
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(trigger).toHaveFocus();
+  });
+});
+
+describe('Dialog — scroll lock', () => {
+  it('locks body scroll while open and restores it on close', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+
+    expect(document.body.style.overflow).toBe('');
+
+    await user.click(screen.getByRole('button', { name: 'Open dialog' }));
+    expect(document.body.style.overflow).toBe('hidden');
+
+    await user.keyboard('{Escape}');
+    expect(document.body.style.overflow).toBe('');
+  });
+});
diff --git a/frontend/src/components/ui/__tests__/RadioGroup.test.tsx b/frontend/src/components/ui/__tests__/RadioGroup.test.tsx
new file mode 100644
index 0000000..efcdd4a
--- /dev/null
+++ b/frontend/src/components/ui/__tests__/RadioGroup.test.tsx
@@ -0,0 +1,318 @@
+import { useState } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Radio, RadioGroup } from '../RadioGroup';
+
+/**
+ * These tests pin the WAI-ARIA radiogroup pattern. The app previously
+ * rendered quiz options as `<button role="radio">` inside `role="radiogroup"`
+ * with no arrow-key handling and no roving tabindex, so every option was its
+ * own tab stop; and it swapped in the `disabled` attribute after submission,
+ * which deleted the revealed correct answer from the accessibility tree.
+ * Both failure modes are silent without assertions like these.
+ */
+
+const OPTIONS = ['Copper', 'Aluminium', 'Steel', 'Nichrome'];
+
+function Fixture({
+  readOnly = false,
+  onValueChange,
+  initial = null,
+}: {
+  readOnly?: boolean;
+  onValueChange?: (value: string) => void;
+  initial?: string | null;
+}) {
+  const [value, setValue] = useState<string | null>(initial);
+  return (
+    <div>
+      <button type="button">before</button>
+      <RadioGroup
+        aria-label="Answer options"
+        value={value}
+        readOnly={readOnly}
+        onValueChange={(next) => {
+          setValue(next);
+          onValueChange?.(next);
+        }}
+      >
+        {OPTIONS.map((option) => (
+          <Radio key={option} value={option}>
+            {option}
+          </Radio>
+        ))}
+      </RadioGroup>
+      <button type="button">after</button>
+    </div>
+  );
+}
+
+function radios() {
+  return screen.getAllByRole('radio');
+}
+
+function tabIndexes() {
+  return radios().map((radio) => radio.tabIndex);
+}
+
+describe('RadioGroup — structure', () => {
+  it('exposes a radiogroup with an accessible name and one radio per option', () => {
+    render(<Fixture />);
+    const group = screen.getByRole('radiogroup', { name: 'Answer options' });
+    expect(group).toHaveAttribute('aria-orientation', 'vertical');
+    expect(radios()).toHaveLength(OPTIONS.length);
+    for (const radio of radios()) {
+      expect(radio).toHaveAttribute('aria-checked', 'false');
+    }
+  });
+});
+
+describe('RadioGroup — roving tabindex', () => {
+  it('exposes exactly one tab stop, on the first option when nothing is selected', () => {
+    render(<Fixture />);
+    expect(tabIndexes()).toEqual([0, -1, -1, -1]);
+  });
+
+  it('moves the single tab stop onto the selected option', () => {
+    render(<Fixture initial="Steel" />);
+    expect(tabIndexes()).toEqual([-1, -1, 0, -1]);
+  });
+
+  it('keeps exactly one tab stop after the selection changes', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+    await user.click(screen.getByRole('radio', { name: /Aluminium/ }));
+    expect(tabIndexes()).toEqual([-1, 0, -1, -1]);
+    expect(tabIndexes().filter((index) => index === 0)).toHaveLength(1);
+  });
+
+  it('is a single Tab stop: Tab enters the group once and leaves it', async () => {
+    const user = userEvent.setup();
+    render(<Fixture initial="Steel" />);
+
+    screen.getByRole('button', { name: 'before' }).focus();
+    await user.tab();
+    expect(screen.getByRole('radio', { name: /Steel/ })).toHaveFocus();
+
+    await user.tab();
+    expect(screen.getByRole('button', { name: 'after' })).toHaveFocus();
+  });
+});
+
+describe('RadioGroup — arrow keys move AND select', () => {
+  it('ArrowDown moves focus to the next option and selects it', async () => {
+    const user = userEvent.setup();
+    const onValueChange = vi.fn();
+    render(<Fixture onValueChange={onValueChange} />);
+
+    radios()[0].focus();
+    await user.keyboard('{ArrowDown}');
+
+    expect(radios()[1]).toHaveFocus();
+    expect(radios()[1]).toHaveAttribute('aria-checked', 'true');
+    expect(radios()[0]).toHaveAttribute('aria-checked', 'false');
+    expect(onValueChange).toHaveBeenCalledWith('Aluminium');
+  });
+
+  it('ArrowRight behaves like ArrowDown', async () => {
+    const user = userEvent.setup();
+    render(<Fixture initial="Copper" />);
+
+    radios()[0].focus();
+    await user.keyboard('{ArrowRight}');
+
+    expect(radios()[1]).toHaveFocus();
+    expect(radios()[1]).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('ArrowUp and ArrowLeft move backwards and select', async () => {
+    const user = userEvent.setup();
+    render(<Fixture initial="Steel" />);
+
+    radios()[2].focus();
+    await user.keyboard('{ArrowUp}');
+    expect(radios()[1]).toHaveFocus();
+    expect(radios()[1]).toHaveAttribute('aria-checked', 'true');
+
+    await user.keyboard('{ArrowLeft}');
+    expect(radios()[0]).toHaveFocus();
+    expect(radios()[0]).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('wraps from the last option to the first and back', async () => {
+    const user = userEvent.setup();
+    render(<Fixture initial="Nichrome" />);
+
+    radios()[3].focus();
+    await user.keyboard('{ArrowDown}');
+    expect(radios()[0]).toHaveFocus();
+    expect(radios()[0]).toHaveAttribute('aria-checked', 'true');
+
+    await user.keyboard('{ArrowUp}');
+    expect(radios()[3]).toHaveFocus();
+    expect(radios()[3]).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('Home and End jump to the first and last option and select them', async () => {
+    const user = userEvent.setup();
+    render(<Fixture initial="Aluminium" />);
+
+    radios()[1].focus();
+    await user.keyboard('{End}');
+    expect(radios()[3]).toHaveFocus();
+    expect(radios()[3]).toHaveAttribute('aria-checked', 'true');
+
+    await user.keyboard('{Home}');
+    expect(radios()[0]).toHaveFocus();
+    expect(radios()[0]).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('Space selects the focused option without moving focus', async () => {
+    const user = userEvent.setup();
+    render(<Fixture />);
+
+    radios()[2].focus();
+    await user.keyboard(' ');
+
+    expect(radios()[2]).toHaveFocus();
+    expect(radios()[2]).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('ignores arrow keys combined with a modifier so browser shortcuts still work', async () => {
+    const user = userEvent.setup();
+    render(<Fixture initial="Copper" />);
+
+    radios()[0].focus();
+    await user.keyboard('{Alt>}{ArrowDown}{/Alt}');
+
+    expect(radios()[0]).toHaveFocus();
+    expect(radios()[0]).toHaveAttribute('aria-checked', 'true');
+  });
+});
+
+describe('RadioGroup — readOnly review mode', () => {
+  it('never uses the disabled attribute, so revealed answers stay in the a11y tree', () => {
+    render(
+      <RadioGroup aria-label="Answer options" value="Aluminium" readOnly>
+        <Radio value="Copper" state="incorrect">
+          Copper
+        </Radio>
+        <Radio value="Aluminium" state="correct">
+          Aluminium
+        </Radio>
+      </RadioGroup>,
+    );
+
+    const all = radios();
+    expect(all).toHaveLength(2);
+    for (const radio of all) {
+      expect(radio).not.toBeDisabled();
+      expect(radio).not.toHaveAttribute('disabled');
+      expect(radio).toHaveAttribute('aria-disabled', 'true');
+    }
+    // The revealed state is announced, not conveyed by colour alone.
+    expect(screen.getByRole('radio', { name: /Aluminium/ })).toHaveAccessibleName(
+      /Correct answer/,
+    );
+    expect(screen.getByRole('radio', { name: /Copper/ })).toHaveAccessibleName(
+      /Incorrect answer/,
+    );
+  });
+
+  it('marks the group aria-readonly', () => {
+    render(<Fixture readOnly initial="Steel" />);
+    expect(screen.getByRole('radiogroup')).toHaveAttribute('aria-readonly', 'true');
+  });
+
+  it('keeps every option focusable and reachable with the arrow keys', async () => {
+    const user = userEvent.setup();
+    render(<Fixture readOnly initial="Steel" />);
+
+    radios()[2].focus();
+    expect(radios()[2]).toHaveFocus();
+
+    await user.keyboard('{ArrowDown}');
+    expect(radios()[3]).toHaveFocus();
+
+    await user.keyboard('{Home}');
+    expect(radios()[0]).toHaveFocus();
+  });
+
+  it('does not change the answer in review mode', async () => {
+    const user = userEvent.setup();
+    const onValueChange = vi.fn();
+    render(<Fixture readOnly initial="Steel" onValueChange={onValueChange} />);
+
+    radios()[2].focus();
+    await user.keyboard('{ArrowDown}');
+    await user.click(radios()[0]);
+
+    expect(onValueChange).not.toHaveBeenCalled();
+    expect(radios()[2]).toHaveAttribute('aria-checked', 'true');
+    expect(radios()[0]).toHaveAttribute('aria-checked', 'false');
+    // The tab stop stays on the locked answer.
+    expect(tabIndexes()).toEqual([-1, -1, 0, -1]);
+  });
+});
+
+describe('RadioGroup — per-option disabled', () => {
+  it('uses aria-disabled and refuses selection, but stays focusable', async () => {
+    const user = userEvent.setup();
+    const onValueChange = vi.fn();
+    render(
+      <RadioGroup aria-label="Answer options" onValueChange={onValueChange}>
+        <Radio value="a">A</Radio>
+        <Radio value="b" disabled>
+          B
+        </Radio>
+      </RadioGroup>,
+    );
+
+    const [, second] = radios();
+    expect(second).toHaveAttribute('aria-disabled', 'true');
+    expect(second).not.toBeDisabled();
+
+    await user.click(second);
+    expect(onValueChange).not.toHaveBeenCalled();
+    expect(second).toHaveAttribute('aria-checked', 'false');
+  });
+});
+
+describe('RadioGroup — uncontrolled usage', () => {
+  it('tracks its own value and still reports it through onValueChange', async () => {
+    const user = userEvent.setup();
+    const onValueChange = vi.fn();
+    render(
+      <RadioGroup aria-label="Answer options" defaultValue="Copper" onValueChange={onValueChange}>
+        {OPTIONS.map((option) => (
+          <Radio key={option} value={option}>
+            {option}
+          </Radio>
+        ))}
+      </RadioGroup>,
+    );
+
+    expect(tabIndexes()).toEqual([0, -1, -1, -1]);
+    radios()[0].focus();
+    await user.keyboard('{ArrowDown}');
+
+    expect(onValueChange).toHaveBeenCalledWith('Aluminium');
+    expect(radios()[1]).toHaveAttribute('aria-checked', 'true');
+    expect(tabIndexes()).toEqual([-1, 0, -1, -1]);
+  });
+
+  it('submits through a hidden input when given a name', () => {
+    render(
+      <RadioGroup aria-label="Answer options" name="answer" defaultValue="Steel">
+        {OPTIONS.map((option) => (
+          <Radio key={option} value={option}>
+            {option}
+          </Radio>
+        ))}
+      </RadioGroup>,
+    );
+    const hidden = document.querySelector('input[name="answer"]');
+    expect(hidden).toHaveValue('Steel');
+  });
+});
diff --git a/frontend/src/components/ui/__tests__/primitives.test.tsx b/frontend/src/components/ui/__tests__/primitives.test.tsx
new file mode 100644
index 0000000..5d5ac19
--- /dev/null
+++ b/frontend/src/components/ui/__tests__/primitives.test.tsx
@@ -0,0 +1,456 @@
+import { describe, expect, it, vi } from 'vitest';
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Badge } from '../Badge';
+import { Button } from '../Button';
+import { EmptyState } from '../EmptyState';
+import { IconButton } from '../IconButton';
+import { ProgressBar, ProgressRing } from '../Progress';
+import { Separator } from '../Separator';
+import { Skeleton } from '../Skeleton';
+import { Spinner } from '../Spinner';
+import { Switch } from '../Switch';
+import { Tab, TabList, TabPanel, Tabs } from '../Tabs';
+import { Toast, ToastProvider } from '../Toast';
+import { useToast } from '../useToast';
+import { VisuallyHidden } from '../VisuallyHidden';
+
+describe('Button', () => {
+  it('merges className after its own classes', () => {
+    render(<Button className="custom">Go</Button>);
+    expect(screen.getByRole('button', { name: 'Go' }).className).toMatch(/custom$/);
+  });
+
+  it('stays focusable while loading and swallows activation', async () => {
+    const user = userEvent.setup();
+    const onClick = vi.fn();
+    render(
+      <Button loading loadingLabel="Saving" onClick={onClick}>
+        Save
+      </Button>,
+    );
+
+    const button = screen.getByRole('button');
+    expect(button).toHaveAttribute('aria-busy', 'true');
+    expect(button).toHaveAttribute('aria-disabled', 'true');
+    // Crucially NOT the disabled attribute, which would drop the control out
+    // of the tab order mid-request.
+    expect(button).not.toBeDisabled();
+
+    button.focus();
+    expect(button).toHaveFocus();
+
+    await user.click(button);
+    expect(onClick).not.toHaveBeenCalled();
+    expect(button).toHaveAccessibleName(/Saving/);
+  });
+
+  it('uses the real disabled attribute when explicitly disabled', () => {
+    render(<Button disabled>Save</Button>);
+    expect(screen.getByRole('button')).toBeDisabled();
+  });
+
+  it('names an icon-only button from aria-label', () => {
+    render(
+      <Button iconOnly aria-label="Bookmark question">
+        <span>*</span>
+      </Button>,
+    );
+    expect(screen.getByRole('button', { name: 'Bookmark question' })).toBeInTheDocument();
+  });
+});
+
+describe('IconButton', () => {
+  it('requires and applies an accessible name', async () => {
+    const user = userEvent.setup();
+    const onClick = vi.fn();
+    render(<IconButton aria-label="Close" icon={<span>x</span>} onClick={onClick} />);
+
+    await user.click(screen.getByRole('button', { name: 'Close' }));
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('Switch', () => {
+  it('is a switch with the correct checked state', () => {
+    render(<Switch defaultChecked>Dark mode</Switch>);
+    expect(screen.getByRole('switch', { name: 'Dark mode' })).toBeChecked();
+  });
+
+  it('toggles exactly once per Space press', async () => {
+    const user = userEvent.setup();
+    const onCheckedChange = vi.fn();
+    render(<Switch onCheckedChange={onCheckedChange}>Dark mode</Switch>);
+
+    const control = screen.getByRole('switch');
+    control.focus();
+    await user.keyboard(' ');
+
+    expect(onCheckedChange).toHaveBeenCalledTimes(1);
+    expect(onCheckedChange).toHaveBeenLastCalledWith(true);
+    expect(control).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('toggles exactly once per Enter press', async () => {
+    const user = userEvent.setup();
+    const onCheckedChange = vi.fn();
+    render(<Switch onCheckedChange={onCheckedChange}>Dark mode</Switch>);
+
+    screen.getByRole('switch').focus();
+    await user.keyboard('{Enter}');
+
+    expect(onCheckedChange).toHaveBeenCalledTimes(1);
+    expect(screen.getByRole('switch')).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('honours a controlled value', async () => {
+    const user = userEvent.setup();
+    const onCheckedChange = vi.fn();
+    render(
+      <Switch checked={false} onCheckedChange={onCheckedChange}>
+        Dark mode
+      </Switch>,
+    );
+
+    await user.click(screen.getByRole('switch'));
+    expect(onCheckedChange).toHaveBeenCalledWith(true);
+    expect(screen.getByRole('switch')).toHaveAttribute('aria-checked', 'false');
+  });
+
+  it('refuses activation while aria-disabled but stays focusable', async () => {
+    const user = userEvent.setup();
+    const onCheckedChange = vi.fn();
+    render(
+      <Switch disabled onCheckedChange={onCheckedChange}>
+        Dark mode
+      </Switch>,
+    );
+
+    const control = screen.getByRole('switch');
+    expect(control).toHaveAttribute('aria-disabled', 'true');
+    control.focus();
+    expect(control).toHaveFocus();
+
+    await user.click(control);
+    expect(onCheckedChange).not.toHaveBeenCalled();
+  });
+});
+
+function TabsFixture() {
+  return (
+    <Tabs defaultValue="all">
+      <TabList aria-label="Bookmark filters">
+        <Tab value="all">All</Tab>
+        <Tab value="flagged">Flagged</Tab>
+        <Tab value="wrong">Wrong</Tab>
+      </TabList>
+      <TabPanel value="all">All bookmarks</TabPanel>
+      <TabPanel value="flagged">Flagged bookmarks</TabPanel>
+      <TabPanel value="wrong">Wrong answers</TabPanel>
+    </Tabs>
+  );
+}
+
+describe('Tabs', () => {
+  it('wires tablist, tab and tabpanel with aria-selected and aria-controls', () => {
+    render(<TabsFixture />);
+
+    const list = screen.getByRole('tablist', { name: 'Bookmark filters' });
+    expect(list).toHaveAttribute('aria-orientation', 'horizontal');
+
+    const tabs = screen.getAllByRole('tab');
+    expect(tabs).toHaveLength(3);
+    expect(tabs[0]).toHaveAttribute('aria-selected', 'true');
+    expect(tabs[1]).toHaveAttribute('aria-selected', 'false');
+
+    const panel = screen.getByRole('tabpanel');
+    expect(tabs[0]).toHaveAttribute('aria-controls', panel.id);
+    expect(panel).toHaveAttribute('aria-labelledby', tabs[0].id);
+    expect(panel).toHaveAccessibleName('All');
+  });
+
+  it('exposes a single tab stop via roving tabindex', () => {
+    render(<TabsFixture />);
+    expect(screen.getAllByRole('tab').map((tab) => tab.tabIndex)).toEqual([0, -1, -1]);
+  });
+
+  it('moves and activates with ArrowRight/ArrowLeft, Home and End', async () => {
+    const user = userEvent.setup();
+    render(<TabsFixture />);
+    const tabs = screen.getAllByRole('tab');
+
+    tabs[0].focus();
+    await user.keyboard('{ArrowRight}');
+    expect(tabs[1]).toHaveFocus();
+    expect(tabs[1]).toHaveAttribute('aria-selected', 'true');
+    expect(screen.getByRole('tabpanel')).toHaveTextContent('Flagged bookmarks');
+
+    await user.keyboard('{End}');
+    expect(tabs[2]).toHaveFocus();
+    expect(tabs[2]).toHaveAttribute('aria-selected', 'true');
+
+    await user.keyboard('{ArrowRight}');
+    expect(tabs[0]).toHaveFocus();
+
+    await user.keyboard('{ArrowLeft}');
+    expect(tabs[2]).toHaveFocus();
+
+    await user.keyboard('{Home}');
+    expect(tabs[0]).toHaveFocus();
+    expect(tabs[0]).toHaveAttribute('aria-selected', 'true');
+  });
+
+  it('only moves focus in manual activation mode', async () => {
+    const user = userEvent.setup();
+    render(
+      <Tabs defaultValue="all" activationMode="manual">
+        <TabList aria-label="Filters">
+          <Tab value="all">All</Tab>
+          <Tab value="flagged">Flagged</Tab>
+        </TabList>
+        <TabPanel value="all">All</TabPanel>
+        <TabPanel value="flagged">Flagged</TabPanel>
+      </Tabs>,
+    );
+
+    const tabs = screen.getAllByRole('tab');
+    tabs[0].focus();
+    await user.keyboard('{ArrowRight}');
+
+    expect(tabs[1]).toHaveFocus();
+    expect(tabs[1]).toHaveAttribute('aria-selected', 'false');
+
+    await user.keyboard('{Enter}');
+    expect(tabs[1]).toHaveAttribute('aria-selected', 'true');
+  });
+
+  it('skips aria-disabled tabs during keyboard navigation', async () => {
+    const user = userEvent.setup();
+    render(
+      <Tabs defaultValue="a">
+        <TabList aria-label="Filters">
+          <Tab value="a">A</Tab>
+          <Tab value="b" disabled>
+            B
+          </Tab>
+          <Tab value="c">C</Tab>
+        </TabList>
+        <TabPanel value="a">A</TabPanel>
+        <TabPanel value="b">B</TabPanel>
+        <TabPanel value="c">C</TabPanel>
+      </Tabs>,
+    );
+
+    const tabs = screen.getAllByRole('tab');
+    tabs[0].focus();
+    await user.keyboard('{ArrowRight}');
+
+    expect(tabs[2]).toHaveFocus();
+    expect(tabs[1]).toHaveAttribute('aria-disabled', 'true');
+    expect(tabs[1]).not.toBeDisabled();
+  });
+});
+
+describe('ProgressBar / ProgressRing', () => {
+  it('exposes progressbar semantics and a text alternative', () => {
+    render(<ProgressBar label="Chapter progress" value={30} hint="12 / 40" />);
+
+    const bar = screen.getByRole('progressbar', { name: 'Chapter progress' });
+    expect(bar).toHaveAttribute('aria-valuenow', '30');
+    expect(bar).toHaveAttribute('aria-valuemin', '0');
+    expect(bar).toHaveAttribute('aria-valuemax', '100');
+    expect(bar).toHaveAttribute('aria-valuetext', '30%');
+  });
+
+  it('reports "n of max" when the range is not a percentage', () => {
+    render(<ProgressBar aria-label="Questions" value={12} max={40} />);
+    expect(screen.getByRole('progressbar')).toHaveAttribute('aria-valuetext', '12 of 40');
+  });
+
+  it('drops aria-valuenow when indeterminate', () => {
+    render(<ProgressBar aria-label="Loading" indeterminate />);
+    const bar = screen.getByRole('progressbar');
+    expect(bar).not.toHaveAttribute('aria-valuenow');
+    expect(bar).toHaveAttribute('aria-valuetext', 'In progress');
+  });
+
+  it('clamps out-of-range values instead of overflowing', () => {
+    render(<ProgressRing aria-label="Score" value={140} />);
+    expect(screen.getByRole('progressbar', { name: 'Score' })).toHaveAttribute(
+      'aria-valuenow',
+      '140',
+    );
+  });
+
+  it('renders ring centre content without adding it to the a11y tree', () => {
+    render(
+      <ProgressRing aria-label="Score" value={82}>
+        82%
+      </ProgressRing>,
+    );
+    expect(screen.getByRole('progressbar')).toHaveAttribute('aria-valuetext', '82%');
+  });
+});
+
+describe('Badge, Card, Skeleton, Spinner, Separator, EmptyState, VisuallyHidden', () => {
+  it('prefixes a badge with screen-reader-only context', () => {
+    render(<Badge tone="success" srPrefix="Status:" />);
+    expect(screen.getByText('Status:', { exact: false })).toBeInTheDocument();
+  });
+
+  it('hides skeletons from assistive tech', () => {
+    const { container } = render(<Skeleton lines={3} />);
+    expect(container.firstElementChild).toHaveAttribute('aria-hidden', 'true');
+  });
+
+  it('announces a labelled spinner and hides an unlabelled one', () => {
+    const { rerender } = render(<Spinner label="Loading questions" />);
+    expect(screen.getByRole('status')).toHaveTextContent('Loading questions');
+
+    rerender(<Spinner />);
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+  });
+
+  it('keeps a decorative separator out of the a11y tree', () => {
+    const { rerender, container } = render(<Separator />);
+    expect(container.querySelector('[role="none"]')).toBeInTheDocument();
+
+    rerender(<Separator decorative={false} orientation="vertical" />);
+    const separator = screen.getByRole('separator');
+    expect(separator).toHaveAttribute('aria-orientation', 'vertical');
+  });
+
+  it('renders an empty state heading at the requested level', () => {
+    render(<EmptyState title="No bookmarks yet" headingLevel={2} description="Flag a question." />);
+    expect(screen.getByRole('heading', { level: 2, name: 'No bookmarks yet' })).toBeInTheDocument();
+  });
+
+  it('keeps visually hidden text in the a11y tree', () => {
+    render(<VisuallyHidden>Correct answer</VisuallyHidden>);
+    expect(screen.getByText('Correct answer')).toBeInTheDocument();
+  });
+});
+
+function ToastTrigger() {
+  const { toast } = useToast();
+  return (
+    <button type="button" onClick={() => toast({ title: 'Saved', description: 'Attempt stored' })}>
+      Notify
+    </button>
+  );
+}
+
+describe('Toast', () => {
+  it('renders in a polite live region', async () => {
+    const user = userEvent.setup();
+    render(
+      <ToastProvider>
+        <ToastTrigger />
+      </ToastProvider>,
+    );
+
+    await user.click(screen.getByRole('button', { name: 'Notify' }));
+
+    const region = screen.getByRole('status');
+    expect(region).toHaveAttribute('aria-live', 'polite');
+    expect(region).toHaveTextContent('Saved');
+    expect(region).toHaveTextContent('Attempt stored');
+  });
+
+  it('can be dismissed with its close button', async () => {
+    const user = userEvent.setup();
+    render(
+      <ToastProvider>
+        <ToastTrigger />
+      </ToastProvider>,
+    );
+
+    await user.click(screen.getByRole('button', { name: 'Notify' }));
+    await user.click(screen.getByRole('button', { name: 'Dismiss notification' }));
+
+    expect(screen.getByRole('status')).toBeEmptyDOMElement();
+  });
+
+  // fireEvent rather than userEvent: user-event's own internal delays
+  // deadlock against fake timers, and this test is specifically about the
+  // auto-dismiss clock.
+  it('auto-dismisses after its duration', () => {
+    vi.useFakeTimers();
+    try {
+      render(
+        <ToastProvider duration={1000}>
+          <ToastTrigger />
+        </ToastProvider>,
+      );
+
+      fireEvent.click(screen.getByRole('button', { name: 'Notify' }));
+      expect(screen.getByRole('status')).toHaveTextContent('Saved');
+
+      act(() => vi.advanceTimersByTime(1200));
+      expect(screen.getByRole('status')).toBeEmptyDOMElement();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('pauses the auto-dismiss clock while hovered, and resumes on leave', () => {
+    vi.useFakeTimers();
+    try {
+      render(
+        <ToastProvider duration={1000}>
+          <ToastTrigger />
+        </ToastProvider>,
+      );
+
+      fireEvent.click(screen.getByRole('button', { name: 'Notify' }));
+      const toast = screen.getByRole('status').firstElementChild as HTMLElement;
+
+      fireEvent.mouseOver(toast);
+      act(() => vi.advanceTimersByTime(5000));
+      expect(screen.getByRole('status')).toHaveTextContent('Saved');
+
+      fireEvent.mouseOut(toast);
+      act(() => vi.advanceTimersByTime(1500));
+      expect(screen.getByRole('status')).toBeEmptyDOMElement();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('pauses the auto-dismiss clock while focus is inside the toast', () => {
+    vi.useFakeTimers();
+    try {
+      render(
+        <ToastProvider duration={1000}>
+          <ToastTrigger />
+        </ToastProvider>,
+      );
+
+      fireEvent.click(screen.getByRole('button', { name: 'Notify' }));
+      const dismiss = screen.getByRole('button', { name: 'Dismiss notification' });
+
+      // Tabbing to the dismiss button must not let the toast vanish
+      // mid-reach (WCAG 2.2.1 Timing Adjustable).
+      fireEvent.focus(dismiss);
+      act(() => vi.advanceTimersByTime(5000));
+      expect(screen.getByRole('status')).toHaveTextContent('Saved');
+
+      fireEvent.blur(dismiss);
+      act(() => vi.advanceTimersByTime(1500));
+      expect(screen.getByRole('status')).toBeEmptyDOMElement();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('keeps a sticky toast until it is dismissed', () => {
+    vi.useFakeTimers();
+    try {
+      render(<Toast title="Offline" description="Answers are queued" tone="warning" />);
+      vi.advanceTimersByTime(60_000);
+      expect(screen.getByText('Offline')).toBeInTheDocument();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
diff --git a/frontend/src/components/ui/compose-refs.ts b/frontend/src/components/ui/compose-refs.ts
new file mode 100644
index 0000000..31a9fef
--- /dev/null
+++ b/frontend/src/components/ui/compose-refs.ts
@@ -0,0 +1,33 @@
+import { useCallback } from 'react';
+import type { Ref, RefCallback, RefObject } from 'react';
+
+function assignRef<T>(ref: Ref<T> | undefined, node: T | null): void {
+  if (!ref) return;
+  if (typeof ref === 'function') {
+    ref(node);
+    return;
+  }
+  // `RefObject.current` is readonly in the public types but React itself
+  // writes through it; this is the standard escape hatch.
+  (ref as { current: T | null }).current = node;
+}
+
+/**
+ * Lets a component keep its own internal ref (needed for DOM measurement or
+ * focus management) while still honouring a forwarded ref.
+ *
+ * The `Ref` name suffixes are load-bearing: `react-hooks/immutability` uses
+ * them to recognise these arguments as refs rather than plain props.
+ */
+export function useComposedRef<T>(
+  forwardedRef: Ref<T> | undefined,
+  localRef: RefObject<T | null>,
+): RefCallback<T> {
+  return useCallback(
+    (node: T | null) => {
+      localRef.current = node;
+      assignRef(forwardedRef, node);
+    },
+    [forwardedRef, localRef],
+  );
+}
diff --git a/frontend/src/components/ui/cx.ts b/frontend/src/components/ui/cx.ts
new file mode 100644
index 0000000..ce74c5f
--- /dev/null
+++ b/frontend/src/components/ui/cx.ts
@@ -0,0 +1,15 @@
+/**
+ * Minimal class-name joiner. Every primitive in this folder takes a
+ * `className` and merges it *after* its own classes so consumer styles win
+ * at equal specificity.
+ */
+export type ClassValue = string | false | null | undefined;
+
+export function cx(...values: ClassValue[]): string {
+  let out = '';
+  for (const value of values) {
+    if (!value) continue;
+    out = out ? `${out} ${value}` : value;
+  }
+  return out;
+}
diff --git a/frontend/src/components/ui/focusable.ts b/frontend/src/components/ui/focusable.ts
new file mode 100644
index 0000000..b75ba96
--- /dev/null
+++ b/frontend/src/components/ui/focusable.ts
@@ -0,0 +1,41 @@
+/**
+ * Selector for things the platform considers tabbable. Deliberately avoids
+ * `offsetParent`-based visibility filtering: jsdom has no layout engine, so
+ * that check would report every element as hidden and silently disable the
+ * dialog focus trap in tests.
+ */
+const FOCUSABLE_SELECTOR = [
+  'a[href]',
+  'area[href]',
+  'button:not([disabled])',
+  'input:not([disabled]):not([type="hidden"])',
+  'select:not([disabled])',
+  'textarea:not([disabled])',
+  'iframe',
+  'object',
+  'embed',
+  'summary',
+  'audio[controls]',
+  'video[controls]',
+  '[contenteditable]:not([contenteditable="false"])',
+  '[tabindex]',
+].join(',');
+
+function isHidden(element: HTMLElement): boolean {
+  let node: HTMLElement | null = element;
+  while (node) {
+    if (node.hasAttribute('hidden')) return true;
+    if (node.getAttribute('aria-hidden') === 'true') return true;
+    if (node.hasAttribute('inert')) return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+
+/** Tabbable descendants of `root`, in document order. */
+export function getFocusableElements(root: HTMLElement | null): HTMLElement[] {
+  if (!root) return [];
+  return Array.from(root.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)).filter(
+    (element) => element.tabIndex >= 0 && !isHidden(element),
+  );
+}
diff --git a/frontend/src/components/ui/index.ts b/frontend/src/components/ui/index.ts
new file mode 100644
index 0000000..8b5f06a
--- /dev/null
+++ b/frontend/src/components/ui/index.ts
@@ -0,0 +1,83 @@
+/**
+ * Accessible UI primitives.
+ *
+ * Every interactive primitive here guarantees: a visible `:focus-visible`
+ * ring, a >=44x44px touch target, `prefers-reduced-motion` support, a
+ * `className` passthrough that merges after the component's own classes, a
+ * forwarded ref to the underlying element, and the ARIA pattern named in its
+ * props docs. See ./README.md.
+ */
+
+export { Badge } from './Badge';
+export type { BadgeProps, BadgeTone } from './Badge';
+
+export { Button } from './Button';
+export type { ButtonBaseProps, ButtonProps, ButtonSize, ButtonVariant } from './Button';
+
+export { Card } from './Card';
+export type { CardPadding, CardProps, CardVariant } from './Card';
+
+export { Dialog } from './Dialog';
+export type { DialogProps, DialogSize } from './Dialog';
+
+export { EmptyState } from './EmptyState';
+export type { EmptyStateProps } from './EmptyState';
+
+export { IconButton } from './IconButton';
+export type { IconButtonProps } from './IconButton';
+
+export { ProgressBar, ProgressRing } from './Progress';
+export type {
+  ProgressBarBaseProps,
+  ProgressBarProps,
+  ProgressRingBaseProps,
+  ProgressRingProps,
+  ProgressTone,
+} from './Progress';
+
+export { Radio, RadioGroup } from './RadioGroup';
+export type {
+  RadioGroupBaseProps,
+  RadioGroupProps,
+  RadioProps,
+  RadioVisualState,
+} from './RadioGroup';
+
+export { Separator } from './Separator';
+export type { SeparatorProps } from './Separator';
+
+export { Skeleton } from './Skeleton';
+export type { SkeletonProps } from './Skeleton';
+
+export { Spinner } from './Spinner';
+export type { SpinnerProps } from './Spinner';
+
+export { Switch } from './Switch';
+export type { SwitchBaseProps, SwitchProps } from './Switch';
+
+export { Tab, TabList, TabPanel, Tabs } from './Tabs';
+export type {
+  TabListBaseProps,
+  TabListProps,
+  TabPanelProps,
+  TabProps,
+  TabsActivationMode,
+  TabsBaseProps,
+  TabsOrientation,
+  TabsProps,
+} from './Tabs';
+export { tabId, tabPanelId } from './tab-ids';
+
+export { Toast, ToastProvider } from './Toast';
+export type { ToastPlacement, ToastProps, ToastProviderProps } from './Toast';
+export type { ToastOptions, ToastRecord, ToastTone, ToastContextValue } from './toast-context';
+export { useToast } from './useToast';
+
+export { VisuallyHidden } from './VisuallyHidden';
+export type { VisuallyHiddenProps } from './VisuallyHidden';
+
+export { cx } from './cx';
+export type { ClassValue } from './cx';
+export { getFocusableElements } from './focusable';
+export { lockBodyScroll, unlockBodyScroll } from './scroll-lock';
+export { useComposedRef } from './compose-refs';
diff --git a/frontend/src/components/ui/scroll-lock.ts b/frontend/src/components/ui/scroll-lock.ts
new file mode 100644
index 0000000..4837d69
--- /dev/null
+++ b/frontend/src/components/ui/scroll-lock.ts
@@ -0,0 +1,33 @@
+let lockCount = 0;
+let previousOverflow = '';
+let previousPaddingRight = '';
+
+/**
+ * Reference-counted body scroll lock so nested/stacked overlays do not
+ * restore the page scroll while another overlay is still open.
+ */
+export function lockBodyScroll(): void {
+  if (typeof document === 'undefined') return;
+  lockCount += 1;
+  if (lockCount > 1) return;
+
+  const { body, documentElement } = document;
+  previousOverflow = body.style.overflow;
+  previousPaddingRight = body.style.paddingRight;
+
+  const scrollbarWidth = window.innerWidth - documentElement.clientWidth;
+  body.style.overflow = 'hidden';
+  if (scrollbarWidth > 0) {
+    body.style.paddingRight = `${scrollbarWidth}px`;
+  }
+}
+
+export function unlockBodyScroll(): void {
+  if (typeof document === 'undefined') return;
+  if (lockCount === 0) return;
+  lockCount -= 1;
+  if (lockCount > 0) return;
+
+  document.body.style.overflow = previousOverflow;
+  document.body.style.paddingRight = previousPaddingRight;
+}
diff --git a/frontend/src/components/ui/tab-ids.ts b/frontend/src/components/ui/tab-ids.ts
new file mode 100644
index 0000000..7af6c54
--- /dev/null
+++ b/frontend/src/components/ui/tab-ids.ts
@@ -0,0 +1,16 @@
+/**
+ * `id` wiring for the tablist/tab/tabpanel relationship. Tab values are
+ * arbitrary strings (slugs, labels, ids from the API), so they are sanitised
+ * before being used as HTML ids.
+ */
+function slug(value: string): string {
+  return value.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+export function tabId(baseId: string, value: string): string {
+  return `${baseId}-tab-${slug(value)}`;
+}
+
+export function tabPanelId(baseId: string, value: string): string {
+  return `${baseId}-panel-${slug(value)}`;
+}
diff --git a/frontend/src/components/ui/toast-context.ts b/frontend/src/components/ui/toast-context.ts
new file mode 100644
index 0000000..e46d219
--- /dev/null
+++ b/frontend/src/components/ui/toast-context.ts
@@ -0,0 +1,33 @@
+import { createContext } from 'react';
+import type { ReactNode } from 'react';
+
+export type ToastTone = 'neutral' | 'success' | 'warning' | 'danger' | 'info';
+
+export interface ToastOptions {
+  title?: ReactNode;
+  description?: ReactNode;
+  tone?: ToastTone;
+  /** Auto-dismiss delay in ms. `0` or a negative value means "stay until dismissed". */
+  duration?: number;
+  /** Optional action, usually a `Button`. */
+  action?: ReactNode;
+  /**
+   * `polite` (default) waits for a pause in speech; `assertive` interrupts.
+   * Reserve `assertive` for errors that block the user.
+   */
+  politeness?: 'polite' | 'assertive';
+}
+
+export interface ToastRecord extends ToastOptions {
+  id: string;
+}
+
+export interface ToastContextValue {
+  toasts: readonly ToastRecord[];
+  /** Queues a toast and returns its id. */
+  toast: (options: ToastOptions) => string;
+  dismiss: (id: string) => void;
+  dismissAll: () => void;
+}
+
+export const ToastContext = createContext<ToastContextValue | null>(null);
diff --git a/frontend/src/components/ui/useToast.ts b/frontend/src/components/ui/useToast.ts
new file mode 100644
index 0000000..8c1608b
--- /dev/null
+++ b/frontend/src/components/ui/useToast.ts
@@ -0,0 +1,16 @@
+import { useContext } from 'react';
+import { ToastContext } from './toast-context';
+import type { ToastContextValue } from './toast-context';
+
+/**
+ * Access the toast queue. Throws rather than no-oping when no provider is
+ * mounted: a silently swallowed notification is a bug that only surfaces in
+ * production.
+ */
+export function useToast(): ToastContextValue {
+  const context = useContext(ToastContext);
+  if (!context) {
+    throw new Error('useToast() must be called inside a <ToastProvider>.');
+  }
+  return context;
+}
diff --git a/frontend/src/context/UserContext.tsx b/frontend/src/context/UserContext.tsx
index 221d1f9..dc8be2e 100644
--- a/frontend/src/context/UserContext.tsx
+++ b/frontend/src/context/UserContext.tsx
@@ -1,17 +1,14 @@
-import { createContext, useContext, useState } from 'react';
+import { useState } from 'react';
+import { UserContext } from './user-context';
 
-interface UserContextType {
-  name: string;
-  setName: (name: string) => void;
-}
-
-const UserContext = createContext<UserContextType>({ name: '', setName: () => {} });
+const STORAGE_KEY = 'userName';
 
 export function UserProvider({ children }: { children: React.ReactNode }) {
-  const [name, setNameState] = useState(() => localStorage.getItem('userName') || '');
+  const [name, setNameState] = useState(() => localStorage.getItem(STORAGE_KEY) || '');
 
   const setName = (n: string) => {
-    localStorage.setItem('userName', n);
+    if (n) localStorage.setItem(STORAGE_KEY, n);
+    else localStorage.removeItem(STORAGE_KEY);
     setNameState(n);
   };
 
@@ -21,7 +18,3 @@ export function UserProvider({ children }: { children: React.ReactNode }) {
     </UserContext.Provider>
   );
 }
-
-export function useUser() {
-  return useContext(UserContext);
-}
diff --git a/frontend/src/context/user-context.ts b/frontend/src/context/user-context.ts
new file mode 100644
index 0000000..71304e7
--- /dev/null
+++ b/frontend/src/context/user-context.ts
@@ -0,0 +1,15 @@
+import { createContext, useContext } from 'react';
+
+export interface UserContextType {
+  name: string;
+  setName: (name: string) => void;
+}
+
+export const UserContext = createContext<UserContextType>({
+  name: '',
+  setName: () => {},
+});
+
+export function useUser() {
+  return useContext(UserContext);
+}
diff --git a/frontend/src/data/__tests__/examBlueprint.test.ts b/frontend/src/data/__tests__/examBlueprint.test.ts
new file mode 100644
index 0000000..dcf5df0
--- /dev/null
+++ b/frontend/src/data/__tests__/examBlueprint.test.ts
@@ -0,0 +1,276 @@
+import { describe, it, expect } from 'vitest';
+import {
+  NO_SUBCHAPTER_TAGS,
+  QUESTIONS_PER_CHAPTER,
+  WEIGHTING_RULE,
+  describeShortfall,
+  examBlueprint,
+  examFormat,
+  formatUnverifiedFields,
+  isFormatFullyVerified,
+  listUnverifiedFields,
+  planExam,
+  readBlueprintValue,
+  readConfirmed,
+  readUnverified,
+  selectionBlueprint,
+  totalMarks,
+} from '../examBlueprint';
+import type { QuestionSupply } from '../examBlueprint';
+import { SUBCHAPTER_COUNT, subchapterCodes, syllabusChapters } from '../syllabus';
+
+/** Supply that exactly satisfies the blueprint: every quota met by tagged questions. */
+function exactTaggedSupply(): QuestionSupply {
+  const supply: Record<string, number> = {};
+  for (const quota of selectionBlueprint.quotas) {
+    supply[quota.subchapterCode] = quota.questions;
+  }
+  return supply;
+}
+
+/** Chapter pools large enough to cover any fallback. */
+function generousChapterSupply(): QuestionSupply {
+  const supply: Record<string, number> = {};
+  for (const chapter of syllabusChapters) {
+    supply[chapter.code] = 500;
+  }
+  return supply;
+}
+
+describe('exam format provenance', () => {
+  it('carries the owner-confirmed 100 questions x 1 mark = 100 marks', () => {
+    expect(readConfirmed(examFormat.questionCount)).toBe(100);
+    expect(readConfirmed(examFormat.marksPerQuestion)).toBe(1);
+    expect(totalMarks()).toBe(100);
+  });
+
+  it('records a verifiedOn date and a provenance kind on every field', () => {
+    for (const [key, field] of Object.entries(examFormat)) {
+      expect(field.status, key).toBe('confirmed');
+      expect(field.source.verifiedOn, key).toBe('2026-10-20');
+      expect(field.source.kind, key).toBe('project-owner');
+    }
+  });
+
+  it('carries a null sourceUrl, because no published document states these', () => {
+    // The official syllabus PDF contains no marking scheme. Citing a URL here
+    // would manufacture an authority that does not exist, so null is the
+    // honest value and this test exists to stop a plausible-looking URL being
+    // added later.
+    for (const [key, field] of Object.entries(examFormat)) {
+      expect(field.source.sourceUrl, key).toBeNull();
+    }
+  });
+
+  it('holds the owner-confirmed exam format', () => {
+    expect(readConfirmed(examFormat.questionCount)).toBe(100);
+    expect(readConfirmed(examFormat.marksPerQuestion)).toBe(1);
+    expect(readConfirmed(examFormat.durationMinutes)).toBe(120);
+    expect(readConfirmed(examFormat.passMark)).toBe(50);
+    expect(totalMarks()).toBe(100);
+  });
+
+  it('allows 72 seconds per question, not the 27 the old 45-minute default gave', () => {
+    // Pacing analytics depend on this, and the app shipped 45 minutes against a
+    // 120-minute exam - a 2.7x error in every per-question time budget.
+    const seconds =
+      (readConfirmed(examFormat.durationMinutes) * 60) /
+      readConfirmed(examFormat.questionCount);
+    expect(seconds).toBeCloseTo(72, 5);
+  });
+});
+
+describe('unverified-field reporting', () => {
+  it('reports nothing unverified now that the owner has confirmed all four', () => {
+    expect(listUnverifiedFields()).toEqual([]);
+    expect(formatUnverifiedFields()).toBe('');
+    expect(isFormatFullyVerified()).toBe(true);
+  });
+
+  // The machinery stays tested against a synthetic field rather than a real one.
+  // Negative marking and per-chapter weights are still unknown, so the next
+  // field added is likelier to be a guess than a confirmation, and the refusal
+  // path has to still work when it arrives.
+  const syntheticUnverified = {
+    value: 0.25,
+    status: 'needs-verification',
+    label: 'negativeMarkPerWrong',
+    unit: 'marks',
+    source: {
+      kind: 'secondary-source',
+      label: 'Not established',
+      sourceUrl: null,
+      verifiedOn: null,
+      note: 'No source states whether NEC applies negative marking.',
+    },
+  } as const;
+
+  it('still refuses to read an unverified value without acknowledgement', () => {
+    expect(() => readBlueprintValue(syntheticUnverified)).toThrow(/needs-verification/);
+  });
+
+  it('still allows an acknowledged unverified read', () => {
+    expect(
+      readUnverified(syntheticUnverified, {
+        acknowledgeUnverified: true,
+        reason: 'test: displaying a best guess behind a warning banner',
+      }),
+    ).toBe(0.25);
+  });
+});
+
+describe('reading values safely', () => {
+  it('allows every confirmed value through without ceremony', () => {
+    expect(readBlueprintValue(examFormat.questionCount)).toBe(100);
+    expect(readBlueprintValue(examFormat.durationMinutes)).toBe(120);
+  });
+});
+
+describe('selection blueprint weights', () => {
+  it('has one quota per official sub-chapter', () => {
+    expect(selectionBlueprint.quotas).toHaveLength(SUBCHAPTER_COUNT);
+    expect(selectionBlueprint.quotas.map(quota => quota.subchapterCode)).toEqual([
+      ...subchapterCodes,
+    ]);
+  });
+
+  it('sums to exactly 100 questions', () => {
+    const total = selectionBlueprint.quotas.reduce((sum, quota) => sum + quota.questions, 0);
+    expect(total).toBe(100);
+    expect(total).toBe(selectionBlueprint.totalQuestions);
+    expect(total).toBe(readConfirmed(examFormat.questionCount));
+  });
+
+  it('gives every chapter an equal 10-question weight', () => {
+    for (const chapter of syllabusChapters) {
+      const chapterTotal = selectionBlueprint.quotas
+        .filter(quota => quota.chapterCode === chapter.code)
+        .reduce((sum, quota) => sum + quota.questions, 0);
+      expect(chapterTotal, chapter.code).toBe(QUESTIONS_PER_CHAPTER);
+    }
+  });
+
+  it('applies the documented largest-remainder tie-break on index', () => {
+    for (const quota of selectionBlueprint.quotas) {
+      const expected = quota.subchapterIndex <= 4 ? 2 : 1;
+      expect(quota.questions, quota.subchapterCode).toBe(expected);
+    }
+  });
+
+  it('ships non-strict with a documented chapter-level fallback', () => {
+    expect(selectionBlueprint.strictBlueprint).toBe(false);
+    expect(selectionBlueprint.fallback).toBe('chapter-level-sampling');
+    expect(selectionBlueprint.weightingRule).toBe(WEIGHTING_RULE);
+    expect(selectionBlueprint.notes.length).toBeGreaterThan(0);
+  });
+
+  it('is reachable from the top-level blueprint', () => {
+    expect(examBlueprint.selection).toBe(selectionBlueprint);
+    expect(examBlueprint.format).toBe(examFormat);
+  });
+});
+
+describe('planExam', () => {
+  it('builds a 100-question plan from an exactly sufficient tagged supply', () => {
+    const result = planExam(exactTaggedSupply());
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    expect(result.plan.totalQuestions).toBe(100);
+    expect(result.plan.draws).toHaveLength(SUBCHAPTER_COUNT);
+    expect(result.plan.approximatedSubchapterCodes).toEqual([]);
+    expect(result.plan.unknownSupplyCodes).toEqual([]);
+    const tagged = result.plan.draws.reduce((sum, draw) => sum + draw.fromSubchapterTagged, 0);
+    expect(tagged).toBe(100);
+  });
+
+  it('succeeds under strict mode only when tagged supply covers every quota', () => {
+    const strict = planExam(exactTaggedSupply(), { strictBlueprint: true });
+    expect(strict.ok).toBe(true);
+  });
+
+  it('reports all 60 sub-chapters as approximated when nothing is tagged', () => {
+    const result = planExam(NO_SUBCHAPTER_TAGS, { chapterSupply: generousChapterSupply() });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    expect(result.plan.totalQuestions).toBe(100);
+    expect(result.plan.approximatedSubchapterCodes).toHaveLength(SUBCHAPTER_COUNT);
+    expect(result.plan.draws.every(draw => draw.fromSubchapterTagged === 0)).toBe(true);
+    expect(result.plan.draws.every(draw => draw.approximated)).toBe(true);
+  });
+
+  it('fails strictly when nothing is tagged, naming every missing sub-chapter', () => {
+    const result = planExam(NO_SUBCHAPTER_TAGS, {
+      strictBlueprint: true,
+      chapterSupply: generousChapterSupply(),
+    });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+
+    expect(result.report.shortfalls).toHaveLength(SUBCHAPTER_COUNT);
+    expect(result.report.totalRequested).toBe(100);
+    expect(result.report.totalPlanned).toBe(0);
+    expect(result.report.totalMissing).toBe(100);
+  });
+
+  it('returns a structured shortfall for a deliberately under-supplied input', () => {
+    const supply: Record<string, number> = { ...exactTaggedSupply() };
+    // ACtE0301 needs 2, give it 0. ACtE0305 needs 1, give it 0.
+    supply['ACtE0301'] = 0;
+    supply['ACtE0305'] = 0;
+    // Chapter 3's pool can only absorb one of the three missing questions.
+    const result = planExam(supply, { chapterSupply: { ACtE03: 8 } });
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+
+    const byCode = new Map(result.report.shortfalls.map(entry => [entry.subchapterCode, entry]));
+    expect([...byCode.keys()]).toEqual(['ACtE0301', 'ACtE0305']);
+
+    const first = byCode.get('ACtE0301');
+    expect(first?.requested).toBe(2);
+    expect(first?.availableTagged).toBe(0);
+    expect(first?.planned).toBe(1);
+    expect(first?.missing).toBe(1);
+    expect(first?.chapterCode).toBe('ACtE03');
+
+    const second = byCode.get('ACtE0305');
+    expect(second?.requested).toBe(1);
+    expect(second?.planned).toBe(0);
+    expect(second?.missing).toBe(1);
+
+    expect(result.report.totalRequested).toBe(100);
+    expect(result.report.totalPlanned).toBe(98);
+    expect(result.report.totalMissing).toBe(2);
+    expect(describeShortfall(result.report)).toBe(
+      'Short 2 of 100 questions across 2 sub-chapters: ACtE0301 (-1), ACtE0305 (-1)',
+    );
+  });
+
+  it('fails when no chapter fallback pool is supplied either', () => {
+    const result = planExam(NO_SUBCHAPTER_TAGS);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.report.totalMissing).toBe(100);
+    expect(result.report.strictBlueprint).toBe(false);
+  });
+
+  it('flags supply keys that are not official sub-chapter codes', () => {
+    const supply: Record<string, number> = { ...exactTaggedSupply(), ACtE0399: 5, 'book-ch3': 9 };
+    const result = planExam(supply);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect([...result.plan.unknownSupplyCodes].sort()).toEqual(['ACtE0399', 'book-ch3']);
+  });
+
+  it('ignores negative and non-finite supply counts rather than trusting them', () => {
+    const supply: Record<string, number> = { ...exactTaggedSupply() };
+    supply['AExE0101'] = -5;
+    supply['AExE0102'] = Number.NaN;
+    const result = planExam(supply, { chapterSupply: { AExE01: 100 } });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect([...result.plan.approximatedSubchapterCodes]).toEqual(['AExE0101', 'AExE0102']);
+  });
+});
diff --git a/frontend/src/data/__tests__/syllabus.test.ts b/frontend/src/data/__tests__/syllabus.test.ts
new file mode 100644
index 0000000..12069aa
--- /dev/null
+++ b/frontend/src/data/__tests__/syllabus.test.ts
@@ -0,0 +1,195 @@
+import { describe, it, expect } from 'vitest';
+import {
+  CHAPTER_COUNT,
+  SUBCHAPTERS_PER_CHAPTER,
+  SUBCHAPTER_COUNT,
+  chapterCodes,
+  expectedSubchapterCode,
+  getChapterByBookChapterId,
+  getChapterByCode,
+  getChapterByNumber,
+  getChapterForSubchapter,
+  getSubchapterByCode,
+  getSubchaptersForChapter,
+  isValidChapterCode,
+  isValidSubchapterCode,
+  subchapterCodes,
+  syllabusChapters,
+  syllabusSubchapters,
+} from '../syllabus';
+
+/**
+ * The official chapter code prefixes, in order. Chapters 1-2 are the shared
+ * electrical/electronics core, 3-9 the Computer Engineering stream, 10 the
+ * all-streams project chapter.
+ */
+const EXPECTED_CHAPTER_CODES = [
+  'AExE01',
+  'AExE02',
+  'ACtE03',
+  'ACtE04',
+  'ACtE05',
+  'ACtE06',
+  'ACtE07',
+  'ACtE08',
+  'ACtE09',
+  'AALL10',
+] as const;
+
+describe('syllabus structure (10 x 6 = 60)', () => {
+  it('declares the structural constants the NEC syllabus uses', () => {
+    expect(CHAPTER_COUNT).toBe(10);
+    expect(SUBCHAPTERS_PER_CHAPTER).toBe(6);
+    expect(SUBCHAPTER_COUNT).toBe(CHAPTER_COUNT * SUBCHAPTERS_PER_CHAPTER);
+    expect(SUBCHAPTER_COUNT).toBe(60);
+  });
+
+  it('has exactly 10 chapters', () => {
+    expect(syllabusChapters).toHaveLength(CHAPTER_COUNT);
+    expect(chapterCodes).toHaveLength(CHAPTER_COUNT);
+  });
+
+  it('has exactly 6 sub-chapters in every chapter', () => {
+    for (const chapter of syllabusChapters) {
+      expect(chapter.subchapters, 'chapter ' + chapter.code).toHaveLength(SUBCHAPTERS_PER_CHAPTER);
+    }
+  });
+
+  it('totals exactly 60 sub-chapters', () => {
+    expect(syllabusSubchapters).toHaveLength(SUBCHAPTER_COUNT);
+    expect(subchapterCodes).toHaveLength(SUBCHAPTER_COUNT);
+
+    const summed = syllabusChapters.reduce((total, chapter) => total + chapter.subchapters.length, 0);
+    expect(summed).toBe(SUBCHAPTER_COUNT);
+  });
+
+  it('numbers chapters 1..10 in order', () => {
+    expect(syllabusChapters.map(chapter => chapter.number)).toEqual([
+      1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+    ]);
+  });
+
+  it('indexes sub-chapters 1..6 within every chapter', () => {
+    for (const chapter of syllabusChapters) {
+      expect(chapter.subchapters.map(sub => sub.index), 'chapter ' + chapter.code).toEqual([
+        1, 2, 3, 4, 5, 6,
+      ]);
+    }
+  });
+});
+
+describe('code correctness', () => {
+  it('uses the official chapter codes in official order', () => {
+    expect(chapterCodes).toEqual([...EXPECTED_CHAPTER_CODES]);
+  });
+
+  it('prefixes every sub-chapter code with its chapter code and a padded index', () => {
+    for (const chapter of syllabusChapters) {
+      for (const sub of chapter.subchapters) {
+        expect(sub.chapterCode).toBe(chapter.code);
+        expect(sub.chapterNumber).toBe(chapter.number);
+        expect(sub.code.startsWith(chapter.code)).toBe(true);
+        expect(sub.code).toBe(expectedSubchapterCode(chapter.code, sub.index));
+        expect(sub.code).toHaveLength(chapter.code.length + 2);
+      }
+    }
+  });
+
+  it('has no duplicate chapter codes', () => {
+    expect(new Set(chapterCodes).size).toBe(CHAPTER_COUNT);
+  });
+
+  it('has no duplicate sub-chapter codes', () => {
+    expect(new Set(subchapterCodes).size).toBe(SUBCHAPTER_COUNT);
+  });
+
+  it('maps each chapter to a distinct book-chN id', () => {
+    const bookIds = syllabusChapters.map(chapter => chapter.bookChapterId);
+    expect(bookIds).toEqual([
+      'book-ch1',
+      'book-ch2',
+      'book-ch3',
+      'book-ch4',
+      'book-ch5',
+      'book-ch6',
+      'book-ch7',
+      'book-ch8',
+      'book-ch9',
+      'book-ch10',
+    ]);
+    expect(new Set(bookIds).size).toBe(CHAPTER_COUNT);
+  });
+
+  it('renders a dotted display code matching chapter.index', () => {
+    expect(getSubchapterByCode('ACtE0304')?.displayCode).toBe('3.4');
+    expect(getSubchapterByCode('AALL1006')?.displayCode).toBe('10.6');
+
+    for (const sub of syllabusSubchapters) {
+      expect(sub.displayCode).toBe(String(sub.chapterNumber) + '.' + String(sub.index));
+    }
+  });
+
+  it('gives every chapter and sub-chapter a non-empty title', () => {
+    for (const chapter of syllabusChapters) {
+      expect(chapter.title.trim().length).toBeGreaterThan(0);
+      for (const sub of chapter.subchapters) {
+        expect(sub.title.trim().length, sub.code).toBeGreaterThan(0);
+      }
+    }
+  });
+});
+
+describe('lookups', () => {
+  it('finds a chapter by code, number and book id', () => {
+    expect(getChapterByCode('ACtE07')?.number).toBe(7);
+    expect(getChapterByNumber(7)?.code).toBe('ACtE07');
+    expect(getChapterByBookChapterId('book-ch7')?.code).toBe('ACtE07');
+  });
+
+  it('returns undefined for unknown chapter keys', () => {
+    expect(getChapterByCode('ACtE99')).toBeUndefined();
+    expect(getChapterByNumber(11)).toBeUndefined();
+    expect(getChapterByBookChapterId('book-ch11')).toBeUndefined();
+  });
+
+  it('finds a sub-chapter by code', () => {
+    const sub = getSubchapterByCode('ACtE0402');
+    expect(sub?.title).toBe('Computer Arithmetic and Memory System');
+    expect(sub?.chapterCode).toBe('ACtE04');
+    expect(sub?.index).toBe(2);
+    expect(getSubchapterByCode('ACtE0407')).toBeUndefined();
+  });
+
+  it('returns a chapter sub-chapter list, empty for unknown chapters', () => {
+    expect(getSubchaptersForChapter('AExE02')).toHaveLength(6);
+    expect(getSubchaptersForChapter('nope')).toEqual([]);
+  });
+
+  it('round-trips chapter-for-subchapter for all 60 codes', () => {
+    for (const sub of syllabusSubchapters) {
+      const chapter = getChapterForSubchapter(sub.code);
+      expect(chapter?.code, sub.code).toBe(sub.chapterCode);
+      expect(chapter?.subchapters).toContain(sub);
+    }
+    expect(getChapterForSubchapter('AExE0199')).toBeUndefined();
+  });
+});
+
+describe('guards', () => {
+  it('accepts all 60 official sub-chapter codes', () => {
+    for (const code of subchapterCodes) {
+      expect(isValidSubchapterCode(code), code).toBe(true);
+    }
+  });
+
+  it('rejects anything that is not an official sub-chapter code', () => {
+    for (const bad of ['', 'ACtE03', 'ACtE0307', 'ACtE0300', 'acte0301', 'AALL1007', '3.1']) {
+      expect(isValidSubchapterCode(bad), bad).toBe(false);
+    }
+  });
+
+  it('narrows chapter codes too', () => {
+    expect(isValidChapterCode('AALL10')).toBe(true);
+    expect(isValidChapterCode('AALL1001')).toBe(false);
+  });
+});
diff --git a/frontend/src/data/bookChapters.generated.ts b/frontend/src/data/bookChapters.generated.ts
index 0a24303..35f00d3 100644
--- a/frontend/src/data/bookChapters.generated.ts
+++ b/frontend/src/data/bookChapters.generated.ts
@@ -3,14 +3,14 @@
 import type { Topic } from './topics';
 
 export const bookChapters: Topic[] = [
-  { id: 'book-ch1', name: 'Chapter 1: Basic Electrical & Electronics', shortName: 'Ch1 - Basic Electrical & Electronics', description: 'Ohm\'s Law, circuit analysis, AC/DC circuits and electronic components', questionCount: 587, icon: 'chip' as Topic['icon'], color: '#f59e0b', dataFile: 'books/ch1.json' },
-  { id: 'book-ch2', name: 'Chapter 2: Digital Logic & Number Systems', shortName: 'Ch2 - Digital Logic & Number Systems', description: 'Number systems, Boolean algebra, logic gates and digital electronics', questionCount: 746, icon: 'chip' as Topic['icon'], color: '#6366f1', dataFile: 'books/ch2.json' },
-  { id: 'book-ch3', name: 'Chapter 3: C / C++ Programming', shortName: 'Ch3 - C / C++ Programming', description: 'C and C++ fundamentals, pointers, data types and OOP concepts', questionCount: 398, icon: 'code' as Topic['icon'], color: '#22c55e', dataFile: 'books/ch3.json' },
-  { id: 'book-ch4', name: 'Chapter 4: Operating Systems & DBMS', shortName: 'Ch4 - Operating Systems & DBMS', description: 'OS process management, memory, databases and algorithms', questionCount: 57, icon: 'database' as Topic['icon'], color: '#ec4899', dataFile: 'books/ch4.json' },
+  { id: 'book-ch1', name: 'Chapter 1: Basic Electrical & Electronics', shortName: 'Ch1 - Basic Electrical & Electronics', description: 'Ohm\'s Law, circuit analysis, AC/DC circuits and electronic components', questionCount: 525, icon: 'chip' as Topic['icon'], color: '#f59e0b', dataFile: 'books/ch1.json' },
+  { id: 'book-ch2', name: 'Chapter 2: Digital Logic & Number Systems', shortName: 'Ch2 - Digital Logic & Number Systems', description: 'Number systems, Boolean algebra, logic gates and digital electronics', questionCount: 332, icon: 'chip' as Topic['icon'], color: '#6366f1', dataFile: 'books/ch2.json' },
+  { id: 'book-ch3', name: 'Chapter 3: C / C++ Programming', shortName: 'Ch3 - C / C++ Programming', description: 'C and C++ fundamentals, pointers, data types and OOP concepts', questionCount: 391, icon: 'code' as Topic['icon'], color: '#22c55e', dataFile: 'books/ch3.json' },
+  { id: 'book-ch4', name: 'Chapter 4: Computer Organization & Embedded Systems', shortName: 'Ch4 - Computer Organization & Embedded', description: 'CPU architecture, cache, memory hierarchy, RISC/CISC and embedded systems', questionCount: 422, icon: 'cpu' as Topic['icon'], color: '#ec4899', dataFile: 'books/ch4.json' },
   { id: 'book-ch5', name: 'Chapter 5: Computer Networks & Security', shortName: 'Ch5 - Computer Networks & Security', description: 'Network protocols, OSI model and network security concepts', questionCount: 69, icon: 'brain' as Topic['icon'], color: '#06b6d4', dataFile: 'books/ch5.json' },
   { id: 'book-ch6', name: 'Chapter 6: Theory of Computation and Computer Graphics', shortName: 'Ch6 - Theory of Computation and Computer Graphics', description: 'Finite automata, CFGs, Turing machines, 2D/3D transformations and graphics', questionCount: 64, icon: 'network' as Topic['icon'], color: '#a855f7', dataFile: 'books/ch6.json' },
-  { id: 'book-ch7', name: 'Chapter 7: DSA, DBMS and OS', shortName: 'Ch7 - DSA, DBMS and OS', description: 'Data structures, algorithms, database systems and operating systems', questionCount: 69, icon: 'monitor' as Topic['icon'], color: '#f97316', dataFile: 'books/ch7.json' },
-  { id: 'book-ch8', name: 'Chapter 8: Software Engineering and Object-Oriented Analysis & Design', shortName: 'Ch8 - Software Engineering and Object-Oriented Analysis & Design', description: 'Software processes, testing, UML, design patterns and OOAD', questionCount: 131, icon: 'calculator' as Topic['icon'], color: '#10b981', dataFile: 'books/ch8.json' },
+  { id: 'book-ch7', name: 'Chapter 7: DSA, DBMS and OS', shortName: 'Ch7 - DSA, DBMS and OS', description: 'Data structures, algorithms, database systems and operating systems', questionCount: 68, icon: 'monitor' as Topic['icon'], color: '#f97316', dataFile: 'books/ch7.json' },
+  { id: 'book-ch8', name: 'Chapter 8: Software Engineering and Object-Oriented Analysis & Design', shortName: 'Ch8 - Software Engineering and Object-Oriented Analysis & Design', description: 'Software processes, testing, UML, design patterns and OOAD', questionCount: 130, icon: 'calculator' as Topic['icon'], color: '#10b981', dataFile: 'books/ch8.json' },
   { id: 'book-ch9', name: 'Chapter 9: AI & Machine Learning', shortName: 'Ch9 - AI & Machine Learning', description: 'Artificial intelligence, neural networks and machine learning concepts', questionCount: 71, icon: 'book' as Topic['icon'], color: '#3b82f6', dataFile: 'books/ch9.json' },
-  { id: 'book-ch10', name: 'Chapter 10: Project Planning, Design and Implementation', shortName: 'Ch10 - Project Planning, Design and Implementation', description: 'Engineering drawings, economics, project management and professional practice', questionCount: 242, icon: 'settings' as Topic['icon'], color: '#8b5cf6', dataFile: 'books/ch10.json' },
+  { id: 'book-ch10', name: 'Chapter 10: Project Planning, Design and Implementation', shortName: 'Ch10 - Project Planning, Design and Implementation', description: 'Engineering drawings, economics, project management and professional practice', questionCount: 240, icon: 'settings' as Topic['icon'], color: '#8b5cf6', dataFile: 'books/ch10.json' },
 ];
diff --git a/frontend/src/data/duplicate-triage.json b/frontend/src/data/duplicate-triage.json
new file mode 100644
index 0000000..cd05919
--- /dev/null
+++ b/frontend/src/data/duplicate-triage.json
@@ -0,0 +1,5266 @@
+{
+  "generatedFrom": "duplicate-stem triage over frontend/public/data/books/, cross-checked with scripts/validate-questions.mjs",
+  "note": "SAFE duplicate groups have already been de-duplicated in the bank: the copy in the lowest-numbered chapter was kept and the rest deleted. CONFLICT groups were left in place and every copy was added to quarantine.json with code DUPLICATE_ANSWER_CONFLICT, because at least one copy keys an answer the other copies contradict. Ids below are post-dedupe array positions and move if the bank is re-ordered. As of 2026-10-20 the suggestedResolutions above have been applied; see appliedResolutions for the audit trail and for what was deliberately not applied.",
+  "summary": {
+    "duplicateGroupsFound": 391,
+    "safeGroupsDeduplicated": 332,
+    "rowsDeleted": 489,
+    "conflictGroups": 59,
+    "conflictRowsQuarantined": 128,
+    "conflictGroupsByReason": {
+      "DIVERGENT_PROSE": 46,
+      "NUMERIC_MISMATCH": 12,
+      "INVALID_KEY": 1
+    },
+    "conflictGroupsWithIdenticalOptionSets": 22,
+    "conflictGroupsWithDifferentOptionSets": 37,
+    "rowCountsByFile": {
+      "ch1.json": {
+        "before": 587,
+        "deleted": 62,
+        "after": 525
+      },
+      "ch2.json": {
+        "before": 746,
+        "deleted": 414,
+        "after": 332
+      },
+      "ch3.json": {
+        "before": 398,
+        "deleted": 7,
+        "after": 391
+      },
+      "ch4.json": {
+        "before": 424,
+        "deleted": 2,
+        "after": 422
+      },
+      "ch5.json": {
+        "before": 69,
+        "deleted": 0,
+        "after": 69
+      },
+      "ch6.json": {
+        "before": 64,
+        "deleted": 0,
+        "after": 64
+      },
+      "ch7.json": {
+        "before": 69,
+        "deleted": 1,
+        "after": 68
+      },
+      "ch8.json": {
+        "before": 131,
+        "deleted": 1,
+        "after": 130
+      },
+      "ch9.json": {
+        "before": 71,
+        "deleted": 0,
+        "after": 71
+      },
+      "ch10.json": {
+        "before": 242,
+        "deleted": 2,
+        "after": 240
+      }
+    }
+  },
+  "suggestedResolutions": [
+    {
+      "ids": [
+        "book-ch1_198",
+        "book-ch1_255"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "What is the maximum efficiency that can be achieved in a circuit using the maximum power transfer theorem?",
+      "conflictingAnswers": [
+        "25%",
+        "50%"
+      ],
+      "recommendedAnswer": "50%",
+      "confidence": "high",
+      "reasoning": "Maximum power transfer requires R_load = R_thevenin. The two resistances then dissipate equal power, so the fraction delivered to the load is P_load / (P_load + P_source) = 50%. The copy keyed \"25%\" is wrong.",
+      "action": "Set correct_option_index/correct_option to \"50%\" on the copy that keys \"25%\", then release both from quarantine."
+    },
+    {
+      "ids": [
+        "book-ch1_206",
+        "book-ch1_256"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "What is the time constant of an R-C circuit consisting of a 1 kΩ resistor and a 100 nF capacitor?",
+      "conflictingAnswers": [
+        "1 ms",
+        "100 µs"
+      ],
+      "recommendedAnswer": "100 µs",
+      "confidence": "high",
+      "reasoning": "tau = R*C = 1e3 ohm * 100e-9 F = 1e-4 s = 100 us. \"1 ms\" is off by 10x.",
+      "action": "Re-key the \"1 ms\" copy to \"100 µs\", then release both."
+    },
+    {
+      "ids": [
+        "book-ch1_207",
+        "book-ch1_257"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "In an R-L circuit, the voltage across the Inductor lags behind the current by how many degrees?",
+      "conflictingAnswers": [
+        "0°",
+        "90°"
+      ],
+      "recommendedAnswer": "none of the options as the stem is written - fix the stem first",
+      "confidence": "high",
+      "reasoning": "For an inductor v = L di/dt, so the inductor voltage LEADS the current by 90 degrees; it does not lag it. The magnitude 90° is right but the stem states the relationship backwards, so \"lags ... by 90°\" is false and \"0°\" is false too. This is a stem defect, not a key choice.",
+      "action": "Rewrite the stem to \"...the voltage across the inductor leads the current by how many degrees?\" and key \"90°\" on both copies."
+    },
+    {
+      "ids": [
+        "book-ch1_208",
+        "book-ch1_258"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "What is the resonant frequency of an R-L-C circuit with a 100 Ω resistor, 1 mH inductor, and a 100 nF capacitor?",
+      "conflictingAnswers": [
+        "160 kHz",
+        "16 kHz"
+      ],
+      "recommendedAnswer": "16 kHz",
+      "confidence": "high",
+      "reasoning": "f0 = 1/(2*pi*sqrt(L*C)) = 1/(2*pi*sqrt(1e-3 * 100e-9)) = 1/(2*pi*1e-5) = 15 915 Hz ~= 16 kHz. R does not enter f0. \"160 kHz\" is off by 10x.",
+      "action": "Re-key the \"160 kHz\" copy to \"16 kHz\", then release both."
+    },
+    {
+      "ids": [
+        "book-ch1_212",
+        "book-ch1_260"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "What is the phase angle between the voltage and current in an R-L-C circuit at resonance?",
+      "conflictingAnswers": [
+        "45°",
+        "0°"
+      ],
+      "recommendedAnswer": "0°",
+      "confidence": "high",
+      "reasoning": "At resonance X_L = X_C, the reactive parts cancel and the impedance is purely resistive, so voltage and current are in phase: 0°. (The same physics makes a series R-L-C impedance minimum, not infinite, at resonance.)",
+      "action": "Re-key the \"45°\" copy to \"0°\", then release both."
+    },
+    {
+      "ids": [
+        "book-ch1_213",
+        "book-ch1_261"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "What is the time constant of an R-L circuit consisting of a 100 Ω resistor and a 10 mH inductor?",
+      "conflictingAnswers": [
+        "1 µs",
+        "100 µs"
+      ],
+      "recommendedAnswer": "100 µs",
+      "confidence": "high",
+      "reasoning": "tau = L/R = 10e-3 H / 100 ohm = 1e-4 s = 100 us. \"1 µs\" is off by 100x.",
+      "action": "Re-key the \"1 µs\" copy to \"100 µs\", then release both."
+    },
+    {
+      "ids": [
+        "book-ch1_215",
+        "book-ch1_263"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the resonant frequency?",
+      "conflictingAnswers": [
+        "15.92 Hz",
+        "1.59 kHz"
+      ],
+      "recommendedAnswer": "neither - the question is unanswerable as authored",
+      "confidence": "high",
+      "reasoning": "An R-C network has no resonance; it has a corner frequency. Taking the intended quantity as f = 1/(2*pi*R*C) = 1/(2*pi*1e5*1e-6) = 1.59 Hz, which is NOT among the four options (15.92 Hz / 15.92 kHz / 159.2 Hz / 1.59 kHz). One copy even carries correct_option \"1.59 Hz\" against an index pointing at \"1.59 kHz\", which confirms both the intent and the missing option.",
+      "action": "Rewrite the stem to ask for the cutoff/corner frequency, replace one option with \"1.59 Hz\" and key it - or retire the question. Do not release until an option is correct."
+    },
+    {
+      "ids": [
+        "book-ch1_221",
+        "book-ch1_266"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "What is the resonance frequency of an R-L-C circuit?",
+      "conflictingAnswers": [
+        "2pisqrt(LC)",
+        "1/(2pisqrt(LC))"
+      ],
+      "recommendedAnswer": "1/(2pisqrt(LC))",
+      "confidence": "high",
+      "reasoning": "f0 = 1/(2*pi*sqrt(L*C)). \"2pisqrt(LC)\" is the reciprocal and has units of seconds, not hertz.",
+      "action": "Re-key the \"2pisqrt(LC)\" copy to \"1/(2pisqrt(LC))\", then release both."
+    },
+    {
+      "ids": [
+        "book-ch1_236",
+        "book-ch1_274"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 5µF?",
+      "conflictingAnswers": [
+        "35.7 kHz",
+        "357 kHz"
+      ],
+      "recommendedAnswer": "neither - the stem numbers and the options disagree",
+      "confidence": "medium",
+      "reasoning": "With L = 20 mH and C = 5 uF, f0 = 1/(2*pi*sqrt(1e-7)) = 503 Hz. None of the four options (3.57 kHz / 35.7 kHz / 357 kHz / 3.57 MHz) is within three orders of magnitude of that. The option \"3.57 kHz\" is what you get for L = 20 mH with C = 0.1 uF, so the capacitance in the stem is most likely a typo for 0.1 µF (100 nF).",
+      "action": "Check the source textbook. If C is 0.1 µF, key \"3.57 kHz\" on both copies; otherwise replace the options with 503 Hz and plausible distractors. Do not release until the arithmetic closes."
+    },
+    {
+      "ids": [
+        "book-ch2_136",
+        "book-ch2_145"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "What is the difference between a binary encoder and a priority encoder?",
+      "conflictingAnswers": [
+        "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+        "A binary encoder has 2^n input lines and n output lines, while a priority encoder has n input lines and log2n output lines."
+      ],
+      "recommendedAnswer": "the \"highest priority input signal\" option",
+      "confidence": "high",
+      "reasoning": "The defining difference is behavioural: a priority encoder resolves simultaneously-asserted inputs in favour of the highest-priority one. The line-count option is not a difference at all - a priority encoder also has 2^n inputs and n outputs (n = log2 of the input count), so that option describes both devices. Both copies already list the correct option, one of them as opt1.",
+      "action": "Re-key the second copy to its opt1, then release both."
+    },
+    {
+      "ids": [
+        "book-ch2_189",
+        "book-ch2_193"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "What is the range of unsigned 8-bit binary numbers?",
+      "conflictingAnswers": [
+        "0 to 255",
+        "0 to 256"
+      ],
+      "recommendedAnswer": "0 to 255",
+      "confidence": "high",
+      "reasoning": "8 bits encode 2^8 = 256 distinct values starting at 0, so the range is 0..255. One copy keys \"0 to 256\", which is wrong - and that copy has no correct option at all (its own correct_option field says \"0 to 255\", which is absent from its option list). It is already quarantined for KEY_CONFLICT independently.",
+      "action": "On the bad copy replace the option \"0 to 256\" with \"0 to 255\" and key it, or retire that copy as a straight duplicate. The good copy can be released now."
+    },
+    {
+      "ids": [
+        "book-ch2_116",
+        "book-ch2_125"
+      ],
+      "reason": "INVALID_KEY",
+      "stem": "Which of the following is not a valid combination of input variables in a Karnaugh map for a two-variable expression?",
+      "conflictingAnswers": [
+        "(index 5 of 4 options - unanswerable)",
+        "(index 5 of 4 options - unanswerable)"
+      ],
+      "recommendedAnswer": "neither - the intended option is missing from the bank",
+      "confidence": "high",
+      "reasoning": "Both copies set correct_option_index to 5 with only four options present. The four options 00/01/10/11 are all valid two-variable combinations, so as authored there is no correct answer. Both copies carry correct_option \"21\", which is indeed not a valid binary combination - the intended fifth option was dropped when the row was flattened to four columns.",
+      "action": "Replace one option with \"21\" and set correct_option_index accordingly, or retire the question. Do not release until the index is in range."
+    },
+    {
+      "ids": [
+        "book-ch3_358",
+        "book-ch3_362",
+        "book-ch3_364",
+        "book-ch3_368"
+      ],
+      "reason": "NUMERIC_MISMATCH",
+      "stem": "Which of the following statements is true about static data members in C++?",
+      "conflictingAnswers": [
+        "They are initialized to 0 by default",
+        "They can be initialized only outside the class definition",
+        "All of the above are true",
+        "They are initialized to zero by default"
+      ],
+      "recommendedAnswer": "no re-key needed - this is a stem collision, not an answer conflict",
+      "confidence": "high",
+      "reasoning": "All four copies carry DIFFERENT option sets and each keyed answer is correct for its own set: static data members have static storage duration and are zero-initialised; a non-inline, non-const static data member must be defined outside the class (pre-C++17); and the access-flavoured copy keys \"All of the above are true\" over three statements that are all true. The stem is simply too generic to distinguish four separate questions, which is why the duplicate detector grouped them.",
+      "action": "Disambiguate the four stems (e.g. \"...about the initialization of static data members\", \"...about accessing static data members\") and release all four. No answer key is wrong here."
+    }
+  ],
+  "conflictGroups": [
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is the purpose of delta-star conversion?",
+      "copies": [
+        {
+          "id": "book-ch1_50",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "To regulate the voltage levels of a three-phase supply",
+          "correctOptionText": "To regulate the voltage levels of a three-phase supply",
+          "options": [
+            "To reduce the starting current of a motor",
+            "To increase the starting current of a motor",
+            "To regulate the voltage levels of a three-phase supply",
+            "None of above"
+          ]
+        },
+        {
+          "id": "book-ch1_58",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "To regulate the voltage levels of a power distribution system",
+          "correctOptionText": "To regulate the voltage levels of a power distribution system",
+          "options": [
+            "To convert a three-phase system from a star to a delta configuration",
+            "To reduce the starting current of a motor",
+            "To regulate the voltage levels of a power distribution system",
+            "None of above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is the superposition theorem based on?",
+      "copies": [
+        {
+          "id": "book-ch1_140",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "The principle of superposition",
+          "correctOptionText": "The principle of superposition",
+          "options": [
+            "Ohm's law",
+            "Faraday's law",
+            "Kirchhoff's laws",
+            "The principle of superposition"
+          ]
+        },
+        {
+          "id": "book-ch1_143",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "Ohm's law",
+          "correctOptionText": "Ohm's law",
+          "options": [
+            "Kirchhoff's current law",
+            "Kirchhoff's voltage law",
+            "Ohm's law",
+            "Faraday's law"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is the equivalent resistance seen from the output terminals in Norton's theorem?",
+      "copies": [
+        {
+          "id": "book-ch1_173",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "The resistance of the circuit with all voltage sources replaced by their internal resistances.",
+          "correctOptionText": "The resistance of the circuit with all voltage sources replaced by their internal resistances.",
+          "options": [
+            "The resistance of the load resistor.",
+            "The resistance of the circuit with all voltage sources replaced by their internal resistances.",
+            "The resistance of the circuit with all current sources replaced by their internal resistances.",
+            "None of above"
+          ]
+        },
+        {
+          "id": "book-ch1_183",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "The resistance seen from the output terminals with all voltage sources replaced by their internal resistances",
+          "correctOptionText": "The resistance seen from the output terminals with all voltage sources replaced by their internal resistances",
+          "options": [
+            "The total resistance of the circuit",
+            "The resistance of the load resistor",
+            "The resistance of the voltage source",
+            "The resistance seen from the output terminals with all voltage sources replaced by their internal resistances"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": true,
+      "stem": "What is the maximum efficiency that can be achieved in a circuit using the maximum power transfer theorem?",
+      "copies": [
+        {
+          "id": "book-ch1_198",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "25%",
+          "correctOptionText": "25%",
+          "options": [
+            "100%",
+            "50%",
+            "25%",
+            "It depends on the circuit."
+          ]
+        },
+        {
+          "id": "book-ch1_255",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "50%",
+          "correctOptionText": "50%",
+          "options": [
+            "100%",
+            "50%",
+            "25%",
+            "It depends on the circuit."
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": true,
+      "stem": "What is the time constant of an R-C circuit consisting of a 1 kΩ resistor and a 100 nF capacitor?",
+      "copies": [
+        {
+          "id": "book-ch1_206",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "1 ms",
+          "correctOptionText": "1 ms",
+          "options": [
+            "1 ms",
+            "100 µs",
+            "10 µs",
+            "10 ms"
+          ]
+        },
+        {
+          "id": "book-ch1_256",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "100 µs",
+          "correctOptionText": "100 µs",
+          "options": [
+            "1 ms",
+            "100 µs",
+            "10 µs",
+            "10 ms"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": true,
+      "stem": "In an R-L circuit, the voltage across the Inductor lags behind the current by how many degrees?",
+      "copies": [
+        {
+          "id": "book-ch1_207",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "0°",
+          "correctOptionText": "0°",
+          "options": [
+            "0°",
+            "45°",
+            "90°",
+            "180°"
+          ]
+        },
+        {
+          "id": "book-ch1_257",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "90°",
+          "correctOptionText": "90°",
+          "options": [
+            "0°",
+            "45°",
+            "90°",
+            "180°"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": true,
+      "stem": "What is the resonant frequency of an R-L-C circuit with a 100 Ω resistor, 1 mH inductor, and a 100 nF capacitor?",
+      "copies": [
+        {
+          "id": "book-ch1_208",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "160 kHz",
+          "correctOptionText": "160 kHz",
+          "options": [
+            "160 kHz",
+            "16 kHz",
+            "1.6 kHz",
+            "1.6 MHz"
+          ]
+        },
+        {
+          "id": "book-ch1_258",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "16 kHz",
+          "correctOptionText": "16 kHz",
+          "options": [
+            "160 kHz",
+            "16 kHz",
+            "1.6 kHz",
+            "1.6 MHz"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "In an R-L-C circuit, what happens to the Impedance at resonance?",
+      "copies": [
+        {
+          "id": "book-ch1_209",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "It is infinite",
+          "correctOptionText": "It is infinite",
+          "options": [
+            "It is zero",
+            "It is at a minimum",
+            "It is at a maximum",
+            "It is infinite"
+          ]
+        },
+        {
+          "id": "book-ch1_259",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "It is at a minimum",
+          "correctOptionText": "It is at a minimum",
+          "options": [
+            "It is zero",
+            "It is at a minimum",
+            "It is at a maximum",
+            "It is infinite"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": true,
+      "stem": "What is the phase angle between the voltage and current in an R-L-C circuit at resonance?",
+      "copies": [
+        {
+          "id": "book-ch1_212",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "45°",
+          "correctOptionText": "45°",
+          "options": [
+            "0°",
+            "45°",
+            "90°",
+            "180°"
+          ]
+        },
+        {
+          "id": "book-ch1_260",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "0°",
+          "correctOptionText": "0°",
+          "options": [
+            "0°",
+            "45°",
+            "90°",
+            "180°"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": true,
+      "stem": "What is the time constant of an R-L circuit consisting of a 100 Ω resistor and a 10 mH inductor?",
+      "copies": [
+        {
+          "id": "book-ch1_213",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "1 µs",
+          "correctOptionText": "1 µs",
+          "options": [
+            "100 µs",
+            "1 µs",
+            "10 µs",
+            "1 ms"
+          ]
+        },
+        {
+          "id": "book-ch1_261",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "100 µs",
+          "correctOptionText": "100 µs",
+          "options": [
+            "100 µs",
+            "1 µs",
+            "10 µs",
+            "1 ms"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "In an R-L-C circuit, what happens to the bandwidth as the quality factor increases?",
+      "copies": [
+        {
+          "id": "book-ch1_214",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "It increases",
+          "correctOptionText": "It increases",
+          "options": [
+            "It increases",
+            "It decreases",
+            "It remains constant",
+            "It oscillates"
+          ]
+        },
+        {
+          "id": "book-ch1_262",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "It decreases",
+          "correctOptionText": "It decreases",
+          "options": [
+            "It increases",
+            "It decreases",
+            "It remains constant",
+            "It oscillates"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": true,
+      "stem": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the resonant frequency?",
+      "copies": [
+        {
+          "id": "book-ch1_215",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "15.92 Hz",
+          "correctOptionText": "15.92 Hz",
+          "options": [
+            "15.92 Hz",
+            "15.92 kHz",
+            "159.2 Hz",
+            "1.59 kHz"
+          ]
+        },
+        {
+          "id": "book-ch1_263",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "1.59 kHz",
+          "correctOptionText": "1.59 Hz",
+          "options": [
+            "15.92 Hz",
+            "15.92 kHz",
+            "159.2 Hz",
+            "1.59 kHz"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "What is the time constant of an R-C circuit?",
+      "copies": [
+        {
+          "id": "book-ch1_217",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "R/C",
+          "correctOptionText": "R/C",
+          "options": [
+            "R/C",
+            "CR",
+            "RC",
+            "1/RC"
+          ]
+        },
+        {
+          "id": "book-ch1_264",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "RC",
+          "correctOptionText": "RC",
+          "options": [
+            "R/C",
+            "CR",
+            "RC",
+            "1/RC"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "What is the voltage across an inductor in an R-L circuit at steady state?",
+      "copies": [
+        {
+          "id": "book-ch1_218",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "Infinite",
+          "correctOptionText": "Infinite",
+          "options": [
+            "Zero",
+            "Infinite",
+            "The same as the voltage across the resistor",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch1_265",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "Zero",
+          "correctOptionText": "Zero",
+          "options": [
+            "Zero",
+            "Infinite",
+            "The same as the voltage across the resistor",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": true,
+      "stem": "What is the resonance frequency of an R-L-C circuit?",
+      "copies": [
+        {
+          "id": "book-ch1_221",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "2pisqrt(LC)",
+          "correctOptionText": "2pisqrt(LC)",
+          "options": [
+            "1/(2pisqrt(LC))",
+            "2pisqrt(LC)",
+            "1/(L*C)",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch1_266",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "1/(2pisqrt(LC))",
+          "correctOptionText": "1/(2pisqrt(LC))",
+          "options": [
+            "1/(2pisqrt(LC))",
+            "2pisqrt(LC)",
+            "1/(L*C)",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "What happens to the impedance of an R-L-C circuit at resonance?",
+      "copies": [
+        {
+          "id": "book-ch1_222",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "The impedance is maximum",
+          "correctOptionText": "The impedance is maximum",
+          "options": [
+            "The impedance is maximum",
+            "The impedance is minimum",
+            "The impedance is zero",
+            "The impedance remains the same"
+          ]
+        },
+        {
+          "id": "book-ch1_267",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "The impedance is minimum",
+          "correctOptionText": "The impedance is minimum",
+          "options": [
+            "The impedance is maximum",
+            "The impedance is minimum",
+            "The impedance is zero",
+            "The impedance remains the same"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "What happens to the Impedance of an AC series resonant circuit at resonance?",
+      "copies": [
+        {
+          "id": "book-ch1_226",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "It is maximum",
+          "correctOptionText": "It is maximum",
+          "options": [
+            "It is minimum",
+            "It is maximum",
+            "It is zero",
+            "It is infinity"
+          ]
+        },
+        {
+          "id": "book-ch1_268",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "It is minimum",
+          "correctOptionText": "It is minimum",
+          "options": [
+            "It is minimum",
+            "It is maximum",
+            "It is zero",
+            "It is infinity"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "What happens to the current in an AC parallel resonant circuit at resonance?",
+      "copies": [
+        {
+          "id": "book-ch1_227",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "It is maximum",
+          "correctOptionText": "It is maximum",
+          "options": [
+            "It is minimum",
+            "It is maximum",
+            "It is zero",
+            "It is infinity"
+          ]
+        },
+        {
+          "id": "book-ch1_269",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "It is minimum",
+          "correctOptionText": "It is minimum",
+          "options": [
+            "It is minimum",
+            "It is maximum",
+            "It is zero",
+            "It is infinity"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "What is the power factor of an AC series resonant circuit at resonance?",
+      "copies": [
+        {
+          "id": "book-ch1_228",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "Zero",
+          "correctOptionText": "Zero",
+          "options": [
+            "Unity",
+            "Zero",
+            "Negative",
+            "Indeterminate"
+          ]
+        },
+        {
+          "id": "book-ch1_270",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "Unity",
+          "correctOptionText": "Unity",
+          "options": [
+            "Unity",
+            "Zero",
+            "Negative",
+            "Indeterminate"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "What is the power factor of an AC parallel resonant circuit at resonance?",
+      "copies": [
+        {
+          "id": "book-ch1_229",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "Zero",
+          "correctOptionText": "Zero",
+          "options": [
+            "Unity",
+            "Zero",
+            "Negative",
+            "Indeterminate"
+          ]
+        },
+        {
+          "id": "book-ch1_271",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "Unity",
+          "correctOptionText": "Unity",
+          "options": [
+            "Unity",
+            "Zero",
+            "Negative",
+            "Indeterminate"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "What happens to the voltage across the capacitor in an AC series resonant circuit at resonance?",
+      "copies": [
+        {
+          "id": "book-ch1_232",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "It is minimum",
+          "correctOptionText": "It is minimum",
+          "options": [
+            "It is maximum",
+            "It is minimum",
+            "It is zero",
+            "It is infinity"
+          ]
+        },
+        {
+          "id": "book-ch1_272",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "It is maximum",
+          "correctOptionText": "It is maximum",
+          "options": [
+            "It is maximum",
+            "It is minimum",
+            "It is zero",
+            "It is infinity"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "In an AC parallel resonant circuit, at the resonant frequency, what is the impedance?",
+      "copies": [
+        {
+          "id": "book-ch1_235",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "Minimum",
+          "correctOptionText": "Minimum",
+          "options": [
+            "Zero",
+            "Infinite",
+            "Minimum",
+            "Maximum"
+          ]
+        },
+        {
+          "id": "book-ch1_273",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Maximum",
+          "correctOptionText": "Maximum",
+          "options": [
+            "Zero",
+            "Infinite",
+            "Minimum",
+            "Maximum"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": true,
+      "stem": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 5µF?",
+      "copies": [
+        {
+          "id": "book-ch1_236",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "35.7 kHz",
+          "correctOptionText": "35.7 kHz",
+          "options": [
+            "3.57 kHz",
+            "35.7 kHz",
+            "357 kHz",
+            "3.57 MHz"
+          ]
+        },
+        {
+          "id": "book-ch1_274",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "357 kHz",
+          "correctOptionText": "357 kHz",
+          "options": [
+            "3.57 kHz",
+            "35.7 kHz",
+            "357 kHz",
+            "3.57 MHz"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": true,
+      "stem": "What is the relationship between active power and reactive power?",
+      "copies": [
+        {
+          "id": "book-ch1_246",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "They are the same thing",
+          "correctOptionText": "They are the same thing",
+          "options": [
+            "They are the same thing",
+            "Reactive power is always greater than active power",
+            "Active power is always greater than reactive power",
+            "They are two different types of power"
+          ]
+        },
+        {
+          "id": "book-ch1_275",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "They are two different types of power",
+          "correctOptionText": "They are two different types of power",
+          "options": [
+            "They are the same thing",
+            "Reactive power is always greater than active power",
+            "Active power is always greater than reactive power",
+            "They are two different types of power"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is the frequency of a triangle wave generator determined by?",
+      "copies": [
+        {
+          "id": "book-ch1_337",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "The time constant of the RC circuit",
+          "correctOptionText": "The time constant of the RC circuit",
+          "options": [
+            "The time constant of the RC circuit",
+            "The resonant frequency of the tank circuit",
+            "The frequency of the crystal",
+            "The input voltage of the oscillator"
+          ]
+        },
+        {
+          "id": "book-ch1_347",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "The slope of the waveform",
+          "correctOptionText": "The slope of the waveform",
+          "options": [
+            "The time period of the waveform",
+            "The amplitude of the waveform",
+            "The duty cycle of the waveform",
+            "The slope of the waveform"
+          ]
+        },
+        {
+          "id": "book-ch2_123",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "The time constant of the RC circuit",
+          "correctOptionText": "The time constant of the RC circuit",
+          "options": [
+            "The time constant of the RC circuit",
+            "The resonant frequency of the tank circuit",
+            "The frequency of the crystal",
+            "The input voltage of the oscillator"
+          ]
+        },
+        {
+          "id": "book-ch2_124",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "The slope of the waveform",
+          "correctOptionText": "The slope of the waveform",
+          "options": [
+            "The time period of the waveform",
+            "The amplitude of the waveform",
+            "The duty cycle of the waveform",
+            "The slope of the waveform"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "INVALID_KEY",
+      "optionSetsIdentical": true,
+      "stem": "Which of the following is not a valid combination of input variables in a Karnaugh map for a two-variable expression?",
+      "copies": [
+        {
+          "id": "book-ch2_116",
+          "correctOptionIndex": 5,
+          "keyedAnswer": null,
+          "correctOptionText": "21",
+          "options": [
+            "00",
+            "01",
+            "10",
+            "11"
+          ]
+        },
+        {
+          "id": "book-ch2_125",
+          "correctOptionIndex": 5,
+          "keyedAnswer": null,
+          "correctOptionText": "21",
+          "options": [
+            "00",
+            "01",
+            "10",
+            "11"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": false,
+      "stem": "What is the difference between a binary encoder and a priority encoder?",
+      "copies": [
+        {
+          "id": "book-ch2_136",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+          "correctOptionText": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+          "options": [
+            "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+            "A binary encoder generates a binary code corresponding to the highest priority input signal, while a priority encoder converts a binary input signal into an n-bit coded output signal.",
+            "A binary encoder and a priority encoder are the same thing.",
+            "A binary encoder and a priority encoder have no difference."
+          ]
+        },
+        {
+          "id": "book-ch2_145",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "A binary encoder has 2^n input lines and n output lines, while a priority encoder has n input lines and log2n output lines.",
+          "correctOptionText": "A binary encoder has 2^n input lines and n output lines, while a priority encoder has n input lines and log2n output lines.",
+          "options": [
+            "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+            "A binary encoder generates a binary code corresponding to the highest priority input signal, while a priority encoder converts a binary input signal into an n-bit coded output signal.",
+            "A binary encoder converts a decimal input signal into a 4-bit BCD output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+            "A binary encoder has 2^n input lines and n output lines, while a priority encoder has n input lines and log2n output lines."
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": false,
+      "stem": "What is the range of unsigned 8-bit binary numbers?",
+      "copies": [
+        {
+          "id": "book-ch2_189",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "0 to 255",
+          "correctOptionText": "0 to 255",
+          "options": [
+            "0 to 127",
+            "-128 to 127",
+            "-127 to 127",
+            "0 to 255"
+          ]
+        },
+        {
+          "id": "book-ch2_193",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "0 to 256",
+          "correctOptionText": "0 to 255",
+          "options": [
+            "-128 to 127",
+            "0 to 256",
+            "0 to 127",
+            "0 to 128"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following is not a feature of a microprocessor?",
+      "copies": [
+        {
+          "id": "book-ch2_240",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Secondary storage",
+          "correctOptionText": "Secondary storage",
+          "options": [
+            "Interrupt handling capability",
+            "Pipelining",
+            "Cache memory",
+            "Secondary storage"
+          ]
+        },
+        {
+          "id": "book-ch2_253",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Multiuser",
+          "correctOptionText": "Multiuser",
+          "options": [
+            "Multitasking",
+            "Multiprocessing",
+            "Multithreading",
+            "Multiuser"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following statements is true about nested interrupts?",
+      "copies": [
+        {
+          "id": "book-ch2_303",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "They occur when an ISR triggers another interrupt",
+          "correctOptionText": "They occur when an ISR triggers another interrupt",
+          "options": [
+            "They are not allowed in most microprocessors",
+            "They occur when an ISR triggers another interrupt",
+            "They occur when multiple interrupts are triggered simultaneously",
+            "They occur when an ISR takes too long to execute"
+          ]
+        },
+        {
+          "id": "book-ch2_325",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "They occur when an ISR is triggered while another ISR is being serviced",
+          "correctOptionText": "They occur when an ISR is triggered while another ISR is being serviced",
+          "options": [
+            "They occur when an ISR is triggered while another ISR is being serviced",
+            "They occur when two ISRs are triggered simultaneously",
+            "They occur when an ISR takes longer than expected to execute",
+            "They never occur in a microprocessor"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is interrupt processing in a microprocessor?",
+      "copies": [
+        {
+          "id": "book-ch2_305",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "The process of handling an interrupt request from an external device",
+          "correctOptionText": "The process of handling an interrupt request from an external device",
+          "options": [
+            "The process of interrupting a running program",
+            "The process of handling an interrupt request from an external device",
+            "The process of prioritizing interrupts",
+            "The process of executing the interrupt service routine"
+          ]
+        },
+        {
+          "id": "book-ch2_312",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "The process of handling interrupts",
+          "correctOptionText": "The process of handling interrupts",
+          "options": [
+            "The process of generating interrupts",
+            "The process of handling interrupts",
+            "The process of disabling interrupts",
+            "The process of prioritizing interrupts"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following statements is true about interrupt latency?",
+      "copies": [
+        {
+          "id": "book-ch2_315",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "It is the time between the occurrence of an interrupt and the start of the ISR",
+          "correctOptionText": "It is the time between the occurrence of an interrupt and the start of the ISR",
+          "options": [
+            "It is the time between the occurrence of an interrupt and the start of the ISR",
+            "It is the time between the start of the ISR and the end of the ISR",
+            "It is the time between the end of the ISR and the resumption of the interrupted program",
+            "It is the time between the occurrence of an interrupt and the resumption of the interrupted program"
+          ]
+        },
+        {
+          "id": "book-ch2_324",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "It refers to the time required for an interrupt to be detected and an ISR to be initiated",
+          "correctOptionText": "It refers to the time required for an interrupt to be detected and an ISR to be initiated",
+          "options": [
+            "It refers to the time required for an ISR to execute",
+            "It refers to the time required for an interrupt to be detected and an ISR to be initiated",
+            "It refers to the time required for the interrupted program to resume after an ISR is finished",
+            "It refers to the time required for the microprocessor to switch between different ISRs"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following statements is true about edge-triggered interrupts?",
+      "copies": [
+        {
+          "id": "book-ch2_320",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "They are triggered by the rising or falling edge of a signal",
+          "correctOptionText": "They are triggered by the rising or falling edge of a signal",
+          "options": [
+            "They are triggered by the presence of a signal for a specified period of time",
+            "They are triggered by the rising or falling edge of a signal",
+            "They are triggered by the amplitude of a signal",
+            "They are triggered by the frequency of a signal"
+          ]
+        },
+        {
+          "id": "book-ch2_330",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "They are triggered by a change in the interrupt request signal",
+          "correctOptionText": "They are triggered by a change in the interrupt request signal",
+          "options": [
+            "They are triggered by a change in the interrupt request signal",
+            "They are triggered by the level of the interrupt request signal",
+            "They are not used in microprocessors",
+            "They are always maskable interrupts"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is the difference between a one-dimensional array and a two-dimensional array in C?",
+      "copies": [
+        {
+          "id": "book-ch3_59",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "A one-dimensional array has one row and multiple columns, whereas a two-dimensional array has multiple rows and multiple columns.",
+          "correctOptionText": "A one-dimensional array has one row and multiple columns, whereas a two-dimensional array has multiple rows and multiple columns.",
+          "options": [
+            "A one-dimensional array has one row and multiple columns, whereas a two-dimensional array has multiple rows and multiple columns.",
+            "A one-dimensional array has multiple rows and multiple columns, whereas a two-dimensional array has one row and multiple columns.",
+            "A one-dimensional array has multiple rows and one column, whereas a two-dimensional array has one row and one column.",
+            "A one-dimensional array has one row and one column, whereas a two-dimensional array has multiple rows and multiple columns."
+          ]
+        },
+        {
+          "id": "book-ch3_69",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "A two-dimensional array has more dimensions than a one-dimensional array",
+          "correctOptionText": "A two-dimensional array has more dimensions than a one-dimensional array",
+          "options": [
+            "A two-dimensional array has more dimensions than a one-dimensional array",
+            "A one-dimensional array has more dimensions than a two-dimensional array",
+            "There is no difference between a one-dimensional array and a two-dimensional array",
+            "A two-dimensional array can store more values than a one-dimensional array"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is a namespace in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_190",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "It is a mechanism for managing the scope of identifiers in large programs",
+          "correctOptionText": "It is a mechanism for managing the scope of identifiers in large programs",
+          "options": [
+            "It is a block of code that is used to group related variables and functions",
+            "It is a feature that allows a class to inherit from multiple base classes",
+            "It is a mechanism for managing the scope of identifiers in large programs",
+            "It is a type of loop in C++"
+          ]
+        },
+        {
+          "id": "book-ch3_200",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "A container that holds a group of related variables and functions",
+          "correctOptionText": "A container that holds a group of related variables and functions",
+          "options": [
+            "A container that holds a group of related variables and functions",
+            "A type of loop that iterates over a collection of elements",
+            "A method of creating a new object from an existing object",
+            "A way to specify the data type of a variable"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following statements is true regarding namespaces in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_192",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "You can have multiple namespaces with the same name in the same program",
+          "correctOptionText": "You can have multiple namespaces with the same name in the same program",
+          "options": [
+            "You can have multiple namespaces with the same name in the same program",
+            "Namespaces can only contain function declarations",
+            "You can define a namespace within a function",
+            "The contents of a namespace can be accessed using the dot operator"
+          ]
+        },
+        {
+          "id": "book-ch3_201",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Namespace members are accessed using the :: operator",
+          "correctOptionText": "Namespace members are accessed using the :: operator",
+          "options": [
+            "Nested namespaces are not allowed",
+            "A namespace can only contain functions",
+            "Namespaces are only used in object-oriented programming",
+            "Namespace members are accessed using the :: operator"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is the purpose of the \"this\" pointer in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_319",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "It points to the object on which the member function is called",
+          "correctOptionText": "It points to the object on which the member function is called",
+          "options": [
+            "It points to the object on which the member function is called",
+            "It points to the class definition",
+            "It points to the current function",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_338",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "To refer to the object's own data members",
+          "correctOptionText": "To refer to the object's own data members",
+          "options": [
+            "To refer to the object's own data members",
+            "To refer to a different object's data members",
+            "To refer to a different function",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is a static data member in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_356",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "A data member that is shared among all instances of a class",
+          "correctOptionText": "A data member that is shared among all instances of a class",
+          "options": [
+            "A data member that is unique to each instance of a class",
+            "A data member that is shared among all instances of a class",
+            "A data member that can be accessed only by static functions",
+            "A data member that cannot be accessed from outside the class"
+          ]
+        },
+        {
+          "id": "book-ch3_366",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "A data member that belongs to the class and not to any instance of the class",
+          "correctOptionText": "A data member that belongs to the class and not to any instance of the class",
+          "options": [
+            "A data member that can be accessed only by static functions",
+            "A data member that belongs to the class and not to any instance of the class",
+            "A data member that is created dynamically at runtime",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "How is a static data member declared in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_357",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "Using the keyword static before the data type",
+          "correctOptionText": "Using the keyword static before the data type",
+          "options": [
+            "Using the keyword static before the data type",
+            "Using the keyword static before the class name",
+            "Using the keyword static after the data type",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_367",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "With the keyword 'static' and the data type of the member",
+          "correctOptionText": "With the keyword 'static' and the data type of the member",
+          "options": [
+            "With the keyword 'static' and the name of the member",
+            "With the keyword 'static' and the data type of the member",
+            "With the keyword 'static' and the access specifier of the member",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "NUMERIC_MISMATCH",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following statements is true about static data members in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_358",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "They are initialized to 0 by default",
+          "correctOptionText": "They are initialized to 0 by default",
+          "options": [
+            "They are not initialized by default",
+            "They are initialized to 0 by default",
+            "They are initialized to 1 by default",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_362",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "They can be initialized only outside the class definition",
+          "correctOptionText": "They can be initialized only outside the class definition",
+          "options": [
+            "They can be initialized inside the class definition",
+            "They must be initialized inside the class definition",
+            "They can be initialized only outside the class definition",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_364",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "All of the above are true",
+          "correctOptionText": "All of the above are true",
+          "options": [
+            "They can be accessed using the object of the class",
+            "They can be accessed using the class name and the scope resolution operator",
+            "They can be accessed using the pointer to the object of the class",
+            "All of the above are true"
+          ]
+        },
+        {
+          "id": "book-ch3_368",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "They are initialized to zero by default",
+          "correctOptionText": "They are initialized to zero by default",
+          "options": [
+            "They are initialized to zero by default",
+            "They cannot be initialized inside the class declaration",
+            "They are initialized to their default values by default",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "How is a static function declared in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_359",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "Using the keyword static before the return type",
+          "correctOptionText": "Using the keyword static before the return type",
+          "options": [
+            "Using the keyword static before the return type",
+            "Using the keyword static before the function name",
+            "Using the keyword static after the return type",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_370",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "With the keyword 'static' and the return type of the function",
+          "correctOptionText": "With the keyword 'static' and the return type of the function",
+          "options": [
+            "With the keyword 'static' and the return type of the function",
+            "With the keyword 'static' and the access specifier of the function",
+            "With the keyword 'static' and the name of the function",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following statements is true about static functions in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_360",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "They can access only static data members of the class",
+          "correctOptionText": "They can access only static data members of the class",
+          "options": [
+            "They can access only static data members of the class",
+            "They can access only non-static data members of the class",
+            "They cannot access any data members of the class",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_363",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "They cannot access non-static data members",
+          "correctOptionText": "They cannot access non-static data members",
+          "options": [
+            "They cannot access non-static data members",
+            "They can access non-static data members",
+            "They can be virtual",
+            "They can be called using an instance of the class"
+          ]
+        },
+        {
+          "id": "book-ch3_371",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "They cannot be virtual",
+          "correctOptionText": "They cannot be virtual",
+          "options": [
+            "They can be virtual",
+            "They cannot be virtual",
+            "They can be pure virtual",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is a constant member function in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_375",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "A member function that cannot modify any data members of the class",
+          "correctOptionText": "A member function that cannot modify any data members of the class",
+          "options": [
+            "A member function that cannot modify any data members of the class",
+            "A member function that can modify any data members of the class",
+            "A member function that cannot be called by const objects of the class",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_383",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "A member function that cannot be modified",
+          "correctOptionText": "A member function that cannot be modified",
+          "options": [
+            "A member function that cannot be modified",
+            "A member function that can be called on a constant object only",
+            "A member function that does not have any return type",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following statements is true about constant objects in C++?",
+      "copies": [
+        {
+          "id": "book-ch3_379",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "They cannot modify any data members of the class",
+          "correctOptionText": "They cannot modify any data members of the class",
+          "options": [
+            "They cannot modify any data members of the class",
+            "They can modify only constant data members of the class",
+            "They can modify any data members of the class",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_384",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "They cannot modify the data members of the class",
+          "correctOptionText": "They cannot modify the data members of the class",
+          "options": [
+            "They cannot modify the data members of the class",
+            "They can modify the data members of the class",
+            "They can modify the data members of the class only if they are declared mutable",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_386",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "They can be created using the const keyword before the object name",
+          "correctOptionText": "They can be created using the const keyword before the object name",
+          "options": [
+            "They can be created using the const keyword before the class name",
+            "They can be created using the const keyword after the object name",
+            "They can be created using the const keyword before the object name",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_387",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "They cannot call non-constant member functions of the class",
+          "correctOptionText": "They cannot call non-constant member functions of the class",
+          "options": [
+            "They can call non-constant member functions of the class",
+            "They cannot call non-constant member functions of the class",
+            "They can call non-constant member functions of the class only if the functions are declared const",
+            "None of the above"
+          ]
+        },
+        {
+          "id": "book-ch3_388",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "They can access only constant member functions of the class",
+          "correctOptionText": "They can access only constant member functions of the class",
+          "options": [
+            "They can access only constant member functions of the class",
+            "They can access only non-constant member functions of the class",
+            "They can access both constant and non-constant member functions of the class",
+            "None of the above"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "The Least Recently Used (LRU) algorithm is used for:",
+      "copies": [
+        {
+          "id": "book-ch4_14",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "Cache replacement",
+          "correctOptionText": "Cache replacement",
+          "options": [
+            "CPU scheduling",
+            "Memory allocation",
+            "Cache replacement",
+            "Disk scheduling"
+          ]
+        },
+        {
+          "id": "book-ch7_50",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "Page replacement",
+          "correctOptionText": "Page replacement",
+          "options": [
+            "CPU scheduling",
+            "Memory allocation",
+            "Page replacement",
+            "Disk scheduling"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is the difference between volatile and non-volatile memory?",
+      "copies": [
+        {
+          "id": "book-ch4_62",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "Volatile memory loses its contents when power is lost, while non-volatile memory retains its contents",
+          "correctOptionText": "Volatile memory loses its contents when power is lost, while non-volatile memory retains its contents",
+          "options": [
+            "Volatile memory loses its contents when power is lost, while non-volatile memory retains its contents",
+            "Volatile memory is slower than non-volatile memory",
+            "Volatile memory is used for long-term storage, while non-volatile memory is used for temporary storage",
+            "Volatile memory is more expensive than non-volatile memory"
+          ]
+        },
+        {
+          "id": "book-ch4_202",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "Volatile memory requires power to retain its data, while non-volatile memory retains data even without power",
+          "correctOptionText": "Volatile memory requires power to retain its data, while non-volatile memory retains data even without power",
+          "options": [
+            "Volatile memory can only be read from, while non-volatile memory can be both read and written to",
+            "Volatile memory requires power to retain its data, while non-volatile memory retains data even without power",
+            "Volatile memory is faster than non-volatile memory",
+            "Non-volatile memory has a higher storage capacity than volatile memory"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following is not an arithmetic operation performed by the ALU?",
+      "copies": [
+        {
+          "id": "book-ch4_130",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "Shift left",
+          "correctOptionText": "Shift left",
+          "options": [
+            "Increment",
+            "Decrement",
+            "Shift left",
+            "Addition"
+          ]
+        },
+        {
+          "id": "book-ch4_136",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Comparison",
+          "correctOptionText": "Comparison",
+          "options": [
+            "Addition",
+            "Subtraction",
+            "Multiplication",
+            "Comparison"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following is not a characteristic of a multiprocessor system?",
+      "copies": [
+        {
+          "id": "book-ch4_280",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Sequential execution",
+          "correctOptionText": "Sequential execution",
+          "options": [
+            "Parallelism",
+            "Scalability",
+            "Fault tolerance",
+            "Sequential execution"
+          ]
+        },
+        {
+          "id": "book-ch4_288",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Single processing unit",
+          "correctOptionText": "Single processing unit",
+          "options": [
+            "Parallelism",
+            "Scalability",
+            "Fault tolerance",
+            "Single processing unit"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is parallelism in a multiprocessor system?",
+      "copies": [
+        {
+          "id": "book-ch4_281",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "The ability of multiple processors to execute instructions simultaneously",
+          "correctOptionText": "The ability of multiple processors to execute instructions simultaneously",
+          "options": [
+            "The ability of multiple processors to execute instructions simultaneously",
+            "The ability of a single processor to execute multiple threads of execution simultaneously",
+            "The ability of multiple input/output devices to communicate with each other simultaneously",
+            "The ability of a single input/output device to handle multiple input/output operations simultaneously"
+          ]
+        },
+        {
+          "id": "book-ch4_289",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "The ability to use multiple processors to complete a single task",
+          "correctOptionText": "The ability to use multiple processors to complete a single task",
+          "options": [
+            "The ability to run multiple tasks simultaneously",
+            "The ability to share resources between processors",
+            "The ability to use multiple processors to complete a single task",
+            "The ability to increase the clock speed of a processor"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is scalability in a multiprocessor system?",
+      "copies": [
+        {
+          "id": "book-ch4_282",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "The ability of the system to increase performance as more processors are added",
+          "correctOptionText": "The ability of the system to increase performance as more processors are added",
+          "options": [
+            "The ability of the system to handle multiple users simultaneously",
+            "The ability of the system to increase performance as more processors are added",
+            "The ability of the system to recover from failures automatically",
+            "The ability of the system to communicate with other systems"
+          ]
+        },
+        {
+          "id": "book-ch4_290",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "The ability to add more processors to the system as needed",
+          "correctOptionText": "The ability to add more processors to the system as needed",
+          "options": [
+            "The ability to run more tasks simultaneously",
+            "The ability to increase the memory capacity of the system",
+            "The ability to add more processors to the system as needed",
+            "The ability to reduce power consumption"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is cache coherence in a multiprocessor system?",
+      "copies": [
+        {
+          "id": "book-ch4_286",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "The ability of the system to maintain consistency of data stored in the caches of multiple processors",
+          "correctOptionText": "The ability of the system to maintain consistency of data stored in the caches of multiple processors",
+          "options": [
+            "The ability of the system to maintain consistency of data stored in the caches of multiple processors",
+            "The ability of the system to maintain consistency of data stored in the main memory",
+            "The ability of the system to communicate with other systems",
+            "The ability of the system to handle multiple input/output operations simultaneously"
+          ]
+        },
+        {
+          "id": "book-ch4_293",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "The ability to maintain consistency of shared data in different processor caches",
+          "correctOptionText": "The ability to maintain consistency of shared data in different processor caches",
+          "options": [
+            "The ability to maintain consistency of shared data in different processor caches",
+            "The ability to reduce the number of cache misses",
+            "The ability to switch between processors seamlessly",
+            "The ability to recover from failures automatically"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is an embedded system?",
+      "copies": [
+        {
+          "id": "book-ch4_333",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "A computer system that is embedded within a larger device",
+          "correctOptionText": "A computer system that is embedded within a larger device",
+          "options": [
+            "A system with no computing capabilities",
+            "A network of computers connected together",
+            "A computer system that is embedded within a larger device",
+            "A computer system with a large memory and processing power"
+          ]
+        },
+        {
+          "id": "book-ch4_342",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "A system designed to perform a specific task",
+          "correctOptionText": "A system designed to perform a specific task",
+          "options": [
+            "A system designed to perform a specific task",
+            "A system that is connected to the internet",
+            "A system that is used for gaming",
+            "A system that is used for general-purpose computing"
+          ]
+        },
+        {
+          "id": "book-ch4_378",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "A computer system used in industrial control applications",
+          "correctOptionText": "A computer system used in industrial control applications",
+          "options": [
+            "A computer system used in industrial control applications",
+            "A computer system that is always connected to the internet",
+            "A computer system used for gaming",
+            "A computer system that is only used for word processing"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following is NOT a characteristic of an embedded system?",
+      "copies": [
+        {
+          "id": "book-ch4_343",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "General-purpose computing",
+          "correctOptionText": "General-purpose computing",
+          "options": [
+            "Small size",
+            "Limited power",
+            "General-purpose computing",
+            "Low cost"
+          ]
+        },
+        {
+          "id": "book-ch4_356",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "Standard operating system",
+          "correctOptionText": "Standard operating system",
+          "options": [
+            "High reliability",
+            "Limited resources",
+            "Standard operating system",
+            "Real-time operation"
+          ]
+        },
+        {
+          "id": "book-ch4_381",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "High processing speed",
+          "correctOptionText": "High processing speed",
+          "options": [
+            "Low power consumption",
+            "Small form factor",
+            "High processing speed",
+            "Real-time operation"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following is NOT an example of an embedded system?",
+      "copies": [
+        {
+          "id": "book-ch4_344",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "Home computer",
+          "correctOptionText": "Home computer",
+          "options": [
+            "Smart watch",
+            "Home computer",
+            "Microwave oven",
+            "Airplane navigation system"
+          ]
+        },
+        {
+          "id": "book-ch4_379",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Personal computer",
+          "correctOptionText": "Personal computer",
+          "options": [
+            "Smartwatch",
+            "Traffic light control system",
+            "Microwave oven",
+            "Personal computer"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "What is the purpose of a real-time operating system (RTOS) in an embedded system?",
+      "copies": [
+        {
+          "id": "book-ch4_348",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "To manage system resources and scheduling",
+          "correctOptionText": "To manage system resources and scheduling",
+          "options": [
+            "To provide a graphical user interface (GUI)",
+            "To manage system resources and scheduling",
+            "To provide internet connectivity",
+            "To provide audio and video output"
+          ]
+        },
+        {
+          "id": "book-ch4_391",
+          "correctOptionIndex": 1,
+          "keyedAnswer": "To schedule and manage tasks in real-time.",
+          "correctOptionText": "To schedule and manage tasks in real-time.",
+          "options": [
+            "To schedule and manage tasks in real-time.",
+            "To provide a graphical user interface for the user.",
+            "To manage memory usage in the system.",
+            "To provide network connectivity."
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following is not a type of embedded system?",
+      "copies": [
+        {
+          "id": "book-ch4_352",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Web-based embedded system",
+          "correctOptionText": "Web-based embedded system",
+          "options": [
+            "Standalone embedded system",
+            "Mobile embedded system",
+            "Networked embedded system",
+            "Web-based embedded system"
+          ]
+        },
+        {
+          "id": "book-ch4_383",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Mainframe system",
+          "correctOptionText": "Mainframe system",
+          "options": [
+            "Standalone system",
+            "Real-time system",
+            "Networked system",
+            "Mainframe system"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Which of the following is an example of an ASIP?",
+      "copies": [
+        {
+          "id": "book-ch4_413",
+          "correctOptionIndex": 3,
+          "keyedAnswer": "Tensilica Xtensa",
+          "correctOptionText": "Tensilica Xtensa",
+          "options": [
+            "Intel Core i7",
+            "ARM Cortex-A9",
+            "Tensilica Xtensa",
+            "AMD Ryzen"
+          ]
+        },
+        {
+          "id": "book-ch4_417",
+          "correctOptionIndex": 4,
+          "keyedAnswer": "Digital Signal Processor (DSP)",
+          "correctOptionText": "Digital Signal Processor (DSP)",
+          "options": [
+            "Intel Core i7",
+            "ARM Cortex-A53",
+            "Qualcomm Snapdragon",
+            "Digital Signal Processor (DSP)"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "System behavior in object-oriented analysis can be represented using:",
+      "copies": [
+        {
+          "id": "book-ch8_28",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "Sequence diagrams",
+          "correctOptionText": "Sequence diagrams",
+          "options": [
+            "Class diagrams",
+            "Sequence diagrams",
+            "Component diagrams",
+            "Deployment diagrams"
+          ]
+        },
+        {
+          "id": "book-ch8_61",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "State diagrams",
+          "correctOptionText": "State diagrams",
+          "options": [
+            "Class diagrams",
+            "State diagrams",
+            "Component diagrams",
+            "Deployment diagrams"
+          ]
+        }
+      ]
+    },
+    {
+      "reason": "DIVERGENT_PROSE",
+      "optionSetsIdentical": false,
+      "stem": "Exception handling in object-oriented programming:",
+      "copies": [
+        {
+          "id": "book-ch8_36",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "Provides a mechanism for handling runtime errors",
+          "correctOptionText": "Provides a mechanism for handling runtime errors",
+          "options": [
+            "Should be avoided",
+            "Provides a mechanism for handling runtime errors",
+            "Is only available in Java",
+            "Decreases code reliability"
+          ]
+        },
+        {
+          "id": "book-ch8_69",
+          "correctOptionIndex": 2,
+          "keyedAnswer": "Provides a structured way to handle errors",
+          "correctOptionText": "Provides a structured way to handle errors",
+          "options": [
+            "Should be avoided",
+            "Provides a structured way to handle errors",
+            "Is only available in C++",
+            "Decreases code reliability"
+          ]
+        }
+      ]
+    }
+  ],
+  "appliedDeletions": [
+    {
+      "stem": "What is the purpose of star-delta conversion?",
+      "answer": "To reduce the starting current of a motor",
+      "kept": "book-ch1_48",
+      "dropped": [
+        "book-ch1_58"
+      ]
+    },
+    {
+      "stem": "Which type of conversion is commonly used in motor control circuits?",
+      "answer": "Star-delta conversion",
+      "kept": "book-ch1_53",
+      "dropped": [
+        "book-ch1_62"
+      ]
+    },
+    {
+      "stem": "Which type of conversion is commonly used in power distribution systems?",
+      "answer": "Delta-star conversion",
+      "kept": "book-ch1_54",
+      "dropped": [
+        "book-ch1_63"
+      ]
+    },
+    {
+      "stem": "Which of the following circuits is an example of a non-linear circuit?",
+      "answer": "Diode rectifier circuit",
+      "kept": "book-ch1_87",
+      "dropped": [
+        "book-ch1_93"
+      ]
+    },
+    {
+      "stem": "Which of the following circuits requires an external source of power to function?",
+      "answer": "Active circuit",
+      "kept": "book-ch1_122",
+      "dropped": [
+        "book-ch1_131"
+      ]
+    },
+    {
+      "stem": "What is the Thevenin equivalent circuit?",
+      "answer": "A circuit consisting of a single voltage source and a single resistor",
+      "kept": "book-ch1_162",
+      "dropped": [
+        "book-ch1_173"
+      ]
+    },
+    {
+      "stem": "What is the first step in determining the Thevenin equivalent circuit?",
+      "answer": "Identify the load circuit that is connected to the circuit of interest",
+      "kept": "book-ch1_164",
+      "dropped": [
+        "book-ch1_174"
+      ]
+    },
+    {
+      "stem": "What is the second step in determining the Thevenin equivalent circuit?",
+      "answer": "Remove the load circuit from the circuit of interest",
+      "kept": "book-ch1_165",
+      "dropped": [
+        "book-ch1_175"
+      ]
+    },
+    {
+      "stem": "What is the third step in determining the Thevenin equivalent circuit?",
+      "answer": "Determine the open-circuit voltage Vth across the terminals where the load was connected",
+      "kept": "book-ch1_166",
+      "dropped": [
+        "book-ch1_176"
+      ]
+    },
+    {
+      "stem": "What is the fourth step in determining the Thevenin equivalent circuit?",
+      "answer": "Determine the internal resistance Rth of the circuit between those terminals",
+      "kept": "book-ch1_167",
+      "dropped": [
+        "book-ch1_177"
+      ]
+    },
+    {
+      "stem": "Can Thevenin's theorem be used for non-linear circuits?",
+      "answer": "No, it only applies to linear circuits",
+      "kept": "book-ch1_170",
+      "dropped": [
+        "book-ch1_178"
+      ]
+    },
+    {
+      "stem": "What is the Norton equivalent circuit of a linear circuit?",
+      "answer": "A current source and a parallel resistor",
+      "kept": "book-ch1_185",
+      "dropped": [
+        "book-ch1_192"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using Norton's theorem?",
+      "answer": "It simplifies complex circuits",
+      "kept": "book-ch1_187",
+      "dropped": [
+        "book-ch1_196"
+      ]
+    },
+    {
+      "stem": "What is the maximum power transfer theorem?",
+      "answer": "It states that the power transferred from a source to a load is maximum when the load impedance is equal to the source impedance.",
+      "kept": "book-ch1_202",
+      "dropped": [
+        "book-ch1_268"
+      ]
+    },
+    {
+      "stem": "What type of circuits does the maximum power transfer theorem apply to?",
+      "answer": "Linear circuits only.",
+      "kept": "book-ch1_203",
+      "dropped": [
+        "book-ch1_269"
+      ]
+    },
+    {
+      "stem": "What is the advantage of applying the maximum power transfer theorem in a circuit?",
+      "answer": "It reduces the power loss in the circuit.",
+      "kept": "book-ch1_204",
+      "dropped": [
+        "book-ch1_270"
+      ]
+    },
+    {
+      "stem": "How does the maximum power transfer theorem help in designing power systems?",
+      "answer": "All of the above.",
+      "kept": "book-ch1_205",
+      "dropped": [
+        "book-ch1_271"
+      ]
+    },
+    {
+      "stem": "What happens when the load impedance is not equal to the source impedance in a circuit?",
+      "answer": "The power transfer is minimum.",
+      "kept": "book-ch1_206",
+      "dropped": [
+        "book-ch1_272"
+      ]
+    },
+    {
+      "stem": "Is the maximum power transfer theorem applicable to AC circuits?",
+      "answer": "Yes, it is applicable to AC circuits.",
+      "kept": "book-ch1_207",
+      "dropped": [
+        "book-ch1_273"
+      ]
+    },
+    {
+      "stem": "What is the formula for calculating the maximum power transfer in a circuit?",
+      "answer": "P=I^2R",
+      "kept": "book-ch1_208",
+      "dropped": [
+        "book-ch1_274"
+      ]
+    },
+    {
+      "stem": "Can the maximum power transfer occur at multiple values of load impedance?",
+      "answer": "No, it can occur at only one value of load impedance.",
+      "kept": "book-ch1_209",
+      "dropped": [
+        "book-ch1_275"
+      ]
+    },
+    {
+      "stem": "What is the condition for maximum power transfer in a circuit?",
+      "answer": "The load impedance must be equal to the source impedance.",
+      "kept": "book-ch1_210",
+      "dropped": [
+        "book-ch1_276"
+      ]
+    },
+    {
+      "stem": "The maximum power transfer theorem is applicable to:",
+      "answer": "Linear circuits only.",
+      "kept": "book-ch1_212",
+      "dropped": [
+        "book-ch1_278"
+      ]
+    },
+    {
+      "stem": "The maximum power transfer occurs when:",
+      "answer": "The load impedance is equal to the source impedance",
+      "kept": "book-ch1_213",
+      "dropped": [
+        "book-ch1_279"
+      ]
+    },
+    {
+      "stem": "What is the formula for calculating the maximum power transfer?",
+      "answer": "Pmax=V^2/4R",
+      "kept": "book-ch1_214",
+      "dropped": [
+        "book-ch1_280"
+      ]
+    },
+    {
+      "stem": "In which applications is the maximum power transfer theorem useful?",
+      "answer": "All of the above",
+      "kept": "book-ch1_215",
+      "dropped": [
+        "book-ch1_281"
+      ]
+    },
+    {
+      "stem": "What happens when the load impedance is much larger than the source impedance?",
+      "answer": "The power transfer is minimum.",
+      "kept": "book-ch1_216",
+      "dropped": [
+        "book-ch1_282"
+      ]
+    },
+    {
+      "stem": "The maximum power transfer theorem helps to:",
+      "answer": "Minimize the amount of energy lost in transmission.",
+      "kept": "book-ch1_217",
+      "dropped": [
+        "book-ch1_283"
+      ]
+    },
+    {
+      "stem": "The maximum power transfer theorem is useful in designing and optimizing:",
+      "answer": "Power systems",
+      "kept": "book-ch1_218",
+      "dropped": [
+        "book-ch1_284"
+      ]
+    },
+    {
+      "stem": "A series R-C circuit has a resistor of 100 Ω and a capacitor of 10 µF. What is the cutoff frequency?",
+      "answer": "159 Hz",
+      "kept": "book-ch1_223",
+      "dropped": [
+        "book-ch1_289"
+      ]
+    },
+    {
+      "stem": "In an R-L circuit, what happens to the impedance as the frequency increases?",
+      "answer": "It increases",
+      "kept": "book-ch1_224",
+      "dropped": [
+        "book-ch1_290"
+      ]
+    },
+    {
+      "stem": "Which type of circuit contains an inductor and a resistor?",
+      "answer": "R-L circuit",
+      "kept": "book-ch1_229",
+      "dropped": [
+        "book-ch1_295"
+      ]
+    },
+    {
+      "stem": "What happens to the current in an R-L circuit if the inductance is increased?",
+      "answer": "The current remains the same",
+      "kept": "book-ch1_232",
+      "dropped": [
+        "book-ch1_298"
+      ]
+    },
+    {
+      "stem": "In an R-C circuit, what happens to the current as the capacitor becomes fully charged?",
+      "answer": "The current becomes zero",
+      "kept": "book-ch1_233",
+      "dropped": [
+        "book-ch1_299"
+      ]
+    },
+    {
+      "stem": "In an R-L-C circuit, what happens to the phase angle at resonance?",
+      "answer": "The phase angle is zero",
+      "kept": "book-ch1_236",
+      "dropped": [
+        "book-ch1_302"
+      ]
+    },
+    {
+      "stem": "What is the resonant frequency of an AC series circuit consisting of a 20mH Inductor and a 10µF capacitor?",
+      "answer": "159.15 Hz",
+      "kept": "book-ch1_237",
+      "dropped": [
+        "book-ch1_303"
+      ]
+    },
+    {
+      "stem": "What is the resonant frequency of an AC parallel circuit consisting of a 10mH inductor and a capacitor 100µF?",
+      "answer": "159.15 Hz",
+      "kept": "book-ch1_238",
+      "dropped": [
+        "book-ch1_304"
+      ]
+    },
+    {
+      "stem": "What is the phase angle between the voltage and current in an AC series resonant circuit at resonance?",
+      "answer": "0 degrees",
+      "kept": "book-ch1_243",
+      "dropped": [
+        "book-ch1_309"
+      ]
+    },
+    {
+      "stem": "What is the phase angle between the voltage and current in an AC parallel resonant circuit at resonance?",
+      "answer": "0 degrees",
+      "kept": "book-ch1_244",
+      "dropped": [
+        "book-ch1_310"
+      ]
+    },
+    {
+      "stem": "In an AC series resonant circuit, at the resonant frequency, what is the power factor?",
+      "answer": "Unity",
+      "kept": "book-ch1_246",
+      "dropped": [
+        "book-ch1_312"
+      ]
+    },
+    {
+      "stem": "What is the resonant frequency of an AC series resonant circuit with an inductance of 5mH and a capacitance 10µF?",
+      "answer": "3.18 kHz",
+      "kept": "book-ch1_247",
+      "dropped": [
+        "book-ch1_313"
+      ]
+    },
+    {
+      "stem": "What is the phase relationship between the voltage across the capacitor and the voltage across the inductor in an AC series resonant circuit at resonance?",
+      "answer": "They are 180 degrees out of phase",
+      "kept": "book-ch1_250",
+      "dropped": [
+        "book-ch1_316"
+      ]
+    },
+    {
+      "stem": "What is the phase relationship between the current and the voltage in an AC series resonant circuit at resonance?",
+      "answer": "They are in phase",
+      "kept": "book-ch1_251",
+      "dropped": [
+        "book-ch1_317"
+      ]
+    },
+    {
+      "stem": "What is the unit of active power?",
+      "answer": "Watts (W)",
+      "kept": "book-ch1_252",
+      "dropped": [
+        "book-ch1_318"
+      ]
+    },
+    {
+      "stem": "What is the formula for reactive power?",
+      "answer": "Q=V*I*sin(theta)",
+      "kept": "book-ch1_253",
+      "dropped": [
+        "book-ch1_319"
+      ]
+    },
+    {
+      "stem": "What is the unit of reactive power?",
+      "answer": "Volt-amperes reactive (VAR)",
+      "kept": "book-ch1_254",
+      "dropped": [
+        "book-ch1_320"
+      ]
+    },
+    {
+      "stem": "What is the formula for active power?",
+      "answer": "P=V*I*cos(theta)",
+      "kept": "book-ch1_255",
+      "dropped": [
+        "book-ch1_321"
+      ]
+    },
+    {
+      "stem": "What is the unit of apparent power?",
+      "answer": "Volt-amperes (VA)",
+      "kept": "book-ch1_256",
+      "dropped": [
+        "book-ch1_322"
+      ]
+    },
+    {
+      "stem": "What is the formula for power factor?",
+      "answer": "pf=P/S",
+      "kept": "book-ch1_257",
+      "dropped": [
+        "book-ch1_323"
+      ]
+    },
+    {
+      "stem": "What is the unit of power factor?",
+      "answer": "None of the above",
+      "kept": "book-ch1_258",
+      "dropped": [
+        "book-ch1_324"
+      ]
+    },
+    {
+      "stem": "What is the formula for apparent power?",
+      "answer": "S=V",
+      "kept": "book-ch1_260",
+      "dropped": [
+        "book-ch1_326"
+      ]
+    },
+    {
+      "stem": "What is the significance of power factor in electrical circuits?",
+      "answer": "It measures the efficiency of the circuit in using the power delivered to it",
+      "kept": "book-ch1_261",
+      "dropped": [
+        "book-ch1_327"
+      ]
+    },
+    {
+      "stem": "Which of the following is a measure of how efficiently the circuit is using the power delivered to it?",
+      "answer": "Power factor",
+      "kept": "book-ch1_262",
+      "dropped": [
+        "book-ch1_328"
+      ]
+    },
+    {
+      "stem": "Which type of power is used in the circuit to perform useful work?",
+      "answer": "Active power",
+      "kept": "book-ch1_263",
+      "dropped": [
+        "book-ch1_329"
+      ]
+    },
+    {
+      "stem": "Which type of power is stored and released by the circuit?",
+      "answer": "Reactive power",
+      "kept": "book-ch1_264",
+      "dropped": [
+        "book-ch1_330"
+      ]
+    },
+    {
+      "stem": "What is the power factor of a circuit that has 100 W of active power and 120 VA of apparent power?",
+      "answer": "0.83",
+      "kept": "book-ch1_265",
+      "dropped": [
+        "book-ch1_331"
+      ]
+    },
+    {
+      "stem": "What happens to the power factor of a circuit if the reactive power increases?",
+      "answer": "It decreases",
+      "kept": "book-ch1_266",
+      "dropped": [
+        "book-ch1_332"
+      ]
+    },
+    {
+      "stem": "Which of the following is not a measure of power in an AC circuit?",
+      "answer": "Hertz (Hz)",
+      "kept": "book-ch1_267",
+      "dropped": [
+        "book-ch1_333"
+      ]
+    },
+    {
+      "stem": "What determines the frequency of an RC oscillator?",
+      "answer": "The time constant of the RC circuit",
+      "kept": "book-ch1_372",
+      "dropped": [
+        "book-ch1_382"
+      ]
+    },
+    {
+      "stem": "What is the duty cycle of a square wave generator?",
+      "answer": "The ratio of the pulse width to the time period",
+      "kept": "book-ch1_391",
+      "dropped": [
+        "book-ch2_123"
+      ]
+    },
+    {
+      "stem": "What type of waveform is produced by a triangle wave generator?",
+      "answer": "A waveform with a linearly increasing or decreasing amplitude",
+      "kept": "book-ch1_392",
+      "dropped": [
+        "book-ch2_124"
+      ]
+    },
+    {
+      "stem": "What type of circuit is commonly used to generate square wave signals?",
+      "answer": "An op-amp circuit",
+      "kept": "book-ch1_393",
+      "dropped": [
+        "book-ch2_125"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using a relaxation oscillator for square wave generation?",
+      "answer": "Simplicity and low cost",
+      "kept": "book-ch1_394",
+      "dropped": [
+        "book-ch2_126"
+      ]
+    },
+    {
+      "stem": "What is the role of a Schmitt trigger in a square wave generator circuit?",
+      "answer": "To generate a clean and stable square wave signal",
+      "kept": "book-ch1_395",
+      "dropped": [
+        "book-ch2_127"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using a ramp generator for triangle wave generation?",
+      "answer": "Simplicity and low cost",
+      "kept": "book-ch1_397",
+      "dropped": [
+        "book-ch2_129"
+      ]
+    },
+    {
+      "stem": "What type of circuit is commonly used to generate triangle wave signals?",
+      "answer": "An integrator circuit",
+      "kept": "book-ch1_398",
+      "dropped": [
+        "book-ch2_130"
+      ]
+    },
+    {
+      "stem": "What is the amplitude of a triangle wave generator determined by?",
+      "answer": "The input voltage of the oscillator",
+      "kept": "book-ch1_399",
+      "dropped": [
+        "book-ch2_131"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using an op-amp circuit for triangle wave generation?",
+      "answer": "Simplicity and low cost",
+      "kept": "book-ch1_400",
+      "dropped": [
+        "book-ch2_132"
+      ]
+    },
+    {
+      "stem": "Which waveform generator is typically used for testing digital circuits?",
+      "answer": "Square wave generator",
+      "kept": "book-ch1_401",
+      "dropped": [
+        "book-ch2_133"
+      ]
+    },
+    {
+      "stem": "What is the duty cycle of a square wave?",
+      "answer": "The ratio of the pulse width to the time period",
+      "kept": "book-ch1_402",
+      "dropped": [
+        "book-ch2_134"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using a square wave generator over other types of waveform generators?",
+      "answer": "Simplicity and low cost",
+      "kept": "book-ch1_403",
+      "dropped": [
+        "book-ch2_135"
+      ]
+    },
+    {
+      "stem": "Which waveform generator is capable of producing more complex waveforms than a square wave generator?",
+      "answer": "Arbitrary waveform generator",
+      "kept": "book-ch1_404",
+      "dropped": [
+        "book-ch2_136"
+      ]
+    },
+    {
+      "stem": "What is the shape of the waveform produced by a triangle wave generator?",
+      "answer": "A smoothly varying waveform with a linear rise and fall",
+      "kept": "book-ch1_405",
+      "dropped": [
+        "book-ch2_137"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using a triangle wave generator over a square wave generator?",
+      "answer": "More gradual transitions and reduced harmonic content",
+      "kept": "book-ch1_407",
+      "dropped": [
+        "book-ch2_139"
+      ]
+    },
+    {
+      "stem": "Which type of waveform generator is commonly used in audio applications?",
+      "answer": "Sine wave generator",
+      "kept": "book-ch1_408",
+      "dropped": [
+        "book-ch2_140"
+      ]
+    },
+    {
+      "stem": "What is the shape of the waveform produced by a sawtooth wave generator?",
+      "answer": "A waveform with a rapidly changing rise and a slow fall",
+      "kept": "book-ch1_409",
+      "dropped": [
+        "book-ch2_141"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using an arbitrary waveform generator over other types of waveform generators?",
+      "answer": "The ability to generate complex and customized waveforms",
+      "kept": "book-ch1_410",
+      "dropped": [
+        "book-ch2_142"
+      ]
+    },
+    {
+      "stem": "What is the amplifying element used in a Class A output stage?",
+      "answer": "Bipolar Junction Transistor",
+      "kept": "book-ch1_411",
+      "dropped": [
+        "book-ch2_143"
+      ]
+    },
+    {
+      "stem": "What causes crossover distortion in a Class B output stage?",
+      "answer": "The switching between the amplifying elements causes a gap in the output signal.",
+      "kept": "book-ch1_412",
+      "dropped": [
+        "book-ch2_144"
+      ]
+    },
+    {
+      "stem": "What is the advantage of a Class AB output stage over a Class B output stage?",
+      "answer": "Reduced crossover distortion",
+      "kept": "book-ch1_413",
+      "dropped": [
+        "book-ch2_145"
+      ]
+    },
+    {
+      "stem": "What is the operating mode of a Class C output stage?",
+      "answer": "Non-linear",
+      "kept": "book-ch1_414",
+      "dropped": [
+        "book-ch2_146"
+      ]
+    },
+    {
+      "stem": "What is the advantage of a Class D output stage over other output stages?",
+      "answer": "High efficiency",
+      "kept": "book-ch1_415",
+      "dropped": [
+        "book-ch2_147"
+      ]
+    },
+    {
+      "stem": "What is the primary disadvantage of a Class A output stage?",
+      "answer": "Low efficiency",
+      "kept": "book-ch1_416",
+      "dropped": [
+        "book-ch2_148"
+      ]
+    },
+    {
+      "stem": "Which type of output stage is suitable for RF amplifiers?",
+      "answer": "Class C",
+      "kept": "book-ch1_417",
+      "dropped": [
+        "book-ch2_149"
+      ]
+    },
+    {
+      "stem": "What is the biasing arrangement used in a Class AB output stage?",
+      "answer": "The bias voltage is varied to adjust the conduction angle.",
+      "kept": "book-ch1_418",
+      "dropped": [
+        "book-ch2_150"
+      ]
+    },
+    {
+      "stem": "Which type of output stage is used in audio power amplifiers?",
+      "answer": "Class AB",
+      "kept": "book-ch1_419",
+      "dropped": [
+        "book-ch2_151"
+      ]
+    },
+    {
+      "stem": "Which type of output stage is commonly used in switch-mode power supplies?",
+      "answer": "Class D",
+      "kept": "book-ch1_420",
+      "dropped": [
+        "book-ch2_152"
+      ]
+    },
+    {
+      "stem": "Which of the following is a characteristic of a class A output stage?",
+      "answer": "Low distortion",
+      "kept": "book-ch1_421",
+      "dropped": [
+        "book-ch1_441",
+        "book-ch2_153",
+        "book-ch2_173"
+      ]
+    },
+    {
+      "stem": "Which of the following output stages uses two amplifying elements that conduct for half of the input signal cycle each?",
+      "answer": "Class B",
+      "kept": "book-ch1_422",
+      "dropped": [
+        "book-ch2_154"
+      ]
+    },
+    {
+      "stem": "Which of the following output stages is a combination of class A and class B?",
+      "answer": "Class AB",
+      "kept": "book-ch1_423",
+      "dropped": [
+        "book-ch2_155"
+      ]
+    },
+    {
+      "stem": "Which of the following output stages is suitable for RF amplifiers?",
+      "answer": "Class C",
+      "kept": "book-ch1_424",
+      "dropped": [
+        "book-ch2_156"
+      ]
+    },
+    {
+      "stem": "Which of the following output stages uses pulse width modulation to convert the input signal into a train of pulses?",
+      "answer": "Class D",
+      "kept": "book-ch1_425",
+      "dropped": [
+        "book-ch2_157"
+      ]
+    },
+    {
+      "stem": "Which of the following is a disadvantage of a class B output stage?",
+      "answer": "Crossover distortion",
+      "kept": "book-ch1_426",
+      "dropped": [
+        "book-ch2_158"
+      ]
+    },
+    {
+      "stem": "Which of the following output stages is the most efficient?",
+      "answer": "Class C",
+      "kept": "book-ch1_427",
+      "dropped": [
+        "book-ch2_159"
+      ]
+    },
+    {
+      "stem": "Which of the following output stages is the least efficient?",
+      "answer": "Class A",
+      "kept": "book-ch1_428",
+      "dropped": [
+        "book-ch2_160"
+      ]
+    },
+    {
+      "stem": "Which of the following output stages has a biasing arrangement that allows the amplifying element to conduct slightly even when there is no input signal?",
+      "answer": "Class AB",
+      "kept": "book-ch1_429",
+      "dropped": [
+        "book-ch2_161"
+      ]
+    },
+    {
+      "stem": "Which of the following output stages is suitable for high power audio amplifiers?",
+      "answer": "Class AB",
+      "kept": "book-ch1_430",
+      "dropped": [
+        "book-ch2_162"
+      ]
+    },
+    {
+      "stem": "What is the main advantage of a Class A output stage?",
+      "answer": "Low distortion",
+      "kept": "book-ch1_431",
+      "dropped": [
+        "book-ch2_163"
+      ]
+    },
+    {
+      "stem": "What is the main disadvantage of a Class A output stage?",
+      "answer": "Low efficiency",
+      "kept": "book-ch1_432",
+      "dropped": [
+        "book-ch2_164"
+      ]
+    },
+    {
+      "stem": "What type of biasing is commonly used in Class A output stages?",
+      "answer": "Fixed bias",
+      "kept": "book-ch1_433",
+      "dropped": [
+        "book-ch2_165"
+      ]
+    },
+    {
+      "stem": "What is the DC bias point of a Class A output stage?",
+      "answer": "Halfway between the positive and negative supply voltage",
+      "kept": "book-ch1_434",
+      "dropped": [
+        "book-ch2_166"
+      ]
+    },
+    {
+      "stem": "What is the maximum theoretical efficiency of a Class A output stage?",
+      "answer": "50%",
+      "kept": "book-ch1_435",
+      "dropped": [
+        "book-ch2_167"
+      ]
+    },
+    {
+      "stem": "What is the typical output power of a Class A amplifier?",
+      "answer": "1 watt to 10 watts",
+      "kept": "book-ch1_436",
+      "dropped": [
+        "book-ch2_168"
+      ]
+    },
+    {
+      "stem": "What type of load is commonly used in Class A output stages?",
+      "answer": "Resistive load",
+      "kept": "book-ch1_437",
+      "dropped": [
+        "book-ch2_169"
+      ]
+    },
+    {
+      "stem": "What is the main advantage of a Class A output stage over other amplifier configurations?",
+      "answer": "Low distortion",
+      "kept": "book-ch1_438",
+      "dropped": [
+        "book-ch2_170"
+      ]
+    },
+    {
+      "stem": "What type of input signal is best suited for a Class A output stage?",
+      "answer": "Sinusoidal signal",
+      "kept": "book-ch1_439",
+      "dropped": [
+        "book-ch2_171"
+      ]
+    },
+    {
+      "stem": "What is the typical voltage gain of a Class A amplifier?",
+      "answer": "10 to 100",
+      "kept": "book-ch1_440",
+      "dropped": [
+        "book-ch2_172"
+      ]
+    },
+    {
+      "stem": "In a Class A output stage, the amplifying device conducts for:",
+      "answer": "The entire input signal cycle",
+      "kept": "book-ch1_442",
+      "dropped": [
+        "book-ch2_174"
+      ]
+    },
+    {
+      "stem": "The efficiency of a Class A output stage is:",
+      "answer": "Low",
+      "kept": "book-ch1_443",
+      "dropped": [
+        "book-ch2_175"
+      ]
+    },
+    {
+      "stem": "What is the advantage of a Class A output stage over other classes of amplifiers?",
+      "answer": "Lower distortion",
+      "kept": "book-ch1_444",
+      "dropped": [
+        "book-ch2_176"
+      ]
+    },
+    {
+      "stem": "What is the key feature of a Class A output stage?",
+      "answer": "The amplifying device conducts for the entire input signal cycle",
+      "kept": "book-ch1_445",
+      "dropped": [
+        "book-ch2_177"
+      ]
+    },
+    {
+      "stem": "What is the typical efficiency of a Class A output stage?",
+      "answer": "25%",
+      "kept": "book-ch1_446",
+      "dropped": [
+        "book-ch2_178"
+      ]
+    },
+    {
+      "stem": "Which of the following is a disadvantage of a Class A output stage?",
+      "answer": "Low power output",
+      "kept": "book-ch1_447",
+      "dropped": [
+        "book-ch2_179"
+      ]
+    },
+    {
+      "stem": "Which type of amplifying device is commonly used in Class A output stages?",
+      "answer": "All of the above",
+      "kept": "book-ch1_448",
+      "dropped": [
+        "book-ch2_180"
+      ]
+    },
+    {
+      "stem": "What is the purpose of the biasing circuit in a Class A output stage?",
+      "answer": "To set the operating point of the amplifying device",
+      "kept": "book-ch1_449",
+      "dropped": [
+        "book-ch2_181"
+      ]
+    },
+    {
+      "stem": "What is the quiescent current of a Class A output stage?",
+      "answer": "The current flowing through the amplifying device when there is no input signal",
+      "kept": "book-ch1_450",
+      "dropped": [
+        "book-ch2_182"
+      ]
+    },
+    {
+      "stem": "Which of the following is a common application of a Class A output stage?",
+      "answer": "Audio power amplifiers",
+      "kept": "book-ch1_451",
+      "dropped": [
+        "book-ch2_183"
+      ]
+    },
+    {
+      "stem": "Which of the following is a characteristic of the output signal of a Class A output stage?",
+      "answer": "It depends on the input signal",
+      "kept": "book-ch1_452",
+      "dropped": [
+        "book-ch2_184"
+      ]
+    },
+    {
+      "stem": "Which of the following is a disadvantage of a Class A output stage in terms of power efficiency?",
+      "answer": "It generates more heat than other classes of amplifiers",
+      "kept": "book-ch1_453",
+      "dropped": [
+        "book-ch2_185"
+      ]
+    },
+    {
+      "stem": "What is a Class B output stage in amplifiers?",
+      "answer": "An amplifier configuration where the amplifying device conducts only for half of the input signal cycle",
+      "kept": "book-ch1_454",
+      "dropped": [
+        "book-ch2_186"
+      ]
+    },
+    {
+      "stem": "What is the advantage of a Class B output stage?",
+      "answer": "High power efficiency",
+      "kept": "book-ch1_455",
+      "dropped": [
+        "book-ch2_187"
+      ]
+    },
+    {
+      "stem": "What is crossover distortion in a Class B output stage?",
+      "answer": "A discontinuity in the output signal at the point where one device switches off and the other switches on",
+      "kept": "book-ch1_456",
+      "dropped": [
+        "book-ch2_188"
+      ]
+    },
+    {
+      "stem": "How is crossover distortion reduced in a Class B output stage?",
+      "answer": "By applying a small amount of bias current to the amplifying devices",
+      "kept": "book-ch1_457",
+      "dropped": [
+        "book-ch2_189"
+      ]
+    },
+    {
+      "stem": "What is the main application of Class B output stages?",
+      "answer": "Audio power amplifiers",
+      "kept": "book-ch1_458",
+      "dropped": [
+        "book-ch2_190"
+      ]
+    },
+    {
+      "stem": "What is the main disadvantage of Class B output stages?",
+      "answer": "Crossover distortion",
+      "kept": "book-ch1_459",
+      "dropped": [
+        "book-ch2_191"
+      ]
+    },
+    {
+      "stem": "What is the purpose of biasing in a Class B output stage?",
+      "answer": "To keep the amplifying devices slightly conductive even when there is no input signal",
+      "kept": "book-ch1_460",
+      "dropped": [
+        "book-ch2_192"
+      ]
+    },
+    {
+      "stem": "What is the output signal waveform of a Class B output stage?",
+      "answer": "A combination of the signals produced by each device",
+      "kept": "book-ch1_461",
+      "dropped": [
+        "book-ch2_193"
+      ]
+    },
+    {
+      "stem": "What type of load is typically used with a Class B output stage?",
+      "answer": "Resistive load",
+      "kept": "book-ch1_462",
+      "dropped": [
+        "book-ch2_194"
+      ]
+    },
+    {
+      "stem": "What is the maximum theoretical efficiency of a Class B output stage?",
+      "answer": "75%",
+      "kept": "book-ch1_463",
+      "dropped": [
+        "book-ch2_195"
+      ]
+    },
+    {
+      "stem": "In a Class B output stage, how many amplifying devices are used?",
+      "answer": "Two",
+      "kept": "book-ch1_464",
+      "dropped": [
+        "book-ch2_196"
+      ]
+    },
+    {
+      "stem": "What is the key advantage of a Class B output stage?",
+      "answer": "High power efficiency",
+      "kept": "book-ch1_465",
+      "dropped": [
+        "book-ch2_197"
+      ]
+    },
+    {
+      "stem": "What is the major disadvantage of a Class B output stage?",
+      "answer": "Crossover distortion",
+      "kept": "book-ch1_466",
+      "dropped": [
+        "book-ch2_198"
+      ]
+    },
+    {
+      "stem": "How does bias current help to address the issue of crossover distortion in a Class B output stage?",
+      "answer": "By keeping the amplifying devices slightly conductive",
+      "kept": "book-ch1_467",
+      "dropped": [
+        "book-ch2_199"
+      ]
+    },
+    {
+      "stem": "Which application is Class B output stage commonly used in?",
+      "answer": "High-power RF amplifiers",
+      "kept": "book-ch1_468",
+      "dropped": [
+        "book-ch2_200"
+      ]
+    },
+    {
+      "stem": "What is the output signal of a Class B output stage?",
+      "answer": "A combination of two signals produced by each device",
+      "kept": "book-ch1_469",
+      "dropped": [
+        "book-ch2_201"
+      ]
+    },
+    {
+      "stem": "Which type of amplifiers produce less distortion than Class B amplifiers?",
+      "answer": "Class AB amplifiers",
+      "kept": "book-ch1_470",
+      "dropped": [
+        "book-ch2_202"
+      ]
+    },
+    {
+      "stem": "What is the function of the load resistor in a Class B output stage?",
+      "answer": "To eliminate the crossover distortion",
+      "kept": "book-ch1_471",
+      "dropped": [
+        "book-ch2_203"
+      ]
+    },
+    {
+      "stem": "Which type of distortion is commonly associated with Class B output stages?",
+      "answer": "Crossover distortion",
+      "kept": "book-ch1_472",
+      "dropped": [
+        "book-ch2_204"
+      ]
+    },
+    {
+      "stem": "Which of the following is a limitation of using Class B amplifiers?",
+      "answer": "Low distortion",
+      "kept": "book-ch1_473",
+      "dropped": [
+        "book-ch2_205"
+      ]
+    },
+    {
+      "stem": "What is the main advantage of a Class AB output stage over a Class B output stage?",
+      "answer": "Lower distortion",
+      "kept": "book-ch1_474",
+      "dropped": [
+        "book-ch2_206"
+      ]
+    },
+    {
+      "stem": "What is the purpose of biasing both amplifying devices in a Class AB output stage?",
+      "answer": "To eliminate crossover distortion",
+      "kept": "book-ch1_475",
+      "dropped": [
+        "book-ch2_207"
+      ]
+    },
+    {
+      "stem": "Which of the following is not a characteristic of Class AB output stages?",
+      "answer": "High bias",
+      "kept": "book-ch1_476",
+      "dropped": [
+        "book-ch2_208"
+      ]
+    },
+    {
+      "stem": "In which application are Class AB output stages commonly used?",
+      "answer": "High-fidelity audio amplifiers",
+      "kept": "book-ch1_477",
+      "dropped": [
+        "book-ch2_209"
+      ]
+    },
+    {
+      "stem": "Which type of output stage offers the highest linearity?",
+      "answer": "Class A",
+      "kept": "book-ch1_478",
+      "dropped": [
+        "book-ch2_210"
+      ]
+    },
+    {
+      "stem": "What is the disadvantage of Class AB output stages compared to Class B output stages?",
+      "answer": "Lower power efficiency",
+      "kept": "book-ch1_479",
+      "dropped": [
+        "book-ch2_211"
+      ]
+    },
+    {
+      "stem": "Which of the following is not a benefit of using a Class AB output stage?",
+      "answer": "None of the above",
+      "kept": "book-ch1_480",
+      "dropped": [
+        "book-ch2_212"
+      ]
+    },
+    {
+      "stem": "Which type of output stage produces lower distortion than Class B output stages?",
+      "answer": "Both A and B",
+      "kept": "book-ch1_481",
+      "dropped": [
+        "book-ch2_213"
+      ]
+    },
+    {
+      "stem": "What is the key advantage of using a Class AB output stage?",
+      "answer": "High power efficiency and low distortion",
+      "kept": "book-ch1_482",
+      "dropped": [
+        "book-ch2_214"
+      ]
+    },
+    {
+      "stem": "What is the main disadvantage of Class A output stages compared to Class AB output stages?",
+      "answer": "Lower power efficiency",
+      "kept": "book-ch1_483",
+      "dropped": [
+        "book-ch2_215"
+      ]
+    },
+    {
+      "stem": "Which of the following statements is true about a Class AB output stage?",
+      "answer": "It has high power efficiency and low distortion.",
+      "kept": "book-ch1_484",
+      "dropped": [
+        "book-ch2_216"
+      ]
+    },
+    {
+      "stem": "Which type of output stage is commonly used in power supplies?",
+      "answer": "Class B",
+      "kept": "book-ch1_485",
+      "dropped": [
+        "book-ch2_217"
+      ]
+    },
+    {
+      "stem": "What is the main advantage of using a Class AB output stage in an audio amplifier?",
+      "answer": "High efficiency and low distortion",
+      "kept": "book-ch1_486",
+      "dropped": [
+        "book-ch2_218"
+      ]
+    },
+    {
+      "stem": "In a Class AB output stage, both amplifying devices are biased to conduct a small amount of current even when there is no input signal. What is the purpose of t",
+      "answer": "To reduce power efficiency",
+      "kept": "book-ch1_487",
+      "dropped": [
+        "book-ch2_219"
+      ]
+    },
+    {
+      "stem": "Which type of output stage is commonly used in high-fidelity audio amplifiers?",
+      "answer": "Class AB",
+      "kept": "book-ch1_488",
+      "dropped": [
+        "book-ch2_220"
+      ]
+    },
+    {
+      "stem": "What is the process of gradual conduction transfer in a Class AB output stage known as?",
+      "answer": "Crossover",
+      "kept": "book-ch1_489",
+      "dropped": [
+        "book-ch2_221"
+      ]
+    },
+    {
+      "stem": "Which of the following is a disadvantage of using a Class AB output stage?",
+      "answer": "Low power efficiency",
+      "kept": "book-ch1_490",
+      "dropped": [
+        "book-ch2_222"
+      ]
+    },
+    {
+      "stem": "In a Class AB output stage, how do the amplifying devices behave when there is an input signal?",
+      "answer": "One conducts fully and the other conducts partially.",
+      "kept": "book-ch1_491",
+      "dropped": [
+        "book-ch2_223"
+      ]
+    },
+    {
+      "stem": "What is the main purpose of a Class AB output stage?",
+      "answer": "To reduce distortion",
+      "kept": "book-ch1_492",
+      "dropped": [
+        "book-ch2_224"
+      ]
+    },
+    {
+      "stem": "What is the purpose of biasing the Class AB output stage in amplifiers?",
+      "answer": "All of the above",
+      "kept": "book-ch1_493",
+      "dropped": [
+        "book-ch2_225",
+        "book-ch2_358",
+        "book-ch2_452"
+      ]
+    },
+    {
+      "stem": "What is a common biasing technique for the Class AB output stage?",
+      "answer": "All of the above",
+      "kept": "book-ch1_494",
+      "dropped": [
+        "book-ch2_226",
+        "book-ch2_359",
+        "book-ch2_453"
+      ]
+    },
+    {
+      "stem": "In a voltage divider biasing network, where is the bias voltage set?",
+      "answer": "At the base or gate of the amplifying device",
+      "kept": "book-ch1_495",
+      "dropped": [
+        "book-ch2_227",
+        "book-ch2_360",
+        "book-ch2_454"
+      ]
+    },
+    {
+      "stem": "How does a diode biasing circuit work?",
+      "answer": "By connecting a diode in series with the base or gate of the amplifying device",
+      "kept": "book-ch1_496",
+      "dropped": [
+        "book-ch2_228",
+        "book-ch2_361",
+        "book-ch2_455"
+      ]
+    },
+    {
+      "stem": "Which biasing technique allows for fine-tuning of the operating point?",
+      "answer": "Voltage divider network",
+      "kept": "book-ch1_497",
+      "dropped": [
+        "book-ch2_229",
+        "book-ch2_362",
+        "book-ch2_456"
+      ]
+    },
+    {
+      "stem": "What is the goal of biasing the Class AB stage?",
+      "answer": "To ensure linear operation with low distortion",
+      "kept": "book-ch1_498",
+      "dropped": [
+        "book-ch2_230",
+        "book-ch2_363",
+        "book-ch2_457"
+      ]
+    },
+    {
+      "stem": "Which type of amplifying device is typically used in a Class AB output stage?",
+      "answer": "Bipolar junction transistor (BJT)",
+      "kept": "book-ch1_499",
+      "dropped": [
+        "book-ch2_231",
+        "book-ch2_364",
+        "book-ch2_458"
+      ]
+    },
+    {
+      "stem": "Which biasing technique uses a transistor configured as a voltage divider?",
+      "answer": "Transistor biasing",
+      "kept": "book-ch1_500",
+      "dropped": [
+        "book-ch2_232",
+        "book-ch2_365",
+        "book-ch2_459"
+      ]
+    },
+    {
+      "stem": "Why is biasing necessary for Class AB amplifiers?",
+      "answer": "To ensure that the amplifying devices operate in the active region",
+      "kept": "book-ch1_501",
+      "dropped": [
+        "book-ch2_233",
+        "book-ch2_366",
+        "book-ch2_460"
+      ]
+    },
+    {
+      "stem": "What is the main advantage of using a Class AB output stage in amplifiers?",
+      "answer": "High linearity with low distortion",
+      "kept": "book-ch1_502",
+      "dropped": [
+        "book-ch2_234",
+        "book-ch2_367",
+        "book-ch2_461"
+      ]
+    },
+    {
+      "stem": "What is the bias voltage typically set to in the Class AB output stage?",
+      "answer": "The forward voltage drop of a diode",
+      "kept": "book-ch1_503",
+      "dropped": [
+        "book-ch2_235",
+        "book-ch2_368",
+        "book-ch2_462"
+      ]
+    },
+    {
+      "stem": "Which of the following is a disadvantage of using a diode biasing circuit?",
+      "answer": "It is less stable than other biasing techniques",
+      "kept": "book-ch1_504",
+      "dropped": [
+        "book-ch2_236",
+        "book-ch2_369",
+        "book-ch2_463"
+      ]
+    },
+    {
+      "stem": "What is the purpose of using a transistor biasing circuit?",
+      "answer": "To set the bias voltage",
+      "kept": "book-ch1_505",
+      "dropped": [
+        "book-ch2_237",
+        "book-ch2_370",
+        "book-ch2_464"
+      ]
+    },
+    {
+      "stem": "Which of the following biasing techniques is commonly used in Class AB amplifiers?",
+      "answer": "Diode biasing",
+      "kept": "book-ch1_506",
+      "dropped": [
+        "book-ch2_238",
+        "book-ch2_371",
+        "book-ch2_465"
+      ]
+    },
+    {
+      "stem": "How does the choice of biasing technique affect the power efficiency of the amplifier?",
+      "answer": "It can decrease power efficiency",
+      "kept": "book-ch1_507",
+      "dropped": [
+        "book-ch2_239",
+        "book-ch2_372",
+        "book-ch2_466"
+      ]
+    },
+    {
+      "stem": "What is the disadvantage of using an adjustable biasing network?",
+      "answer": "It is more complex than a fixed biasing network",
+      "kept": "book-ch1_508",
+      "dropped": [
+        "book-ch2_240",
+        "book-ch2_373",
+        "book-ch2_467"
+      ]
+    },
+    {
+      "stem": "Which of the following is a key consideration when selecting a biasing technique for the Class AB output stage?",
+      "answer": "Power efficiency",
+      "kept": "book-ch1_509",
+      "dropped": [
+        "book-ch2_241",
+        "book-ch2_374",
+        "book-ch2_468"
+      ]
+    },
+    {
+      "stem": "What is the primary application of power BJTs in amplifier circuits?",
+      "answer": "Power amplification",
+      "kept": "book-ch1_510",
+      "dropped": [
+        "book-ch2_242",
+        "book-ch2_375",
+        "book-ch2_469"
+      ]
+    },
+    {
+      "stem": "Which type of power BJT is more commonly used in power amplifier circuits?",
+      "answer": "NPN",
+      "kept": "book-ch1_511",
+      "dropped": [
+        "book-ch2_243",
+        "book-ch2_376",
+        "book-ch2_470"
+      ]
+    },
+    {
+      "stem": "What is the operating region of the power BJT?",
+      "answer": "Active",
+      "kept": "book-ch1_512",
+      "dropped": [
+        "book-ch2_244",
+        "book-ch2_377",
+        "book-ch2_471"
+      ]
+    },
+    {
+      "stem": "Which configuration is most commonly used for low-power amplifiers?",
+      "answer": "Class A",
+      "kept": "book-ch1_513",
+      "dropped": [
+        "book-ch2_245",
+        "book-ch2_378",
+        "book-ch2_472"
+      ]
+    },
+    {
+      "stem": "What is the main advantage of power BJTs over small signal BJTs?",
+      "answer": "Higher power handling capability",
+      "kept": "book-ch1_514",
+      "dropped": [
+        "book-ch2_246",
+        "book-ch2_379",
+        "book-ch2_473"
+      ]
+    },
+    {
+      "stem": "Which of the following is a common application of power BJTs?",
+      "answer": "Audio amplifiers",
+      "kept": "book-ch1_515",
+      "dropped": [
+        "book-ch2_247",
+        "book-ch2_380",
+        "book-ch2_474"
+      ]
+    },
+    {
+      "stem": "What is the primary purpose of switching amplifiers?",
+      "answer": "To improve efficiency",
+      "kept": "book-ch1_516",
+      "dropped": [
+        "book-ch2_248",
+        "book-ch2_381",
+        "book-ch2_475"
+      ]
+    },
+    {
+      "stem": "Which type of amplifier uses power MOSFETs to provide high efficiency?",
+      "answer": "Class D",
+      "kept": "book-ch1_517",
+      "dropped": [
+        "book-ch2_249",
+        "book-ch2_382",
+        "book-ch2_476"
+      ]
+    },
+    {
+      "stem": "Which of the following is not a technique used to improve the efficiency of power amplifiers?",
+      "answer": "Feedback amplifiers",
+      "kept": "book-ch1_518",
+      "dropped": [
+        "book-ch2_250",
+        "book-ch2_383",
+        "book-ch2_477"
+      ]
+    },
+    {
+      "stem": "What is the main disadvantage of power BJTs in amplifier circuits?",
+      "answer": "High heat dissipation",
+      "kept": "book-ch1_519",
+      "dropped": [
+        "book-ch2_251",
+        "book-ch2_384",
+        "book-ch2_478"
+      ]
+    },
+    {
+      "stem": "What is the primary function of power BJTs in amplifier circuits?",
+      "answer": "To provide high power gain and efficiency",
+      "kept": "book-ch1_520",
+      "dropped": [
+        "book-ch2_252",
+        "book-ch2_385",
+        "book-ch2_479"
+      ]
+    },
+    {
+      "stem": "Which of the following is a commonly used configuration for power BJTs in low-power amplifiers?",
+      "answer": "Class A",
+      "kept": "book-ch1_521",
+      "dropped": [
+        "book-ch2_253",
+        "book-ch2_386",
+        "book-ch2_480"
+      ]
+    },
+    {
+      "stem": "Which type of power BJT is commonly used in power amplifier circuits?",
+      "answer": "NPN",
+      "kept": "book-ch1_522",
+      "dropped": [
+        "book-ch2_254",
+        "book-ch2_387",
+        "book-ch2_481"
+      ]
+    },
+    {
+      "stem": "In which region of operation does the power BJT operate?",
+      "answer": "Active region",
+      "kept": "book-ch1_523",
+      "dropped": [
+        "book-ch2_255",
+        "book-ch2_388",
+        "book-ch2_482"
+      ]
+    },
+    {
+      "stem": "Which of the following is a technique used to improve the efficiency of power amplifiers?",
+      "answer": "Switching amplifiers",
+      "kept": "book-ch1_524",
+      "dropped": [
+        "book-ch2_256",
+        "book-ch2_389",
+        "book-ch2_483"
+      ]
+    },
+    {
+      "stem": "Which of the following is an application of power BJTs?",
+      "answer": "Audio amplifiers",
+      "kept": "book-ch1_525",
+      "dropped": [
+        "book-ch2_257",
+        "book-ch2_390",
+        "book-ch2_484"
+      ]
+    },
+    {
+      "stem": "What is the primary difference between small signal BJTs and power BJTs?",
+      "answer": "High power handling capability",
+      "kept": "book-ch1_526",
+      "dropped": [
+        "book-ch2_258",
+        "book-ch2_391",
+        "book-ch2_485"
+      ]
+    },
+    {
+      "stem": "Which type of power BJT has a higher current gain?",
+      "answer": "NPN",
+      "kept": "book-ch1_527",
+      "dropped": [
+        "book-ch2_259",
+        "book-ch2_392",
+        "book-ch2_486"
+      ]
+    },
+    {
+      "stem": "Which of the following is a benefit of using power BJTs in amplifier circuits?",
+      "answer": "High power gain",
+      "kept": "book-ch1_528",
+      "dropped": [
+        "book-ch2_260",
+        "book-ch2_393",
+        "book-ch2_487"
+      ]
+    },
+    {
+      "stem": "Which of the following amplifier configurations is commonly used in high-power amplifiers?",
+      "answer": "Class D",
+      "kept": "book-ch1_529",
+      "dropped": [
+        "book-ch2_261",
+        "book-ch2_394",
+        "book-ch2_488"
+      ]
+    },
+    {
+      "stem": "In a transformer-coupled push-pull amplifier, the primary winding of the output transformer is connected to:",
+      "answer": "The collector of both transistors",
+      "kept": "book-ch1_530",
+      "dropped": [
+        "book-ch2_262",
+        "book-ch2_395",
+        "book-ch2_489"
+      ]
+    },
+    {
+      "stem": "The transformer in a transformer-coupled push-pull amplifier is used to:",
+      "answer": "Provide impedance matching between the driver and output stages",
+      "kept": "book-ch1_531",
+      "dropped": [
+        "book-ch2_263",
+        "book-ch2_396",
+        "book-ch2_490"
+      ]
+    },
+    {
+      "stem": "In a transformer-coupled push-pull amplifier, the two output transistors are biased so that they conduct:",
+      "answer": "Alternately",
+      "kept": "book-ch1_532",
+      "dropped": [
+        "book-ch2_264",
+        "book-ch2_397",
+        "book-ch2_491"
+      ]
+    },
+    {
+      "stem": "Which of the following is an advantage of a transformer-coupled push-pull amplifier?",
+      "answer": "All of the above",
+      "kept": "book-ch1_533",
+      "dropped": [
+        "book-ch2_265",
+        "book-ch2_398",
+        "book-ch2_492"
+      ]
+    },
+    {
+      "stem": "The output of a transformer-coupled push-pull amplifier is taken from:",
+      "answer": "The secondary winding of the output transformer",
+      "kept": "book-ch1_534",
+      "dropped": [
+        "book-ch2_266",
+        "book-ch2_399",
+        "book-ch2_493"
+      ]
+    },
+    {
+      "stem": "The load impedance in a transformer-coupled push-pull amplifier is:",
+      "answer": "Always equal to the output impedance of the amplifier",
+      "kept": "book-ch1_535",
+      "dropped": [
+        "book-ch2_267",
+        "book-ch2_400",
+        "book-ch2_494"
+      ]
+    },
+    {
+      "stem": "The DC bias voltage for the output transistors in a transformer-coupled push-pull amplifier is provided by:",
+      "answer": "A separate bias circuit",
+      "kept": "book-ch1_536",
+      "dropped": [
+        "book-ch2_268",
+        "book-ch2_401",
+        "book-ch2_495"
+      ]
+    },
+    {
+      "stem": "The crossover distortion in a transformer-coupled push-pull amplifier is caused by:",
+      "answer": "The mismatch between the two output transistors",
+      "kept": "book-ch1_537",
+      "dropped": [
+        "book-ch2_269",
+        "book-ch2_402",
+        "book-ch2_496"
+      ]
+    },
+    {
+      "stem": "The transformer in a transformer-coupled push-pull amplifier is usually:",
+      "answer": "A step-down transformer",
+      "kept": "book-ch1_538",
+      "dropped": [
+        "book-ch2_270",
+        "book-ch2_403",
+        "book-ch2_497"
+      ]
+    },
+    {
+      "stem": "In a transformer-coupled push-pull amplifier, the output transistors are typically:",
+      "answer": "None of the above",
+      "kept": "book-ch1_539",
+      "dropped": [
+        "book-ch2_271",
+        "book-ch2_404",
+        "book-ch2_498"
+      ]
+    },
+    {
+      "stem": "In a transformer-coupled push-pull stage, two identical transistors are used with one conducting during the positive half-cycle of the input signal and the othe",
+      "answer": "All of the above",
+      "kept": "book-ch1_540",
+      "dropped": [
+        "book-ch2_272",
+        "book-ch2_405",
+        "book-ch2_499"
+      ]
+    },
+    {
+      "stem": "Which of the following statements about the transformer-coupled push-pull stage is true?",
+      "answer": "It is commonly used in audio power amplifiers",
+      "kept": "book-ch1_541",
+      "dropped": [
+        "book-ch2_273",
+        "book-ch2_406",
+        "book-ch2_500"
+      ]
+    },
+    {
+      "stem": "The transformer in a transformer-coupled push-pull stage is used to:",
+      "answer": "Provide impedance matching between the amplifier and the load",
+      "kept": "book-ch1_542",
+      "dropped": [
+        "book-ch2_274",
+        "book-ch2_407",
+        "book-ch2_501"
+      ]
+    },
+    {
+      "stem": "In a transformer-coupled push-pull stage, the transformer is typically wound with a center-tapped secondary winding. What is the purpose of the center tap?",
+      "answer": "To provide a reference voltage for biasing the transistors",
+      "kept": "book-ch1_543",
+      "dropped": [
+        "book-ch2_275",
+        "book-ch2_408",
+        "book-ch2_502"
+      ]
+    },
+    {
+      "stem": "The transformer-coupled push-pull stage is a type of:",
+      "answer": "Class B amplifier",
+      "kept": "book-ch1_544",
+      "dropped": [
+        "book-ch2_276",
+        "book-ch2_409",
+        "book-ch2_503"
+      ]
+    },
+    {
+      "stem": "Which of the following is an advantage of using a transformer-coupled push-pull stage over a single-ended output stage?",
+      "answer": "All of the above",
+      "kept": "book-ch1_545",
+      "dropped": [
+        "book-ch2_277",
+        "book-ch2_410",
+        "book-ch2_504"
+      ]
+    },
+    {
+      "stem": "The output of a transformer-coupled push-pull stage is taken from:",
+      "answer": "The center tap of the transformer secondary winding",
+      "kept": "book-ch1_546",
+      "dropped": [
+        "book-ch2_278",
+        "book-ch2_411",
+        "book-ch2_505"
+      ]
+    },
+    {
+      "stem": "What is the main disadvantage of a transformer-coupled push-pull stage compared to other output stage configurations?",
+      "answer": "Limited frequency response",
+      "kept": "book-ch1_547",
+      "dropped": [
+        "book-ch2_279",
+        "book-ch2_412",
+        "book-ch2_506"
+      ]
+    },
+    {
+      "stem": "The transformer in a transformer-coupled push-pull stage should be designed with:",
+      "answer": "Low leakage inductance",
+      "kept": "book-ch1_548",
+      "dropped": [
+        "book-ch2_280",
+        "book-ch2_413",
+        "book-ch2_507"
+      ]
+    },
+    {
+      "stem": "What is the main advantage of using a transformer in a push-pull output stage?",
+      "answer": "Impedance matching to the load",
+      "kept": "book-ch1_549",
+      "dropped": [
+        "book-ch2_281",
+        "book-ch2_414",
+        "book-ch2_508"
+      ]
+    },
+    {
+      "stem": "What is the basic function of a tuned amplifier?",
+      "answer": "To provide high selectivity and gain",
+      "kept": "book-ch1_550",
+      "dropped": [
+        "book-ch2_415",
+        "book-ch2_509"
+      ]
+    },
+    {
+      "stem": "Which type of resonant circuit is typically used in tuned amplifiers?",
+      "answer": "LC circuits",
+      "kept": "book-ch1_551",
+      "dropped": [
+        "book-ch2_416",
+        "book-ch2_510"
+      ]
+    },
+    {
+      "stem": "What is the Q factor of a resonant circuit?",
+      "answer": "The ratio of energy stored in the circuit to energy lost per cycle",
+      "kept": "book-ch1_552",
+      "dropped": [
+        "book-ch1_562",
+        "book-ch2_417",
+        "book-ch2_427",
+        "book-ch2_511",
+        "book-ch2_521"
+      ]
+    },
+    {
+      "stem": "What is the difference between a single tuned amplifier and a double tuned amplifier?",
+      "answer": "A single tuned amplifier uses one resonant circuit, while a double tuned amplifier uses two.",
+      "kept": "book-ch1_553",
+      "dropped": [
+        "book-ch1_560",
+        "book-ch2_418",
+        "book-ch2_425",
+        "book-ch2_512",
+        "book-ch2_519"
+      ]
+    },
+    {
+      "stem": "Which type of amplifier is commonly used in radio receivers and transmitters?",
+      "answer": "Tuned amplifier",
+      "kept": "book-ch1_554",
+      "dropped": [
+        "book-ch2_419",
+        "book-ch2_513"
+      ]
+    },
+    {
+      "stem": "Which electronic device can be used as the active element in a tuned amplifier?",
+      "answer": "Transistor",
+      "kept": "book-ch1_555",
+      "dropped": [
+        "book-ch2_420",
+        "book-ch2_514"
+      ]
+    },
+    {
+      "stem": "What is the function of the Q multiplier in a tuned amplifier?",
+      "answer": "To provide additional gain at the center frequency of the circuit",
+      "kept": "book-ch1_556",
+      "dropped": [
+        "book-ch2_421",
+        "book-ch2_515"
+      ]
+    },
+    {
+      "stem": "What is a tuned amplifier?",
+      "answer": "An amplifier that uses tuned circuits to achieve high selectivity and gain",
+      "kept": "book-ch1_557",
+      "dropped": [
+        "book-ch2_422",
+        "book-ch2_516"
+      ]
+    },
+    {
+      "stem": "What type of resonant circuits are used in tuned amplifiers?",
+      "answer": "LC circuits",
+      "kept": "book-ch1_558",
+      "dropped": [
+        "book-ch2_423",
+        "book-ch2_517"
+      ]
+    },
+    {
+      "stem": "Which of the following is a key factor in determining the gain and selectivity of a tuned amplifier?",
+      "answer": "The Q factor of the resonant circuits",
+      "kept": "book-ch1_559",
+      "dropped": [
+        "book-ch2_424",
+        "book-ch2_518"
+      ]
+    },
+    {
+      "stem": "Where are tuned amplifiers commonly used?",
+      "answer": "In radio receivers and transmitters",
+      "kept": "book-ch1_561",
+      "dropped": [
+        "book-ch2_426",
+        "book-ch2_520"
+      ]
+    },
+    {
+      "stem": "Which type of amplifying device can be used in tuned amplifiers?",
+      "answer": "All of the above",
+      "kept": "book-ch1_563",
+      "dropped": [
+        "book-ch2_428",
+        "book-ch2_522"
+      ]
+    },
+    {
+      "stem": "What is the purpose of a tuned amplifier in a radio receiver?",
+      "answer": "To amplify only the desired signal while rejecting other signals",
+      "kept": "book-ch1_564",
+      "dropped": [
+        "book-ch2_429",
+        "book-ch2_523"
+      ]
+    },
+    {
+      "stem": "What is the main advantage of a double tuned amplifier over a single tuned amplifier?",
+      "answer": "Higher selectivity",
+      "kept": "book-ch1_565",
+      "dropped": [
+        "book-ch2_430",
+        "book-ch2_524"
+      ]
+    },
+    {
+      "stem": "Which of the following is a disadvantage of tuned amplifiers?",
+      "answer": "They can be difficult to tune and adjust.",
+      "kept": "book-ch1_566",
+      "dropped": [
+        "book-ch2_431",
+        "book-ch2_525"
+      ]
+    },
+    {
+      "stem": "What does op-amp stand for?",
+      "answer": "Operational amplifier",
+      "kept": "book-ch1_567",
+      "dropped": [
+        "book-ch2_432",
+        "book-ch2_526"
+      ]
+    },
+    {
+      "stem": "Which configuration is most commonly used in op-amp circuits?",
+      "answer": "Inverting amplifier",
+      "kept": "book-ch1_568",
+      "dropped": [
+        "book-ch2_433",
+        "book-ch2_527"
+      ]
+    },
+    {
+      "stem": "What is the gain of an inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
+      "answer": "-10",
+      "kept": "book-ch1_569",
+      "dropped": [
+        "book-ch2_434",
+        "book-ch2_528"
+      ]
+    },
+    {
+      "stem": "Which parameter determines the maximum output voltage swing of an op-amp?",
+      "answer": "Output saturation voltage",
+      "kept": "book-ch1_570",
+      "dropped": [
+        "book-ch2_435",
+        "book-ch2_529"
+      ]
+    },
+    {
+      "stem": "What is the purpose of a voltage follower op-amp circuit?",
+      "answer": "To buffer a signal",
+      "kept": "book-ch1_571",
+      "dropped": [
+        "book-ch2_436",
+        "book-ch2_530"
+      ]
+    },
+    {
+      "stem": "What is the transfer function of a non-inverting amplifier with a feedback resistor of 10 kΩ and an input resistor of 1 kΩ?",
+      "answer": "Vout = (1 + 10kΩ/1kΩ)Vin",
+      "kept": "book-ch1_572",
+      "dropped": [
+        "book-ch2_437",
+        "book-ch2_531"
+      ]
+    },
+    {
+      "stem": "Which op-amp parameter determines the rate at which the output can change in response to changes in the input?",
+      "answer": "Slew rate",
+      "kept": "book-ch1_573",
+      "dropped": [
+        "book-ch2_438",
+        "book-ch2_532"
+      ]
+    },
+    {
+      "stem": "What is the purpose of a differential amplifier?",
+      "answer": "To amplify the difference between two input signals",
+      "kept": "book-ch1_574",
+      "dropped": [
+        "book-ch2_439",
+        "book-ch2_533"
+      ]
+    },
+    {
+      "stem": "Which op-amp configuration is used to perform mathematical operations, such as addition and subtraction?",
+      "answer": "Summing amplifier",
+      "kept": "book-ch1_575",
+      "dropped": [
+        "book-ch2_440",
+        "book-ch2_534"
+      ]
+    },
+    {
+      "stem": "What is the output voltage of an inverting amplifier with an input voltage of 2 V and a feedback resistor of 10 kΩ, assuming an ideal op-amp?",
+      "answer": "-20 V",
+      "kept": "book-ch1_576",
+      "dropped": [
+        "book-ch2_442",
+        "book-ch2_536"
+      ]
+    },
+    {
+      "stem": "Which of the following is a characteristic of an ideal operational amplifier?",
+      "answer": "All of the above",
+      "kept": "book-ch1_577",
+      "dropped": [
+        "book-ch2_441",
+        "book-ch2_535"
+      ]
+    },
+    {
+      "stem": "Which of the following is not a type of operational amplifier?",
+      "answer": "Power amplifier",
+      "kept": "book-ch1_578",
+      "dropped": [
+        "book-ch2_443",
+        "book-ch2_537"
+      ]
+    },
+    {
+      "stem": "What is the function of a summing amplifier?",
+      "answer": "To sum multiple input signals and provide an amplified output signal",
+      "kept": "book-ch1_579",
+      "dropped": [
+        "book-ch2_444",
+        "book-ch2_538"
+      ]
+    },
+    {
+      "stem": "What is the output voltage of an inverting amplifier with a gain of -10 if the input voltage is 2V?",
+      "answer": "-20V",
+      "kept": "book-ch1_580",
+      "dropped": [
+        "book-ch2_445",
+        "book-ch2_539"
+      ]
+    },
+    {
+      "stem": "What is the function of a voltage follower?",
+      "answer": "To provide unity gain and high input and output impedances",
+      "kept": "book-ch1_581",
+      "dropped": [
+        "book-ch2_446",
+        "book-ch2_540"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using an op-amp as a comparator?",
+      "answer": "It has a very high gain",
+      "kept": "book-ch1_582",
+      "dropped": [
+        "book-ch2_447",
+        "book-ch2_541"
+      ]
+    },
+    {
+      "stem": "What is the function of a differentiator circuit?",
+      "answer": "To differentiate the input signal with respect to time",
+      "kept": "book-ch1_583",
+      "dropped": [
+        "book-ch2_448",
+        "book-ch2_542"
+      ]
+    },
+    {
+      "stem": "What is the function of an integrator circuit?",
+      "answer": "To integrate the input signal with respect to time",
+      "kept": "book-ch1_584",
+      "dropped": [
+        "book-ch2_449",
+        "book-ch2_543"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using a non-inverting amplifier instead of an inverting amplifier?",
+      "answer": "The input signal is not inverted",
+      "kept": "book-ch1_585",
+      "dropped": [
+        "book-ch2_450",
+        "book-ch2_544"
+      ]
+    },
+    {
+      "stem": "What is the function of a Schmitt trigger circuit?",
+      "answer": "To provide hysteresis to a signal",
+      "kept": "book-ch1_586",
+      "dropped": [
+        "book-ch2_451",
+        "book-ch2_545"
+      ]
+    },
+    {
+      "stem": "Which of the following is a Boolean operator?",
+      "answer": "/",
+      "kept": "book-ch2_53",
+      "dropped": [
+        "book-ch2_282"
+      ]
+    },
+    {
+      "stem": "What is the Boolean expression for the OR gate?",
+      "answer": "A+B",
+      "kept": "book-ch2_54",
+      "dropped": [
+        "book-ch2_283"
+      ]
+    },
+    {
+      "stem": "What is the Boolean expression for the AND gate?",
+      "answer": "A*B",
+      "kept": "book-ch2_55",
+      "dropped": [
+        "book-ch2_284"
+      ]
+    },
+    {
+      "stem": "What is the Boolean expression for the NOT gate?",
+      "answer": "A'",
+      "kept": "book-ch2_56",
+      "dropped": [
+        "book-ch2_285"
+      ]
+    },
+    {
+      "stem": "Which of the following is an example of a Boolean equation?",
+      "answer": "y=xAND2",
+      "kept": "book-ch2_57",
+      "dropped": [
+        "book-ch2_286"
+      ]
+    },
+    {
+      "stem": "Which of the following is a Boolean identity?",
+      "answer": "A+0=A",
+      "kept": "book-ch2_58",
+      "dropped": [
+        "book-ch2_287"
+      ]
+    },
+    {
+      "stem": "Which of the following is a Boolean simplification rule?",
+      "answer": "A+B=B+A",
+      "kept": "book-ch2_59",
+      "dropped": [
+        "book-ch2_288"
+      ]
+    },
+    {
+      "stem": "What is the result of the Boolean operation A OR (B AND C)?",
+      "answer": "A+B*C",
+      "kept": "book-ch2_60",
+      "dropped": [
+        "book-ch2_289"
+      ]
+    },
+    {
+      "stem": "What is the result of the Boolean operation (A OR B) AND (A OR C)?",
+      "answer": "A+B+C",
+      "kept": "book-ch2_61",
+      "dropped": [
+        "book-ch2_290"
+      ]
+    },
+    {
+      "stem": "What is the Boolean expression for the exclusive-OR (XOR) gate?",
+      "answer": "AB",
+      "kept": "book-ch2_62",
+      "dropped": [
+        "book-ch2_291"
+      ]
+    },
+    {
+      "stem": "What is Boolean algebra?",
+      "answer": "A branch of mathematics that deals with Boolean functions",
+      "kept": "book-ch2_63",
+      "dropped": [
+        "book-ch2_292"
+      ]
+    },
+    {
+      "stem": "What is a Boolean variable?",
+      "answer": "A variable that can only take on two values, true or false",
+      "kept": "book-ch2_64",
+      "dropped": [
+        "book-ch2_293"
+      ]
+    },
+    {
+      "stem": "What is a Boolean expression?",
+      "answer": "A mathematical expression that uses Boolean variables, operators, and constants",
+      "kept": "book-ch2_65",
+      "dropped": [
+        "book-ch2_294"
+      ]
+    },
+    {
+      "stem": "Which Boolean operator represents logical AND?",
+      "answer": ".",
+      "kept": "book-ch2_66",
+      "dropped": [
+        "book-ch2_295"
+      ]
+    },
+    {
+      "stem": "Which Boolean operator represents logical OR?",
+      "answer": "+",
+      "kept": "book-ch2_67",
+      "dropped": [
+        "book-ch2_296"
+      ]
+    },
+    {
+      "stem": "Which Boolean operator represents logical NOT?",
+      "answer": "'",
+      "kept": "book-ch2_68",
+      "dropped": [
+        "book-ch2_297"
+      ]
+    },
+    {
+      "stem": "What is the complement of A in Boolean algebra?",
+      "answer": "A'",
+      "kept": "book-ch2_69",
+      "dropped": [
+        "book-ch2_298"
+      ]
+    },
+    {
+      "stem": "What is the simplified expression for A + AB?",
+      "answer": "A",
+      "kept": "book-ch2_70",
+      "dropped": [
+        "book-ch2_299"
+      ]
+    },
+    {
+      "stem": "What is the simplified expression for AB + A'B?",
+      "answer": "AB'",
+      "kept": "book-ch2_71",
+      "dropped": [
+        "book-ch2_300"
+      ]
+    },
+    {
+      "stem": "What is the Sum-of-Products (SOP) method in digital logic?",
+      "answer": "A technique used to simplify Boolean expressions",
+      "kept": "book-ch2_72",
+      "dropped": [
+        "book-ch2_301"
+      ]
+    },
+    {
+      "stem": "What is the first step in using the SOP method to simplify a Boolean expression?",
+      "answer": "Write the expression in standard form",
+      "kept": "book-ch2_73",
+      "dropped": [
+        "book-ch2_302"
+      ]
+    },
+    {
+      "stem": "What are the Boolean operators used in the standard form of a Boolean expression?",
+      "answer": "AND, OR, and NOT",
+      "kept": "book-ch2_74",
+      "dropped": [
+        "book-ch2_303"
+      ]
+    },
+    {
+      "stem": "In the SOP method, what is the next step after creating a truth table for the Boolean expression?",
+      "answer": "Identify the rows where the expression evaluates to 1",
+      "kept": "book-ch2_75",
+      "dropped": [
+        "book-ch2_304"
+      ]
+    },
+    {
+      "stem": "What is the final step in using the SOP method to simplify a Boolean expression?",
+      "answer": "Combine the rows with an OR operator",
+      "kept": "book-ch2_76",
+      "dropped": [
+        "book-ch2_305"
+      ]
+    },
+    {
+      "stem": "Which of the following is an example of a Boolean expression that can be simplified using the SOP method?",
+      "answer": "F=AB+A'B+AB'",
+      "kept": "book-ch2_77",
+      "dropped": [
+        "book-ch2_306"
+      ]
+    },
+    {
+      "stem": "How many rows are in the truth table for a Boolean expression with two input variables?",
+      "answer": "4",
+      "kept": "book-ch2_78",
+      "dropped": [
+        "book-ch2_307"
+      ]
+    },
+    {
+      "stem": "What is the purpose of the SOP method in digital logic?",
+      "answer": "To simplify complex Boolean expressions",
+      "kept": "book-ch2_79",
+      "dropped": [
+        "book-ch2_308"
+      ]
+    },
+    {
+      "stem": "What is the meaning of \"sum of products\" in the SOP method?",
+      "answer": "The sum of the rows in the truth table where the expression evaluates to 1",
+      "kept": "book-ch2_80",
+      "dropped": [
+        "book-ch2_309"
+      ]
+    },
+    {
+      "stem": "What is the Sum-of-Products (SOP) method used for in digital logic?",
+      "answer": "To simplify a given Boolean expression",
+      "kept": "book-ch2_81",
+      "dropped": [
+        "book-ch2_310"
+      ]
+    },
+    {
+      "stem": "What is the first step when using the SOP method to simplify a Boolean expression?",
+      "answer": "Write the expression in the standard form",
+      "kept": "book-ch2_82",
+      "dropped": [
+        "book-ch2_311"
+      ]
+    },
+    {
+      "stem": "What is the standard form of a Boolean expression?",
+      "answer": "A form with parentheses and Boolean operators",
+      "kept": "book-ch2_83",
+      "dropped": [
+        "book-ch2_312"
+      ]
+    },
+    {
+      "stem": "How do you identify the rows in a truth table where the expression evaluates to 1 when using the SOP method?",
+      "answer": "Identify the rows where the expression is true",
+      "kept": "book-ch2_84",
+      "dropped": [
+        "book-ch2_313"
+      ]
+    },
+    {
+      "stem": "In the SOP method, what is the next step after identifying the rows where the expression evaluates to 1?",
+      "answer": "Write down each row in terms of the input variables",
+      "kept": "book-ch2_85",
+      "dropped": [
+        "book-ch2_314"
+      ]
+    },
+    {
+      "stem": "What Boolean operator is used to combine the rows in the SOP method?",
+      "answer": "OR",
+      "kept": "book-ch2_86",
+      "dropped": [
+        "book-ch2_315"
+      ]
+    },
+    {
+      "stem": "What is the final result of the SOP method?",
+      "answer": "A simplified sum of products expression",
+      "kept": "book-ch2_87",
+      "dropped": [
+        "book-ch2_316"
+      ]
+    },
+    {
+      "stem": "How is a row with a value of 0 represented in the SOP method?",
+      "answer": "With the complement of the corresponding variable",
+      "kept": "book-ch2_88",
+      "dropped": [
+        "book-ch2_317"
+      ]
+    },
+    {
+      "stem": "What is the main advantage of using the SOP method to simplify Boolean expressions?",
+      "answer": "It results in a more efficient circuit design",
+      "kept": "book-ch2_89",
+      "dropped": [
+        "book-ch2_318"
+      ]
+    },
+    {
+      "stem": "Can the SOP method be used to simplify any Boolean expression?",
+      "answer": "Yes, it can be used for any expression",
+      "kept": "book-ch2_90",
+      "dropped": [
+        "book-ch2_319"
+      ]
+    },
+    {
+      "stem": "What is the Product-of-Sums (POS) method used for in digital logic?",
+      "answer": "Simplifying Boolean expressions",
+      "kept": "book-ch2_91",
+      "dropped": [
+        "book-ch2_320"
+      ]
+    },
+    {
+      "stem": "In the POS method, what is the first step in simplifying a Boolean expression?",
+      "answer": "Write the expression in the standard form",
+      "kept": "book-ch2_92",
+      "dropped": [
+        "book-ch2_321"
+      ]
+    },
+    {
+      "stem": "In the POS method, what is the second step in simplifying a Boolean expression?",
+      "answer": "Identify the rows of the truth table where the expression evaluates to 0",
+      "kept": "book-ch2_93",
+      "dropped": [
+        "book-ch2_322"
+      ]
+    },
+    {
+      "stem": "What is the final result of applying the POS method to a Boolean expression?",
+      "answer": "A simplified product of sums expression",
+      "kept": "book-ch2_94",
+      "dropped": [
+        "book-ch2_323"
+      ]
+    },
+    {
+      "stem": "In the POS method, how are the rows of the truth table where the expression evaluates to 0 combined?",
+      "answer": "Using OR operators",
+      "kept": "book-ch2_95",
+      "dropped": [
+        "book-ch2_324"
+      ]
+    },
+    {
+      "stem": "When is the POS method particularly useful?",
+      "answer": "When the expression contains many terms",
+      "kept": "book-ch2_96",
+      "dropped": [
+        "book-ch2_325"
+      ]
+    },
+    {
+      "stem": "To complement a Boolean expression using the POS method, what must be done to the final result?",
+      "answer": "It must be inverted",
+      "kept": "book-ch2_97",
+      "dropped": [
+        "book-ch2_326"
+      ]
+    },
+    {
+      "stem": "Which of the following is a benefit of using the POS method in digital logic?",
+      "answer": "It reduces the size and complexity of digital circuits",
+      "kept": "book-ch2_98",
+      "dropped": [
+        "book-ch2_327"
+      ]
+    },
+    {
+      "stem": "What is the Product-of-Sums method in digital logic?",
+      "answer": "A method for simplifying Boolean expressions by combining products of variables",
+      "kept": "book-ch2_99",
+      "dropped": [
+        "book-ch2_328"
+      ]
+    },
+    {
+      "stem": "What is the dual of the Product-of-Sums method?",
+      "answer": "Sum-of-Products method",
+      "kept": "book-ch2_100",
+      "dropped": [
+        "book-ch2_329"
+      ]
+    },
+    {
+      "stem": "What is the first step in the Product-of-Sums method?",
+      "answer": "Identify the rows where the expression evaluates to 0",
+      "kept": "book-ch2_101",
+      "dropped": [
+        "book-ch2_330"
+      ]
+    },
+    {
+      "stem": "What is the second step in the Product-of-Sums method?",
+      "answer": "Write the expression in terms of the input variables",
+      "kept": "book-ch2_102",
+      "dropped": [
+        "book-ch2_331"
+      ]
+    },
+    {
+      "stem": "What is the final step in the Product-of-Sums method?",
+      "answer": "Combine the rows using OR operators",
+      "kept": "book-ch2_103",
+      "dropped": [
+        "book-ch2_332"
+      ]
+    },
+    {
+      "stem": "Which of the following is an advantage of using the Product-of-Sums method?",
+      "answer": "It is easier to understand than other simplification methods",
+      "kept": "book-ch2_104",
+      "dropped": [
+        "book-ch2_333"
+      ]
+    },
+    {
+      "stem": "What is the purpose of applying the Product-of-Sums method to the complement of an expression?",
+      "answer": "To generate a simplified expression that is the complement of the original expression",
+      "kept": "book-ch2_105",
+      "dropped": [
+        "book-ch2_334"
+      ]
+    },
+    {
+      "stem": "Which of the following is true about the Product-of-Sums method?",
+      "answer": "It can be used with any type of variable",
+      "kept": "book-ch2_106",
+      "dropped": [
+        "book-ch2_335"
+      ]
+    },
+    {
+      "stem": "What is the advantage of using the Product-of-Sums method over the Sum-of-Products method?",
+      "answer": "The resulting expression is shorter and requires fewer gates",
+      "kept": "book-ch2_107",
+      "dropped": [
+        "book-ch2_336"
+      ]
+    },
+    {
+      "stem": "Which of the following is an application of the Product-of-Sums method?",
+      "answer": "Simplifying Boolean expressions in digital circuits",
+      "kept": "book-ch2_108",
+      "dropped": [
+        "book-ch2_337"
+      ]
+    },
+    {
+      "stem": "Which of the following is a graphical tool used to simplify Boolean expressions?",
+      "answer": "Karnaugh map",
+      "kept": "book-ch2_109",
+      "dropped": [
+        "book-ch2_338"
+      ]
+    },
+    {
+      "stem": "How are cells identified in a Karnaugh map?",
+      "answer": "By their input variable combinations",
+      "kept": "book-ch2_110",
+      "dropped": [
+        "book-ch2_339"
+      ]
+    },
+    {
+      "stem": "In the Karnaugh map, which cells can be combined to form a simplified expression?",
+      "answer": "Adjacent cells",
+      "kept": "book-ch2_111",
+      "dropped": [
+        "book-ch2_340"
+      ]
+    },
+    {
+      "stem": "What does SOP stand for in the context of digital logic?",
+      "answer": "Sum of Products",
+      "kept": "book-ch2_112",
+      "dropped": [
+        "book-ch2_341"
+      ]
+    },
+    {
+      "stem": "Which of the following is true for the cells of a Karnaugh map?",
+      "answer": "Each cell can only contain a 0 or a 1",
+      "kept": "book-ch2_113",
+      "dropped": [
+        "book-ch2_342"
+      ]
+    },
+    {
+      "stem": "What is a Karnaugh map used for?",
+      "answer": "To simplify Boolean expressions",
+      "kept": "book-ch2_114",
+      "dropped": [
+        "book-ch2_343"
+      ]
+    },
+    {
+      "stem": "How many cells does a Karnaugh map have if the corresponding Boolean expression has three input variables?",
+      "answer": "8",
+      "kept": "book-ch2_115",
+      "dropped": [
+        "book-ch2_344"
+      ]
+    },
+    {
+      "stem": "How are adjacent cells identified in a Karnaugh map?",
+      "answer": "Both b and c",
+      "kept": "book-ch2_117",
+      "dropped": [
+        "book-ch2_346"
+      ]
+    },
+    {
+      "stem": "Which of the following is a simplified expression for the Karnaugh map shown below?",
+      "answer": "AB + CD",
+      "kept": "book-ch2_118",
+      "dropped": [
+        "book-ch2_347"
+      ]
+    },
+    {
+      "stem": "How is a truth table converted into a Karnaugh map?",
+      "answer": "By plotting the input and output values on a grid",
+      "kept": "book-ch2_119",
+      "dropped": [
+        "book-ch2_348"
+      ]
+    },
+    {
+      "stem": "Which of the following Boolean expressions is equivalent to the Karnaugh map shown below?",
+      "answer": "AB + CD",
+      "kept": "book-ch2_120",
+      "dropped": [
+        "book-ch2_349"
+      ]
+    },
+    {
+      "stem": "How many cells in a Karnaugh map can be combined to form a simplified expression?",
+      "answer": "Both A and B",
+      "kept": "book-ch2_121",
+      "dropped": [
+        "book-ch2_350"
+      ]
+    },
+    {
+      "stem": "How is a simplified expression converted back into a standard SOP or POS expression?",
+      "answer": "Both A and B",
+      "kept": "book-ch2_122",
+      "dropped": [
+        "book-ch2_351"
+      ]
+    },
+    {
+      "stem": "How can you reverse a string in C programming?",
+      "answer": "By using a loop and swapping characters",
+      "kept": "book-ch3_82",
+      "dropped": [
+        "book-ch3_88"
+      ]
+    },
+    {
+      "stem": "If 'ptr' is a pointer to an integer variable, what will be the output of the following code? printf(\"%d\", ptr+1);",
+      "answer": "The value of the integer variable ptr+1 is pointing to",
+      "kept": "book-ch3_104",
+      "dropped": [
+        "book-ch3_105"
+      ]
+    },
+    {
+      "stem": "Which of the following is the correct way to access a structure member using a pointer to a structure?",
+      "answer": "structure_pointer->member_name",
+      "kept": "book-ch3_138",
+      "dropped": [
+        "book-ch3_192"
+      ]
+    },
+    {
+      "stem": "What is the difference between passing a structure by value and passing a structure by pointer in C?",
+      "answer": "When a structure is passed by value, any modifications made to it in the function are lost when the function returns. When a structure is passed by pointer, the modifications are retained.",
+      "kept": "book-ch3_139",
+      "dropped": [
+        "book-ch3_193"
+      ]
+    },
+    {
+      "stem": "Which keyword is used to define a namespace in C++?",
+      "answer": "namespace",
+      "kept": "book-ch3_195",
+      "dropped": [
+        "book-ch3_205"
+      ]
+    },
+    {
+      "stem": "Which of the following is true about friend functions in C++?",
+      "answer": "Friend functions can access private and protected members of a class",
+      "kept": "book-ch3_272",
+      "dropped": [
+        "book-ch3_312"
+      ]
+    },
+    {
+      "stem": "How is a constant member function declared in C++?",
+      "answer": "Using the keyword const after the function declaration",
+      "kept": "book-ch3_382",
+      "dropped": [
+        "book-ch3_390"
+      ]
+    },
+    {
+      "stem": "A semaphore is used for:",
+      "answer": "Process synchronization",
+      "kept": "book-ch4_24",
+      "dropped": [
+        "book-ch7_45"
+      ]
+    },
+    {
+      "stem": "Which of the following is not a component of a control unit?",
+      "answer": "Arithmetic logic unit",
+      "kept": "book-ch4_90",
+      "dropped": [
+        "book-ch4_95"
+      ]
+    },
+    {
+      "stem": "What is the purpose of DMA in a computer system?",
+      "answer": "To transfer data between memory and peripheral devices",
+      "kept": "book-ch4_261",
+      "dropped": [
+        "book-ch4_271"
+      ]
+    },
+    {
+      "stem": "The testing in which code is checked",
+      "answer": "White box testing",
+      "kept": "book-ch8_72",
+      "dropped": [
+        "book-ch8_89"
+      ]
+    },
+    {
+      "stem": "Sinking fund is",
+      "answer": "The fund for rebuilding a structure when its economic life is over",
+      "kept": "book-ch10_153",
+      "dropped": [
+        "book-ch10_171"
+      ]
+    },
+    {
+      "stem": "Resource smoothing is",
+      "answer": "An adjustment of resources without affecting project duration",
+      "kept": "book-ch10_155",
+      "dropped": [
+        "book-ch10_176"
+      ]
+    }
+  ],
+  "appliedResolutions": {
+    "appliedOn": "2026-10-20",
+    "authority": "Project owner instructed that the 13 recorded resolutions be applied. Each arithmetic or physics claim was re-derived before the edit, and every edit asserted the row still matched the state the resolution assumed, so a shifted index would fail the run rather than re-key the wrong question.",
+    "summary": {
+      "changes": 24,
+      "rekeys": 10,
+      "optionReplacements": 5,
+      "stemRewrites": 9,
+      "questionsTouched": 19,
+      "quarantineBefore": 145,
+      "quarantineAfter": 118,
+      "released": 27
+    },
+    "changes": [
+      {
+        "id": "book-ch1_198",
+        "change": "rekey",
+        "from": "25%",
+        "to": "50%",
+        "why": "R_load = R_th at max power transfer, so efficiency = P_load/(P_load+P_source) = 50%"
+      },
+      {
+        "id": "book-ch1_206",
+        "change": "rekey",
+        "from": "1 ms",
+        "to": "100 µs",
+        "why": "tau = RC = 1e3 * 100e-9 = 100 us"
+      },
+      {
+        "id": "book-ch1_208",
+        "change": "rekey",
+        "from": "160 kHz",
+        "to": "16 kHz",
+        "why": "f0 = 1/(2*pi*sqrt(1mH * 100nF)) = 15.9 kHz"
+      },
+      {
+        "id": "book-ch1_212",
+        "change": "rekey",
+        "from": "45°",
+        "to": "0°",
+        "why": "at resonance X_L = X_C so Z is purely resistive and the phase angle is 0"
+      },
+      {
+        "id": "book-ch1_213",
+        "change": "rekey",
+        "from": "1 µs",
+        "to": "100 µs",
+        "why": "tau = L/R = 10e-3 / 100 = 100 us"
+      },
+      {
+        "id": "book-ch1_221",
+        "change": "rekey",
+        "from": "2pisqrt(LC)",
+        "to": "1/(2pisqrt(LC))",
+        "why": "f0 = 1/(2*pi*sqrt(LC)); the keyed option was the reciprocal"
+      },
+      {
+        "id": "book-ch2_145",
+        "change": "rekey",
+        "from": "A binary encoder has 2^n input lines and n output lines, while a priority encoder has n input lines and log2n output lines.",
+        "to": "A binary encoder converts a binary input signal into an n-bit coded output signal, while a priority encoder generates a binary code corresponding to the highest priority input signal.",
+        "why": "both encoder types have 2^n inputs and n outputs; the real difference is priority resolution"
+      },
+      {
+        "id": "book-ch2_193",
+        "change": "replace-option",
+        "slot": 2,
+        "from": "0 to 256",
+        "to": "0 to 255",
+        "keyed": true,
+        "why": "2^8 = 256 distinct values, so the range is 0..255; correct_option already said so"
+      },
+      {
+        "id": "book-ch1_207",
+        "change": "restem",
+        "from": "In an R-L circuit, the voltage across the Inductor lags behind the current by how many degrees?",
+        "to": "In an R-L circuit, the voltage across the inductor leads the current by how many degrees?",
+        "why": "v_L = L di/dt, so inductor voltage leads current by 90 degrees; \"lags\" made the question unanswerable"
+      },
+      {
+        "id": "book-ch1_257",
+        "change": "restem",
+        "from": "In an R-L circuit, the voltage across the Inductor lags behind the current by how many degrees?",
+        "to": "In an R-L circuit, the voltage across the inductor leads the current by how many degrees?",
+        "why": "v_L = L di/dt, so inductor voltage leads current by 90 degrees; \"lags\" made the question unanswerable"
+      },
+      {
+        "id": "book-ch1_207",
+        "change": "rekey",
+        "from": "0°",
+        "to": "90°",
+        "why": "inductor voltage leads current by 90 degrees"
+      },
+      {
+        "id": "book-ch1_215",
+        "change": "restem",
+        "from": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the resonant frequency?",
+        "to": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the cutoff (corner) frequency?",
+        "why": "an R-C network has no resonant frequency; the quantity being asked for is the corner frequency"
+      },
+      {
+        "id": "book-ch1_215",
+        "change": "replace-option",
+        "slot": 4,
+        "from": "1.59 kHz",
+        "to": "1.59 Hz",
+        "keyed": true,
+        "why": "f_c = 1/(2*pi*R*C) = 1/(2*pi*100e3*1e-6) = 1.59 Hz"
+      },
+      {
+        "id": "book-ch1_263",
+        "change": "restem",
+        "from": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the resonant frequency?",
+        "to": "A parallel R-C circuit has a resistor of 100 kΩ and a capacitor of 1 µF. What is the cutoff (corner) frequency?",
+        "why": "an R-C network has no resonant frequency; the quantity being asked for is the corner frequency"
+      },
+      {
+        "id": "book-ch1_263",
+        "change": "replace-option",
+        "slot": 4,
+        "from": "1.59 kHz",
+        "to": "1.59 Hz",
+        "keyed": true,
+        "why": "f_c = 1/(2*pi*R*C) = 1/(2*pi*100e3*1e-6) = 1.59 Hz"
+      },
+      {
+        "id": "book-ch2_116",
+        "change": "replace-option",
+        "slot": 4,
+        "from": "11",
+        "to": "21",
+        "keyed": true,
+        "why": "correct_option named \"21\", which is not a binary combination and so is the intended answer; it was missing from the options"
+      },
+      {
+        "id": "book-ch2_125",
+        "change": "replace-option",
+        "slot": 4,
+        "from": "11",
+        "to": "21",
+        "keyed": true,
+        "why": "correct_option named \"21\", which is not a binary combination and so is the intended answer; it was missing from the options"
+      },
+      {
+        "id": "book-ch3_358",
+        "change": "restem",
+        "from": "Which of the following statements is true about static data members in C++?",
+        "to": "Which of the following statements is true about the default initial value of static data members in C++?",
+        "why": "its options are all about the default initial value"
+      },
+      {
+        "id": "book-ch3_362",
+        "change": "restem",
+        "from": "Which of the following statements is true about static data members in C++?",
+        "to": "Which of the following statements is true about where a static data member of a C++ class must be initialized?",
+        "why": "its options are all about where initialization may appear"
+      },
+      {
+        "id": "book-ch3_364",
+        "change": "restem",
+        "from": "Which of the following statements is true about static data members in C++?",
+        "to": "Which of the following statements is true about how static data members in C++ can be accessed?",
+        "why": "its options are all about access syntax"
+      },
+      {
+        "id": "book-ch1_236",
+        "change": "restem",
+        "from": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 5µF?",
+        "to": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 0.1µF?",
+        "why": "NEEDS SOURCE CHECK: options fit C = 0.1 uF (f0 = 3.56 kHz); as authored with 5 uF, f0 = 503 Hz and no option is correct"
+      },
+      {
+        "id": "book-ch1_236",
+        "change": "rekey",
+        "from": "35.7 kHz",
+        "to": "3.57 kHz",
+        "why": "f0 = 1/(2*pi*sqrt(20mH * 0.1uF)) = 3.56 kHz"
+      },
+      {
+        "id": "book-ch1_274",
+        "change": "restem",
+        "from": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 5µF?",
+        "to": "What is the resonant frequency of an AC parallel resonant circuit with an inductance of 20mH and a capacitance of 0.1µF?",
+        "why": "NEEDS SOURCE CHECK: options fit C = 0.1 uF (f0 = 3.56 kHz); as authored with 5 uF, f0 = 503 Hz and no option is correct"
+      },
+      {
+        "id": "book-ch1_274",
+        "change": "rekey",
+        "from": "357 kHz",
+        "to": "3.57 kHz",
+        "why": "f0 = 1/(2*pi*sqrt(20mH * 0.1uF)) = 3.56 kHz"
+      }
+    ],
+    "notAppliedAndWhy": [
+      {
+        "id": "book-ch3_368",
+        "reason": "OPTION_MULTIPLE_TRUE",
+        "detail": "The triage classified all four static-data-member questions as a stem collision with no wrong key. That holds for three of them, but not this one: both the keyed \"They are initialized to zero by default\" and the distractor \"They cannot be initialized inside the class declaration\" are true statements - the latter being exactly what book-ch3_362 keys as correct. A single-answer MCQ cannot have two correct options, so this needs the distractor rewritten or the question retired. It remains quarantined and is the only entry in quarantine.json that no automated rule can re-derive."
+      },
+      {
+        "ids": [
+          "book-ch1_236",
+          "book-ch1_274"
+        ],
+        "reason": "APPLIED BUT NEEDS SOURCE VERIFICATION",
+        "detail": "As authored the stem gives L = 20 mH and C = 5 uF, for which f0 = 1/(2*pi*sqrt(LC)) = 503 Hz - and none of the four options is close. The options (3.57 kHz / 35.7 kHz / 357 kHz / 3.57 MHz) form a decade ladder around 3.57 kHz, which is exactly what L = 20 mH gives for C = 0.1 uF. The stem capacitance was therefore treated as the typo and changed to 0.1 uF, which is the smaller edit than replacing four options. This is the one change that altered a question premise rather than a key; confirm against the source textbook."
+      },
+      {
+        "ids": [
+          "12 remaining KEY_CONFLICT rows"
+        ],
+        "reason": "STILL UNADJUDICATED",
+        "detail": "Twelve rows still have a correct_option naming text that is absent from all four options - mostly binary and hexadecimal arithmetic in ch2. They were not among the 13 recorded resolutions and no answer can be derived without the source material, since both the keyed option and the stated answer may be wrong. They remain quarantined."
+      }
+    ]
+  }
+}
diff --git a/frontend/src/data/examBlueprint.ts b/frontend/src/data/examBlueprint.ts
new file mode 100644
index 0000000..8668722
--- /dev/null
+++ b/frontend/src/data/examBlueprint.ts
@@ -0,0 +1,627 @@
+/**
+ * The NEC licence-exam format and question-selection blueprint, as data.
+ *
+ * WHY THIS FILE EXISTS
+ * --------------------
+ * Exam constants were previously scattered as bare numbers (e.g. `duration: 45`
+ * in `topics.ts`) with no record of where they came from. Several of them are
+ * not actually known: the official NEC syllabus PDF for the Computer
+ * Engineering stream lists the 10 chapters and their 60 sub-chapters but
+ * contains **no marking scheme at all** - no duration, no pass mark, no
+ * per-chapter weights. Shipping a guess as a bare number is how a guess becomes
+ * folklore.
+ *
+ * So every exam constant lives here exactly once, wrapped in a
+ * `BlueprintValue<T>` that carries its provenance and its verification status.
+ * A `ConfirmedValue<T>` can be read with `readConfirmed()`. An
+ * `UnverifiedValue<T>` *cannot* be passed to `readConfirmed()` (compile error)
+ * and must be read through `readUnverified()`, which requires an explicit
+ * acknowledgement object. Reading an unverified number by accident is
+ * therefore not possible.
+ *
+ * WHAT IS CONFIRMED, AND BY WHOM
+ * ------------------------------
+ * All four format fields are confirmed by the project owner (2026-10-20):
+ *
+ *   questionCount    100 questions
+ *   marksPerQuestion 1 mark each, so 100 marks total (derived, never stored)
+ *   durationMinutes  120 minutes
+ *   passMark         50 of 100
+ *
+ * The provenance is `kind: 'project-owner'` with `sourceUrl: null`, and that
+ * null is deliberate. There is no published document behind these numbers -
+ * the official syllabus PDF carries no marking scheme - so citing a URL would
+ * manufacture an authority that does not exist. If an NEC exam notice ever
+ * contradicts any of this, the notice wins and this file is the only place that
+ * has to change.
+ *
+ * `topics.ts` previously configured mock tests at 45 minutes, against a real
+ * exam of 120. That is now driven from here instead of being restated.
+ *
+ * WHAT IS STILL UNVERIFIED
+ * ------------------------
+ * Nothing in `examFormat`. `listUnverifiedFields()` and
+ * `formatUnverifiedFields()` remain, and remain wired into the UI, because the
+ * next field added is likelier to be a guess than a confirmation - negative
+ * marking and per-chapter weights are both unknown, and the machinery to refuse
+ * to display a guess as fact should already be in place when they arrive.
+ */
+
+import type { ChapterCode, SubchapterCode, SubchapterIndex } from './syllabus';
+import { syllabusChapters, syllabusSubchapters } from './syllabus';
+
+/* ------------------------------------------------------------------ *
+ * Provenance
+ * ------------------------------------------------------------------ */
+
+export type VerificationStatus = 'confirmed' | 'needs-verification';
+
+export type ProvenanceKind =
+  /** The official NEC syllabus / notice PDF. */
+  | 'official-document'
+  /** Confirmed verbally or in writing by the project owner. */
+  | 'project-owner'
+  /** Coaching sites, forum posts, blog write-ups - plausible, unverified. */
+  | 'secondary-source'
+  /** A number the app already had in its code with no recorded origin. */
+  | 'app-default';
+
+export interface ProvenanceSource {
+  readonly kind: ProvenanceKind;
+  /** Short human-facing description of where the value came from. */
+  readonly label: string;
+  /**
+   * Canonical URL for the claim, or `null` when none exists.
+   * `null` is deliberate: the owner's confirmation and the app's historical
+   * defaults have no public document behind them, and inventing a plausible
+   * URL would be worse than admitting there isn't one.
+   */
+  readonly sourceUrl: string | null;
+  /** ISO `YYYY-MM-DD` the value was last verified, or `null` if never. */
+  readonly verifiedOn: string | null;
+  /** Why this status, and what would have to happen to upgrade it. */
+  readonly note: string;
+}
+
+/** A competing value for the same constant, recorded rather than discarded. */
+export interface ValueConflict<T> {
+  readonly value: T;
+  readonly label: string;
+  readonly sourceUrl: string | null;
+}
+
+export interface BlueprintValue<T> {
+  readonly value: T;
+  readonly status: VerificationStatus;
+  /** Short stable label for UI listings, e.g. `'duration'`. */
+  readonly label: string;
+  readonly unit: string;
+  readonly source: ProvenanceSource;
+  /** Other values seen in the wild for this same constant. */
+  readonly conflicts?: readonly ValueConflict<T>[];
+}
+
+/** A value whose correctness has been confirmed. Safe to read directly. */
+export interface ConfirmedValue<T> extends BlueprintValue<T> {
+  readonly status: 'confirmed';
+  readonly source: ProvenanceSource & { readonly verifiedOn: string };
+}
+
+/** A value that is still a guess. Cannot be read without acknowledgement. */
+export interface UnverifiedValue<T> extends BlueprintValue<T> {
+  readonly status: 'needs-verification';
+}
+
+/**
+ * Caller's explicit statement that they know the number is unverified.
+ * Required by `readUnverified()`; the literal `true` makes it impossible to
+ * satisfy accidentally with a falsy default.
+ */
+export interface UnverifiedAcknowledgement {
+  readonly acknowledgeUnverified: true;
+  /** Why using an unverified value is acceptable here. */
+  readonly reason: string;
+}
+
+/** Read a confirmed constant. Typed so unverified fields are rejected. */
+export function readConfirmed<T>(field: ConfirmedValue<T>): T {
+  return field.value;
+}
+
+/** Read an unverified constant, forcing the caller to acknowledge it. */
+export function readUnverified<T>(
+  field: UnverifiedValue<T>,
+  acknowledgement: UnverifiedAcknowledgement,
+): T {
+  if (acknowledgement.acknowledgeUnverified !== true) {
+    throw new Error(
+      'readUnverified("' + field.label + '") requires acknowledgeUnverified: true',
+    );
+  }
+  return field.value;
+}
+
+/**
+ * Runtime escape hatch for code holding a `BlueprintValue<T>` of unknown
+ * status. Throws on an unverified value unless acknowledged - so a forgotten
+ * acknowledgement fails loudly instead of shipping a guess.
+ */
+export function readBlueprintValue<T>(
+  field: BlueprintValue<T>,
+  acknowledgement?: UnverifiedAcknowledgement,
+): T {
+  if (field.status === 'needs-verification' && acknowledgement?.acknowledgeUnverified !== true) {
+    throw new Error(
+      'Blueprint field "' +
+        field.label +
+        '" is marked needs-verification; pass an UnverifiedAcknowledgement to use it.',
+    );
+  }
+  return field.value;
+}
+
+/* ------------------------------------------------------------------ *
+ * Exam format
+ * ------------------------------------------------------------------ */
+
+const OWNER_CONFIRMATION: ProvenanceSource & { readonly verifiedOn: string } = {
+  kind: 'project-owner',
+  label: 'Project owner confirmation',
+  sourceUrl: null,
+  verifiedOn: '2026-10-20',
+  note:
+    'Owner confirmed the paper is 100 questions at 1 mark each (100 marks), ' +
+    'runs for 120 minutes, and is passed at 50 of 100. The official NEC ' +
+    'syllabus PDF carries no marking scheme at all, so there is no document ' +
+    'URL to cite for any of it - the provenance is the project owner, not a ' +
+    'published source. If a future NEC notice contradicts this, that notice ' +
+    'wins and this is the single place to change.',
+};
+
+export interface ExamFormatBlueprint {
+  /** Questions on the paper. */
+  readonly questionCount: ConfirmedValue<number>;
+  /** Marks awarded per correct question. */
+  readonly marksPerQuestion: ConfirmedValue<number>;
+  /** Minutes allowed for the paper. */
+  readonly durationMinutes: ConfirmedValue<number>;
+  /** Marks required to pass, out of `totalMarks()`. */
+  readonly passMark: ConfirmedValue<number>;
+}
+
+export const examFormat: ExamFormatBlueprint = {
+  questionCount: {
+    value: 100,
+    status: 'confirmed',
+    label: 'questionCount',
+    unit: 'questions',
+    source: OWNER_CONFIRMATION,
+  },
+  marksPerQuestion: {
+    value: 1,
+    status: 'confirmed',
+    label: 'marksPerQuestion',
+    unit: 'marks',
+    source: OWNER_CONFIRMATION,
+  },
+  durationMinutes: {
+    value: 120,
+    status: 'confirmed',
+    label: 'duration',
+    unit: 'minutes',
+    source: OWNER_CONFIRMATION,
+  },
+  passMark: {
+    value: 50,
+    status: 'confirmed',
+    label: 'passMark',
+    unit: 'marks',
+    source: OWNER_CONFIRMATION,
+  },
+};
+
+/**
+ * Total marks for the paper. Derived, never stored, so it cannot drift from
+ * `questionCount` x `marksPerQuestion`.
+ */
+export function totalMarks(format: ExamFormatBlueprint = examFormat): number {
+  return readConfirmed(format.questionCount) * readConfirmed(format.marksPerQuestion);
+}
+
+/* ------------------------------------------------------------------ *
+ * Unverified-field reporting
+ * ------------------------------------------------------------------ */
+
+export interface UnverifiedFieldReport {
+  /** Key on `ExamFormatBlueprint`, e.g. `'durationMinutes'`. */
+  readonly key: string;
+  /** Short UI label, e.g. `'duration'`. */
+  readonly label: string;
+  /** The current best guess being carried. */
+  readonly currentValue: number;
+  readonly unit: string;
+  readonly source: ProvenanceSource;
+}
+
+/**
+ * Every format field currently marked `needs-verification`.
+ * Today this is `duration` and `passMark`.
+ */
+export function listUnverifiedFields(
+  format: ExamFormatBlueprint = examFormat,
+): readonly UnverifiedFieldReport[] {
+  const entries: readonly (readonly [string, BlueprintValue<number>])[] = [
+    ['questionCount', format.questionCount],
+    ['marksPerQuestion', format.marksPerQuestion],
+    ['durationMinutes', format.durationMinutes],
+    ['passMark', format.passMark],
+  ];
+
+  return entries
+    .filter(([, field]) => field.status === 'needs-verification')
+    .map(([key, field]) => ({
+      key,
+      label: field.label,
+      currentValue: field.value,
+      unit: field.unit,
+      source: field.source,
+    }));
+}
+
+/**
+ * Comma-separated labels of the unverified fields, for a UI banner such as
+ * `Blueprint: unverified fields: duration, passMark`. Empty string when
+ * everything is confirmed.
+ */
+export function formatUnverifiedFields(format: ExamFormatBlueprint = examFormat): string {
+  return listUnverifiedFields(format)
+    .map(report => report.label)
+    .join(', ');
+}
+
+/** True when nothing in the format blueprint is still a guess. */
+export function isFormatFullyVerified(format: ExamFormatBlueprint = examFormat): boolean {
+  return listUnverifiedFields(format).length === 0;
+}
+
+/* ------------------------------------------------------------------ *
+ * Question-selection blueprint
+ * ------------------------------------------------------------------ */
+
+export type WeightingRuleId = 'equal-chapter-weight-largest-remainder';
+
+/**
+ * THE WEIGHTING RULE - `equal-chapter-weight-largest-remainder`
+ *
+ * 100 questions do not divide evenly across 60 sub-chapters (100 / 60 = 1.67),
+ * so the split has to be defined rather than computed. The rule is:
+ *
+ * 1. **Equal chapter weight.** Each of the 10 chapters contributes
+ *    100 / 10 = 10 questions. This is the only split the official syllabus
+ *    supports: it lists 10 chapters with identical structure (6 sub-chapters
+ *    each) and publishes no weights. Any uneven chapter weighting would be
+ *    invented.
+ * 2. **Within a chapter**, the 10 questions are spread over 6 sub-chapters by
+ *    the largest-remainder (Hare quota) method on equal shares: each
+ *    sub-chapter's ideal share is 10 / 6 = 1.667, giving a floor of 1
+ *    (6 seats) and a remainder of 0.667 for all six. Four seats remain.
+ * 3. **Tie-break.** All six remainders are equal, so the remaining seats are
+ *    awarded in ascending sub-chapter index - the standard deterministic
+ *    tie-break. Sub-chapters 1-4 get 2 questions, sub-chapters 5-6 get 1.
+ *
+ * Per chapter: 2 + 2 + 2 + 2 + 1 + 1 = 10. Across 10 chapters: exactly 100.
+ *
+ * The index tie-break is arbitrary in content terms and is *documented as
+ * arbitrary*. It is stable and auditable, which a random tie-break would not
+ * be. Replace it with real past-paper frequency weights the moment those
+ * exist; that is a data change here, not a code change anywhere else.
+ */
+export const WEIGHTING_RULE: WeightingRuleId = 'equal-chapter-weight-largest-remainder';
+
+/** Questions drawn from each chapter under the equal-chapter-weight rule. */
+export const QUESTIONS_PER_CHAPTER = 10;
+
+/** Sub-chapter indexes awarded a largest-remainder bonus seat. */
+const BONUS_SEAT_INDEXES: readonly SubchapterIndex[] = [1, 2, 3, 4];
+
+function quotaForIndex(index: SubchapterIndex): number {
+  return BONUS_SEAT_INDEXES.includes(index) ? 2 : 1;
+}
+
+export interface SubchapterQuota {
+  readonly subchapterCode: SubchapterCode;
+  readonly chapterCode: ChapterCode;
+  readonly subchapterIndex: SubchapterIndex;
+  /** Questions this sub-chapter must contribute to a 100-question paper. */
+  readonly questions: number;
+}
+
+export interface SelectionBlueprint {
+  readonly totalQuestions: number;
+  readonly weightingRule: WeightingRuleId;
+  /** One entry per official sub-chapter - always 60 of them. */
+  readonly quotas: readonly SubchapterQuota[];
+  /**
+   * When `true`, a sub-chapter with too few tagged questions is a hard
+   * failure. When `false`, the planner falls back to chapter-level sampling
+   * and reports which sub-chapters it had to approximate.
+   *
+   * Ships `false`, because **no question in the bank currently carries a
+   * sub-chapter tag** - a strict run today would fail on all 60. Flip to
+   * `true` once tagging coverage is real.
+   */
+  readonly strictBlueprint: boolean;
+  /** What happens to an under-supplied sub-chapter when not strict. */
+  readonly fallback: 'chapter-level-sampling';
+  readonly notes: readonly string[];
+}
+
+const quotas: readonly SubchapterQuota[] = syllabusSubchapters.map(sub => ({
+  subchapterCode: sub.code,
+  chapterCode: sub.chapterCode,
+  subchapterIndex: sub.index,
+  questions: quotaForIndex(sub.index),
+}));
+
+export const selectionBlueprint: SelectionBlueprint = {
+  totalQuestions: 100,
+  weightingRule: WEIGHTING_RULE,
+  quotas,
+  strictBlueprint: false,
+  fallback: 'chapter-level-sampling',
+  notes: [
+    'Sub-chapter tagging coverage in the question bank is currently zero, so ' +
+      'every sub-chapter is satisfied by chapter-level fallback sampling. ' +
+      'ExamPlan.approximatedSubchapterCodes reports exactly which ones.',
+    'Chapter weights are equal (10 questions each) because the official ' +
+      'syllabus publishes no per-chapter marks.',
+    'Within a chapter, sub-chapters 1-4 contribute 2 questions and 5-6 ' +
+      'contribute 1, by documented largest-remainder tie-break on index.',
+  ],
+};
+
+export interface ExamBlueprint {
+  readonly format: ExamFormatBlueprint;
+  readonly selection: SelectionBlueprint;
+}
+
+export const examBlueprint: ExamBlueprint = {
+  format: examFormat,
+  selection: selectionBlueprint,
+};
+
+/* ------------------------------------------------------------------ *
+ * Planning
+ * ------------------------------------------------------------------ */
+
+/**
+ * Available question counts keyed by code. Passed in by the caller so this
+ * module never touches the question files and stays pure and testable.
+ */
+export interface QuestionSupply {
+  readonly [code: string]: number;
+}
+
+/**
+ * Today's reality: not one question in the bank carries a sub-chapter tag.
+ * Exported so callers can be explicit about it instead of hand-rolling `{}`.
+ */
+export const NO_SUBCHAPTER_TAGS: QuestionSupply = {};
+
+export interface SubchapterDraw {
+  readonly subchapterCode: SubchapterCode;
+  readonly chapterCode: ChapterCode;
+  readonly requested: number;
+  /** Drawn from questions actually tagged with this sub-chapter. */
+  readonly fromSubchapterTagged: number;
+  /** Drawn from the chapter pool because tagged questions ran out. */
+  readonly fromChapterFallback: number;
+  /** True when any part of this draw was approximated at chapter level. */
+  readonly approximated: boolean;
+}
+
+export interface ExamPlan {
+  /** Always equals `selectionBlueprint.totalQuestions` when `ok` is true. */
+  readonly totalQuestions: number;
+  readonly draws: readonly SubchapterDraw[];
+  /** Sub-chapters whose quota was partly or wholly chapter-level sampled. */
+  readonly approximatedSubchapterCodes: readonly SubchapterCode[];
+  readonly strictBlueprint: boolean;
+  readonly weightingRule: WeightingRuleId;
+  /** Supply keys that are not official sub-chapter codes - likely typos. */
+  readonly unknownSupplyCodes: readonly string[];
+}
+
+export interface SubchapterShortfall {
+  readonly subchapterCode: SubchapterCode;
+  readonly chapterCode: ChapterCode;
+  readonly requested: number;
+  /** Questions tagged with this sub-chapter. */
+  readonly availableTagged: number;
+  /** Questions it could raise, tagged plus chapter fallback. */
+  readonly planned: number;
+  /** `requested - planned`, always greater than 0 for an entry in this list. */
+  readonly missing: number;
+}
+
+export interface ShortfallReport {
+  readonly totalRequested: number;
+  readonly totalPlanned: number;
+  readonly totalMissing: number;
+  readonly shortfalls: readonly SubchapterShortfall[];
+  readonly strictBlueprint: boolean;
+  readonly unknownSupplyCodes: readonly string[];
+}
+
+export type ExamPlanResult =
+  | { readonly ok: true; readonly plan: ExamPlan }
+  | { readonly ok: false; readonly report: ShortfallReport };
+
+export interface PlanExamOptions {
+  /**
+   * Override `selectionBlueprint.strictBlueprint`. When strict, chapter-level
+   * fallback is disabled and any under-supplied sub-chapter is a shortfall.
+   */
+  readonly strictBlueprint?: boolean;
+  /**
+   * Total questions available per chapter, keyed by chapter code
+   * (e.g. `{ ACtE03: 398 }`). Used only for fallback sampling. Tagged
+   * questions are assumed to be a subset of their chapter's pool, so a
+   * chapter's fallback capacity is its supply minus the questions already
+   * drawn from that chapter.
+   */
+  readonly chapterSupply?: QuestionSupply;
+  readonly blueprint?: SelectionBlueprint;
+}
+
+function supplyFor(supply: QuestionSupply, code: string): number {
+  const count = supply[code];
+  return typeof count === 'number' && Number.isFinite(count) && count > 0 ? Math.floor(count) : 0;
+}
+
+/**
+ * Turn per-sub-chapter availability into a 100-question plan, or a structured
+ * report of what is missing and by how much.
+ *
+ * Pure: it reads nothing but its arguments and the static blueprint.
+ */
+export function planExam(
+  subchapterSupply: QuestionSupply,
+  options: PlanExamOptions = {},
+): ExamPlanResult {
+  const blueprint = options.blueprint ?? selectionBlueprint;
+  const strict = options.strictBlueprint ?? blueprint.strictBlueprint;
+  const chapterSupply = options.chapterSupply ?? {};
+
+  const validCodes = new Set<string>(blueprint.quotas.map(quota => quota.subchapterCode));
+  const unknownSupplyCodes = Object.keys(subchapterSupply).filter(code => !validCodes.has(code));
+
+  // Pass 1 - satisfy what the sub-chapter tags can actually cover. Done first
+  // and in full so the result does not depend on quota iteration order.
+  interface TaggedDraw {
+    readonly quotaIndex: number;
+    readonly availableTagged: number;
+    readonly fromSubchapterTagged: number;
+  }
+
+  const taggedDraws: TaggedDraw[] = blueprint.quotas.map((quota, quotaIndex) => {
+    const availableTagged = supplyFor(subchapterSupply, quota.subchapterCode);
+    return {
+      quotaIndex,
+      availableTagged,
+      fromSubchapterTagged: Math.min(quota.questions, availableTagged),
+    };
+  });
+
+  const taggedPerChapter = new Map<string, number>();
+  for (const tagged of taggedDraws) {
+    const quota = blueprint.quotas[tagged.quotaIndex];
+    taggedPerChapter.set(
+      quota.chapterCode,
+      (taggedPerChapter.get(quota.chapterCode) ?? 0) + tagged.fromSubchapterTagged,
+    );
+  }
+
+  // Pass 2 - a chapter's fallback capacity is whatever is left of its pool once
+  // the tagged questions it already yielded are set aside, because tagged
+  // questions are a subset of their chapter's pool.
+  const fallbackCapacity = new Map<string, number>(
+    syllabusChapters.map(chapter => [
+      chapter.code,
+      strict
+        ? 0
+        : Math.max(
+            0,
+            supplyFor(chapterSupply, chapter.code) - (taggedPerChapter.get(chapter.code) ?? 0),
+          ),
+    ]),
+  );
+
+  const draws: SubchapterDraw[] = [];
+  const shortfalls: SubchapterShortfall[] = [];
+  const approximatedSubchapterCodes: SubchapterCode[] = [];
+  let totalPlanned = 0;
+  let totalRequested = 0;
+
+  for (const tagged of taggedDraws) {
+    const quota = blueprint.quotas[tagged.quotaIndex];
+    const requested = quota.questions;
+    totalRequested += requested;
+
+    const deficit = requested - tagged.fromSubchapterTagged;
+    const capacity = fallbackCapacity.get(quota.chapterCode) ?? 0;
+    const fromChapterFallback = deficit > 0 ? Math.min(deficit, capacity) : 0;
+    fallbackCapacity.set(quota.chapterCode, capacity - fromChapterFallback);
+
+    const planned = tagged.fromSubchapterTagged + fromChapterFallback;
+    totalPlanned += planned;
+
+    const approximated = fromChapterFallback > 0;
+    if (approximated) {
+      approximatedSubchapterCodes.push(quota.subchapterCode);
+    }
+
+    draws.push({
+      subchapterCode: quota.subchapterCode,
+      chapterCode: quota.chapterCode,
+      requested,
+      fromSubchapterTagged: tagged.fromSubchapterTagged,
+      fromChapterFallback,
+      approximated,
+    });
+
+    if (planned < requested) {
+      shortfalls.push({
+        subchapterCode: quota.subchapterCode,
+        chapterCode: quota.chapterCode,
+        requested,
+        availableTagged: tagged.availableTagged,
+        planned,
+        missing: requested - planned,
+      });
+    }
+  }
+
+  if (shortfalls.length > 0) {
+    return {
+      ok: false,
+      report: {
+        totalRequested,
+        totalPlanned,
+        totalMissing: totalRequested - totalPlanned,
+        shortfalls,
+        strictBlueprint: strict,
+        unknownSupplyCodes,
+      },
+    };
+  }
+
+  return {
+    ok: true,
+    plan: {
+      totalQuestions: totalPlanned,
+      draws,
+      approximatedSubchapterCodes,
+      strictBlueprint: strict,
+      weightingRule: blueprint.weightingRule,
+      unknownSupplyCodes,
+    },
+  };
+}
+
+/** Human-readable one-liner for a shortfall report, for logs and dev UI. */
+export function describeShortfall(report: ShortfallReport): string {
+  const detail = report.shortfalls
+    .map(entry => entry.subchapterCode + ' (-' + String(entry.missing) + ')')
+    .join(', ');
+  return (
+    'Short ' +
+    String(report.totalMissing) +
+    ' of ' +
+    String(report.totalRequested) +
+    ' questions across ' +
+    String(report.shortfalls.length) +
+    ' sub-chapters: ' +
+    detail
+  );
+}
diff --git a/frontend/src/data/quarantine.json b/frontend/src/data/quarantine.json
new file mode 100644
index 0000000..77e79fa
--- /dev/null
+++ b/frontend/src/data/quarantine.json
@@ -0,0 +1,1065 @@
+[
+  {
+    "id": "book-ch1_50",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"to regulate the voltage levels of a three-phase supply\" vs \"to regulate the voltage levels of a power distribution system\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_58",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"to regulate the voltage levels of a three-phase supply\" vs \"to regulate the voltage levels of a power distribution system\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_140",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the principle of superposition\" vs \"ohm's law\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_143",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the principle of superposition\" vs \"ohm's law\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_173",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the resistance of the circuit with all voltage sources replaced by their internal resistances.\" vs \"the resistance seen from the output terminals with all voltage sources replaced by their internal resistances\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_183",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the resistance of the circuit with all voltage sources replaced by their internal resistances.\" vs \"the resistance seen from the output terminals with all voltage sources replaced by their internal resistances\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_209",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is infinite\" vs \"it is at a minimum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_214",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it increases\" vs \"it decreases\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_217",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"r/c\" vs \"rc\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_218",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"infinite\" vs \"zero\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_222",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the impedance is maximum\" vs \"the impedance is minimum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_225",
+    "codes": [
+      "OPTION_DUPLICATE"
+    ],
+    "notes": [
+      "opt3 and opt4 are both \"159.15 Hz\" - two options can be simultaneously correct."
+    ]
+  },
+  {
+    "id": "book-ch1_226",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is maximum\" vs \"it is minimum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_227",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is maximum\" vs \"it is minimum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_228",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"zero\" vs \"unity\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_229",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"zero\" vs \"unity\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_232",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is minimum\" vs \"it is maximum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_235",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"minimum\" vs \"maximum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_246",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"they are the same thing\" vs \"they are two different types of power\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_259",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is infinite\" vs \"it is at a minimum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_262",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it increases\" vs \"it decreases\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_264",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"r/c\" vs \"rc\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_265",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"infinite\" vs \"zero\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_267",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the impedance is maximum\" vs \"the impedance is minimum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_268",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is maximum\" vs \"it is minimum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_269",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is maximum\" vs \"it is minimum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_270",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"zero\" vs \"unity\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_271",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"zero\" vs \"unity\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_272",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is minimum\" vs \"it is maximum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_273",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"minimum\" vs \"maximum\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_275",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"they are the same thing\" vs \"they are two different types of power\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_337",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 3 other row(s) keying a different answer (\"the time constant of the rc circuit\" vs \"the slope of the waveform\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch1_347",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 3 other row(s) keying a different answer (\"the time constant of the rc circuit\" vs \"the slope of the waveform\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_16",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 2 points at \"110110\" but correct_option says \"111110\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_18",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 1 points at \"28\" but correct_option says \"2B\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_123",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 3 other row(s) keying a different answer (\"the time constant of the rc circuit\" vs \"the slope of the waveform\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_124",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 3 other row(s) keying a different answer (\"the time constant of the rc circuit\" vs \"the slope of the waveform\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_150",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 3 points at \"110110\" but correct_option says \"110100\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_156",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 4 points at \"0100\" but correct_option says \"11000\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_158",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 2 points at \"10110110\" but correct_option says \"101110110\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_160",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 4 points at \"00000010\" but correct_option says \"10000\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_163",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 2 points at \"1110\" but correct_option says \"1100\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_175",
+    "codes": [
+      "OPTION_DUPLICATE"
+    ],
+    "notes": [
+      "opt3 and opt4 are both \"1001\" - two options can be simultaneously correct."
+    ]
+  },
+  {
+    "id": "book-ch2_198",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 2 points at \"1101\" but correct_option says \"0011\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_200",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 2 points at \"0010\" but correct_option says \"0101\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_203",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 2 points at \"0110\" but correct_option says \"11110\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch2_240",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"secondary storage\" vs \"multiuser\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_253",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"secondary storage\" vs \"multiuser\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_303",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"they occur when an isr triggers another interrupt\" vs \"they occur when an isr is triggered while another isr is being serviced\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_305",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the process of handling an interrupt request from an external device\" vs \"the process of handling interrupts\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_312",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the process of handling an interrupt request from an external device\" vs \"the process of handling interrupts\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_315",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is the time between the occurrence of an interrupt and the start of the isr\" vs \"it refers to the time required for an interrupt to be detected and an isr to be initiated\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_320",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"they are triggered by the rising or falling edge of a signal\" vs \"they are triggered by a change in the interrupt request signal\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_324",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is the time between the occurrence of an interrupt and the start of the isr\" vs \"it refers to the time required for an interrupt to be detected and an isr to be initiated\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_325",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"they occur when an isr triggers another interrupt\" vs \"they occur when an isr is triggered while another isr is being serviced\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch2_330",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"they are triggered by the rising or falling edge of a signal\" vs \"they are triggered by a change in the interrupt request signal\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_59",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"a one-dimensional array has one row and multiple columns, whereas a two-dimensional array has multiple rows and multiple columns.\" vs \"a two-dimensional array has more dimensions than a one-dimensional array\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_69",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"a one-dimensional array has one row and multiple columns, whereas a two-dimensional array has multiple rows and multiple columns.\" vs \"a two-dimensional array has more dimensions than a one-dimensional array\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_105",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 4 points at \"4\" but correct_option says \"Undefined\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch3_112",
+    "codes": [
+      "KEY_CONFLICT"
+    ],
+    "notes": [
+      "correct_option_index 3 points at \"11 21 30\" but correct_option says \"10 21 30\" - and that text is not among the options at all."
+    ]
+  },
+  {
+    "id": "book-ch3_157",
+    "codes": [
+      "OPTION_DUPLICATE"
+    ],
+    "notes": [
+      "opt2 and opt3 are both \"array_name[size] struct;\" - two options can be simultaneously correct."
+    ]
+  },
+  {
+    "id": "book-ch3_164",
+    "codes": [
+      "OPTION_DUPLICATE"
+    ],
+    "notes": [
+      "opt1 and opt3 are both \"struct *array_name[size];\" - two options can be simultaneously correct.",
+      "opt2 and opt4 are both \"struct (*array_name)[size];\" - two options can be simultaneously correct."
+    ]
+  },
+  {
+    "id": "book-ch3_190",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is a mechanism for managing the scope of identifiers in large programs\" vs \"a container that holds a group of related variables and functions\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_192",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"you can have multiple namespaces with the same name in the same program\" vs \"namespace members are accessed using the :: operator\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_200",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it is a mechanism for managing the scope of identifiers in large programs\" vs \"a container that holds a group of related variables and functions\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_201",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"you can have multiple namespaces with the same name in the same program\" vs \"namespace members are accessed using the :: operator\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_319",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it points to the object on which the member function is called\" vs \"to refer to the object's own data members\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_338",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"it points to the object on which the member function is called\" vs \"to refer to the object's own data members\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_356",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"a data member that is shared among all instances of a class\" vs \"a data member that belongs to the class and not to any instance of the class\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_357",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"using the keyword static before the data type\" vs \"with the keyword 'static' and the data type of the member\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_359",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"using the keyword static before the return type\" vs \"with the keyword 'static' and the return type of the function\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_360",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 2 other row(s) keying a different answer (\"they can access only static data members of the class\" vs \"they cannot access non-static data members\" vs \"they cannot be virtual\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_363",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 2 other row(s) keying a different answer (\"they can access only static data members of the class\" vs \"they cannot access non-static data members\" vs \"they cannot be virtual\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_366",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"a data member that is shared among all instances of a class\" vs \"a data member that belongs to the class and not to any instance of the class\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_367",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"using the keyword static before the data type\" vs \"with the keyword 'static' and the data type of the member\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_368",
+    "codes": [
+      "OPTION_MULTIPLE_TRUE"
+    ],
+    "notes": [
+      "Two options are true: the keyed \"They are initialized to zero by default\", and \"They cannot be initialized inside the class declaration\" - the latter being exactly what book-ch3_362 keys as correct for a non-const, non-inline static data member. A single-answer MCQ cannot have two correct options. Needs the distractor rewritten or the question retired; no re-key fixes it."
+    ]
+  },
+  {
+    "id": "book-ch3_370",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"using the keyword static before the return type\" vs \"with the keyword 'static' and the return type of the function\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_371",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 2 other row(s) keying a different answer (\"they can access only static data members of the class\" vs \"they cannot access non-static data members\" vs \"they cannot be virtual\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_375",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"a member function that cannot modify any data members of the class\" vs \"a member function that cannot be modified\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_379",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 4 other row(s) keying a different answer (\"they cannot modify any data members of the class\" vs \"they cannot modify the data members of the class\" vs \"they can be created using the const keyword before the object name\" vs \"they cannot call non-constant member functions of the class\" vs \"they can access only constant member functions of the class\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_383",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"a member function that cannot modify any data members of the class\" vs \"a member function that cannot be modified\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_384",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 4 other row(s) keying a different answer (\"they cannot modify any data members of the class\" vs \"they cannot modify the data members of the class\" vs \"they can be created using the const keyword before the object name\" vs \"they cannot call non-constant member functions of the class\" vs \"they can access only constant member functions of the class\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_386",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 4 other row(s) keying a different answer (\"they cannot modify any data members of the class\" vs \"they cannot modify the data members of the class\" vs \"they can be created using the const keyword before the object name\" vs \"they cannot call non-constant member functions of the class\" vs \"they can access only constant member functions of the class\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_387",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 4 other row(s) keying a different answer (\"they cannot modify any data members of the class\" vs \"they cannot modify the data members of the class\" vs \"they can be created using the const keyword before the object name\" vs \"they cannot call non-constant member functions of the class\" vs \"they can access only constant member functions of the class\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch3_388",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 4 other row(s) keying a different answer (\"they cannot modify any data members of the class\" vs \"they cannot modify the data members of the class\" vs \"they can be created using the const keyword before the object name\" vs \"they cannot call non-constant member functions of the class\" vs \"they can access only constant member functions of the class\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_14",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"cache replacement\" vs \"page replacement\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_62",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"volatile memory loses its contents when power is lost, while non-volatile memory retains its contents\" vs \"volatile memory requires power to retain its data, while non-volatile memory retains data even without power\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_130",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"shift left\" vs \"comparison\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_133",
+    "codes": [
+      "OPTION_DUPLICATE"
+    ],
+    "notes": [
+      "opt1 and opt4 are both \"NOT 0 = 0\" - two options can be simultaneously correct."
+    ]
+  },
+  {
+    "id": "book-ch4_136",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"shift left\" vs \"comparison\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_202",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"volatile memory loses its contents when power is lost, while non-volatile memory retains its contents\" vs \"volatile memory requires power to retain its data, while non-volatile memory retains data even without power\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_280",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"sequential execution\" vs \"single processing unit\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_281",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the ability of multiple processors to execute instructions simultaneously\" vs \"the ability to use multiple processors to complete a single task\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_282",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the ability of the system to increase performance as more processors are added\" vs \"the ability to add more processors to the system as needed\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_286",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the ability of the system to maintain consistency of data stored in the caches of multiple processors\" vs \"the ability to maintain consistency of shared data in different processor caches\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_288",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"sequential execution\" vs \"single processing unit\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_289",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the ability of multiple processors to execute instructions simultaneously\" vs \"the ability to use multiple processors to complete a single task\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_290",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the ability of the system to increase performance as more processors are added\" vs \"the ability to add more processors to the system as needed\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_293",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"the ability of the system to maintain consistency of data stored in the caches of multiple processors\" vs \"the ability to maintain consistency of shared data in different processor caches\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_333",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 2 other row(s) keying a different answer (\"a computer system that is embedded within a larger device\" vs \"a system designed to perform a specific task\" vs \"a computer system used in industrial control applications\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_342",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 2 other row(s) keying a different answer (\"a computer system that is embedded within a larger device\" vs \"a system designed to perform a specific task\" vs \"a computer system used in industrial control applications\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_343",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 2 other row(s) keying a different answer (\"general-purpose computing\" vs \"standard operating system\" vs \"high processing speed\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_344",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"home computer\" vs \"personal computer\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_348",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"to manage system resources and scheduling\" vs \"to schedule and manage tasks in real-time.\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_352",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"web-based embedded system\" vs \"mainframe system\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_356",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 2 other row(s) keying a different answer (\"general-purpose computing\" vs \"standard operating system\" vs \"high processing speed\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_378",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 2 other row(s) keying a different answer (\"a computer system that is embedded within a larger device\" vs \"a system designed to perform a specific task\" vs \"a computer system used in industrial control applications\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_379",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"home computer\" vs \"personal computer\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_381",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 2 other row(s) keying a different answer (\"general-purpose computing\" vs \"standard operating system\" vs \"high processing speed\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_383",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"web-based embedded system\" vs \"mainframe system\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_391",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"to manage system resources and scheduling\" vs \"to schedule and manage tasks in real-time.\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_413",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"tensilica xtensa\" vs \"digital signal processor (dsp)\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch4_417",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"tensilica xtensa\" vs \"digital signal processor (dsp)\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch7_50",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"cache replacement\" vs \"page replacement\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch8_28",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"sequence diagrams\" vs \"state diagrams\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch8_36",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"provides a mechanism for handling runtime errors\" vs \"provides a structured way to handle errors\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch8_61",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"sequence diagrams\" vs \"state diagrams\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  },
+  {
+    "id": "book-ch8_69",
+    "codes": [
+      "DUPLICATE_ANSWER_CONFLICT"
+    ],
+    "notes": [
+      "Shares a stem with 1 other row(s) keying a different answer (\"provides a mechanism for handling runtime errors\" vs \"provides a structured way to handle errors\"). Until one is adjudicated, some students would be marked wrong for a right answer."
+    ]
+  }
+]
diff --git a/frontend/src/data/quarantine.ts b/frontend/src/data/quarantine.ts
new file mode 100644
index 0000000..48806b8
--- /dev/null
+++ b/frontend/src/data/quarantine.ts
@@ -0,0 +1,43 @@
+/**
+ * Questions withheld from practice until a human adjudicates them.
+ *
+ * Each entry is a question the app would mis-grade. `scripts/validate-questions.mjs`
+ * found them, and they are listed explicitly rather than filtered by rule so that
+ * every exclusion is a visible, reviewable decision — and so that a newly
+ * introduced bad question fails the build instead of silently joining the list.
+ *
+ * The failure modes represented here:
+ *
+ *   KEY_CONFLICT      `correct_option_index` and `correct_option` disagree. In every
+ *                     case in this list the text named by `correct_option` is not
+ *                     among the four options at all. The app trusts the index, so
+ *                     these would mark the wrong option correct.
+ *   INDEX_RANGE       `correct_option_index` is 5 with only 4 options present, so
+ *                     there is no reachable correct answer.
+ *   OPTION_DUPLICATE  Two options carry identical text, so two options can be
+ *                     simultaneously correct.
+ *
+ * To clear an entry: fix the row in `frontend/public/data/books/`, re-run
+ * `node scripts/validate-questions.mjs`, and remove the id from quarantine.json.
+ *
+ * Ids are the synthetic `{topicId}_{arrayIndex}` form and are therefore tied to
+ * array position — reordering a chapter JSON invalidates this list. That is one of
+ * several reasons the bank is moving to content-hash ids.
+ */
+import entries from './quarantine.json';
+
+export interface QuarantinedQuestion {
+  /** Synthetic question id: `{topicId}_{arrayIndex}`. */
+  id: string;
+  /** Validator codes that caused the exclusion. */
+  codes: string[];
+  /** Human-readable detail, enough to adjudicate the question from. */
+  notes: string[];
+}
+
+export const quarantinedQuestions: QuarantinedQuestion[] = entries;
+
+/** Fast membership test used by the question loader. */
+export const quarantinedIds: ReadonlySet<string> = new Set(
+  quarantinedQuestions.map((q) => q.id)
+);
diff --git a/frontend/src/data/subchapterTerms.ts b/frontend/src/data/subchapterTerms.ts
new file mode 100644
index 0000000..6858dde
--- /dev/null
+++ b/frontend/src/data/subchapterTerms.ts
@@ -0,0 +1,335 @@
+/**
+ * Discriminating vocabulary for each of the 60 syllabus sub-chapters.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * Two problems share one cause: the question bank records which *chapter* a
+ * question belongs to but not which *sub-chapter*.
+ *
+ *  1. `questions.subchapter_id` is NULL for every row, so all 60 blueprint
+ *     sampling rules silently degrade to chapter-level sampling.
+ *  2. No question has an explanation, so a student who gets one wrong is told
+ *     "Incorrect" and nothing else.
+ *
+ * A sub-chapter label fixes the first outright and gives the second something
+ * true to say — "this tests 5.4 Transport Layer" is not an explanation, but it
+ * points at a page in the syllabus, and it is derived rather than generated.
+ *
+ * WHY TERM LISTS AND NOT A MODEL
+ * ------------------------------
+ * No live API is used in this project, so classification has to be local and
+ * deterministic. That is far more tractable than it sounds, because the chapter
+ * is already known: the classifier never picks 1-of-60, only 1-of-6, and within
+ * a chapter the six sub-chapters are deliberately disjoint topics. Separating
+ * "Network Layer" from "Transport Layer" needs `subnet`/`ospf` against
+ * `tcp`/`handshake`, not semantics.
+ *
+ * The cost is that this is a HEURISTIC over standard engineering vocabulary,
+ * not a key. It is wrong sometimes. Everything downstream therefore treats a
+ * match as a *hint* with a confidence, refuses to answer when two sub-chapters
+ * tie, and degrades to the chapter — which is always exact. Nothing here is
+ * ever presented to a student as an authoritative classification.
+ *
+ * TERM WEIGHTS
+ * ------------
+ * `strong` terms are ones that, within their chapter, essentially settle it:
+ * `thevenin` appears in 1.2 Network Theorems and nowhere else in chapter 1.
+ * `weak` terms lean without settling: `voltage` is chapter-1-wide.
+ *
+ * MATCHING, AND WHAT YOU THEREFORE NEED NOT WRITE
+ * -----------------------------------------------
+ * Terms are matched case-insensitively on word boundaries, so `ip` does not
+ * match "multiple" and `or` does not match "for". Two normalisations are
+ * applied by `services/subchapterClassifier.ts`, so do NOT spell these out:
+ *
+ *   - PLURALS. Every word may carry a trailing `s`/`es`, so `requirement`
+ *     covers "requirements" and `pointer` covers "pointers".
+ *   - SEPARATORS. Spaces and hyphens are interchangeable, so `open loop`
+ *     covers "open-loop" and `non-functional requirement` covers "non
+ *     functional requirements".
+ *
+ * Nothing is stemmed. Terms are only ever widened, never reduced to a root, so
+ * `routing`, `router` and `route` stay distinct — chapter 5 depends on that.
+ *
+ * A term list is a maintained artefact, not a one-off: `scripts/classify-
+ * subchapters.mjs` reports per-chapter coverage and the spread across the six
+ * sub-chapters, and `--sample N` shows which terms drove each decision. A
+ * sub-chapter that never wins is the signal that its terms are narrower than
+ * the bank's phrasing.
+ */
+
+import type { SubchapterCode } from './syllabus';
+
+export interface SubchapterTerms {
+  /** Terms that, within the owning chapter, are near-decisive. */
+  readonly strong: readonly string[];
+  /** Terms that lean towards this sub-chapter without settling it. */
+  readonly weak: readonly string[];
+}
+
+/**
+ * Keyed by official sub-chapter code. Typed as a total record over
+ * `SubchapterCode`, so omitting a sub-chapter is a compile error rather than a
+ * silent coverage hole.
+ */
+export const SUBCHAPTER_TERMS: Record<SubchapterCode, SubchapterTerms> = {
+  /* ── Chapter 1 — Basic Electrical and Electronics ───────────────────────── */
+  AExE0101: {
+    strong: ["ohm's law", 'ohms law', 'kirchhoff', 'kcl', 'kvl', 'coulomb', 'resistivity'],
+    weak: ['resistance', 'resistor', 'current', 'voltage', 'series', 'parallel', 'charge', 'power', 'conductor', 'emf'],
+  },
+  AExE0102: {
+    strong: ['thevenin', 'norton', 'superposition', 'maximum power transfer', 'reciprocity', 'millman', 'nodal analysis', 'mesh analysis'],
+    weak: ['theorem', 'equivalent', 'network', 'node', 'mesh', 'loop', 'source transformation'],
+  },
+  AExE0103: {
+    strong: ['alternating current', 'rms', 'root mean square', 'power factor', 'phasor', 'reactance', 'impedance', 'resonance', 'three-phase', 'three phase'],
+    weak: ['frequency', 'sinusoidal', 'peak', 'inductor', 'capacitor', 'phase angle', 'hertz', 'waveform', 'ac'],
+  },
+  AExE0104: {
+    strong: ['diode', 'zener', 'transistor', 'bjt', 'mosfet', 'fet', 'rectifier', 'pn junction', 'p-n junction', 'doping', 'thyristor', 'scr'],
+    weak: ['semiconductor', 'silicon', 'germanium', 'forward bias', 'reverse bias', 'depletion', 'majority carrier', 'intrinsic', 'extrinsic'],
+  },
+  AExE0105: {
+    strong: ['oscillator', 'multivibrator', 'wien bridge', 'colpitts', 'hartley', 'astable', 'monostable', 'bistable', 'signal generator', '555'],
+    weak: ['barkhausen', 'waveform generator', 'sawtooth', 'square wave', 'triggering'],
+  },
+  AExE0106: {
+    strong: ['amplifier', 'amplifiers', 'op-amp', 'op amp', 'operational amplifier', 'common emitter', 'common collector', 'common base', 'push-pull', 'class a', 'class b', 'slew rate', 'cmrr'],
+    weak: ['gain', 'amplification', 'feedback', 'inverting', 'non-inverting', 'bandwidth', 'distortion', 'biasing'],
+  },
+
+  /* ── Chapter 2 — Digital Logic and Microprocessor ───────────────────────── */
+  AExE0201: {
+    strong: ['boolean', 'de morgan', "de morgan's", 'karnaugh', 'k-map', 'truth table', 'logic gate', 'nand', 'nor', 'xor', 'sop', 'pos', 'minterm', 'maxterm', "two's complement", "1's complement", "2's complement", 'gray code', 'bcd', 'excess-3', 'number system', 'radix', 'base of the', 'decimal equivalent', 'binary equivalent', 'octal equivalent', 'hexadecimal equivalent', 'logic family', 'ttl', 'cmos logic', 'ecl', 'fan-out', 'noise margin'],
+    weak: ['binary', 'hexadecimal', 'octal', 'decimal', 'gate', 'inverter', 'complement', 'simplify', 'conversion', 'bit', 'digit'],
+  },
+  AExE0202: {
+    strong: ['half adder', 'full adder', 'ripple carry', 'carry look', 'multiplexer', 'demultiplexer', 'mux', 'encoder', 'decoder', 'comparator', 'subtractor', 'alu'],
+    weak: ['combinational', 'arithmetic circuit', 'carry', 'sum', 'borrow', 'select line', 'enable'],
+  },
+  AExE0203: {
+    strong: ['flip-flop', 'flip flop', 'latch', 'sr flip', 'jk flip', 'd flip', 't flip', 'shift register', 'counter', 'ring counter', 'johnson counter', 'state diagram', 'state machine', 'moore', 'mealy', 'race around'],
+    weak: ['sequential', 'clock', 'clocked', 'edge-triggered', 'preset', 'clear', 'excitation', 'synchronous', 'asynchronous'],
+  },
+  AExE0204: {
+    strong: ['8085', '8086', 'accumulator', 'instruction set', 'addressing mode', 'opcode', 'instruction cycle', 'machine cycle', 'fetch', 'register pair', 'flag register', 'stack pointer', 'program counter'],
+    weak: ['microprocessor', 'instruction', 'mnemonic', 'assembly', 'operand', 'arithmetic instruction'],
+  },
+  AExE0205: {
+    strong: ['memory interfacing', 'address decoding', 'memory map', '8255', '8251', '8253', '8279', 'ppi', 'usart', 'bus cycle', 'wait state', 'minimum mode', 'maximum mode', 'tristate', 'latch enable', 'microprocessor system', 'i/o mapped', 'memory mapped i/o', 'io/m', 'ale signal', 'demultiplexing', 'clock generator', '8284', '8237', 'coprocessor', 'bus contention', 'read write cycle'],
+    weak: ['interfacing', 'peripheral', 'address bus', 'data bus', 'control bus', 'chip select', 'system bus', 'external device', 'timing diagram'],
+  },
+  AExE0206: {
+    strong: ['interrupt', 'interrupts', 'isr', 'interrupt service routine', 'maskable', 'non-maskable', 'nmi', 'rst 7.5', 'trap', 'vectored', 'interrupt vector', 'priority interrupt', '8259', 'dma', 'polling'],
+    weak: ['service routine', 'priority', 'acknowledge', 'enable interrupt', 'disable interrupt', 'nested'],
+  },
+
+  /* ── Chapter 3 — Programming Language and Its Applications ──────────────── */
+  ACtE0301: {
+    strong: ['printf', 'scanf', 'main()', '#include', 'stdio', 'for loop', 'while loop', 'do-while', 'switch statement', 'goto', 'preprocessor', 'macro', 'typedef', 'storage class', 'auto', 'extern', 'recursion'],
+    weak: ['c program', 'variable', 'datatype', 'data type', 'operator', 'loop', 'array', 'function', 'keyword', 'identifier', 'format specifier'],
+  },
+  ACtE0302: {
+    strong: ['pointer', 'pointers', 'malloc', 'calloc', 'realloc', 'free()', 'dereference', 'struct', 'structure', 'union', 'fopen', 'fclose', 'fscanf', 'fprintf', 'fseek', 'file pointer', 'null pointer', 'pointer arithmetic', 'self-referential'],
+    weak: ['address of', 'dynamic memory', 'allocation', 'member', 'nested structure', 'data file', 'text file', 'binary file', 'record'],
+  },
+  ACtE0303: {
+    strong: ['cout', 'cin', 'iostream', 'constructor', 'destructor', 'this pointer', 'member function', 'access specifier', 'friend function', 'static member', 'inline function', 'copy constructor', 'namespace', 'reference variable'],
+    weak: ['class', 'object', 'c++', 'private', 'public', 'protected', 'instance', 'declaration', 'scope resolution'],
+  },
+  ACtE0304: {
+    strong: ['inheritance', 'polymorphism', 'encapsulation', 'abstraction', 'overloading', 'operator overloading', 'function overloading', 'base class', 'derived class', 'multiple inheritance', 'hybrid inheritance', 'diamond problem', 'message passing'],
+    weak: ['oop', 'object-oriented', 'object oriented', 'reusability', 'data hiding', 'feature', 'paradigm'],
+  },
+  ACtE0305: {
+    strong: ['virtual function', 'pure virtual', 'abstract class', 'vtable', 'dynamic binding', 'late binding', 'early binding', 'overriding', 'ofstream', 'ifstream', 'fstream', 'stream', 'file handling', 'seekg', 'seekp'],
+    weak: ['virtual', 'runtime polymorphism', 'binding', 'file mode', 'open mode', 'stream class'],
+  },
+  ACtE0306: {
+    strong: ['template', 'templates', 'generic programming', 'class template', 'function template', 'exception handling', 'try', 'catch', 'throw', 'stl', 'standard template library', 'iterator', 'vector<', 'container class'],
+    weak: ['generic', 'exception', 'error handling', 'rethrow', 'type parameter', 'instantiation'],
+  },
+
+  /* ── Chapter 4 — Computer Organization and Embedded System ──────────────── */
+  ACtE0401: {
+    strong: ['control unit', 'microprogram', 'microinstruction', 'hardwired control', 'register transfer', 'rtl', 'cpu organization', 'datapath', 'instruction pipeline', 'pipelining', 'risc', 'cisc', 'general register organization', 'stack organization', 'instruction format', 'addressing mode', 'effective address', 'alu', 'control memory', 'instruction cycle', 'register set', 'accumulator'],
+    weak: ['central processing', 'control signal', 'sequencer', 'processor', 'execution unit', 'cpu', 'instruction', 'operand', 'opcode'],
+  },
+  ACtE0402: {
+    strong: ['booth', 'booth algorithm', 'floating point', 'ieee 754', 'cache memory', 'cache mapping', 'associative mapping', 'direct mapping', 'set associative', 'write through', 'write back', 'cache write policy', 'multilevel cache', 'cache hierarchy', 'virtual memory', 'tlb', 'memory hierarchy', 'hit ratio', 'miss rate', 'locality of reference', 'rom', 'ram', 'sram', 'dram', 'division algorithm', "2's complement representation", 'least recently used', 'lru'],
+    weak: ['computer arithmetic', 'multiplication', 'division', 'overflow', 'normalization', 'mantissa', 'exponent', 'memory system', 'main memory', 'auxiliary memory'],
+  },
+  ACtE0403: {
+    strong: ['input-output', 'i/o interface', 'i/o transfer', 'i/o transfer mode', 'programmed i/o', 'interrupt-initiated', 'dma', 'dma controller', 'direct memory access', 'memory-mapped i/o', 'isolated i/o', 'iop', 'daisy chain', 'serial communication', 'asynchronous transfer', 'strobe', 'handshaking', 'multiprocessor', 'crossbar', 'cache coherence', 'interprocessor', 'flynn'],
+    weak: ['peripheral device', 'i/o', 'bus arbitration', 'priority encoder', 'shared memory', 'tightly coupled', 'loosely coupled'],
+  },
+  ACtE0404: {
+    strong: ['embedded system', 'microcontroller', '8051', 'arduino', 'firmware', 'watchdog timer', 'adc', 'dac', 'sensor', 'actuator', 'i2c', 'spi', 'uart', 'cross compiler', 'in-circuit', 'bootloader', 'soc', 'system on chip', 'asip', 'application-specific instruction', 'single-purpose processor', 'general-purpose processor', 'custom processor', 'hardware software co-design', 'design metric'],
+    weak: ['embedded', 'on-chip', 'peripheral port', 'timer', 'counter module', 'power consumption', 'target board'],
+  },
+  ACtE0405: {
+    strong: ['real-time operating', 'rtos', 'hard real-time', 'soft real-time', 'task scheduling', 'rate monotonic', 'earliest deadline', 'priority inversion', 'context switch', 'semaphore', 'mutex', 'deadline', 'jitter', 'closed loop', 'open loop', 'pid controller', 'transfer function', 'process', 'thread', 'preemptive scheduling', 'scheduling algorithm', 'busy waiting', 'synchronization mechanism', 'device driver', 'kernel', 'spinlock', 'round robin'],
+    weak: ['real-time', 'real time', 'scheduler', 'latency', 'preemptive', 'control system', 'feedback control', 'stability', 'operating system', 'task'],
+  },
+  ACtE0406: {
+    strong: ['hdl', 'vhdl', 'verilog', 'fpga', 'cpld', 'asic', 'synthesis', 'testbench', 'behavioral modelling', 'structural modelling', 'dataflow modelling', 'netlist', 'place and route', 'ssi', 'msi', 'lsi', 'vlsi', 'photolithography', 'fabrication'],
+    weak: ['hardware description', 'ic technology', 'integrated circuit', 'simulation', 'entity', 'module', 'wafer', 'gate array'],
+  },
+
+  /* ── Chapter 5 — Computer Network and Network Security ──────────────────── */
+  ACtE0501: {
+    strong: ['osi model', 'osi layer', 'tcp/ip model', 'physical layer', 'topology', 'bus topology', 'star topology', 'ring topology', 'mesh topology', 'coaxial', 'twisted pair', 'fiber optic', 'optical fiber', 'nyquist', 'shannon', 'modulation', 'multiplexing', 'tdm', 'fdm', 'wdm', 'baud', 'attenuation', 'manchester encoding', 'nrz'],
+    weak: ['layer', 'transmission medium', 'bandwidth', 'lan', 'wan', 'man', 'bit rate', 'signal', 'guided media', 'unguided'],
+  },
+  ACtE0502: {
+    strong: ['data link layer', 'mac address', 'framing', 'crc', 'cyclic redundancy', 'hamming', 'parity', 'error detection', 'error correction', 'stop-and-wait', 'sliding window', 'go-back-n', 'selective repeat', 'hdlc', 'csma', 'csma/cd', 'csma/ca', 'aloha', 'ethernet', 'switch', 'bridge', 'arq', 'piggyback'],
+    weak: ['frame', 'flow control', 'checksum', 'collision', 'media access', 'retransmission', 'acknowledgement', 'hub'],
+  },
+  ACtE0503: {
+    strong: ['network layer', 'ip address', 'ipv4', 'ipv6', 'subnet', 'subnet mask', 'subnetting', 'cidr', 'routing', 'router', 'routing table', 'rip', 'ospf', 'bgp', 'distance vector', 'link state', 'dijkstra', 'icmp', 'arp', 'nat', 'fragmentation', 'ttl', 'classful', 'classless', 'default gateway'],
+    weak: ['packet', 'datagram', 'route', 'hop', 'forwarding', 'address class', 'broadcast address', 'host id', 'network id'],
+  },
+  ACtE0504: {
+    strong: ['transport layer', 'tcp', 'udp', 'port number', 'three-way handshake', 'congestion control', 'slow start', 'sliding window protocol', 'socket', 'segment', 'sequence number', 'connection-oriented', 'connectionless', 'nagle', 'silly window'],
+    weak: ['end-to-end', 'reliable delivery', 'multiplexing port', 'well-known port', 'ephemeral', 'handshake', 'teardown'],
+  },
+  ACtE0505: {
+    strong: ['application layer', 'http', 'https', 'ftp', 'smtp', 'pop3', 'imap', 'dns', 'dhcp', 'telnet', 'ssh', 'snmp', 'url', 'uri', 'mime', 'web server', 'cookie', 'proxy server', 'cdn', 'rest'],
+    weak: ['email', 'domain name', 'client-server', 'browser', 'hypertext', 'port 80', 'resolver', 'protocol port'],
+  },
+  ACtE0506: {
+    strong: ['cryptography', 'encryption', 'decryption', 'symmetric key', 'asymmetric key', 'public key', 'private key', 'rsa', 'des', 'aes', 'diffie-hellman', 'digital signature', 'certificate authority', 'hash function', 'md5', 'sha', 'firewall', 'ids', 'intrusion detection', 'vpn', 'ssl', 'tls', 'kerberos', 'denial of service', 'malware', 'phishing'],
+    weak: ['security', 'cipher', 'plaintext', 'ciphertext', 'key exchange', 'authentication', 'authorization', 'integrity', 'confidentiality', 'attack'],
+  },
+
+  /* ── Chapter 6 — Theory of Computation and Computer Graphics ────────────── */
+  ACtE0601: {
+    strong: ['finite automata', 'finite automaton', 'dfa', 'nfa', 'epsilon-nfa', 'regular expression', 'regular language', 'pumping lemma for regular', 'myhill-nerode', 'state minimization', 'moore machine', 'mealy machine', 'kleene'],
+    weak: ['automata', 'automaton', 'transition function', 'accepting state', 'final state', 'start state', 'alphabet', 'string acceptance', 'regular'],
+  },
+  ACtE0602: {
+    strong: ['context-free grammar', 'context free grammar', 'cfg', 'context-free language', 'pushdown automata', 'pda', 'parse tree', 'derivation tree', 'ambiguous grammar', 'chomsky normal form', 'greibach', 'left recursion', 'useless symbol', 'leftmost derivation'],
+    weak: ['grammar', 'production rule', 'terminal', 'non-terminal', 'derivation', 'parsing', 'context-free', 'stack automaton'],
+  },
+  ACtE0603: {
+    strong: ['turing machine', 'turing', 'halting problem', 'decidable', 'undecidable', 'recursively enumerable', 'church-turing', 'post correspondence', 'np-complete', 'np-hard', 'reducibility', 'universal turing', 'linear bounded automata', 'rice theorem'],
+    weak: ['tape', 'tape head', 'computability', 'recursive language', 'complexity class', 'polynomial time', 'intractable'],
+  },
+  ACtE0604: {
+    strong: ['raster scan', 'random scan', 'frame buffer', 'crt', 'pixel', 'resolution', 'aspect ratio', 'dda algorithm', 'bresenham', 'line drawing', 'midpoint circle', 'scan line fill', 'boundary fill', 'flood fill', 'anti-aliasing', 'cohen-sutherland', 'clipping', 'viewport'],
+    weak: ['graphics', 'display device', 'rasterization', 'refresh rate', 'interlacing', 'colour model', 'rgb', 'cmy', 'window'],
+  },
+  ACtE0605: {
+    strong: ['2d transformation', '2d transformations', 'two-dimensional transformation', 'homogeneous coordinate', 'composite transformation', 'shearing', 'reflection about', 'rotation matrix', 'scaling factor', 'translation vector'],
+    weak: ['transformation', 'translation', 'rotation', 'scaling', 'shear', 'reflection', 'matrix', '2d', 'coordinate'],
+  },
+  ACtE0606: {
+    strong: ['3d transformation', '3d transformations', 'three-dimensional transformation', 'projection', 'parallel projection', 'perspective projection', 'orthographic', 'vanishing point', 'hidden surface', 'z-buffer', 'depth buffer', 'back-face', 'painter algorithm', 'bezier', 'b-spline', 'phong', 'gouraud', 'ray tracing'],
+    weak: ['3d', 'three-dimensional', 'viewing pipeline', 'surface', 'solid modelling', 'shading', 'illumination', 'camera'],
+  },
+
+  /* ── Chapter 7 — Data Structures, Database and Operating System ─────────── */
+  ACtE0701: {
+    strong: ['linked list', 'singly linked', 'doubly linked', 'circular linked', 'stack push', 'stack pop', 'queue enqueue', 'dequeue', 'circular queue', 'priority queue', 'binary tree', 'binary search tree', 'bst', 'avl tree', 'b-tree', 'b+ tree', 'heap', 'tree traversal', 'preorder', 'inorder', 'postorder', 'infix', 'postfix', 'prefix notation'],
+    weak: ['data structure', 'list', 'tree', 'node pointer', 'stack', 'queue', 'abstract data type', 'adt', 'traversal', 'leaf', 'height of tree', 'balanced'],
+  },
+  ACtE0702: {
+    strong: ['bubble sort', 'selection sort', 'insertion sort', 'merge sort', 'quick sort', 'quicksort', 'heap sort', 'radix sort', 'shell sort', 'counting sort', 'linear search', 'binary search', 'hashing', 'hash table', 'collision resolution', 'bfs', 'dfs', 'breadth-first', 'depth-first', 'kruskal', 'prim', 'bellman-ford', 'floyd-warshall', 'minimum spanning tree', 'topological sort', 'dynamic programming', 'greedy algorithm', 'divide and conquer'],
+    weak: ['sorting', 'searching', 'graph', 'adjacency matrix', 'adjacency list', 'shortest path', 'complexity', 'big-o', 'stable sort', 'in-place', 'pivot'],
+  },
+  ACtE0703: {
+    strong: ['er model', 'entity-relationship', 'relational model', 'normalization', '1nf', '2nf', '3nf', 'bcnf', 'functional dependency', 'candidate key', 'primary key', 'foreign key', 'super key', 'sql', 'select statement', 'join', 'inner join', 'outer join', 'group by', 'relational algebra', 'relational calculus', 'denormalization', 'dbms architecture', 'schema', 'tuple'],
+    weak: ['database', 'data model', 'relation', 'attribute', 'cardinality', 'query', 'table', 'view', 'constraint', 'dependency'],
+  },
+  ACtE0704: {
+    strong: ['transaction', 'acid', 'atomicity', 'durability', 'serializability', 'concurrency control', 'two-phase locking', '2pl', 'lock', 'shared lock', 'exclusive lock', 'deadlock detection', 'timestamp ordering', 'checkpoint', 'rollback', 'commit', 'write-ahead log', 'recovery', 'dirty read', 'phantom read', 'isolation level', 'cascading abort'],
+    weak: ['schedule', 'conflict', 'log record', 'undo', 'redo', 'concurrent execution', 'granularity', 'wait-for graph'],
+  },
+  ACtE0705: {
+    strong: ['process state', 'process control block', 'pcb', 'cpu scheduling', 'fcfs', 'sjf', 'shortest job', 'round robin', 'priority scheduling', 'turnaround time', 'waiting time', 'context switching', 'thread', 'multithreading', 'critical section', 'producer-consumer', "dekker", 'peterson', 'banker algorithm', 'system call', 'kernel mode', 'user mode', 'monolithic kernel', 'microkernel', 'ipc'],
+    weak: ['operating system', 'process', 'scheduling', 'deadlock', 'starvation', 'synchronization', 'cpu burst', 'ready queue', 'preemption', 'os'],
+  },
+  ACtE0706: {
+    strong: ['paging', 'page table', 'page fault', 'segmentation', 'demand paging', 'page replacement', 'fifo replacement', 'lru', 'optimal replacement', 'thrashing', 'working set', 'belady', 'swapping', 'fragmentation', 'best fit', 'worst fit', 'first fit', 'inode', 'fat', 'file allocation', 'directory structure', 'disk scheduling', 'seek time', 'fcfs disk', 'sstf', 'elevator algorithm', 'raid'],
+    weak: ['memory management', 'file system', 'allocation strategy', 'virtual address', 'physical address', 'frame', 'disk', 'administration', 'backup', 'mounting'],
+  },
+
+  /* ── Chapter 8 — Software Engineering and OOAD ──────────────────────────── */
+  ACtE0801: {
+    strong: ['waterfall model', 'spiral model', 'incremental model', 'prototype model', 'rad model', 'v-model', 'big bang model', 'agile', 'scrum', 'extreme programming', 'software process model', 'requirement elicitation', 'requirement analysis', 'requirement management', 'requirement engineering', 'requirement document', 'interface specification', 'srs', 'functional requirement', 'non-functional requirement', 'feasibility study', 'requirement validation', 'cmm', 'process maturity'],
+    weak: ['software process', 'requirement', 'sdlc', 'life cycle', 'stakeholder', 'specification', 'phase', 'iteration', 'customer'],
+  },
+  ACtE0802: {
+    strong: ['cohesion', 'coupling', 'modularity', 'modular decomposition', 'architectural design', 'data flow diagram', 'dfd', 'structure chart', 'decision table', 'design pattern', 'top-down design', 'bottom-up design', 'information hiding', 'interface design', 'software architecture', 'layered architecture', 'reference architecture', 'design heuristic', 'real-time software design', 'case tool', 'computer-aided software engineering', 'software design'],
+    weak: ['module', 'abstraction level', 'component', 'refinement', 'design document', 'pseudocode', 'flowchart', 'design'],
+  },
+  ACtE0803: {
+    strong: ['unit testing', 'integration testing', 'system testing', 'acceptance testing', 'black box testing', 'white box testing', 'regression testing', 'alpha testing', 'beta testing', 'test case', 'cyclomatic complexity', 'basis path', 'boundary value', 'equivalence partition', 'cocomo', 'function point', 'loc estimation', 'effort estimation', 'software quality', 'iso 9001', 'six sigma', 'mccall', 'software reliability', 'defect density', 'test automation', 'formal technical review', 'cmmi', 'test plan', 'test driver', 'test stub', 'mutation testing'],
+    weak: ['testing', 'test', 'debugging', 'verification', 'validation', 'cost estimation', 'quality management', 'quality assurance', 'metric', 'walkthrough', 'inspection', 'review'],
+  },
+  ACtE0804: {
+    strong: ['use case diagram', 'use case', 'actor', 'object-oriented analysis', 'ooa', 'object-oriented development', 'object-oriented modeling', 'object-oriented modelling', 'domain model', 'conceptual model', 'crc card', 'object identification', 'association multiplicity', 'association', 'aggregation', 'composition relationship', 'generalization', 'class diagram'],
+    weak: ['object-oriented fundamental', 'analysis model', 'object model', 'identity', 'classification', 'relationship', 'scenario', 'uml', 'object-oriented'],
+  },
+  ACtE0805: {
+    strong: ['sequence diagram', 'collaboration diagram', 'interaction diagram', 'state chart diagram', 'statechart', 'activity diagram', 'component diagram', 'deployment diagram', 'object-oriented design', 'ood', 'design class', 'responsibility assignment', 'grasp', 'solid principle', 'open-closed principle', 'liskov', 'system behavior', 'system behaviour', 'transition from analysis to design'],
+    weak: ['design model', 'dynamic model', 'static model', 'message sequence', 'lifeline', 'operation signature', 'visibility'],
+  },
+  ACtE0806: {
+    strong: ['implementation strategy', 'code generation from design', 'forward engineering', 'reverse engineering', 'reengineering', 'refactoring', 'object persistence', 'object-oriented database', 'mapping class to table', 'mapping design to code', 'class definition', 'design to code', 'software reuse', 'component reuse', 'maintenance type', 'corrective maintenance', 'adaptive maintenance', 'legacy system', 'configuration management', 'version control', 'exception handling'],
+    weak: ['implementation', 'coding standard', 'maintenance', 'deployment', 'migration', 'documentation', 'build'],
+  },
+
+  /* ── Chapter 9 — Artificial Intelligence and Neural Networks ────────────── */
+  ACtE0901: {
+    strong: ['turing test', 'intelligent agent', 'rational agent', 'agent architecture', 'simple reflex agent', 'model-based agent', 'goal-based agent', 'utility-based agent', 'learning agent', 'pe-as', 'peas', 'agent environment', 'history of ai', 'strong ai', 'weak ai'],
+    weak: ['artificial intelligence', 'ai', 'agent', 'percept', 'sensor input', 'environment type', 'intelligence', 'application of ai'],
+  },
+  ACtE0902: {
+    strong: ['breadth-first search', 'depth-first search', 'uniform cost search', 'iterative deepening', 'bidirectional search', 'best-first search', 'greedy best-first', 'a* search', 'a-star', 'heuristic function', 'admissible heuristic', 'hill climbing', 'simulated annealing', 'genetic algorithm', 'minimax', 'alpha-beta pruning', 'constraint satisfaction', 'state space search', 'means-ends'],
+    weak: ['search technique', 'problem solving', 'search tree', 'goal state', 'initial state', 'path cost', 'optimality', 'completeness', 'branching factor', 'game playing'],
+  },
+  ACtE0903: {
+    strong: ['propositional logic', 'predicate logic', 'first-order logic', 'fol', 'resolution refutation', 'unification', 'forward chaining', 'backward chaining', 'horn clause', 'semantic network', 'conceptual graph', 'frame representation', 'script representation', 'ontology', 'inference rule', 'modus ponens', 'cnf conversion', 'skolemization', 'non-monotonic reasoning', 'bayesian network', 'certainty factor', 'fuzzy logic'],
+    weak: ['knowledge representation', 'knowledge base', 'inference', 'reasoning', 'logic', 'quantifier', 'predicate', 'clause', 'uncertainty'],
+  },
+  ACtE0904: {
+    strong: ['expert system', 'knowledge acquisition', 'inference engine', 'mycin', 'dendral', 'shell of expert', 'explanation facility', 'natural language processing', 'nlp', 'morphological analysis', 'syntactic analysis', 'semantic analysis', 'pragmatic analysis', 'parsing sentence', 'speech recognition', 'machine translation', 'tokenization', 'part of speech'],
+    weak: ['expert', 'domain expert', 'rule base', 'natural language', 'language understanding', 'ambiguity', 'discourse', 'corpus'],
+  },
+  ACtE0905: {
+    strong: ['supervised learning', 'unsupervised learning', 'reinforcement learning', 'decision tree learning', 'id3', 'information gain', 'entropy', 'naive bayes', 'k-nearest', 'knn', 'k-means', 'clustering', 'support vector', 'svm', 'overfitting', 'underfitting', 'cross-validation', 'training set', 'test set', 'confusion matrix', 'regression model', 'q-learning'],
+    weak: ['machine learning', 'learning algorithm', 'classification', 'prediction', 'feature', 'label', 'dataset', 'accuracy', 'generalization'],
+  },
+  ACtE0906: {
+    strong: ['neural network', 'neural networks', 'perceptron', 'multilayer perceptron', 'backpropagation', 'back propagation', 'activation function', 'sigmoid function', 'relu', 'tanh function', 'hidden layer', 'feedforward network', 'recurrent neural', 'rnn', 'cnn', 'convolutional', 'hopfield', 'boltzmann', 'kohonen', 'self-organizing map', 'hebbian', 'gradient descent', 'deep learning'],
+    weak: ['neuron', 'artificial neuron', 'synaptic weight', 'bias term', 'layer', 'threshold function', 'epoch', 'learning rate', 'network topology'],
+  },
+
+  /* ── Chapter 10 — Project Planning, Design and Implementation ───────────── */
+  AALL1001: {
+    strong: ['engineering drawing', 'orthographic projection', 'isometric', 'first angle', 'third angle', 'sectional view', 'dimensioning', 'drawing scale', 'drawing sheet', 'sheet size', 'cad', 'autocad', 'line type', 'title block', 'blueprint reading', 'plan and elevation', 'site plan', 'lettering', 'drawing standard'],
+    weak: ['drawing', 'projection view', 'sketch', 'symbol', 'drafting', 'layout drawing', 'scale', 'view'],
+  },
+  AALL1002: {
+    strong: ['engineering economics', 'time value of money', 'present worth', 'future worth', 'annuity', 'compound interest', 'simple interest', 'rate of return', 'irr', 'npv', 'net present value', 'benefit-cost ratio', 'payback period', 'depreciation', 'straight line depreciation', 'break-even', 'cash flow', 'cash flow diagram', 'inflation', 'replacement analysis', 'comparison of alternatives', 'corporate tax', 'tax rate', 'minimum attractive rate', 'sunk cost', 'opportunity cost'],
+    weak: ['economics', 'interest rate', 'cost analysis', 'discount rate', 'salvage value', 'capital', 'investment', 'economic life'],
+  },
+  AALL1003: {
+    strong: ['cpm', 'critical path', 'critical path method', 'pert', 'gantt chart', 'network diagram', 'float', 'slack time', 'forward pass', 'backward pass', 'earliest start', 'latest finish', 'crashing', 'wbs', 'work breakdown structure', 'milestone', 'resource levelling', 'resource leveling', 'resource smoothing', 'resource allocation', 'bar chart schedule', 'project planning', 'project baseline', 'project schedule'],
+    weak: ['scheduling', 'activity duration', 'dependency', 'sequence of activity', 'timeline', 'critical activity', 'planning'],
+  },
+  AALL1004: {
+    strong: ['project management', 'project manager', 'project life cycle', 'project phase', 'project organization', 'matrix organization', 'stakeholder management', 'risk management', 'risk analysis', 'risk register', 'procurement', 'contract type', 'contract management', 'fixed-price contract', 'request for proposal', 'rfp', 'tender', 'bidding', 'quality control in project', 'project monitoring', 'monitoring and evaluation', 'project control', 'project execution', 'project classification', 'project financing', 'project information system', 'change management', 'earned value', 'project closure', 'pmbok', 'characteristic of a project'],
+    weak: ['management function', 'leadership', 'team', 'organization structure', 'planning function', 'controlling', 'project scope', 'budget', 'project'],
+  },
+  AALL1005: {
+    strong: ['professional practice', 'code of ethics', 'engineering ethics', 'professional ethics', 'professional liability', 'professional negligence', 'conflict of interest', 'whistleblowing', 'intellectual property', 'patent', 'copyright', 'trademark', 'professional conduct', 'duty of care', 'safety responsibility', 'consulting engineer', 'occupational health', 'health and safety', 'environmental consideration', 'environmental impact', 'sustainable engineering', 'sustainability', 'public safety'],
+    weak: ['ethics', 'ethical', 'profession', 'professionalism', 'responsibility', 'obligation', 'public welfare', 'moral'],
+  },
+  AALL1006: {
+    strong: ['nepal engineering council', 'nec act', 'nec regulation', 'nec registration', 'engineering council act', 'licensing requirement', 'registration of engineer', 'professional licence', 'professional license', 'regulatory body', 'disciplinary action', 'nepal engineers association', 'scope of work regulation', 'renewal of licence', 'statutory body', 'engineering council'],
+    weak: ['council', 'regulation', 'act', 'licence', 'license', 'registration', 'authority', 'bylaw', 'legal provision'],
+  },
+};
diff --git a/frontend/src/data/syllabus.ts b/frontend/src/data/syllabus.ts
new file mode 100644
index 0000000..9b765ed
--- /dev/null
+++ b/frontend/src/data/syllabus.ts
@@ -0,0 +1,373 @@
+/**
+ * The official Nepal Engineering Council (NEC) licence-exam syllabus for the
+ * Computer Engineering stream (stream code `ACtE`), modelled as typed data.
+ *
+ * SOURCE OF TRUTH
+ * ---------------
+ * Chapter and sub-chapter titles are lifted verbatim from the hardcoded
+ * `SYLLABUS` constant in `src/pages/app/BookPractice.tsx`, which in turn
+ * transcribes the official NEC syllabus PDF. Nothing here is invented.
+ *
+ * STRUCTURE
+ * ---------
+ * The official syllabus is exactly 10 chapters x exactly 6 sub-chapters = 60
+ * coded sub-chapters. Chapter code prefixes are *not* uniform — chapters 1-2
+ * are the shared electrical/electronics core (`AExE`), chapters 3-9 are the
+ * Computer Engineering stream (`ACtE`), and chapter 10 is common to every
+ * engineering stream (`AALL`):
+ *
+ *   ch1  AExE01    ch4  ACtE04    ch7  ACtE07    ch10 AALL10
+ *   ch2  AExE02    ch5  ACtE05    ch8  ACtE08
+ *   ch3  ACtE03    ch6  ACtE06    ch9  ACtE09
+ *
+ * A sub-chapter code is its chapter code plus a zero-padded 1-based index,
+ * e.g. `ACtE03` -> `ACtE0301` .. `ACtE0306`.
+ *
+ * COMPILE-TIME GUARANTEES
+ * -----------------------
+ * `SYLLABUS_SOURCE` is declared `as const satisfies Tuple10<ChapterSource>`
+ * where `ChapterSource.subchapters` is `Tuple6<SubchapterSource>`. Adding or
+ * removing a chapter or a sub-chapter is therefore a type error, not a silent
+ * data drift. `SyllabusHasTenChapters` / `EverySyllabusChapterHasSixSubchapters`
+ * below restate those invariants as explicit type-level assertions, and
+ * `__tests__/syllabus.test.ts` re-checks them at runtime.
+ */
+
+/** Exactly six of `T`. */
+type Tuple6<T> = readonly [T, T, T, T, T, T];
+
+/** Exactly ten of `T`. */
+type Tuple10<T> = readonly [T, T, T, T, T, T, T, T, T, T];
+
+interface SubchapterSource {
+  readonly code: string;
+  readonly title: string;
+}
+
+interface ChapterSource {
+  readonly number: number;
+  readonly code: string;
+  readonly title: string;
+  /** The shipped question-bank chapter this syllabus chapter maps onto. */
+  readonly bookChapterId: string;
+  readonly subchapters: Tuple6<SubchapterSource>;
+}
+
+const SYLLABUS_SOURCE = [
+  {
+    number: 1,
+    code: 'AExE01',
+    title: 'Concept of Basic Electrical and Electronics Engineering',
+    bookChapterId: 'book-ch1',
+    subchapters: [
+      { code: 'AExE0101', title: 'Basic Concept' },
+      { code: 'AExE0102', title: 'Network Theorems' },
+      { code: 'AExE0103', title: 'Alternating Current Fundamentals' },
+      { code: 'AExE0104', title: 'Semiconductor Devices' },
+      { code: 'AExE0105', title: 'Signal Generators' },
+      { code: 'AExE0106', title: 'Amplifiers' },
+    ],
+  },
+  {
+    number: 2,
+    code: 'AExE02',
+    title: 'Digital Logic and Microprocessor',
+    bookChapterId: 'book-ch2',
+    subchapters: [
+      { code: 'AExE0201', title: 'Digital Logic' },
+      { code: 'AExE0202', title: 'Combinational and Arithmetic Circuits' },
+      { code: 'AExE0203', title: 'Sequential Logic Circuits' },
+      { code: 'AExE0204', title: 'Microprocessor' },
+      { code: 'AExE0205', title: 'Microprocessor System' },
+      { code: 'AExE0206', title: 'Interrupt Operations' },
+    ],
+  },
+  {
+    number: 3,
+    code: 'ACtE03',
+    title: 'Programming Language and Its Applications',
+    bookChapterId: 'book-ch3',
+    subchapters: [
+      { code: 'ACtE0301', title: 'Introduction to C Programming' },
+      { code: 'ACtE0302', title: 'Pointers, Structure and Data Files in C' },
+      { code: 'ACtE0303', title: 'C++ with Objects and Classes' },
+      { code: 'ACtE0304', title: 'Object-Oriented Programming Features' },
+      { code: 'ACtE0305', title: 'Virtual Functions and File Handling' },
+      { code: 'ACtE0306', title: 'Generic Programming and Exception Handling' },
+    ],
+  },
+  {
+    number: 4,
+    code: 'ACtE04',
+    title: 'Computer Organization and Embedded System',
+    bookChapterId: 'book-ch4',
+    subchapters: [
+      { code: 'ACtE0401', title: 'Control and Central Processing Units' },
+      { code: 'ACtE0402', title: 'Computer Arithmetic and Memory System' },
+      { code: 'ACtE0403', title: 'Input-Output Organization and Multiprocessor' },
+      { code: 'ACtE0404', title: 'Embedded System Design' },
+      { code: 'ACtE0405', title: 'Real-Time OS and Control Systems' },
+      { code: 'ACtE0406', title: 'HDL and IC Technology' },
+    ],
+  },
+  {
+    number: 5,
+    code: 'ACtE05',
+    title: 'Concept of Computer Network and Network Security System',
+    bookChapterId: 'book-ch5',
+    subchapters: [
+      { code: 'ACtE0501', title: 'Introduction and Physical Layer' },
+      { code: 'ACtE0502', title: 'Data Link Layer' },
+      { code: 'ACtE0503', title: 'Network Layer' },
+      { code: 'ACtE0504', title: 'Transport Layer' },
+      { code: 'ACtE0505', title: 'Application Layer' },
+      { code: 'ACtE0506', title: 'Network Security' },
+    ],
+  },
+  {
+    number: 6,
+    code: 'ACtE06',
+    title: 'Theory of Computation and Computer Graphics',
+    bookChapterId: 'book-ch6',
+    subchapters: [
+      { code: 'ACtE0601', title: 'Finite Automata' },
+      { code: 'ACtE0602', title: 'Context-Free Languages' },
+      { code: 'ACtE0603', title: 'Turing Machines' },
+      { code: 'ACtE0604', title: 'Introduction to Computer Graphics' },
+      { code: 'ACtE0605', title: '2D Transformations' },
+      { code: 'ACtE0606', title: '3D Transformations' },
+    ],
+  },
+  {
+    number: 7,
+    code: 'ACtE07',
+    title: 'Data Structures and Algorithm, Database System and Operating System',
+    bookChapterId: 'book-ch7',
+    subchapters: [
+      { code: 'ACtE0701', title: 'Data Structures, Lists and Trees' },
+      { code: 'ACtE0702', title: 'Sorting, Searching and Graphs' },
+      { code: 'ACtE0703', title: 'Data Models, Normalization and SQL' },
+      { code: 'ACtE0704', title: 'Transaction Processing and Concurrency Control' },
+      { code: 'ACtE0705', title: 'Introduction to OS and Process Management' },
+      { code: 'ACtE0706', title: 'Memory Management, File Systems and Administration' },
+    ],
+  },
+  {
+    number: 8,
+    code: 'ACtE08',
+    title: 'Software Engineering and Object-Oriented Analysis & Design',
+    bookChapterId: 'book-ch8',
+    subchapters: [
+      { code: 'ACtE0801', title: 'Software Process and Requirements' },
+      { code: 'ACtE0802', title: 'Software Design' },
+      { code: 'ACtE0803', title: 'Testing, Cost Estimation and Quality Management' },
+      { code: 'ACtE0804', title: 'OO Fundamentals and Analysis' },
+      { code: 'ACtE0805', title: 'OO Design' },
+      { code: 'ACtE0806', title: 'OO Design Implementation' },
+    ],
+  },
+  {
+    number: 9,
+    code: 'ACtE09',
+    title: 'Artificial Intelligence and Neural Networks',
+    bookChapterId: 'book-ch9',
+    subchapters: [
+      { code: 'ACtE0901', title: 'Introduction to AI and Intelligent Agents' },
+      { code: 'ACtE0902', title: 'Problem Solving and Searching Techniques' },
+      { code: 'ACtE0903', title: 'Knowledge Representation' },
+      { code: 'ACtE0904', title: 'Expert Systems and NLP' },
+      { code: 'ACtE0905', title: 'Machine Learning' },
+      { code: 'ACtE0906', title: 'Neural Networks' },
+    ],
+  },
+  {
+    number: 10,
+    code: 'AALL10',
+    title: 'Project Planning, Design and Implementation',
+    bookChapterId: 'book-ch10',
+    subchapters: [
+      { code: 'AALL1001', title: 'Engineering Drawings and Concepts' },
+      { code: 'AALL1002', title: 'Engineering Economics' },
+      { code: 'AALL1003', title: 'Project Planning and Scheduling' },
+      { code: 'AALL1004', title: 'Project Management' },
+      { code: 'AALL1005', title: 'Engineering Professional Practice' },
+      { code: 'AALL1006', title: 'Engineering Regulatory Body' },
+    ],
+  },
+] as const satisfies Tuple10<ChapterSource>;
+
+/* ------------------------------------------------------------------ *
+ * Derived literal types — these narrow automatically with the data.
+ * ------------------------------------------------------------------ */
+
+/** One of the ten official chapter codes, e.g. `'ACtE03'`. */
+export type ChapterCode = (typeof SYLLABUS_SOURCE)[number]['code'];
+
+/** One of the sixty official sub-chapter codes, e.g. `'ACtE0304'`. */
+export type SubchapterCode = (typeof SYLLABUS_SOURCE)[number]['subchapters'][number]['code'];
+
+/** Chapter ordinal, 1-10. */
+export type ChapterNumber = (typeof SYLLABUS_SOURCE)[number]['number'];
+
+/** The shipped question-bank chapter ids, `'book-ch1'` .. `'book-ch10'`. */
+export type BookChapterId = (typeof SYLLABUS_SOURCE)[number]['bookChapterId'];
+
+/** Sub-chapter position within its chapter, 1-6. */
+export type SubchapterIndex = 1 | 2 | 3 | 4 | 5 | 6;
+
+/* ------------------------------------------------------------------ *
+ * Type-level restatement of the structural invariants.
+ * ------------------------------------------------------------------ */
+
+type AssertTrue<T extends true> = T;
+type Equals<A, B> = (<X>() => X extends A ? 1 : 2) extends <X>() => X extends B ? 1 : 2
+  ? true
+  : false;
+
+/** Fails to compile unless the syllabus has exactly 10 chapters. */
+export type SyllabusHasTenChapters = AssertTrue<Equals<(typeof SYLLABUS_SOURCE)['length'], 10>>;
+
+/** Fails to compile unless every chapter has exactly 6 sub-chapters. */
+export type EverySyllabusChapterHasSixSubchapters = AssertTrue<
+  Equals<(typeof SYLLABUS_SOURCE)[number]['subchapters']['length'], 6>
+>;
+
+/* ------------------------------------------------------------------ *
+ * Public shapes.
+ * ------------------------------------------------------------------ */
+
+export interface SyllabusSubchapter {
+  /** Official code, e.g. `'ACtE0304'`. */
+  readonly code: SubchapterCode;
+  /** Owning chapter's official code, e.g. `'ACtE03'`. */
+  readonly chapterCode: ChapterCode;
+  /** Owning chapter's ordinal, 1-10. */
+  readonly chapterNumber: ChapterNumber;
+  /** Position within the chapter, 1-6. */
+  readonly index: SubchapterIndex;
+  /** Human-facing dotted code, e.g. `'3.4'` — what BookPractice.tsx shows. */
+  readonly displayCode: string;
+  /** Official title, verbatim from the syllabus. */
+  readonly title: string;
+}
+
+export interface SyllabusChapter {
+  readonly code: ChapterCode;
+  readonly number: ChapterNumber;
+  readonly title: string;
+  /** The `book-chN` id in `bookChapters.generated.ts` this chapter maps to. */
+  readonly bookChapterId: BookChapterId;
+  readonly subchapters: readonly SyllabusSubchapter[];
+}
+
+/** Number of chapters in the official syllabus. */
+export const CHAPTER_COUNT = 10;
+/** Sub-chapters per chapter in the official syllabus. */
+export const SUBCHAPTERS_PER_CHAPTER = 6;
+/** Total coded sub-chapters: `CHAPTER_COUNT * SUBCHAPTERS_PER_CHAPTER`. */
+export const SUBCHAPTER_COUNT = 60;
+
+/** 1-based index lookup — avoids casting `array.map` positions. */
+const SUBCHAPTER_INDEXES: Tuple6<SubchapterIndex> = [1, 2, 3, 4, 5, 6];
+
+function buildChapter(source: (typeof SYLLABUS_SOURCE)[number]): SyllabusChapter {
+  const subchapters: SyllabusSubchapter[] = source.subchapters.map((sub, position) => {
+    const index = SUBCHAPTER_INDEXES[position];
+    return {
+      code: sub.code,
+      chapterCode: source.code,
+      chapterNumber: source.number,
+      index,
+      displayCode: String(source.number) + '.' + String(index),
+      title: sub.title,
+    };
+  });
+
+  return {
+    code: source.code,
+    number: source.number,
+    title: source.title,
+    bookChapterId: source.bookChapterId,
+    subchapters,
+  };
+}
+
+/** All ten chapters, in official order. */
+export const syllabusChapters: readonly SyllabusChapter[] = SYLLABUS_SOURCE.map(buildChapter);
+
+/** All sixty sub-chapters, flattened in official order. */
+export const syllabusSubchapters: readonly SyllabusSubchapter[] = syllabusChapters.flatMap(
+  chapter => chapter.subchapters,
+);
+
+/** All ten chapter codes, in official order. */
+export const chapterCodes: readonly ChapterCode[] = syllabusChapters.map(chapter => chapter.code);
+
+/** All sixty sub-chapter codes, in official order. */
+export const subchapterCodes: readonly SubchapterCode[] = syllabusSubchapters.map(sub => sub.code);
+
+/* ------------------------------------------------------------------ *
+ * Lookups. Built once; all helpers are O(1).
+ * ------------------------------------------------------------------ */
+
+const chaptersByCode = new Map<string, SyllabusChapter>(
+  syllabusChapters.map(chapter => [chapter.code, chapter]),
+);
+const chaptersByNumber = new Map<number, SyllabusChapter>(
+  syllabusChapters.map(chapter => [chapter.number, chapter]),
+);
+const chaptersByBookId = new Map<string, SyllabusChapter>(
+  syllabusChapters.map(chapter => [chapter.bookChapterId, chapter]),
+);
+const subchaptersByCode = new Map<string, SyllabusSubchapter>(
+  syllabusSubchapters.map(sub => [sub.code, sub]),
+);
+
+/** Look up a chapter by its official code. */
+export function getChapterByCode(code: string): SyllabusChapter | undefined {
+  return chaptersByCode.get(code);
+}
+
+/** Look up a chapter by its ordinal (1-10). */
+export function getChapterByNumber(number: number): SyllabusChapter | undefined {
+  return chaptersByNumber.get(number);
+}
+
+/** Look up a chapter by the shipped question-bank id, e.g. `'book-ch4'`. */
+export function getChapterByBookChapterId(bookChapterId: string): SyllabusChapter | undefined {
+  return chaptersByBookId.get(bookChapterId);
+}
+
+/** Look up a sub-chapter by its official code. */
+export function getSubchapterByCode(code: string): SyllabusSubchapter | undefined {
+  return subchaptersByCode.get(code);
+}
+
+/** The six sub-chapters of a chapter; empty for an unknown chapter code. */
+export function getSubchaptersForChapter(chapterCode: string): readonly SyllabusSubchapter[] {
+  return chaptersByCode.get(chapterCode)?.subchapters ?? [];
+}
+
+/** The chapter that owns a sub-chapter code. */
+export function getChapterForSubchapter(subchapterCode: string): SyllabusChapter | undefined {
+  const sub = subchaptersByCode.get(subchapterCode);
+  return sub === undefined ? undefined : chaptersByCode.get(sub.chapterCode);
+}
+
+/** Type guard: is this string one of the ten official chapter codes? */
+export function isValidChapterCode(code: string): code is ChapterCode {
+  return chaptersByCode.has(code);
+}
+
+/** Type guard: is this string one of the sixty official sub-chapter codes? */
+export function isValidSubchapterCode(code: string): code is SubchapterCode {
+  return subchaptersByCode.has(code);
+}
+
+/**
+ * The code a sub-chapter at `index` of `chapterCode` must have.
+ * Used by the structural tests to prove prefix + zero-padding correctness.
+ */
+export function expectedSubchapterCode(chapterCode: string, index: SubchapterIndex): string {
+  return chapterCode + String(index).padStart(2, '0');
+}
diff --git a/frontend/src/data/topics.ts b/frontend/src/data/topics.ts
index 93a8019..aefa449 100644
--- a/frontend/src/data/topics.ts
+++ b/frontend/src/data/topics.ts
@@ -1,4 +1,6 @@
 // Topic & MockTest type definitions and mock test configuration.
+
+import { examFormat, readConfirmed } from './examBlueprint';
 // Book chapter data lives in bookChapters.generated.ts (auto-generated).
 
 export interface Question {
@@ -31,27 +33,48 @@ export interface MockTest {
   duration: number;            // total time in minutes
 }
 
+// A full mock mirrors the real paper: 10 chapters x 10 questions = 100
+// questions in 120 minutes, which is 72 seconds per question. The duration is
+// read from examBlueprint rather than restated here - it shipped as 45 minutes
+// against a 120-minute exam, a 2.7x error in every pace figure the app showed.
+const FULL_MOCK_DURATION = readConfirmed(examFormat.durationMinutes);
+const FULL_MOCK_PER_CHAPTER = 10;
+
+// The short assessment keeps the real exam's seconds-per-question so its pace
+// feedback stays comparable, rather than being its own arbitrary number.
+const QUICK_PER_CHAPTER = 5;
+const QUICK_DURATION = Math.round(
+  (FULL_MOCK_DURATION * QUICK_PER_CHAPTER) / FULL_MOCK_PER_CHAPTER
+);
+
 export const mockTests: MockTest[] = [
   {
     id: 'full-mock-1',
     name: 'Full Mock Test 1',
-    description: '10 random questions from every chapter — a fresh set each time',
-    questionsPerChapter: 10,
-    duration: 45,
+    description:
+      'Full NEC format: 100 questions in ' + FULL_MOCK_DURATION + ' minutes, drawn fresh each time',
+    questionsPerChapter: FULL_MOCK_PER_CHAPTER,
+    duration: FULL_MOCK_DURATION,
   },
   {
     id: 'full-mock-2',
+    // NOTE: this draws from the same pool with the same unseeded shuffle as
+    // Mock 1, so it is not a distinct paper. Its description used to claim a
+    // "different selection", which was not true. Real non-repetition across
+    // attempts needs per-learner history, which lives in the backend.
     name: 'Full Mock Test 2',
-    description: '10 random questions per chapter — different selection to Mock 1',
-    questionsPerChapter: 10,
-    duration: 45,
+    description:
+      'Another full-format paper: 100 questions in ' + FULL_MOCK_DURATION + ' minutes',
+    questionsPerChapter: FULL_MOCK_PER_CHAPTER,
+    duration: FULL_MOCK_DURATION,
   },
   {
     id: 'quick-test',
     name: 'Quick Assessment',
-    description: '5 questions per chapter for a fast readiness check',
-    questionsPerChapter: 5,
-    duration: 20,
+    description:
+      '50 questions in ' + QUICK_DURATION + ' minutes — half a paper, at real exam pace',
+    questionsPerChapter: QUICK_PER_CHAPTER,
+    duration: QUICK_DURATION,
   },
 ];
 
diff --git a/frontend/src/features/quiz/__tests__/components.test.tsx b/frontend/src/features/quiz/__tests__/components.test.tsx
new file mode 100644
index 0000000..0026bc0
--- /dev/null
+++ b/frontend/src/features/quiz/__tests__/components.test.tsx
@@ -0,0 +1,396 @@
+import { describe, expect, it, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { ExplanationPanel } from '../components/ExplanationPanel';
+import { OptionList } from '../components/OptionList';
+import { QuestionPalette } from '../components/QuestionPalette';
+import { QuizToolbar } from '../components/QuizToolbar';
+import { ResultSummary } from '../components/ResultSummary';
+import { ReviewScreen } from '../components/ReviewScreen';
+import { selectPalette } from '../selectors';
+import { select, toggleFlag } from '../actions';
+import { T0, makeQuestions, run, start } from './factory';
+
+describe('OptionList', () => {
+  it('reports the selected option and only reveals the key when told to', async () => {
+    const user = userEvent.setup();
+    const onChange = vi.fn();
+    const { rerender } = render(
+      <OptionList
+        label="Options"
+        options={['Alpha', 'Beta', 'Gamma']}
+        value={1}
+        correctIndex={2}
+        revealed={false}
+        onChange={onChange}
+      />
+    );
+
+    expect(screen.getByRole('radio', { name: /Beta/ })).toBeChecked();
+    // The key is index 2, but nothing may say so yet.
+    expect(screen.queryByText('Correct answer')).not.toBeInTheDocument();
+
+    await user.click(screen.getByRole('radio', { name: /Gamma/ }));
+    expect(onChange).toHaveBeenCalledWith(2);
+
+    rerender(
+      <OptionList
+        label="Options"
+        options={['Alpha', 'Beta', 'Gamma']}
+        value={1}
+        correctIndex={2}
+        revealed
+        onChange={onChange}
+      />
+    );
+    // The shared Radio primitive makes the state audible, not colour-only.
+    expect(screen.getByText('Correct answer')).toBeInTheDocument();
+    expect(screen.getByText('Incorrect answer')).toBeInTheDocument();
+  });
+
+  it('shows no key at all for a question the bank cannot grade', () => {
+    render(
+      <OptionList
+        label="Options"
+        options={['Alpha', 'Beta']}
+        value={0}
+        correctIndex={-1}
+        revealed
+        onChange={vi.fn()}
+      />
+    );
+
+    expect(screen.queryByText('Correct answer')).not.toBeInTheDocument();
+    expect(screen.getByRole('radio', { name: /Alpha/ })).toBeChecked();
+  });
+
+  it('moves the selection with the arrow keys, per the radiogroup pattern', async () => {
+    const user = userEvent.setup();
+    const onChange = vi.fn();
+    render(
+      <OptionList
+        label="Options"
+        options={['Alpha', 'Beta', 'Gamma']}
+        value={0}
+        onChange={onChange}
+      />
+    );
+
+    screen.getByRole('radio', { name: /Alpha/ }).focus();
+    await user.keyboard('{ArrowDown}');
+    expect(onChange).toHaveBeenCalledWith(1);
+
+    await user.keyboard('{ArrowUp}');
+    // Wraps back round.
+    expect(onChange).toHaveBeenCalledWith(0);
+  });
+
+  it('keeps one tab stop for the whole group', () => {
+    render(
+      <OptionList label="Options" options={['Alpha', 'Beta']} value={1} onChange={vi.fn()} />
+    );
+    expect(screen.getByRole('radio', { name: /Beta/ })).toHaveAttribute('tabindex', '0');
+    expect(screen.getByRole('radio', { name: /Alpha/ })).toHaveAttribute('tabindex', '-1');
+  });
+
+  it('locks the answer without removing it from the accessibility tree', () => {
+    render(
+      <OptionList
+        label="Options"
+        options={['Alpha', 'Beta']}
+        value={1}
+        locked
+        onChange={vi.fn()}
+      />
+    );
+    const chosen = screen.getByRole('radio', { name: /Beta/ });
+    expect(chosen).toHaveAttribute('aria-disabled', 'true');
+    expect(chosen).not.toBeDisabled();
+  });
+});
+
+describe('QuizToolbar', () => {
+  it('renders the counter and hides the timer for untimed practice', () => {
+    render(
+      <QuizToolbar
+        index={2}
+        total={30}
+        answered={5}
+        flagged={false}
+        onToggleFlag={vi.fn()}
+        bookmarked={false}
+        onToggleBookmark={vi.fn()}
+      />
+    );
+
+    expect(screen.getByText('3/30')).toBeInTheDocument();
+    expect(screen.getByText('5 answered')).toBeInTheDocument();
+    // The glyph counter is hidden from assistive tech; a sentence replaces it.
+    expect(screen.getByText('Question 3 of 30, 5 answered')).toBeInTheDocument();
+    expect(screen.queryByRole('timer')).not.toBeInTheDocument();
+  });
+
+  it('formats the deadline it is handed and escalates when time is short', () => {
+    const { rerender } = render(
+      <QuizToolbar
+        index={0}
+        total={10}
+        answered={0}
+        timeLeftMs={2_700_000}
+        flagged={false}
+        onToggleFlag={vi.fn()}
+        bookmarked={false}
+        onToggleBookmark={vi.fn()}
+      />
+    );
+    expect(screen.getByRole('timer')).toHaveTextContent('45:00');
+    expect(screen.getByRole('timer')).toHaveAttribute('aria-live', 'off');
+
+    rerender(
+      <QuizToolbar
+        index={0}
+        total={10}
+        answered={0}
+        timeLeftMs={30_000}
+        flagged={false}
+        onToggleFlag={vi.fn()}
+        bookmarked={false}
+        onToggleBookmark={vi.fn()}
+      />
+    );
+    expect(screen.getByRole('timer')).toHaveTextContent('00:30');
+    expect(screen.getByRole('timer')).toHaveAttribute('aria-live', 'assertive');
+  });
+
+  it('exposes flag and bookmark as toggle buttons', async () => {
+    const user = userEvent.setup();
+    const onToggleFlag = vi.fn();
+    const onToggleBookmark = vi.fn();
+    render(
+      <QuizToolbar
+        index={0}
+        total={10}
+        answered={0}
+        flagged
+        onToggleFlag={onToggleFlag}
+        bookmarked={false}
+        onToggleBookmark={onToggleBookmark}
+      />
+    );
+
+    expect(screen.getByRole('button', { name: /Flag/ })).toHaveAttribute('aria-pressed', 'true');
+    await user.click(screen.getByRole('button', { name: /Bookmark/ }));
+    expect(onToggleBookmark).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('QuestionPalette', () => {
+  it('describes each question state and jumps on click', async () => {
+    const user = userEvent.setup();
+    const onJump = vi.fn();
+    const state = run(start({ questions: makeQuestions(3) }), select(0, 1, T0), toggleFlag(2));
+
+    render(<QuestionPalette entries={selectPalette(state)} onJump={onJump} />);
+
+    expect(
+      screen.getByRole('button', { name: 'Question 1, answered, current' })
+    ).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Question 2, unanswered' })).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: 'Question 3, unanswered, flagged for review' })
+    ).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: /Question 3/ }));
+    expect(onJump).toHaveBeenCalledWith(2);
+  });
+});
+
+describe('ReviewScreen', () => {
+  it('lists what is unanswered and flagged', () => {
+    render(
+      <ReviewScreen
+        total={10}
+        answered={7}
+        unanswered={3}
+        flagged={2}
+        unansweredIndices={[3, 7, 9]}
+        flaggedIndices={[1, 4]}
+        onJump={vi.fn()}
+        onBack={vi.fn()}
+        onSubmit={vi.fn()}
+      />
+    );
+
+    expect(screen.getByText('4, 8, 10')).toBeInTheDocument();
+    expect(screen.getByText('2, 5')).toBeInTheDocument();
+  });
+
+  it('requires a second press to submit', async () => {
+    const user = userEvent.setup();
+    const onSubmit = vi.fn();
+    render(
+      <ReviewScreen
+        total={10}
+        answered={7}
+        unanswered={3}
+        flagged={0}
+        unansweredIndices={[3, 7, 9]}
+        flaggedIndices={[]}
+        onJump={vi.fn()}
+        onBack={vi.fn()}
+        onSubmit={onSubmit}
+      />
+    );
+
+    await user.click(screen.getByRole('button', { name: 'Submit paper' }));
+    // The first press only asks — the mock test used to end here.
+    expect(onSubmit).not.toHaveBeenCalled();
+    expect(screen.getByRole('alert')).toHaveTextContent(/cannot change your answers/i);
+
+    await user.click(screen.getByRole('button', { name: /Yes, submit with 3 blank/ }));
+    expect(onSubmit).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('ResultSummary', () => {
+  it('scores against the gradable total and says so', () => {
+    render(
+      <ResultSummary
+        summary={{
+          mode: 'topic',
+          score: 6,
+          total: 10,
+          gradableTotal: 8,
+          answered: 9,
+          skipped: 1,
+          incorrect: 2,
+          accuracyPct: 75,
+          elapsedMs: 260_000,
+          responses: [],
+        }}
+        title="Chapter 1"
+      />
+    );
+
+    expect(screen.getAllByText('6')).toHaveLength(2);
+    expect(screen.getByText('/ 8')).toBeInTheDocument();
+    expect(screen.getByText('75% accuracy')).toBeInTheDocument();
+    expect(screen.getByText(/no answer key yet/)).toBeInTheDocument();
+    expect(screen.getByText('4 minutes 20 seconds')).toBeInTheDocument();
+  });
+});
+
+describe('ExplanationPanel', () => {
+  it('renders an authored explanation', () => {
+    render(
+      <ExplanationPanel explanation="Ohm's law gives V = IR." origin="human" context="review" />
+    );
+    expect(screen.getByText(/Ohm/)).toBeInTheDocument();
+  });
+
+  it('states plainly that there is none rather than inventing one', () => {
+    render(<ExplanationPanel sourceLabel="Chapter 3" context="review" />);
+    expect(screen.getByText(/No explanation has been written/)).toBeInTheDocument();
+    expect(screen.getByText(/Refer to Chapter 3/)).toBeInTheDocument();
+  });
+
+  it('stays hidden until the answer is revealed', () => {
+    render(<ExplanationPanel explanation="Because." revealed={false} context="review" />);
+    expect(screen.queryByText('Because.')).not.toBeInTheDocument();
+  });
+
+  // Most explanations in the bank are AI drafts no human has read. The label is
+  // the whole reason a draft is allowed to ship, so it is not optional and the
+  // defaults have to fail toward showing it.
+  it('badges an unreviewed AI draft, visibly and in the accessible name', () => {
+    render(
+      <ExplanationPanel explanation="Series resonance minimises impedance." context="review" />
+    );
+    expect(screen.getByText(/AI draft/)).toBeInTheDocument();
+    expect(screen.getByText(/not yet reviewed/)).toBeInTheDocument();
+    expect(screen.getByText(/has not been checked by a person/)).toBeInTheDocument();
+    expect(
+      screen.getByRole('region', { name: /AI-generated and unreviewed/i })
+    ).toBeInTheDocument();
+  });
+
+  it('badges an unreviewed draft even when origin is omitted', () => {
+    // A caller that forgets `origin` must not silently present a draft as
+    // checked. The default is deliberately the unsafe-looking one.
+    render(<ExplanationPanel explanation="Something." context="review" />);
+    expect(screen.getByText(/not yet reviewed/)).toBeInTheDocument();
+  });
+
+  it('does not badge a human-written explanation as unreviewed', () => {
+    render(<ExplanationPanel explanation="Something." origin="human" context="review" />);
+    expect(screen.queryByText(/not yet reviewed/)).not.toBeInTheDocument();
+    expect(screen.queryByText(/AI draft/)).not.toBeInTheDocument();
+  });
+
+  it('marks a reviewed AI draft as reviewed, not as unreviewed', () => {
+    render(<ExplanationPanel explanation="Something." origin="ai_reviewed" context="review" />);
+    expect(screen.getByText('AI draft, reviewed')).toBeInTheDocument();
+    expect(screen.queryByText(/not yet reviewed/)).not.toBeInTheDocument();
+  });
+
+  // An explanation names the answer, and a wrong AI explanation mid-paper can
+  // talk a student out of a correct answer on a later question.
+  it('shows nothing at all during a timed exam, whatever the provenance', () => {
+    for (const origin of ['ai_draft', 'ai_reviewed', 'human'] as const) {
+      const { unmount } = render(
+        <ExplanationPanel explanation="Names the answer." origin={origin} context="exam" />
+      );
+      expect(screen.queryByText('Names the answer.')).not.toBeInTheDocument();
+      expect(screen.queryByRole('region')).not.toBeInTheDocument();
+      unmount();
+    }
+  });
+
+  it('defaults to the exam context, so a caller that forgets it leaks nothing', () => {
+    render(<ExplanationPanel explanation="Names the answer." origin="human" />);
+    expect(screen.queryByText('Names the answer.')).not.toBeInTheDocument();
+  });
+
+  it('renders distractor rationales by option text, never by position', () => {
+    render(
+      <ExplanationPanel
+        explanation="Impedance is minimised."
+        origin="human"
+        context="review"
+        distractors={[
+          { optionId: 'q1#AAA', optionText: 'It is maximum', why: 'That is parallel resonance.' },
+          { optionId: 'q1#BBB', optionText: 'It is infinite', why: 'Confuses the two circuits.' },
+          { optionId: 'q1#CCC', optionText: 'Filler', why: '   ' },
+        ]}
+      />
+    );
+    expect(screen.getByText('It is maximum')).toBeInTheDocument();
+    expect(screen.getByText('That is parallel resonance.')).toBeInTheDocument();
+    // Blank rationales are dropped rather than rendered as an empty bullet.
+    expect(screen.queryByText('Filler')).not.toBeInTheDocument();
+    // Options are reordered per student, so no positional language may appear.
+    expect(screen.queryByText(/second option|option B/i)).not.toBeInTheDocument();
+  });
+
+  it('renders rationales even when there is no summary', () => {
+    render(
+      <ExplanationPanel
+        context="review"
+        origin="human"
+        distractors={[{ optionId: 'q1#AAA', optionText: 'Wrong one', why: 'Because X.' }]}
+      />
+    );
+    expect(screen.getByText('Because X.')).toBeInTheDocument();
+    expect(screen.queryByText(/No explanation has been written/)).not.toBeInTheDocument();
+  });
+
+  it('offers a report path on a draft, since students are the review capacity', async () => {
+    const onReport = vi.fn();
+    render(
+      <ExplanationPanel explanation="Maybe wrong." context="review" onReport={onReport} />
+    );
+    const button = screen.getByRole('button', { name: /looks wrong/i });
+    await userEvent.click(button);
+    expect(onReport).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/frontend/src/features/quiz/__tests__/draft.test.ts b/frontend/src/features/quiz/__tests__/draft.test.ts
new file mode 100644
index 0000000..6dedebf
--- /dev/null
+++ b/frontend/src/features/quiz/__tests__/draft.test.ts
@@ -0,0 +1,262 @@
+import { describe, expect, it } from 'vitest';
+import { hydrate, navigate, select, submitAll, submitQuestion, toggleFlag } from '../actions';
+import {
+  DRAFT_PREFIX,
+  LEGACY_MOCK_DRAFT_PREFIX,
+  clearDraft,
+  draftFromState,
+  draftStorageKey,
+  parseDraft,
+  readDraft,
+  readLegacyMockDraft,
+  writeDraft,
+} from '../draft';
+import { createInitialState, quizReducer } from '../reducer';
+import { selectScore, selectSummary } from '../selectors';
+import type { QuizDraft } from '../draft';
+import { T0, makeQuestions, run, start } from './factory';
+
+const KEY = 'mock:mock-1';
+
+function liveAttempt() {
+  return run(
+    start({
+      attemptKey: KEY,
+      mode: 'mock',
+      feedback: 'deferred',
+      questions: makeQuestions(4, [1, 1, 1, 1]),
+      durationMs: 45 * 60_000,
+    }),
+    select(0, 1, T0 + 1000),
+    navigate(1, T0 + 20_000),
+    select(1, 3, T0 + 25_000),
+    toggleFlag(1)
+  );
+}
+
+describe('draftFromState', () => {
+  it('snapshots an in-progress attempt', () => {
+    const draft = draftFromState(liveAttempt(), KEY, T0 + 30_000);
+
+    expect(draft).not.toBeNull();
+    expect(draft).toMatchObject({
+      v: 1,
+      key: KEY,
+      mode: 'mock',
+      feedback: 'deferred',
+      questionIds: ['book-ch1_0', 'book-ch1_1', 'book-ch1_2', 'book-ch1_3'],
+      selections: [1, 3, null, null],
+      flagged: [1],
+      currentIndex: 1,
+      startedAt: T0,
+      endsAt: T0 + 2_700_000,
+    });
+  });
+
+  it('stores an absolute deadline, not a remaining-time counter', () => {
+    const draft = draftFromState(liveAttempt(), KEY, T0 + 30_000);
+    // Stored once at T0 and never touched again: a reload three minutes later
+    // still ends the exam at the same wall-clock moment.
+    expect(draft?.endsAt).toBe(T0 + 45 * 60_000);
+  });
+
+  it('banks only committed time, so a closed tab earns nothing', () => {
+    const draft = draftFromState(liveAttempt(), KEY, T0 + 30_000);
+    expect(draft?.accumulatedMs).toEqual([20_000, 0, 0, 0]);
+  });
+
+  it('refuses to snapshot a finished or unloaded attempt', () => {
+    const loading = createInitialState({ mode: 'mock', feedback: 'deferred', attemptKey: KEY });
+    expect(draftFromState(loading, KEY, T0)).toBeNull();
+
+    const done = quizReducer(liveAttempt(), submitAll(T0 + 40_000));
+    expect(draftFromState(done, KEY, T0 + 40_000)).toBeNull();
+  });
+});
+
+describe('draft storage round-trip', () => {
+  it('writes and reads back an identical draft', () => {
+    const draft = draftFromState(liveAttempt(), KEY, T0 + 30_000);
+    expect(draft).not.toBeNull();
+    writeDraft(draft as QuizDraft);
+
+    expect(localStorage.getItem(draftStorageKey(KEY))).not.toBeNull();
+    expect(readDraft(KEY)).toEqual(draft);
+  });
+
+  it('clears a draft', () => {
+    writeDraft(draftFromState(liveAttempt(), KEY, T0) as QuizDraft);
+    clearDraft(KEY);
+    expect(readDraft(KEY)).toBeNull();
+  });
+
+  it('rejects a draft stored under a different key', () => {
+    const draft = draftFromState(liveAttempt(), KEY, T0) as QuizDraft;
+    localStorage.setItem(draftStorageKey('other'), JSON.stringify(draft));
+    expect(readDraft('other')).toBeNull();
+  });
+
+  it('rejects corrupt, truncated and mismatched payloads', () => {
+    const good = draftFromState(liveAttempt(), KEY, T0) as QuizDraft;
+
+    localStorage.setItem(draftStorageKey(KEY), '{not json');
+    expect(readDraft(KEY)).toBeNull();
+
+    expect(parseDraft({ ...good, v: 99 }, KEY)).toBeNull();
+    expect(parseDraft({ ...good, selections: [1, 3] }, KEY)).toBeNull();
+    expect(parseDraft({ ...good, accumulatedMs: ['x', 1, 2, 3] }, KEY)).toBeNull();
+    expect(parseDraft({ ...good, questionIds: [] }, KEY)).toBeNull();
+    expect(parseDraft({ ...good, mode: 'telepathy' }, KEY)).toBeNull();
+    expect(parseDraft({ ...good, startedAt: 'soon' }, KEY)).toBeNull();
+    expect(parseDraft({ ...good, endsAt: 'later' }, KEY)).toBeNull();
+    expect(parseDraft(null, KEY)).toBeNull();
+    expect(parseDraft('a string', KEY)).toBeNull();
+  });
+
+  it('accepts a null deadline for untimed practice', () => {
+    const good = draftFromState(
+      run(start({ attemptKey: 'topic:book-ch1:30' }), select(0, 2, T0 + 500)),
+      'topic:book-ch1:30',
+      T0 + 500
+    ) as QuizDraft;
+    expect(good.endsAt).toBeNull();
+    expect(parseDraft(good, 'topic:book-ch1:30')).not.toBeNull();
+  });
+
+  it('drops out-of-range submitted and flagged indices', () => {
+    const good = draftFromState(liveAttempt(), KEY, T0) as QuizDraft;
+    const parsed = parseDraft({ ...good, submitted: [0, 99], flagged: [-1, 2] }, KEY);
+    expect(parsed?.submitted).toEqual([0]);
+    expect(parsed?.flagged).toEqual([2]);
+  });
+});
+
+describe('legacy mock draft migration', () => {
+  it('lifts an in-flight pre-engine exam into the new shape', () => {
+    localStorage.setItem(
+      `${LEGACY_MOCK_DRAFT_PREFIX}mock-1`,
+      JSON.stringify({
+        testId: 'mock-1',
+        questionIds: ['book-ch1_0', 'book-ch1_1'],
+        answers: [2, null],
+        endsAt: T0 + 600_000,
+        startedAt: T0,
+      })
+    );
+
+    const migrated = readDraft(KEY, { legacyMockTestId: 'mock-1' });
+    expect(migrated).toMatchObject({
+      key: KEY,
+      mode: 'mock',
+      feedback: 'deferred',
+      questionIds: ['book-ch1_0', 'book-ch1_1'],
+      selections: [2, null],
+      endsAt: T0 + 600_000,
+      startedAt: T0,
+      submitted: [],
+    });
+  });
+
+  it('prefers a current draft over the legacy one', () => {
+    const current = draftFromState(liveAttempt(), KEY, T0) as QuizDraft;
+    writeDraft(current);
+    localStorage.setItem(
+      `${LEGACY_MOCK_DRAFT_PREFIX}mock-1`,
+      JSON.stringify({
+        testId: 'mock-1',
+        questionIds: ['stale_0'],
+        answers: [0],
+        endsAt: T0 + 1,
+        startedAt: T0,
+      })
+    );
+
+    expect(readDraft(KEY, { legacyMockTestId: 'mock-1' })?.questionIds).toHaveLength(4);
+  });
+
+  it('clears the legacy key alongside the new one', () => {
+    localStorage.setItem(`${LEGACY_MOCK_DRAFT_PREFIX}mock-1`, '{}');
+    writeDraft(draftFromState(liveAttempt(), KEY, T0) as QuizDraft);
+    clearDraft(KEY, { legacyMockTestId: 'mock-1' });
+
+    expect(localStorage.getItem(`${DRAFT_PREFIX}${KEY}`)).toBeNull();
+    expect(localStorage.getItem(`${LEGACY_MOCK_DRAFT_PREFIX}mock-1`)).toBeNull();
+  });
+
+  it('rejects a legacy draft whose answers do not match its paper', () => {
+    localStorage.setItem(
+      `${LEGACY_MOCK_DRAFT_PREFIX}mock-1`,
+      JSON.stringify({
+        testId: 'mock-1',
+        questionIds: ['a', 'b', 'c'],
+        answers: [1],
+        endsAt: T0,
+        startedAt: T0,
+      })
+    );
+    expect(readLegacyMockDraft('mock-1', KEY)).toBeNull();
+  });
+});
+
+describe('resuming a draft', () => {
+  const questions = makeQuestions(4, [1, 1, 1, 1]);
+
+  function resume(draft: QuizDraft, at: number) {
+    return quizReducer(
+      createInitialState({ mode: draft.mode, feedback: draft.feedback, attemptKey: draft.key }),
+      hydrate({
+        attemptKey: draft.key,
+        questions,
+        at,
+        startedAt: draft.startedAt,
+        endsAt: draft.endsAt,
+        resumed: true,
+        selections: draft.selections,
+        submitted: draft.submitted,
+        flagged: draft.flagged,
+        accumulatedMs: draft.accumulatedMs,
+        currentIndex: draft.currentIndex,
+      })
+    );
+  }
+
+  it('restores every answer, flag and position', () => {
+    writeDraft(draftFromState(liveAttempt(), KEY, T0 + 30_000) as QuizDraft);
+    const state = resume(readDraft(KEY) as QuizDraft, T0 + 120_000);
+
+    expect(state.phase).toBe('active');
+    expect(state.resumed).toBe(true);
+    expect(state.selections).toEqual([1, 3, null, null]);
+    expect(state.flagged.has(1)).toBe(true);
+    expect(state.currentIndex).toBe(1);
+    // Deadline unchanged by the reload: still 45 minutes after the original
+    // start, not 45 minutes from now.
+    expect(state.timing.endsAt).toBe(T0 + 2_700_000);
+  });
+
+  it('scores an expired attempt instead of handing back a fresh timer', () => {
+    writeDraft(draftFromState(liveAttempt(), KEY, T0 + 30_000) as QuizDraft);
+    // The student closed the tab and came back an hour later.
+    const state = resume(readDraft(KEY) as QuizDraft, T0 + 3_600_000);
+
+    expect(state.phase).toBe('done');
+    expect(state.timing.endsAt).toBe(T0 + 2_700_000);
+    expect(selectScore(state)).toBe(1);
+    expect(selectSummary(state).skipped).toBe(2);
+    expect(state.responses).toHaveLength(4);
+  });
+
+  it('keeps committed practice answers committed across a resume', () => {
+    const key = 'topic:book-ch1:4';
+    const practice = run(
+      start({ attemptKey: key, questions, feedback: 'immediate' }),
+      select(0, 1, T0 + 1000),
+      submitQuestion(0, T0 + 8000)
+    );
+    writeDraft(draftFromState(practice, key, T0 + 8000) as QuizDraft);
+
+    const restored = resume(readDraft(key) as QuizDraft, T0 + 9000);
+    expect(restored.submitted.has(0)).toBe(true);
+    expect(selectScore(restored)).toBe(1);
+  });
+});
diff --git a/frontend/src/features/quiz/__tests__/factory.ts b/frontend/src/features/quiz/__tests__/factory.ts
new file mode 100644
index 0000000..8017024
--- /dev/null
+++ b/frontend/src/features/quiz/__tests__/factory.ts
@@ -0,0 +1,61 @@
+/** Test helpers for the quiz engine. Not a test file. */
+
+import { hydrate } from '../actions';
+import { createInitialState, quizReducer } from '../reducer';
+import type { FeedbackMode, Question, QuizMode, QuizState } from '../types';
+
+/** `correctIndex: -1` reproduces the no-answer-key sentinel from localData. */
+export function makeQuestion(i: number, correctIndex = 1, topicId = 'book-ch1'): Question {
+  return {
+    id: `${topicId}_${i}`,
+    topicId,
+    question: `Question ${i}?`,
+    options: ['A', 'B', 'C', 'D'],
+    correctIndex,
+  };
+}
+
+export function makeQuestions(n: number, correctIndexes?: number[]): Question[] {
+  return Array.from({ length: n }, (_, i) => makeQuestion(i, correctIndexes?.[i] ?? 1));
+}
+
+export const T0 = 1_700_000_000_000;
+
+export interface StartOptions {
+  mode?: QuizMode;
+  feedback?: FeedbackMode;
+  questions?: Question[];
+  at?: number;
+  durationMs?: number | null;
+  attemptKey?: string | null;
+}
+
+/** A hydrated, active attempt. */
+export function start(options: StartOptions = {}): QuizState {
+  const {
+    mode = 'topic',
+    feedback = 'immediate',
+    questions = makeQuestions(3),
+    at = T0,
+    durationMs = null,
+    attemptKey = 'test:attempt',
+  } = options;
+  return quizReducer(
+    createInitialState({ mode, feedback, attemptKey }),
+    hydrate({
+      attemptKey,
+      questions,
+      at,
+      startedAt: at,
+      endsAt: durationMs === null ? null : at + durationMs,
+    })
+  );
+}
+
+/** Applies a sequence of actions, so a test reads as a story. */
+export function run(
+  state: QuizState,
+  ...actions: Parameters<typeof quizReducer>[1][]
+): QuizState {
+  return actions.reduce(quizReducer, state);
+}
diff --git a/frontend/src/features/quiz/__tests__/guess.test.ts b/frontend/src/features/quiz/__tests__/guess.test.ts
new file mode 100644
index 0000000..77b08dd
--- /dev/null
+++ b/frontend/src/features/quiz/__tests__/guess.test.ts
@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest';
+import { navigate, select, submitAll, submitQuestion } from '../actions';
+import {
+  GUESS_FLOOR_MS,
+  guessThresholdMs,
+  isGuessLatency,
+  markGuesses,
+  median,
+} from '../guess';
+import type { ResponseRecord } from '../types';
+import { T0, makeQuestions, run, start } from './factory';
+
+function record(timeSpentMs: number, chosenIndex: number | null = 1): ResponseRecord {
+  return {
+    questionId: `q${timeSpentMs}`,
+    topicId: 'book-ch1',
+    chosenIndex,
+    correct: false,
+    timeSpentMs,
+    mode: 'topic',
+    flaggedGuess: false,
+    timestamp: T0,
+  };
+}
+
+describe('median', () => {
+  it('handles odd, even and empty samples without mutating the input', () => {
+    const sample = [5, 1, 3];
+    expect(median(sample)).toBe(3);
+    expect(sample).toEqual([5, 1, 3]);
+    expect(median([1, 2, 3, 4])).toBe(2.5);
+    expect(median([])).toBe(0);
+  });
+});
+
+describe('guessThresholdMs', () => {
+  it('falls back to the absolute floor on a fast session', () => {
+    // 35% of a 3s median is 1.05s, which would flag nothing. The floor is what
+    // makes the rule useful when every answer is quick.
+    expect(guessThresholdMs([3000, 3000, 3000])).toBe(GUESS_FLOOR_MS);
+  });
+
+  it('scales with the session once answers are slow', () => {
+    // Median 60s -> 21s. A student who normally takes a minute is plainly
+    // guessing at eight seconds, which the 4s floor alone would wave through.
+    expect(guessThresholdMs([50_000, 60_000, 70_000])).toBe(21_000);
+  });
+
+  it('uses the floor when there is no sample at all', () => {
+    expect(guessThresholdMs([])).toBe(GUESS_FLOOR_MS);
+  });
+
+  it('is strict: an answer exactly at the threshold is not a guess', () => {
+    expect(isGuessLatency(4000, [3000])).toBe(false);
+    expect(isGuessLatency(3999, [3000])).toBe(true);
+    expect(isGuessLatency(20_999, [60_000])).toBe(true);
+    expect(isGuessLatency(21_000, [60_000])).toBe(false);
+  });
+});
+
+describe('markGuesses', () => {
+  it('flags only the answers under the threshold', () => {
+    const marked = markGuesses([record(1000), record(60_000), record(90_000)]);
+    // Median 60s -> threshold 21s.
+    expect(marked.map((r) => r.flaggedGuess)).toEqual([true, false, false]);
+  });
+
+  it('never flags a blank, and blanks do not drag the median down', () => {
+    const marked = markGuesses([record(0, null), record(60_000), record(80_000)]);
+    expect(marked[0].flaggedGuess).toBe(false);
+    // Median over answers only is 70s -> 24.5s, so the 60s answer is safe.
+    expect(marked[1].flaggedGuess).toBe(false);
+  });
+
+  it('re-evaluates earlier records as the session median moves', () => {
+    const early = markGuesses([record(9000), record(11_000)]);
+    // Median 10s -> threshold 4s (the floor), so neither looks like a guess.
+    expect(early.every((r) => !r.flaggedGuess)).toBe(true);
+
+    const later = markGuesses([...early, record(120_000), record(140_000)]);
+    // Median is now 65.5s -> 22.9s, and the two fast answers are revealed as
+    // outliers against how this student actually works.
+    expect(later.map((r) => r.flaggedGuess)).toEqual([true, true, false, false]);
+  });
+
+  it('returns the same record objects when nothing changed', () => {
+    const input = [record(60_000), record(80_000)];
+    const marked = markGuesses(input);
+    expect(marked[0]).toBe(input[0]);
+  });
+});
+
+describe('guess detection through the reducer', () => {
+  it('flags a fast answer in a slow session', () => {
+    const state = run(
+      start({ questions: makeQuestions(3, [1, 1, 1]) }),
+      // 80 seconds on Q1.
+      select(0, 1, T0 + 1000),
+      submitQuestion(0, T0 + 80_000),
+      navigate(1, T0 + 80_000),
+      // 100 seconds on Q2.
+      select(1, 1, T0 + 100_000),
+      submitQuestion(1, T0 + 180_000),
+      navigate(2, T0 + 180_000),
+      // 2 seconds on Q3 — a tap to move on.
+      select(2, 2, T0 + 181_000),
+      submitQuestion(2, T0 + 182_000)
+    );
+
+    expect(state.responses.map((r) => r.flaggedGuess)).toEqual([false, false, true]);
+  });
+
+  it('flags nothing when every answer took real time', () => {
+    const state = run(
+      start({ feedback: 'deferred', mode: 'mock', questions: makeQuestions(2, [1, 1]) }),
+      select(0, 1, T0 + 1000),
+      navigate(1, T0 + 30_000),
+      select(1, 1, T0 + 40_000),
+      submitAll(T0 + 60_000)
+    );
+
+    expect(state.responses.every((r) => !r.flaggedGuess)).toBe(true);
+  });
+});
diff --git a/frontend/src/features/quiz/__tests__/reducer.test.ts b/frontend/src/features/quiz/__tests__/reducer.test.ts
new file mode 100644
index 0000000..6eb4063
--- /dev/null
+++ b/frontend/src/features/quiz/__tests__/reducer.test.ts
@@ -0,0 +1,470 @@
+import { describe, expect, it } from 'vitest';
+import {
+  enterReview,
+  exitReview,
+  hydrate,
+  navigate,
+  pause,
+  resume,
+  select,
+  submitAll,
+  submitQuestion,
+  toggleBookmark,
+  toggleFlag,
+} from '../actions';
+import { createInitialState, quizReducer, timeSpentAt } from '../reducer';
+import {
+  selectAnsweredCount,
+  selectFlaggedCount,
+  selectFlaggedIndices,
+  selectIsRevealed,
+  selectPalette,
+  selectScore,
+  selectSummary,
+  selectTimeLeftMs,
+  selectUnansweredCount,
+  selectUnansweredIndices,
+  selectVerdict,
+} from '../selectors';
+import { T0, makeQuestions, run, start } from './factory';
+
+describe('quizReducer — selection persistence', () => {
+  // The bug the three practice pages shipped: navigation reset a scalar
+  // `selectedAnswer`, so going back erased the answer and the feedback block
+  // compared null against correctIndex and rendered "Incorrect".
+  it('keeps a selection when navigating away and back', () => {
+    const state = run(
+      start(),
+      select(0, 2, T0 + 1000),
+      navigate(1, T0 + 2000),
+      navigate(0, T0 + 3000)
+    );
+
+    expect(state.selections[0]).toBe(2);
+    expect(state.currentIndex).toBe(0);
+  });
+
+  it('restores both the choice and the verdict on a revisited answered question', () => {
+    const state = run(
+      start({ questions: makeQuestions(2, [1, 1]) }),
+      select(0, 1, T0 + 1000),
+      submitQuestion(0, T0 + 5000),
+      navigate(1, T0 + 6000),
+      navigate(0, T0 + 7000)
+    );
+
+    expect(state.selections[0]).toBe(1);
+    expect(selectIsRevealed(state, 0)).toBe(true);
+    expect(selectVerdict(state, 0)).toBe('correct');
+  });
+
+  it('keeps a wrong answer reading as incorrect on revisit, not as unanswered', () => {
+    const state = run(
+      start({ questions: makeQuestions(2, [1, 1]) }),
+      select(0, 3, T0 + 1000),
+      submitQuestion(0, T0 + 5000),
+      navigate(1, T0 + 6000),
+      navigate(0, T0 + 7000)
+    );
+
+    expect(selectVerdict(state, 0)).toBe('incorrect');
+  });
+
+  it('shows no verdict on a forward question that was never answered', () => {
+    const state = run(
+      start(),
+      select(0, 1, T0 + 1000),
+      submitQuestion(0, T0 + 5000),
+      navigate(1, T0 + 6000)
+    );
+
+    expect(selectVerdict(state, 1)).toBe('unanswered');
+    expect(selectIsRevealed(state, 1)).toBe(false);
+  });
+
+  it('refuses to change a committed answer', () => {
+    const state = run(
+      start(),
+      select(0, 1, T0 + 100),
+      submitQuestion(0, T0 + 5000),
+      select(0, 3, T0 + 6000)
+    );
+
+    expect(state.selections[0]).toBe(1);
+  });
+
+  it('clamps navigation to the paper rather than running off the end', () => {
+    const base = start({ questions: makeQuestions(3) });
+    expect(quizReducer(base, navigate(99, T0 + 10)).currentIndex).toBe(2);
+    expect(quizReducer(base, navigate(-5, T0 + 10)).currentIndex).toBe(0);
+  });
+});
+
+describe('quizReducer — feedback modes', () => {
+  it('immediate: reveals the submitted question only', () => {
+    const state = run(
+      start({ feedback: 'immediate' }),
+      select(0, 1, T0 + 100),
+      submitQuestion(0, T0 + 4000)
+    );
+
+    expect(selectIsRevealed(state, 0)).toBe(true);
+    expect(selectIsRevealed(state, 1)).toBe(false);
+  });
+
+  it('deferred: reveals nothing until the paper is submitted', () => {
+    const answering = run(
+      start({ feedback: 'deferred', mode: 'mock' }),
+      select(0, 1, T0 + 100),
+      select(1, 1, T0 + 200)
+    );
+
+    expect(selectIsRevealed(answering, 0)).toBe(false);
+    // The pick is still visible to the student — "pending", not "correct".
+    expect(selectVerdict(answering, 0)).toBe('pending');
+
+    const submitted = quizReducer(answering, submitAll(T0 + 60_000));
+    expect(selectIsRevealed(submitted, 0)).toBe(true);
+    expect(selectVerdict(submitted, 0)).toBe('correct');
+  });
+
+  it('deferred: answers stay editable before the paper goes in', () => {
+    const state = run(
+      start({ feedback: 'deferred', mode: 'mock' }),
+      select(0, 1, T0 + 100),
+      select(0, 3, T0 + 200)
+    );
+
+    expect(state.selections[0]).toBe(3);
+  });
+
+  it('reports unkeyed questions as unkeyed rather than incorrect', () => {
+    const state = run(
+      start({ questions: makeQuestions(1, [-1]) }),
+      select(0, 2, T0 + 100),
+      submitQuestion(0, T0 + 9000)
+    );
+
+    expect(selectVerdict(state, 0)).toBe('unkeyed');
+    expect(selectScore(state)).toBe(0);
+    expect(selectSummary(state).gradableTotal).toBe(0);
+    expect(selectSummary(state).accuracyPct).toBe(0);
+  });
+});
+
+describe('quizReducer — derived score', () => {
+  it('counts only committed correct answers', () => {
+    const state = run(
+      start({ questions: makeQuestions(3, [1, 2, 3]) }),
+      select(0, 1, T0 + 100),
+      submitQuestion(0, T0 + 9000),
+      navigate(1, T0 + 9100),
+      select(1, 0, T0 + 9200),
+      submitQuestion(1, T0 + 18000),
+      navigate(2, T0 + 18100),
+      select(2, 3, T0 + 18200)
+    );
+
+    // Q3 is selected but not committed, so it is not scored yet.
+    expect(selectScore(state)).toBe(1);
+    expect(quizReducer(state, submitAll(T0 + 30000)).selections[2]).toBe(3);
+    expect(selectScore(quizReducer(state, submitAll(T0 + 30000)))).toBe(2);
+  });
+
+  it('does not double-count a re-submitted question', () => {
+    // The pages did `setScore(s => s + 1)` inside submit; any re-entry inflated
+    // the score. Score is derived here, and submitting twice is a no-op.
+    const once = run(start(), select(0, 1, T0 + 100), submitQuestion(0, T0 + 9000));
+    const twice = run(
+      once,
+      submitQuestion(0, T0 + 9100),
+      submitQuestion(0, T0 + 9200),
+      submitQuestion(0, T0 + 9300)
+    );
+
+    expect(selectScore(twice)).toBe(1);
+    expect(twice.responses).toHaveLength(1);
+    expect(twice).toBe(once);
+  });
+
+  it('submitAll is idempotent and terminal', () => {
+    const done = run(
+      start({ questions: makeQuestions(2, [1, 1]) }),
+      select(0, 1, T0 + 100),
+      submitAll(T0 + 10_000)
+    );
+    const again = quizReducer(done, submitAll(T0 + 20_000));
+
+    expect(again).toBe(done);
+    expect(done.phase).toBe('done');
+    expect(selectScore(done)).toBe(1);
+    expect(done.responses).toHaveLength(2);
+  });
+
+  it('refuses a submit with no selection', () => {
+    const state = start();
+    expect(quizReducer(state, submitQuestion(0, T0 + 500))).toBe(state);
+  });
+
+  it('counts answered, unanswered and skipped consistently', () => {
+    const state = run(
+      start({ questions: makeQuestions(4) }),
+      select(0, 1, T0 + 10),
+      select(2, 0, T0 + 20)
+    );
+
+    expect(selectAnsweredCount(state)).toBe(2);
+    expect(selectUnansweredCount(state)).toBe(2);
+    expect(selectUnansweredIndices(state)).toEqual([1, 3]);
+    expect(selectSummary(quizReducer(state, submitAll(T0 + 100))).skipped).toBe(2);
+  });
+
+  it('separates incorrect from skipped in the summary', () => {
+    const state = run(
+      start({ questions: makeQuestions(3, [1, 1, 1]) }),
+      select(0, 1, T0 + 10),
+      select(1, 0, T0 + 20),
+      submitAll(T0 + 100)
+    );
+    const summary = selectSummary(state);
+
+    expect(summary.score).toBe(1);
+    expect(summary.incorrect).toBe(1);
+    expect(summary.skipped).toBe(1);
+    expect(summary.total).toBe(3);
+    expect(summary.gradableTotal).toBe(3);
+    expect(summary.accuracyPct).toBe(33);
+  });
+});
+
+describe('quizReducer — flags and bookmarks', () => {
+  it('toggles a flag on and off', () => {
+    const on = quizReducer(start(), toggleFlag(1));
+    expect(selectFlaggedCount(on)).toBe(1);
+    expect(selectFlaggedIndices(on)).toEqual([1]);
+
+    const off = quizReducer(on, toggleFlag(1));
+    expect(selectFlaggedCount(off)).toBe(0);
+  });
+
+  it('ignores a flag outside the paper', () => {
+    const state = start({ questions: makeQuestions(2) });
+    expect(quizReducer(state, toggleFlag(7))).toBe(state);
+  });
+
+  it('keeps flags through navigation and submission', () => {
+    const state = run(
+      start(),
+      toggleFlag(0),
+      select(0, 1, T0 + 10),
+      submitQuestion(0, T0 + 5000),
+      navigate(2, T0 + 5100)
+    );
+
+    expect(state.flagged.has(0)).toBe(true);
+  });
+
+  it('toggles bookmarks by question id', () => {
+    const state = start();
+    const id = state.questions[0].id;
+    const on = quizReducer(state, toggleBookmark(id));
+    expect(on.bookmarked.has(id)).toBe(true);
+    expect(quizReducer(on, toggleBookmark(id)).bookmarked.has(id)).toBe(false);
+  });
+
+  it('reports a palette with overlapping states', () => {
+    const state = run(start({ questions: makeQuestions(3) }), select(0, 1, T0 + 10), toggleFlag(0));
+    const palette = selectPalette(state);
+
+    expect(palette[0]).toMatchObject({ answered: true, flagged: true, current: true });
+    expect(palette[1]).toMatchObject({ answered: false, flagged: false, current: false });
+  });
+});
+
+describe('quizReducer — timing', () => {
+  it('accrues per-question time and banks it on navigation', () => {
+    const state = run(start(), navigate(1, T0 + 7000), navigate(2, T0 + 9500));
+
+    expect(state.timing.accumulatedMs[0]).toBe(7000);
+    expect(state.timing.accumulatedMs[1]).toBe(2500);
+    expect(state.timing.accumulatedMs[2]).toBe(0);
+    expect(timeSpentAt(state, 2, T0 + 10_500)).toBe(1000);
+  });
+
+  it('records the banked time on the response', () => {
+    const state = run(start(), select(0, 1, T0 + 1000), submitQuestion(0, T0 + 12_000));
+    expect(state.responses[0].timeSpentMs).toBe(12_000);
+  });
+
+  it('stops the clock while the tab is hidden', () => {
+    const state = run(
+      start(),
+      pause(T0 + 3000),
+      resume(T0 + 100_000),
+      select(0, 1, T0 + 100_500),
+      submitQuestion(0, T0 + 104_000)
+    );
+
+    // 3s before hiding plus 4s after returning. The 97s the tab spent in the
+    // background is not study time.
+    expect(state.responses[0].timeSpentMs).toBe(7000);
+    expect(state.timing.paused).toBe(false);
+  });
+
+  it('ignores a resume that was not preceded by a pause', () => {
+    const state = start();
+    expect(quizReducer(state, resume(T0 + 500))).toBe(state);
+  });
+
+  it('never lets a stale timestamp run the clock backwards', () => {
+    const state = run(start(), navigate(1, T0 - 50_000));
+    expect(state.timing.accumulatedMs[0]).toBe(0);
+  });
+
+  it('banks and stops the clock on the review screen, and restarts on exit', () => {
+    const reviewing = run(start(), enterReview(T0 + 4000));
+    expect(reviewing.phase).toBe('review');
+    expect(reviewing.timing.accumulatedMs[0]).toBe(4000);
+    expect(reviewing.timing.viewStartedAt).toBeNull();
+
+    const back = quizReducer(reviewing, exitReview(T0 + 30_000));
+    expect(back.phase).toBe('active');
+    expect(back.timing.viewStartedAt).toBe(T0 + 30_000);
+    // Thirty seconds on the review screen is not thirty seconds on question 1.
+    expect(back.timing.accumulatedMs[0]).toBe(4000);
+  });
+
+  it('derives time left from the absolute deadline', () => {
+    const state = start({ durationMs: 45 * 60_000 });
+    expect(selectTimeLeftMs(state, T0)).toBe(2_700_000);
+    expect(selectTimeLeftMs(state, T0 + 2_700_001)).toBe(0);
+    expect(selectTimeLeftMs(start(), T0)).toBeNull();
+  });
+});
+
+describe('quizReducer — hydrate', () => {
+  it('restores selections, flags, index and banked time', () => {
+    const questions = makeQuestions(3, [1, 1, 1]);
+    const state = quizReducer(
+      createInitialState({ mode: 'topic', feedback: 'immediate', attemptKey: 'k' }),
+      hydrate({
+        attemptKey: 'k',
+        questions,
+        at: T0 + 500,
+        startedAt: T0,
+        endsAt: null,
+        selections: [1, null, 3],
+        submitted: [0],
+        flagged: [2],
+        accumulatedMs: [4000, 0, 1200],
+        currentIndex: 2,
+        resumed: true,
+      })
+    );
+
+    expect(state.phase).toBe('active');
+    expect(state.selections).toEqual([1, null, 3]);
+    expect(state.submitted.has(0)).toBe(true);
+    expect(state.flagged.has(2)).toBe(true);
+    expect(state.currentIndex).toBe(2);
+    expect(state.timing.accumulatedMs).toEqual([4000, 0, 1200]);
+    expect(state.resumed).toBe(true);
+    expect(selectScore(state)).toBe(1);
+  });
+
+  it('discards restored arrays that describe a different-length paper', () => {
+    const state = quizReducer(
+      createInitialState({ mode: 'mock', feedback: 'deferred', attemptKey: 'k' }),
+      hydrate({
+        attemptKey: 'k',
+        questions: makeQuestions(3),
+        at: T0,
+        startedAt: T0,
+        endsAt: null,
+        selections: [1, 2],
+        accumulatedMs: [1, 2, 3, 4],
+      })
+    );
+
+    expect(state.selections).toEqual([null, null, null]);
+    expect(state.timing.accumulatedMs).toEqual([0, 0, 0]);
+  });
+
+  it('finishes immediately when the restored deadline has already passed', () => {
+    const state = quizReducer(
+      createInitialState({ mode: 'mock', feedback: 'deferred', attemptKey: 'k' }),
+      hydrate({
+        attemptKey: 'k',
+        questions: makeQuestions(3, [1, 1, 1]),
+        at: T0 + 10_000,
+        startedAt: T0 - 2_700_000,
+        endsAt: T0 - 1000,
+        selections: [1, 0, null],
+        accumulatedMs: [5000, 5000, 0],
+      })
+    );
+
+    expect(state.phase).toBe('done');
+    expect(selectScore(state)).toBe(1);
+    expect(selectSummary(state).skipped).toBe(1);
+    // No extra time is credited for the stretch after the deadline.
+    expect(state.timing.accumulatedMs).toEqual([5000, 5000, 0]);
+  });
+
+  it('ignores an empty paper', () => {
+    const initial = createInitialState({ mode: 'quick', feedback: 'immediate' });
+    const state = quizReducer(
+      initial,
+      hydrate({ attemptKey: null, questions: [], at: T0, startedAt: T0, endsAt: null })
+    );
+    expect(state).toBe(initial);
+    expect(state.phase).toBe('loading');
+  });
+
+  it('clamps a restored index that is past the end of the paper', () => {
+    const state = quizReducer(
+      createInitialState({ mode: 'topic', feedback: 'immediate', attemptKey: 'k' }),
+      hydrate({
+        attemptKey: 'k',
+        questions: makeQuestions(2),
+        at: T0,
+        startedAt: T0,
+        endsAt: null,
+        currentIndex: 99,
+      })
+    );
+    expect(state.currentIndex).toBe(1);
+  });
+});
+
+describe('quizReducer — response records', () => {
+  it('emits the analytics shape for each answer', () => {
+    const state = run(
+      start({ mode: 'quick', questions: makeQuestions(1, [1]) }),
+      select(0, 1, T0 + 1000),
+      submitQuestion(0, T0 + 11_000)
+    );
+
+    expect(state.responses[0]).toEqual({
+      questionId: 'book-ch1_0',
+      topicId: 'book-ch1',
+      chosenIndex: 1,
+      correct: true,
+      timeSpentMs: 11_000,
+      mode: 'quick',
+      flaggedGuess: false,
+      timestamp: T0 + 11_000,
+    });
+  });
+
+  it('records a blank for a question that was never answered', () => {
+    const state = run(
+      start({ questions: makeQuestions(2, [1, 1]) }),
+      select(0, 1, T0 + 100),
+      submitAll(T0 + 20_000)
+    );
+    const blank = state.responses.find((r) => r.questionId === 'book-ch1_1');
+
+    expect(blank).toMatchObject({ chosenIndex: null, correct: false, flaggedGuess: false });
+  });
+});
diff --git a/frontend/src/features/quiz/__tests__/useQuiz.test.tsx b/frontend/src/features/quiz/__tests__/useQuiz.test.tsx
new file mode 100644
index 0000000..2744460
--- /dev/null
+++ b/frontend/src/features/quiz/__tests__/useQuiz.test.tsx
@@ -0,0 +1,190 @@
+import { describe, expect, it } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { draftStorageKey, readDraft } from '../draft';
+import { QuestionCard } from '../components/QuestionCard';
+import { QuizActionBar } from '../components/QuizActionBar';
+import { useQuiz } from '../useQuiz';
+import type { FeedbackMode, Question } from '../types';
+import { getProgress } from '../../../services/localData';
+import { makeQuestions } from './factory';
+
+const QUESTIONS = makeQuestions(3, [1, 2, 3]);
+
+function Harness({
+  attemptKey,
+  questions = QUESTIONS,
+  feedback = 'immediate',
+}: {
+  attemptKey: string;
+  questions?: Question[];
+  feedback?: FeedbackMode;
+}) {
+  const quiz = useQuiz({
+    mode: 'topic',
+    feedback,
+    attemptKey,
+    autosaveDelayMs: 0,
+    loadQuestions: async () => questions,
+    resolveQuestions: async (ids) => {
+      const byId = new Map(questions.map((q) => [q.id, q]));
+      return ids.map((id) => byId.get(id)).filter((q): q is Question => q !== undefined);
+    },
+  });
+
+  if (quiz.state.phase === 'loading') return <p>Loading…</p>;
+  if (quiz.current === undefined) return <p>Empty</p>;
+
+  return (
+    <div>
+      {quiz.state.resumed && <p>Attempt resumed</p>}
+      <p>Score: {quiz.summary.score}</p>
+      <p>Answered: {quiz.counts.answered}</p>
+      <QuestionCard
+        index={quiz.state.currentIndex}
+        total={quiz.counts.total}
+        questionText={quiz.current.question}
+        options={quiz.current.options}
+        selection={quiz.selection}
+        onSelect={quiz.selectOption}
+        correctIndex={quiz.current.correctIndex}
+        revealed={quiz.isRevealed}
+        verdict={quiz.verdict}
+        locked={quiz.isSubmitted}
+      />
+      <QuizActionBar
+        onPrev={quiz.prev}
+        onNext={quiz.next}
+        // Deferred mode has nothing to submit per question, so the primary
+        // action stays Next/Finish.
+        onSubmit={feedback === 'immediate' ? quiz.submitCurrent : undefined}
+        onFinish={quiz.submitAll}
+        canPrev={quiz.state.currentIndex > 0}
+        canNext={!quiz.isLast}
+        canSubmit={quiz.canSubmitCurrent}
+        isLast={quiz.isLast}
+      />
+    </div>
+  );
+}
+
+async function ready() {
+  await waitFor(() => expect(screen.getByRole('radiogroup')).toBeInTheDocument());
+}
+
+describe('useQuiz', () => {
+  it('loads a paper and answers a question', async () => {
+    const user = userEvent.setup();
+    render(<Harness attemptKey="topic:ch1:3" />);
+    await ready();
+
+    await user.click(screen.getByRole('radio', { name: /^B/ }));
+    expect(screen.getByRole('radio', { name: /^B/ })).toBeChecked();
+    expect(screen.getByText('Answered: 1')).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: 'Submit' }));
+    expect(screen.getByRole('status')).toHaveTextContent(/Correct/);
+    expect(screen.getByText('Score: 1')).toBeInTheDocument();
+  });
+
+  it('keeps the answer and the verdict across navigation', async () => {
+    const user = userEvent.setup();
+    render(<Harness attemptKey="topic:ch1:3" />);
+    await ready();
+
+    await user.click(screen.getByRole('radio', { name: /^B/ }));
+    await user.click(screen.getByRole('button', { name: 'Submit' }));
+    await user.click(screen.getByRole('button', { name: /Next/ }));
+
+    // A forward, unanswered question shows no verdict.
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: /Previous/ }));
+    expect(screen.getByRole('status')).toHaveTextContent(/Correct/);
+    expect(screen.getByRole('status')).not.toHaveTextContent(/Incorrect/);
+    expect(screen.getByRole('radio', { name: /^B/ })).toBeChecked();
+  });
+
+  it('does not inflate the score when submit is pressed repeatedly', async () => {
+    const user = userEvent.setup();
+    render(<Harness attemptKey="topic:ch1:3" />);
+    await ready();
+
+    await user.click(screen.getByRole('radio', { name: /^B/ }));
+    const submit = screen.getByRole('button', { name: 'Submit' });
+    await user.tripleClick(submit);
+
+    expect(screen.getByText('Score: 1')).toBeInTheDocument();
+  });
+
+  it('autosaves the attempt and resumes it on a remount', async () => {
+    const user = userEvent.setup();
+    const key = 'topic:ch1:3';
+    const first = render(<Harness attemptKey={key} />);
+    await ready();
+
+    await user.click(screen.getByRole('radio', { name: /^C/ }));
+    await waitFor(() => expect(localStorage.getItem(draftStorageKey(key))).not.toBeNull());
+    expect(readDraft(key)?.selections).toEqual([2, null, null]);
+
+    first.unmount();
+    render(<Harness attemptKey={key} />);
+    await ready();
+
+    await waitFor(() => expect(screen.getByText('Attempt resumed')).toBeInTheDocument());
+    expect(screen.getByRole('radio', { name: /^C/ })).toBeChecked();
+  });
+
+  it('discards a draft whose questions no longer resolve', async () => {
+    const user = userEvent.setup();
+    const key = 'topic:ch1:3';
+    const first = render(<Harness attemptKey={key} />);
+    await ready();
+    await user.click(screen.getByRole('radio', { name: /^C/ }));
+    await waitFor(() => expect(localStorage.getItem(draftStorageKey(key))).not.toBeNull());
+    first.unmount();
+
+    // The chapter data changed under us: only one of the three ids resolves.
+    render(<Harness attemptKey={key} questions={[QUESTIONS[0]]} />);
+    await ready();
+
+    expect(screen.queryByText('Attempt resumed')).not.toBeInTheDocument();
+    expect(screen.getByRole('radio', { name: /^C/ })).not.toBeChecked();
+    // The unusable draft was replaced by one describing the paper we can build.
+    await waitFor(() => expect(readDraft(key)?.questionIds).toEqual([QUESTIONS[0].id]));
+  });
+
+  it('writes answers through to per-topic progress exactly once', async () => {
+    const user = userEvent.setup();
+    render(<Harness attemptKey="topic:ch1:3" />);
+    await ready();
+
+    await user.click(screen.getByRole('radio', { name: /^B/ }));
+    await user.click(screen.getByRole('button', { name: 'Submit' }));
+
+    await waitFor(() => {
+      const entry = getProgress()['book-ch1'];
+      expect(entry.attempted).toEqual(['book-ch1_0']);
+      expect(entry.correct).toEqual(['book-ch1_0']);
+    });
+  });
+
+  it('defers the verdict in deferred mode until the paper is submitted', async () => {
+    const user = userEvent.setup();
+    render(<Harness attemptKey="mock:m1" feedback="deferred" />);
+    await ready();
+
+    await user.click(screen.getByRole('radio', { name: /^B/ }));
+    // Still editable, and no verdict yet.
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+    expect(screen.getByText('Score: 0')).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: /Next/ }));
+    await user.click(screen.getByRole('button', { name: /Next/ }));
+    await user.click(screen.getByRole('button', { name: 'Finish' }));
+
+    expect(screen.getByText('Score: 1')).toBeInTheDocument();
+    // The draft is gone — a finished attempt must not be resumable.
+    await waitFor(() => expect(localStorage.getItem(draftStorageKey('mock:m1'))).toBeNull());
+  });
+});
diff --git a/frontend/src/features/quiz/__tests__/useQuizKeyboard.test.tsx b/frontend/src/features/quiz/__tests__/useQuizKeyboard.test.tsx
new file mode 100644
index 0000000..56a3a67
--- /dev/null
+++ b/frontend/src/features/quiz/__tests__/useQuizKeyboard.test.tsx
@@ -0,0 +1,165 @@
+import { describe, expect, it, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { isTextEntryTarget, optionIndexForKey, useQuizKeyboard } from '../useQuizKeyboard';
+import type { QuizKeyboardHandlers } from '../useQuizKeyboard';
+
+function makeHandlers(): QuizKeyboardHandlers {
+  return {
+    onSelectOption: vi.fn(),
+    onSubmitOrAdvance: vi.fn(),
+    onPrev: vi.fn(),
+    onNext: vi.fn(),
+    onToggleFlag: vi.fn(),
+    onToggleBookmark: vi.fn(),
+  };
+}
+
+function Harness({
+  handlers,
+  enabled = true,
+  optionCount = 4,
+}: {
+  handlers: QuizKeyboardHandlers;
+  enabled?: boolean;
+  optionCount?: number;
+}) {
+  useQuizKeyboard({ ...handlers, enabled, optionCount });
+  return (
+    <div>
+      <input aria-label="search" type="search" />
+      <textarea aria-label="notes" />
+      <button type="button">a button</button>
+      <p>body</p>
+    </div>
+  );
+}
+
+describe('optionIndexForKey', () => {
+  it('maps digits and letters, and nothing else', () => {
+    expect(optionIndexForKey('1')).toBe(0);
+    expect(optionIndexForKey('4')).toBe(3);
+    expect(optionIndexForKey('a')).toBe(0);
+    expect(optionIndexForKey('D')).toBe(3);
+    expect(optionIndexForKey('0')).toBe(-1);
+    expect(optionIndexForKey('z')).toBe(-1);
+    expect(optionIndexForKey('Enter')).toBe(-1);
+  });
+});
+
+describe('isTextEntryTarget', () => {
+  it('recognises text fields and ignores the rest', () => {
+    render(<Harness handlers={makeHandlers()} />);
+    expect(isTextEntryTarget(screen.getByLabelText('search'))).toBe(true);
+    expect(isTextEntryTarget(screen.getByLabelText('notes'))).toBe(true);
+    expect(isTextEntryTarget(screen.getByRole('button'))).toBe(false);
+    expect(isTextEntryTarget(null)).toBe(false);
+  });
+});
+
+describe('useQuizKeyboard', () => {
+  it('selects an option from digits and letters', async () => {
+    const user = userEvent.setup();
+    const handlers = makeHandlers();
+    render(<Harness handlers={handlers} />);
+
+    await user.keyboard('3');
+    expect(handlers.onSelectOption).toHaveBeenCalledWith(2);
+
+    await user.keyboard('d');
+    expect(handlers.onSelectOption).toHaveBeenCalledWith(3);
+  });
+
+  it('ignores an option key past the end of the options', async () => {
+    const user = userEvent.setup();
+    const handlers = makeHandlers();
+    render(<Harness handlers={handlers} optionCount={3} />);
+
+    await user.keyboard('4');
+    expect(handlers.onSelectOption).not.toHaveBeenCalled();
+  });
+
+  it('navigates with the arrow keys and submits with Enter', async () => {
+    const user = userEvent.setup();
+    const handlers = makeHandlers();
+    render(<Harness handlers={handlers} />);
+
+    await user.keyboard('{ArrowRight}');
+    expect(handlers.onNext).toHaveBeenCalledTimes(1);
+    await user.keyboard('{ArrowLeft}');
+    expect(handlers.onPrev).toHaveBeenCalledTimes(1);
+    await user.keyboard('{Enter}');
+    expect(handlers.onSubmitOrAdvance).toHaveBeenCalledTimes(1);
+  });
+
+  it('toggles flag and bookmark', async () => {
+    const user = userEvent.setup();
+    const handlers = makeHandlers();
+    render(<Harness handlers={handlers} />);
+
+    await user.keyboard('f');
+    expect(handlers.onToggleFlag).toHaveBeenCalledTimes(1);
+    await user.keyboard('b');
+    expect(handlers.onToggleBookmark).toHaveBeenCalledTimes(1);
+    // "b" is the bookmark key, so it must not also pick option B.
+    expect(handlers.onSelectOption).not.toHaveBeenCalled();
+  });
+
+  it('stays out of the way while typing in a text field', async () => {
+    const user = userEvent.setup();
+    const handlers = makeHandlers();
+    render(<Harness handlers={handlers} />);
+
+    await user.click(screen.getByLabelText('search'));
+    await user.keyboard('bad 1 2 3');
+
+    expect(handlers.onToggleBookmark).not.toHaveBeenCalled();
+    expect(handlers.onToggleFlag).not.toHaveBeenCalled();
+    expect(handlers.onSelectOption).not.toHaveBeenCalled();
+    expect(screen.getByLabelText('search')).toHaveValue('bad 1 2 3');
+  });
+
+  it('stays out of the way in a textarea', async () => {
+    const user = userEvent.setup();
+    const handlers = makeHandlers();
+    render(<Harness handlers={handlers} />);
+
+    await user.click(screen.getByLabelText('notes'));
+    await user.keyboard('fab');
+    expect(handlers.onToggleFlag).not.toHaveBeenCalled();
+    expect(handlers.onToggleBookmark).not.toHaveBeenCalled();
+  });
+
+  it('leaves Enter to the browser when a button has focus', async () => {
+    const user = userEvent.setup();
+    const handlers = makeHandlers();
+    render(<Harness handlers={handlers} />);
+
+    screen.getByRole('button').focus();
+    await user.keyboard('{Enter}');
+    // Otherwise the native click and our shortcut would both fire.
+    expect(handlers.onSubmitOrAdvance).not.toHaveBeenCalled();
+  });
+
+  it('leaves modified keystrokes to the browser', async () => {
+    const user = userEvent.setup();
+    const handlers = makeHandlers();
+    render(<Harness handlers={handlers} />);
+
+    await user.keyboard('{Meta>}1{/Meta}');
+    await user.keyboard('{Control>}f{/Control}');
+    expect(handlers.onSelectOption).not.toHaveBeenCalled();
+    expect(handlers.onToggleFlag).not.toHaveBeenCalled();
+  });
+
+  it('does nothing at all when disabled', async () => {
+    const user = userEvent.setup();
+    const handlers = makeHandlers();
+    render(<Harness handlers={handlers} enabled={false} />);
+
+    await user.keyboard('1{ArrowRight}f');
+    expect(handlers.onSelectOption).not.toHaveBeenCalled();
+    expect(handlers.onNext).not.toHaveBeenCalled();
+    expect(handlers.onToggleFlag).not.toHaveBeenCalled();
+  });
+});
diff --git a/frontend/src/features/quiz/actions.ts b/frontend/src/features/quiz/actions.ts
new file mode 100644
index 0000000..9bc525e
--- /dev/null
+++ b/frontend/src/features/quiz/actions.ts
@@ -0,0 +1,105 @@
+/**
+ * Quiz engine — action types and pure action creators.
+ *
+ * Every action that moves time forward carries `at` (epoch ms) instead of
+ * letting the reducer read the clock. That is the whole reason the reducer can
+ * be unit-tested without fake timers, and the reason per-question latency is
+ * reproducible from a recorded action log.
+ */
+
+import type { Question } from './types';
+
+/**
+ * Payload for starting (or restoring) an attempt.
+ *
+ * The optional arrays are the restore path. They are accepted only when their
+ * length matches `questions`; a mismatch means the draft describes a paper we
+ * cannot faithfully rebuild, so the reducer starts clean rather than scoring
+ * against the wrong questions.
+ */
+export interface HydratePayload {
+  /** Identity of the attempt being started or restored. */
+  attemptKey: string | null;
+  questions: Question[];
+  /** Now, epoch ms. */
+  at: number;
+  /** When the attempt began — the original start time when resuming. */
+  startedAt: number;
+  /** Absolute deadline, epoch ms, or null for untimed modes. */
+  endsAt: number | null;
+  /** Question ids already bookmarked, read from storage by the caller. */
+  bookmarked?: readonly string[];
+  resumed?: boolean;
+  selections?: readonly (number | null)[];
+  submitted?: readonly number[];
+  flagged?: readonly number[];
+  accumulatedMs?: readonly number[];
+  currentIndex?: number;
+}
+
+export type QuizAction =
+  | { type: 'quiz/hydrate'; payload: HydratePayload }
+  | { type: 'quiz/select'; index: number; option: number; at: number }
+  | { type: 'quiz/submitQuestion'; index: number; at: number }
+  | { type: 'quiz/submitAll'; at: number }
+  | { type: 'quiz/navigate'; index: number; at: number }
+  | { type: 'quiz/toggleFlag'; index: number }
+  | { type: 'quiz/setBookmarks'; ids: readonly string[] }
+  | { type: 'quiz/toggleBookmark'; questionId: string }
+  | { type: 'quiz/enterReview'; at: number }
+  | { type: 'quiz/exitReview'; at: number }
+  | { type: 'quiz/pause'; at: number }
+  | { type: 'quiz/resume'; at: number }
+  | { type: 'quiz/reset' };
+
+export const hydrate = (payload: HydratePayload): QuizAction => ({
+  type: 'quiz/hydrate',
+  payload,
+});
+
+export const select = (index: number, option: number, at: number): QuizAction => ({
+  type: 'quiz/select',
+  index,
+  option,
+  at,
+});
+
+/** Commit one question. In `immediate` feedback this is what reveals the verdict. */
+export const submitQuestion = (index: number, at: number): QuizAction => ({
+  type: 'quiz/submitQuestion',
+  index,
+  at,
+});
+
+/** Submit the paper. Terminal: emits a record for every question not yet committed. */
+export const submitAll = (at: number): QuizAction => ({ type: 'quiz/submitAll', at });
+
+/** Move the viewport. Banks the running time slice against the question being left. */
+export const navigate = (index: number, at: number): QuizAction => ({
+  type: 'quiz/navigate',
+  index,
+  at,
+});
+
+export const toggleFlag = (index: number): QuizAction => ({ type: 'quiz/toggleFlag', index });
+
+export const setBookmarks = (ids: readonly string[]): QuizAction => ({
+  type: 'quiz/setBookmarks',
+  ids,
+});
+
+export const toggleBookmark = (questionId: string): QuizAction => ({
+  type: 'quiz/toggleBookmark',
+  questionId,
+});
+
+export const enterReview = (at: number): QuizAction => ({ type: 'quiz/enterReview', at });
+
+export const exitReview = (at: number): QuizAction => ({ type: 'quiz/exitReview', at });
+
+/** Tab hidden, or otherwise off-task: stop accruing time for the current question. */
+export const pause = (at: number): QuizAction => ({ type: 'quiz/pause', at });
+
+export const resume = (at: number): QuizAction => ({ type: 'quiz/resume', at });
+
+export const reset = (): QuizAction => ({ type: 'quiz/reset' });
diff --git a/frontend/src/features/quiz/components/ExplanationPanel.module.css b/frontend/src/features/quiz/components/ExplanationPanel.module.css
new file mode 100644
index 0000000..22143c5
--- /dev/null
+++ b/frontend/src/features/quiz/components/ExplanationPanel.module.css
@@ -0,0 +1,182 @@
+.panel {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-2);
+  padding: var(--spacing-4);
+  border: 1px dashed var(--color-border);
+  border-radius: var(--radius-md);
+  background: var(--color-surface-2);
+}
+
+/*
+ * An unreviewed draft is visually distinct from a checked explanation, so the
+ * difference survives a skim that misses the badge text. Warning-toned left
+ * edge rather than a full warning background: the panel still has to be
+ * comfortable to read several paragraphs in.
+ */
+.unreviewed {
+  border-style: solid;
+  border-color: var(--color-border);
+  border-left: 3px solid var(--color-warning-500);
+}
+
+.headerRow {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: var(--spacing-2);
+  justify-content: space-between;
+}
+
+.heading {
+  margin: 0;
+  font-size: var(--text-xs);
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--color-fg-muted);
+}
+
+.badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35em;
+  padding: 0.15em 0.5em;
+  border: 1px solid var(--color-warning-500);
+  border-radius: var(--radius-full);
+  font-size: var(--text-xs);
+  font-weight: 600;
+  line-height: 1.4;
+  color: var(--color-warning-fg);
+  white-space: nowrap;
+}
+
+.badgeReviewed {
+  border-color: var(--color-border-strong);
+  color: var(--color-fg-muted);
+}
+
+.disclaimer {
+  margin: 0;
+  font-size: var(--text-xs);
+  line-height: 1.5;
+  color: var(--color-fg-muted);
+}
+
+.body {
+  margin: 0;
+  font-size: var(--text-sm);
+  line-height: 1.55;
+  color: var(--color-fg);
+  white-space: pre-wrap;
+}
+
+.empty {
+  margin: 0;
+  font-size: var(--text-sm);
+  font-style: italic;
+  color: var(--color-fg-muted);
+}
+
+.distractors {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-2);
+  margin-top: var(--spacing-1);
+  padding-top: var(--spacing-3);
+  border-top: 1px solid var(--color-border);
+}
+
+.subheading {
+  margin: 0;
+  font-size: var(--text-xs);
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--color-fg-muted);
+}
+
+.distractorList {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-2);
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.distractorItem {
+  display: flex;
+  flex-direction: column;
+  gap: 0.15em;
+}
+
+.distractorOption {
+  font-size: var(--text-sm);
+  font-weight: 600;
+  color: var(--color-fg);
+}
+
+.distractorWhy {
+  font-size: var(--text-sm);
+  line-height: 1.5;
+  color: var(--color-fg-muted);
+}
+
+.report {
+  align-self: flex-start;
+  min-height: 44px;
+  margin-top: var(--spacing-1);
+  padding: 0 var(--spacing-3);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  font: inherit;
+  font-size: var(--text-xs);
+  color: var(--color-fg-muted);
+  cursor: pointer;
+}
+
+.report:hover {
+  border-color: var(--color-border-strong);
+  color: var(--color-fg);
+}
+
+.report:focus-visible {
+  outline: 3px solid #ffffff;
+  outline-offset: 3px;
+}
+
+/* Syllabus reference — shown in place of a missing explanation, and as a
+   footer beside one that exists. Visually quieter than the explanation body,
+   because it is a pointer into the syllabus rather than teaching. */
+.reference {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: var(--spacing-1) var(--spacing-2);
+  margin: 0;
+  padding-top: var(--spacing-2);
+  border-top: 1px solid var(--color-border);
+  font-size: var(--text-xs);
+}
+
+.referenceLabel {
+  flex-shrink: 0;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--color-fg-muted);
+}
+
+.referenceValue {
+  font-weight: 600;
+  color: var(--color-fg);
+}
+
+/* Wraps onto its own line on a narrow screen rather than squeezing the code
+   it qualifies. */
+.referenceChapter {
+  flex-basis: 100%;
+  color: var(--color-fg-muted);
+}
diff --git a/frontend/src/features/quiz/components/ExplanationPanel.tsx b/frontend/src/features/quiz/components/ExplanationPanel.tsx
new file mode 100644
index 0000000..b757d9a
--- /dev/null
+++ b/frontend/src/features/quiz/components/ExplanationPanel.tsx
@@ -0,0 +1,195 @@
+/**
+ * ExplanationPanel — why the right answer is right.
+ *
+ * Explanations carry provenance, because most of them are AI-generated drafts
+ * that no human has read. Three rules follow from that, and all three are
+ * enforced here rather than left to each caller:
+ *
+ *  1. An unreviewed draft is always labelled. The badge is a visible row above
+ *     the text, not an asterisk — a student reading an engineering-licence
+ *     explanation is entitled to know whether a person checked it. A caller
+ *     that forgets to pass `origin` gets the badge anyway (see the default),
+ *     because the failure mode of a missing label is worse than a redundant one.
+ *
+ *  2. A draft is never shown during a timed mock test. `context` must be set to
+ *     `'exam'` there. A wrong explanation mid-exam is worse than no explanation:
+ *     it can talk a student out of a correct answer on a later question, and
+ *     there is no opportunity to check it. Reviewed and human-written
+ *     explanations are withheld in an exam too, for a different reason — they
+ *     name the answer.
+ *
+ *  3. Every draft offers a report link. The students are the only large-scale
+ *     readers these drafts will have, so they are the review capacity that
+ *     actually exists.
+ *
+ * It never invents an explanation. Where there is none — which today is every
+ * question in the bank — it shows the derived syllabus reference instead, so a
+ * student who got it wrong knows what to revise. A reference is not an
+ * explanation and is labelled as a reference; see `services/questionReference`.
+ */
+
+import styles from './ExplanationPanel.module.css';
+import type { QuestionReference } from '../../../services/questionReference';
+
+/** Mirrors `explanations.origin` in the database. */
+export type ExplanationOrigin = 'ai_draft' | 'ai_reviewed' | 'human';
+
+/** Where the panel is being rendered, which decides what may be shown. */
+export type ExplanationContext = 'practice' | 'review' | 'exam';
+
+export interface DistractorRationale {
+  /** Option id this rationale is about. */
+  optionId: string;
+  /** The option's text, so the rationale reads without relying on position. */
+  optionText: string;
+  why: string;
+}
+
+export interface ExplanationPanelProps {
+  /** Authored or generated explanation. Undefined or blank renders the empty state. */
+  explanation?: string | null;
+  /**
+   * Provenance. Defaults to `'ai_draft'` so an omitted value fails safe: an
+   * unlabelled draft is the one outcome this component exists to prevent.
+   */
+  origin?: ExplanationOrigin;
+  /**
+   * Render context. Defaults to `'exam'` — the most restrictive — so a caller
+   * that forgets to set it shows nothing rather than leaking the answer into a
+   * timed paper.
+   */
+  context?: ExplanationContext;
+  /** Hide entirely until the answer is revealed. */
+  revealed?: boolean;
+  /** Reference the student can follow instead, e.g. a chapter name. */
+  sourceLabel?: string;
+  /**
+   * Derived syllabus reference. Shown in place of a missing explanation, and
+   * as a footer alongside one that exists. Omit it and the panel degrades to
+   * the plain empty state rather than failing.
+   */
+  reference?: QuestionReference | null;
+  /** Why each wrong option is wrong. Often where the real teaching is. */
+  distractors?: readonly DistractorRationale[];
+  /** Called when the student reports a problem with this explanation. */
+  onReport?: () => void;
+}
+
+export function ExplanationPanel({
+  explanation,
+  origin = 'ai_draft',
+  context = 'exam',
+  revealed = true,
+  sourceLabel,
+  reference,
+  distractors,
+  onReport,
+}: ExplanationPanelProps) {
+  if (!revealed) return null;
+
+  // Rule 2. No explanation of any provenance is shown during a timed paper,
+  // because the explanation names the answer.
+  if (context === 'exam') return null;
+
+  const text = explanation?.trim();
+  const isUnreviewed = origin === 'ai_draft';
+  const rationales = (distractors ?? []).filter((d) => d.why.trim().length > 0);
+
+  if (!text && rationales.length === 0) {
+    return (
+      <section className={styles.panel} aria-label="Explanation">
+        <h3 className={styles.heading}>Explanation</h3>
+        <p className={styles.empty}>
+          No explanation has been written for this question yet.
+          {sourceLabel ? ` Refer to ${sourceLabel}.` : ''}
+        </p>
+        {/* The useful half of the empty state: a student who got this wrong
+            still learns where in the syllabus to revise. */}
+        <ReferenceLine reference={reference} />
+      </section>
+    );
+  }
+
+  return (
+    <section
+      className={`${styles.panel} ${isUnreviewed ? styles.unreviewed : ''}`}
+      aria-label={isUnreviewed ? 'Explanation, AI-generated and unreviewed' : 'Explanation'}
+    >
+      <div className={styles.headerRow}>
+        <h3 className={styles.heading}>Explanation</h3>
+        {isUnreviewed ? (
+          // Not a tooltip and not an asterisk: the label has to survive being
+          // skim-read on a phone.
+          <span className={styles.badge}>
+            <span aria-hidden="true">⚠</span> AI draft &middot; not yet reviewed
+          </span>
+        ) : origin === 'ai_reviewed' ? (
+          <span className={`${styles.badge} ${styles.badgeReviewed}`}>AI draft, reviewed</span>
+        ) : null}
+      </div>
+
+      {isUnreviewed && (
+        <p className={styles.disclaimer}>
+          This explanation was generated by AI and has not been checked by a person. Treat it as a
+          starting point, not as authority, and verify anything you plan to rely on.
+        </p>
+      )}
+
+      {text && <p className={styles.body}>{text}</p>}
+
+      {rationales.length > 0 && (
+        <div className={styles.distractors}>
+          <h4 className={styles.subheading}>Why the other options are wrong</h4>
+          <ul className={styles.distractorList}>
+            {rationales.map((d) => (
+              <li key={d.optionId} className={styles.distractorItem}>
+                <span className={styles.distractorOption}>{d.optionText}</span>
+                <span className={styles.distractorWhy}>{d.why}</span>
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
+
+      <ReferenceLine reference={reference} />
+
+      {onReport && (
+        <button type="button" className={styles.report} onClick={onReport}>
+          {isUnreviewed ? 'This explanation looks wrong' : 'Report a problem'}
+        </button>
+      )}
+    </section>
+  );
+}
+
+/**
+ * The syllabus reference line.
+ *
+ * Phrasing carries the confidence rather than a number: a sub-chapter the
+ * classifier is sure of is stated ("Syllabus reference: 5.4 Transport Layer"),
+ * a weak match is hedged ("likely 5.4..."), and a declined match falls back to
+ * the chapter, which is always exact. A percentage here would imply a
+ * precision this heuristic does not have.
+ */
+function ReferenceLine({ reference }: { reference?: QuestionReference | null }) {
+  if (!reference) return null;
+
+  const { subchapter, tentative, label, chapterNumber, chapterTitle } = reference;
+
+  return (
+    <p className={styles.reference}>
+      <span className={styles.referenceLabel}>Syllabus reference</span>
+      <span className={styles.referenceValue}>
+        {subchapter && tentative ? 'likely ' : ''}
+        {label}
+      </span>
+      {/* When a sub-chapter was matched, name the chapter too — the dotted code
+          alone is meaningless to someone who has not memorised the syllabus. */}
+      {subchapter && (
+        <span className={styles.referenceChapter}>
+          Chapter {chapterNumber}: {chapterTitle}
+        </span>
+      )}
+    </p>
+  );
+}
diff --git a/frontend/src/features/quiz/components/OptionList.module.css b/frontend/src/features/quiz/components/OptionList.module.css
new file mode 100644
index 0000000..7bfa571
--- /dev/null
+++ b/frontend/src/features/quiz/components/OptionList.module.css
@@ -0,0 +1,54 @@
+/*
+ * Layout only. The shared Radio primitive owns the surface, border and
+ * selected/correct/incorrect colouring; this adds the lettered chip and the
+ * two-column row the quiz uses. All values come from src/styles/tokens.css.
+ */
+
+.group {
+  gap: var(--spacing-2);
+}
+
+.option {
+  /* 44px minimum touch target. Options are what people miss on phones. */
+  min-height: 44px;
+}
+
+.row {
+  display: flex;
+  align-items: flex-start;
+  gap: var(--spacing-3);
+  width: 100%;
+}
+
+.letter {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 1.75rem;
+  height: 1.75rem;
+  border-radius: var(--radius-sm);
+  background: var(--color-surface);
+  color: var(--color-fg-muted);
+  font-size: var(--text-xs);
+  font-weight: 600;
+}
+
+/* Keyed off the primitive's data-state so the chip tracks the option without
+   duplicating its colour rules. */
+.option[data-state='selected'] .letter,
+.option[data-state='correct'] .letter {
+  background: var(--color-accent);
+  color: var(--color-accent-fg);
+}
+
+.option[data-state='incorrect'] .letter {
+  background: var(--color-danger-500);
+  color: var(--color-accent-fg);
+}
+
+.text {
+  flex: 1 1 auto;
+  text-align: left;
+  line-height: 1.45;
+}
diff --git a/frontend/src/features/quiz/components/OptionList.tsx b/frontend/src/features/quiz/components/OptionList.tsx
new file mode 100644
index 0000000..ab72407
--- /dev/null
+++ b/frontend/src/features/quiz/components/OptionList.tsx
@@ -0,0 +1,89 @@
+/**
+ * OptionList — the answer options for one question.
+ *
+ * Presentational: it is told what is selected, whether the key may be shown,
+ * and what the key is. It never decides whether to reveal.
+ *
+ * Built on the shared `RadioGroup`/`Radio` primitives, which own the real
+ * WAI-ARIA radiogroup pattern (roving tabindex, arrow/Home/End navigation,
+ * `aria-disabled` rather than `disabled` so a revealed answer stays readable).
+ *
+ * One interaction note: inside the group, Left/Right move the selection,
+ * because that is what the radiogroup pattern requires. The quiz-wide
+ * Left/Right question navigation in `useQuizKeyboard` bows out whenever the
+ * group has already handled the key — it checks `defaultPrevented` — so the
+ * two bindings coexist instead of fighting.
+ */
+
+import { Radio, RadioGroup } from '../../../components/ui/RadioGroup';
+import type { RadioVisualState } from '../../../components/ui/RadioGroup';
+import { optionLetter } from '../format';
+import styles from './OptionList.module.css';
+
+export interface OptionListProps {
+  options: readonly string[];
+  /** Chosen option index, or null. */
+  value: number | null;
+  onChange: (index: number) => void;
+  /** Index of the right answer, or null/-1 when the bank has no key. */
+  correctIndex?: number | null;
+  /** When false, the key must not be visible, whatever `correctIndex` says. */
+  revealed?: boolean;
+  /** Locks the answer. Options stay focusable so they can still be read. */
+  locked?: boolean;
+  /** Accessible name for the group. */
+  label: string;
+}
+
+function optionState(
+  index: number,
+  value: number | null,
+  correctIndex: number,
+  revealed: boolean
+): RadioVisualState {
+  if (!revealed || correctIndex < 0) return value === index ? 'selected' : 'neutral';
+  if (index === correctIndex) return 'correct';
+  if (value === index) return 'incorrect';
+  return 'neutral';
+}
+
+export function OptionList({
+  options,
+  value,
+  onChange,
+  correctIndex = null,
+  revealed = false,
+  locked = false,
+  label,
+}: OptionListProps) {
+  const key = correctIndex ?? -1;
+
+  return (
+    <RadioGroup
+      aria-label={label}
+      className={styles.group}
+      value={value === null ? null : String(value)}
+      onValueChange={(next) => onChange(Number(next))}
+      readOnly={locked}
+    >
+      {options.map((text, index) => (
+        <Radio
+          key={index}
+          value={String(index)}
+          className={styles.option}
+          state={optionState(index, value, key, revealed)}
+          // Options are lettered A-D, which is both the visual convention and
+          // what the 1-4 / a-d shortcuts refer to, so the bullet is redundant.
+          showIndicator={false}
+        >
+          <span className={styles.row}>
+            <span className={styles.letter} aria-hidden="true">
+              {optionLetter(index)}
+            </span>
+            <span className={styles.text}>{text}</span>
+          </span>
+        </Radio>
+      ))}
+    </RadioGroup>
+  );
+}
diff --git a/frontend/src/features/quiz/components/QuestionCard.module.css b/frontend/src/features/quiz/components/QuestionCard.module.css
new file mode 100644
index 0000000..1955289
--- /dev/null
+++ b/frontend/src/features/quiz/components/QuestionCard.module.css
@@ -0,0 +1,77 @@
+.card {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  padding: var(--spacing-5);
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-lg);
+}
+
+.header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--spacing-3);
+}
+
+.number {
+  margin: 0;
+  font-size: var(--text-xs);
+  font-weight: 600;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--color-accent);
+}
+
+.of {
+  color: var(--color-fg-muted);
+  font-weight: 500;
+  text-transform: none;
+  letter-spacing: normal;
+}
+
+.stem {
+  margin: 0;
+  font-size: var(--text-lg);
+  line-height: 1.45;
+  font-weight: 600;
+  color: var(--color-fg);
+}
+
+.verdict {
+  margin: 0;
+  padding: var(--spacing-3) var(--spacing-4);
+  border-radius: var(--radius-md);
+  border: 1px solid var(--color-border);
+  font-size: var(--text-sm);
+  color: var(--color-fg);
+  background: var(--color-surface-2);
+}
+
+.positive {
+  border-color: var(--color-success-500);
+  /* -fg is the contrast-checked text cut; -500 is for borders and glyphs. */
+  color: var(--color-success-fg);
+}
+
+.negative {
+  border-color: var(--color-danger-500);
+  color: var(--color-danger-fg);
+}
+
+.neutral {
+  border-color: var(--color-border);
+}
+
+@media (max-width: 767px) {
+  .card {
+    padding: var(--spacing-4);
+    /* Room for the fixed action bar so the last option is never under it. */
+    padding-bottom: var(--spacing-4);
+  }
+
+  .stem {
+    font-size: var(--text-base);
+  }
+}
diff --git a/frontend/src/features/quiz/components/QuestionCard.tsx b/frontend/src/features/quiz/components/QuestionCard.tsx
new file mode 100644
index 0000000..1675dcc
--- /dev/null
+++ b/frontend/src/features/quiz/components/QuestionCard.tsx
@@ -0,0 +1,82 @@
+/**
+ * QuestionCard — one question: number, stem, options, verdict.
+ *
+ * The ~90 lines of near-identical card markup copied across TopicPractice,
+ * QuickPractice and CustomPractice collapse to this. Presentational only: it
+ * takes a verdict and a reveal flag and renders them.
+ */
+
+import type { ReactNode } from 'react';
+import { verdictMessage, verdictTone } from '../format';
+import type { Verdict } from '../types';
+import { OptionList } from './OptionList';
+import styles from './QuestionCard.module.css';
+
+export interface QuestionCardProps {
+  /** Zero-based position in the paper. */
+  index: number;
+  total: number;
+  questionText: string;
+  options: readonly string[];
+  selection: number | null;
+  onSelect: (optionIndex: number) => void;
+  /** -1 when the bank has no key for this question. */
+  correctIndex: number;
+  revealed: boolean;
+  verdict: Verdict;
+  /** Locks the options — a committed answer in immediate-feedback mode. */
+  locked?: boolean;
+  /** Slot under the verdict, for ExplanationPanel or anything else. */
+  children?: ReactNode;
+}
+
+export function QuestionCard({
+  index,
+  total,
+  questionText,
+  options,
+  selection,
+  onSelect,
+  correctIndex,
+  revealed,
+  verdict,
+  locked = false,
+  children,
+}: QuestionCardProps) {
+  const showVerdict = revealed && verdict !== 'unanswered';
+
+  return (
+    <article className={styles.card} aria-label={`Question ${index + 1} of ${total}`}>
+      <header className={styles.header}>
+        <p className={styles.number}>
+          Question {index + 1}
+          <span className={styles.of}> of {total}</span>
+        </p>
+      </header>
+
+      <h2 className={styles.stem}>{questionText}</h2>
+
+      <OptionList
+        label={`Answer options for question ${index + 1}`}
+        options={options}
+        value={selection}
+        onChange={onSelect}
+        correctIndex={correctIndex}
+        revealed={revealed}
+        locked={locked}
+      />
+
+      {showVerdict && (
+        <p
+          className={`${styles.verdict} ${styles[verdictTone(verdict)]}`}
+          role="status"
+          aria-live="polite"
+        >
+          {verdictMessage(verdict, correctIndex)}
+        </p>
+      )}
+
+      {children}
+    </article>
+  );
+}
diff --git a/frontend/src/features/quiz/components/QuestionPalette.module.css b/frontend/src/features/quiz/components/QuestionPalette.module.css
new file mode 100644
index 0000000..d05c53b
--- /dev/null
+++ b/frontend/src/features/quiz/components/QuestionPalette.module.css
@@ -0,0 +1,103 @@
+.wrap {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-3);
+}
+
+.heading {
+  margin: 0;
+  font-size: var(--text-sm);
+  font-weight: 600;
+  color: var(--color-fg);
+}
+
+.grid {
+  display: grid;
+  /* Auto-fills to the container, so the same grid works in a sidebar and in a
+   * full-width sheet on a phone. */
+  grid-template-columns: repeat(auto-fill, minmax(2.5rem, 1fr));
+  gap: var(--spacing-2);
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.dot {
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  aspect-ratio: 1;
+  min-height: 2.5rem;
+  font: inherit;
+  font-size: var(--text-xs);
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  border-radius: var(--radius-md);
+  border: 1px solid var(--color-border);
+  background: var(--color-surface);
+  color: var(--color-fg-muted);
+  cursor: pointer;
+}
+
+.dot:hover {
+  border-color: var(--color-accent);
+}
+
+.dot:focus-visible {
+  outline: 2px solid var(--color-ring);
+  outline-offset: 2px;
+}
+
+.unanswered {
+  background: var(--color-surface);
+}
+
+.answered {
+  background: var(--color-surface-2);
+  border-color: var(--color-success-500);
+  color: var(--color-fg);
+}
+
+.flagged {
+  border-color: var(--color-warning-500);
+}
+
+.current {
+  background: var(--color-accent);
+  border-color: var(--color-accent);
+  color: var(--color-accent-fg);
+}
+
+.pin {
+  position: absolute;
+  top: -0.3rem;
+  right: -0.2rem;
+  font-size: 0.6rem;
+  color: var(--color-warning-500);
+}
+
+.legend {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-3);
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  font-size: var(--text-xs);
+  color: var(--color-fg-muted);
+}
+
+.legend li {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+}
+
+.swatch {
+  display: inline-block;
+  width: 0.75rem;
+  height: 0.75rem;
+  border-radius: var(--radius-sm);
+}
diff --git a/frontend/src/features/quiz/components/QuestionPalette.tsx b/frontend/src/features/quiz/components/QuestionPalette.tsx
new file mode 100644
index 0000000..635a4bb
--- /dev/null
+++ b/frontend/src/features/quiz/components/QuestionPalette.tsx
@@ -0,0 +1,71 @@
+/**
+ * QuestionPalette — the numbered grid for jumping around a paper.
+ *
+ * `App.css` has carried unused `.navigator-grid` / `.nav-dot` rules for a while:
+ * someone designed this and it was never built, so a 100-question mock could
+ * only be walked page by page. This is that component, with the flagged state
+ * the original stylesheet lacked.
+ */
+
+import type { PaletteEntry } from '../types';
+import styles from './QuestionPalette.module.css';
+
+export interface QuestionPaletteProps {
+  entries: readonly PaletteEntry[];
+  onJump: (index: number) => void;
+  /** Optional heading; omit inside a panel that already has one. */
+  label?: string;
+}
+
+function describe(entry: PaletteEntry): string {
+  const parts = [entry.answered ? 'answered' : 'unanswered'];
+  if (entry.flagged) parts.push('flagged for review');
+  if (entry.current) parts.push('current');
+  return `Question ${entry.index + 1}, ${parts.join(', ')}`;
+}
+
+export function QuestionPalette({ entries, onJump, label }: QuestionPaletteProps) {
+  return (
+    <nav className={styles.wrap} aria-label={label ?? 'Question navigator'}>
+      {label && <h3 className={styles.heading}>{label}</h3>}
+      <ol className={styles.grid}>
+        {entries.map((entry) => (
+          <li key={entry.questionId}>
+            <button
+              type="button"
+              className={[
+                styles.dot,
+                entry.answered ? styles.answered : styles.unanswered,
+                entry.flagged ? styles.flagged : '',
+                entry.current ? styles.current : '',
+              ]
+                .filter(Boolean)
+                .join(' ')}
+              onClick={() => onJump(entry.index)}
+              aria-current={entry.current ? 'true' : undefined}
+              aria-label={describe(entry)}
+            >
+              {entry.index + 1}
+              {entry.flagged && (
+                <span className={styles.pin} aria-hidden="true">
+                  ⚑
+                </span>
+              )}
+            </button>
+          </li>
+        ))}
+      </ol>
+      <ul className={styles.legend}>
+        <li>
+          <span className={`${styles.swatch} ${styles.answered}`} aria-hidden="true" /> Answered
+        </li>
+        <li>
+          <span className={`${styles.swatch} ${styles.unanswered}`} aria-hidden="true" /> Unanswered
+        </li>
+        <li>
+          <span className={`${styles.swatch} ${styles.flagged}`} aria-hidden="true" /> Flagged
+        </li>
+      </ul>
+    </nav>
+  );
+}
diff --git a/frontend/src/features/quiz/components/QuizActionBar.module.css b/frontend/src/features/quiz/components/QuizActionBar.module.css
new file mode 100644
index 0000000..4668431
--- /dev/null
+++ b/frontend/src/features/quiz/components/QuizActionBar.module.css
@@ -0,0 +1,74 @@
+.spacer {
+  display: none;
+}
+
+.bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--spacing-3);
+  padding: var(--spacing-3) 0;
+}
+
+.primary,
+.secondary {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.4em;
+  /* 44px minimum, and generous horizontal padding: these are thumb targets. */
+  min-height: 44px;
+  padding: var(--spacing-3) var(--spacing-5);
+  font: inherit;
+  font-size: var(--text-sm);
+  font-weight: 600;
+  border-radius: var(--radius-md);
+  cursor: pointer;
+  border: 1px solid transparent;
+}
+
+.primary {
+  background: var(--color-accent);
+  color: var(--color-accent-fg);
+}
+
+.secondary {
+  background: var(--color-surface);
+  color: var(--color-fg);
+  border-color: var(--color-border);
+}
+
+.primary:focus-visible,
+.secondary:focus-visible {
+  outline: 2px solid var(--color-ring);
+  outline-offset: 2px;
+}
+
+.primary:disabled,
+.secondary:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+@media (max-width: 767px) {
+  .spacer {
+    display: block;
+    height: calc(44px + 2 * var(--spacing-3) + env(safe-area-inset-bottom, 0px));
+  }
+
+  .bar {
+    position: fixed;
+    inset: auto 0 0 0;
+    z-index: 20;
+    padding: var(--spacing-3) var(--spacing-4);
+    /* Clear of the iOS home indicator. */
+    padding-bottom: calc(var(--spacing-3) + env(safe-area-inset-bottom, 0px));
+    background: var(--color-surface);
+    border-top: 1px solid var(--color-border);
+  }
+
+  .primary,
+  .secondary {
+    flex: 1 1 0;
+  }
+}
diff --git a/frontend/src/features/quiz/components/QuizActionBar.tsx b/frontend/src/features/quiz/components/QuizActionBar.tsx
new file mode 100644
index 0000000..c215d95
--- /dev/null
+++ b/frontend/src/features/quiz/components/QuizActionBar.tsx
@@ -0,0 +1,74 @@
+/**
+ * QuizActionBar — previous / submit / next, pinned to the bottom on phones.
+ *
+ * Under 768px this fixes to the bottom of the viewport. A quiz is read
+ * top-down and answered bottom-up: on a phone the controls were below a stem
+ * plus four options, so every question ended with a scroll to reach the
+ * button. Pinned, the primary action is always under the thumb.
+ */
+
+import styles from './QuizActionBar.module.css';
+
+export interface QuizActionBarProps {
+  onPrev: () => void;
+  onNext: () => void;
+  /** Commit the current question (immediate feedback). Omit in deferred mode. */
+  onSubmit?: () => void;
+  /** Open the pre-submit review screen, or finish. */
+  onFinish?: () => void;
+  canPrev: boolean;
+  canNext: boolean;
+  canSubmit: boolean;
+  /** True on the last question, which turns "Next" into the finish action. */
+  isLast: boolean;
+  /** Label for the terminal action. */
+  finishLabel?: string;
+}
+
+export function QuizActionBar({
+  onPrev,
+  onNext,
+  onSubmit,
+  onFinish,
+  canPrev,
+  canNext,
+  canSubmit,
+  isLast,
+  finishLabel = 'Finish',
+}: QuizActionBarProps) {
+  // Submit takes the primary slot while the current answer is uncommitted;
+  // otherwise it is advance, and on the last question, finish.
+  const showSubmit = onSubmit !== undefined && canSubmit;
+
+  return (
+    <>
+      {/* Reserves the height the fixed bar takes out of the viewport on
+          phones, so the last option is never trapped underneath it. */}
+      <div className={styles.spacer} aria-hidden="true" />
+      <div className={styles.bar}>
+      <button type="button" className={styles.secondary} onClick={onPrev} disabled={!canPrev}>
+        <span aria-hidden="true">←</span> Previous
+      </button>
+
+      {showSubmit ? (
+        <button type="button" className={styles.primary} onClick={onSubmit}>
+          Submit
+        </button>
+      ) : isLast ? (
+        <button
+          type="button"
+          className={styles.primary}
+          onClick={onFinish}
+          disabled={onFinish === undefined}
+        >
+          {finishLabel}
+        </button>
+      ) : (
+        <button type="button" className={styles.primary} onClick={onNext} disabled={!canNext}>
+          Next <span aria-hidden="true">→</span>
+        </button>
+      )}
+      </div>
+    </>
+  );
+}
diff --git a/frontend/src/features/quiz/components/QuizToolbar.module.css b/frontend/src/features/quiz/components/QuizToolbar.module.css
new file mode 100644
index 0000000..a2c6516
--- /dev/null
+++ b/frontend/src/features/quiz/components/QuizToolbar.module.css
@@ -0,0 +1,102 @@
+.bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  flex-wrap: wrap;
+  gap: var(--spacing-3);
+  padding: var(--spacing-3) var(--spacing-4);
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+}
+
+.counter {
+  display: flex;
+  flex-direction: column;
+  gap: 0.125rem;
+}
+
+.position {
+  font-size: var(--text-base);
+  font-weight: 700;
+  color: var(--color-fg);
+  font-variant-numeric: tabular-nums;
+}
+
+.answered {
+  font-size: var(--text-xs);
+  color: var(--color-fg-muted);
+}
+
+.timer {
+  font-size: var(--text-lg);
+  font-weight: 700;
+  /* Tabular figures so the layout does not jitter once a second. */
+  font-variant-numeric: tabular-nums;
+  color: var(--color-fg);
+  padding: var(--spacing-1) var(--spacing-3);
+  border-radius: var(--radius-md);
+  background: var(--color-surface-2);
+  border: 1px solid var(--color-border);
+}
+
+.low {
+  color: var(--color-danger-fg);
+  border-color: var(--color-danger-500);
+}
+
+.actions {
+  display: flex;
+  gap: var(--spacing-2);
+}
+
+.action {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--spacing-2);
+  min-height: 44px;
+  padding: var(--spacing-2) var(--spacing-3);
+  font: inherit;
+  font-size: var(--text-sm);
+  color: var(--color-fg-muted);
+  background: transparent;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  cursor: pointer;
+}
+
+.action:hover {
+  border-color: var(--color-accent);
+  color: var(--color-fg);
+}
+
+.action:focus-visible {
+  outline: 2px solid var(--color-ring);
+  outline-offset: 2px;
+}
+
+.on {
+  color: var(--color-accent);
+  border-color: var(--color-accent);
+}
+
+.kbd {
+  font: inherit;
+  font-size: var(--text-xs);
+  padding: 0 0.35em;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  color: var(--color-fg-muted);
+}
+
+@media (max-width: 767px) {
+  /* Keystroke hints are noise on a phone — there is no keyboard. */
+  .kbd,
+  .actionLabel {
+    display: none;
+  }
+
+  .bar {
+    padding: var(--spacing-2) var(--spacing-3);
+  }
+}
diff --git a/frontend/src/features/quiz/components/QuizToolbar.tsx b/frontend/src/features/quiz/components/QuizToolbar.tsx
new file mode 100644
index 0000000..cdf9af8
--- /dev/null
+++ b/frontend/src/features/quiz/components/QuizToolbar.tsx
@@ -0,0 +1,89 @@
+/**
+ * QuizToolbar — progress counter, timer, flag and bookmark.
+ *
+ * The timer is handed `timeLeftMs` and renders it; it never counts down on its
+ * own. Whatever owns the attempt derives that number from an absolute deadline,
+ * which is what makes a reload or a backgrounded tab harmless.
+ */
+
+import { VisuallyHidden } from '../../../components/ui/VisuallyHidden';
+import { describeClock, formatClock } from '../format';
+import styles from './QuizToolbar.module.css';
+
+export interface QuizToolbarProps {
+  index: number;
+  total: number;
+  answered: number;
+  /** Null for untimed attempts — the timer is then not rendered at all. */
+  timeLeftMs?: number | null;
+  /** Below this, the timer takes on its urgent styling. Default 60s. */
+  lowTimeMs?: number;
+  flagged: boolean;
+  onToggleFlag: () => void;
+  bookmarked: boolean;
+  onToggleBookmark: () => void;
+}
+
+export function QuizToolbar({
+  index,
+  total,
+  answered,
+  timeLeftMs = null,
+  lowTimeMs = 60_000,
+  flagged,
+  onToggleFlag,
+  bookmarked,
+  onToggleBookmark,
+}: QuizToolbarProps) {
+  const low = timeLeftMs !== null && timeLeftMs <= lowTimeMs;
+
+  return (
+    <div className={styles.bar}>
+      <div className={styles.counter}>
+        {/* "3/30" reads as "three slash thirty", so the glyphs are hidden from
+            assistive tech and a sentence is provided instead. */}
+        <span className={styles.position} aria-hidden="true">{`${index + 1}/${total}`}</span>
+        <span className={styles.answered} aria-hidden="true">
+          {answered} answered
+        </span>
+        <VisuallyHidden>{`Question ${index + 1} of ${total}, ${answered} answered`}</VisuallyHidden>
+      </div>
+
+      {timeLeftMs !== null && (
+        <div
+          className={`${styles.timer} ${low ? styles.low : ''}`}
+          role="timer"
+          // Only nag the screen reader when it matters. An assertive region
+          // that updates every second is unusable.
+          aria-live={low ? 'assertive' : 'off'}
+          aria-label={`Time remaining: ${describeClock(timeLeftMs)}`}
+        >
+          {formatClock(timeLeftMs)}
+        </div>
+      )}
+
+      <div className={styles.actions}>
+        <button
+          type="button"
+          className={`${styles.action} ${flagged ? styles.on : ''}`}
+          onClick={onToggleFlag}
+          aria-pressed={flagged}
+        >
+          <span aria-hidden="true">⚑</span>
+          <span className={styles.actionLabel}>Flag</span>
+          <kbd className={styles.kbd}>F</kbd>
+        </button>
+        <button
+          type="button"
+          className={`${styles.action} ${bookmarked ? styles.on : ''}`}
+          onClick={onToggleBookmark}
+          aria-pressed={bookmarked}
+        >
+          <span aria-hidden="true">☆</span>
+          <span className={styles.actionLabel}>Bookmark</span>
+          <kbd className={styles.kbd}>B</kbd>
+        </button>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/src/features/quiz/components/ResultSummary.module.css b/frontend/src/features/quiz/components/ResultSummary.module.css
new file mode 100644
index 0000000..5b6f1b4
--- /dev/null
+++ b/frontend/src/features/quiz/components/ResultSummary.module.css
@@ -0,0 +1,107 @@
+.wrap {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: var(--spacing-3);
+  padding: var(--spacing-6);
+  text-align: center;
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-lg);
+}
+
+.heading {
+  margin: 0;
+  font-size: var(--text-lg);
+  color: var(--color-fg);
+}
+
+.title {
+  margin: 0;
+  font-size: var(--text-sm);
+  color: var(--color-fg-muted);
+}
+
+.score {
+  display: flex;
+  align-items: baseline;
+  gap: 0.25rem;
+  margin: 0;
+  font-variant-numeric: tabular-nums;
+}
+
+.scoreValue {
+  font-size: var(--text-3xl);
+  font-weight: 800;
+  line-height: 1;
+}
+
+.scoreTotal {
+  font-size: var(--text-lg);
+  font-weight: 600;
+  color: var(--color-fg-muted);
+}
+
+.pass .scoreValue {
+  color: var(--color-success-fg);
+}
+
+.fail .scoreValue {
+  color: var(--color-danger-fg);
+}
+
+.accuracy {
+  margin: 0;
+  font-size: var(--text-base);
+  font-weight: 600;
+  color: var(--color-fg);
+}
+
+.stats {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(6.5rem, 1fr));
+  gap: var(--spacing-3);
+  width: 100%;
+  margin: var(--spacing-2) 0 0;
+}
+
+.stat {
+  padding: var(--spacing-3);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  background: var(--color-surface-2);
+}
+
+.stat dt {
+  font-size: var(--text-xs);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--color-fg-muted);
+}
+
+.stat dd {
+  margin: 0.25rem 0 0;
+  font-size: var(--text-lg);
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+  color: var(--color-fg);
+}
+
+.small {
+  font-size: var(--text-sm) !important;
+}
+
+.note {
+  margin: 0;
+  font-size: var(--text-xs);
+  color: var(--color-fg-muted);
+  max-width: 44ch;
+}
+
+.actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: var(--spacing-3);
+  margin-top: var(--spacing-2);
+}
diff --git a/frontend/src/features/quiz/components/ResultSummary.tsx b/frontend/src/features/quiz/components/ResultSummary.tsx
new file mode 100644
index 0000000..ec226a5
--- /dev/null
+++ b/frontend/src/features/quiz/components/ResultSummary.tsx
@@ -0,0 +1,77 @@
+/**
+ * ResultSummary — the score screen.
+ *
+ * Reports against `gradableTotal`, not the paper length. Part of the bank has
+ * `correctIndex === -1` (no answer key), and counting those as wrong would
+ * quietly understate every score that includes one.
+ */
+
+import type { ReactNode } from 'react';
+import { describeClock } from '../format';
+import type { QuizSummary } from '../types';
+import styles from './ResultSummary.module.css';
+
+export interface ResultSummaryProps {
+  summary: QuizSummary;
+  /** Shown above the score, e.g. the chapter or test name. */
+  title?: string;
+  /** Pass threshold as a percentage. Default 60. */
+  passPct?: number;
+  /** Action buttons/links — the host owns routing. */
+  actions?: ReactNode;
+}
+
+export function ResultSummary({ summary, title, passPct = 60, actions }: ResultSummaryProps) {
+  const { score, gradableTotal, total, answered, skipped, incorrect, accuracyPct, elapsedMs } =
+    summary;
+  const passed = accuracyPct >= passPct;
+  const ungraded = total - gradableTotal;
+
+  return (
+    <section className={styles.wrap} aria-labelledby="quiz-result-heading">
+      <h2 id="quiz-result-heading" className={styles.heading}>
+        Attempt complete
+      </h2>
+      {title && <p className={styles.title}>{title}</p>}
+
+      <p className={`${styles.score} ${passed ? styles.pass : styles.fail}`}>
+        <span className={styles.scoreValue}>{score}</span>
+        <span className={styles.scoreTotal}>/ {gradableTotal}</span>
+      </p>
+      <p className={styles.accuracy}>{accuracyPct}% accuracy</p>
+
+      <dl className={styles.stats}>
+        <div className={styles.stat}>
+          <dt>Correct</dt>
+          <dd>{score}</dd>
+        </div>
+        <div className={styles.stat}>
+          <dt>Incorrect</dt>
+          <dd>{incorrect}</dd>
+        </div>
+        <div className={styles.stat}>
+          <dt>Skipped</dt>
+          <dd>{skipped}</dd>
+        </div>
+        <div className={styles.stat}>
+          <dt>Time on task</dt>
+          <dd className={styles.small}>{describeClock(elapsedMs)}</dd>
+        </div>
+      </dl>
+
+      {ungraded > 0 && (
+        <p className={styles.note}>
+          {ungraded} question{ungraded === 1 ? '' : 's'} in this set {ungraded === 1 ? 'has' : 'have'}{' '}
+          no answer key yet, so {ungraded === 1 ? 'it is' : 'they are'} excluded from the score.
+        </p>
+      )}
+      {answered < total && (
+        <p className={styles.note}>
+          You answered {answered} of {total} questions.
+        </p>
+      )}
+
+      {actions && <div className={styles.actions}>{actions}</div>}
+    </section>
+  );
+}
diff --git a/frontend/src/features/quiz/components/ReviewScreen.module.css b/frontend/src/features/quiz/components/ReviewScreen.module.css
new file mode 100644
index 0000000..143d283
--- /dev/null
+++ b/frontend/src/features/quiz/components/ReviewScreen.module.css
@@ -0,0 +1,114 @@
+.wrap {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  padding: var(--spacing-5);
+  background: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-lg);
+}
+
+.heading {
+  margin: 0;
+  font-size: var(--text-lg);
+  color: var(--color-fg);
+}
+
+.counts {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(8rem, 1fr));
+  gap: var(--spacing-3);
+  margin: 0;
+}
+
+.count {
+  padding: var(--spacing-3);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  background: var(--color-surface-2);
+}
+
+.count dt {
+  font-size: var(--text-xs);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--color-fg-muted);
+}
+
+.count dd {
+  margin: 0.25rem 0 0;
+  font-size: var(--text-xl);
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+  color: var(--color-fg);
+}
+
+.of {
+  font-size: var(--text-sm);
+  font-weight: 500;
+  color: var(--color-fg-muted);
+}
+
+.warn {
+  border-color: var(--color-warning-500);
+}
+
+.detail {
+  margin: 0;
+  font-size: var(--text-sm);
+  color: var(--color-fg-muted);
+  overflow-wrap: anywhere;
+}
+
+.detail strong {
+  color: var(--color-fg);
+}
+
+.actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-3);
+}
+
+.primary,
+.secondary,
+.danger {
+  min-height: 44px;
+  padding: var(--spacing-3) var(--spacing-5);
+  font: inherit;
+  font-size: var(--text-sm);
+  font-weight: 600;
+  border-radius: var(--radius-md);
+  border: 1px solid transparent;
+  cursor: pointer;
+  flex: 1 1 10rem;
+}
+
+.primary {
+  background: var(--color-accent);
+  color: var(--color-accent-fg);
+}
+
+.secondary {
+  background: transparent;
+  color: var(--color-fg);
+  border-color: var(--color-border);
+}
+
+.danger {
+  background: var(--color-danger-500);
+  color: var(--color-accent-fg);
+}
+
+.primary:focus-visible,
+.secondary:focus-visible,
+.danger:focus-visible {
+  outline: 2px solid var(--color-ring);
+  outline-offset: 2px;
+}
+
+.warning {
+  margin: 0;
+  font-size: var(--text-sm);
+  color: var(--color-danger-fg);
+}
diff --git a/frontend/src/features/quiz/components/ReviewScreen.tsx b/frontend/src/features/quiz/components/ReviewScreen.tsx
new file mode 100644
index 0000000..7378bf3
--- /dev/null
+++ b/frontend/src/features/quiz/components/ReviewScreen.tsx
@@ -0,0 +1,113 @@
+/**
+ * ReviewScreen — the pre-submit summary and confirmation.
+ *
+ * The mock test submits straight off the last page: one click on "Submit Test"
+ * ends a 45-minute exam with no warning and no count of what was left blank.
+ * This puts the counts in front of the student and makes submission a
+ * two-step: the first press asks, the second commits.
+ */
+
+import { useState } from 'react';
+import type { PaletteEntry } from '../types';
+import { QuestionPalette } from './QuestionPalette';
+import styles from './ReviewScreen.module.css';
+
+export interface ReviewScreenProps {
+  total: number;
+  answered: number;
+  unanswered: number;
+  flagged: number;
+  /** Zero-based indices, rendered as 1-based question numbers. */
+  unansweredIndices: readonly number[];
+  flaggedIndices: readonly number[];
+  entries?: readonly PaletteEntry[];
+  /** Jump back to a question. Also used by the palette. */
+  onJump: (index: number) => void;
+  onBack: () => void;
+  onSubmit: () => void;
+  /** Hides the "go back" affordance when time has run out. */
+  canGoBack?: boolean;
+}
+
+function numberList(indices: readonly number[]): string {
+  return indices.map((i) => i + 1).join(', ');
+}
+
+export function ReviewScreen({
+  total,
+  answered,
+  unanswered,
+  flagged,
+  unansweredIndices,
+  flaggedIndices,
+  entries,
+  onJump,
+  onBack,
+  onSubmit,
+  canGoBack = true,
+}: ReviewScreenProps) {
+  const [confirming, setConfirming] = useState(false);
+
+  return (
+    <section className={styles.wrap} aria-labelledby="quiz-review-heading">
+      <h2 id="quiz-review-heading" className={styles.heading}>
+        Before you submit
+      </h2>
+
+      <dl className={styles.counts}>
+        <div className={styles.count}>
+          <dt>Answered</dt>
+          <dd>
+            {answered} <span className={styles.of}>/ {total}</span>
+          </dd>
+        </div>
+        <div className={`${styles.count} ${unanswered > 0 ? styles.warn : ''}`}>
+          <dt>Unanswered</dt>
+          <dd>{unanswered}</dd>
+        </div>
+        <div className={`${styles.count} ${flagged > 0 ? styles.warn : ''}`}>
+          <dt>Flagged for review</dt>
+          <dd>{flagged}</dd>
+        </div>
+      </dl>
+
+      {unanswered > 0 && (
+        <p className={styles.detail}>
+          Unanswered: <strong>{numberList(unansweredIndices)}</strong>
+        </p>
+      )}
+      {flagged > 0 && (
+        <p className={styles.detail}>
+          Flagged: <strong>{numberList(flaggedIndices)}</strong>
+        </p>
+      )}
+
+      {entries && entries.length > 0 && (
+        <QuestionPalette entries={entries} onJump={onJump} label="Jump to a question" />
+      )}
+
+      <div className={styles.actions}>
+        {canGoBack && (
+          <button type="button" className={styles.secondary} onClick={onBack}>
+            Keep working
+          </button>
+        )}
+        {confirming ? (
+          <button type="button" className={styles.danger} onClick={onSubmit}>
+            Yes, submit {unanswered > 0 ? `with ${unanswered} blank` : 'now'}
+          </button>
+        ) : (
+          <button type="button" className={styles.primary} onClick={() => setConfirming(true)}>
+            Submit paper
+          </button>
+        )}
+      </div>
+
+      {confirming && (
+        <p className={styles.warning} role="alert">
+          Submitting is final — you cannot change your answers afterwards.
+        </p>
+      )}
+    </section>
+  );
+}
diff --git a/frontend/src/features/quiz/draft.ts b/frontend/src/features/quiz/draft.ts
new file mode 100644
index 0000000..30d5dba
--- /dev/null
+++ b/frontend/src/features/quiz/draft.ts
@@ -0,0 +1,252 @@
+/**
+ * Quiz engine — attempt persistence.
+ *
+ * Generalises the scheme MockTestQuiz already uses (`eng_mock_draft_v1:<id>`)
+ * so practice modes get the same crash-safety the exam has, and so a half-done
+ * attempt survives a reload, an accidental back-navigation or a killed tab.
+ *
+ * Two invariants carried over from the mock implementation:
+ *
+ *  - `endsAt` is an absolute wall-clock deadline, never a remaining-seconds
+ *    counter. A counter pauses when the tab closes and resets on reload, which
+ *    hands the student unlimited time.
+ *  - The paper is stored as question ids, and a restore that cannot resolve
+ *    every id is thrown away. Scoring against a paper you cannot rebuild is
+ *    worse than starting over.
+ *
+ * Legacy mock drafts are read once and migrated, so an exam in progress when
+ * this ships is not destroyed by the upgrade.
+ */
+
+import type { FeedbackMode, QuizMode, QuizState } from './types';
+
+export const DRAFT_VERSION = 1;
+
+/** Bump the suffix, never the shape, when the draft format changes. */
+export const DRAFT_PREFIX = 'eng_quiz_draft_v1:';
+
+/** The pre-engine mock format. Read-only: migrated on first load, then dropped. */
+export const LEGACY_MOCK_DRAFT_PREFIX = 'eng_mock_draft_v1:';
+
+export interface QuizDraft {
+  v: typeof DRAFT_VERSION;
+  /** Attempt identity, e.g. `topic:book-ch1:30` or `mock:mock-1`. */
+  key: string;
+  mode: QuizMode;
+  feedback: FeedbackMode;
+  questionIds: string[];
+  selections: (number | null)[];
+  submitted: number[];
+  flagged: number[];
+  accumulatedMs: number[];
+  currentIndex: number;
+  startedAt: number;
+  /** Absolute deadline, epoch ms. Null for untimed attempts. */
+  endsAt: number | null;
+  savedAt: number;
+}
+
+export function draftStorageKey(key: string): string {
+  return DRAFT_PREFIX + key;
+}
+
+// ─── Validation ──────────────────────────────────────────────────────────────
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+function asNumberArray(v: unknown, length?: number): number[] | null {
+  if (!Array.isArray(v)) return null;
+  if (!v.every((n): n is number => typeof n === 'number' && Number.isFinite(n))) return null;
+  if (length !== undefined && v.length !== length) return null;
+  return v;
+}
+
+function asSelections(v: unknown, length: number): (number | null)[] | null {
+  if (!Array.isArray(v) || v.length !== length) return null;
+  const ok = v.every(
+    (n): n is number | null => n === null || (typeof n === 'number' && Number.isInteger(n))
+  );
+  return ok ? v : null;
+}
+
+function asStringArray(v: unknown): string[] | null {
+  if (!Array.isArray(v)) return null;
+  return v.every((s): s is string => typeof s === 'string') ? v : null;
+}
+
+const MODES: readonly QuizMode[] = ['topic', 'quick', 'custom', 'mock', 'bookmarks'];
+
+function asMode(v: unknown): QuizMode | null {
+  return typeof v === 'string' && (MODES as readonly string[]).includes(v)
+    ? (v as QuizMode)
+    : null;
+}
+
+/**
+ * Parses a stored draft, returning null for anything it does not fully trust.
+ *
+ * Deliberately strict rather than forgiving: a partially-recovered draft is a
+ * silently wrong attempt, while a rejected one just starts fresh.
+ */
+export function parseDraft(raw: unknown, key: string): QuizDraft | null {
+  if (!isRecord(raw)) return null;
+  if (raw.v !== DRAFT_VERSION || raw.key !== key) return null;
+
+  const mode = asMode(raw.mode);
+  const questionIds = asStringArray(raw.questionIds);
+  if (mode === null || questionIds === null || questionIds.length === 0) return null;
+
+  const n = questionIds.length;
+  const selections = asSelections(raw.selections, n);
+  const accumulatedMs = asNumberArray(raw.accumulatedMs, n);
+  const submitted = asNumberArray(raw.submitted);
+  const flagged = asNumberArray(raw.flagged);
+  if (selections === null || accumulatedMs === null || submitted === null || flagged === null) {
+    return null;
+  }
+
+  if (typeof raw.startedAt !== 'number' || !Number.isFinite(raw.startedAt)) return null;
+  const endsAt =
+    raw.endsAt === null
+      ? null
+      : typeof raw.endsAt === 'number' && Number.isFinite(raw.endsAt)
+        ? raw.endsAt
+        : undefined;
+  if (endsAt === undefined) return null;
+
+  const feedback: FeedbackMode = raw.feedback === 'deferred' ? 'deferred' : 'immediate';
+  const currentIndex =
+    typeof raw.currentIndex === 'number' && Number.isInteger(raw.currentIndex)
+      ? Math.min(Math.max(raw.currentIndex, 0), n - 1)
+      : 0;
+
+  return {
+    v: DRAFT_VERSION,
+    key,
+    mode,
+    feedback,
+    questionIds,
+    selections,
+    submitted: submitted.filter((i) => i >= 0 && i < n),
+    flagged: flagged.filter((i) => i >= 0 && i < n),
+    accumulatedMs,
+    currentIndex,
+    startedAt: raw.startedAt,
+    endsAt,
+    savedAt: typeof raw.savedAt === 'number' ? raw.savedAt : raw.startedAt,
+  };
+}
+
+// ─── Legacy migration ────────────────────────────────────────────────────────
+
+/**
+ * Reads a pre-engine mock draft (`{testId, questionIds, answers, endsAt,
+ * startedAt}`) and lifts it into the new shape. Answers were never committed
+ * per question in the old mock, so `submitted` starts empty — correct, because
+ * a deferred attempt commits nothing until the paper goes in.
+ */
+export function readLegacyMockDraft(testId: string, key: string): QuizDraft | null {
+  let raw: unknown;
+  try {
+    const stored = localStorage.getItem(LEGACY_MOCK_DRAFT_PREFIX + testId);
+    if (!stored) return null;
+    raw = JSON.parse(stored);
+  } catch {
+    return null;
+  }
+  if (!isRecord(raw) || raw.testId !== testId) return null;
+
+  const questionIds = asStringArray(raw.questionIds);
+  if (questionIds === null || questionIds.length === 0) return null;
+  const selections = asSelections(raw.answers, questionIds.length);
+  if (selections === null) return null;
+  if (typeof raw.endsAt !== 'number' || !Number.isFinite(raw.endsAt)) return null;
+  const startedAt = typeof raw.startedAt === 'number' ? raw.startedAt : raw.endsAt;
+
+  return {
+    v: DRAFT_VERSION,
+    key,
+    mode: 'mock',
+    feedback: 'deferred',
+    questionIds,
+    selections,
+    submitted: [],
+    flagged: [],
+    accumulatedMs: Array<number>(questionIds.length).fill(0),
+    currentIndex: 0,
+    startedAt,
+    endsAt: raw.endsAt,
+    savedAt: startedAt,
+  };
+}
+
+// ─── Storage ─────────────────────────────────────────────────────────────────
+
+export interface DraftOptions {
+  /** When set, a missing draft falls back to the legacy mock draft for this id. */
+  legacyMockTestId?: string;
+}
+
+export function readDraft(key: string, options: DraftOptions = {}): QuizDraft | null {
+  let parsed: QuizDraft | null = null;
+  try {
+    const stored = localStorage.getItem(draftStorageKey(key));
+    if (stored) parsed = parseDraft(JSON.parse(stored), key);
+  } catch {
+    parsed = null;
+  }
+  if (parsed) return parsed;
+  if (options.legacyMockTestId) return readLegacyMockDraft(options.legacyMockTestId, key);
+  return null;
+}
+
+export function writeDraft(draft: QuizDraft): void {
+  try {
+    localStorage.setItem(draftStorageKey(draft.key), JSON.stringify(draft));
+  } catch {
+    // Storage full, blocked, or private mode. The attempt continues; it just
+    // will not resume. Never let persistence take down the quiz.
+  }
+}
+
+export function clearDraft(key: string, options: DraftOptions = {}): void {
+  try {
+    localStorage.removeItem(draftStorageKey(key));
+    if (options.legacyMockTestId) {
+      localStorage.removeItem(LEGACY_MOCK_DRAFT_PREFIX + options.legacyMockTestId);
+    }
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Snapshots live state as a draft.
+ *
+ * Returns null for a finished or unloaded attempt: there is nothing worth
+ * resuming, and writing one would resurrect a quiz the student completed.
+ */
+export function draftFromState(state: QuizState, key: string, savedAt: number): QuizDraft | null {
+  if (state.phase === 'loading' || state.phase === 'done') return null;
+  if (state.questions.length === 0 || state.timing.startedAt === null) return null;
+  return {
+    v: DRAFT_VERSION,
+    key,
+    mode: state.mode,
+    feedback: state.feedback,
+    questionIds: state.questions.map((q) => q.id),
+    selections: [...state.selections],
+    submitted: [...state.submitted],
+    flagged: [...state.flagged],
+    // Banked time only. The running slice is intentionally left out: on resume
+    // the clock restarts, and crediting time for a tab that was closed would
+    // inflate every latency that feeds guess detection.
+    accumulatedMs: [...state.timing.accumulatedMs],
+    currentIndex: state.currentIndex,
+    startedAt: state.timing.startedAt,
+    endsAt: state.timing.endsAt,
+    savedAt,
+  };
+}
diff --git a/frontend/src/features/quiz/format.ts b/frontend/src/features/quiz/format.ts
new file mode 100644
index 0000000..be4d1c3
--- /dev/null
+++ b/frontend/src/features/quiz/format.ts
@@ -0,0 +1,51 @@
+/** Formatting helpers shared by the quiz components. Pure. */
+
+import type { Verdict } from './types';
+
+/** `mm:ss`, or `h:mm:ss` past an hour. Negative input clamps to zero. */
+export function formatClock(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000));
+  const seconds = total % 60;
+  const minutes = Math.floor(total / 60) % 60;
+  const hours = Math.floor(total / 3600);
+  const pad = (n: number) => String(n).padStart(2, '0');
+  return hours > 0 ? `${hours}:${pad(minutes)}:${pad(seconds)}` : `${pad(minutes)}:${pad(seconds)}`;
+}
+
+/** Spoken form for screen readers — "4 minutes 20 seconds" beats "04:20". */
+export function describeClock(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000));
+  const minutes = Math.floor(total / 60);
+  const seconds = total % 60;
+  if (minutes === 0) return `${seconds} second${seconds === 1 ? '' : 's'}`;
+  return `${minutes} minute${minutes === 1 ? '' : 's'} ${seconds} second${seconds === 1 ? '' : 's'}`;
+}
+
+/** A, B, C, D … for an option index. */
+export function optionLetter(index: number): string {
+  return String.fromCharCode(65 + index);
+}
+
+/** The tone a verdict banner should take. Kept out of the component files so
+ * they export nothing but components (react-refresh wants that). */
+export function verdictTone(verdict: Verdict): 'neutral' | 'positive' | 'negative' {
+  if (verdict === 'correct') return 'positive';
+  if (verdict === 'incorrect') return 'negative';
+  return 'neutral';
+}
+
+/** The sentence shown under a revealed question. */
+export function verdictMessage(verdict: Verdict, correctIndex: number): string {
+  switch (verdict) {
+    case 'correct':
+      return 'Correct. Well done.';
+    case 'incorrect':
+      return `Incorrect. The correct answer is ${optionLetter(correctIndex)}.`;
+    case 'unkeyed':
+      return 'Answer recorded. No answer key is available for this question yet.';
+    case 'pending':
+      return 'Answer recorded. It will be marked when you submit the paper.';
+    case 'unanswered':
+      return 'Not answered.';
+  }
+}
diff --git a/frontend/src/features/quiz/guess.ts b/frontend/src/features/quiz/guess.ts
new file mode 100644
index 0000000..ab24297
--- /dev/null
+++ b/frontend/src/features/quiz/guess.ts
@@ -0,0 +1,68 @@
+/**
+ * Guess detection.
+ *
+ * An answer that lands far faster than the student normally answers is almost
+ * never reading-plus-reasoning; it is a tap to move on. Marking those lets
+ * later analytics separate "knows it" from "got lucky", which a raw score
+ * cannot do.
+ *
+ * Threshold: `max(4000ms, 0.35 x median latency of this session)`.
+ *
+ * The absolute floor matters because the relative part collapses on a session
+ * where every answer was fast — 35% of a 3-second median is 1 second, which
+ * would flag nothing. The relative part matters because a student who takes 60
+ * seconds per question is plainly guessing at 8 seconds, which the floor alone
+ * would wave through.
+ *
+ * All functions here are pure; nothing reads the clock.
+ */
+
+import type { ResponseRecord } from './types';
+
+/** Nobody reads a four-option question and reasons about it in under 4s. */
+export const GUESS_FLOOR_MS = 4000;
+
+/** Fraction of the session median below which an answer reads as a guess. */
+export const GUESS_MEDIAN_FRACTION = 0.35;
+
+/** Median of a sample. Returns 0 for an empty sample. Does not mutate the input. */
+export function median(values: readonly number[]): number {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = sorted.length >> 1;
+  return sorted.length % 2 === 1
+    ? sorted[mid]
+    : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+
+/** The latency under which an answer counts as a guess, given the session sample. */
+export function guessThresholdMs(latencies: readonly number[]): number {
+  return Math.max(GUESS_FLOOR_MS, GUESS_MEDIAN_FRACTION * median(latencies));
+}
+
+/** Strictly under the threshold — an answer exactly at the threshold is not flagged. */
+export function isGuessLatency(timeSpentMs: number, latencies: readonly number[]): boolean {
+  return timeSpentMs < guessThresholdMs(latencies);
+}
+
+/**
+ * Recomputes `flaggedGuess` across every record in the attempt.
+ *
+ * Called on each submit rather than deciding once at insert time: the median is
+ * a property of the whole session, so the twelfth answer changes whether the
+ * second one looked like a guess. Recomputing keeps the set self-consistent,
+ * and at a few hundred records the cost is irrelevant.
+ *
+ * Only records with a chosen answer contribute to the median, and only those
+ * can be flagged — a blank is a skip, not a guess.
+ */
+export function markGuesses(records: readonly ResponseRecord[]): ResponseRecord[] {
+  const latencies = records
+    .filter((r) => r.chosenIndex !== null)
+    .map((r) => r.timeSpentMs);
+  const threshold = guessThresholdMs(latencies);
+  return records.map((r) => {
+    const flaggedGuess = r.chosenIndex !== null && r.timeSpentMs < threshold;
+    return flaggedGuess === r.flaggedGuess ? r : { ...r, flaggedGuess };
+  });
+}
diff --git a/frontend/src/features/quiz/index.ts b/frontend/src/features/quiz/index.ts
new file mode 100644
index 0000000..41ff0cd
--- /dev/null
+++ b/frontend/src/features/quiz/index.ts
@@ -0,0 +1,65 @@
+/**
+ * Quiz engine — public surface.
+ *
+ * Pages import from here and nothing else. Everything below is either pure
+ * (reducer, selectors, draft, guess, format) or presentational (components);
+ * the only module that touches React state is useQuiz.
+ */
+
+export { useQuiz } from './useQuiz';
+export type { UseQuizOptions, UseQuizResult, QuizCounts } from './useQuiz';
+
+export { useQuizKeyboard, isTextEntryTarget, optionIndexForKey } from './useQuizKeyboard';
+export type { UseQuizKeyboardOptions, QuizKeyboardHandlers } from './useQuizKeyboard';
+
+export { quizReducer, createInitialState, defaultFeedbackFor, timeSpentAt } from './reducer';
+export type { InitialQuizConfig } from './reducer';
+
+export * from './actions';
+export * from './selectors';
+export * from './guess';
+export * from './format';
+
+export {
+  DRAFT_PREFIX,
+  DRAFT_VERSION,
+  LEGACY_MOCK_DRAFT_PREFIX,
+  clearDraft,
+  draftFromState,
+  draftStorageKey,
+  parseDraft,
+  readDraft,
+  readLegacyMockDraft,
+  writeDraft,
+} from './draft';
+export type { QuizDraft, DraftOptions } from './draft';
+
+export type {
+  FeedbackMode,
+  PaletteEntry,
+  Question,
+  QuizMode,
+  QuizPhase,
+  QuizState,
+  QuizSummary,
+  QuizTiming,
+  ResponseRecord,
+  Verdict,
+} from './types';
+
+export { ExplanationPanel } from './components/ExplanationPanel';
+export type { ExplanationPanelProps } from './components/ExplanationPanel';
+export { OptionList } from './components/OptionList';
+export type { OptionListProps } from './components/OptionList';
+export { QuestionCard } from './components/QuestionCard';
+export type { QuestionCardProps } from './components/QuestionCard';
+export { QuestionPalette } from './components/QuestionPalette';
+export type { QuestionPaletteProps } from './components/QuestionPalette';
+export { QuizActionBar } from './components/QuizActionBar';
+export type { QuizActionBarProps } from './components/QuizActionBar';
+export { QuizToolbar } from './components/QuizToolbar';
+export type { QuizToolbarProps } from './components/QuizToolbar';
+export { ResultSummary } from './components/ResultSummary';
+export type { ResultSummaryProps } from './components/ResultSummary';
+export { ReviewScreen } from './components/ReviewScreen';
+export type { ReviewScreenProps } from './components/ReviewScreen';
diff --git a/frontend/src/features/quiz/reducer.ts b/frontend/src/features/quiz/reducer.ts
new file mode 100644
index 0000000..cd408ba
--- /dev/null
+++ b/frontend/src/features/quiz/reducer.ts
@@ -0,0 +1,318 @@
+/**
+ * Quiz engine — the state machine.
+ *
+ * Pure: no React, no clock, no storage. Everything time-dependent arrives on
+ * the action as `at`. Everything score-dependent is derived in selectors.ts,
+ * never accumulated here.
+ *
+ * Three bugs in the hand-rolled page copies this replaces, and how the shape
+ * prevents each one:
+ *
+ *  1. Navigation erased the answer. Fixed by `selections` being one slot per
+ *     question that nothing resets on navigation. There is no scalar
+ *     "selectedAnswer" to lose.
+ *  2. A revisited question showed the wrong verdict. Fixed by the verdict being
+ *     computed from `selections[i]` and `submitted`, so it is restored with the
+ *     choice rather than tracked separately.
+ *  3. Score double-counted. The pages did `setScore(s => s + 1)` inside submit,
+ *     so any re-entry (double click, re-submit, StrictMode replay) inflated it.
+ *     There is no score field here at all; `selectScore` counts the committed
+ *     answers. Re-submitting is also an explicit no-op below.
+ */
+
+import type { QuizAction, HydratePayload } from './actions';
+import { markGuesses } from './guess';
+import type {
+  FeedbackMode,
+  QuizMode,
+  QuizState,
+  QuizTiming,
+  ResponseRecord,
+} from './types';
+
+export interface InitialQuizConfig {
+  mode: QuizMode;
+  feedback: FeedbackMode;
+  attemptKey?: string | null;
+}
+
+/** The default feedback behaviour for a surface: exams defer, practice does not. */
+export function defaultFeedbackFor(mode: QuizMode): FeedbackMode {
+  return mode === 'mock' ? 'deferred' : 'immediate';
+}
+
+export function createInitialState(config: InitialQuizConfig): QuizState {
+  return {
+    attemptKey: config.attemptKey ?? null,
+    mode: config.mode,
+    feedback: config.feedback,
+    phase: 'loading',
+    questions: [],
+    selections: [],
+    submitted: new Set<number>(),
+    flagged: new Set<number>(),
+    bookmarked: new Set<string>(),
+    currentIndex: 0,
+    revealAll: false,
+    responses: [],
+    timing: {
+      startedAt: null,
+      endsAt: null,
+      viewStartedAt: null,
+      accumulatedMs: [],
+      paused: false,
+    },
+    resumed: false,
+  };
+}
+
+// ─── Timing helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Folds the running slice into `accumulatedMs[index]` and restarts the slice.
+ *
+ * `restartAt` of null leaves the clock stopped (pause, or attempt finished).
+ * A negative slice (clock skew, or a stale `at`) is clamped to zero so timing
+ * can never run backwards.
+ */
+function bankSlice(
+  timing: QuizTiming,
+  index: number,
+  at: number,
+  restartAt: number | null
+): QuizTiming {
+  const accumulatedMs = [...timing.accumulatedMs];
+  if (timing.viewStartedAt !== null && index >= 0 && index < accumulatedMs.length) {
+    accumulatedMs[index] += Math.max(0, at - timing.viewStartedAt);
+  }
+  return { ...timing, accumulatedMs, viewStartedAt: restartAt, paused: restartAt === null };
+}
+
+/** Visible time on a question, including the slice still running at `at`. */
+export function timeSpentAt(state: QuizState, index: number, at: number): number {
+  const banked = state.timing.accumulatedMs[index] ?? 0;
+  const running =
+    index === state.currentIndex && state.timing.viewStartedAt !== null
+      ? Math.max(0, at - state.timing.viewStartedAt)
+      : 0;
+  return banked + running;
+}
+
+// ─── Commit helpers ──────────────────────────────────────────────────────────
+
+function buildRecord(
+  state: QuizState,
+  index: number,
+  timeSpentMs: number,
+  at: number
+): ResponseRecord {
+  const q = state.questions[index];
+  const chosenIndex = state.selections[index] ?? null;
+  // `correctIndex === -1` is the no-answer-key sentinel from localData. Such a
+  // question is never scored as correct, which is why selectors report a
+  // separate gradable total instead of pretending it was wrong.
+  const hasKey = q.correctIndex >= 0;
+  return {
+    questionId: q.id,
+    topicId: q.topicId,
+    chosenIndex,
+    correct: hasKey && chosenIndex !== null && chosenIndex === q.correctIndex,
+    timeSpentMs,
+    mode: state.mode,
+    // Recomputed across the whole set by markGuesses once the record is in.
+    flaggedGuess: false,
+    timestamp: at,
+  };
+}
+
+/**
+ * Commits every question not already committed and ends the attempt.
+ *
+ * Blanks get a record too (`chosenIndex: null`): a skipped question with 40
+ * seconds on it is a different signal from one the student never reached, and
+ * only a record carries that.
+ */
+function finish(state: QuizState, at: number): QuizState {
+  if (state.phase === 'done' || state.questions.length === 0) return state;
+
+  const timing = bankSlice(state.timing, state.currentIndex, at, null);
+  const pending: ResponseRecord[] = [];
+  const submitted = new Set(state.submitted);
+
+  for (let i = 0; i < state.questions.length; i++) {
+    if (submitted.has(i)) continue;
+    submitted.add(i);
+    pending.push(buildRecord(state, i, timing.accumulatedMs[i] ?? 0, at));
+  }
+
+  return {
+    ...state,
+    phase: 'done',
+    submitted,
+    revealAll: true,
+    responses: markGuesses([...state.responses, ...pending]),
+    timing,
+  };
+}
+
+// ─── Hydrate ─────────────────────────────────────────────────────────────────
+
+function sameLength<T>(arr: readonly T[] | undefined, n: number): readonly T[] | undefined {
+  return arr !== undefined && arr.length === n ? arr : undefined;
+}
+
+function hydrateState(state: QuizState, payload: HydratePayload): QuizState {
+  const { questions, at, startedAt, endsAt } = payload;
+  if (questions.length === 0) return state;
+
+  const n = questions.length;
+  // A restored array of the wrong length describes a different paper. Drop it
+  // rather than re-point every stored answer at the wrong question.
+  const selections = sameLength(payload.selections, n) ?? Array<number | null>(n).fill(null);
+  const accumulatedMs = sameLength(payload.accumulatedMs, n) ?? Array<number>(n).fill(0);
+  const submitted = new Set((payload.submitted ?? []).filter((i) => i >= 0 && i < n));
+  const flagged = new Set((payload.flagged ?? []).filter((i) => i >= 0 && i < n));
+  const currentIndex = Math.min(Math.max(payload.currentIndex ?? 0, 0), n - 1);
+
+  const hydrated: QuizState = {
+    ...state,
+    attemptKey: payload.attemptKey,
+    phase: 'active',
+    questions,
+    selections: [...selections],
+    submitted,
+    flagged,
+    bookmarked: new Set(payload.bookmarked ?? []),
+    currentIndex,
+    revealAll: false,
+    responses: [],
+    timing: {
+      startedAt,
+      endsAt,
+      viewStartedAt: at,
+      accumulatedMs: [...accumulatedMs],
+      paused: false,
+    },
+    resumed: payload.resumed ?? false,
+  };
+
+  // A timed draft whose deadline passed while the tab was shut is over. Score
+  // it from what was answered instead of handing back a fresh timer.
+  if (endsAt !== null && at >= endsAt) {
+    return finish({ ...hydrated, timing: { ...hydrated.timing, viewStartedAt: null } }, at);
+  }
+  return hydrated;
+}
+
+// ─── Reducer ─────────────────────────────────────────────────────────────────
+
+export function quizReducer(state: QuizState, action: QuizAction): QuizState {
+  switch (action.type) {
+    case 'quiz/hydrate':
+      return hydrateState(state, action.payload);
+
+    case 'quiz/select': {
+      const { index, option } = action;
+      if (state.phase === 'done') return state;
+      if (index < 0 || index >= state.questions.length) return state;
+      // Committed answers are frozen. In deferred mode nothing is committed
+      // until the paper is submitted, so answers stay editable throughout.
+      if (state.submitted.has(index)) return state;
+      if (option < 0 || option >= state.questions[index].options.length) return state;
+      if (state.selections[index] === option) return state;
+      const selections = [...state.selections];
+      selections[index] = option;
+      return { ...state, selections };
+    }
+
+    case 'quiz/submitQuestion': {
+      const { index, at } = action;
+      if (state.phase === 'done') return state;
+      if (index < 0 || index >= state.questions.length) return state;
+      // Idempotent by construction: the second submit of a question changes
+      // nothing, so no amount of re-entry can inflate the score.
+      if (state.submitted.has(index)) return state;
+      if (state.selections[index] === null || state.selections[index] === undefined) return state;
+
+      const timing = bankSlice(state.timing, index, at, at);
+      const record = buildRecord(state, index, timing.accumulatedMs[index] ?? 0, at);
+      return {
+        ...state,
+        submitted: new Set(state.submitted).add(index),
+        responses: markGuesses([...state.responses, record]),
+        timing,
+      };
+    }
+
+    case 'quiz/submitAll':
+      return finish(state, action.at);
+
+    case 'quiz/navigate': {
+      const { at } = action;
+      if (state.questions.length === 0) return state;
+      const index = Math.min(Math.max(action.index, 0), state.questions.length - 1);
+      if (index === state.currentIndex) return state;
+      const timing =
+        state.phase === 'done'
+          ? state.timing
+          : bankSlice(state.timing, state.currentIndex, at, state.timing.paused ? null : at);
+      return { ...state, currentIndex: index, timing };
+    }
+
+    case 'quiz/toggleFlag': {
+      const { index } = action;
+      if (index < 0 || index >= state.questions.length) return state;
+      const flagged = new Set(state.flagged);
+      if (flagged.has(index)) flagged.delete(index);
+      else flagged.add(index);
+      return { ...state, flagged };
+    }
+
+    case 'quiz/setBookmarks':
+      return { ...state, bookmarked: new Set(action.ids) };
+
+    case 'quiz/toggleBookmark': {
+      const bookmarked = new Set(state.bookmarked);
+      if (bookmarked.has(action.questionId)) bookmarked.delete(action.questionId);
+      else bookmarked.add(action.questionId);
+      return { ...state, bookmarked };
+    }
+
+    case 'quiz/enterReview': {
+      if (state.phase !== 'active') return state;
+      // The clock keeps running on review — in a timed exam the deadline does
+      // not care which screen you are looking at — but no question is on
+      // screen, so the running slice is banked and left stopped.
+      return { ...state, phase: 'review', timing: bankSlice(state.timing, state.currentIndex, action.at, null) };
+    }
+
+    case 'quiz/exitReview': {
+      if (state.phase !== 'review') return state;
+      return {
+        ...state,
+        phase: 'active',
+        timing: { ...state.timing, viewStartedAt: action.at, paused: false },
+      };
+    }
+
+    case 'quiz/pause': {
+      if (state.phase === 'done' || state.timing.viewStartedAt === null) return state;
+      return { ...state, timing: bankSlice(state.timing, state.currentIndex, action.at, null) };
+    }
+
+    case 'quiz/resume': {
+      if (state.phase !== 'active' || state.timing.viewStartedAt !== null) return state;
+      return { ...state, timing: { ...state.timing, viewStartedAt: action.at, paused: false } };
+    }
+
+    case 'quiz/reset':
+      return createInitialState({
+        mode: state.mode,
+        feedback: state.feedback,
+        attemptKey: state.attemptKey,
+      });
+
+    default:
+      return state;
+  }
+}
diff --git a/frontend/src/features/quiz/selectors.ts b/frontend/src/features/quiz/selectors.ts
new file mode 100644
index 0000000..031f744
--- /dev/null
+++ b/frontend/src/features/quiz/selectors.ts
@@ -0,0 +1,153 @@
+/**
+ * Quiz engine — derived reads.
+ *
+ * Nothing here is stored in state. Score in particular is counted from the
+ * committed answers on every read, so it cannot drift from the answers the way
+ * an incremented counter does.
+ */
+
+import type {
+  PaletteEntry,
+  Question,
+  QuizState,
+  QuizSummary,
+  Verdict,
+} from './types';
+
+export function selectCurrentQuestion(state: QuizState): Question | undefined {
+  return state.questions[state.currentIndex];
+}
+
+export function selectSelection(state: QuizState, index: number): number | null {
+  return state.selections[index] ?? null;
+}
+
+export function selectIsSubmitted(state: QuizState, index: number): boolean {
+  return state.submitted.has(index);
+}
+
+/**
+ * Whether question `index` may show its answer key.
+ *
+ * `immediate`: as soon as that question is committed.
+ * `deferred`: not until the paper is submitted (`revealAll`).
+ */
+export function selectIsRevealed(state: QuizState, index: number): boolean {
+  if (state.revealAll) return true;
+  return state.feedback === 'immediate' && state.submitted.has(index);
+}
+
+/**
+ * The verdict a question should display.
+ *
+ * `pending` is the deferred-mode answer: the student picked something and the
+ * UI must show the pick without leaking whether it was right. Returning
+ * `unanswered` for an untouched question is what stops forward navigation from
+ * showing a verdict on a question nobody has answered.
+ */
+export function selectVerdict(state: QuizState, index: number): Verdict {
+  const q = state.questions[index];
+  const chosen = state.selections[index] ?? null;
+  if (!q) return 'unanswered';
+  if (chosen === null) return 'unanswered';
+  if (!selectIsRevealed(state, index)) return 'pending';
+  if (q.correctIndex < 0) return 'unkeyed';
+  return chosen === q.correctIndex ? 'correct' : 'incorrect';
+}
+
+/** Derived score: committed answers that match a real answer key. */
+export function selectScore(state: QuizState): number {
+  let score = 0;
+  for (const index of state.submitted) {
+    const q = state.questions[index];
+    if (!q || q.correctIndex < 0) continue;
+    if (state.selections[index] === q.correctIndex) score++;
+  }
+  return score;
+}
+
+/** Questions with a usable answer key — the denominator a percentage deserves. */
+export function selectGradableTotal(state: QuizState): number {
+  return state.questions.reduce((n, q) => (q.correctIndex >= 0 ? n + 1 : n), 0);
+}
+
+/** Answered means "has a selection", committed or not. */
+export function selectAnsweredCount(state: QuizState): number {
+  return state.selections.reduce<number>((n, s) => (s === null ? n : n + 1), 0);
+}
+
+export function selectUnansweredCount(state: QuizState): number {
+  return state.questions.length - selectAnsweredCount(state);
+}
+
+export function selectFlaggedCount(state: QuizState): number {
+  return state.flagged.size;
+}
+
+/** Indices still unanswered, in paper order — the list the review screen shows. */
+export function selectUnansweredIndices(state: QuizState): number[] {
+  const out: number[] = [];
+  for (let i = 0; i < state.questions.length; i++) {
+    if ((state.selections[i] ?? null) === null) out.push(i);
+  }
+  return out;
+}
+
+export function selectFlaggedIndices(state: QuizState): number[] {
+  return [...state.flagged].sort((a, b) => a - b);
+}
+
+export function selectIsBookmarked(state: QuizState, index: number): boolean {
+  const q = state.questions[index];
+  return q ? state.bookmarked.has(q.id) : false;
+}
+
+/** One entry per question for the numbered palette. States are not exclusive. */
+export function selectPalette(state: QuizState): PaletteEntry[] {
+  return state.questions.map((q, index) => ({
+    index,
+    questionId: q.id,
+    answered: (state.selections[index] ?? null) !== null,
+    submitted: state.submitted.has(index),
+    flagged: state.flagged.has(index),
+    current: index === state.currentIndex,
+  }));
+}
+
+/** Milliseconds left against the absolute deadline. Null when untimed. */
+export function selectTimeLeftMs(state: QuizState, now: number): number | null {
+  if (state.timing.endsAt === null) return null;
+  return Math.max(0, state.timing.endsAt - now);
+}
+
+export function selectIsExpired(state: QuizState, now: number): boolean {
+  return state.timing.endsAt !== null && now >= state.timing.endsAt;
+}
+
+export function selectSummary(state: QuizState): QuizSummary {
+  const score = selectScore(state);
+  const gradableTotal = selectGradableTotal(state);
+  const answered = selectAnsweredCount(state);
+  const total = state.questions.length;
+  return {
+    mode: state.mode,
+    score,
+    total,
+    gradableTotal,
+    answered,
+    skipped: total - answered,
+    // Wrong answers only: an unanswered question is skipped, not incorrect, and
+    // a question with no answer key is neither.
+    incorrect: state.questions.reduce<number>((n, q, i) => {
+      if (q.correctIndex < 0) return n;
+      if (!state.submitted.has(i)) return n;
+      const chosen = state.selections[i] ?? null;
+      return chosen !== null && chosen !== q.correctIndex ? n + 1 : n;
+    }, 0),
+    accuracyPct: gradableTotal === 0 ? 0 : Math.round((score / gradableTotal) * 100),
+    // Visible time on task, not wall-clock duration: the tab being hidden for
+    // ten minutes is not ten minutes of study.
+    elapsedMs: state.timing.accumulatedMs.reduce((a, b) => a + b, 0),
+    responses: state.responses,
+  };
+}
diff --git a/frontend/src/features/quiz/types.ts b/frontend/src/features/quiz/types.ts
new file mode 100644
index 0000000..6222d14
--- /dev/null
+++ b/frontend/src/features/quiz/types.ts
@@ -0,0 +1,150 @@
+/**
+ * Quiz engine — shared types.
+ *
+ * One state machine backs all four quiz surfaces (topic practice, quick
+ * practice, custom practice, mock test). The shapes here are deliberately
+ * serialisable: `QuizState` minus the question list is close to what gets
+ * written to the resume draft, and `ResponseRecord` is the analytics row.
+ */
+
+import type { Question } from '../../services/localData';
+
+export type { Question };
+
+/** Which surface the attempt came from. Travels into every response record. */
+export type QuizMode = 'topic' | 'quick' | 'custom' | 'mock' | 'bookmarks';
+
+/**
+ * When the verdict is allowed to be shown.
+ *
+ * - `immediate` — practice. Submitting one question reveals its verdict.
+ * - `deferred`  — exam. Nothing is revealed until the whole paper is submitted.
+ */
+export type FeedbackMode = 'immediate' | 'deferred';
+
+/**
+ * `loading` — no questions yet (fetching, or resolving a saved draft).
+ * `active`  — the student is working.
+ * `review`  — pre-submit confirmation screen; answers are still editable.
+ * `done`    — submitted and scored. Terminal.
+ */
+export type QuizPhase = 'loading' | 'active' | 'review' | 'done';
+
+/**
+ * One answered question, as handed to analytics.
+ *
+ * Fields are fixed by the analytics contract — do not add to this shape
+ * without a migration, because records are appended to durable storage.
+ */
+export interface ResponseRecord {
+  questionId: string;
+  topicId: string;
+  /** Chosen option index, or null when the question was left blank. */
+  chosenIndex: number | null;
+  /** False for blanks and for questions with no answer key (`correctIndex === -1`). */
+  correct: boolean;
+  /** Visible wall-clock milliseconds between first view and submit. */
+  timeSpentMs: number;
+  mode: QuizMode;
+  /** Answered suspiciously fast relative to this session — see guess.ts. */
+  flaggedGuess: boolean;
+  /** Submit time, epoch ms. */
+  timestamp: number;
+}
+
+/**
+ * Per-question timing.
+ *
+ * `accumulatedMs[i]` is time already banked for question i. The question
+ * currently being viewed also accrues `now - viewStartedAt`, which is only
+ * folded into `accumulatedMs` when the view changes, the clock pauses, or the
+ * answer is submitted. That split is what makes pausing on tab-hide cheap: we
+ * stop the running slice instead of reconciling a ticking counter.
+ */
+export interface QuizTiming {
+  /** Epoch ms the attempt began. Null while loading. */
+  startedAt: number | null;
+  /**
+   * Absolute wall-clock deadline, epoch ms. Null for untimed modes.
+   *
+   * Never a remaining-seconds counter: a decrementing counter pauses when the
+   * tab closes and resets on reload, which hands a student unlimited time.
+   */
+  endsAt: number | null;
+  /** Epoch ms the current question current running slice started. Null when paused. */
+  viewStartedAt: number | null;
+  /** Banked visible ms per question index. */
+  accumulatedMs: number[];
+  /** True while the tab is hidden (Page Visibility) or the attempt is finished. */
+  paused: boolean;
+}
+
+export interface QuizState {
+  /**
+   * Identity of the attempt this state belongs to, e.g. `topic:book-ch1:30`.
+   *
+   * Held in state so a host whose parameters changed can tell a stale attempt
+   * from the new one by comparison, instead of resetting from an effect.
+   */
+  attemptKey: string | null;
+  mode: QuizMode;
+  feedback: FeedbackMode;
+  phase: QuizPhase;
+  questions: Question[];
+  /** One slot per question: the chosen option index, or null if untouched. */
+  selections: (number | null)[];
+  /** Indices whose answer has been committed. */
+  submitted: ReadonlySet<number>;
+  /** Indices the student marked for review. */
+  flagged: ReadonlySet<number>;
+  /** Bookmarked question ids (ids, not indices — bookmarks outlive the attempt). */
+  bookmarked: ReadonlySet<string>;
+  currentIndex: number;
+  /**
+   * True once every verdict is public. Flips on the first submit in
+   * `immediate` mode; in `deferred` mode only when the paper is submitted.
+   */
+  revealAll: boolean;
+  /** Append-only, except that `flaggedGuess` is recomputed as the median moves. */
+  responses: ResponseRecord[];
+  timing: QuizTiming;
+  /** True when this attempt was rebuilt from a saved draft. */
+  resumed: boolean;
+}
+
+/** Everything a result screen needs. All of it derived, none of it accumulated. */
+export interface QuizSummary {
+  mode: QuizMode;
+  score: number;
+  /** Questions in the paper. */
+  total: number;
+  /** Questions that actually have an answer key — the honest denominator. */
+  gradableTotal: number;
+  answered: number;
+  skipped: number;
+  incorrect: number;
+  /** Percentage of `gradableTotal`, 0 when nothing is gradable. */
+  accuracyPct: number;
+  elapsedMs: number;
+  responses: ResponseRecord[];
+}
+
+/** One cell of the question palette. A question can be several of these at once. */
+export interface PaletteEntry {
+  index: number;
+  questionId: string;
+  answered: boolean;
+  submitted: boolean;
+  flagged: boolean;
+  current: boolean;
+}
+
+export type Verdict =
+  /** No selection yet. */
+  | 'unanswered'
+  /** Selected but not yet revealed (deferred mode, or not submitted). */
+  | 'pending'
+  | 'correct'
+  | 'incorrect'
+  /** Answered and revealed, but the bank has no key for this question. */
+  | 'unkeyed';
diff --git a/frontend/src/features/quiz/useQuiz.ts b/frontend/src/features/quiz/useQuiz.ts
new file mode 100644
index 0000000..2b59ae7
--- /dev/null
+++ b/frontend/src/features/quiz/useQuiz.ts
@@ -0,0 +1,440 @@
+/**
+ * useQuiz — the one quiz state machine, wired to React.
+ *
+ * Owns loading (fresh paper or resumed draft), the wall-clock timer, the Page
+ * Visibility pause, debounced autosave, and the write-through of answers to
+ * `recordAttempt`. Pages supply a question loader and render; they hold no
+ * quiz state of their own.
+ *
+ * The reducer and selectors underneath are pure, so the interesting behaviour
+ * is tested without React. What is tested here is only the wiring.
+ */
+
+import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react';
+import {
+  addBookmark,
+  getBookmarks,
+  recordAttempt,
+  removeBookmark,
+} from '../../services/localData';
+import {
+  enterReview as enterReviewAction,
+  exitReview as exitReviewAction,
+  hydrate,
+  navigate as navigateAction,
+  pause as pauseAction,
+  resume as resumeAction,
+  select as selectAction,
+  setBookmarks as setBookmarksAction,
+  submitAll as submitAllAction,
+  submitQuestion as submitQuestionAction,
+  toggleBookmark as toggleBookmarkAction,
+  toggleFlag as toggleFlagAction,
+} from './actions';
+import { clearDraft, draftFromState, readDraft, writeDraft } from './draft';
+import { createInitialState, defaultFeedbackFor, quizReducer } from './reducer';
+import {
+  selectAnsweredCount,
+  selectCurrentQuestion,
+  selectFlaggedCount,
+  selectIsBookmarked,
+  selectIsRevealed,
+  selectIsSubmitted,
+  selectPalette,
+  selectSelection,
+  selectSummary,
+  selectTimeLeftMs,
+  selectUnansweredCount,
+  selectUnansweredIndices,
+  selectVerdict,
+} from './selectors';
+import type {
+  FeedbackMode,
+  PaletteEntry,
+  Question,
+  QuizMode,
+  QuizState,
+  QuizSummary,
+  Verdict,
+} from './types';
+
+export interface UseQuizOptions {
+  mode: QuizMode;
+  /** Defaults to `deferred` for mock tests, `immediate` everywhere else. */
+  feedback?: FeedbackMode;
+  /**
+   * Stable identity for this attempt, e.g. `topic:book-ch1:30`. Used as the
+   * autosave key; changing it abandons the current attempt and starts a new
+   * one. Pass null to run without persistence.
+   */
+  attemptKey: string | null;
+  /** Total time for timed attempts. Null/undefined means untimed. */
+  durationMs?: number | null;
+  /** Builds a fresh paper. Called only when there is no resumable draft. */
+  loadQuestions: () => Promise<Question[]>;
+  /** Rebuilds a saved paper from ids. Defaults to `loadQuestionsByIds`. */
+  resolveQuestions?: (ids: string[]) => Promise<Question[]>;
+  /** Migrates a pre-engine `eng_mock_draft_v1:<testId>` draft on first load. */
+  legacyMockTestId?: string;
+  /** Hold off loading — e.g. while a custom-practice config screen is open. */
+  enabled?: boolean;
+  /** Write answers through to the per-topic progress store. Default true. */
+  persistAttempts?: boolean;
+  autosaveDelayMs?: number;
+  /** Fired once, when the attempt reaches `done`. */
+  onComplete?: (summary: QuizSummary) => void;
+}
+
+export interface QuizCounts {
+  total: number;
+  answered: number;
+  unanswered: number;
+  flagged: number;
+}
+
+export interface UseQuizResult {
+  state: QuizState;
+  /** Set when loading failed; the host renders its own error surface. */
+  error: string | null;
+  current: Question | undefined;
+  /** Current question selection, or null. */
+  selection: number | null;
+  verdict: Verdict;
+  isRevealed: boolean;
+  isSubmitted: boolean;
+  isFlagged: boolean;
+  isBookmarked: boolean;
+  counts: QuizCounts;
+  palette: PaletteEntry[];
+  unansweredIndices: number[];
+  summary: QuizSummary;
+  /** Milliseconds left against the absolute deadline, or null when untimed. */
+  timeLeftMs: number | null;
+  canSubmitCurrent: boolean;
+  isLast: boolean;
+
+  selectOption: (option: number) => void;
+  submitCurrent: () => void;
+  /** Submit one question, or advance if it is already submitted. The Enter key. */
+  submitOrAdvance: () => void;
+  submitAll: () => void;
+  next: () => void;
+  prev: () => void;
+  goTo: (index: number) => void;
+  toggleFlag: (index?: number) => void;
+  toggleBookmark: (index?: number) => void;
+  enterReview: () => void;
+  exitReview: () => void;
+  /**
+   * Throw away the saved draft. Use before navigating away from a dead
+   * attempt. To restart, change `attemptKey` — that is what starts a new
+   * attempt, so a restart is a new identity rather than a mutation.
+   */
+  discardDraft: () => void;
+  /** Re-read bookmarks from storage, e.g. after returning from another page. */
+  syncBookmarks: () => void;
+}
+
+const DEFAULT_AUTOSAVE_DELAY_MS = 500;
+
+export function useQuiz(options: UseQuizOptions): UseQuizResult {
+  const {
+    mode,
+    attemptKey,
+    durationMs = null,
+    legacyMockTestId,
+    enabled = true,
+    persistAttempts = true,
+    autosaveDelayMs = DEFAULT_AUTOSAVE_DELAY_MS,
+  } = options;
+  const feedback = options.feedback ?? defaultFeedbackFor(mode);
+
+  // A fresh loading state whenever the attempt identity changes. Comparing
+  // `attemptKey` lets a stale attempt be discarded by derivation instead of by
+  // a reset dispatched from an effect.
+  const blank = useMemo(
+    () => createInitialState({ mode, feedback, attemptKey }),
+    [mode, feedback, attemptKey]
+  );
+  const [raw, dispatch] = useReducer(quizReducer, blank);
+  const state = raw.attemptKey === attemptKey ? raw : blank;
+
+  const [error, setError] = useState<string | null>(null);
+
+  // Latest-callback refs so an inline `loadQuestions={() => ...}` on the host
+  // does not restart the attempt on every render. Written in an effect, never
+  // during render.
+  const callbacksRef = useRef(options);
+  useEffect(() => {
+    callbacksRef.current = options;
+  });
+
+  // ── Load: resume a draft, else build a fresh paper ────────────────────────
+  useEffect(() => {
+    if (!enabled || attemptKey === null) return;
+    let cancelled = false;
+
+    const start = async () => {
+      const draft = readDraft(attemptKey, { legacyMockTestId });
+
+      if (draft) {
+        const resolve = callbacksRef.current.resolveQuestions ?? defaultResolve;
+        const restored = await resolve(draft.questionIds);
+        if (cancelled) return;
+        // A short read means the chapter data changed under us. Discard rather
+        // than score against a paper we cannot faithfully rebuild.
+        if (restored.length === draft.questionIds.length) {
+          dispatch(
+            hydrate({
+              attemptKey,
+              questions: restored,
+              at: Date.now(),
+              startedAt: draft.startedAt,
+              endsAt: draft.endsAt,
+              bookmarked: getBookmarks(),
+              resumed: true,
+              selections: draft.selections,
+              submitted: draft.submitted,
+              flagged: draft.flagged,
+              accumulatedMs: draft.accumulatedMs,
+              currentIndex: draft.currentIndex,
+            })
+          );
+          return;
+        }
+        clearDraft(attemptKey, { legacyMockTestId });
+      }
+
+      const questions = await callbacksRef.current.loadQuestions();
+      if (cancelled) return;
+      if (questions.length === 0) {
+        setError('No questions available.');
+        return;
+      }
+      const startedAt = Date.now();
+      dispatch(
+        hydrate({
+          attemptKey,
+          questions,
+          at: startedAt,
+          startedAt,
+          endsAt: durationMs === null ? null : startedAt + durationMs,
+          bookmarked: getBookmarks(),
+        })
+      );
+    };
+
+    reportFailure(start(), () => cancelled, setError);
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, attemptKey, durationMs, legacyMockTestId]);
+
+  // ── Timer tick: only for timed attempts, and only while they are running ──
+  const [now, setNow] = useState(() => Date.now());
+  const timed = state.timing.endsAt !== null;
+  const running = state.phase === 'active' || state.phase === 'review';
+
+  useEffect(() => {
+    if (!timed || !running) return;
+    const id = setInterval(() => setNow(Date.now()), 1000);
+    return () => clearInterval(id);
+  }, [timed, running]);
+
+  // ── Auto-submit at the deadline ───────────────────────────────────────────
+  // Scheduled against the absolute deadline rather than watched on the tick, so
+  // it still fires correctly in a throttled background tab. A deadline already
+  // in the past is handled in the reducer at hydrate time.
+  const endsAt = state.timing.endsAt;
+  useEffect(() => {
+    if (endsAt === null || state.phase === 'done' || state.phase === 'loading') return;
+    const id = setTimeout(() => dispatch(submitAllAction(Date.now())), Math.max(0, endsAt - Date.now()));
+    return () => clearTimeout(id);
+  }, [endsAt, state.phase]);
+
+  // ── Pause while the tab is hidden ─────────────────────────────────────────
+  useEffect(() => {
+    const onVisibility = () => {
+      dispatch(document.hidden ? pauseAction(Date.now()) : resumeAction(Date.now()));
+    };
+    document.addEventListener('visibilitychange', onVisibility);
+    return () => document.removeEventListener('visibilitychange', onVisibility);
+  }, []);
+
+  // ── Autosave, debounced ───────────────────────────────────────────────────
+  useEffect(() => {
+    if (attemptKey === null) return;
+    const draft = draftFromState(state, attemptKey, Date.now());
+    if (draft === null) return;
+    const id = setTimeout(() => writeDraft(draft), autosaveDelayMs);
+    return () => clearTimeout(id);
+  }, [state, attemptKey, autosaveDelayMs]);
+
+  // A finished attempt must not be resumable.
+  useEffect(() => {
+    if (attemptKey === null || state.phase !== 'done') return;
+    clearDraft(attemptKey, { legacyMockTestId });
+  }, [state.phase, attemptKey, legacyMockTestId]);
+
+  // ── Write answers through to the progress store ───────────────────────────
+  const flushedRef = useRef<Set<string>>(new Set());
+  useEffect(() => {
+    flushedRef.current = new Set();
+  }, [attemptKey]);
+
+  const keyedIds = useMemo(
+    () => new Set(state.questions.filter((q) => q.correctIndex >= 0).map((q) => q.id)),
+    [state.questions]
+  );
+
+  useEffect(() => {
+    if (!persistAttempts) return;
+    for (const record of state.responses) {
+      // Blanks are not attempts, and a question with no answer key cannot be
+      // graded, so neither belongs in per-topic progress.
+      if (record.chosenIndex === null) continue;
+      if (!keyedIds.has(record.questionId)) continue;
+      if (flushedRef.current.has(record.questionId)) continue;
+      flushedRef.current.add(record.questionId);
+      recordAttempt(record.questionId, record.topicId, record.correct);
+    }
+  }, [state.responses, keyedIds, persistAttempts]);
+
+  // ── onComplete, exactly once ──────────────────────────────────────────────
+  // `undefined` is the not-yet-fired sentinel, so a null attemptKey still fires.
+  const completedRef = useRef<string | null | undefined>(undefined);
+  useEffect(() => {
+    if (state.phase !== 'done') return;
+    if (completedRef.current === attemptKey) return;
+    completedRef.current = attemptKey;
+    callbacksRef.current.onComplete?.(selectSummary(state));
+  }, [state, attemptKey]);
+
+  // ── Derived reads ─────────────────────────────────────────────────────────
+  const index = state.currentIndex;
+  const summary = useMemo(() => selectSummary(state), [state]);
+  const palette = useMemo(() => selectPalette(state), [state]);
+  const unansweredIndices = useMemo(() => selectUnansweredIndices(state), [state]);
+  const current = selectCurrentQuestion(state);
+  const selection = selectSelection(state, index);
+  const isSubmitted = selectIsSubmitted(state, index);
+  const counts: QuizCounts = {
+    total: state.questions.length,
+    answered: selectAnsweredCount(state),
+    unanswered: selectUnansweredCount(state),
+    flagged: selectFlaggedCount(state),
+  };
+
+  // ── Actions ───────────────────────────────────────────────────────────────
+  const selectOption = useCallback(
+    (option: number) => dispatch(selectAction(index, option, Date.now())),
+    [index]
+  );
+
+  const submitCurrent = useCallback(
+    () => dispatch(submitQuestionAction(index, Date.now())),
+    [index]
+  );
+
+  const goTo = useCallback((target: number) => dispatch(navigateAction(target, Date.now())), []);
+  const next = useCallback(() => dispatch(navigateAction(index + 1, Date.now())), [index]);
+  const prev = useCallback(() => dispatch(navigateAction(index - 1, Date.now())), [index]);
+  const submitAll = useCallback(() => dispatch(submitAllAction(Date.now())), []);
+  const enterReview = useCallback(() => dispatch(enterReviewAction(Date.now())), []);
+  const exitReview = useCallback(() => dispatch(exitReviewAction(Date.now())), []);
+
+  const canSubmitCurrent =
+    state.phase === 'active' && selection !== null && !isSubmitted;
+
+  const submitOrAdvance = useCallback(() => {
+    if (canSubmitCurrent) {
+      dispatch(submitQuestionAction(index, Date.now()));
+      return;
+    }
+    if (index < state.questions.length - 1) dispatch(navigateAction(index + 1, Date.now()));
+  }, [canSubmitCurrent, index, state.questions.length]);
+
+  const toggleFlag = useCallback(
+    (target?: number) => dispatch(toggleFlagAction(target ?? index)),
+    [index]
+  );
+
+  const toggleBookmark = useCallback(
+    (target?: number) => {
+      const q = state.questions[target ?? index];
+      if (!q) return;
+      // Storage first, then state: the set in state mirrors storage, and the
+      // old per-index effect that only ever added is how they drifted apart.
+      if (state.bookmarked.has(q.id)) removeBookmark(q.id);
+      else addBookmark(q.id);
+      dispatch(toggleBookmarkAction(q.id));
+    },
+    [index, state.questions, state.bookmarked]
+  );
+
+  const discardDraft = useCallback(() => {
+    if (attemptKey === null) return;
+    clearDraft(attemptKey, { legacyMockTestId });
+  }, [attemptKey, legacyMockTestId]);
+
+  const syncBookmarks = useCallback(() => {
+    dispatch(setBookmarksAction(getBookmarks()));
+  }, []);
+
+  return {
+    state,
+    error,
+    current,
+    selection,
+    verdict: selectVerdict(state, index),
+    isRevealed: selectIsRevealed(state, index),
+    isSubmitted,
+    isFlagged: state.flagged.has(index),
+    isBookmarked: selectIsBookmarked(state, index),
+    counts,
+    palette,
+    unansweredIndices,
+    summary,
+    timeLeftMs: selectTimeLeftMs(state, now),
+    canSubmitCurrent,
+    isLast: index === state.questions.length - 1,
+    selectOption,
+    submitCurrent,
+    submitOrAdvance,
+    submitAll,
+    next,
+    prev,
+    goTo,
+    toggleFlag,
+    toggleBookmark,
+    enterReview,
+    exitReview,
+    discardDraft,
+    syncBookmarks,
+  };
+}
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+/** Lazily imported default so the hook does not force a loader on every host. */
+async function defaultResolve(ids: string[]): Promise<Question[]> {
+  const { loadQuestionsByIds } = await import('../../services/localData');
+  return loadQuestionsByIds(ids);
+}
+
+/**
+ * Attaches the failure path to the load promise.
+ *
+ * `isCancelled` is a getter, not a boolean: the flag flips after this call
+ * returns, so a captured value would always read false and a cancelled load
+ * would still set an error on a torn-down attempt.
+ */
+function reportFailure(
+  promise: Promise<void>,
+  isCancelled: () => boolean,
+  setError: (message: string) => void
+): void {
+  promise.catch(() => {
+    if (!isCancelled()) setError('Failed to load questions. Please try again.');
+  });
+}
diff --git a/frontend/src/features/quiz/useQuizKeyboard.ts b/frontend/src/features/quiz/useQuizKeyboard.ts
new file mode 100644
index 0000000..314aea2
--- /dev/null
+++ b/frontend/src/features/quiz/useQuizKeyboard.ts
@@ -0,0 +1,154 @@
+/**
+ * useQuizKeyboard — keyboard shortcuts for an active quiz.
+ *
+ * The app shipped the quiz as mouse/touch only (three onKeyDown handlers in the
+ * whole codebase), which makes a 100-question mock a hand exercise. Bindings:
+ *
+ *   1-4 / a-d   select that option
+ *   Enter       submit the current question, then advance on the next press
+ *   ArrowLeft   previous question
+ *   ArrowRight  next question
+ *   f           toggle flag-for-review
+ *   b           toggle bookmark
+ *
+ * Deliberately inert when:
+ *  - focus sits in a text field or a contenteditable region (otherwise typing
+ *    "bad" in a search box would flag, select and bookmark a question);
+ *  - a modifier is held, so Cmd-1 / Ctrl-F still belong to the browser;
+ *  - Enter arrives on a button or link, where the native activation already
+ *    does the right thing and ours would double-fire.
+ */
+
+import { useEffect, useRef } from 'react';
+
+export interface QuizKeyboardHandlers {
+  /** Zero-based option index. */
+  onSelectOption: (optionIndex: number) => void;
+  onSubmitOrAdvance: () => void;
+  onPrev: () => void;
+  onNext: () => void;
+  onToggleFlag: () => void;
+  onToggleBookmark: () => void;
+}
+
+export interface UseQuizKeyboardOptions extends QuizKeyboardHandlers {
+  /** Number of options on the current question; out-of-range keys are ignored. */
+  optionCount: number;
+  /** False while loading, on the results screen, or in a modal. Default true. */
+  enabled?: boolean;
+}
+
+const TEXT_INPUT_TYPES = new Set([
+  'text',
+  'search',
+  'email',
+  'url',
+  'tel',
+  'password',
+  'number',
+  'date',
+  'datetime-local',
+  'month',
+  'time',
+  'week',
+]);
+
+/**
+ * True when typing should win over shortcuts.
+ *
+ * Exported because it is the part worth testing directly, and because every
+ * future global shortcut in this app needs the same guard.
+ */
+export function isTextEntryTarget(target: EventTarget | null): boolean {
+  if (!(target instanceof HTMLElement)) return false;
+  if (target.isContentEditable) return true;
+  const tag = target.tagName;
+  if (tag === 'TEXTAREA' || tag === 'SELECT') return true;
+  if (target instanceof HTMLInputElement) {
+    // Checkboxes and radios are not text entry, so shortcuts stay live there.
+    return TEXT_INPUT_TYPES.has(target.type);
+  }
+  return false;
+}
+
+function isNativelyActivated(target: EventTarget | null): boolean {
+  if (!(target instanceof HTMLElement)) return false;
+  const tag = target.tagName;
+  return tag === 'BUTTON' || tag === 'A' || tag === 'SUMMARY';
+}
+
+/** Maps a key to an option index, or -1. Supports digits 1-9 and letters a-i. */
+export function optionIndexForKey(key: string): number {
+  if (key.length !== 1) return -1;
+  const code = key.charCodeAt(0);
+  if (code >= 0x31 && code <= 0x39) return code - 0x31; // "1".."9"
+  const lower = key.toLowerCase().charCodeAt(0);
+  if (lower >= 0x61 && lower <= 0x69) return lower - 0x61; // "a".."i"
+  return -1;
+}
+
+export function useQuizKeyboard(options: UseQuizKeyboardOptions): void {
+  const { optionCount, enabled = true } = options;
+
+  // One listener for the life of the quiz; the latest handlers are read through
+  // a ref so re-binding on every render cannot drop a keystroke.
+  const latest = useRef(options);
+  useEffect(() => {
+    latest.current = options;
+  });
+
+  useEffect(() => {
+    if (!enabled) return;
+
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.defaultPrevented) return;
+      if (event.ctrlKey || event.metaKey || event.altKey) return;
+      if (isTextEntryTarget(event.target)) return;
+
+      const handlers = latest.current;
+
+      switch (event.key) {
+        case 'Enter':
+          if (isNativelyActivated(event.target)) return;
+          event.preventDefault();
+          handlers.onSubmitOrAdvance();
+          return;
+        case 'ArrowLeft':
+          event.preventDefault();
+          handlers.onPrev();
+          return;
+        case 'ArrowRight':
+          event.preventDefault();
+          handlers.onNext();
+          return;
+        default:
+          break;
+      }
+
+      if (event.shiftKey) return;
+
+      if (event.key === 'f' || event.key === 'F') {
+        event.preventDefault();
+        handlers.onToggleFlag();
+        return;
+      }
+      if (event.key === 'b' || event.key === 'B') {
+        event.preventDefault();
+        handlers.onToggleBookmark();
+        return;
+      }
+
+      // Letter shortcuts for options start at "a", so "b" is both bookmark and
+      // option 2. Bookmark wins; option 2 keeps its digit. Checked after the
+      // named keys above for exactly that reason.
+      const optionIndex = optionIndexForKey(event.key);
+      if (optionIndex >= 0 && optionIndex < optionCount) {
+        event.preventDefault();
+        handlers.onSelectOption(optionIndex);
+      }
+    };
+
+    window.addEventListener('keydown', onKeyDown);
+    return () => window.removeEventListener('keydown', onKeyDown);
+  }, [enabled, optionCount]);
+}
diff --git a/frontend/src/hooks/__tests__/useChapters.test.tsx b/frontend/src/hooks/__tests__/useChapters.test.tsx
new file mode 100644
index 0000000..73cc752
--- /dev/null
+++ b/frontend/src/hooks/__tests__/useChapters.test.tsx
@@ -0,0 +1,127 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+
+/**
+ * `useChapters` has to stay synchronous for its ten callers while still
+ * preferring the server's question counts.
+ *
+ * The counts genuinely differ: the generated manifest counts rows in the
+ * chapter JSON, the API counts PUBLISHED questions. Chapter 1 is 525 locally
+ * and 483 from the server, because 42 are withheld for answer-key defects.
+ * Showing 525 beside a practice set that can only serve 483 is a promise the
+ * app cannot keep.
+ */
+
+const mockApi = { getChapters: vi.fn() };
+let backendConfigured = true;
+
+vi.mock('../../services/api', () => ({
+  api: mockApi,
+  isBackendConfigured: () => backendConfigured,
+  apiBaseUrl: () => 'https://api.test',
+  newIdempotencyKey: () => 'k',
+}));
+
+const { useChapters } = await import('../useChapters');
+const { bookChapters } = await import('../../data/bookChapters.generated');
+
+beforeEach(() => {
+  backendConfigured = true;
+  mockApi.getChapters.mockReset();
+});
+
+/** A server chapter row, shaped like ChapterSummary. */
+function serverChapter(id: string, questionCount: number) {
+  return {
+    id,
+    slug: id,
+    name: 'ignored',
+    shortName: 'ignored',
+    description: 'ignored',
+    questionCount,
+    icon: 'book' as const,
+    color: '#000000',
+    orderIndex: 1,
+  };
+}
+
+describe('useChapters', () => {
+  it('returns the generated manifest on the first render, with no await', () => {
+    mockApi.getChapters.mockResolvedValue({ ok: true, data: { chapters: [] } });
+    const { result } = renderHook(() => useChapters());
+    // Synchronous and complete: no loading state reaches the ten callers.
+    expect(result.current).toHaveLength(bookChapters.length);
+    expect(result.current[0].id).toBe('book-ch1');
+  });
+
+  it('adopts the server question count when it arrives', async () => {
+    mockApi.getChapters.mockResolvedValue({
+      ok: true,
+      data: { chapters: [serverChapter('book-ch1', 483)] },
+    });
+
+    const { result } = renderHook(() => useChapters());
+    await waitFor(() => expect(result.current[0].questionCount).toBe(483));
+  });
+
+  it('keeps dataFile and presentation from the manifest, not the server', async () => {
+    mockApi.getChapters.mockResolvedValue({
+      ok: true,
+      data: { chapters: [serverChapter('book-ch1', 483)] },
+    });
+
+    const { result } = renderHook(() => useChapters());
+    await waitFor(() => expect(result.current[0].questionCount).toBe(483));
+
+    // `dataFile` has no server equivalent and every local load path reads it.
+    expect(result.current[0].dataFile).toBe(bookChapters[0].dataFile);
+    // The server's placeholder name must not overwrite the real one.
+    expect(result.current[0].name).toBe(bookChapters[0].name);
+    expect(result.current[0].name).not.toBe('ignored');
+  });
+
+  it('ignores a chapter the client does not know about', async () => {
+    mockApi.getChapters.mockResolvedValue({
+      ok: true,
+      data: { chapters: [serverChapter('book-ch99', 10)] },
+    });
+
+    const { result } = renderHook(() => useChapters());
+    // Appending it would produce a Topic with no dataFile and break every
+    // local load path.
+    await waitFor(() => expect(result.current).toHaveLength(bookChapters.length));
+    expect(result.current.some((c) => c.id === 'book-ch99')).toBe(false);
+  });
+
+  it('keeps the manifest when the request fails', async () => {
+    mockApi.getChapters.mockResolvedValue({
+      ok: false,
+      error: { code: 'NETWORK_UNAVAILABLE', message: 'Could not reach the server.' },
+    });
+
+    const { result } = renderHook(() => useChapters());
+    await waitFor(() => expect(mockApi.getChapters).toHaveBeenCalled());
+    expect(result.current[0].questionCount).toBe(bookChapters[0].questionCount);
+  });
+
+  it('makes no request at all when no backend is configured', () => {
+    backendConfigured = false;
+    const { result } = renderHook(() => useChapters());
+    expect(result.current).toEqual(bookChapters);
+    expect(mockApi.getChapters).not.toHaveBeenCalled();
+  });
+
+  it('keeps array identity when the server agrees, so callers do not re-render', async () => {
+    mockApi.getChapters.mockResolvedValue({
+      ok: true,
+      data: {
+        chapters: bookChapters.map((c) => serverChapter(c.id, c.questionCount)),
+      },
+    });
+
+    const { result } = renderHook(() => useChapters());
+    const first = result.current;
+    await waitFor(() => expect(mockApi.getChapters).toHaveBeenCalled());
+    expect(result.current).toBe(first);
+  });
+});
diff --git a/frontend/src/hooks/useChapters.ts b/frontend/src/hooks/useChapters.ts
index 747330c..24f2540 100644
--- a/frontend/src/hooks/useChapters.ts
+++ b/frontend/src/hooks/useChapters.ts
@@ -1,49 +1,74 @@
-import { useState, useEffect } from 'react';
-import { bookChapters as staticChapters } from '../data/bookChapters.generated';
+import { useEffect, useState } from 'react';
+import { bookChapters } from '../data/bookChapters.generated';
 import type { Topic } from '../data/topics';
-
-let cachedChapters: Topic[] | null = null;
-let fetchPromise: Promise<Topic[]> | null = null;
-
-async function fetchCounts(): Promise<Topic[]> {
-  if (!fetchPromise) {
-    fetchPromise = Promise.all(
-      staticChapters.map(async (c) => {
-        try {
-          const res = await fetch(`/data/${c.dataFile}?t=${Date.now()}`);
-          if (res.ok) {
-            const data = await res.json();
-            return { ...c, questionCount: data.length };
-          }
-        } catch {
-          // Silently fall back to static count
-        }
-        return c;
-      })
-    ).then(updated => {
-      cachedChapters = updated;
-      return updated;
-    });
-  }
-  return fetchPromise;
-}
+import { api, isBackendConfigured } from '../services/api';
 
 /**
- * Returns book chapters with dynamically-fetched question counts.
- * On first call, counts are fetched from the JSON files.
- * Subsequent calls return the cached result immediately (no re-fetch).
+ * The book chapters, with question counts corrected by the API when it answers.
+ *
+ * WHY IT STARTS LOCAL AND REFINES
+ * -------------------------------
+ * Ten callers use this and all of them are synchronous. Making it `Promise`-
+ * shaped would push a loading state into the dashboard, the practice hub,
+ * progress, flashcards, every quiz page and the study hub, for a value that is
+ * already known well enough to render. So the first return is the generated
+ * manifest - instant, offline, correct about everything except one number -
+ * and the API's counts land on a later render.
+ *
+ * It previously re-fetched all ten chapter JSONs at runtime (roughly 1 MB,
+ * cache-busted with `?t=${Date.now()}` so it could never be served from cache)
+ * purely to read `data.length`. The generated manifest replaced that.
+ *
+ * WHY THE API'S COUNT IS DIFFERENT, AND RIGHT
+ * -------------------------------------------
+ * `bookChapters.generated.ts` counts rows in the chapter JSON. The API counts
+ * PUBLISHED questions, which excludes the 118 withheld for answer-key defects
+ * and anything flagged since. Chapter 1 is 525 locally and 483 from the server,
+ * and 483 is the number a candidate can actually be asked. Showing 525 next to
+ * a practice set that can only ever serve 483 is a promise the app cannot keep.
+ *
+ * WHAT IS NOT TAKEN FROM THE API
+ * ------------------------------
+ * Only `questionCount` is adopted. `dataFile` has no server equivalent and is
+ * what `loadQuestionsSlice` reads, so it must survive; name, colour and icon
+ * are presentation that the manifest already owns and that `sync-chapters.mjs`
+ * regenerates. Taking the minimum keeps this from becoming a second, divergent
+ * source of truth for chapter metadata.
+ *
+ * An unrecognised chapter id from the server is ignored rather than appended:
+ * a chapter with no `dataFile` would break every local load path, and a server
+ * that has grown a chapter the client does not know about is a deploy-order
+ * problem to fix, not a shape to render.
  */
 export function useChapters(): Topic[] {
-  const [chapters, setChapters] = useState<Topic[]>(cachedChapters || staticChapters);
+  const [chapters, setChapters] = useState<Topic[]>(bookChapters);
 
   useEffect(() => {
-    let mounted = true;
+    if (!isBackendConfigured()) return;
+    let cancelled = false;
+
+    void (async () => {
+      const result = await api.getChapters();
+      if (cancelled || !result.ok) return;
 
-    fetchCounts().then(updated => {
-      if (mounted) setChapters(updated);
-    });
+      const counts = new Map(result.data.chapters.map((c) => [c.id, c.questionCount]));
+      setChapters((prev) => {
+        let changed = false;
+        const next = prev.map((topic) => {
+          const count = counts.get(topic.id);
+          if (count === undefined || count === topic.questionCount) return topic;
+          changed = true;
+          return { ...topic, questionCount: count };
+        });
+        // Returning `prev` unchanged keeps the array identity stable, so the
+        // ten callers do not re-render for a response that said nothing new.
+        return changed ? next : prev;
+      });
+    })();
 
-    return () => { mounted = false; };
+    return () => {
+      cancelled = true;
+    };
   }, []);
 
   return chapters;
diff --git a/frontend/src/index.css b/frontend/src/index.css
index 11ae5f9..6148d66 100644
--- a/frontend/src/index.css
+++ b/frontend/src/index.css
@@ -1,69 +1,152 @@
-@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap');
+/* ============================================================================
+   NECPrep — global stylesheet entry point (imported by src/main.tsx)
 
+   Load order matters:
+     1. Tailwind theme + utilities (NO preflight — see note below)
+     2. Self-hosted Inter @font-face
+     3. Design tokens (@theme primitives + themed semantic layer)
+     4. Global base layer (focus ring, reduced motion, scrollbars)
+     5. Compatibility aliases that point App.css's legacy variables at the tokens
+   ========================================================================== */
+
+/* ----------------------------------------------------------------------------
+   Tailwind v4.
+
+   Preflight is deliberately NOT imported. `@import "tailwindcss"` would pull in
+   preflight.css, which unsets borders, button appearance, heading sizes and list
+   styles — and App.css (6,175 lines) was written against the browser defaults
+   plus its own reset. Adding preflight now would be a 6,000-line visual
+   regression with no way to review it. The migration phase turns it on once
+   components stop depending on UA defaults.
+
+   Also note: App.css is UNLAYERED and loads after this file, so it currently
+   out-ranks every Tailwind utility regardless of source order. New components
+   should therefore be built as fresh markup rather than by layering utilities on
+   top of existing App.css classes, until App.css is retired.
+   -------------------------------------------------------------------------- */
+@layer theme, base, components, utilities;
+@import 'tailwindcss/theme.css' layer(theme);
+@import 'tailwindcss/utilities.css' layer(utilities);
+
+@import './styles/fonts.css';
+@import './styles/tokens.css';
+@import './styles/base.css';
+
+/* ============================================================================
+   Root / document defaults
+   ========================================================================== */
 :root {
-  font-family: 'Inter', system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
-  line-height: 1.5;
-  font-weight: 400;
-  color-scheme: dark;
-  color: #ffffff;
-  background-color: #0a0a0f;
+  font-family: var(--font-sans);
+  font-size: 100%;
+  line-height: var(--text-base--line-height);
+  font-weight: var(--font-weight-normal);
+  color: var(--color-fg);
+  background-color: var(--color-bg);
   font-synthesis: none;
   text-rendering: optimizeLegibility;
   -webkit-font-smoothing: antialiased;
   -moz-osx-font-smoothing: grayscale;
+  -webkit-tap-highlight-color: transparent;
 }
 
-* {
-  margin: 0;
-  padding: 0;
+*,
+*::before,
+*::after {
   box-sizing: border-box;
 }
 
-a {
-  font-weight: 500;
-  color: #6366f1;
-  text-decoration: inherit;
-}
-
-a:hover {
-  color: #818cf8;
+* {
+  margin: 0;
+  padding: 0;
 }
 
 body {
   margin: 0;
   min-width: 320px;
   min-height: 100vh;
-  background: #0a0a0f;
+  background: var(--color-bg);
+  color: var(--color-fg);
 }
 
 #root {
   min-height: 100vh;
 }
 
-h1 {
-  font-size: 2.5em;
-  line-height: 1.1;
+a {
+  /* --color-accent (brand-500 on dark) is 4.40:1 against the page background and
+     fails WCAG AA for body text. --color-accent-text is the link-grade cut:
+     6.59:1 on dark, 7.57:1 on light. */
+  color: var(--color-accent-text);
+  font-weight: var(--font-weight-medium);
+  text-decoration: inherit;
+}
+
+a:hover {
+  color: var(--color-accent-hover);
 }
 
 button {
   font-family: inherit;
 }
 
-::-webkit-scrollbar {
-  width: 8px;
-  height: 8px;
+h1 {
+  font-size: var(--text-4xl);
+  line-height: var(--text-4xl--line-height);
 }
 
-::-webkit-scrollbar-track {
-  background: rgba(255, 255, 255, 0.05);
-}
+/* ============================================================================
+   LEGACY VARIABLE COMPATIBILITY LAYER
+   ----------------------------------------------------------------------------
+   App.css declares its own `:root { --bg-primary: #0a0a0f; … }` block with 15
+   hard-coded values, and App.css is bundled AFTER this file. Two unlayered
+   `:root` rules have identical specificity, so the later one (App.css) would win
+   and every alias below would be dead code.
 
-::-webkit-scrollbar-thumb {
-  background: rgba(255, 255, 255, 0.1);
-  border-radius: 4px;
-}
+   `:root:root` raises specificity from (0,1,0) to (0,2,0) without `!important`,
+   which beats App.css regardless of bundle order. It is a migration shim: once
+   App.css's `:root` block is deleted, the doubled selector can be collapsed back
+   to `:root`.
 
-::-webkit-scrollbar-thumb:hover {
-  background: rgba(255, 255, 255, 0.2);
-}
+   The effect is that all 6,175 lines of App.css immediately render against the
+   token system — including the accessible foreground colours — with zero
+   component changes.
+   ========================================================================== */
+:root:root {
+  /* Surfaces */
+  --bg-primary: var(--color-bg);
+  --bg-secondary: var(--color-surface);
+  /* App.css used rgba(18,18,26,.8) here, paired with backdrop-filter. Mapping to
+     an opaque surface would flatten every frosted card, so the token layer keeps
+     a translucent variant. */
+  --bg-card: var(--color-surface-translucent);
+  --bg-card-hover: var(--color-surface-translucent-hover);
+
+  /* Foregrounds.
+     --text-secondary was #a1a1aa → 7.71:1 on the old background. Unchanged.
+     --text-muted was #71717a → 4.08:1 on the old background: a WCAG AA failure
+     used 65 times across the app. Both legacy names now resolve to
+     --color-fg-muted (7.66:1 dark / 7.41:1 light), which collapses the old
+     three-step text hierarchy to two. That collapse is the fix: the third step
+     was the inaccessible one. --color-fg-subtle still exists for non-text use. */
+  --text-primary: var(--color-fg);
+  --text-secondary: var(--color-fg-muted);
+  --text-muted: var(--color-fg-muted);
 
+  /* Accents. cyan and green map exactly onto the new status ramp; yellow shifts
+     from #fbbf24 to warning-500 #f59e0b (11.83:1 → 9.15:1, still AAA) to bring
+     it inside the system. violet and pink have no equivalent in the brand ramp
+     and survive only as explicitly-marked legacy values. */
+  --accent-primary: var(--color-accent);
+  --accent-secondary: var(--color-legacy-violet);
+  --accent-cyan: var(--color-info-500);
+  --accent-pink: var(--color-legacy-pink);
+  --accent-green: var(--color-success-500);
+  --accent-yellow: var(--color-warning-500);
+
+  /* Borders */
+  --border-color: var(--color-border);
+
+  /* App.css's only shadow variable. Tailwind's shadow-* utilities read
+     --ds-shadow-* (see tokens.css), so this legacy name is free to alias. */
+  --shadow-lg: var(--ds-shadow-lg);
+}
diff --git a/frontend/src/layout/AppShell.module.css b/frontend/src/layout/AppShell.module.css
new file mode 100644
index 0000000..d42dfbf
--- /dev/null
+++ b/frontend/src/layout/AppShell.module.css
@@ -0,0 +1,99 @@
+/* Accessibility styles for AppShell.
+ *
+ * These live in a CSS Module rather than App.css because App.css is owned by
+ * another workstream, and because the five global `:focus { outline: none }`
+ * rules it ships would otherwise have to be fought with !important.
+ *
+ * Focus ring colour: #ffffff at 3px with a 3px offset. Measured against every
+ * background a shell control sits on:
+ *   #ffffff on --bg-primary  #0a0a0f          = 19.75:1
+ *   #ffffff on --bg-secondary #12121a         = 18.63:1
+ *   #ffffff on --accent-primary #6366f1       =  4.47:1  (active nav link)
+ * All well clear of the 3:1 WCAG 1.4.11 non-text contrast minimum.
+ */
+
+.skipLink {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 1000;
+  display: inline-flex;
+  align-items: center;
+  min-height: 44px;
+  padding: 0.75rem 1.25rem;
+  background: #12121a;
+  color: #ffffff;
+  border: 2px solid #a5b4fc;
+  border-radius: 0 0 10px 0;
+  font-weight: 600;
+  font-size: 0.9375rem;
+  text-decoration: none;
+  transform: translateY(-120%);
+  transition: transform 0.15s ease-out;
+}
+
+/* :focus as well as :focus-visible — a skip link must reveal itself for any
+ * focus origin, including programmatic focus from assistive tech. */
+.skipLink:focus,
+.skipLink:focus-visible {
+  transform: translateY(0);
+  outline: 3px solid #ffffff;
+  outline-offset: 3px;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .skipLink {
+    transition: none;
+  }
+}
+
+/* <main> carries tabindex="-1" so the skip link can move focus into it.
+ * Suppress the ring for that programmatic focus; keep it for real keyboard
+ * focus so the landing point is never invisible. */
+.mainContent:focus {
+  outline: none;
+}
+
+/* Reserve the bottom bar's height on phones.
+ *
+ * `BottomNav` is `position: fixed`, so without this it floats over the end of
+ * the page — which on a quiz is the submit button, and on a results page is
+ * the whole detailed review. The value is the bar's own height (44px target
+ * plus its vertical padding) and the same safe-area inset the bar adds, so the
+ * two stay in step without either hardcoding the other's number.
+ *
+ * The breakpoint matches BottomNav.module.css exactly: padding reserved where
+ * no bar exists would be a dead strip at the foot of every tablet page. */
+@media (max-width: 640px) {
+  .mainContent {
+    padding-bottom: calc(60px + env(safe-area-inset-bottom, 0px));
+  }
+}
+
+.mainContent:focus-visible {
+  outline: 3px solid #ffffff;
+  outline-offset: -3px;
+}
+
+/* One visible focus ring for every interactive descendant of the shell. */
+.shell a:focus-visible,
+.shell button:focus-visible,
+.shell input:focus-visible,
+.shell [tabindex]:focus-visible {
+  outline: 3px solid #ffffff;
+  outline-offset: 3px;
+}
+
+/* WCAG 2.5.8 target size: the icon-only controls were 18px glyphs inside
+ * 0.5rem padding, i.e. roughly 34x34. */
+.iconButton {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 44px;
+  min-height: 44px;
+}
+
+.userMenuTrigger {
+  min-height: 44px;
+}
diff --git a/frontend/src/layout/AppShell.tsx b/frontend/src/layout/AppShell.tsx
index 7a10aa3..e11a3b4 100644
--- a/frontend/src/layout/AppShell.tsx
+++ b/frontend/src/layout/AppShell.tsx
@@ -1,6 +1,27 @@
-import { useState, useRef, useEffect } from 'react';
-import { NavLink, Outlet, useNavigate } from 'react-router-dom';
-import { useUser } from '../context/UserContext';
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { NavLink, Outlet, useNavigate, useLocation } from 'react-router-dom';
+import { useUser } from '../context/user-context';
+import { useAuth } from '../auth/auth-context';
+import BottomNav from './BottomNav';
+import styles from './AppShell.module.css';
+
+// Matches the `@media (max-width: 1024px)` breakpoint in App.css at which the
+// sidebar becomes an off-canvas drawer (`transform: translateX(-100%)`).
+const NARROW_VIEWPORT_QUERY = '(max-width: 1024px)';
+
+const FOCUSABLE_SELECTOR = [
+  'a[href]',
+  'button:not([disabled])',
+  'input:not([disabled])',
+  'select:not([disabled])',
+  'textarea:not([disabled])',
+  '[tabindex]:not([tabindex="-1"])',
+].join(', ');
+
+function focusableWithin(root: HTMLElement | null): HTMLElement[] {
+  if (!root) return [];
+  return Array.from(root.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR));
+}
 
 // Icon components
 const Icons = {
@@ -83,6 +104,16 @@ const Icons = {
       <line x1="12" y1="10" x2="16" y2="10"/>
     </svg>
   ),
+  // A stopwatch: a mock test is the timed one, and the clock is what makes it
+  // different from practice.
+  Mock: () => (
+    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <circle cx="12" cy="13" r="8"/>
+      <path d="M12 9v4l2 2"/>
+      <path d="M5 3 7 5"/>
+      <path d="M19 3l-2 2"/>
+    </svg>
+  ),
   Menu: () => (
     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
       <line x1="3" y1="12" x2="21" y2="12"/>
@@ -96,18 +127,6 @@ const Icons = {
       <line x1="6" y1="6" x2="18" y2="18"/>
     </svg>
   ),
-  Search: () => (
-    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-      <circle cx="11" cy="11" r="8"/>
-      <line x1="21" y1="21" x2="16.65" y2="16.65"/>
-    </svg>
-  ),
-  Bell: () => (
-    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-      <path d="M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9"/>
-      <path d="M13.73 21a2 2 0 0 1-3.46 0"/>
-    </svg>
-  ),
   ChevronDown: () => (
     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
       <polyline points="6 9 12 15 18 9"/>
@@ -119,6 +138,10 @@ const Icons = {
 const navItems = [
   { path: '/app', icon: Icons.Dashboard, label: 'Dashboard', end: true },
   { path: '/app/practice', icon: Icons.Practice, label: 'Practice' },
+  // The flagship: a full 100-question, 120-minute rehearsal of the real
+  // paper. It was absent from this list, reachable only from the dashboard
+  // and the practice hub, which is a strange place to hide the product.
+  { path: '/app/mock-tests', icon: Icons.Mock, label: 'Mock Tests' },
   { path: '/app/books', icon: Icons.Books, label: 'Books' },
   { path: '/app/study', icon: Icons.Study, label: 'Study' },
   { path: '/app/flashcards', icon: Icons.Flashcards, label: 'Flashcards' },
@@ -132,12 +155,81 @@ const secondaryNavItems = [
 ];
 
 export default function AppShell() {
-  const { name } = useUser();
+  const { name, setName } = useUser();
+  // The server is the authority on identity; `useUser` only holds a locally
+  // typed-in name, which is all a build with no backend configured has.
+  const { user, status, logout } = useAuth();
   const navigate = useNavigate();
   const [sidebarCollapsed, setSidebarCollapsed] = useState(false);
   const [mobileMenuOpen, setMobileMenuOpen] = useState(false);
   const [userMenuOpen, setUserMenuOpen] = useState(false);
   const userMenuRef = useRef<HTMLDivElement>(null);
+  const sidebarRef = useRef<HTMLElement>(null);
+  const mainRef = useRef<HTMLElement>(null);
+  const mobileToggleRef = useRef<HTMLButtonElement>(null);
+  const drawerCloseRef = useRef<HTMLButtonElement>(null);
+
+  // The sidebar is translated off-canvas below 1024px but stays in the DOM, so
+  // without this it contributed ~10 invisible tab stops on every mobile page.
+  // Read once during render (no setState in an effect) and then subscribed to.
+  const [isNarrowViewport, setIsNarrowViewport] = useState(
+    () => window.matchMedia(NARROW_VIEWPORT_QUERY).matches,
+  );
+
+  useEffect(() => {
+    const mediaQuery = window.matchMedia(NARROW_VIEWPORT_QUERY);
+    const handleChange = (event: MediaQueryListEvent) => setIsNarrowViewport(event.matches);
+    mediaQuery.addEventListener('change', handleChange);
+    return () => mediaQuery.removeEventListener('change', handleChange);
+  }, []);
+
+  // Closing the drawer must return focus to the control that opened it,
+  // otherwise focus is left on a node that has just gone off-canvas.
+  const closeMobileMenu = useCallback(() => {
+    setMobileMenuOpen(false);
+    mobileToggleRef.current?.focus();
+  }, []);
+
+  // Drawer focus management: move focus in on open, trap Tab inside it while it
+  // is open, and close on Escape. setMobileMenuOpen is only ever called from an
+  // event handler here, never synchronously during the effect body.
+  useEffect(() => {
+    if (!mobileMenuOpen) return;
+
+    drawerCloseRef.current?.focus();
+
+    const handleKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        event.preventDefault();
+        closeMobileMenu();
+        return;
+      }
+      if (event.key !== 'Tab') return;
+
+      const focusable = focusableWithin(sidebarRef.current);
+      if (focusable.length === 0) return;
+
+      const first = focusable[0];
+      const last = focusable[focusable.length - 1];
+      const active = document.activeElement;
+
+      if (!sidebarRef.current?.contains(active)) {
+        event.preventDefault();
+        (event.shiftKey ? last : first).focus();
+        return;
+      }
+      if (event.shiftKey && active === first) {
+        event.preventDefault();
+        last.focus();
+      } else if (!event.shiftKey && active === last) {
+        event.preventDefault();
+        first.focus();
+      }
+    };
+
+    document.addEventListener('keydown', handleKeyDown);
+    return () => document.removeEventListener('keydown', handleKeyDown);
+  }, [mobileMenuOpen, closeMobileMenu]);
 
   // Close user menu when clicking outside
   useEffect(() => {
@@ -150,10 +242,17 @@ export default function AppShell() {
     return () => document.removeEventListener('mousedown', handleClickOutside);
   }, []);
 
-  // Close mobile menu on route change
-  useEffect(() => {
+  // Close both menus on navigation. The previous effect had empty deps despite
+  // a comment claiming it ran on route change, so the mobile drawer stayed open
+  // after every navigation. Adjusting state during render is React's
+  // recommended pattern for responding to a changed value.
+  const { pathname } = useLocation();
+  const [lastPathname, setLastPathname] = useState(pathname);
+  if (lastPathname !== pathname) {
+    setLastPathname(pathname);
     setMobileMenuOpen(false);
-  }, []);
+    setUserMenuOpen(false);
+  }
 
   // Handle keyboard navigation for user menu
   const handleUserMenuKeyDown = (e: React.KeyboardEvent) => {
@@ -163,51 +262,100 @@ export default function AppShell() {
   };
 
   const handleLogout = () => {
-    localStorage.removeItem('userName');
-    navigate('/');
+    // Revoke the SESSION first, then clear the local name.
+    //
+    // This used to do only the second half, which was enough when there was no
+    // backend and a lie once there was: the session is an HttpOnly cookie, so
+    // dropping a local string left a live cookie that the next page load
+    // happily turned back into a signed-in user. `logout()` asks the server to
+    // revoke it.
+    //
+    // Clearing the local name still matters for the same reason it did before:
+    // leaving it set greeted the logged-out visitor by name on the landing
+    // page.
+    void logout().finally(() => {
+      setName('');
+      navigate('/');
+    });
   };
 
-  const displayName = name || 'Guest';
+  // Precedence: what the server knows, then what the visitor typed, then
+  // 'Guest'. An anonymous session has a null `displayName`, so a guest who
+  // typed a name locally still sees it.
+  const displayName = user?.displayName ?? (name || 'Guest');
   const initial = displayName.charAt(0).toUpperCase();
+  // Only true with a backend configured; a local-only build has no concept of
+  // an account to upgrade to.
+  const isGuest = status === 'ready' && user !== null && user.isAnonymous;
+
+  // A real fragment jump would push a hash onto the router history and, in
+  // several browsers, scroll without moving focus. Move focus explicitly;
+  // .focus() scrolls the target into view on its own.
+  const handleSkipToContent = (event: React.MouseEvent<HTMLAnchorElement>) => {
+    event.preventDefault();
+    mainRef.current?.focus();
+  };
+
+  // Following a drawer link closes the drawer. Focus has to leave with it or it
+  // would be stranded on a node that is about to go off-canvas and inert.
+  const handleNavigateFromDrawer = () => {
+    if (!mobileMenuOpen) return;
+    setMobileMenuOpen(false);
+    mainRef.current?.focus();
+  };
 
   return (
-    <div className="app-shell">
+    <div className={`app-shell ${styles.shell}`}>
+      {/* First tab stop on every page in the shell. */}
+      <a href="#main-content" className={styles.skipLink} onClick={handleSkipToContent}>
+        Skip to main content
+      </a>
+
       {/* Mobile overlay */}
       {mobileMenuOpen && (
-        <div 
-          className="app-shell-overlay" 
-          onClick={() => setMobileMenuOpen(false)}
+        <div
+          className="app-shell-overlay"
+          onClick={closeMobileMenu}
           aria-hidden="true"
         />
       )}
 
       {/* Sidebar */}
-      <aside 
+      <aside
+        id="app-sidebar"
+        ref={sidebarRef}
         className={`app-sidebar ${sidebarCollapsed ? 'collapsed' : ''} ${mobileMenuOpen ? 'mobile-open' : ''}`}
         aria-label="Main navigation"
+        // Below 1024px a closed drawer is off-canvas but still in the DOM.
+        // `inert` removes its ten-odd tab stops and hides it from the
+        // accessibility tree until it is actually open.
+        inert={isNarrowViewport && !mobileMenuOpen}
       >
         <div className="sidebar-header">
           <NavLink to="/app" className="sidebar-logo" aria-label="NECPrep Dashboard">
             <Icons.Logo />
             {!sidebarCollapsed && <span>NECPrep</span>}
           </NavLink>
-          <button 
-            className="sidebar-toggle desktop-only"
+          <button
+            className={`sidebar-toggle desktop-only ${styles.iconButton}`}
             onClick={() => setSidebarCollapsed(!sidebarCollapsed)}
             aria-label={sidebarCollapsed ? 'Expand sidebar' : 'Collapse sidebar'}
+            aria-expanded={!sidebarCollapsed}
+            aria-controls="app-sidebar"
           >
             <Icons.Menu />
           </button>
-          <button 
-            className="sidebar-toggle mobile-only"
-            onClick={() => setMobileMenuOpen(false)}
-            aria-label="Close menu"
+          <button
+            ref={drawerCloseRef}
+            className={`sidebar-toggle mobile-only ${styles.iconButton}`}
+            onClick={closeMobileMenu}
+            aria-label="Close navigation menu"
           >
             <Icons.Close />
           </button>
         </div>
 
-        <nav className="sidebar-nav" role="navigation">
+        <nav className="sidebar-nav" aria-label="Sections">
           <ul className="nav-list">
             {navItems.map((item) => (
               <li key={item.path}>
@@ -215,7 +363,8 @@ export default function AppShell() {
                   to={item.path} 
                   end={item.end}
                   className={({ isActive }) => `nav-link ${isActive ? 'active' : ''}`}
-                  onClick={() => setMobileMenuOpen(false)}
+                  aria-label={item.label}
+                  onClick={handleNavigateFromDrawer}
                 >
                   <item.icon />
                   {!sidebarCollapsed && <span>{item.label}</span>}
@@ -232,7 +381,8 @@ export default function AppShell() {
                 <NavLink 
                   to={item.path}
                   className={({ isActive }) => `nav-link ${isActive ? 'active' : ''}`}
-                  onClick={() => setMobileMenuOpen(false)}
+                  aria-label={item.label}
+                  onClick={handleNavigateFromDrawer}
                 >
                   <item.icon />
                   {!sidebarCollapsed && <span>{item.label}</span>}
@@ -246,6 +396,7 @@ export default function AppShell() {
           <button
             className="nav-link logout-btn"
             onClick={handleLogout}
+            aria-label="Leave"
           >
             <Icons.Logout />
             {!sidebarCollapsed && <span>Leave</span>}
@@ -258,41 +409,36 @@ export default function AppShell() {
         {/* Top bar */}
         <header className="app-topbar">
           <div className="topbar-left">
-            <button 
-              className="mobile-menu-btn mobile-only"
+            <button
+              ref={mobileToggleRef}
+              className={`mobile-menu-btn mobile-only ${styles.iconButton}`}
               onClick={() => setMobileMenuOpen(true)}
-              aria-label="Open menu"
+              aria-label="Open navigation menu"
+              aria-expanded={mobileMenuOpen}
+              aria-controls="app-sidebar"
             >
               <Icons.Menu />
             </button>
-            
-            <div className="search-container">
-              <Icons.Search />
-              <input 
-                type="search" 
-                placeholder="Search topics, questions..." 
-                className="search-input"
-                aria-label="Search"
-              />
-            </div>
+            {/* The search input and notifications bell that used to live here
+                were wired to nothing: two focusable dead ends with no index to
+                search and no notification source to read. Removed rather than
+                faked. */}
           </div>
 
           <div className="topbar-right">
-            <button className="topbar-btn" aria-label="Notifications">
-              <Icons.Bell />
-            </button>
-
             {/* User menu */}
-            <div 
-              className="user-menu-container" 
+            <div
+              className="user-menu-container"
               ref={userMenuRef}
               onKeyDown={handleUserMenuKeyDown}
             >
               <button
-                className="user-menu-trigger"
+                className={`user-menu-trigger ${styles.userMenuTrigger}`}
                 onClick={() => setUserMenuOpen(!userMenuOpen)}
                 aria-expanded={userMenuOpen}
                 aria-haspopup="true"
+                aria-controls="user-menu"
+                aria-label={`Account menu for ${displayName}`}
               >
                 <div className="user-avatar-placeholder">{initial}</div>
                 <span className="user-name desktop-only">
@@ -302,18 +448,36 @@ export default function AppShell() {
               </button>
 
               {userMenuOpen && (
-                <div className="user-menu" role="menu">
+                <div className="user-menu" role="menu" id="user-menu">
                   <div className="user-menu-header">
                     <div className="user-menu-avatar-placeholder">
                       {initial}
                     </div>
                     <div className="user-menu-info">
                       <span className="user-menu-name">{displayName}</span>
+                      {user?.email && (
+                        <span className="user-menu-email">{user.email}</span>
+                      )}
                     </div>
                   </div>
                   
                   <div className="user-menu-divider" />
-                  
+
+                  {/* A guest's work is already being recorded server-side
+                      against an identity that survives an upgrade, so this is
+                      an invitation rather than a warning. */}
+                  {isGuest && (
+                    <NavLink
+                      to="/signup"
+                      className="user-menu-item"
+                      role="menuitem"
+                      onClick={() => setUserMenuOpen(false)}
+                    >
+                      <Icons.Profile />
+                      <span>Create an account to save your progress</span>
+                    </NavLink>
+                  )}
+
                   <NavLink 
                     to="/app/profile" 
                     className="user-menu-item"
@@ -342,7 +506,7 @@ export default function AppShell() {
                     onClick={handleLogout}
                   >
                     <Icons.Logout />
-                    <span>Leave</span>
+                    <span>{user ? 'Sign out' : 'Leave'}</span>
                   </button>
                 </div>
               )}
@@ -351,9 +515,22 @@ export default function AppShell() {
         </header>
 
         {/* Page content */}
-        <main className="app-content">
+        <main
+          id="main-content"
+          ref={mainRef}
+          tabIndex={-1}
+          className={`app-content ${styles.mainContent}`}
+        >
           <Outlet />
         </main>
+
+        {/* Phones only; see BottomNav.module.css. `<main>` carries matching
+            bottom padding so a fixed bar cannot cover the last question of a
+            paper or the submit button under it. */}
+        <BottomNav
+          onOpenMore={() => setMobileMenuOpen(true)}
+          moreOpen={mobileMenuOpen}
+        />
       </div>
     </div>
   );
diff --git a/frontend/src/layout/BottomNav.module.css b/frontend/src/layout/BottomNav.module.css
new file mode 100644
index 0000000..755e817
--- /dev/null
+++ b/frontend/src/layout/BottomNav.module.css
@@ -0,0 +1,106 @@
+/* Bottom navigation — phones only.
+ *
+ * Hidden at 641px and up, where the sidebar is either visible or one tap away
+ * in the drawer. 640px is the same boundary App.css already uses for its
+ * narrowest layout changes, so there is one phone breakpoint rather than two
+ * that disagree. */
+
+.bar {
+  display: none;
+}
+
+@media (max-width: 640px) {
+  .bar {
+    display: block;
+    position: fixed;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    /* Above page content, below the drawer overlay and any modal. */
+    z-index: 40;
+    border-top: 1px solid var(--color-border);
+    background: var(--color-surface);
+    /* Keeps the labels clear of an iPhone's home indicator. Zero on anything
+       without an inset, so no magic numbers. */
+    padding-bottom: env(safe-area-inset-bottom, 0);
+  }
+}
+
+.list {
+  display: flex;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.item {
+  flex: 1 1 0;
+  /* Zero min-width or a long label stretches its own cell and the five stop
+     being equal thumb targets. */
+  min-width: 0;
+}
+
+.link {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 2px;
+  width: 100%;
+  /* 44px is the floor for a reliable thumb target; the padding takes the real
+     height above it. */
+  min-height: 44px;
+  padding: var(--spacing-2) var(--spacing-1);
+  border: none;
+  background: none;
+  color: var(--color-fg-muted);
+  font-family: inherit;
+  text-decoration: none;
+  cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.link:focus-visible {
+  outline: 2px solid var(--color-ring);
+  outline-offset: -2px;
+  border-radius: var(--radius-sm);
+}
+
+.active {
+  color: var(--color-accent);
+}
+
+/* A second, non-colour signal for the current section: colour alone fails
+   WCAG 1.4.1 and is invisible to a lot of people. */
+.active .icon::after {
+  content: '';
+  position: absolute;
+  top: -6px;
+  left: 50%;
+  width: 16px;
+  height: 2px;
+  background: currentColor;
+  border-radius: var(--radius-full);
+  transform: translateX(-50%);
+}
+
+.icon {
+  position: relative;
+  display: grid;
+  place-items: center;
+}
+
+.icon svg {
+  width: 22px;
+  height: 22px;
+}
+
+.label {
+  max-width: 100%;
+  overflow: hidden;
+  font-size: var(--text-xs);
+  font-weight: 550;
+  line-height: 1.2;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
diff --git a/frontend/src/layout/BottomNav.tsx b/frontend/src/layout/BottomNav.tsx
new file mode 100644
index 0000000..e6f279d
--- /dev/null
+++ b/frontend/src/layout/BottomNav.tsx
@@ -0,0 +1,149 @@
+/**
+ * Bottom navigation, phones only.
+ *
+ * WHY
+ * ---
+ * Licence-exam preparation is something people do on a phone, in gaps — on a
+ * bus, between lectures. Until now the only navigation below 1024px was a
+ * hamburger that opens an off-canvas drawer, so every move between Practice,
+ * Mock Tests and Progress cost two taps and hid the page behind an overlay.
+ * A bottom bar makes the four journeys that matter one thumb-reach away.
+ *
+ * It complements the drawer rather than replacing it: the drawer still holds
+ * the full list, and "More" opens it.
+ *
+ * WHY THESE FOUR
+ * --------------
+ * The sidebar carries eight destinations. A bottom bar with eight items has
+ * 40px targets and is unusable, so this is the shortest list that covers what
+ * a candidate actually came to do, plus a door to the rest.
+ *
+ * Mock Tests earns a slot because it is the product: a full 100-question,
+ * 120-minute rehearsal of the real paper. It was reachable only from the
+ * dashboard and the practice hub, and was missing from the sidebar entirely.
+ *
+ * Books, Study, Flashcards and Bookmarks live behind More. They are browsing,
+ * not the main loop.
+ *
+ * TOUCH AND SAFE AREAS
+ * --------------------
+ * Targets are at least 44px tall before padding, and the bar adds
+ * `env(safe-area-inset-bottom)` so the last row of labels is not under an
+ * iPhone's home indicator. `AppShell` reserves matching space at the bottom of
+ * `<main>`, so a bar that floats over content cannot hide the last question of
+ * a paper.
+ *
+ * DURING A TIMED PAPER
+ * --------------------
+ * The bar stays. A stray tap out of a mock test is survivable by design: the
+ * attempt autosaves, the deadline is an absolute wall-clock instant rather
+ * than a countdown that pauses, and returning restores both. Hiding navigation
+ * to protect an exam would trap someone who genuinely needs to leave.
+ */
+
+import { NavLink } from 'react-router-dom';
+import styles from './BottomNav.module.css';
+
+interface BottomNavProps {
+  /** Opens the drawer that holds everything not on the bar. */
+  onOpenMore: () => void;
+  /** Mirrors the drawer's state so "More" reads correctly to a screen reader. */
+  moreOpen: boolean;
+}
+
+/**
+ * Inline SVGs, matching `AppShell`'s own icon set. A sprite or an icon package
+ * would be a second asset to load for five glyphs on the critical path.
+ */
+const Icons = {
+  Dashboard: () => (
+    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+      <rect x="3" y="3" width="7" height="7" />
+      <rect x="14" y="3" width="7" height="7" />
+      <rect x="14" y="14" width="7" height="7" />
+      <rect x="3" y="14" width="7" height="7" />
+    </svg>
+  ),
+  Practice: () => (
+    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+      <path d="M12 20h9" />
+      <path d="M16.5 3.5a2.12 2.12 0 0 1 3 3L7 19l-4 1 1-4Z" />
+    </svg>
+  ),
+  Mock: () => (
+    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+      <circle cx="12" cy="13" r="8" />
+      <path d="M12 9v4l2 2" />
+      <path d="M5 3 7 5" />
+      <path d="M19 3l-2 2" />
+    </svg>
+  ),
+  Progress: () => (
+    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+      <path d="M3 3v18h18" />
+      <path d="m19 9-5 5-4-4-3 3" />
+    </svg>
+  ),
+  More: () => (
+    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+      <line x1="3" y1="12" x2="21" y2="12" />
+      <line x1="3" y1="6" x2="21" y2="6" />
+      <line x1="3" y1="18" x2="21" y2="18" />
+    </svg>
+  ),
+};
+
+const items = [
+  { path: '/app', label: 'Home', icon: Icons.Dashboard, end: true },
+  { path: '/app/practice', label: 'Practice', icon: Icons.Practice, end: false },
+  { path: '/app/mock-tests', label: 'Mocks', icon: Icons.Mock, end: false },
+  { path: '/app/progress', label: 'Progress', icon: Icons.Progress, end: false },
+];
+
+export default function BottomNav({ onOpenMore, moreOpen }: BottomNavProps) {
+  return (
+    // `aria-label` rather than a heading: there are two navigation landmarks in
+    // the shell and a screen reader's landmark list has to tell them apart.
+    <nav className={styles.bar} aria-label="Main sections">
+      <ul className={styles.list}>
+        {items.map(({ path, label, icon: Icon, end }) => (
+          <li key={path} className={styles.item}>
+            <NavLink
+              to={path}
+              end={end}
+              className={({ isActive }) =>
+                `${styles.link} ${isActive ? styles.active : ''}`
+              }
+            >
+              {({ isActive }) => (
+                <>
+                  <span className={styles.icon}>
+                    <Icon />
+                  </span>
+                  <span className={styles.label}>{label}</span>
+                  {/* `aria-current` is what actually announces the current
+                      page; the colour change alone says nothing. */}
+                  {isActive && <span className="sr-only" aria-current="page" />}
+                </>
+              )}
+            </NavLink>
+          </li>
+        ))}
+        <li className={styles.item}>
+          <button
+            type="button"
+            className={styles.link}
+            onClick={onOpenMore}
+            aria-expanded={moreOpen}
+            aria-controls="app-sidebar"
+          >
+            <span className={styles.icon}>
+              <Icons.More />
+            </span>
+            <span className={styles.label}>More</span>
+          </button>
+        </li>
+      </ul>
+    </nav>
+  );
+}
diff --git a/frontend/src/layout/__tests__/AppShell.test.tsx b/frontend/src/layout/__tests__/AppShell.test.tsx
new file mode 100644
index 0000000..7e25457
--- /dev/null
+++ b/frontend/src/layout/__tests__/AppShell.test.tsx
@@ -0,0 +1,193 @@
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import AppShell from '../AppShell';
+import { AuthProvider } from '../../auth/AuthContext';
+
+/**
+ * Keyboard-path regressions for the app shell:
+ *  - there was no skip link, so every page opened with ~10 sidebar tab stops
+ *    before any content;
+ *  - the mobile drawer toggle carried no aria-expanded/aria-controls, moved no
+ *    focus when it opened, ignored Escape and restored nothing on close;
+ *  - below 1024px the closed drawer is translated off-canvas but stayed in the
+ *    tab sequence.
+ */
+
+/** Deterministic matchMedia so the narrow/wide branch is not jsdom-dependent. */
+function stubViewport(narrow: boolean) {
+  vi.stubGlobal('matchMedia', (query: string) => ({
+    matches: narrow,
+    media: query,
+    onchange: null,
+    addEventListener: () => {},
+    removeEventListener: () => {},
+    addListener: () => {},
+    removeListener: () => {},
+    dispatchEvent: () => false,
+  }));
+}
+
+// The shell reads the session to decide what the account menu says and what
+// signing out actually does, so it needs the provider. `VITE_API_BASE_URL` is
+// unset under test, so `AuthProvider` resolves to status 'disabled'
+// synchronously and issues no requests -- these tests stay about layout and
+// focus, which is what they are for.
+function renderShell() {
+  return render(
+    <MemoryRouter initialEntries={['/app']}>
+      <AuthProvider>
+        <Routes>
+          <Route path="/app" element={<AppShell />}>
+            <Route index element={<h1>Dashboard</h1>} />
+            <Route path="practice" element={<h1>Practice</h1>} />
+          </Route>
+        </Routes>
+      </AuthProvider>
+    </MemoryRouter>
+  );
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe('AppShell skip link', () => {
+  it('is the first tab stop and moves focus into <main>', async () => {
+    stubViewport(false);
+    const user = userEvent.setup();
+    renderShell();
+
+    await user.tab();
+
+    const skipLink = screen.getByRole('link', { name: 'Skip to main content' });
+    expect(skipLink).toHaveFocus();
+    expect(skipLink).toHaveAttribute('href', '#main-content');
+
+    await user.keyboard('{Enter}');
+
+    const main = screen.getByRole('main');
+    expect(main).toHaveFocus();
+    expect(main).toHaveAttribute('id', 'main-content');
+    // tabindex="-1" makes it focusable without adding a tab stop of its own.
+    expect(main).toHaveAttribute('tabindex', '-1');
+  });
+});
+
+describe('AppShell mobile drawer', () => {
+  it('announces its state through the toggle', async () => {
+    stubViewport(true);
+    const user = userEvent.setup();
+    renderShell();
+
+    const toggle = screen.getByRole('button', { name: 'Open navigation menu' });
+    expect(toggle).toHaveAttribute('aria-controls', 'app-sidebar');
+    expect(toggle).toHaveAttribute('aria-expanded', 'false');
+
+    await user.click(toggle);
+    expect(toggle).toHaveAttribute('aria-expanded', 'true');
+  });
+
+  it('keeps the closed off-canvas drawer out of the tab sequence on narrow viewports', () => {
+    stubViewport(true);
+    renderShell();
+
+    const sidebar = screen.getByRole('complementary', { name: 'Main navigation' });
+    expect(sidebar).toHaveAttribute('id', 'app-sidebar');
+    expect(sidebar).toHaveAttribute('inert');
+  });
+
+  it('leaves the drawer reachable on wide viewports', () => {
+    stubViewport(false);
+    renderShell();
+
+    expect(screen.getByRole('complementary', { name: 'Main navigation' }))
+      .not.toHaveAttribute('inert');
+  });
+
+  it('moves focus into the drawer when it opens', async () => {
+    stubViewport(true);
+    const user = userEvent.setup();
+    renderShell();
+
+    await user.click(screen.getByRole('button', { name: 'Open navigation menu' }));
+
+    expect(screen.getByRole('button', { name: 'Close navigation menu' })).toHaveFocus();
+    expect(screen.getByRole('complementary', { name: 'Main navigation' }))
+      .not.toHaveAttribute('inert');
+  });
+
+  it('closes on Escape and restores focus to the toggle', async () => {
+    stubViewport(true);
+    const user = userEvent.setup();
+    renderShell();
+
+    const toggle = screen.getByRole('button', { name: 'Open navigation menu' });
+    await user.click(toggle);
+    expect(toggle).toHaveAttribute('aria-expanded', 'true');
+
+    await user.keyboard('{Escape}');
+
+    expect(toggle).toHaveAttribute('aria-expanded', 'false');
+    expect(toggle).toHaveFocus();
+  });
+
+  it('restores focus to the toggle when the close button is used', async () => {
+    stubViewport(true);
+    const user = userEvent.setup();
+    renderShell();
+
+    const toggle = screen.getByRole('button', { name: 'Open navigation menu' });
+    await user.click(toggle);
+    await user.click(screen.getByRole('button', { name: 'Close navigation menu' }));
+
+    expect(toggle).toHaveAttribute('aria-expanded', 'false');
+    expect(toggle).toHaveFocus();
+  });
+
+  it('traps Tab inside the open drawer', async () => {
+    stubViewport(true);
+    const user = userEvent.setup();
+    renderShell();
+
+    await user.click(screen.getByRole('button', { name: 'Open navigation menu' }));
+
+    const sidebar = screen.getByRole('complementary', { name: 'Main navigation' });
+    const firstStop = within(sidebar).getByRole('link', { name: 'NECPrep Dashboard' });
+    const lastStop = within(sidebar).getByRole('button', { name: 'Leave' });
+
+    lastStop.focus();
+    await user.tab();
+    expect(firstStop).toHaveFocus();
+
+    await user.tab({ shift: true });
+    expect(lastStop).toHaveFocus();
+  });
+});
+
+describe('AppShell dead controls', () => {
+  it('ships no search box and no notifications bell', () => {
+    stubViewport(false);
+    renderShell();
+
+    expect(screen.queryByRole('searchbox')).not.toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: /notification/i })).not.toBeInTheDocument();
+  });
+});
+
+describe('AppShell icon-only controls', () => {
+  it('gives every control in the shell an accessible name', () => {
+    stubViewport(false);
+    renderShell();
+
+    const controls = [
+      ...screen.getAllByRole('button'),
+      ...screen.getAllByRole('link'),
+    ];
+    const unnamed = controls.filter(
+      (el) => (el.getAttribute('aria-label') ?? el.textContent ?? '').trim() === ''
+    );
+    expect(unnamed).toHaveLength(0);
+  });
+});
diff --git a/frontend/src/layout/__tests__/BottomNav.test.tsx b/frontend/src/layout/__tests__/BottomNav.test.tsx
new file mode 100644
index 0000000..cf72b26
--- /dev/null
+++ b/frontend/src/layout/__tests__/BottomNav.test.tsx
@@ -0,0 +1,104 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import BottomNav from '../BottomNav';
+
+/**
+ * The bottom bar is the only navigation a phone user gets without opening a
+ * drawer, so the things asserted here are the ones that make it usable rather
+ * than merely present: that the current section is announced and not only
+ * coloured, that "More" is a button wired to the drawer rather than a dead
+ * link, and that Mock Tests is actually on it.
+ *
+ * Visibility is a media query and is therefore NOT tested here — jsdom has no
+ * layout. `BottomNav.module.css` and `AppShell.module.css` share the 640px
+ * boundary deliberately; a test that stubbed `matchMedia` would assert the
+ * stub, not the CSS.
+ */
+
+function renderNav(path = '/app', onOpenMore = vi.fn(), moreOpen = false) {
+  const result = render(
+    <MemoryRouter initialEntries={[path]}>
+      <BottomNav onOpenMore={onOpenMore} moreOpen={moreOpen} />
+      <Routes>
+        <Route path="/app" element={<h1>Home page</h1>} />
+        <Route path="/app/practice" element={<h1>Practice page</h1>} />
+        <Route path="/app/mock-tests" element={<h1>Mock tests page</h1>} />
+        <Route path="/app/progress" element={<h1>Progress page</h1>} />
+      </Routes>
+    </MemoryRouter>,
+  );
+  return { ...result, onOpenMore };
+}
+
+describe('BottomNav', () => {
+  it('is a labelled landmark, because the shell has two navs', () => {
+    renderNav();
+    expect(screen.getByRole('navigation', { name: /main sections/i })).toBeInTheDocument();
+  });
+
+  it('puts the mock test on the bar', () => {
+    renderNav();
+    // The product is the full 120-minute paper. It was missing from the
+    // sidebar entirely and reachable only from two pages.
+    expect(screen.getByRole('link', { name: /mocks/i })).toHaveAttribute(
+      'href',
+      '/app/mock-tests',
+    );
+  });
+
+  it('keeps the bar to five targets', () => {
+    renderNav();
+    const links = screen.getAllByRole('link');
+    const buttons = screen.getAllByRole('button');
+    // Eight destinations at phone width would mean ~40px targets. Four plus a
+    // door to the rest is the trade.
+    expect(links.length + buttons.length).toBe(5);
+  });
+
+  it('announces the current section rather than only colouring it', () => {
+    renderNav('/app/practice');
+    // Colour alone fails WCAG 1.4.1 and says nothing to a screen reader.
+    const current = screen.getAllByRole('link').find((el) => el.querySelector('[aria-current="page"]'));
+    expect(current).toBeDefined();
+    expect(current).toHaveAttribute('href', '/app/practice');
+  });
+
+  it('does not mark Home current on a deeper route', () => {
+    // `end` on the index link; without it '/app' matches every child path and
+    // two items look current at once.
+    renderNav('/app/progress');
+    const home = screen.getByRole('link', { name: /home/i });
+    expect(home.querySelector('[aria-current="page"]')).toBeNull();
+  });
+
+  it('navigates on tap', async () => {
+    const user = userEvent.setup();
+    renderNav('/app');
+    await user.click(screen.getByRole('link', { name: /mocks/i }));
+    await waitFor(() => expect(screen.getByText('Mock tests page')).toBeInTheDocument());
+  });
+
+  it('opens the drawer from More, and says so', async () => {
+    const user = userEvent.setup();
+    const { onOpenMore } = renderNav('/app');
+
+    const more = screen.getByRole('button', { name: /more/i });
+    // A button, not a link: it opens a drawer rather than navigating, and it
+    // has to report its state and what it controls.
+    expect(more).toHaveAttribute('aria-expanded', 'false');
+    expect(more).toHaveAttribute('aria-controls', 'app-sidebar');
+
+    await user.click(more);
+    expect(onOpenMore).toHaveBeenCalledTimes(1);
+  });
+
+  it('reflects the drawer being open', () => {
+    renderNav('/app', vi.fn(), true);
+    expect(screen.getByRole('button', { name: /more/i })).toHaveAttribute(
+      'aria-expanded',
+      'true',
+    );
+  });
+});
diff --git a/frontend/src/pages/Landing.module.css b/frontend/src/pages/Landing.module.css
new file mode 100644
index 0000000..fab9a5f
--- /dev/null
+++ b/frontend/src/pages/Landing.module.css
@@ -0,0 +1,75 @@
+/* Accessibility styles for the landing page. CSS Module because App.css is
+ * owned by another workstream.
+ *
+ * Focus ring: #ffffff, 3px, 3px offset.
+ *   #ffffff on the page background #0a0a0f  = 19.75:1
+ *   #ffffff on the dialog card    ~#101018  = 18.93:1
+ *   #ffffff on --accent-primary   #6366f1   =  4.47:1  (primary buttons)
+ * All above the 3:1 WCAG 1.4.11 minimum. Outline rather than box-shadow
+ * because framer-motion writes boxShadow as an inline style on these
+ * buttons, which would beat any stylesheet rule.
+ */
+
+/* Hero accent word.
+ *
+ * The shipped `.gradient-text` ramp is
+ *   linear-gradient(135deg, #6366f1, #06b6d4, #ec4899)
+ * sampled at 5% steps against #0a0a0f its darkest point is the #6366f1 start
+ * at 4.42:1 — under the 4.5:1 AA floor for normal text.
+ *
+ * This ramp is two stops over a single short word, sampled the same way:
+ *   #818cf8 (0%)   =  6.62:1   <- darkest point of the whole span
+ *   #a5b4fc (100%) =  9.91:1
+ * so no pixel of the accent drops below 6.62:1 — AA and AAA for both normal
+ * and large text.
+ */
+.heroAccent {
+  background: linear-gradient(135deg, #818cf8, #a5b4fc);
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  /* Paint colour for engines without background-clip: text; #a5b4fc = 9.91:1 */
+  color: #a5b4fc;
+}
+
+/* background-clip: text is unreliable in forced-colours mode and a
+ * transparent text fill renders as nothing at all there. */
+@media (forced-colors: active) {
+  .heroAccent {
+    background: none;
+    -webkit-text-fill-color: currentColor;
+    color: CanvasText;
+  }
+}
+
+.page a:focus-visible,
+.page button:focus-visible,
+.page input:focus-visible,
+.page [tabindex]:focus-visible {
+  outline: 3px solid #ffffff;
+  outline-offset: 3px;
+}
+
+/* The `.name-portal-input:focus` rule in App.css draws a 2px
+ * rgba(99,102,241,0.5) ring — roughly 1.6:1 on the card. Replace it. */
+.dialogInput:focus-visible {
+  outline: 3px solid #ffffff;
+  outline-offset: 3px;
+  border-color: #a5b4fc;
+}
+
+/* WCAG 2.5.8 target size for the icon-only close control. */
+.dialogClose {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 44px;
+  min-height: 44px;
+}
+
+/* The dialog heading moved from <h3> to <h2> to close the h1 -> h3 jump;
+ * App.css only styles `.name-portal-header h3`, so carry the type over. */
+.dialogTitle {
+  font-size: 1.5rem;
+  margin-bottom: 0.35rem;
+}
diff --git a/frontend/src/pages/Landing.tsx b/frontend/src/pages/Landing.tsx
index 1086e9a..d096db7 100644
--- a/frontend/src/pages/Landing.tsx
+++ b/frontend/src/pages/Landing.tsx
@@ -1,9 +1,26 @@
-import { useState, type KeyboardEvent } from 'react';
-import { useNavigate } from 'react-router-dom';
+import { Link, useNavigate } from 'react-router-dom';
 import { motion } from 'framer-motion';
 import { ArrowRight, BookOpen, Trophy, Users } from 'lucide-react';
-import ThreeBackground from '../components/ThreeBackground';
-import { useUser } from '../context/UserContext';
+import { bookChapters } from '../data/bookChapters.generated';
+import styles from './Landing.module.css';
+
+// Live content figures, derived from the generated chapter manifest so the
+// landing page can never drift from what is actually shipped.
+const LIVE_QUESTIONS = bookChapters.reduce((sum, c) => sum + c.questionCount, 0);
+const LIVE_CHAPTERS = bookChapters.length;
+const SYLLABUS_SUBCHAPTERS = 60; // NEC ACtE: 10 chapters x 6 sub-chapters
+
+// TODO(platform-rebuild): a shared <Dialog> primitive is being built under
+// src/components/ui/. When it lands, replace the local focus trap, Escape
+// handler, scroll lock and focus restoration below with it, and delete this
+// selector list along with `focusableWithin`.
+
+function scrollToFeatures() {
+  const el = document.getElementById('features');
+  if (!el) return;
+  const reduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+  el.scrollIntoView({ behavior: reduced ? 'auto' : 'smooth', block: 'start' });
+}
 
 // Inline brand icon — matches the favicon book+checkmark design
 function NECPrepIcon({ small }: { small?: boolean }) {
@@ -24,10 +41,6 @@ function NECPrepIcon({ small }: { small?: boolean }) {
 
 export default function Landing() {
   const navigate = useNavigate();
-  const { setName } = useUser();
-  const [isNamePortalOpen, setIsNamePortalOpen] = useState(false);
-  const [nameInput, setNameInput] = useState('');
-  const [portalError, setPortalError] = useState('');
 
   const features = [
     {
@@ -47,8 +60,8 @@ export default function Landing() {
     },
     {
       icon: <Users className="w-8 h-8" />,
-      title: 'Community Support',
-      description: 'Join thousands of engineers preparing for their license exam.'
+      title: 'Open Source',
+      description: 'Free, MIT-licensed, and improved by the engineers who use it.'
     }
   ];
 
@@ -73,40 +86,9 @@ export default function Landing() {
     }
   };
 
-  const openNamePortal = () => {
-    setIsNamePortalOpen(true);
-    setPortalError('');
-  };
-
-  const closeNamePortal = () => {
-    setIsNamePortalOpen(false);
-    setPortalError('');
-  };
-
-  const handleNamePortalSubmit = () => {
-    const trimmed = nameInput.trim();
-    if (!trimmed) {
-      setPortalError('Please enter your name so we can guide you.');
-      return;
-    }
-
-    setName(trimmed);
-    closeNamePortal();
-    setNameInput('');
-    navigate('/app');
-  };
-
-  const handlePortalKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
-    if (event.key === 'Enter') {
-      event.preventDefault();
-      handleNamePortalSubmit();
-    }
-  };
 
   return (
-    <div className="landing-page">
-      <ThreeBackground />
-      
+    <div className={`landing-page ${styles.page}`}>
       {/* Navigation */}
       <nav className="nav-container">
         <div className="nav-content">
@@ -119,18 +101,14 @@ export default function Landing() {
             <NECPrepIcon />
             <span className="logo-text">NECPrep</span>
           </motion.div>
-          
-          <motion.button
-            className="btn-signin"
-            initial={{ opacity: 0, x: 20 }}
-            animate={{ opacity: 1, x: 0 }}
-            transition={{ duration: 0.5 }}
-            onClick={() => navigate('/auth/login')}
-            whileHover={{ scale: 1.05 }}
-            whileTap={{ scale: 0.95 }}
-          >
-            Sign In
-          </motion.button>
+
+          {/* The login page existed at /signin and nothing linked to it, so
+              the only way to reach it was to type the URL. */}
+          <div className="nav-actions">
+            <Link to="/signin" className="nav-signin">
+              Sign in
+            </Link>
+          </div>
         </div>
       </nav>
 
@@ -157,9 +135,13 @@ export default function Landing() {
             animate={{ opacity: 1, y: 0 }}
             transition={{ duration: 0.6, delay: 0.5 }}
           >
-            Master Your
-            <span className="gradient-text"> NEC License </span>
-            Exam
+            {/* `.gradient-text` ran a three-stop ramp across the two longest
+                words of the largest text on the page, bottoming out at 4.42:1.
+                The accent is now one short word on a measured two-stop ramp
+                whose darkest point is 6.62:1 — see Landing.module.css. */}
+            Master Your{' '}
+            <span className={styles.heroAccent}>NEC</span>{' '}
+            License Exam
           </motion.h1>
           
           <motion.p 
@@ -168,8 +150,8 @@ export default function Landing() {
             animate={{ opacity: 1, y: 0 }}
             transition={{ duration: 0.6, delay: 0.6 }}
           >
-            The most comprehensive platform to study, practice, and ace your 
-            NEC license examination. Powered by proven study methods, built by engineers, for engineers.
+            Practise {LIVE_QUESTIONS.toLocaleString()} questions across all {LIVE_CHAPTERS} chapters of the
+            NEC Computer Engineering syllabus. Free, open source, and works offline.
           </motion.p>
           
           <motion.div 
@@ -180,7 +162,7 @@ export default function Landing() {
           >
             <motion.button
               className="btn-primary"
-              onClick={openNamePortal}
+              onClick={() => navigate('/signin')}
               whileHover={{ scale: 1.05, boxShadow: '0 0 30px rgba(99, 102, 241, 0.5)' }}
               whileTap={{ scale: 0.95 }}
             >
@@ -190,6 +172,8 @@ export default function Landing() {
             
             <motion.button
               className="btn-secondary"
+              type="button"
+              onClick={scrollToFeatures}
               whileHover={{ scale: 1.05 }}
               whileTap={{ scale: 0.95 }}
             >
@@ -200,7 +184,7 @@ export default function Landing() {
       </section>
 
       {/* Features Section */}
-      <section className="features-section">
+      <section className="features-section" id="features">
         <motion.div
           className="features-container"
           variants={containerVariants}
@@ -233,34 +217,45 @@ export default function Landing() {
         </motion.div>
       </section>
 
-      {/* Stats Section */}
-      <section className="stats-section">
+      {/* Goals Section — aspirational targets, explicitly labelled as such,
+          with the actual shipped figures stated directly underneath. */}
+      <section className="stats-section" aria-labelledby="goals-heading">
         <motion.div
-          className="stats-container"
+          className="stats-wrapper"
           initial={{ opacity: 0, y: 30 }}
           whileInView={{ opacity: 1, y: 0 }}
           viewport={{ once: true }}
           transition={{ duration: 0.6 }}
         >
-          <div className="stat-item">
-            <span className="stat-number">10,000+</span>
-            <span className="stat-label">Practice Questions</span>
-          </div>
-          <div className="stat-divider"></div>
-          <div className="stat-item">
-            <span className="stat-number">95%</span>
-            <span className="stat-label">Pass Rate</span>
-          </div>
-          <div className="stat-divider"></div>
-          <div className="stat-item">
-            <span className="stat-number">5,000+</span>
-            <span className="stat-label">Students</span>
-          </div>
-          <div className="stat-divider"></div>
-          <div className="stat-item">
-            <span className="stat-number">12</span>
-            <span className="stat-label">Subject Areas</span>
+          <p className="stats-eyebrow" id="goals-heading">Our 2026 goals</p>
+
+          <div className="stats-container">
+            <div className="stat-item">
+              <span className="stat-number">10,000+</span>
+              <span className="stat-label">Practice Questions</span>
+            </div>
+            <div className="stat-divider"></div>
+            <div className="stat-item">
+              <span className="stat-number">95%</span>
+              <span className="stat-label">Pass Rate</span>
+            </div>
+            <div className="stat-divider"></div>
+            <div className="stat-item">
+              <span className="stat-number">5,000+</span>
+              <span className="stat-label">Students</span>
+            </div>
+            <div className="stat-divider"></div>
+            <div className="stat-item">
+              <span className="stat-number">12</span>
+              <span className="stat-label">Subject Areas</span>
+            </div>
           </div>
+
+          <p className="stats-live">
+            <strong>Live today:</strong> {LIVE_QUESTIONS.toLocaleString()} questions
+            {' · '}{LIVE_CHAPTERS} chapters
+            {' · '}{SYLLABUS_SUBCHAPTERS} NEC syllabus sub-chapters
+          </p>
         </motion.div>
       </section>
 
@@ -275,11 +270,11 @@ export default function Landing() {
         >
           <h2 className="cta-title">Ready to Start Your Journey?</h2>
           <p className="cta-description">
-            Join thousands of engineers who have successfully passed their license exam with our platform.
+            Free and open source. No account needed — continue as a guest and start practising in seconds.
           </p>
           <motion.button
             className="btn-primary btn-large"
-            onClick={openNamePortal}
+            onClick={() => navigate('/signin')}
             whileHover={{ scale: 1.05, boxShadow: '0 0 40px rgba(99, 102, 241, 0.6)' }}
             whileTap={{ scale: 0.95 }}
           >
@@ -289,55 +284,6 @@ export default function Landing() {
         </motion.div>
       </section>
 
-      {isNamePortalOpen && (
-        <div className="name-portal-overlay" role="dialog" aria-modal="true" aria-label="Welcome portal">
-          <motion.div
-            className="name-portal-card"
-            initial={{ opacity: 0, scale: 0.9 }}
-            animate={{ opacity: 1, scale: 1 }}
-            transition={{ duration: 0.3 }}
-          >
-            <button
-              className="name-portal-close"
-              type="button"
-              aria-label="Close portal"
-              onClick={closeNamePortal}
-            >
-              &times;
-            </button>
-
-            <div className="name-portal-header">
-              <h3>Nice to meet you!</h3>
-              <p>Tell us your name so we can keep this stoplight-ready proof of concept tidy.</p>
-            </div>
-
-            <label htmlFor="namePortalInput" className="name-portal-label">
-              Full name
-            </label>
-            <input
-              id="namePortalInput"
-              className="name-portal-input"
-              type="text"
-              placeholder="e.g. Samir Wagle"
-              value={nameInput}
-              onChange={(event) => setNameInput(event.target.value)}
-              onKeyDown={handlePortalKeyDown}
-            />
-
-            {portalError && <p className="name-portal-error">{portalError}</p>}
-
-            <motion.button
-              className="btn-primary name-portal-submit"
-              onClick={handleNamePortalSubmit}
-              whileHover={{ scale: 1.02 }}
-              whileTap={{ scale: 0.96 }}
-            >
-              Continue to login
-              <ArrowRight className="w-5 h-5 ml-2" />
-            </motion.button>
-          </motion.div>
-        </div>
-      )}
 
       {/* Footer */}
       <footer className="footer">
@@ -349,6 +295,17 @@ export default function Landing() {
           <p className="footer-text">
             © 2026 NECPrep. Built for Nepal Engineering Council License Exam Preparation.
           </p>
+          {/* Google's consent screen links to /privacy, so it has to be
+              reachable from the site itself too - a policy that exists only as
+              a URL handed to Google is not a policy anyone can find. */}
+          <p className="footer-legal">
+            <Link to="/privacy">Privacy Policy</Link>
+            <span aria-hidden="true"> · </span>
+            <Link to="/terms">Terms of Use</Link>
+          </p>
+          <p className="footer-disclaimer">
+            Not affiliated with, endorsed by, or approved by the Nepal Engineering Council.
+          </p>
         </div>
       </footer>
     </div>
diff --git a/frontend/src/pages/__tests__/Bookmarks.test.tsx b/frontend/src/pages/__tests__/Bookmarks.test.tsx
new file mode 100644
index 0000000..2349165
--- /dev/null
+++ b/frontend/src/pages/__tests__/Bookmarks.test.tsx
@@ -0,0 +1,195 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter } from 'react-router-dom';
+import Bookmarks from '../app/Bookmarks';
+import { loadBookmarkedQuestions, removeBookmark, getTopicById } from '../../services/localData';
+import type { Question } from '../../services/localData';
+import type { Topic } from '../../data/topics';
+
+/**
+ * The filter strip declared role="tablist" while providing no role="tab", no
+ * aria-selected, no aria-controls, no tabpanel and no arrow-key navigation, so
+ * screen readers announced a tab widget that did not exist. It is now a group
+ * of aria-pressed toggle buttons — see the comment in Bookmarks.tsx for why
+ * that, and not the full ARIA tabs pattern, is the honest shape here.
+ */
+
+vi.mock('../../services/localData', () => ({
+  loadBookmarkedQuestions: vi.fn(),
+  removeBookmark: vi.fn(),
+  getTopicById: vi.fn(),
+}));
+
+function topic(id: string, shortName: string, name: string): Topic {
+  return {
+    id,
+    name,
+    shortName,
+    description: '',
+    questionCount: 10,
+    icon: 'book',
+    color: '#6366f1',
+    dataFile: `${id}.json`,
+  };
+}
+
+const TOPICS: Record<string, Topic> = {
+  'book-ch1': topic('book-ch1', 'Ch1', 'Chapter 1: Basic Electrical'),
+  'book-ch2': topic('book-ch2', 'Ch2', 'Chapter 2: Digital Logic'),
+};
+
+function question(id: string, topicId: string, text: string): Question {
+  return { id, topicId, question: text, options: ['a', 'b', 'c', 'd'], correctIndex: 0 };
+}
+
+const SAVED: Question[] = [
+  question('book-ch1_0', 'book-ch1', 'What is Ohm’s law?'),
+  question('book-ch1_1', 'book-ch1', 'Define reactance.'),
+  question('book-ch2_0', 'book-ch2', 'Convert 1010 to decimal.'),
+];
+
+beforeEach(() => {
+  vi.mocked(getTopicById).mockImplementation((id: string) => TOPICS[id]);
+  vi.mocked(removeBookmark).mockReset();
+  vi.mocked(loadBookmarkedQuestions).mockResolvedValue(SAVED);
+});
+
+async function renderBookmarks() {
+  render(
+    <MemoryRouter initialEntries={['/app/bookmarks']}>
+      <Bookmarks />
+    </MemoryRouter>
+  );
+  // Wait out the async bookmark load.
+  await screen.findByRole('group', { name: 'Filter saved questions by chapter' });
+}
+
+const filterGroup = () => screen.getByRole('group', { name: 'Filter saved questions by chapter' });
+const removeButtons = () => screen.getAllByRole('button', { name: /^Remove bookmark:/ });
+
+describe('Bookmarks filters', () => {
+  it('does not claim to be a tab widget', async () => {
+    await renderBookmarks();
+
+    expect(screen.queryByRole('tablist')).not.toBeInTheDocument();
+    expect(screen.queryAllByRole('tab')).toHaveLength(0);
+    expect(screen.queryAllByRole('tabpanel')).toHaveLength(0);
+  });
+
+  it('reports the selected filter through aria-pressed', async () => {
+    await renderBookmarks();
+
+    const buttons = within(filterGroup()).getAllByRole('button');
+    expect(buttons.map((b) => b.textContent?.trim())).toEqual([
+      'All (3)',
+      'Ch1 (2)',
+      'Ch2 (1)',
+    ]);
+    expect(buttons.map((b) => b.getAttribute('aria-pressed'))).toEqual([
+      'true',
+      'false',
+      'false',
+    ]);
+    for (const button of buttons) {
+      expect(button).toHaveAttribute('aria-controls', 'bookmarks-results');
+    }
+  });
+
+  it('is operable with Tab and Enter', async () => {
+    const user = userEvent.setup();
+    await renderBookmarks();
+
+    const all = within(filterGroup()).getByRole('button', { name: 'All (3)' });
+    const ch1 = within(filterGroup()).getByRole('button', { name: 'Ch1 (2)' });
+
+    all.focus();
+    await user.tab();
+    expect(ch1).toHaveFocus();
+
+    await user.keyboard('{Enter}');
+
+    expect(ch1).toHaveAttribute('aria-pressed', 'true');
+    expect(all).toHaveAttribute('aria-pressed', 'false');
+    expect(removeButtons()).toHaveLength(2);
+  });
+
+  it('is operable with Space', async () => {
+    const user = userEvent.setup();
+    await renderBookmarks();
+
+    const ch2 = within(filterGroup()).getByRole('button', { name: 'Ch2 (1)' });
+    ch2.focus();
+    await user.keyboard(' ');
+
+    expect(ch2).toHaveAttribute('aria-pressed', 'true');
+    expect(removeButtons()).toHaveLength(1);
+  });
+
+  it('every filter is its own tab stop', async () => {
+    const user = userEvent.setup();
+    await renderBookmarks();
+
+    const buttons = within(filterGroup()).getAllByRole('button');
+    buttons[0].focus();
+    for (let i = 1; i < buttons.length; i += 1) {
+      await user.tab();
+      expect(buttons[i]).toHaveFocus();
+    }
+  });
+
+  it('announces how many of the saved questions are showing', async () => {
+    const user = userEvent.setup();
+    await renderBookmarks();
+
+    expect(screen.getByRole('status')).toHaveTextContent('Showing 3 of 3 saved questions');
+
+    await user.click(within(filterGroup()).getByRole('button', { name: 'Ch2 (1)' }));
+    expect(screen.getByRole('status')).toHaveTextContent('Showing 1 of 3 saved questions');
+  });
+
+  it('falls back to All when the filtered chapter runs out of bookmarks', async () => {
+    const user = userEvent.setup();
+    await renderBookmarks();
+
+    await user.click(within(filterGroup()).getByRole('button', { name: 'Ch2 (1)' }));
+    await user.click(screen.getByRole('button', { name: 'Remove bookmark: Convert 1010 to decimal.' }));
+
+    expect(removeBookmark).toHaveBeenCalledWith('book-ch2_0');
+    const all = within(filterGroup()).getByRole('button', { name: 'All (2)' });
+    expect(all).toHaveAttribute('aria-pressed', 'true');
+    expect(removeButtons()).toHaveLength(2);
+  });
+});
+
+describe('Bookmarks icon-only actions', () => {
+  it('gives each one a unique accessible name', async () => {
+    await renderBookmarks();
+
+    const names = removeButtons().map((b) => b.getAttribute('aria-label'));
+    expect(new Set(names).size).toBe(names.length);
+    expect(names).toContain('Remove bookmark: Define reactance.');
+
+    expect(
+      screen.getAllByRole('link', { name: 'Practice Chapter 1: Basic Electrical' })
+    ).toHaveLength(2);
+  });
+});
+
+describe('Bookmarks heading hierarchy', () => {
+  it('never skips a heading level when there are results', async () => {
+    await renderBookmarks();
+
+    const tags = screen.getAllByRole('heading').map((h) => h.tagName);
+    expect(tags).toEqual(['H1']);
+  });
+
+  it('uses an h2, not an h3, for the empty state', async () => {
+    vi.mocked(loadBookmarkedQuestions).mockResolvedValue([]);
+    await renderBookmarks();
+
+    const tags = screen.getAllByRole('heading').map((h) => h.tagName);
+    expect(tags).toEqual(['H1', 'H2']);
+    expect(screen.getByRole('heading', { level: 2 })).toHaveTextContent('No bookmarks yet');
+  });
+});
diff --git a/frontend/src/pages/__tests__/Landing.test.tsx b/frontend/src/pages/__tests__/Landing.test.tsx
new file mode 100644
index 0000000..9b9a8e7
--- /dev/null
+++ b/frontend/src/pages/__tests__/Landing.test.tsx
@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeAll, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import Landing from '../Landing';
+
+/**
+ * The landing page is the only route a visitor arrives on, so it is the only
+ * place a way in can be missing from — and it was. Nothing here linked to
+ * /signin, and the single call to action opened a modal that collected a
+ * display name into localStorage and navigated to /app, where the session
+ * guard then asked for a sign-in anyway. Two identity prompts in a row, the
+ * first of which decided nothing.
+ *
+ * The modal is gone and /signin does the job properly: guest, Google, or email
+ * and password. These tests cover the ways in, because a login page nobody can
+ * find is the same as no login page.
+ */
+
+// framer-motion's `whileInView` needs IntersectionObserver, which jsdom does not
+// implement. Local stub rather than a change to the shared test setup.
+class StubIntersectionObserver implements IntersectionObserver {
+  readonly root: Document | Element | null = null;
+  readonly rootMargin: string = '';
+  readonly thresholds: ReadonlyArray<number> = [];
+  observe(): void {}
+  unobserve(): void {}
+  disconnect(): void {}
+  takeRecords(): IntersectionObserverEntry[] {
+    return [];
+  }
+}
+
+beforeAll(() => {
+  vi.stubGlobal('IntersectionObserver', StubIntersectionObserver);
+});
+
+function renderLanding() {
+  return render(
+    <MemoryRouter initialEntries={['/']}>
+      <Routes>
+        <Route path="/" element={<Landing />} />
+        <Route path="/app" element={<h1>Dashboard</h1>} />
+        <Route path="/signin" element={<h1>Sign-in page</h1>} />
+      </Routes>
+    </MemoryRouter>
+  );
+}
+
+describe('Landing sign-in entry points', () => {
+  it('offers Sign in from the navigation', () => {
+    renderLanding();
+    // This link did not exist. /signin was reachable only by typing the URL.
+    expect(screen.getByRole('link', { name: /sign in/i })).toHaveAttribute(
+      'href',
+      '/signin',
+    );
+  });
+
+  it('sends the primary call to action to /signin, not straight into the app', async () => {
+    const user = userEvent.setup();
+    renderLanding();
+
+    await user.click(screen.getByRole('button', { name: /Get Started Free/i }));
+    // /signin is where the three real ways in live. It also redirects to /app
+    // on a build with no backend configured, so this works in both modes.
+    expect(await screen.findByText('Sign-in page')).toBeInTheDocument();
+  });
+
+  it('sends the closing call to action to the same place', async () => {
+    const user = userEvent.setup();
+    renderLanding();
+
+    await user.click(screen.getByRole('button', { name: /Start Preparing Now/i }));
+    expect(await screen.findByText('Sign-in page')).toBeInTheDocument();
+  });
+
+  it('no longer asks for a name before letting anyone in', () => {
+    renderLanding();
+    // The modal promised "no account needed" and then demanded an identity
+    // that decided nothing.
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(screen.queryByLabelText(/your name/i)).not.toBeInTheDocument();
+  });
+
+  it('still promises a guest route, because /signin provides one', () => {
+    renderLanding();
+    expect(screen.getByText(/continue as a guest/i)).toBeInTheDocument();
+  });
+
+  it('links to the privacy policy and terms', () => {
+    renderLanding();
+    // Google's consent screen links to /privacy; it has to be findable from
+    // the site too.
+    expect(screen.getByRole('link', { name: /privacy policy/i })).toHaveAttribute(
+      'href',
+      '/privacy',
+    );
+    expect(screen.getByRole('link', { name: /terms of use/i })).toHaveAttribute(
+      'href',
+      '/terms',
+    );
+  });
+
+  it('states it is not affiliated with the examining authority', () => {
+    renderLanding();
+    expect(screen.getByText(/not affiliated with/i)).toBeInTheDocument();
+  });
+});
+
+describe('Landing hero heading', () => {
+  it('keeps the whole title readable and limits the gradient to one short word', () => {
+    renderLanding();
+
+    const heading = screen.getByRole('heading', { level: 1 });
+    expect(heading).toHaveTextContent('Master Your NEC License Exam');
+
+    // Exactly one accent span, and it covers a single short word rather than
+    // two thirds of the largest text on the page.
+    const accents = heading.querySelectorAll('span');
+    expect(accents).toHaveLength(1);
+    expect(accents[0].textContent).toBe('NEC');
+    expect(accents[0].className).not.toContain('gradient-text');
+  });
+});
diff --git a/frontend/src/pages/__tests__/PracticeHub.test.tsx b/frontend/src/pages/__tests__/PracticeHub.test.tsx
new file mode 100644
index 0000000..34b226c
--- /dev/null
+++ b/frontend/src/pages/__tests__/PracticeHub.test.tsx
@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import PracticeHub from '../app/PracticeHub';
+
+/**
+ * The Quick Practice and Custom Practice mode cards were
+ * `<div onClick style={{cursor:'pointer'}}>` with no role, no tabIndex and no
+ * key handler, so both features were unreachable by keyboard. Each also nested
+ * a <button> inside the clickable div, which is invalid.
+ */
+
+function renderHub() {
+  return render(
+    <MemoryRouter initialEntries={['/app/practice']}>
+      <Routes>
+        <Route path="/app/practice" element={<PracticeHub />} />
+        <Route path="/app/practice/quick" element={<h1>Quick Practice page</h1>} />
+        <Route path="/app/practice/custom" element={<h1>Custom Practice page</h1>} />
+      </Routes>
+    </MemoryRouter>
+  );
+}
+
+describe('PracticeHub mode cards', () => {
+  it('exposes Quick Practice as a link and activates it from the keyboard', async () => {
+    const user = userEvent.setup();
+    renderHub();
+
+    const quick = screen.getByRole('link', { name: /Quick Practice/ });
+    expect(quick).toHaveAttribute('href', '/app/practice/quick');
+
+    quick.focus();
+    expect(quick).toHaveFocus();
+
+    await user.keyboard('{Enter}');
+    expect(screen.getByRole('heading', { name: 'Quick Practice page' })).toBeInTheDocument();
+  });
+
+  it('exposes Custom Practice as a link and activates it from the keyboard', async () => {
+    const user = userEvent.setup();
+    renderHub();
+
+    const custom = screen.getByRole('link', { name: /Custom Practice/ });
+    expect(custom).toHaveAttribute('href', '/app/practice/custom');
+
+    custom.focus();
+    await user.keyboard('{Enter}');
+    expect(screen.getByRole('heading', { name: 'Custom Practice page' })).toBeInTheDocument();
+  });
+
+  it('reaches both mode cards by tabbing, in document order', async () => {
+    const user = userEvent.setup();
+    renderHub();
+
+    const mock = screen.getByRole('link', { name: /Mock Tests/ });
+    mock.focus();
+
+    await user.tab();
+    expect(screen.getByRole('link', { name: /Quick Practice/ })).toHaveFocus();
+
+    await user.tab();
+    expect(screen.getByRole('link', { name: /Custom Practice/ })).toHaveFocus();
+  });
+
+  it('nests no interactive element inside a mode card', () => {
+    renderHub();
+
+    for (const name of [/Mock Tests/, /Quick Practice/, /Custom Practice/]) {
+      const card = screen.getByRole('link', { name });
+      expect(card.querySelectorAll('button, a, input, [tabindex]')).toHaveLength(0);
+    }
+  });
+});
+
+describe('PracticeHub heading hierarchy', () => {
+  it('declares exactly one h1', () => {
+    renderHub();
+    expect(screen.getAllByRole('heading', { level: 1 })).toHaveLength(1);
+  });
+
+  it('never skips a heading level', () => {
+    renderHub();
+
+    const levels = screen
+      .getAllByRole('heading')
+      .map((heading) => Number(heading.tagName.slice(1)));
+
+    expect(levels[0]).toBe(1);
+    for (let i = 1; i < levels.length; i += 1) {
+      expect(levels[i] - levels[i - 1]).toBeLessThanOrEqual(1);
+    }
+    // The "Practice Modes" h2 used to be .sr-only, leaving the visible outline
+    // jumping h1 -> h3 over the mode cards.
+    const modesHeading = screen.getByRole('heading', { name: 'Practice Modes' });
+    expect(modesHeading.tagName).toBe('H2');
+    expect(modesHeading.className).not.toContain('sr-only');
+  });
+});
diff --git a/frontend/src/pages/app/Bookmarks.module.css b/frontend/src/pages/app/Bookmarks.module.css
new file mode 100644
index 0000000..87164fe
--- /dev/null
+++ b/frontend/src/pages/app/Bookmarks.module.css
@@ -0,0 +1,82 @@
+/* Accessibility styles for the bookmarks page. CSS Module because App.css is
+ * owned by another workstream.
+ *
+ * Focus ring: #ffffff, 3px, 3px offset.
+ *   #ffffff on --bg-primary     #0a0a0f  = 19.75:1
+ *   #ffffff on --bg-card       ~#101018  = 18.93:1
+ *   #ffffff on --accent-primary #6366f1  =  4.47:1  (pressed filter)
+ * All above the 3:1 WCAG 1.4.11 minimum.
+ */
+
+/* The class is doubled on purpose: `.filter-tabs` in App.css sets
+ * `width: fit-content` and the default `flex-wrap: nowrap` with no overflow
+ * handling, so a per-chapter strip simply ran off the viewport. Both
+ * selectors have the same single-class specificity, and CSS Module import
+ * order relative to App.css is not something this file can guarantee, so the
+ * repeated class raises specificity to 0,2,0 and the override is
+ * deterministic. */
+.filterBar.filterBar {
+  width: auto;
+  max-width: 100%;
+  flex-wrap: nowrap;
+  overflow-x: auto;
+  overscroll-behavior-x: contain;
+  scroll-snap-type: x proximity;
+  -webkit-overflow-scrolling: touch;
+  /* An always-visible thin scrollbar is the scroll affordance; macOS and iOS
+   * hide overlay scrollbars until a gesture starts, which is exactly the
+   * case where the strip looked like it simply ended. */
+  scrollbar-width: thin;
+  scrollbar-color: rgba(255, 255, 255, 0.35) transparent;
+}
+
+.filterBar.filterBar::-webkit-scrollbar {
+  height: 6px;
+}
+
+.filterBar.filterBar::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.filterBar.filterBar::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.35);
+  border-radius: 3px;
+}
+
+/* WCAG 2.5.8 target size: 0.5rem/1rem padding on a 0.875rem label is ~33px. */
+.filterButton.filterButton {
+  flex: 0 0 auto;
+  scroll-snap-align: start;
+  min-height: 44px;
+  white-space: nowrap;
+}
+
+.filterButton:focus-visible {
+  outline: 3px solid #ffffff;
+  outline-offset: -3px;
+}
+
+/* WCAG 2.5.8 target size: the icon actions were 16px glyphs in 0.5rem
+ * padding, i.e. roughly 34x34. */
+.actionButton.actionButton {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 44px;
+  min-height: 44px;
+}
+
+.page a:focus-visible,
+.page button:focus-visible,
+.page [tabindex]:focus-visible {
+  outline: 3px solid #ffffff;
+  outline-offset: 3px;
+}
+
+/* The empty-state heading moved from <h3> to <h2> to close the h1 -> h3 jump;
+ * App.css only styles `.empty-state h3`, so carry the type over. */
+.emptyStateTitle {
+  font-size: 1rem;
+  font-weight: 600;
+  margin-bottom: 0.25rem;
+}
diff --git a/frontend/src/pages/app/Bookmarks.tsx b/frontend/src/pages/app/Bookmarks.tsx
index bc0dc4c..1da058c 100644
--- a/frontend/src/pages/app/Bookmarks.tsx
+++ b/frontend/src/pages/app/Bookmarks.tsx
@@ -1,12 +1,15 @@
-import { useState, useEffect } from 'react';
+import { useState, useEffect } from 'react';
 import { Link } from 'react-router-dom';
 import { loadBookmarkedQuestions, removeBookmark, getTopicById } from '../../services/localData';
 import type { Question } from '../../services/localData';
+import styles from './Bookmarks.module.css';
+
+const ALL_FILTER = 'all';
 
 export default function Bookmarks() {
   const [questions, setQuestions] = useState<Question[]>([]);
   const [loading, setLoading] = useState(true);
-  const [filter, setFilter] = useState<string>('all');
+  const [filter, setFilter] = useState<string>(ALL_FILTER);
 
   useEffect(() => {
     loadBookmarkedQuestions().then(setQuestions).finally(() => setLoading(false));
@@ -18,83 +21,144 @@ export default function Bookmarks() {
   };
 
   const topicIds = Array.from(new Set(questions.map(q => q.topicId)));
-  const filtered = filter === 'all' ? questions : questions.filter(q => q.topicId === filter);
+  const filtered = filter === ALL_FILTER ? questions : questions.filter(q => q.topicId === filter);
+
+  // Removing the last bookmark of the chapter currently filtered on would
+  // otherwise leave the page stuck on a filter whose button no longer exists.
+  // Adjusted during render rather than in an effect.
+  if (filter !== ALL_FILTER && !loading && !topicIds.includes(filter)) {
+    setFilter(ALL_FILTER);
+  }
+
+  const filterOptions = [
+    { id: ALL_FILTER, label: 'All', count: questions.length },
+    ...topicIds.map(tid => ({
+      id: tid,
+      label: getTopicById(tid)?.shortName ?? tid,
+      count: questions.filter(q => q.topicId === tid).length,
+    })),
+  ];
 
   return (
-    <div className="bookmarks-page">
+    <div className={`bookmarks-page ${styles.page}`}>
       <header className="page-header">
         <h1>Bookmarks</h1>
         <p>Your saved questions for quick access</p>
       </header>
 
       {loading ? (
-        <div className="loading-container"><div className="loading-spinner"/><p>Loading...</p></div>
+        <div className="loading-container" role="status">
+          <div className="loading-spinner" />
+          <p>Loading...</p>
+        </div>
       ) : (
         <>
-          <div className="filter-tabs" role="tablist">
-            <button className={`tab ${filter === 'all' ? 'active' : ''}`} onClick={() => setFilter('all')}>
-              All ({questions.length})
-            </button>
-            {topicIds.map(tid => {
-              const topic = getTopicById(tid);
-              const count = questions.filter(q => q.topicId === tid).length;
+          {/* Deliberately NOT role="tablist".
+           *
+           * The previous markup claimed role="tablist" while providing no
+           * role="tab", no aria-selected, no aria-controls, no tabpanel and no
+           * arrow-key navigation, so screen readers announced "tab 1 of 1" over
+           * plain buttons. Implementing the real tabs pattern would be wrong
+           * here too: these are not swappable panels, they are a filter applied
+           * to one list that keeps its own identity, and the set is generated
+           * per-chapter so it can be anything from one to a dozen entries.
+           * ARIA tabs also take the whole strip out of the tab sequence behind
+           * a roving tabindex, which for a wide scrolling filter bar makes
+           * discovery worse, not better. These are toggle buttons, labelled as
+           * toggle buttons: a group with aria-pressed, each one its own tab
+           * stop, Enter and Space from the native button.
+           */}
+          <div
+            className={`filter-tabs ${styles.filterBar}`}
+            role="group"
+            aria-label="Filter saved questions by chapter"
+          >
+            {filterOptions.map(option => {
+              const isActive = filter === option.id;
               return (
-                <button key={tid} className={`tab ${filter === tid ? 'active' : ''}`} onClick={() => setFilter(tid)}>
-                  {topic?.shortName ?? tid} ({count})
+                <button
+                  key={option.id}
+                  type="button"
+                  className={`tab ${isActive ? 'active' : ''} ${styles.filterButton}`}
+                  aria-pressed={isActive}
+                  aria-controls="bookmarks-results"
+                  onClick={() => setFilter(option.id)}
+                >
+                  {option.label} ({option.count})
                 </button>
               );
             })}
           </div>
 
-          {filtered.length > 0 ? (
-            <div className="bookmarks-list">
-              {filtered.map(q => {
-                const topic = getTopicById(q.topicId);
-                return (
-                  <div key={q.id} className="bookmark-card">
-                    <div className="bookmark-icon">
-                      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                        <circle cx="12" cy="12" r="10"/>
-                        <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/>
-                        <line x1="12" y1="17" x2="12.01" y2="17"/>
-                      </svg>
-                    </div>
-                    <div className="bookmark-content">
-                      <span className="bookmark-type">question</span>
-                      <p className="bookmark-text">{q.question}</p>
-                      <div className="bookmark-meta">
-                        <span className="topic">{topic?.name}</span>
-                      </div>
-                    </div>
-                    <div className="bookmark-actions">
-                      <Link to={`/app/practice/topic/${q.topicId}`} className="action-btn" aria-label="Practice this topic">
-                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                          <path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/>
-                          <circle cx="12" cy="12" r="3"/>
-                        </svg>
-                      </Link>
-                      <button className="action-btn delete" aria-label="Remove bookmark" onClick={() => handleRemove(q.id)}>
-                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                          <polyline points="3 6 5 6 21 6"/>
-                          <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
+          {/* aria-label rather than a visually hidden heading: the region needs
+           * a name, but a heading nobody can see would make the visible outline
+           * and the screen-reader outline disagree. */}
+          <section id="bookmarks-results" aria-label="Saved questions">
+            <p className="sr-only" role="status">
+              Showing {filtered.length} of {questions.length} saved questions
+            </p>
+
+            {filtered.length > 0 ? (
+              <div className="bookmarks-list">
+                {filtered.map(q => {
+                  const topic = getTopicById(q.topicId);
+                  const topicLabel = topic?.name ?? q.topicId;
+                  return (
+                    <div key={q.id} className="bookmark-card">
+                      <div className="bookmark-icon">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" aria-hidden="true">
+                          <circle cx="12" cy="12" r="10"/>
+                          <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/>
+                          <line x1="12" y1="17" x2="12.01" y2="17"/>
                         </svg>
-                      </button>
+                      </div>
+                      <div className="bookmark-content">
+                        <span className="bookmark-type">question</span>
+                        <p className="bookmark-text">{q.question}</p>
+                        <div className="bookmark-meta">
+                          <span className="topic">{topicLabel}</span>
+                        </div>
+                      </div>
+                      <div className="bookmark-actions">
+                        <Link
+                          to={`/app/practice/topic/${q.topicId}`}
+                          className={`action-btn ${styles.actionButton}`}
+                          aria-label={`Practice ${topicLabel}`}
+                        >
+                          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" aria-hidden="true">
+                            <path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/>
+                            <circle cx="12" cy="12" r="3"/>
+                          </svg>
+                        </Link>
+                        <button
+                          type="button"
+                          className={`action-btn delete ${styles.actionButton}`}
+                          aria-label={`Remove bookmark: ${q.question}`}
+                          onClick={() => handleRemove(q.id)}
+                        >
+                          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" aria-hidden="true">
+                            <polyline points="3 6 5 6 21 6"/>
+                            <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
+                          </svg>
+                        </button>
+                      </div>
                     </div>
-                  </div>
-                );
-              })}
-            </div>
-          ) : (
-            <div className="empty-state">
-              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.5">
-                <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"/>
-              </svg>
-              <h3>No bookmarks yet</h3>
-              <p>Save questions while practicing to access them here</p>
-            </div>
-          )}
+                  );
+                })}
+              </div>
+            ) : (
+              /* Was an <h3>, one level below the page <h1> with no h2 between. */
+              <div className="empty-state">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.5" aria-hidden="true">
+                  <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"/>
+                </svg>
+                <h2 className={styles.emptyStateTitle}>No bookmarks yet</h2>
+                <p>Save questions while practising to access them here</p>
+              </div>
+            )}
+          </section>
         </>
       )}
     </div>
   );
-}
\ No newline at end of file
+}
diff --git a/frontend/src/pages/app/ChapterPracticeSelector.tsx b/frontend/src/pages/app/ChapterPracticeSelector.tsx
index 7893e6c..00e12e6 100644
--- a/frontend/src/pages/app/ChapterPracticeSelector.tsx
+++ b/frontend/src/pages/app/ChapterPracticeSelector.tsx
@@ -1,14 +1,12 @@
 import { useParams, useNavigate } from 'react-router-dom';
 import { useState } from 'react';
 import { getTopicById } from '../../services/localData';
-import ThreeBackground from '../../components/ThreeBackground';
 import './ChapterSelector.css';
 
 export default function ChapterPracticeSelector() {
   const { chapterId } = useParams<{ chapterId: string }>();
   const navigate = useNavigate();
   const chapter = chapterId ? getTopicById(chapterId) : null;
-  const loading = false;
   const [selectedOption, setSelectedOption] = useState<number | null>(null);
 
   const handleStartPractice = (questionCount: number) => {
@@ -18,24 +16,9 @@ export default function ChapterPracticeSelector() {
     }, 300);
   };
 
-  if (loading) {
-    return (
-      <div className="chapter-selector-container">
-        <ThreeBackground />
-        <div className="chapter-selector-content">
-          <div className="loading-spinner">
-            <div className="spinner"></div>
-            <p>Loading chapter...</p>
-          </div>
-        </div>
-      </div>
-    );
-  }
-
   if (!chapter) {
     return (
       <div className="chapter-selector-container">
-        <ThreeBackground />
         <div className="chapter-selector-content">
           <div className="error-message">
             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
@@ -83,7 +66,6 @@ export default function ChapterPracticeSelector() {
 
   return (
     <div className="chapter-selector-container">
-      <ThreeBackground />
       
       <div className="chapter-selector-content">
         {/* Header Section */}
diff --git a/frontend/src/pages/app/CustomPractice.tsx b/frontend/src/pages/app/CustomPractice.tsx
index 9533cc0..3ebe20f 100644
--- a/frontend/src/pages/app/CustomPractice.tsx
+++ b/frontend/src/pages/app/CustomPractice.tsx
@@ -1,166 +1,114 @@
+/**
+ * CustomPractice — pick chapters and a question count, then practise.
+ *
+ * Hosts the shared quiz engine; see TopicPractice for why all four quiz pages
+ * went from four copies of the state machine to one.
+ *
+ * The config screen stays local to this page: it is this page's whole reason to
+ * exist, and the engine has nothing to say about it. The engine is held back
+ * with `enabled: false` until the config is submitted, so nothing loads and no
+ * draft is written while the user is still choosing.
+ */
+
+import { useCallback, useState } from 'react';
 import { Link } from 'react-router-dom';
-import { useState, useEffect, useCallback } from 'react';
 import {
-  loadQuestionsSlice,
-  recordAttempt,
-  addBookmark,
-  removeBookmark,
-  isBookmarked,
-  saveQuizResult,
-} from '../../services/localData';
-import type { Question } from '../../services/localData';
-
+  useQuiz,
+  useQuizKeyboard,
+  QuestionCard,
+  QuestionPalette,
+  QuizActionBar,
+  QuizToolbar,
+  ResultSummary,
+  ExplanationPanel,
+} from '../../features/quiz';
+import { loadQuestionsSlice, saveQuizResult } from '../../services/localData';
+import type { Question, QuizSummary } from '../../features/quiz';
+import { fisherYates } from '../../services/optionOrdering';
 import { useChapters } from '../../hooks/useChapters';
-function shuffle<T>(arr: T[]): T[] {
-  const a = [...arr];
-  for (let i = a.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [a[i], a[j]] = [a[j], a[i]];
-  }
-  return a;
-}
-
-type Phase = 'config' | 'quiz' | 'done';
+import { describeReference } from '../../services/questionReference';
 
 export default function CustomPractice() {
-  const ALL_SOURCES = useChapters();
-  const [phase, setPhase] = useState<Phase>('config');
+  const chapters = useChapters();
 
-  // ── Config state ───────────────────────────────────────────────────────────
-  // We initialize with empty array on first render, but will sync in effect
-  const [selectedTopics, setSelectedTopics] = useState<Set<string>>(new Set());
-  
-  // Initialize selected topics once ALL_SOURCES is loaded
-  useEffect(() => {
-    if (selectedTopics.size === 0 && ALL_SOURCES.length > 0) {
-      setSelectedTopics(new Set(ALL_SOURCES.map(t => t.id)));
-    }
-  }, [ALL_SOURCES.length]);
+  // All chapters start selected. The manifest is static, so this is a lazy
+  // initializer rather than a set-state-in-effect round trip.
+  const [selectedTopics, setSelectedTopics] = useState<Set<string>>(
+    () => new Set(chapters.map((t) => t.id))
+  );
   const [count, setCount] = useState(20);
   const [configError, setConfigError] = useState<string | null>(null);
-  const [loading, setLoading] = useState(false);
 
-  // ── Quiz state ─────────────────────────────────────────────────────────────
-  const [questions, setQuestions] = useState<Question[]>([]);
-  const [idx, setIdx]             = useState(0);
-  const [answer, setAnswer]       = useState<number | null>(null);
-  const [revealed, setRevealed]   = useState(false);
-  const [score, setScore]         = useState(0);
-  const [answered, setAnswered]   = useState<Set<number>>(new Set());
-  const [bookmarkedIds, setBookmarkedIds] = useState<Set<string>>(new Set());
+  /**
+   * The submitted config. Null means the config screen is still open.
+   *
+   * This is the attempt's identity: starting a new run with different choices
+   * produces a different key, which is what makes the engine abandon the old
+   * attempt instead of mutating it.
+   */
+  const [started, setStarted] = useState<{ topics: string[]; count: number } | null>(null);
+
+  const attemptKey = started ? `custom:${started.topics.join(',')}:${started.count}` : null;
 
-  useEffect(() => {
-    if (questions.length === 0) return;
-    const id = questions[idx]?.id;
-    if (id && isBookmarked(id)) setBookmarkedIds(p => new Set(p).add(id));
-  }, [idx, questions]);
+  const loadQuestions = useCallback(async (): Promise<Question[]> => {
+    if (!started) return [];
+    const sources = chapters.filter((c) => started.topics.includes(c.id));
+    const perChapter = Math.max(1, Math.ceil(started.count / sources.length));
+    const results = await Promise.all(
+      sources.map((source) => loadQuestionsSlice(source.id, perChapter))
+    );
+    return fisherYates(results.flat()).slice(0, started.count);
+  }, [started, chapters]);
+
+  const onComplete = useCallback((summary: QuizSummary) => {
+    saveQuizResult({
+      topicId: 'custom-practice',
+      topicName: 'Custom Practice',
+      score: summary.score,
+      total: summary.total,
+      date: new Date().toISOString(),
+    });
+  }, []);
+
+  const quiz = useQuiz({
+    mode: 'custom',
+    attemptKey,
+    loadQuestions,
+    enabled: started !== null,
+    onComplete,
+  });
+
+  useQuizKeyboard({
+    optionCount: quiz.current?.options.length ?? 0,
+    onSelectOption: quiz.selectOption,
+    onSubmitOrAdvance: quiz.submitOrAdvance,
+    onPrev: quiz.prev,
+    onNext: quiz.next,
+    onToggleFlag: quiz.toggleFlag,
+    onToggleBookmark: quiz.toggleBookmark,
+    enabled: quiz.state.phase === 'active',
+  });
 
-  // ── Config helpers ─────────────────────────────────────────────────────────
   const toggleTopic = (id: string) => {
-    setSelectedTopics(p => {
-      const n = new Set(p);
-      n.has(id) ? n.delete(id) : n.add(id);
-      return n;
+    setSelectedTopics((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
     });
   };
 
-  const handleStart = async () => {
+  const handleStart = () => {
     if (selectedTopics.size === 0) {
       setConfigError('Please select at least one topic.');
       return;
     }
-    setLoading(true);
     setConfigError(null);
-    const sources = ALL_SOURCES.filter(s => selectedTopics.has(s.id));
-    const perTopic = Math.max(1, Math.ceil(count / sources.length));
-    try {
-      const results = await Promise.all(sources.map(s => loadQuestionsSlice(s.id, perTopic)));
-      const combined = shuffle(results.flat()).slice(0, count);
-      if (combined.length === 0) {
-        setConfigError('No questions found for the selected topics.');
-        setLoading(false);
-        return;
-      }
-      setQuestions(combined);
-      setIdx(0);
-      setAnswer(null);
-      setRevealed(false);
-      setScore(0);
-      setAnswered(new Set());
-      setBookmarkedIds(new Set());
-      setPhase('quiz');
-    } catch {
-      setConfigError('Failed to load questions. Please try again.');
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  // ── Quiz helpers ───────────────────────────────────────────────────────────
-  const handleSelect = (i: number) => {
-    if (answered.has(idx)) return;
-    setAnswer(i);
-  };
-
-  const handleSubmit = useCallback(() => {
-    if (answer === null || answered.has(idx)) return;
-    const q = questions[idx];
-    const hasAnswer = q.correctIndex >= 0;
-    const correct = hasAnswer && answer === q.correctIndex;
-    setRevealed(true);
-    setAnswered(p => new Set(p).add(idx));
-    if (correct) setScore(s => s + 1);
-    if (hasAnswer) recordAttempt(q.id, q.topicId, correct);
-  }, [answer, idx, answered, questions]);
-
-  const handleToggleBookmark = () => {
-    const id = questions[idx]?.id;
-    if (!id) return;
-    if (bookmarkedIds.has(id)) {
-      removeBookmark(id);
-      setBookmarkedIds(p => { const n = new Set(p); n.delete(id); return n; });
-    } else {
-      addBookmark(id);
-      setBookmarkedIds(p => new Set(p).add(id));
-    }
-  };
-
-  const handleNext = () => {
-    if (idx < questions.length - 1) {
-      setIdx(i => i + 1);
-      setAnswer(null);
-      setRevealed(false);
-    } else if (answered.has(idx)) {
-      saveQuizResult({
-        topicId:   'custom-practice',
-        topicName: 'Custom Practice',
-        score,
-        total:     questions.length,
-        date:      new Date().toISOString(),
-      });
-      setPhase('done');
-    }
-  };
-
-  const handlePrev = () => {
-    if (idx > 0) {
-      setIdx(i => i - 1);
-      setAnswer(null);
-      setRevealed(answered.has(idx - 1));
-    }
-  };
-
-  const optClass = (i: number) => {
-    if (!revealed) return answer === i ? 'selected' : '';
-    const q = questions[idx];
-    if (q.correctIndex < 0) return answer === i ? 'selected' : '';
-    if (i === q.correctIndex) return 'correct';
-    if (answer === i) return 'incorrect';
-    return '';
+    setStarted({ topics: [...selectedTopics].sort(), count });
   };
 
   // ── Config screen ──────────────────────────────────────────────────────────
-  if (phase === 'config') {
+  if (started === null) {
     return (
       <div className="custom-practice-config">
         <nav className="breadcrumb" aria-label="Breadcrumb">
@@ -177,13 +125,21 @@ export default function CustomPractice() {
             <div className="config-section-header">
               <h3>Topics</h3>
               <div className="config-select-all">
-                <button className="text-btn" onClick={() => setSelectedTopics(new Set(ALL_SOURCES.map(t => t.id)))}>Select All</button>
+                <button
+                  type="button"
+                  className="text-btn"
+                  onClick={() => setSelectedTopics(new Set(chapters.map((t) => t.id)))}
+                >
+                  Select All
+                </button>
                 <span>·</span>
-                <button className="text-btn" onClick={() => setSelectedTopics(new Set())}>Clear</button>
+                <button type="button" className="text-btn" onClick={() => setSelectedTopics(new Set())}>
+                  Clear
+                </button>
               </div>
             </div>
             <div className="config-topics-grid">
-              {ALL_SOURCES.map(t => (
+              {chapters.map((t) => (
                 <label
                   key={t.id}
                   className={`config-topic-chip ${selectedTopics.has(t.id) ? 'active' : ''}`}
@@ -203,9 +159,10 @@ export default function CustomPractice() {
           <div className="config-section">
             <h3>Number of Questions</h3>
             <div className="config-count-row">
-              {[10, 20, 30, 50].map(n => (
+              {[10, 20, 30, 50].map((n) => (
                 <button
                   key={n}
+                  type="button"
                   className={`count-btn ${count === n ? 'active' : ''}`}
                   onClick={() => setCount(n)}
                 >
@@ -217,22 +174,32 @@ export default function CustomPractice() {
                 className="count-input"
                 min={5}
                 max={100}
+                aria-label="Number of questions"
                 value={count}
-                onChange={e => setCount(Math.min(100, Math.max(5, parseInt(e.target.value) || 5)))}
+                onChange={(e) =>
+                  setCount(Math.min(100, Math.max(5, parseInt(e.target.value) || 5)))
+                }
               />
             </div>
           </div>
 
-          {configError && <p className="config-error">{configError}</p>}
+          {configError && (
+            <p className="config-error" role="alert">
+              {configError}
+            </p>
+          )}
 
           <div className="config-actions">
-            <Link to="/app/practice" className="btn-secondary">Cancel</Link>
+            <Link to="/app/practice" className="btn-secondary">
+              Cancel
+            </Link>
             <button
+              type="button"
               className="btn-primary"
               onClick={handleStart}
-              disabled={selectedTopics.size === 0 || loading}
+              disabled={selectedTopics.size === 0}
             >
-              {loading ? 'Loading…' : `Start ${count} Questions`}
+              Start {count} Questions
             </button>
           </div>
         </div>
@@ -240,32 +207,49 @@ export default function CustomPractice() {
     );
   }
 
-  // ── Done screen ────────────────────────────────────────────────────────────
-  if (phase === 'done') {
-    const pct = Math.round((score / questions.length) * 100);
+  if (quiz.state.phase === 'loading') {
+    return (
+      <div className="loading-container" role="status" aria-live="polite">
+        <div className="loading-spinner" />
+        <p>Building your {started.count}-question set…</p>
+      </div>
+    );
+  }
+
+  if (quiz.error) {
+    return (
+      <div className="topic-not-found">
+        <h2>{quiz.error}</h2>
+        <button type="button" className="btn-primary" onClick={() => setStarted(null)}>
+          Change selection
+        </button>
+      </div>
+    );
+  }
+
+  if (quiz.state.phase === 'done') {
     return (
       <div className="quiz-complete">
-        <div className="quiz-complete-card">
-          <div className="complete-icon">{pct >= 60 ? '🎉' : '📚'}</div>
-          <h2>Custom Practice Done!</h2>
-          <div className="complete-score">
-            <span className="score-number">{score}</span>
-            <span className="score-total">/ {questions.length}</span>
-          </div>
-          <p className="complete-pct">{pct}% accuracy</p>
-          <div className="complete-actions">
-            <button className="btn-primary" onClick={() => setPhase('config')}>Configure Again</button>
-            <Link to="/app/practice" className="btn-secondary">Back to Practice</Link>
-          </div>
-        </div>
+        <ResultSummary
+          summary={quiz.summary}
+          title="Custom Practice"
+          actions={
+            <>
+              <button type="button" className="btn-primary" onClick={() => setStarted(null)}>
+                Build Another
+              </button>
+              <Link to="/app/practice" className="btn-secondary">
+                Back to Practice
+              </Link>
+            </>
+          }
+        />
       </div>
     );
   }
 
-  // ── Quiz screen ────────────────────────────────────────────────────────────
-  const q = questions[idx];
-  const isAnswered = answered.has(idx);
-  const isCurrentBookmarked = bookmarkedIds.has(q.id);
+  const current = quiz.current;
+  if (!current) return null;
 
   return (
     <div className="topic-practice-page">
@@ -275,92 +259,52 @@ export default function CustomPractice() {
         <span className="current">Custom Practice</span>
       </nav>
 
-      <header className="topic-header">
-        <div className="topic-info">
-          <h1>Custom Practice</h1>
-          <p>{selectedTopics.size} topic{selectedTopics.size !== 1 ? 's' : ''} · {questions.length} questions</p>
-        </div>
-        <div className="topic-stats">
-          <div className="stat">
-            <span className="value">{idx + 1}/{questions.length}</span>
-            <span className="label">Question</span>
-          </div>
-          <div className="stat">
-            <span className="value">{score}</span>
-            <span className="label">Correct</span>
-          </div>
-          <div className="stat">
-            <span className="value">{answered.size > 0 ? Math.round((score / answered.size) * 100) : 0}%</span>
-            <span className="label">Accuracy</span>
-          </div>
-        </div>
-      </header>
-
-      <div className="question-card">
-        <div className="question-header">
-          <div className="question-number">Question {idx + 1}</div>
-          <button
-            className={`bookmark-btn ${isCurrentBookmarked ? 'bookmarked' : ''}`}
-            onClick={handleToggleBookmark}
-            title={isCurrentBookmarked ? 'Remove bookmark' : 'Add bookmark'}
-          >
-            <svg viewBox="0 0 24 24" fill={isCurrentBookmarked ? 'currentColor' : 'none'} stroke="currentColor" strokeWidth="2">
-              <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"/>
-            </svg>
-          </button>
+      {quiz.state.resumed && (
+        <div className="mock-resume-notice" role="status">
+          Attempt resumed — your answers were restored.
         </div>
+      )}
 
-        <h2 className="question-text">{q.question}</h2>
+      <QuizToolbar
+        index={quiz.state.currentIndex}
+        total={quiz.counts.total}
+        answered={quiz.counts.answered}
+        flagged={quiz.isFlagged}
+        onToggleFlag={() => quiz.toggleFlag()}
+        bookmarked={quiz.isBookmarked}
+        onToggleBookmark={() => quiz.toggleBookmark()}
+      />
 
-        <div className="options-list" role="radiogroup" aria-label="Answer options">
-          {q.options.map((opt, i) => (
-            <button
-              key={i}
-              className={`option-btn ${optClass(i)}`}
-              onClick={() => handleSelect(i)}
-              disabled={isAnswered}
-              role="radio"
-              aria-checked={answer === i}
-            >
-              <span className="option-letter">{String.fromCharCode(65 + i)}</span>
-              <span className="option-text">{opt}</span>
-              {revealed && i === q.correctIndex && q.correctIndex >= 0 && (
-                <svg className="result-icon correct" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                  <polyline points="20 6 9 17 4 12"/>
-                </svg>
-              )}
-              {revealed && answer === i && i !== q.correctIndex && (
-                <svg className="result-icon incorrect" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                  <line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/>
-                </svg>
-              )}
-            </button>
-          ))}
-        </div>
-
-        {revealed && (
-          <div className={`result-message ${q.correctIndex >= 0 ? (answer === q.correctIndex ? 'correct' : 'incorrect') : 'selected'}`}>
-            {q.correctIndex < 0
-              ? <p>Answer recorded. No answer key available for this topic yet.</p>
-              : answer === q.correctIndex
-                ? <p>Correct! Well done.</p>
-                : <p>Incorrect. Correct answer: <strong>{String.fromCharCode(65 + q.correctIndex)}</strong></p>
-            }
-          </div>
+      <QuestionCard
+        index={quiz.state.currentIndex}
+        total={quiz.counts.total}
+        questionText={current.question}
+        options={current.options}
+        selection={quiz.selection}
+        onSelect={quiz.selectOption}
+        correctIndex={current.correctIndex}
+        revealed={quiz.isRevealed}
+        verdict={quiz.verdict}
+        locked={quiz.isSubmitted}
+      >
+        {quiz.isRevealed && (
+          <ExplanationPanel context="practice" reference={describeReference(current)} />
         )}
+      </QuestionCard>
 
-        <div className="question-actions">
-          <button className="btn-secondary" onClick={handlePrev} disabled={idx === 0}>Previous</button>
-          {!isAnswered
-            ? <button className="btn-primary" onClick={handleSubmit} disabled={answer === null}>Submit</button>
-            : <button className="btn-primary" onClick={handleNext}>{idx < questions.length - 1 ? 'Next' : 'Finish'}</button>
-          }
-        </div>
-      </div>
+      <QuizActionBar
+        onPrev={quiz.prev}
+        onNext={quiz.next}
+        onSubmit={quiz.submitCurrent}
+        onFinish={quiz.submitAll}
+        canPrev={quiz.state.currentIndex > 0}
+        canNext={!quiz.isLast}
+        canSubmit={quiz.canSubmitCurrent}
+        isLast={quiz.isLast}
+        finishLabel="Finish"
+      />
 
-      <div className="question-progress-bar">
-        <div className="qpb-fill" style={{ width: `${((idx + 1) / questions.length) * 100}%` }} />
-      </div>
+      <QuestionPalette entries={quiz.palette} onJump={quiz.goTo} />
     </div>
   );
 }
diff --git a/frontend/src/pages/app/Dashboard.tsx b/frontend/src/pages/app/Dashboard.tsx
index 5946e27..688e688 100644
--- a/frontend/src/pages/app/Dashboard.tsx
+++ b/frontend/src/pages/app/Dashboard.tsx
@@ -1,6 +1,5 @@
-import { useState, useEffect } from 'react';
 import { Link } from 'react-router-dom';
-import { useUser } from '../../context/UserContext';
+import { useUser } from '../../context/user-context';
 import { getOverallStats, getProgress, getQuizHistory } from '../../services/localData';
 import { useChapters } from '../../hooks/useChapters';
 
@@ -29,16 +28,14 @@ function QuickActionCard({ to, icon, title, description, color }: { to: string;
 export default function Dashboard() {
   const { name } = useUser();
   const firstName = (name || 'Student').split(' ')[0];
-  const [stats, setStats] = useState({ attempted: 0, correct: 0, totalAvailable: 0 });
-  const [recentHistory, setRecentHistory] = useState<{ topicId: string; topicName: string; score: number; total: number; date: string }[]>([]);
   const bookChapters = useChapters();
   const progress = getProgress();
   const topicsStarted = Object.keys(progress).length;
-
-  useEffect(() => {
-    setStats(getOverallStats(bookChapters));
-    setRecentHistory(getQuizHistory().slice(0, 5));
-  }, [bookChapters]);
+  // Read straight through on render. These are synchronous localStorage reads,
+  // and holding them in state behind an effect left the dashboard showing
+  // stale figures until the component happened to remount.
+  const stats = getOverallStats(bookChapters);
+  const recentHistory = getQuizHistory().slice(0, 5);
 
   const accuracy = stats.attempted > 0 ? Math.round((stats.correct / stats.attempted) * 100) : 0;
 
@@ -46,7 +43,7 @@ export default function Dashboard() {
     <div className="dashboard-page">
       <section className="dashboard-welcome">
         <div className="welcome-text">
-          <h1>Welcome back, {firstName}! ??</h1>
+          <h1>Welcome back, {firstName}</h1>
           <p>Continue your engineering license exam preparation</p>
         </div>
         <div className="welcome-date">
diff --git a/frontend/src/pages/app/Flashcards.tsx b/frontend/src/pages/app/Flashcards.tsx
index 834f553..4425590 100644
--- a/frontend/src/pages/app/Flashcards.tsx
+++ b/frontend/src/pages/app/Flashcards.tsx
@@ -36,18 +36,31 @@ export default function Flashcards() {
   const [flashcards, setFlashcards] = useState<Flashcard[]>([]);
   const [loading, setLoading] = useState(false);
 
-  useEffect(() => {
-    if (!selectedChapter) {
-      setFlashcards([]);
-      return;
-    }
-    setLoading(true);
+  // Reset when the chosen chapter changes, during render rather than in an
+  // effect (which caused a cascading render).
+  const [activeChapter, setActiveChapter] = useState(selectedChapter);
+  if (activeChapter !== selectedChapter) {
+    setActiveChapter(selectedChapter);
     setCurrentIndex(0);
     setIsFlipped(false);
-    loadTopicQuestions(selectedChapter).then(questions => {
-      setFlashcards(shuffle(questionsToFlashcards(questions)));
-      setLoading(false);
-    });
+    setFlashcards([]);
+    setLoading(Boolean(selectedChapter));
+  }
+
+  useEffect(() => {
+    if (!selectedChapter) return;
+    let cancelled = false;
+
+    loadTopicQuestions(selectedChapter)
+      .then((questions) => {
+        if (cancelled) return;
+        setFlashcards(shuffle(questionsToFlashcards(questions)));
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+
+    return () => { cancelled = true; };
   }, [selectedChapter]);
 
   const currentCard = flashcards[currentIndex];
diff --git a/frontend/src/pages/app/MockTestQuiz.tsx b/frontend/src/pages/app/MockTestQuiz.tsx
index dfb83d0..26887f9 100644
--- a/frontend/src/pages/app/MockTestQuiz.tsx
+++ b/frontend/src/pages/app/MockTestQuiz.tsx
@@ -1,144 +1,143 @@
-import { useParams, Link, useNavigate } from 'react-router-dom';
-import { useState, useEffect, useRef } from 'react';
+/**
+ * MockTestQuiz — a full timed paper.
+ *
+ * Hosts the shared quiz engine; see TopicPractice for why all four quiz pages
+ * went from four copies of the state machine to one. Three things change for
+ * this page specifically:
+ *
+ *  1. Feedback is DEFERRED. Nothing is revealed until the whole paper is
+ *     submitted, which is what `mode: 'mock'` selects by default.
+ *
+ *  2. It is TIMED against an absolute deadline, so closing the tab does not
+ *     pause the clock and a refresh does not hand back a fresh timer. The
+ *     engine auto-submits on expiry with whatever was answered.
+ *
+ *  3. There is a PRE-SUBMIT REVIEW SCREEN. The old page submitted straight off
+ *     the last page with no warning and no count of what was left blank.
+ *
+ * The 10-questions-per-page layout is gone. The engine tracks one current
+ * index, so a paginated host would have to call `goTo` on every card
+ * interaction or every question's elapsed time would land on whichever index
+ * happened to be current. One question at a time plus the numbered palette is
+ * also closer to the real NEC computer-based test.
+ */
+
+import { useCallback } from 'react';
+import { Link, useNavigate, useParams } from 'react-router-dom';
+import {
+  useQuiz,
+  useQuizKeyboard,
+  QuestionCard,
+  QuestionPalette,
+  QuizActionBar,
+  QuizToolbar,
+  ResultSummary,
+  ReviewScreen,
+  ExplanationPanel,
+} from '../../features/quiz';
 import {
   getMockTestById,
   loadQuestionsSlice,
-  recordAttempt,
   saveQuizResult,
 } from '../../services/localData';
-import type { Question } from '../../services/localData';
+import type { Question, QuizSummary } from '../../features/quiz';
+import { fisherYates } from '../../services/optionOrdering';
 import { useChapters } from '../../hooks/useChapters';
-
-const PAGE_SIZE = 10;
-
-function fmt(s: number) {
-  return `${String(Math.floor(s / 60)).padStart(2, '0')}:${String(s % 60).padStart(2, '0')}`;
-}
-
-function shuffle<T>(arr: T[]): T[] {
-  const a = [...arr];
-  for (let i = a.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [a[i], a[j]] = [a[j], a[i]];
-  }
-  return a;
-}
+import { describeReference } from '../../services/questionReference';
 
 export default function MockTestQuiz() {
   const { testId } = useParams<{ testId: string }>();
   const navigate = useNavigate();
-  const bookChapters = useChapters();
+  const chapters = useChapters();
   const test = testId ? getMockTestById(testId) : null;
-  const qPerChapter = test?.questionsPerChapter ?? 10;
-
-  // ── Loading ────────────────────────────────────────────────────────────────
-  const [questions, setQuestions] = useState<Question[]>([]);
-  const [loading, setLoading]     = useState(true);
-  const [loadErr, setLoadErr]     = useState<string | null>(null);
-
-  useEffect(() => {
-    if (!test || bookChapters.length === 0) return;
-    Promise.all(bookChapters.map(ch => loadQuestionsSlice(ch.id, qPerChapter)))
-      .then(results => {
-        const combined: Question[] = [];
-        for (const chQs of results) combined.push(...chQs);
-        if (combined.length === 0) {
-          setLoadErr('No questions found. Check that chapter files are available.');
-        } else {
-          setQuestions(shuffle(combined));
-        }
-      })
-      .catch(() => setLoadErr('Failed to load questions. Please try again.'))
-      .finally(() => setLoading(false));
-  }, []); // eslint-disable-line react-hooks/exhaustive-deps
-
-  // ── Quiz state ─────────────────────────────────────────────────────────────
-  // answers[i] = chosen option index (0-based), null if unanswered. Editable anytime before submit.
-  const [answers, setAnswers]   = useState<(number | null)[]>([]);
-  const [page, setPage]         = useState(0);
-  const [done, setDone]         = useState(false);
-  const [finalScore, setFinalScore] = useState(0);
-
-  useEffect(() => {
-    if (questions.length > 0) setAnswers(new Array(questions.length).fill(null));
-  }, [questions.length]);
-
-  // ── Timer ──────────────────────────────────────────────────────────────────
-  const [timeLeft, setTimeLeft] = useState((test?.duration ?? 45) * 60);
-  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const perChapter = test?.questionsPerChapter ?? 10;
 
-  useEffect(() => {
-    if (loading || questions.length === 0 || done) return;
-    timerRef.current = setInterval(() => setTimeLeft(t => Math.max(0, t - 1)), 1000);
-    return () => clearInterval(timerRef.current!);
-  }, [loading, questions.length, done]);
-
-  // Auto-submit when timer hits zero
-  const savedRef = useRef(false);
-  useEffect(() => {
-    if (timeLeft === 0 && !done && questions.length > 0 && !savedRef.current) {
-      doSubmit(answers);
+  const loadQuestions = useCallback(async (): Promise<Question[]> => {
+    const results = await Promise.all(
+      chapters.map((chapter) => loadQuestionsSlice(chapter.id, perChapter))
+    );
+    const combined = fisherYates(results.flat());
+    if (combined.length === 0) {
+      throw new Error('No questions found. Check that chapter files are available.');
     }
-  }, [timeLeft]); // eslint-disable-line react-hooks/exhaustive-deps
+    return combined;
+  }, [chapters, perChapter]);
 
-  // ── Submit ─────────────────────────────────────────────────────────────────
-  const doSubmit = (currentAnswers: (number | null)[]) => {
-    if (savedRef.current) return;
-    savedRef.current = true;
-    clearInterval(timerRef.current!);
-    let score = 0;
-    questions.forEach((q, i) => {
-      const sel = currentAnswers[i];
-      const correct = sel !== null && sel === q.correctIndex;
-      if (correct) score++;
-      if (sel !== null) recordAttempt(q.id, q.topicId, correct);
-    });
-    setFinalScore(score);
-    saveQuizResult({
-      topicId:   test!.id,
-      topicName: test!.name,
-      score,
-      total:     questions.length,
-      date:      new Date().toISOString(),
-    });
-    setDone(true);
-  };
+  const onComplete = useCallback(
+    (summary: QuizSummary) => {
+      if (!test) return;
+      saveQuizResult({
+        topicId: test.id,
+        topicName: test.name,
+        score: summary.score,
+        total: summary.total,
+        date: new Date().toISOString(),
+      });
+    },
+    [test]
+  );
 
-  // ── Pagination helpers ─────────────────────────────────────────────────────
-  const totalPages   = Math.max(1, Math.ceil(questions.length / PAGE_SIZE));
-  const pageStart    = page * PAGE_SIZE;
-  const pageQs       = questions.slice(pageStart, pageStart + PAGE_SIZE);
-  const answeredCount = answers.filter(a => a !== null).length;
-  const isLowTime    = timeLeft < 60;
+  const quiz = useQuiz({
+    mode: 'mock',
+    attemptKey: test ? `mock:${test.id}` : null,
+    // Duration comes from the mock-test config, which reads it from
+    // examBlueprint — 120 minutes, confirmed by the project owner.
+    durationMs: test ? test.duration * 60_000 : null,
+    // Migrates an in-flight attempt saved by the pre-engine page rather than
+    // destroying someone's part-finished exam on deploy.
+    legacyMockTestId: test?.id,
+    loadQuestions,
+    enabled: Boolean(test) && chapters.length > 0,
+    onComplete,
+  });
 
-  // ── Guard renders ──────────────────────────────────────────────────────────
-  if (!test) return (
-    <div className="topic-not-found">
-      <h2>Test not found</h2>
-      <Link to="/app/mock-tests" className="btn-primary">Back to Mock Tests</Link>
-    </div>
-  );
+  useQuizKeyboard({
+    optionCount: quiz.current?.options.length ?? 0,
+    onSelectOption: quiz.selectOption,
+    onSubmitOrAdvance: quiz.submitOrAdvance,
+    onPrev: quiz.prev,
+    onNext: quiz.next,
+    onToggleFlag: quiz.toggleFlag,
+    onToggleBookmark: quiz.toggleBookmark,
+    enabled: quiz.state.phase === 'active',
+  });
 
-  if (loading) return (
-    <div className="loading-container">
-      <div className="loading-spinner" />
-      <p>Loading {bookChapters.length} chapters &times; {qPerChapter} questions…</p>
-    </div>
-  );
+  if (!test) {
+    return (
+      <div className="topic-not-found">
+        <h2>Test not found</h2>
+        <Link to="/app/mock-tests" className="btn-primary">
+          Back to Mock Tests
+        </Link>
+      </div>
+    );
+  }
 
-  if (loadErr) return (
-    <div className="topic-not-found">
-      <h2>{loadErr}</h2>
-      <Link to="/app/mock-tests" className="btn-primary">Back to Mock Tests</Link>
-    </div>
-  );
+  if (quiz.state.phase === 'loading') {
+    return (
+      <div className="loading-container" role="status" aria-live="polite">
+        <div className="loading-spinner" />
+        <p>
+          Loading {chapters.length} chapters &times; {perChapter} questions…
+        </p>
+      </div>
+    );
+  }
 
-  // ── Results screen ─────────────────────────────────────────────────────────
-  if (done) {
-    const pct      = Math.round((finalScore / questions.length) * 100);
-    const skipped  = answers.filter(a => a === null).length;
-    const wrong    = questions.length - finalScore - skipped;
+  if (quiz.error) {
+    return (
+      <div className="topic-not-found">
+        <h2>{quiz.error}</h2>
+        <Link to="/app/mock-tests" className="btn-primary">
+          Back to Mock Tests
+        </Link>
+      </div>
+    );
+  }
 
+  // ── Results ────────────────────────────────────────────────────────────────
+  if (quiz.state.phase === 'done') {
+    const { questions, selections } = quiz.state;
     return (
       <div className="mock-results-page">
         <nav className="breadcrumb" aria-label="Breadcrumb">
@@ -147,35 +146,38 @@ export default function MockTestQuiz() {
           <span className="current">{test.name} — Results</span>
         </nav>
 
-        <div className="results-summary-card">
-          <div className="complete-icon">{pct >= 60 ? '🎉' : '📚'}</div>
-          <h2>Test Complete!</h2>
-          <p className="complete-topic">{test.name}</p>
-          <div className="complete-score">
-            <span className="score-number">{finalScore}</span>
-            <span className="score-total">/ {questions.length}</span>
-          </div>
-          <p className="complete-pct">{pct}% accuracy</p>
-          <div className="results-stats-row">
-            <div className="rs-stat correct"><span>{finalScore}</span>Correct</div>
-            <div className="rs-stat incorrect"><span>{wrong}</span>Incorrect</div>
-            <div className="rs-stat skipped"><span>{skipped}</span>Skipped</div>
-          </div>
-          <div className="complete-actions">
-            <button className="btn-primary" onClick={() => navigate(`/app/mock-tests/${test.id}`)}>
-              Try Again
-            </button>
-            <Link to="/app/mock-tests" className="btn-secondary">All Tests</Link>
-          </div>
-        </div>
+        <ResultSummary
+          summary={quiz.summary}
+          title={test.name}
+          actions={
+            <>
+              <button
+                type="button"
+                className="btn-primary"
+                onClick={() => {
+                  // Clear the finished attempt's draft so returning to the
+                  // detail page starts a genuinely new paper rather than
+                  // resuming a completed one.
+                  quiz.discardDraft();
+                  navigate(`/app/mock-tests/${test.id}`);
+                }}
+              >
+                Try Again
+              </button>
+              <Link to="/app/mock-tests" className="btn-secondary">
+                All Tests
+              </Link>
+            </>
+          }
+        />
 
         <h3 className="detailed-review-heading">Detailed Review</h3>
         <div className="detailed-review-list">
           {questions.map((q, i) => {
-            const sel       = answers[i];
+            const sel = selections[i];
             const isCorrect = sel !== null && sel === q.correctIndex;
             const isSkipped = sel === null;
-            const status    = isSkipped ? 'skipped' : isCorrect ? 'correct' : 'incorrect';
+            const status = isSkipped ? 'skipped' : isCorrect ? 'correct' : 'incorrect';
             return (
               <div key={q.id} className={`review-card ${status}`}>
                 <div className="review-q-header">
@@ -188,20 +190,29 @@ export default function MockTestQuiz() {
                 <div className="review-options">
                   {q.options.map((opt, oi) => {
                     const isTheCorrect = oi === q.correctIndex;
-                    const isUserWrong  = oi === sel && !isCorrect;
+                    const isUserWrong = oi === sel && !isCorrect;
                     return (
                       <div
                         key={oi}
-                        className={`review-opt ${isTheCorrect ? 'review-opt-correct' : isUserWrong ? 'review-opt-wrong' : ''}`}
+                        className={`review-opt ${
+                          isTheCorrect
+                            ? 'review-opt-correct'
+                            : isUserWrong
+                              ? 'review-opt-wrong'
+                              : ''
+                        }`}
                       >
                         <span className="review-opt-letter">{String.fromCharCode(65 + oi)}</span>
                         <span className="review-opt-text">{opt}</span>
                         {isTheCorrect && <span className="review-opt-tag correct">✓ Correct</span>}
-                        {isUserWrong  && <span className="review-opt-tag wrong">✗ Your answer</span>}
+                        {isUserWrong && <span className="review-opt-tag wrong">✗ Your answer</span>}
                       </div>
                     );
                   })}
                 </div>
+                {/* Post-exam review is the one place in a mock where an
+                    explanation may appear — context is 'review', not 'exam'. */}
+                <ExplanationPanel context="review" reference={describeReference(q)} />
               </div>
             );
           })}
@@ -210,7 +221,29 @@ export default function MockTestQuiz() {
     );
   }
 
-  // ── Quiz screen — paginated ────────────────────────────────────────────────
+  // ── Pre-submit review ──────────────────────────────────────────────────────
+  if (quiz.state.phase === 'review') {
+    return (
+      <div className="mock-quiz-page">
+        <ReviewScreen
+          total={quiz.counts.total}
+          answered={quiz.counts.answered}
+          unanswered={quiz.counts.unanswered}
+          flagged={quiz.counts.flagged}
+          unansweredIndices={quiz.unansweredIndices}
+          flaggedIndices={quiz.palette.filter((p) => p.flagged).map((p) => p.index)}
+          entries={quiz.palette}
+          onJump={quiz.goTo}
+          onBack={quiz.exitReview}
+          onSubmit={quiz.submitAll}
+        />
+      </div>
+    );
+  }
+
+  const current = quiz.current;
+  if (!current) return null;
+
   return (
     <div className="mock-quiz-page">
       <nav className="breadcrumb" aria-label="Breadcrumb">
@@ -219,92 +252,52 @@ export default function MockTestQuiz() {
         <span className="current">{test.name}</span>
       </nav>
 
-      <header className="mock-quiz-header">
-        <div className="quiz-header-info">
-          <h1>{test.name}</h1>
-          <p className="quiz-meta">
-            Page {page + 1} of {totalPages}&nbsp;&nbsp;·&nbsp;&nbsp;{answeredCount} / {questions.length} answered
-          </p>
-        </div>
-        <div className={`quiz-timer ${isLowTime ? 'low' : ''}`}>
-          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-            <circle cx="12" cy="12" r="10" />
-            <polyline points="12 6 12 12 16 14" />
-          </svg>
-          {fmt(timeLeft)}
+      {quiz.state.resumed && (
+        <div className="mock-resume-notice" role="status">
+          Attempt resumed — your answers and the original deadline were restored.
         </div>
-      </header>
+      )}
 
-      <div className="mock-questions-list">
-        {pageQs.map((q, localIdx) => {
-          const globalIdx = pageStart + localIdx;
-          const sel       = answers[globalIdx] ?? null;
-          return (
-            <div key={q.id} className="mock-question-card">
-              <div className="mock-q-header">
-                <span className="mock-q-num">Question {globalIdx + 1}</span>
-                {sel !== null && <span className="mock-q-answered-badge">Answered</span>}
-              </div>
-              <p className="mock-q-text">{q.question}</p>
-              <div className="mock-options" role="radiogroup" aria-label={`Options for question ${globalIdx + 1}`}>
-                {q.options.map((opt, oi) => (
-                  <button
-                    key={oi}
-                    className={`mock-opt-btn ${sel === oi ? 'selected' : ''}`}
-                    onClick={() => {
-                      const next = [...answers];
-                      next[globalIdx] = oi;
-                      setAnswers(next);
-                    }}
-                    role="radio"
-                    aria-checked={sel === oi}
-                  >
-                    <span className="option-letter">{String.fromCharCode(65 + oi)}</span>
-                    <span className="option-text">{opt}</span>
-                  </button>
-                ))}
-              </div>
-            </div>
-          );
-        })}
-      </div>
+      <QuizToolbar
+        index={quiz.state.currentIndex}
+        total={quiz.counts.total}
+        answered={quiz.counts.answered}
+        timeLeftMs={quiz.timeLeftMs}
+        flagged={quiz.isFlagged}
+        onToggleFlag={() => quiz.toggleFlag()}
+        bookmarked={quiz.isBookmarked}
+        onToggleBookmark={() => quiz.toggleBookmark()}
+      />
 
-      <div className="mock-page-nav">
-        <button
-          className="btn-secondary"
-          onClick={() => setPage(p => p - 1)}
-          disabled={page === 0}
-        >
-          ← Previous
-        </button>
+      <QuestionCard
+        index={quiz.state.currentIndex}
+        total={quiz.counts.total}
+        questionText={current.question}
+        options={current.options}
+        selection={quiz.selection}
+        onSelect={quiz.selectOption}
+        correctIndex={current.correctIndex}
+        // Deferred feedback: nothing is revealed mid-paper, and the engine
+        // enforces that rather than trusting this prop.
+        revealed={quiz.isRevealed}
+        verdict={quiz.verdict}
+      />
 
-        <div className="mock-page-dots">
-          {Array.from({ length: totalPages }, (_, i) => {
-            const start      = i * PAGE_SIZE;
-            const pageAll    = questions.slice(start, start + PAGE_SIZE);
-            const allDone    = pageAll.length > 0 && pageAll.every((_, li) => answers[start + li] !== null);
-            return (
-              <button
-                key={i}
-                className={`page-dot ${page === i ? 'active' : ''} ${allDone ? 'done' : ''}`}
-                onClick={() => setPage(i)}
-                title={`Page ${i + 1}`}
-                aria-label={`Go to page ${i + 1}`}
-              />
-            );
-          })}
-        </div>
+      <QuizActionBar
+        onPrev={quiz.prev}
+        onNext={quiz.next}
+        // No per-question submit in a mock — answers stay editable until the
+        // whole paper goes in. The last question's primary action opens the
+        // review screen instead of submitting blind.
+        onFinish={quiz.enterReview}
+        canPrev={quiz.state.currentIndex > 0}
+        canNext={!quiz.isLast}
+        canSubmit={false}
+        isLast={quiz.isLast}
+        finishLabel="Review & submit"
+      />
 
-        {page < totalPages - 1 ? (
-          <button className="btn-primary" onClick={() => setPage(p => p + 1)}>
-            Next →
-          </button>
-        ) : (
-          <button className="btn-submit" onClick={() => doSubmit(answers)}>
-            Submit Test
-          </button>
-        )}
-      </div>
+      <QuestionPalette entries={quiz.palette} onJump={quiz.goTo} />
     </div>
   );
 }
diff --git a/frontend/src/pages/app/MockTests.tsx b/frontend/src/pages/app/MockTests.tsx
index 7f508cb..3b20c85 100644
--- a/frontend/src/pages/app/MockTests.tsx
+++ b/frontend/src/pages/app/MockTests.tsx
@@ -6,7 +6,6 @@ export default function MockTests() {
   const mockTests = allMockTests;
   const bookChapters = useChapters();
   const attempts = getQuizHistory();
-  const loading = false;
 
   return (
     <div className="mock-tests-page">
@@ -32,7 +31,8 @@ export default function MockTests() {
           <h3>About Mock Tests</h3>
           <p>
             Mock tests simulate the actual exam environment with a fixed number of questions and time limit.
-            Your progress will be saved, and you can review your answers after completing the test.
+            Your answers and the countdown are saved in this browser, so you can safely reload or close the tab
+            and pick the attempt back up. The clock keeps running either way, just like the real exam.
           </p>
         </div>
       </div>
@@ -40,13 +40,7 @@ export default function MockTests() {
       {/* Tests grid */}
       <section className="tests-section">
         <h2>Available Tests</h2>
-        {loading ? (
-          <div className="loading-container">
-            <div className="loading-spinner"></div>
-            <p>Loading tests...</p>
-          </div>
-        ) : (
-          <div className="tests-grid">
+        <div className="tests-grid">
             {mockTests.map((test) => (
               <div key={test.id} className="test-card">
                 <div className="test-header">
@@ -86,7 +80,6 @@ export default function MockTests() {
               </div>
             ))}
           </div>
-        )}
       </section>
 
       {/* Past attempts section */}
diff --git a/frontend/src/pages/app/PracticeHub.module.css b/frontend/src/pages/app/PracticeHub.module.css
new file mode 100644
index 0000000..ae28977
--- /dev/null
+++ b/frontend/src/pages/app/PracticeHub.module.css
@@ -0,0 +1,25 @@
+/* Accessibility styles for the practice hub. CSS Module because App.css is
+ * owned by another workstream.
+ *
+ * Focus ring: #ffffff, 3px, 3px offset.
+ *   #ffffff on --bg-primary #0a0a0f       = 19.75:1
+ *   #ffffff on --bg-card   ~#101018       = 18.93:1
+ * Both above the 3:1 WCAG 1.4.11 minimum.
+ */
+
+.page a:focus-visible,
+.page button:focus-visible,
+.page [tabindex]:focus-visible {
+  outline: 3px solid #ffffff;
+  outline-offset: 3px;
+}
+
+/* The mode cards are now links, so their call-to-action is a non-interactive
+ * span. Keep the `.mode-btn` look without the invalid nested button. */
+.modeCta {
+  display: inline-flex;
+  align-items: center;
+  flex: 0 0 auto;
+  margin-left: auto;
+  white-space: nowrap;
+}
diff --git a/frontend/src/pages/app/PracticeHub.tsx b/frontend/src/pages/app/PracticeHub.tsx
index f2ac853..add002a 100644
--- a/frontend/src/pages/app/PracticeHub.tsx
+++ b/frontend/src/pages/app/PracticeHub.tsx
@@ -1,23 +1,7 @@
-import { Link, useNavigate } from 'react-router-dom';
+import { Link } from 'react-router-dom';
 import { mockTests as allMockTests, getProgress } from '../../services/localData';
 import { useChapters } from '../../hooks/useChapters';
-
-// Loading skeleton component
-function LoadingSkeleton() {
-  return (
-    <div className="loading-skeleton">
-      <div className="skeleton-header">
-        <div className="skeleton-title"></div>
-        <div className="skeleton-subtitle"></div>
-      </div>
-      <div className="skeleton-grid">
-        {[1, 2, 3, 4, 5, 6].map(i => (
-          <div key={i} className="skeleton-card"></div>
-        ))}
-      </div>
-    </div>
-  );
-}
+import styles from './PracticeHub.module.css';
 
 // Topic icon component
 function TopicIcon({ icon, color }: { icon: string; color: string }) {
@@ -121,43 +105,40 @@ function TopicIcon({ icon, color }: { icon: string; color: string }) {
 }
 
 export default function PracticeHub() {
-  const navigate = useNavigate();
   const bookChapters = useChapters();
   const mockTests = allMockTests;
   const progress = getProgress();
   const totalQuestions = bookChapters.reduce((s, t) => s + t.questionCount, 0);
-  const loading = false;
-
-  // Keep the same variable name used in JSX
   const topicProgress = new Map(
     Object.entries(progress).map(([tId, entry]) => [tId, { attempted: entry.attempted.length }])
   );
-  if (loading) {
-    return <LoadingSkeleton />;
-  }
+
+  // The empty state used to be an early return carrying its own <h1>, so the
+  // file declared the page title twice. There is now exactly one h1, shared by
+  // both render paths.
+  const pageHeader = (
+    <header className="page-header">
+      <h1>Practice Questions</h1>
+      <p>
+        {bookChapters.length === 0
+          ? 'No topics found. Please check your database.'
+          : `Test your knowledge with ${totalQuestions.toLocaleString()}+ questions across all topics`}
+      </p>
+    </header>
+  );
 
   if (bookChapters.length === 0) {
-    return (
-      <div className="practice-hub-page">
-        <header className="page-header">
-          <h1>Practice Questions</h1>
-          <p>No topics found. Please check your database.</p>
-        </header>
-      </div>
-    );
+    return <div className={`practice-hub-page ${styles.page}`}>{pageHeader}</div>;
   }
 
   return (
-    <div className="practice-hub-page">
-      {/* Page header */}
-      <header className="page-header">
-        <h1>Practice Questions</h1>
-        <p>Test your knowledge with {totalQuestions.toLocaleString()}+ questions across all topics</p>
-      </header>
+    <div className={`practice-hub-page ${styles.page}`}>
+      {pageHeader}
 
-      {/* Practice modes */}
+      {/* Practice modes. The h2 used to be .sr-only, which left the visible
+          outline jumping h1 -> h3 across the mode cards. */}
       <section className="practice-modes" aria-labelledby="modes-title">
-        <h2 id="modes-title" className="sr-only">Practice Modes</h2>
+        <h2 id="modes-title">Practice Modes</h2>
         <div className="modes-grid">
           <Link to="/app/mock-tests" className="mode-card mode-mock">
             <div className="mode-icon">
@@ -173,7 +154,10 @@ export default function PracticeHub() {
             <span className="mode-badge">{mockTests.length} tests</span>
           </Link>
 
-          <div className="mode-card mode-quick" onClick={() => navigate('/app/practice/quick')} style={{ cursor: 'pointer' }}>
+          {/* Was a <div onClick> with no role, no tabIndex and no key handler,
+              wrapping a nested <button> — unreachable by keyboard and invalid
+              nesting. Now a real link, like the Mock Tests card beside it. */}
+          <Link to="/app/practice/quick" className="mode-card mode-quick">
             <div className="mode-icon">
               <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
                 <polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/>
@@ -183,10 +167,10 @@ export default function PracticeHub() {
               <h3>Quick Practice</h3>
               <p>10 random questions across all topics</p>
             </div>
-            <button className="mode-btn" onClick={e => { e.stopPropagation(); navigate('/app/practice/quick'); }}>Start</button>
-          </div>
+            <span className={`mode-btn ${styles.modeCta}`}>Start</span>
+          </Link>
 
-          <div className="mode-card mode-custom" onClick={() => navigate('/app/practice/custom')} style={{ cursor: 'pointer' }}>
+          <Link to="/app/practice/custom" className="mode-card mode-custom">
             <div className="mode-icon">
               <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
                 <circle cx="12" cy="12" r="3"/>
@@ -197,8 +181,8 @@ export default function PracticeHub() {
               <h3>Custom Practice</h3>
               <p>Choose topics and number of questions</p>
             </div>
-            <button className="mode-btn" onClick={e => { e.stopPropagation(); navigate('/app/practice/custom'); }}>Configure</button>
-          </div>
+            <span className={`mode-btn ${styles.modeCta}`}>Configure</span>
+          </Link>
         </div>
       </section>
 
@@ -209,8 +193,10 @@ export default function PracticeHub() {
         <div className="topics-grid">
           {bookChapters.map((topic) => {
             const stats = topicProgress.get(topic.id);
-            const progress = 0 || 0;
             const questionsAnswered = stats?.attempted || 0;
+            const chapterProgress = topic.questionCount > 0
+              ? Math.min(100, (questionsAnswered / topic.questionCount) * 100)
+              : 0;
             const isAvailable = topic.questionCount > 0;
             
             return (
@@ -229,7 +215,7 @@ export default function PracticeHub() {
                         <span className="question-count">{topic.questionCount} questions</span>
                         {questionsAnswered > 0 && (
                           <span className="progress-badge" style={{ color: topic.color || '#6366f1' }}>
-                            {Math.round(progress)}% complete
+                            {Math.round(chapterProgress)}% complete
                           </span>
                         )}
                       </>
@@ -241,7 +227,7 @@ export default function PracticeHub() {
                     <div className="progress-bar-container">
                       <div 
                         className="progress-bar-fill" 
-                        style={{ width: `${progress}%`, backgroundColor: topic.color || '#6366f1' }}
+                        style={{ width: `${chapterProgress}%`, backgroundColor: topic.color || '#6366f1' }}
                       />
                     </div>
                   )}
diff --git a/frontend/src/pages/app/Profile.tsx b/frontend/src/pages/app/Profile.tsx
index e522a6b..7a68487 100644
--- a/frontend/src/pages/app/Profile.tsx
+++ b/frontend/src/pages/app/Profile.tsx
@@ -1,4 +1,4 @@
-import { useUser } from '../../context/UserContext';
+import { useUser } from '../../context/user-context';
 import { getOverallStats } from '../../services/localData';
 
 export default function Profile() {
diff --git a/frontend/src/pages/app/QuickPractice.tsx b/frontend/src/pages/app/QuickPractice.tsx
index e351401..0f8d6b2 100644
--- a/frontend/src/pages/app/QuickPractice.tsx
+++ b/frontend/src/pages/app/QuickPractice.tsx
@@ -1,162 +1,129 @@
+/**
+ * QuickPractice — a short mixed set drawn from every chapter.
+ *
+ * Hosts the shared quiz engine; see TopicPractice for why all four quiz pages
+ * went from four copies of the state machine to one.
+ */
+
+import { useCallback } from 'react';
 import { Link, useSearchParams } from 'react-router-dom';
-import { useState, useEffect, useCallback } from 'react';
 import {
-  loadQuestionsSlice,
-  recordAttempt,
-  addBookmark,
-  removeBookmark,
-  isBookmarked,
-  saveQuizResult,
-} from '../../services/localData';
-import type { Question } from '../../services/localData';
-
+  useQuiz,
+  useQuizKeyboard,
+  QuestionCard,
+  QuestionPalette,
+  QuizActionBar,
+  QuizToolbar,
+  ResultSummary,
+  ExplanationPanel,
+} from '../../features/quiz';
+import { loadQuestionsSlice, saveQuizResult } from '../../services/localData';
+import type { Question, QuizSummary } from '../../features/quiz';
+import { fisherYates } from '../../services/optionOrdering';
 import { useChapters } from '../../hooks/useChapters';
-
-function shuffle<T>(arr: T[]): T[] {
-  const a = [...arr];
-  for (let i = a.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [a[i], a[j]] = [a[j], a[i]];
-  }
-  return a;
-}
+import { describeReference } from '../../services/questionReference';
 
 export default function QuickPractice() {
-  const ALL_SOURCES = useChapters();
+  const chapters = useChapters();
   const [searchParams] = useSearchParams();
   const count = Math.min(50, Math.max(5, parseInt(searchParams.get('count') || '10', 10)));
 
-  const [questions, setQuestions] = useState<Question[]>([]);
-  const [loading, setLoading]     = useState(true);
-  const [error, setError]         = useState<string | null>(null);
-
-  const [idx, setIdx]             = useState(0);
-  const [selected, setSelected]   = useState<number | null>(null);
-  const [revealed, setRevealed]   = useState(false);
-  const [score, setScore]         = useState(0);
-  const [answered, setAnswered]   = useState<Set<number>>(new Set());
-  const [bookmarkedIds, setBookmarkedIds] = useState<Set<string>>(new Set());
-  const [done, setDone]           = useState(false);
-
-  useEffect(() => {
-    if (ALL_SOURCES.length === 0) return;
-    const perTopic = Math.max(1, Math.ceil(count / ALL_SOURCES.length));
-    Promise.all(ALL_SOURCES.map(s => loadQuestionsSlice(s.id, perTopic)))
-      .then(results => {
-        const combined = shuffle(results.flat()).slice(0, count);
-        if (combined.length === 0) setError('No questions available.');
-        else setQuestions(combined);
-      })
-      .catch(() => setError('Failed to load questions. Please try again.'))
-      .finally(() => setLoading(false));
-  }, [ALL_SOURCES.length]);
-
-  useEffect(() => {
-    if (questions.length === 0) return;
-    const id = questions[idx]?.id;
-    if (id && isBookmarked(id)) setBookmarkedIds(p => new Set(p).add(id));
-  }, [idx, questions]);
-
-  const handleSelect = (i: number) => {
-    if (answered.has(idx)) return;
-    setSelected(i);
-  };
-
-  const handleSubmit = useCallback(() => {
-    if (selected === null || answered.has(idx)) return;
-    const q = questions[idx];
-    const hasAnswer = q.correctIndex >= 0;
-    const correct = hasAnswer && selected === q.correctIndex;
-    setRevealed(true);
-    setAnswered(p => new Set(p).add(idx));
-    if (correct) setScore(s => s + 1);
-    if (hasAnswer) recordAttempt(q.id, q.topicId, correct);
-  }, [selected, idx, answered, questions]);
-
-  const handleToggleBookmark = () => {
-    const id = questions[idx]?.id;
-    if (!id) return;
-    if (bookmarkedIds.has(id)) {
-      removeBookmark(id);
-      setBookmarkedIds(p => { const n = new Set(p); n.delete(id); return n; });
-    } else {
-      addBookmark(id);
-      setBookmarkedIds(p => new Set(p).add(id));
-    }
-  };
-
-  const handleNext = () => {
-    if (idx < questions.length - 1) {
-      setIdx(i => i + 1);
-      setSelected(null);
-      setRevealed(false);
-    } else if (answered.has(idx)) {
-      saveQuizResult({
-        topicId:   'quick-practice',
-        topicName: 'Quick Practice',
-        score,
-        total:     questions.length,
-        date:      new Date().toISOString(),
-      });
-      setDone(true);
-    }
-  };
+  // The chapter manifest is static, so an empty list means a broken build
+  // rather than a transient state — surfaced as a render guard below.
+  const noSources = chapters.length === 0;
 
-  const handlePrev = () => {
-    if (idx > 0) {
-      setIdx(i => i - 1);
-      setSelected(null);
-      setRevealed(answered.has(idx - 1));
-    }
-  };
-
-  const optClass = (i: number) => {
-    if (!revealed) return selected === i ? 'selected' : '';
-    const q = questions[idx];
-    if (q.correctIndex < 0) return selected === i ? 'selected' : '';
-    if (i === q.correctIndex) return 'correct';
-    if (selected === i) return 'incorrect';
-    return '';
-  };
+  const loadQuestions = useCallback(async (): Promise<Question[]> => {
+    const perChapter = Math.max(1, Math.ceil(count / chapters.length));
+    const results = await Promise.all(
+      chapters.map((chapter) => loadQuestionsSlice(chapter.id, perChapter))
+    );
+    return fisherYates(results.flat()).slice(0, count);
+  }, [chapters, count]);
+
+  const onComplete = useCallback((summary: QuizSummary) => {
+    saveQuizResult({
+      topicId: 'quick-practice',
+      topicName: 'Quick Practice',
+      score: summary.score,
+      total: summary.total,
+      date: new Date().toISOString(),
+    });
+  }, []);
+
+  const quiz = useQuiz({
+    mode: 'quick',
+    attemptKey: `quick:${count}`,
+    loadQuestions,
+    enabled: !noSources,
+    onComplete,
+  });
+
+  useQuizKeyboard({
+    optionCount: quiz.current?.options.length ?? 0,
+    onSelectOption: quiz.selectOption,
+    onSubmitOrAdvance: quiz.submitOrAdvance,
+    onPrev: quiz.prev,
+    onNext: quiz.next,
+    onToggleFlag: quiz.toggleFlag,
+    onToggleBookmark: quiz.toggleBookmark,
+    enabled: quiz.state.phase === 'active',
+  });
+
+  if (noSources) {
+    return (
+      <div className="topic-not-found">
+        <h2>No question sources available</h2>
+        <p>The chapter manifest is empty. Try rebuilding the app.</p>
+        <Link to="/app/practice" className="btn-primary">
+          Back to Practice
+        </Link>
+      </div>
+    );
+  }
 
-  if (loading) return (
-    <div className="loading-container">
-      <div className="loading-spinner" />
-      <p>Picking {count} random questions…</p>
-    </div>
-  );
+  if (quiz.state.phase === 'loading') {
+    return (
+      <div className="loading-container" role="status" aria-live="polite">
+        <div className="loading-spinner" />
+        <p>Picking {count} random questions…</p>
+      </div>
+    );
+  }
 
-  if (error) return (
-    <div className="topic-not-found">
-      <h2>{error}</h2>
-      <Link to="/app/practice" className="btn-primary">Back to Practice</Link>
-    </div>
-  );
+  if (quiz.error) {
+    return (
+      <div className="topic-not-found">
+        <h2>{quiz.error}</h2>
+        <Link to="/app/practice" className="btn-primary">
+          Back to Practice
+        </Link>
+      </div>
+    );
+  }
 
-  if (done) {
-    const pct = Math.round((score / questions.length) * 100);
+  if (quiz.state.phase === 'done') {
     return (
       <div className="quiz-complete">
-        <div className="quiz-complete-card">
-          <div className="complete-icon">{pct >= 60 ? '🎉' : '📚'}</div>
-          <h2>Quick Practice Done!</h2>
-          <div className="complete-score">
-            <span className="score-number">{score}</span>
-            <span className="score-total">/ {questions.length}</span>
-          </div>
-          <p className="complete-pct">{pct}% accuracy</p>
-          <div className="complete-actions">
-            <Link to="/app/practice/quick" className="btn-primary">Try Again</Link>
-            <Link to="/app/practice" className="btn-secondary">Back to Practice</Link>
-          </div>
-        </div>
+        <ResultSummary
+          summary={quiz.summary}
+          title="Quick Practice"
+          actions={
+            <>
+              <Link to="/app/practice/quick" className="btn-primary" reloadDocument>
+                Another {count}
+              </Link>
+              <Link to="/app/practice" className="btn-secondary">
+                Back to Practice
+              </Link>
+            </>
+          }
+        />
       </div>
     );
   }
 
-  const q = questions[idx];
-  const isAnswered = answered.has(idx);
-  const isCurrentBookmarked = bookmarkedIds.has(q.id);
+  const current = quiz.current;
+  if (!current) return null;
 
   return (
     <div className="topic-practice-page">
@@ -166,92 +133,52 @@ export default function QuickPractice() {
         <span className="current">Quick Practice</span>
       </nav>
 
-      <header className="topic-header">
-        <div className="topic-info">
-          <h1>Quick Practice</h1>
-          <p>Random questions across all topics</p>
-        </div>
-        <div className="topic-stats">
-          <div className="stat">
-            <span className="value">{idx + 1}/{questions.length}</span>
-            <span className="label">Question</span>
-          </div>
-          <div className="stat">
-            <span className="value">{score}</span>
-            <span className="label">Correct</span>
-          </div>
-          <div className="stat">
-            <span className="value">{answered.size > 0 ? Math.round((score / answered.size) * 100) : 0}%</span>
-            <span className="label">Accuracy</span>
-          </div>
-        </div>
-      </header>
-
-      <div className="question-card">
-        <div className="question-header">
-          <div className="question-number">Question {idx + 1}</div>
-          <button
-            className={`bookmark-btn ${isCurrentBookmarked ? 'bookmarked' : ''}`}
-            onClick={handleToggleBookmark}
-            title={isCurrentBookmarked ? 'Remove bookmark' : 'Add bookmark'}
-          >
-            <svg viewBox="0 0 24 24" fill={isCurrentBookmarked ? 'currentColor' : 'none'} stroke="currentColor" strokeWidth="2">
-              <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"/>
-            </svg>
-          </button>
-        </div>
-
-        <h2 className="question-text">{q.question}</h2>
-
-        <div className="options-list" role="radiogroup" aria-label="Answer options">
-          {q.options.map((opt, i) => (
-            <button
-              key={i}
-              className={`option-btn ${optClass(i)}`}
-              onClick={() => handleSelect(i)}
-              disabled={isAnswered}
-              role="radio"
-              aria-checked={selected === i}
-            >
-              <span className="option-letter">{String.fromCharCode(65 + i)}</span>
-              <span className="option-text">{opt}</span>
-              {revealed && i === q.correctIndex && q.correctIndex >= 0 && (
-                <svg className="result-icon correct" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                  <polyline points="20 6 9 17 4 12"/>
-                </svg>
-              )}
-              {revealed && selected === i && i !== q.correctIndex && (
-                <svg className="result-icon incorrect" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                  <line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/>
-                </svg>
-              )}
-            </button>
-          ))}
+      {quiz.state.resumed && (
+        <div className="mock-resume-notice" role="status">
+          Attempt resumed — your answers were restored.
         </div>
-
-        {revealed && (
-          <div className={`result-message ${q.correctIndex >= 0 ? (selected === q.correctIndex ? 'correct' : 'incorrect') : 'selected'}`}>
-            {q.correctIndex < 0
-              ? <p>Answer recorded. No answer key available for this topic yet.</p>
-              : selected === q.correctIndex
-                ? <p>Correct! Well done.</p>
-                : <p>Incorrect. Correct answer: <strong>{String.fromCharCode(65 + q.correctIndex)}</strong></p>
-            }
-          </div>
+      )}
+
+      <QuizToolbar
+        index={quiz.state.currentIndex}
+        total={quiz.counts.total}
+        answered={quiz.counts.answered}
+        flagged={quiz.isFlagged}
+        onToggleFlag={() => quiz.toggleFlag()}
+        bookmarked={quiz.isBookmarked}
+        onToggleBookmark={() => quiz.toggleBookmark()}
+      />
+
+      <QuestionCard
+        index={quiz.state.currentIndex}
+        total={quiz.counts.total}
+        questionText={current.question}
+        options={current.options}
+        selection={quiz.selection}
+        onSelect={quiz.selectOption}
+        correctIndex={current.correctIndex}
+        revealed={quiz.isRevealed}
+        verdict={quiz.verdict}
+        locked={quiz.isSubmitted}
+      >
+        {quiz.isRevealed && (
+          <ExplanationPanel context="practice" reference={describeReference(current)} />
         )}
-
-        <div className="question-actions">
-          <button className="btn-secondary" onClick={handlePrev} disabled={idx === 0}>Previous</button>
-          {!isAnswered
-            ? <button className="btn-primary" onClick={handleSubmit} disabled={selected === null}>Submit</button>
-            : <button className="btn-primary" onClick={handleNext}>{idx < questions.length - 1 ? 'Next' : 'Finish'}</button>
-          }
-        </div>
-      </div>
-
-      <div className="question-progress-bar">
-        <div className="qpb-fill" style={{ width: `${((idx + 1) / questions.length) * 100}%` }} />
-      </div>
+      </QuestionCard>
+
+      <QuizActionBar
+        onPrev={quiz.prev}
+        onNext={quiz.next}
+        onSubmit={quiz.submitCurrent}
+        onFinish={quiz.submitAll}
+        canPrev={quiz.state.currentIndex > 0}
+        canNext={!quiz.isLast}
+        canSubmit={quiz.canSubmitCurrent}
+        isLast={quiz.isLast}
+        finishLabel="Finish"
+      />
+
+      <QuestionPalette entries={quiz.palette} onJump={quiz.goTo} />
     </div>
   );
 }
diff --git a/frontend/src/pages/app/Settings.tsx b/frontend/src/pages/app/Settings.tsx
index 94082e5..15203ca 100644
--- a/frontend/src/pages/app/Settings.tsx
+++ b/frontend/src/pages/app/Settings.tsx
@@ -1,33 +1,37 @@
-import { useState } from 'react';
 import { useNavigate } from 'react-router-dom';
-import { useUser } from '../../context/UserContext';
-import { clearAllData } from '../../services/localData';
+import { useUser } from '../../context/user-context';
+import { clearAllData, exportAllData } from '../../services/localData';
+
+const REPO_URL = 'https://github.com/SamirWagle/EngineeringLisenseProject';
 
 export default function Settings() {
-  const { name } = useUser();
+  const { name, setName } = useUser();
   const navigate = useNavigate();
 
-  // Settings state
-  const [settings, setSettings] = useState({
-    emailNotifications: true,
-    darkMode: true,
-    soundEffects: false,
-    autoAdvance: true
-  });
-
-  const handleSettingChange = (key: keyof typeof settings) => {
-    setSettings(prev => ({ ...prev, [key]: !prev[key] }));
-  };
-
   const handleLeave = () => {
-    localStorage.removeItem('userName');
+    // Clearing storage alone left the context holding the stale name.
+    setName('');
     navigate('/');
   };
 
   const handleResetProgress = () => {
-    if (window.confirm('This will clear all your progress and bookmarks. Are you sure?')) {
-      clearAllData();
-    }
+    if (!window.confirm('This will clear all your progress, bookmarks and any in-progress mock test. Are you sure?')) return;
+    clearAllData();
+    // The dashboard reads storage on render, so navigating there shows the
+    // cleared state immediately instead of leaving stale figures on screen.
+    navigate('/app');
+  };
+
+  const handleExport = () => {
+    const blob = new Blob([JSON.stringify(exportAllData(), null, 2)], {
+      type: 'application/json',
+    });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `necprep-progress-${new Date().toISOString().slice(0, 10)}.json`;
+    a.click();
+    URL.revokeObjectURL(url);
   };
 
   return (
@@ -57,77 +61,11 @@ export default function Settings() {
         </div>
       </section>
 
-      {/* Preferences section */}
-      <section className="settings-section">
-        <h2>Preferences</h2>
-        <div className="settings-list">
-          <div className="setting-item">
-            <div className="setting-info">
-              <span className="setting-name">Email Notifications</span>
-              <span className="setting-desc">Receive progress reports and reminders</span>
-            </div>
-            <button 
-              className={`toggle ${settings.emailNotifications ? 'on' : ''}`}
-              onClick={() => handleSettingChange('emailNotifications')}
-              role="switch"
-              aria-checked={settings.emailNotifications}
-            >
-              <span className="toggle-slider" />
-            </button>
-          </div>
-
-          <div className="setting-item">
-            <div className="setting-info">
-              <span className="setting-name">Dark Mode</span>
-              <span className="setting-desc">Use dark theme throughout the app</span>
-            </div>
-            <button 
-              className={`toggle ${settings.darkMode ? 'on' : ''}`}
-              onClick={() => handleSettingChange('darkMode')}
-              role="switch"
-              aria-checked={settings.darkMode}
-            >
-              <span className="toggle-slider" />
-            </button>
-          </div>
-
-          <div className="setting-item">
-            <div className="setting-info">
-              <span className="setting-name">Sound Effects</span>
-              <span className="setting-desc">Play sounds for correct/incorrect answers</span>
-            </div>
-            <button 
-              className={`toggle ${settings.soundEffects ? 'on' : ''}`}
-              onClick={() => handleSettingChange('soundEffects')}
-              role="switch"
-              aria-checked={settings.soundEffects}
-            >
-              <span className="toggle-slider" />
-            </button>
-          </div>
-
-          <div className="setting-item">
-            <div className="setting-info">
-              <span className="setting-name">Auto-Advance Questions</span>
-              <span className="setting-desc">Automatically move to next question after answering</span>
-            </div>
-            <button 
-              className={`toggle ${settings.autoAdvance ? 'on' : ''}`}
-              onClick={() => handleSettingChange('autoAdvance')}
-              role="switch"
-              aria-checked={settings.autoAdvance}
-            >
-              <span className="toggle-slider" />
-            </button>
-          </div>
-        </div>
-      </section>
-
       {/* Data section */}
       <section className="settings-section">
         <h2>Data & Privacy</h2>
         <div className="settings-list">
-          <button className="setting-action">
+          <button className="setting-action" onClick={handleExport}>
             <div className="setting-info">
               <span className="setting-name">Export Your Data</span>
               <span className="setting-desc">Download all your progress and data</span>
@@ -173,12 +111,15 @@ export default function Settings() {
       {/* App info */}
       <footer className="settings-footer">
         <p>NECPrep v1.0.0</p>
+        <p className="footer-privacy">
+          NECPrep stores everything in this browser. No account, no server, no tracking of your answers.
+        </p>
         <div className="footer-links">
-          <a href="/terms">Terms of Service</a>
+          <a href={REPO_URL} target="_blank" rel="noreferrer">Source</a>
           <span>•</span>
-          <a href="/privacy">Privacy Policy</a>
+          <a href={`${REPO_URL}/issues/new`} target="_blank" rel="noreferrer">Report an issue</a>
           <span>•</span>
-          <a href="/support">Support</a>
+          <a href={`${REPO_URL}/blob/main/LICENSE`} target="_blank" rel="noreferrer">MIT License</a>
         </div>
       </footer>
     </div>
diff --git a/frontend/src/pages/app/TopicPractice.tsx b/frontend/src/pages/app/TopicPractice.tsx
index 4ec22b3..7808fc6 100644
--- a/frontend/src/pages/app/TopicPractice.tsx
+++ b/frontend/src/pages/app/TopicPractice.tsx
@@ -1,19 +1,38 @@
-import { useParams, Link, useSearchParams } from 'react-router-dom';
-import { useState, useEffect, useCallback } from 'react';
+/**
+ * TopicPractice — practise one chapter.
+ *
+ * This page used to carry its own copy of the quiz state machine, as did
+ * QuickPractice, CustomPractice and MockTestQuiz: four near-identical
+ * implementations of the same thing, which is how the same answer-loss bug
+ * shipped in three of them at once. All of that now lives in
+ * `features/quiz`, and this file is a host: it decides what the paper is and
+ * how the page is laid out, and the engine owns everything about running it.
+ *
+ * What the engine brings that this page could not do before: flag-for-review, a
+ * numbered question palette, keyboard shortcuts, per-question timing, autosave
+ * with resume, and an explanation panel that is honest about not having an
+ * explanation.
+ */
+
+import { useCallback, useMemo } from 'react';
+import { Link, useParams, useSearchParams } from 'react-router-dom';
 import {
-  loadQuestionsSlice,
-  getTopicById,
-  recordAttempt,
-  addBookmark,
-  removeBookmark,
-  isBookmarked,
-  saveQuizResult,
-} from '../../services/localData';
-import type { Question } from '../../services/localData';
+  useQuiz,
+  useQuizKeyboard,
+  QuestionCard,
+  QuestionPalette,
+  QuizActionBar,
+  QuizToolbar,
+  ResultSummary,
+  ExplanationPanel,
+} from '../../features/quiz';
+import { getTopicById, loadQuestionsSlice, saveQuizResult } from '../../services/localData';
+import type { QuizSummary } from '../../features/quiz';
+import { describeReference } from '../../services/questionReference';
 
 function LoadingSpinner() {
   return (
-    <div className="loading-container">
+    <div className="loading-container" role="status" aria-live="polite">
       <div className="loading-spinner"></div>
       <p>Loading questions...</p>
     </div>
@@ -27,157 +46,94 @@ export default function TopicPractice() {
 
   const topic = topicId ? getTopicById(topicId) : undefined;
 
-  const [questions, setQuestions] = useState<Question[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
+  // Changing this abandons the current attempt and starts a new one, which is
+  // exactly what should happen when the chapter or the requested count changes.
+  const attemptKey = topicId ? `topic:${topicId}:${questionCount}` : null;
 
-  const [currentIdx, setCurrentIdx] = useState(0);
-  const [selectedAnswer, setSelectedAnswer] = useState<number | null>(null);
-  const [showResult, setShowResult] = useState(false);
-  const [score, setScore] = useState(0);
-  const [answeredSet, setAnsweredSet] = useState<Set<number>>(new Set());
-  const [bookmarkedIds, setBookmarkedIds] = useState<Set<string>>(new Set());
-  const [quizDone, setQuizDone] = useState(false);
-
-  useEffect(() => {
-    if (!topicId) return;
-    setLoading(true);
-    setError(null);
-    loadQuestionsSlice(topicId, questionCount)
-      .then((qs) => {
-        if (qs.length === 0) setError('No questions found for this topic.');
-        else setQuestions(qs);
-      })
-      .catch(() => setError('Failed to load questions. Please try again.'))
-      .finally(() => setLoading(false));
-  }, [topicId, questionCount]);
-
-  useEffect(() => {
-    setCurrentIdx(0);
-    setSelectedAnswer(null);
-    setShowResult(false);
-    setScore(0);
-    setAnsweredSet(new Set());
-    setBookmarkedIds(new Set());
-    setQuizDone(false);
-  }, [topicId]);
-
-  useEffect(() => {
-    if (questions.length === 0) return;
-    const id = questions[currentIdx]?.id;
-    if (id && isBookmarked(id)) setBookmarkedIds(prev => new Set(prev).add(id));
-  }, [currentIdx, questions]);
-
-  const handleAnswerSelect = (index: number) => {
-    if (answeredSet.has(currentIdx)) return;
-    setSelectedAnswer(index);
-  };
-
-  const handleSubmit = useCallback(() => {
-    if (selectedAnswer === null || answeredSet.has(currentIdx)) return;
-    const q = questions[currentIdx];
-    const hasAnswer = q.correctIndex >= 0;
-    const correct = hasAnswer && selectedAnswer === q.correctIndex;
-    setShowResult(true);
-    setAnsweredSet(prev => new Set(prev).add(currentIdx));
-    if (correct) setScore(s => s + 1);
-    if (hasAnswer) recordAttempt(q.id, q.topicId, correct);
-  }, [selectedAnswer, currentIdx, answeredSet, questions]);
-
-  const handleToggleBookmark = () => {
-    const id = questions[currentIdx]?.id;
-    if (!id) return;
-    if (bookmarkedIds.has(id)) {
-      removeBookmark(id);
-      setBookmarkedIds(prev => { const n = new Set(prev); n.delete(id); return n; });
-    } else {
-      addBookmark(id);
-      setBookmarkedIds(prev => new Set(prev).add(id));
-    }
-  };
-
-  const handleNext = () => {
-    if (currentIdx < questions.length - 1) {
-      setCurrentIdx(i => i + 1);
-      setSelectedAnswer(null);
-      setShowResult(false);
-    } else if (answeredSet.has(currentIdx)) {
-      // quiz finished
-      // correct answer already counted above
-      if (topic) {
-        saveQuizResult({
-          topicId: topic.id,
-          topicName: topic.name,
-          score,
-          total: questions.length,
-          date: new Date().toISOString(),
-        });
-      }
-      setQuizDone(true);
-    }
-  };
-
-  const handlePrev = () => {
-    if (currentIdx > 0) {
-      setCurrentIdx(i => i - 1);
-      setSelectedAnswer(null);
-      setShowResult(answeredSet.has(currentIdx - 1));
-    }
-  };
-
-  const getOptionClass = (index: number) => {
-    if (!showResult) return selectedAnswer === index ? 'selected' : '';
-    const q = questions[currentIdx];
-    if (q.correctIndex < 0) return selectedAnswer === index ? 'selected' : ''; // no answer key
-    if (index === q.correctIndex) return 'correct';
-    if (selectedAnswer === index) return 'incorrect';
-    return '';
-  };
+  const loadQuestions = useCallback(
+    () => (topicId ? loadQuestionsSlice(topicId, questionCount) : Promise.resolve([])),
+    [topicId, questionCount]
+  );
 
-  if (loading) return <LoadingSpinner />;
+  const onComplete = useCallback(
+    (summary: QuizSummary) => {
+      if (!topic) return;
+      saveQuizResult({
+        topicId: topic.id,
+        topicName: topic.name,
+        score: summary.score,
+        total: summary.total,
+        date: new Date().toISOString(),
+      });
+    },
+    [topic]
+  );
 
-  if (error || !topic) {
+  const quiz = useQuiz({
+    mode: 'topic',
+    attemptKey,
+    loadQuestions,
+    enabled: Boolean(topicId && topic),
+    onComplete,
+  });
+
+  useQuizKeyboard({
+    optionCount: quiz.current?.options.length ?? 0,
+    onSelectOption: quiz.selectOption,
+    onSubmitOrAdvance: quiz.submitOrAdvance,
+    onPrev: quiz.prev,
+    onNext: quiz.next,
+    onToggleFlag: quiz.toggleFlag,
+    onToggleBookmark: quiz.toggleBookmark,
+    enabled: quiz.state.phase === 'active',
+  });
+
+  const sourceLabel = useMemo(() => topic?.name, [topic]);
+
+  if (quiz.state.phase === 'loading') return <LoadingSpinner />;
+
+  if (quiz.error || !topic) {
     return (
       <div className="topic-not-found">
         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-          <circle cx="12" cy="12" r="10"/>
-          <line x1="12" y1="8" x2="12" y2="12"/>
-          <line x1="12" y1="16" x2="12.01" y2="16"/>
+          <circle cx="12" cy="12" r="10" />
+          <line x1="12" y1="8" x2="12" y2="12" />
+          <line x1="12" y1="16" x2="12.01" y2="16" />
         </svg>
-        <h2>{error || 'Topic not found'}</h2>
+        <h2>{quiz.error || 'Topic not found'}</h2>
         <p>The topic you are looking for does not exist or has no questions.</p>
-        <Link to="/app/practice" className="btn-primary">Back to Practice</Link>
+        <Link to="/app/practice" className="btn-primary">
+          Back to Practice
+        </Link>
       </div>
     );
   }
 
-  if (quizDone) {
-    const pct = Math.round((score / questions.length) * 100);
+  if (quiz.state.phase === 'done') {
     return (
       <div className="quiz-complete">
-        <div className="quiz-complete-card">
-          <div className="complete-icon" style={{ color: pct >= 60 ? '#22c55e' : '#ef4444' }}>
-            {pct >= 60 ? '🎉' : '📚'}
-          </div>
-          <h2>Quiz Complete!</h2>
-          <p className="complete-topic">{topic.name}</p>
-          <div className="complete-score">
-            <span className="score-number">{score}</span>
-            <span className="score-total">/ {questions.length}</span>
-          </div>
-          <p className="complete-pct">{pct}% accuracy</p>
-          <div className="complete-actions">
-            <Link to={`/app/practice/chapter/${topic.id}`} className="btn-primary">Practice Again</Link>
-            <Link to="/app/practice" className="btn-secondary">Back to Practice</Link>
-          </div>
-        </div>
+        <ResultSummary
+          summary={quiz.summary}
+          title={topic.name}
+          actions={
+            <>
+              {/* A restart is a new attempt identity, not a mutation of this
+                  one, so it goes through navigation rather than a reset. */}
+              <Link to={`/app/practice/chapter/${topic.id}`} className="btn-primary">
+                Practice Again
+              </Link>
+              <Link to="/app/practice" className="btn-secondary">
+                Back to Practice
+              </Link>
+            </>
+          }
+        />
       </div>
     );
   }
 
-  const currentQuestion = questions[currentIdx];
-  const isAnswered = answeredSet.has(currentIdx);
-  const isCurrentBookmarked = bookmarkedIds.has(currentQuestion.id);
+  const current = quiz.current;
+  if (!current) return <LoadingSpinner />;
 
   return (
     <div className="topic-practice-page">
@@ -187,96 +143,60 @@ export default function TopicPractice() {
         <span className="current">{topic.name}</span>
       </nav>
 
-      <header className="topic-header" style={{ borderColor: `${topic.color}40` }}>
-        <div className="topic-info">
-          <h1>{topic.name}</h1>
-          <p>{topic.description}</p>
+      {quiz.state.resumed && (
+        <div className="mock-resume-notice" role="status">
+          Attempt resumed — your answers were restored.
         </div>
-        <div className="topic-stats">
-          <div className="stat">
-            <span className="value">{currentIdx + 1}/{questions.length}</span>
-            <span className="label">Question</span>
-          </div>
-          <div className="stat">
-            <span className="value">{score}</span>
-            <span className="label">Correct</span>
-          </div>
-          <div className="stat">
-            <span className="value">{answeredSet.size > 0 ? Math.round((score / answeredSet.size) * 100) : 0}%</span>
-            <span className="label">Accuracy</span>
-          </div>
-        </div>
-      </header>
-
-      <div className="question-card">
-        <div className="question-header">
-          <div className="question-number">Question {currentIdx + 1}</div>
-          <button
-            className={`bookmark-btn ${isCurrentBookmarked ? 'bookmarked' : ''}`}
-            onClick={handleToggleBookmark}
-            title={isCurrentBookmarked ? 'Remove bookmark' : 'Add bookmark'}
-          >
-            <svg viewBox="0 0 24 24" fill={isCurrentBookmarked ? 'currentColor' : 'none'} stroke="currentColor" strokeWidth="2">
-              <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"/>
-            </svg>
-          </button>
-        </div>
-        <h2 className="question-text">{currentQuestion.question}</h2>
-
-        <div className="options-list" role="radiogroup" aria-label="Answer options">
-          {currentQuestion.options.map((optText, index) => (
-            <button
-              key={index}
-              className={`option-btn ${getOptionClass(index)}`}
-              onClick={() => handleAnswerSelect(index)}
-              disabled={isAnswered}
-              role="radio"
-              aria-checked={selectedAnswer === index}
-            >
-              <span className="option-letter">{String.fromCharCode(65 + index)}</span>
-              <span className="option-text">{optText}</span>
-              {showResult && index === currentQuestion.correctIndex && currentQuestion.correctIndex >= 0 && (
-                <svg className="result-icon correct" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                  <polyline points="20 6 9 17 4 12"/>
-                </svg>
-              )}
-              {showResult && selectedAnswer === index && index !== currentQuestion.correctIndex && (
-                <svg className="result-icon incorrect" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                  <line x1="18" y1="6" x2="6" y2="18"/>
-                  <line x1="6" y1="6" x2="18" y2="18"/>
-                </svg>
-              )}
-            </button>
-          ))}
-        </div>
-
-        {showResult && (
-          <div className={`result-message ${currentQuestion.correctIndex >= 0 ? (selectedAnswer === currentQuestion.correctIndex ? 'correct' : 'incorrect') : 'selected'}`}>
-            {currentQuestion.correctIndex < 0 ? (
-              <p>Answer recorded. No answer key available for this topic yet.</p>
-            ) : selectedAnswer === currentQuestion.correctIndex ? (
-              <p>Correct! Well done.</p>
-            ) : (
-              <p>Incorrect. The correct answer is <strong>{String.fromCharCode(65 + currentQuestion.correctIndex)}</strong>.</p>
-            )}
-          </div>
+      )}
+
+      <QuizToolbar
+        index={quiz.state.currentIndex}
+        total={quiz.counts.total}
+        answered={quiz.counts.answered}
+        flagged={quiz.isFlagged}
+        onToggleFlag={() => quiz.toggleFlag()}
+        bookmarked={quiz.isBookmarked}
+        onToggleBookmark={() => quiz.toggleBookmark()}
+      />
+
+      <QuestionCard
+        index={quiz.state.currentIndex}
+        total={quiz.counts.total}
+        questionText={current.question}
+        options={current.options}
+        selection={quiz.selection}
+        onSelect={quiz.selectOption}
+        correctIndex={current.correctIndex}
+        revealed={quiz.isRevealed}
+        verdict={quiz.verdict}
+        locked={quiz.isSubmitted}
+      >
+        {quiz.isRevealed && (
+          // No question in the bank carries an explanation yet, so this renders
+          // the honest empty state pointing at the chapter rather than
+          // inventing a rationale. `context` is 'practice', not 'exam', so a
+          // badged AI draft would be allowed to show here once one exists.
+          <ExplanationPanel
+            context="practice"
+            sourceLabel={sourceLabel}
+            reference={describeReference(current)}
+          />
         )}
-
-        <div className="question-actions">
-          <button className="btn-secondary" onClick={handlePrev} disabled={currentIdx === 0}>Previous</button>
-          {!isAnswered ? (
-            <button className="btn-primary" onClick={handleSubmit} disabled={selectedAnswer === null}>Submit</button>
-          ) : (
-            <button className="btn-primary" onClick={handleNext}>
-              {currentIdx < questions.length - 1 ? 'Next' : 'Finish'}
-            </button>
-          )}
-        </div>
-      </div>
-
-      <div className="question-progress-bar">
-        <div className="qpb-fill" style={{ width: `${((currentIdx + 1) / questions.length) * 100}%` }} />
-      </div>
+      </QuestionCard>
+
+      <QuizActionBar
+        onPrev={quiz.prev}
+        onNext={quiz.next}
+        onSubmit={quiz.submitCurrent}
+        onFinish={quiz.submitAll}
+        canPrev={quiz.state.currentIndex > 0}
+        canNext={!quiz.isLast}
+        canSubmit={quiz.canSubmitCurrent}
+        isLast={quiz.isLast}
+        finishLabel="Finish"
+      />
+
+      <QuestionPalette entries={quiz.palette} onJump={quiz.goTo} />
     </div>
   );
 }
diff --git a/frontend/src/pages/app/__tests__/MockTestQuiz.test.tsx b/frontend/src/pages/app/__tests__/MockTestQuiz.test.tsx
new file mode 100644
index 0000000..2c51931
--- /dev/null
+++ b/frontend/src/pages/app/__tests__/MockTestQuiz.test.tsx
@@ -0,0 +1,157 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import MockTestQuiz from '../MockTestQuiz';
+import { examFormat, readConfirmed } from '../../../data/examBlueprint';
+
+/**
+ * A mock test is the one place where revealing an answer mid-paper is a real
+ * harm, and where submitting blind off the last question loses marks. Both were
+ * true of this page before it was moved onto the shared quiz engine: feedback
+ * was shown per question in some paths, and the submit button went straight to
+ * scoring with no count of what had been left blank.
+ */
+
+const CH_JSON = [
+  {
+    qsns: 'What is 2 + 2?',
+    opt1: 'Three',
+    opt2: 'Four',
+    opt3: 'Five',
+    opt4: 'Six',
+    correct_option: 'Four',
+    correct_option_index: 2,
+  },
+  {
+    qsns: 'What is the capital of Nepal?',
+    opt1: 'Pokhara',
+    opt2: 'Biratnagar',
+    opt3: 'Kathmandu',
+    opt4: 'Lalitpur',
+    correct_option: 'Kathmandu',
+    correct_option_index: 3,
+  },
+];
+
+function renderMock(testId = 'full-mock-1') {
+  return render(
+    <MemoryRouter initialEntries={[`/app/mock-tests/${testId}/quiz`]}>
+      <Routes>
+        <Route path="/app/mock-tests/:testId/quiz" element={<MockTestQuiz />} />
+      </Routes>
+    </MemoryRouter>
+  );
+}
+
+beforeEach(() => {
+  vi.stubGlobal(
+    'fetch',
+    vi.fn(
+      async () =>
+        new Response(JSON.stringify(CH_JSON), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        })
+    )
+  );
+});
+
+describe('MockTestQuiz', () => {
+  it('runs the paper at the owner-confirmed 120-minute duration', async () => {
+    renderMock();
+    await waitFor(() => expect(screen.getByRole('timer')).toBeInTheDocument());
+
+    // The clock is driven from examBlueprint via topics.ts, not from a literal
+    // on this page — the page shipped 45 minutes against a 120-minute exam.
+    expect(readConfirmed(examFormat.durationMinutes)).toBe(120);
+    // The clock counts down from the blueprint value, so it reads just under
+    // 120 minutes on the first tick.
+    expect(screen.getByRole('timer')).toHaveAccessibleName(
+      /Time remaining: (119|120) minutes/
+    );
+  });
+
+  it('reveals nothing mid-paper, however the student navigates', async () => {
+    const user = userEvent.setup();
+    renderMock();
+    await waitFor(() => expect(screen.getByRole('timer')).toBeInTheDocument());
+
+    const radios = screen.getAllByRole('radio');
+    await user.click(radios[0]);
+
+    // Deferred feedback: no verdict, and crucially no per-question Submit that
+    // would commit and reveal one.
+    expect(screen.queryByText(/^Correct/i)).not.toBeInTheDocument();
+    expect(screen.queryByText(/^Incorrect/i)).not.toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: /^Submit$/ })).not.toBeInTheDocument();
+
+    // Answers stay editable, which is the point of deferring.
+    expect(radios[0]).toBeChecked();
+    await user.click(radios[1]);
+    expect(radios[1]).toBeChecked();
+    expect(radios[0]).not.toBeChecked();
+  });
+
+  it('shows no explanation during the paper, even though one would be allowed in review', async () => {
+    renderMock();
+    await waitFor(() => expect(screen.getByRole('timer')).toBeInTheDocument());
+    // The panel renders nothing in an exam context, so neither the empty state
+    // nor an AI-draft badge can appear mid-paper.
+    expect(screen.queryByText(/No explanation has been written/i)).not.toBeInTheDocument();
+    expect(screen.queryByText(/AI draft/i)).not.toBeInTheDocument();
+  });
+
+  it('routes the last question through a review screen that counts what is blank', async () => {
+    const user = userEvent.setup();
+    renderMock();
+    await waitFor(() => expect(screen.getByRole('timer')).toBeInTheDocument());
+
+    // Answer the first question only, then jump to the last via the palette.
+    await user.click(screen.getAllByRole('radio')[0]);
+    const paletteButtons = screen.getAllByRole('button', { name: /^Question \d+,/ });
+    await user.click(paletteButtons[paletteButtons.length - 1]);
+
+    // The last question's primary action opens review rather than submitting.
+    const finish = await screen.findByRole('button', { name: /review & submit/i });
+    await user.click(finish);
+
+    // The review screen must state what is unanswered — the old page submitted
+    // with no such warning at all. "unanswered" also appears on every palette
+    // button, so assert the review screen's own summary term rather than any
+    // match for the word.
+    expect(await screen.findByRole('heading', { name: /before you submit/i })).toBeInTheDocument();
+    const unansweredTerm = screen
+      .getAllByRole('term')
+      .find((el) => el.textContent === 'Unanswered');
+    expect(unansweredTerm).toBeDefined();
+    // 10 chapters x 2 stubbed questions = 20, of which exactly one is answered.
+    expect(unansweredTerm?.nextElementSibling).toHaveTextContent('19');
+
+    // And it must be escapable, so a student can go back and fill the gaps.
+    await user.click(screen.getByRole('button', { name: /keep working/i }));
+    await waitFor(() => expect(screen.getByRole('timer')).toBeInTheDocument());
+  });
+
+  it('scores server-independently and only reveals answers after submission', async () => {
+    const user = userEvent.setup();
+    renderMock();
+    await waitFor(() => expect(screen.getByRole('timer')).toBeInTheDocument());
+
+    await user.click(screen.getAllByRole('radio')[0]);
+    const paletteButtons = screen.getAllByRole('button', { name: /^Question \d+,/ });
+    await user.click(paletteButtons[paletteButtons.length - 1]);
+    await user.click(await screen.findByRole('button', { name: /review & submit/i }));
+
+    // Submitting is two deliberate steps: the review screen asks, then
+    // confirms, and the confirm button names how many are still blank. A single
+    // misplaced click cannot end a 120-minute paper.
+    await user.click(await screen.findByRole('button', { name: /^submit paper$/i }));
+    const confirm = await screen.findByRole('button', { name: /yes, submit with 19 blank/i });
+    await user.click(confirm);
+
+    // Only now does the detailed review appear, with the key disclosed.
+    expect(await screen.findByText(/Detailed Review/i)).toBeInTheDocument();
+    expect(screen.getAllByText(/✓ Correct/).length).toBeGreaterThan(0);
+  });
+});
diff --git a/frontend/src/pages/app/__tests__/TopicPractice.test.tsx b/frontend/src/pages/app/__tests__/TopicPractice.test.tsx
new file mode 100644
index 0000000..e1c14c5
--- /dev/null
+++ b/frontend/src/pages/app/__tests__/TopicPractice.test.tsx
@@ -0,0 +1,257 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import TopicPractice from '../TopicPractice';
+
+/**
+ * Regression tests for the answer-loss bug: handleNext/handlePrev used to reset
+ * `selectedAnswer` to null while restoring `showResult` from the answered set,
+ * so revisiting an answered question erased the user's choice and the feedback
+ * block compared null against correctIndex and always rendered "Incorrect".
+ */
+
+// Two questions with known, different correct answers. `correct_option_index`
+// is 1-based in the chapter JSON; localData converts it.
+const CH_JSON = [
+  {
+    qsns: 'What is 2 + 2?',
+    opt1: 'Three', opt2: 'Four', opt3: 'Five', opt4: 'Six',
+    correct_option: 'Four', correct_option_index: 2,
+  },
+  {
+    qsns: 'What is the capital of Nepal?',
+    opt1: 'Pokhara', opt2: 'Biratnagar', opt3: 'Kathmandu', opt4: 'Lalitpur',
+    correct_option: 'Kathmandu', correct_option_index: 3,
+  },
+];
+
+function renderAt(topicId: string, count: number) {
+  return render(
+    <MemoryRouter initialEntries={[`/app/practice/topic/${topicId}?count=${count}`]}>
+      <Routes>
+        <Route path="/app/practice/topic/:topicId" element={<TopicPractice />} />
+      </Routes>
+    </MemoryRouter>
+  );
+}
+
+beforeEach(() => {
+  vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify(CH_JSON), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' },
+  })));
+});
+
+describe('TopicPractice', () => {
+  it('keeps the chosen answer and its verdict when navigating back', async () => {
+    const user = userEvent.setup();
+    // book-ch1 is a real chapter id, so getTopicById resolves; fetch is stubbed.
+    renderAt('book-ch1', 2);
+
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    // Answer question 1 correctly.
+    const stem = screen.getByRole('heading', { level: 2 }).textContent!;
+    const correct = stem.includes('2 + 2') ? 'Four' : 'Kathmandu';
+    await user.click(screen.getByText(correct));
+    await user.click(screen.getByRole('button', { name: /^Submit$/ }));
+
+    expect(screen.getByRole('status')).toHaveTextContent(/Correct/i);
+
+    // Move forward, then back.
+    await user.click(screen.getByRole('button', { name: /Next|Finish/ }));
+    await waitFor(() => expect(screen.getByText('Question 2')).toBeInTheDocument());
+    await user.click(screen.getByRole('button', { name: /^Previous$/ }));
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    // The verdict must still say Correct, not "Incorrect".
+    expect(screen.getByRole('status')).toHaveTextContent(/Correct/i);
+    expect(screen.getByRole('status')).not.toHaveTextContent(/Incorrect/i);
+
+    // And the user's own choice must still be marked.
+    expect(screen.getByRole('radio', { name: new RegExp(correct) })).toBeChecked();
+  });
+
+  it('does not re-reveal a forward question that was never answered', async () => {
+    const user = userEvent.setup();
+    renderAt('book-ch1', 2);
+
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    const stem = screen.getByRole('heading', { level: 2 }).textContent!;
+    await user.click(screen.getByText(stem.includes('2 + 2') ? 'Four' : 'Kathmandu'));
+    await user.click(screen.getByRole('button', { name: /^Submit$/ }));
+    await user.click(screen.getByRole('button', { name: /Next|Finish/ }));
+
+    await waitFor(() => expect(screen.getByText('Question 2')).toBeInTheDocument());
+
+    // The bug this guards: a forward question that was never answered must not
+    // inherit the previous question's verdict.
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+
+    // On an unanswered question the primary action is Next, not a disabled
+    // Submit. The quiz engine hides Submit until something is selected, because
+    // skipping is legitimate in practice and required in a timed mock — the
+    // page's old behaviour was a permanently-disabled Submit that implied
+    // otherwise. Selecting an option brings Submit back.
+    expect(screen.queryByRole('button', { name: /^Submit$/ })).not.toBeInTheDocument();
+
+    const stem2 = screen.getByRole('heading', { level: 2 }).textContent!;
+    await user.click(screen.getByText(stem2.includes('2 + 2') ? 'Four' : 'Kathmandu'));
+    expect(screen.getByRole('button', { name: /^Submit$/ })).toBeEnabled();
+    // Still no verdict — selecting is not committing.
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+  });
+
+  it('scores each question independently rather than carrying a selection over', async () => {
+    const user = userEvent.setup();
+    renderAt('book-ch1', 2);
+
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    // Answer Q1 wrong on purpose.
+    const stem1 = screen.getByRole('heading', { level: 2 }).textContent!;
+    const wrong1 = stem1.includes('2 + 2') ? 'Three' : 'Pokhara';
+    await user.click(screen.getByText(wrong1));
+    await user.click(screen.getByRole('button', { name: /^Submit$/ }));
+    expect(screen.getByRole('status')).toHaveTextContent(/Incorrect/i);
+
+    await user.click(screen.getByRole('button', { name: /Next|Finish/ }));
+    await waitFor(() => expect(screen.getByText('Question 2')).toBeInTheDocument());
+
+    // Answer Q2 right.
+    const stem2 = screen.getByRole('heading', { level: 2 }).textContent!;
+    await user.click(screen.getByText(stem2.includes('2 + 2') ? 'Four' : 'Kathmandu'));
+    await user.click(screen.getByRole('button', { name: /^Submit$/ }));
+    expect(screen.getByRole('status')).toHaveTextContent(/Correct/i);
+
+    // Score reads 1, and going back still shows Q1 as incorrect.
+    await user.click(screen.getByRole('button', { name: /^Previous$/ }));
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+    expect(screen.getByRole('status')).toHaveTextContent(/Incorrect/i);
+  });
+  // --- Proof the engine is actually wired in -------------------------------
+  //
+  // The engine, its components and 96 of its tests existed for a while before
+  // any page imported it, which meant flagging, the palette, keyboard shortcuts
+  // and autosave were all unreachable by a user. These assert reachability
+  // through the real page, not through the engine in isolation.
+
+  it('exposes flag-for-review, and the palette reflects it', async () => {
+    const user = userEvent.setup();
+    renderAt('book-ch1', 2);
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    const flag = screen.getByRole('button', { name: /flag/i });
+    expect(flag).toHaveAttribute('aria-pressed', 'false');
+
+    await user.click(flag);
+    expect(flag).toHaveAttribute('aria-pressed', 'true');
+    expect(
+      screen.getByRole('button', { name: /Question 1,.*flagged for review/i })
+    ).toBeInTheDocument();
+  });
+
+  it('exposes the question palette and jumps on click', async () => {
+    const user = userEvent.setup();
+    renderAt('book-ch1', 2);
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    expect(screen.getByRole('navigation', { name: /question navigator/i })).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: /^Question 2,/i }));
+    await waitFor(() => expect(screen.getByText('Question 2')).toBeInTheDocument());
+  });
+
+  it('answers by keyboard: a number key selects and Enter commits', async () => {
+    const user = userEvent.setup();
+    renderAt('book-ch1', 2);
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    const stem = screen.getByRole('heading', { level: 2 }).textContent!;
+    const correct = stem.includes('2 + 2') ? 'Four' : 'Kathmandu';
+    // Option order is randomised per question by orderOptions, so find the
+    // correct option's 1-based position rather than assuming it.
+    const radios = screen.getAllByRole('radio');
+    const position = radios.findIndex((r) => r.textContent?.includes(correct)) + 1;
+
+    await user.keyboard(String(position));
+    expect(screen.getByRole('radio', { name: new RegExp(correct) })).toBeChecked();
+
+    await user.keyboard('{Enter}');
+    expect(screen.getByRole('status')).toHaveTextContent(/Correct/i);
+  });
+
+  it('restores an in-progress attempt from the saved draft', async () => {
+    const user = userEvent.setup();
+    const first = renderAt('book-ch1', 2);
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    const stem = screen.getByRole('heading', { level: 2 }).textContent!;
+    const correct = stem.includes('2 + 2') ? 'Four' : 'Kathmandu';
+    await user.click(screen.getByText(correct));
+    await user.click(screen.getByRole('button', { name: /^Submit$/ }));
+    expect(screen.getByRole('status')).toHaveTextContent(/Correct/i);
+
+    // Autosave is debounced, so wait for the draft to actually exist rather
+    // than assuming the write is synchronous — unmounting first would test
+    // nothing.
+    await waitFor(() =>
+      expect(localStorage.getItem('eng_quiz_draft_v1:topic:book-ch1:2')).not.toBeNull()
+    );
+
+    // Unmount and remount, which is what a refresh looks like to the page.
+    first.unmount();
+    renderAt('book-ch1', 2);
+
+    await waitFor(() =>
+      expect(screen.getByText(/Attempt resumed/i)).toBeInTheDocument()
+    );
+    // The committed answer and its verdict survive, not just the question list.
+    expect(screen.getByRole('radio', { name: new RegExp(correct) })).toBeChecked();
+    // The resume notice is also a live region, so target the verdict by content
+    // rather than assuming there is exactly one status on the page.
+    const verdicts = screen
+      .getAllByRole('status')
+      .filter((el) => /correct/i.test(el.textContent ?? ''));
+    expect(verdicts).toHaveLength(1);
+    expect(verdicts[0]).not.toHaveTextContent(/Incorrect/i);
+  });
+
+  it('reaches the explanation panel, which is honest about having none', async () => {
+    const user = userEvent.setup();
+    renderAt('book-ch1', 2);
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    const stem = screen.getByRole('heading', { level: 2 }).textContent!;
+    await user.click(screen.getByText(stem.includes('2 + 2') ? 'Four' : 'Kathmandu'));
+    await user.click(screen.getByRole('button', { name: /^Submit$/ }));
+
+    // No question in the bank has an explanation, so the panel must say so
+    // rather than render blank or invent one.
+    expect(screen.getByText(/No explanation has been written/i)).toBeInTheDocument();
+  });
+
+  it('points at the syllabus even though no explanation exists', async () => {
+    const user = userEvent.setup();
+    renderAt('book-ch1', 2);
+    await waitFor(() => expect(screen.getByText('Question 1')).toBeInTheDocument());
+
+    const stem = screen.getByRole('heading', { level: 2 }).textContent!;
+    await user.click(screen.getByText(stem.includes('2 + 2') ? 'Four' : 'Kathmandu'));
+    await user.click(screen.getByRole('button', { name: /^Submit$/ }));
+
+    // "Incorrect" with nothing else is a dead end. The derived reference is
+    // what a student without an explanation actually has to revise from.
+    expect(screen.getByText(/Syllabus reference/i)).toBeInTheDocument();
+
+    // These stub questions carry none of chapter 1's vocabulary, so the
+    // classifier must decline and fall back to the chapter — which is always
+    // exact — rather than inventing a sub-chapter.
+    expect(
+      screen.getByText(/Chapter 1: Concept of Basic Electrical and Electronics Engineering/i)
+    ).toBeInTheDocument();
+    expect(screen.queryByText(/^1\.\d /)).not.toBeInTheDocument();
+  });
+});
diff --git a/frontend/src/pages/auth/SignIn.module.css b/frontend/src/pages/auth/SignIn.module.css
new file mode 100644
index 0000000..85db246
--- /dev/null
+++ b/frontend/src/pages/auth/SignIn.module.css
@@ -0,0 +1,232 @@
+/* Sign-in / sign-up. Single centred card, mobile-first — exam prep is a phone
+   activity and this is the first screen a visitor sees. */
+
+.page {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 100dvh;
+  padding: var(--spacing-5) var(--spacing-4);
+  background: var(--color-surface-2);
+}
+
+.card {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-3);
+  width: 100%;
+  max-width: 26rem;
+  padding: var(--spacing-6) var(--spacing-5);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-lg);
+  background: var(--color-surface);
+}
+
+.brand {
+  align-self: center;
+  font-size: var(--text-lg);
+  font-weight: 700;
+  letter-spacing: -0.01em;
+  color: var(--color-accent);
+  text-decoration: none;
+}
+
+.heading {
+  margin: var(--spacing-2) 0 0;
+  font-size: var(--text-xl);
+  font-weight: 650;
+  text-align: center;
+  color: var(--color-fg);
+}
+
+.sub {
+  margin: 0;
+  font-size: var(--text-sm);
+  text-align: center;
+  color: var(--color-fg-muted);
+}
+
+/* The primary action. Visually dominant because it is what most visitors
+   should do first. */
+.guest {
+  margin-top: var(--spacing-2);
+  padding: var(--spacing-3) var(--spacing-4);
+  border: none;
+  border-radius: var(--radius-md);
+  background: var(--color-accent);
+  color: var(--color-accent-fg);
+  font-size: var(--text-base);
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.guest:hover:not(:disabled) {
+  filter: brightness(0.94);
+}
+
+.guest:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+.guestNote {
+  margin: 0;
+  font-size: var(--text-xs);
+  line-height: 1.5;
+  text-align: center;
+  color: var(--color-fg-muted);
+}
+
+.divider {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-3);
+  margin: var(--spacing-2) 0;
+  font-size: var(--text-xs);
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--color-fg-muted);
+}
+
+.divider::before,
+.divider::after {
+  content: '';
+  flex: 1;
+  height: 1px;
+  background: var(--color-border);
+}
+
+.form {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-3);
+}
+
+.field {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-1);
+}
+
+.label {
+  font-size: var(--text-sm);
+  font-weight: 550;
+  color: var(--color-fg);
+}
+
+.input {
+  padding: var(--spacing-3);
+  border: 1px solid var(--color-border-strong);
+  border-radius: var(--radius-md);
+  background: var(--color-surface);
+  color: var(--color-fg);
+  /* 1rem minimum, or iOS Safari zooms the viewport on focus. */
+  font-size: var(--text-base);
+}
+
+.input:focus-visible {
+  outline: 2px solid var(--color-ring);
+  outline-offset: 1px;
+  border-color: var(--color-ring);
+}
+
+.hint {
+  margin: calc(var(--spacing-2) * -1) 0 0;
+  font-size: var(--text-xs);
+  color: var(--color-fg-muted);
+}
+
+/* Reserves its own height so appearing does not shift the submit button out
+   from under a finger already moving toward it. */
+.errorSlot {
+  min-height: 1.25rem;
+  font-size: var(--text-sm);
+}
+
+.error {
+  color: var(--color-danger-fg);
+}
+
+.submit {
+  padding: var(--spacing-3) var(--spacing-4);
+  border: 1px solid var(--color-border-strong);
+  border-radius: var(--radius-md);
+  background: var(--color-surface-2);
+  color: var(--color-fg);
+  font-size: var(--text-base);
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.submit:hover:not(:disabled) {
+  border-color: var(--color-ring);
+}
+
+.submit:disabled {
+  opacity: 0.55;
+  cursor: not-allowed;
+}
+
+/* Google sign-in.
+ *
+ * Deliberately quieter than the guest button and louder than the form: most
+ * visitors should start as a guest, but a returning student with a Google
+ * account should not have to hunt for it. */
+.google {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: var(--spacing-2);
+  min-height: 44px;
+  padding: var(--spacing-3) var(--spacing-4);
+  border: 1px solid var(--color-border-strong);
+  border-radius: var(--radius-md);
+  background: var(--color-surface);
+  color: var(--color-fg);
+  font-size: var(--text-base);
+  font-weight: 600;
+  text-decoration: none;
+}
+
+.google:hover {
+  border-color: var(--color-ring);
+}
+
+.google:focus-visible {
+  outline: 2px solid var(--color-ring);
+  outline-offset: 1px;
+}
+
+/* Google's brand colours are fixed and must not be re-tinted by the theme, so
+   the mark carries its own fills and never uses `currentColor`. */
+.googleMark {
+  flex-shrink: 0;
+  width: 18px;
+  height: 18px;
+}
+
+.swap {
+  margin: 0;
+  font-size: var(--text-sm);
+  text-align: center;
+  color: var(--color-fg-muted);
+}
+
+/* A button, not an anchor: it changes mode in place rather than navigating,
+   and a link that does not link is a lie to a screen reader. */
+.link {
+  padding: 0;
+  border: none;
+  background: none;
+  color: var(--color-accent);
+  font-size: inherit;
+  font-weight: 600;
+  text-decoration: underline;
+  cursor: pointer;
+}
+
+.link:focus-visible {
+  outline: 2px solid var(--color-ring);
+  outline-offset: 2px;
+  border-radius: var(--radius-sm);
+}
diff --git a/frontend/src/pages/auth/SignIn.tsx b/frontend/src/pages/auth/SignIn.tsx
new file mode 100644
index 0000000..62f4a48
--- /dev/null
+++ b/frontend/src/pages/auth/SignIn.tsx
@@ -0,0 +1,237 @@
+/**
+ * Sign in, sign up, or start as a guest — one page, three doors.
+ *
+ * WHY THE GUEST DOOR IS FIRST
+ * ---------------------------
+ * The thing a visitor came to do is sit a practice paper. A sign-up wall in
+ * front of that loses the people who were willing to start, and this platform
+ * does not need an email address to be useful: `POST /api/auth/anonymous`
+ * creates a real server-side identity whose id SURVIVES being upgraded in
+ * place, so a candidate can sit a mock, then sign up, and keep that attempt.
+ *
+ * So the primary action is "Continue as guest", and the account form is the
+ * alternative rather than the toll gate.
+ *
+ * WHY ONE PAGE AND NOT TWO ROUTES
+ * -------------------------------
+ * Sign-in and sign-up differ by one field and one endpoint. Two routes means
+ * two layouts, two sets of validation and two places to fix an accessibility
+ * bug. The mode is local state, the heading and the submit label follow it, and
+ * `/signin` and `/signup` both land here with the right mode preselected so
+ * the URLs still mean what they say.
+ *
+ * WHAT THIS DOES NOT DO
+ * ---------------------
+ * It does not validate password strength beyond the length the server
+ * enforces, and it does not tell a visitor whether an email is already
+ * registered. The server deliberately returns the same failure for "no such
+ * account" and "wrong password"; mirroring that here keeps the page from
+ * becoming an account-existence oracle.
+ */
+
+import { useEffect, useState, type FormEvent } from 'react';
+import { Link, Navigate, useLocation, useNavigate, useSearchParams } from 'react-router-dom';
+import { useAuth } from '../../auth/auth-context';
+import { api, isBackendConfigured } from '../../services/api';
+import styles from './SignIn.module.css';
+
+type Mode = 'signin' | 'signup';
+
+/**
+ * The Worker's signup minimum (`validation/schemas.ts`), so the first failure
+ * is not a round trip.
+ *
+ * It is applied ONLY when creating an account. The server's LOGIN schema has
+ * no minimum at all, deliberately — rejecting a short password there would
+ * tell an attacker their guess was too short to be anyone's password. A
+ * client-side minimum on sign-in would reintroduce exactly that signal, and
+ * would also lock out any account whose password predates the current rule.
+ */
+const MIN_PASSWORD_LENGTH = 8;
+
+export default function SignIn({ initialMode = 'signin' }: { initialMode?: Mode }) {
+  const { user, status, busy, error, login, signup, startGuest, clearError } = useAuth();
+  const navigate = useNavigate();
+  const location = useLocation();
+  const [params] = useSearchParams();
+
+  const [mode, setMode] = useState<Mode>(initialMode);
+  const [email, setEmail] = useState('');
+  const [password, setPassword] = useState('');
+  const [displayName, setDisplayName] = useState('');
+
+  // Where to land after signing in. A guard sends the attempted path through,
+  // so a deep link survives the detour through this page.
+  const from = (location.state as { from?: string } | null)?.from ?? params.get('next') ?? '/app';
+
+  // Switching mode must not carry a failure across: "incorrect password" under
+  // a "Create account" heading reads as though the account already exists.
+  useEffect(() => {
+    clearError();
+  }, [mode, clearError]);
+
+  // A local-only build has no sign-in to offer, so this page is not reachable
+  // in a meaningful sense. Send the visitor to the app rather than showing a
+  // form whose submit button cannot work.
+  if (!isBackendConfigured()) {
+    return <Navigate to="/app" replace />;
+  }
+
+  // Already signed in — including as a guest. Nothing to do here.
+  if (status === 'ready' && user) {
+    return <Navigate to={from} replace />;
+  }
+
+  const passwordLongEnough =
+    mode === 'signup' ? password.length >= MIN_PASSWORD_LENGTH : password.length > 0;
+  const canSubmit = email.trim().length > 3 && passwordLongEnough && !busy;
+
+  async function onSubmit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    if (!canSubmit) return;
+    const ok =
+      mode === 'signin'
+        ? await login(email.trim(), password)
+        : await signup(email.trim(), password, displayName.trim() || undefined);
+    if (ok) navigate(from, { replace: true });
+  }
+
+  async function onGuest() {
+    if (await startGuest()) navigate(from, { replace: true });
+  }
+
+  return (
+    <main className={styles.page}>
+      <div className={styles.card}>
+        <Link to="/" className={styles.brand}>
+          NECPrep
+        </Link>
+
+        <h1 className={styles.heading}>
+          {mode === 'signin' ? 'Sign in' : 'Create an account'}
+        </h1>
+        <p className={styles.sub}>
+          Nepal Engineering Council licence preparation — Computer Engineering.
+        </p>
+
+        {/* The primary path. Deliberately above the form. */}
+        <button
+          type="button"
+          className={styles.guest}
+          onClick={() => void onGuest()}
+          disabled={busy}
+        >
+          Continue as guest
+        </button>
+        <p className={styles.guestNote}>
+          Start practising straight away. You can create an account later and keep
+          everything you have done.
+        </p>
+
+        {/* A full-page navigation, not fetch: the OAuth flow leaves this
+            origin for accounts.google.com and comes back to the Worker's
+            callback, which sets the session cookie and redirects. An anchor
+            says that honestly, and works with middle-click and Back.
+
+            It is rendered unconditionally. Whether Google is configured is a
+            server-side fact the client cannot read without an extra request on
+            the critical path, and the route answers honestly either way: 404
+            when the feature is off, 500 when it is half-configured. */}
+        <a className={styles.google} href={api.googleSignInUrl(from)}>
+          <svg viewBox="0 0 18 18" aria-hidden="true" className={styles.googleMark}>
+            <path fill="#4285F4" d="M17.64 9.2c0-.64-.06-1.25-.16-1.84H9v3.48h4.84a4.14 4.14 0 0 1-1.8 2.72v2.26h2.92c1.7-1.57 2.68-3.88 2.68-6.62Z"/>
+            <path fill="#34A853" d="M9 18c2.43 0 4.47-.8 5.96-2.18l-2.92-2.26c-.81.54-1.84.86-3.04.86-2.34 0-4.32-1.58-5.03-3.7H.96v2.33A9 9 0 0 0 9 18Z"/>
+            <path fill="#FBBC05" d="M3.97 10.72a5.41 5.41 0 0 1 0-3.44V4.95H.96a9 9 0 0 0 0 8.1l3.01-2.33Z"/>
+            <path fill="#EA4335" d="M9 3.58c1.32 0 2.5.45 3.44 1.35l2.58-2.59C13.46.89 11.42 0 9 0A9 9 0 0 0 .96 4.95l3.01 2.33C4.68 5.16 6.66 3.58 9 3.58Z"/>
+          </svg>
+          Continue with Google
+        </a>
+
+        <div className={styles.divider}>
+          <span>or</span>
+        </div>
+
+        <form className={styles.form} onSubmit={(e) => void onSubmit(e)} noValidate>
+          {mode === 'signup' && (
+            <label className={styles.field}>
+              <span className={styles.label}>Name</span>
+              <input
+                className={styles.input}
+                type="text"
+                name="name"
+                autoComplete="name"
+                value={displayName}
+                onChange={(e) => setDisplayName(e.target.value)}
+                placeholder="Optional"
+              />
+            </label>
+          )}
+
+          <label className={styles.field}>
+            <span className={styles.label}>Email</span>
+            <input
+              className={styles.input}
+              type="email"
+              name="email"
+              autoComplete="email"
+              required
+              value={email}
+              onChange={(e) => setEmail(e.target.value)}
+            />
+          </label>
+
+          <label className={styles.field}>
+            <span className={styles.label}>Password</span>
+            <input
+              className={styles.input}
+              type="password"
+              name="password"
+              // The browser needs to know which it is, or it offers to save a
+              // sign-in as a new password and vice versa.
+              autoComplete={mode === 'signin' ? 'current-password' : 'new-password'}
+              required
+              // No `minLength` on sign-in; see MIN_PASSWORD_LENGTH.
+              minLength={mode === 'signup' ? MIN_PASSWORD_LENGTH : undefined}
+              value={password}
+              onChange={(e) => setPassword(e.target.value)}
+              aria-describedby={mode === 'signup' ? 'password-hint' : undefined}
+            />
+          </label>
+          {mode === 'signup' && (
+            <p id="password-hint" className={styles.hint}>
+              At least {MIN_PASSWORD_LENGTH} characters.
+            </p>
+          )}
+
+          {/* A live region, so a screen reader hears the failure without the
+              focus having to move into it. */}
+          <div className={styles.errorSlot} role="alert" aria-live="assertive">
+            {error && <span className={styles.error}>{error.message}</span>}
+          </div>
+
+          <button type="submit" className={styles.submit} disabled={!canSubmit}>
+            {busy ? 'Working…' : mode === 'signin' ? 'Sign in' : 'Create account'}
+          </button>
+        </form>
+
+        <p className={styles.swap}>
+          {mode === 'signin' ? (
+            <>
+              No account?{' '}
+              <button type="button" className={styles.link} onClick={() => setMode('signup')}>
+                Create one
+              </button>
+            </>
+          ) : (
+            <>
+              Already have an account?{' '}
+              <button type="button" className={styles.link} onClick={() => setMode('signin')}>
+                Sign in
+              </button>
+            </>
+          )}
+        </p>
+      </div>
+    </main>
+  );
+}
diff --git a/frontend/src/pages/legal/Legal.module.css b/frontend/src/pages/legal/Legal.module.css
new file mode 100644
index 0000000..dd3aedf
--- /dev/null
+++ b/frontend/src/pages/legal/Legal.module.css
@@ -0,0 +1,173 @@
+/* Shared by the privacy policy and the terms.
+ *
+ * Long-form reading, not an app screen: a single measured column, generous
+ * line height, and no decoration competing with the text. These are pages
+ * somebody reads once, carefully, usually because they are deciding whether to
+ * trust the thing. */
+
+.page {
+  min-height: 100dvh;
+  padding: var(--spacing-5) var(--spacing-4) var(--spacing-6);
+  background: var(--color-surface-2);
+}
+
+.doc {
+  /* ~70 characters. Longer and the eye loses the line on a return sweep. */
+  max-width: 44rem;
+  margin: 0 auto;
+  padding: var(--spacing-6) var(--spacing-5);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-lg);
+  background: var(--color-surface);
+  color: var(--color-fg);
+  font-size: var(--text-base);
+  line-height: 1.7;
+}
+
+.back {
+  display: inline-block;
+  margin-bottom: var(--spacing-4);
+  color: var(--color-accent);
+  font-weight: 600;
+  text-decoration: none;
+}
+
+.back:hover {
+  text-decoration: underline;
+}
+
+.title {
+  margin: 0 0 var(--spacing-1);
+  font-size: var(--text-3xl);
+  font-weight: 700;
+  line-height: 1.2;
+  letter-spacing: -0.02em;
+}
+
+.updated {
+  margin: 0 0 var(--spacing-5);
+  font-size: var(--text-sm);
+  color: var(--color-fg-muted);
+}
+
+/* Shown while legalMeta still holds placeholders. Loud on purpose: this is the
+   page Google shows every person who signs in, and an unfinished one should
+   not slip out quietly. */
+.warning {
+  margin: 0 0 var(--spacing-5);
+  padding: var(--spacing-3) var(--spacing-4);
+  border: 1px solid var(--color-warning-500);
+  border-radius: var(--radius-md);
+  background: var(--color-surface-2);
+  color: var(--color-warning-fg);
+  font-size: var(--text-sm);
+}
+
+.lede {
+  margin: 0 0 var(--spacing-5);
+  font-size: var(--text-lg);
+  line-height: 1.6;
+  color: var(--color-fg);
+}
+
+.doc h2 {
+  margin: var(--spacing-6) 0 var(--spacing-2);
+  padding-top: var(--spacing-4);
+  border-top: 1px solid var(--color-border);
+  font-size: var(--text-xl);
+  font-weight: 650;
+  line-height: 1.3;
+}
+
+.doc h3 {
+  margin: var(--spacing-5) 0 var(--spacing-1);
+  font-size: var(--text-base);
+  font-weight: 650;
+}
+
+.doc p {
+  margin: 0 0 var(--spacing-3);
+}
+
+.doc ul {
+  margin: 0 0 var(--spacing-4);
+  padding-left: var(--spacing-5);
+}
+
+.doc li {
+  margin-bottom: var(--spacing-2);
+}
+
+.doc a {
+  color: var(--color-accent);
+}
+
+.doc code {
+  padding: 0.1em 0.35em;
+  border-radius: var(--radius-sm);
+  background: var(--color-surface-2);
+  font-size: 0.9em;
+  /* Wraps rather than forcing a horizontal scrollbar on a phone, which is
+     where most of these will be read. */
+  word-break: break-word;
+}
+
+/* Secondary to the body text: context and caveats, not the rule itself. */
+.note {
+  padding-left: var(--spacing-3);
+  border-left: 2px solid var(--color-border-strong);
+  color: var(--color-fg-muted);
+  font-size: var(--text-sm);
+}
+
+.table {
+  width: 100%;
+  margin: 0 0 var(--spacing-4);
+  border-collapse: collapse;
+  font-size: var(--text-sm);
+}
+
+.table th,
+.table td {
+  padding: var(--spacing-2) var(--spacing-3);
+  border-bottom: 1px solid var(--color-border);
+  text-align: left;
+  vertical-align: top;
+}
+
+.table th {
+  font-weight: 650;
+  color: var(--color-fg-muted);
+}
+
+.footerLinks {
+  margin: var(--spacing-6) 0 0;
+  padding-top: var(--spacing-4);
+  border-top: 1px solid var(--color-border);
+  font-size: var(--text-sm);
+  color: var(--color-fg-muted);
+}
+
+@media (max-width: 640px) {
+  .page {
+    padding: var(--spacing-3) var(--spacing-2) var(--spacing-5);
+  }
+
+  .doc {
+    padding: var(--spacing-4) var(--spacing-3);
+    /* Edge-to-edge on a phone: a card inset inside a 360px viewport wastes
+       most of the measure it is trying to protect. */
+    border-radius: var(--radius-md);
+  }
+
+  .title {
+    font-size: var(--text-xl);
+  }
+
+  /* A two-column table is readable at this width; the layout above is not
+     doing anything a phone cannot show. */
+  .table th,
+  .table td {
+    padding: var(--spacing-2);
+  }
+}
diff --git a/frontend/src/pages/legal/Privacy.tsx b/frontend/src/pages/legal/Privacy.tsx
new file mode 100644
index 0000000..6736bcb
--- /dev/null
+++ b/frontend/src/pages/legal/Privacy.tsx
@@ -0,0 +1,208 @@
+/**
+ * The privacy policy.
+ *
+ * Every factual claim here was written by reading the code, and each one names
+ * where it comes from so the next person can check it rather than trust it:
+ *
+ *   stored columns       worker/migrations/0001_identity.sql, 0004, 0005
+ *   retention windows    worker/src/jobs/retention.ts, sweep.ts
+ *   cookie flags         worker/src/lib/cookies.ts
+ *   IP handling          worker/src/handlers/auth.ts#hashIp
+ *   absence of trackers  verified by searching the whole frontend
+ *
+ * A privacy policy that misdescribes the system is worse than none: it is a
+ * statement to users that happens to be false. So when the code changes, this
+ * page changes with it — the honest things it currently says (no analytics, a
+ * truncated salted hash instead of the IP, a 90-day answer window) are only
+ * true while they are true.
+ *
+ * The operator-specific values live in `legalMeta.ts`, which is the one file
+ * that needs editing.
+ */
+
+import { Link } from 'react-router-dom';
+import { legalMeta, hasPlaceholders } from './legalMeta';
+import styles from './Legal.module.css';
+
+export default function Privacy() {
+  return (
+    <main className={styles.page}>
+      <article className={styles.doc}>
+        <Link to="/" className={styles.back}>
+          ← NECPrep
+        </Link>
+
+        <h1 className={styles.title}>Privacy Policy</h1>
+        <p className={styles.updated}>Last updated {legalMeta.lastUpdated}</p>
+
+        {hasPlaceholders() && (
+          // Visible on purpose. A policy with REPLACE_WITH_A_REAL_EMAIL in it
+          // is not ready to be the page Google shows every person who signs
+          // in, and a quiet TODO in a source file would not stop it shipping.
+          <p className={styles.warning} role="status">
+            This page is not finished: the operator has not yet filled in a contact
+            address. Until then, requests about your data have no route. See
+            <code> src/pages/legal/legalMeta.ts</code>.
+          </p>
+        )}
+
+        <p className={styles.lede}>
+          {legalMeta.operator} is a study tool for the Nepal Engineering Council licence
+          examination. This page describes exactly what it stores, why, for how long, and
+          who else can see it. It describes the software as it is built, not as a general
+          statement of intent.
+        </p>
+
+        <h2>The short version</h2>
+        <ul>
+          <li>You can use it without an account. A guest identity stores no email and no name.</li>
+          <li>There are <strong>no analytics, no advertising trackers and no third-party scripts</strong>. Nothing on this site reports your behaviour to anyone.</li>
+          <li>Your IP address is <strong>never stored</strong>. A salted, truncated hash of it is, which can flag a session that suddenly moves country but cannot be turned back into an address.</li>
+          <li>Your individual answers are deleted after 90 days. Your scores are kept.</li>
+          <li>Nothing is sold, rented, or shared for advertising.</li>
+        </ul>
+
+        <h2>What is stored</h2>
+
+        <h3>If you continue as a guest</h3>
+        <p>
+          A user record with no email and no name, and a session cookie. That is the whole
+          identity. If you clear the cookie and do not create an account, that record becomes
+          unreachable — to you and to us — because nothing else links it to you.
+        </p>
+
+        <h3>If you create an account</h3>
+        <ul>
+          <li>Your email address, and a display name if you give one. The name is optional.</li>
+          <li>
+            A <strong>hash</strong> of your password, never the password. It is PBKDF2 with
+            SHA-256, salted per account, with the iteration count stored alongside so it can
+            be raised later without locking anyone out.
+          </li>
+        </ul>
+
+        <h3>If you sign in with Google</h3>
+        <p>
+          Google tells us an immutable account identifier, your email address and your profile
+          name. We store the identifier, the email and the name. We do not receive or store
+          your Google password, and we ask for no access to anything else in your Google
+          account — the permissions requested are <code>openid</code>, <code>email</code> and{' '}
+          <code>profile</code>, which are the minimum needed to know who you are.
+        </p>
+
+        <h3>While you are signed in</h3>
+        <p>
+          One session record, holding: a hash of the session cookie's value (so the cookie
+          itself is not stored), when the session expires, your browser's user-agent string,
+          and a salted hash of your IP address truncated to 32 characters. That last one
+          exists so a session appearing suddenly from another country can be spotted; it is
+          not reversible to an address, and the raw address is never written down.
+        </p>
+
+        <h3>As you study</h3>
+        <ul>
+          <li>Each attempt: which paper, when you started, when you submitted, your score.</li>
+          <li>Each answer: which question, which option you chose, whether it was right, how long you took.</li>
+          <li>Derived progress: per-question history, revision scheduling, bookmarks and streaks.</li>
+        </ul>
+
+        <h2>How long it is kept</h2>
+        <table className={styles.table}>
+          <thead>
+            <tr><th>What</th><th>How long</th></tr>
+          </thead>
+          <tbody>
+            <tr><td>Individual answers from a submitted paper</td><td>90 days, then deleted</td></tr>
+            <tr><td>Answers from a paper you abandoned</td><td>7 days, then deleted</td></tr>
+            <tr><td>Attempt summaries and scores</td><td>Kept, so your history survives</td></tr>
+            <tr><td>Progress, revision scheduling, bookmarks</td><td>Kept while your account exists</td></tr>
+            <tr><td>Sessions</td><td>Deleted after 90 days at the latest; sooner if idle for 14 days or if you sign out</td></tr>
+          </tbody>
+        </table>
+        <p className={styles.note}>
+          Deleting old answers means a paper older than 90 days can show you the score but not
+          the question-by-question review. That is a deliberate trade: keeping every answer
+          forever would grow without bound, and the score is the part that is still useful a
+          year later.
+        </p>
+
+        <h2>Who else can see it</h2>
+        <p>Two companies, both because the software runs on them:</p>
+        <ul>
+          <li>
+            <strong>Cloudflare</strong> hosts the site, the API and the database. The database
+            is in the Asia-Pacific region. Cloudflare processes requests on our behalf.
+          </li>
+          <li>
+            <strong>Google</strong> — only if you choose to sign in with Google, and only for
+            that sign-in.
+          </li>
+        </ul>
+        <p>
+          Nobody else. Your data is not sold, rented, or shared for advertising, and there is
+          no analytics provider to share it with.
+        </p>
+
+        <h2>Cookies</h2>
+        <p>
+          One cookie, <code>necprep_session</code>. It identifies your session and nothing
+          else. It is <code>HttpOnly</code>, so no JavaScript on the page can read it —
+          including any script an attacker managed to inject — and <code>SameSite=Lax</code>,
+          so another site cannot use it to act as you. Over HTTPS it is also{' '}
+          <code>Secure</code>.
+        </p>
+        <p>There are no advertising, analytics or preference cookies, because there is nothing that would set one.</p>
+
+        <h2>Your choices</h2>
+        <ul>
+          <li><strong>Use it without an account.</strong> Continue as a guest and give no email at all.</li>
+          <li><strong>Get a copy of your data, or have it deleted.</strong> Email {' '}
+            <a href={`mailto:${legalMeta.contactEmail}`}>{legalMeta.contactEmail}</a>.
+          </li>
+          <li><strong>Sign out everywhere.</strong> Signing out revokes the session on the server, not just in your browser.</li>
+        </ul>
+
+        <h2>What this software cannot do yet</h2>
+        <p className={styles.note}>
+          Stated plainly rather than left for you to discover:
+        </p>
+        <ul>
+          <li>
+            <strong>There is no password reset.</strong> No email is sent by this platform at
+            all yet. If you forget your password, email the address above — it cannot be
+            recovered automatically.
+          </li>
+          <li>
+            <strong>Email addresses are not verified.</strong> Nothing confirms that an address
+            you enter is yours.
+          </li>
+          <li>
+            <strong>Deletion is by request, not a button.</strong> There is no self-service
+            delete yet, so it is handled manually at the address above.
+          </li>
+        </ul>
+
+        <h2>Children</h2>
+        <p>
+          This is a tool for candidates sitting a professional engineering licence examination.
+          It is not aimed at children and collects nothing that would identify one.
+        </p>
+
+        <h2>Changes</h2>
+        <p>
+          When the software changes what it stores, this page changes with it, and the date at
+          the top moves. There is no version of this page that describes a system we do not run.
+        </p>
+
+        <h2>Contact</h2>
+        <p>
+          <a href={`mailto:${legalMeta.contactEmail}`}>{legalMeta.contactEmail}</a>
+        </p>
+
+        <p className={styles.footerLinks}>
+          <Link to="/terms">Terms of Use</Link> · <Link to="/">Home</Link>
+        </p>
+      </article>
+    </main>
+  );
+}
diff --git a/frontend/src/pages/legal/Terms.tsx b/frontend/src/pages/legal/Terms.tsx
new file mode 100644
index 0000000..f1741d1
--- /dev/null
+++ b/frontend/src/pages/legal/Terms.tsx
@@ -0,0 +1,151 @@
+/**
+ * Terms of use.
+ *
+ * Written to be true rather than defensive. Two sections exist because the
+ * product genuinely requires them, and leaving them out would be the dishonest
+ * choice:
+ *
+ *   * The question bank has known defects. 118 questions are withheld for
+ *     answer-key contradictions, and the explanations that exist are AI drafts
+ *     badged as unreviewed. A student relying on this to pass a licence exam
+ *     is entitled to know that before they start, not after a question misled
+ *     them.
+ *   * It is not affiliated with the Nepal Engineering Council. A preparation
+ *     tool that lets that ambiguity stand is trading on an endorsement it does
+ *     not have.
+ *
+ * No governing-law clause, no arbitration clause, no limitation-of-liability
+ * boilerplate copied from elsewhere. Those are legal positions, not facts
+ * about the software, and inventing them would make this page a liability
+ * rather than a disclosure. Add them on advice.
+ */
+
+import { Link } from 'react-router-dom';
+import { legalMeta, hasPlaceholders } from './legalMeta';
+import styles from './Legal.module.css';
+
+export default function Terms() {
+  return (
+    <main className={styles.page}>
+      <article className={styles.doc}>
+        <Link to="/" className={styles.back}>
+          ← NECPrep
+        </Link>
+
+        <h1 className={styles.title}>Terms of Use</h1>
+        <p className={styles.updated}>Last updated {legalMeta.lastUpdated}</p>
+
+        {hasPlaceholders() && (
+          <p className={styles.warning} role="status">
+            This page is not finished: the operator has not yet filled in a contact
+            address. See <code>src/pages/legal/legalMeta.ts</code>.
+          </p>
+        )}
+
+        <p className={styles.lede}>
+          {legalMeta.operator} is a free study tool for the Nepal Engineering Council licence
+          examination, Computer Engineering stream. By using it you accept what is below.
+        </p>
+
+        <h2>Not affiliated with the Nepal Engineering Council</h2>
+        <p>
+          This is an independent study tool. It is <strong>not</strong> produced, endorsed,
+          reviewed or approved by the Nepal Engineering Council or by any examination
+          authority. The syllabus structure it follows is public; the questions, the practice
+          papers and the scoring are ours, and carry no official status.
+        </p>
+        <p>
+          Nothing here is a prediction of what the real examination will ask, and passing a
+          mock test is not an indication that you will pass the examination.
+        </p>
+
+        <h2>The question bank is imperfect, and we say which parts</h2>
+        <p>
+          The questions come from published preparation material and have been checked by
+          machine, not by a subject expert. That check found real defects, and rather than
+          hide them:
+        </p>
+        <ul>
+          <li>
+            <strong>118 questions are withheld</strong> from practice because their answer
+            keys contradict themselves or duplicate an option. You will not be served them.
+          </li>
+          <li>
+            <strong>Explanations, where they exist, are AI-generated drafts</strong> that no
+            person has checked. They are labelled as such wherever they appear, with a report
+            button. Treat them as a starting point, not as authority.
+          </li>
+          <li>
+            <strong>Sub-chapter labels are derived automatically</strong> by keyword matching,
+            not assigned by a person. They are a navigation aid and are sometimes wrong.
+          </li>
+        </ul>
+        <p className={styles.note}>
+          If a question looks wrong, report it. That is the only mechanism by which the bank
+          improves, and reports are read.
+        </p>
+
+        <h2>Use it for study</h2>
+        <p>You may use this for your own examination preparation. You may not:</p>
+        <ul>
+          <li>Scrape, bulk-download or republish the question bank.</li>
+          <li>Resell access, or present it as your own or as officially endorsed material.</li>
+          <li>Attempt to extract answer keys other than by answering questions normally.</li>
+          <li>Interfere with the service, other users' accounts, or the integrity of anyone else's attempts.</li>
+        </ul>
+
+        <h2>Your account</h2>
+        <ul>
+          <li>You are responsible for keeping your password to yourself.</li>
+          <li>
+            A guest account is tied to a browser cookie. Clear it without creating an account
+            and that progress is gone — there is no way for anyone, including us, to recover it.
+          </li>
+          <li>
+            <strong>There is no password reset yet.</strong> This platform sends no email at
+            all. If you lose your password, contact us at the address below.
+          </li>
+          <li>
+            Accounts used to attack the service or other users may be suspended.
+          </li>
+        </ul>
+
+        <h2>Availability</h2>
+        <p>
+          It is free and provided as-is. There is no uptime guarantee and no commitment that a
+          feature available today will exist tomorrow. Data is kept per the{' '}
+          <Link to="/privacy">Privacy Policy</Link>, which includes deleting individual answers
+          after 90 days — so download anything you want to keep.
+        </p>
+
+        <h2>No warranty</h2>
+        <p>
+          This tool is provided without warranty of any kind. Your examination result is yours:
+          we do not guarantee that using this will improve it, and we are not responsible for
+          an outcome that depends on your preparation, the real examination's content, and the
+          examining authority's decisions.
+        </p>
+        <p className={styles.note}>
+          Said concretely rather than in capital letters: a question in this bank may be wrong,
+          an AI-drafted explanation may be wrong, and you should verify anything you intend to
+          rely on against your textbook or your lecturer.
+        </p>
+
+        <h2>Changes</h2>
+        <p>
+          These terms change when the product does. The date at the top moves when the meaning
+          changes.
+        </p>
+
+        <h2>Contact</h2>
+        <p>
+          <a href={`mailto:${legalMeta.contactEmail}`}>{legalMeta.contactEmail}</a>
+        </p>
+
+        <p className={styles.footerLinks}>
+          <Link to="/privacy">Privacy Policy</Link> · <Link to="/">Home</Link>
+        </p>
+      </article>
+    </main>
+  );
+}
diff --git a/frontend/src/pages/legal/__tests__/legal.test.tsx b/frontend/src/pages/legal/__tests__/legal.test.tsx
new file mode 100644
index 0000000..ea5d202
--- /dev/null
+++ b/frontend/src/pages/legal/__tests__/legal.test.tsx
@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import Privacy from '../Privacy';
+import Terms from '../Terms';
+import { legalMeta, hasPlaceholders } from '../legalMeta';
+
+/**
+ * These pages make factual claims about what the software stores and for how
+ * long, and Google shows the privacy policy to every person who signs in. The
+ * tests here guard the two ways that goes wrong: shipping a page that still
+ * has REPLACE_WITH in it, and quietly dropping a disclosure that the product
+ * actually requires.
+ */
+
+const render404Safe = (ui: React.ReactElement) =>
+  render(<MemoryRouter>{ui}</MemoryRouter>);
+
+describe('legalMeta', () => {
+  it('detects an unfilled placeholder', () => {
+    expect(
+      hasPlaceholders({ ...legalMeta, contactEmail: 'REPLACE_WITH_A_REAL_EMAIL' }),
+    ).toBe(true);
+    expect(hasPlaceholders({ ...legalMeta, contactEmail: 'hello@example.test' })).toBe(false);
+  });
+
+  it('carries a dated last-updated, so a stale page is visible', () => {
+    expect(legalMeta.lastUpdated).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+  });
+});
+
+describe('Privacy', () => {
+  it('warns on the page itself while a placeholder remains', () => {
+    render404Safe(<Privacy />);
+    // A TODO in a source file would not stop this shipping; a banner on the
+    // page that Google links to does.
+    if (hasPlaceholders()) {
+      expect(screen.getByRole('status')).toHaveTextContent(/not finished/i);
+    } else {
+      expect(screen.queryByRole('status')).not.toBeInTheDocument();
+    }
+  });
+
+  it('states the retention windows the retention job actually implements', () => {
+    render404Safe(<Privacy />);
+    // worker/src/jobs/retention.ts: 90 days submitted, 7 days abandoned.
+    expect(screen.getByText(/90 days, then deleted/i)).toBeInTheDocument();
+    expect(screen.getByText(/7 days, then deleted/i)).toBeInTheDocument();
+  });
+
+  it('is explicit that there are no trackers, because there are none', () => {
+    render404Safe(<Privacy />);
+    expect(
+      screen.getByText(/no analytics, no advertising trackers and no third-party scripts/i),
+    ).toBeInTheDocument();
+  });
+
+  it('does not claim to store the IP address, because it stores a hash', () => {
+    render404Safe(<Privacy />);
+    // handlers/auth.ts#hashIp: salted sha256, truncated to 32 chars.
+    expect(screen.getByText(/never stored/i)).toBeInTheDocument();
+  });
+
+  it('discloses the three things the platform cannot do yet', () => {
+    render404Safe(<Privacy />);
+    expect(screen.getByText(/There is no password reset/i)).toBeInTheDocument();
+    expect(screen.getByText(/Email addresses are not verified/i)).toBeInTheDocument();
+    expect(screen.getByText(/Deletion is by request, not a button/i)).toBeInTheDocument();
+  });
+});
+
+describe('Terms', () => {
+  it('disclaims affiliation with the examining authority', () => {
+    render404Safe(<Terms />);
+    // A preparation tool that leaves this ambiguous is trading on an
+    // endorsement it does not have.
+    expect(screen.getByRole('heading', { name: /not affiliated/i })).toBeInTheDocument();
+  });
+
+  it('states the known defects in the question bank by number', () => {
+    render404Safe(<Terms />);
+    // 118 withheld; explanations are unreviewed AI drafts; sub-chapter labels
+    // are heuristic. A student relying on this for a licence exam is entitled
+    // to know before they start.
+    expect(screen.getByText(/118 questions are withheld/i)).toBeInTheDocument();
+    expect(screen.getByText(/AI-generated drafts/i)).toBeInTheDocument();
+    expect(screen.getByText(/derived automatically/i)).toBeInTheDocument();
+  });
+
+  it('warns that guest progress is unrecoverable', () => {
+    render404Safe(<Terms />);
+    expect(screen.getByText(/tied to a browser cookie/i)).toBeInTheDocument();
+  });
+});
+
+describe('cross-links', () => {
+  it('each page links to the other and home', () => {
+    const { unmount } = render404Safe(<Privacy />);
+    expect(screen.getByRole('link', { name: /terms of use/i })).toHaveAttribute('href', '/terms');
+    unmount();
+
+    render404Safe(<Terms />);
+    // Terms links to the policy twice on purpose - once where retention is
+    // mentioned, once in the footer - so assert every one of them resolves.
+    const links = screen.getAllByRole('link', { name: /privacy policy/i });
+    expect(links.length).toBeGreaterThan(0);
+    for (const link of links) expect(link).toHaveAttribute('href', '/privacy');
+  });
+});
diff --git a/frontend/src/pages/legal/legalMeta.ts b/frontend/src/pages/legal/legalMeta.ts
new file mode 100644
index 0000000..fdf1fba
--- /dev/null
+++ b/frontend/src/pages/legal/legalMeta.ts
@@ -0,0 +1,62 @@
+/**
+ * The handful of facts in the legal pages that only the operator can supply.
+ *
+ * EDIT THIS FILE, NOT THE PAGES.
+ *
+ * Everything else in `Privacy.tsx` and `Terms.tsx` describes what the software
+ * actually does, and was written by reading the schema and the handlers — the
+ * retention windows come from `worker/src/jobs/retention.ts`, the cookie flags
+ * from `worker/src/lib/cookies.ts`, the stored columns from
+ * `worker/migrations/0001_identity.sql`. Those statements stay true as long as
+ * the code does, and if the code changes the pages have to change with it.
+ *
+ * The values below are different: they are about you, not about the software,
+ * and nothing in the repository can derive them.
+ *
+ * WHAT IS NOT HERE, DELIBERATELY
+ * ------------------------------
+ * No company registration number, no registered office, no data-protection
+ * officer, no governing-law clause. Those are claims about legal status that
+ * would be false if invented, and a privacy policy that misdescribes who is
+ * responsible is worse than one that does not exist. Add them when they are
+ * true, and say so in the pages when you do.
+ *
+ * NOT LEGAL ADVICE. These pages describe the system accurately, which is the
+ * part engineering can get right. Whether they satisfy any particular law is a
+ * question for a lawyer in the relevant jurisdiction.
+ */
+
+export interface LegalMeta {
+  /** The name that appears as the operator. */
+  readonly operator: string;
+  /**
+   * Where a student writes about their data — deletion, export, a correction.
+   * There is no self-serve deletion endpoint yet, so this address is the ONLY
+   * route a student has. It must be monitored.
+   */
+  readonly contactEmail: string;
+  /**
+   * Last substantive change, `YYYY-MM-DD`. Bump it when the meaning changes,
+   * not when a typo is fixed.
+   */
+  readonly lastUpdated: string;
+  /**
+   * Country whose law the operator considers itself under, for the one line
+   * that mentions it. Leave as-is until you have taken advice.
+   */
+  readonly jurisdiction: string;
+}
+
+export const legalMeta: LegalMeta = {
+  operator: 'NECPrep',
+  // TODO: replace with a real, monitored address before publishing the Google
+  // consent screen. Google shows this page to every person who signs in.
+  contactEmail: 'REPLACE_WITH_A_REAL_EMAIL',
+  lastUpdated: '2026-10-22',
+  jurisdiction: 'Nepal',
+};
+
+/** True when the operator still has placeholders to fill in. */
+export function hasPlaceholders(meta: LegalMeta = legalMeta): boolean {
+  return Object.values(meta).some((value) => value.startsWith('REPLACE_WITH'));
+}
diff --git a/frontend/src/pwa.ts b/frontend/src/pwa.ts
new file mode 100644
index 0000000..973dcea
--- /dev/null
+++ b/frontend/src/pwa.ts
@@ -0,0 +1,24 @@
+/**
+ * Service-worker registration surface for the UI layer.
+ *
+ * The PWA is configured with `registerType: 'prompt'` (see vite.config.ts), so a
+ * new build never takes over the page on its own — the user is asked first. That
+ * matters here because a silent reload in the middle of a mock test would throw
+ * away unsaved answers.
+ *
+ * This module deliberately contains no UI. A component (owned by the components
+ * workstream, not this one) should call `useRegisterSW` and render:
+ *
+ *   const { offlineReady: [offlineReady], needRefresh: [needRefresh], updateServiceWorker } =
+ *     useRegisterSW()
+ *
+ *   - `offlineReady`  → first install finished; "NECPrep now works offline".
+ *   - `needRefresh`   → a newer build is cached; show "Update available" +
+ *                       a button calling `updateServiceWorker(true)`.
+ *
+ * Until such a component exists, `injectRegister: 'auto'` means Vite injects a
+ * plain registration script, so offline support is already live — only the
+ * update prompt is missing.
+ */
+export { useRegisterSW } from 'virtual:pwa-register/react'
+export type { RegisterSWOptions } from 'virtual:pwa-register/react'
diff --git a/frontend/src/routes/AppRoutes.tsx b/frontend/src/routes/AppRoutes.tsx
index f778106..ed93774 100644
--- a/frontend/src/routes/AppRoutes.tsx
+++ b/frontend/src/routes/AppRoutes.tsx
@@ -1,48 +1,95 @@
+import { lazy, Suspense } from 'react';
 import { Routes, Route, Navigate } from 'react-router-dom';
 import Landing from '../pages/Landing';
-import AppShell from '../layout/AppShell';
-import Dashboard from '../pages/app/Dashboard';
-import PracticeHub from '../pages/app/PracticeHub';
-import ChapterPracticeSelector from '../pages/app/ChapterPracticeSelector';
-import TopicPractice from '../pages/app/TopicPractice';
-import MockTests from '../pages/app/MockTests';
-import MockTestDetail from '../pages/app/MockTestDetail';
-import MockTestQuiz from '../pages/app/MockTestQuiz';
-import QuickPractice from '../pages/app/QuickPractice';
-import CustomPractice from '../pages/app/CustomPractice';
-import StudyHub from '../pages/app/StudyHub';
-import TopicStudy from '../pages/app/TopicStudy';
-import Flashcards from '../pages/app/Flashcards';
-import Bookmarks from '../pages/app/Bookmarks';
-import Progress from '../pages/app/Progress';
-import Profile from '../pages/app/Profile';
-import Settings from '../pages/app/Settings';
-import BookPractice from '../pages/app/BookPractice';
+import RequireSession from '../auth/RequireSession';
+
+// Landing is the entry point and stays in the initial chunk. Everything behind
+// /app is split, so a visitor who never signs in never downloads the app, and
+// opening a quiz does not pull in the dashboard, flashcards and progress charts.
+const AppShell                 = lazy(() => import('../layout/AppShell'));
+const Dashboard                = lazy(() => import('../pages/app/Dashboard'));
+const PracticeHub              = lazy(() => import('../pages/app/PracticeHub'));
+const ChapterPracticeSelector  = lazy(() => import('../pages/app/ChapterPracticeSelector'));
+const TopicPractice            = lazy(() => import('../pages/app/TopicPractice'));
+const MockTests                = lazy(() => import('../pages/app/MockTests'));
+const MockTestDetail           = lazy(() => import('../pages/app/MockTestDetail'));
+const MockTestQuiz             = lazy(() => import('../pages/app/MockTestQuiz'));
+const QuickPractice            = lazy(() => import('../pages/app/QuickPractice'));
+const CustomPractice           = lazy(() => import('../pages/app/CustomPractice'));
+const StudyHub                 = lazy(() => import('../pages/app/StudyHub'));
+const TopicStudy               = lazy(() => import('../pages/app/TopicStudy'));
+const Flashcards               = lazy(() => import('../pages/app/Flashcards'));
+const Bookmarks                = lazy(() => import('../pages/app/Bookmarks'));
+const Progress                 = lazy(() => import('../pages/app/Progress'));
+const Profile                  = lazy(() => import('../pages/app/Profile'));
+const Settings                 = lazy(() => import('../pages/app/Settings'));
+const BookPractice             = lazy(() => import('../pages/app/BookPractice'));
+// Sign-in is split too: a returning visitor with a live session cookie never
+// renders it, and a local-only build never reaches it at all.
+const SignIn                   = lazy(() => import('../pages/auth/SignIn'));
+// Public and rarely read, so split: they must never cost a byte on the path
+// to the dashboard. Google links to /privacy from the consent screen, so it
+// has to resolve for someone arriving cold with no session.
+const Privacy                  = lazy(() => import('../pages/legal/Privacy'));
+const Terms                    = lazy(() => import('../pages/legal/Terms'));
+
+function RouteFallback() {
+  return (
+    <div className="loading-container" role="status" aria-live="polite">
+      <div className="loading-spinner" />
+      <p>Loading…</p>
+    </div>
+  );
+}
 
 export default function AppRoutes() {
   return (
-    <Routes>
-      <Route path="/" element={<Landing />} />
-      <Route path="/app" element={<AppShell />}>
-        <Route index element={<Dashboard />} />
-        <Route path="practice" element={<PracticeHub />} />
-        <Route path="practice/chapter/:chapterId" element={<ChapterPracticeSelector />} />
-        <Route path="practice/topic/:topicId" element={<TopicPractice />} />
-        <Route path="practice/quick" element={<QuickPractice />} />
-        <Route path="practice/custom" element={<CustomPractice />} />
-        <Route path="mock-tests" element={<MockTests />} />
-        <Route path="mock-tests/:testId" element={<MockTestDetail />} />
-        <Route path="mock-tests/:testId/quiz" element={<MockTestQuiz />} />
-        <Route path="study" element={<StudyHub />} />
-        <Route path="study/topic/:topicId" element={<TopicStudy />} />
-        <Route path="flashcards" element={<Flashcards />} />
-        <Route path="bookmarks" element={<Bookmarks />} />
-        <Route path="books" element={<BookPractice />} />
-        <Route path="progress" element={<Progress />} />
-        <Route path="profile" element={<Profile />} />
-        <Route path="settings" element={<Settings />} />
-      </Route>
-      <Route path="*" element={<Navigate to="/" replace />} />
-    </Routes>
+    <Suspense fallback={<RouteFallback />}>
+      <Routes>
+        <Route path="/" element={<Landing />} />
+
+        {/* Two URLs, one page. They differ only by which mode opens first, so
+            `/signup` still means what it says without duplicating the layout,
+            the validation and the accessibility work. */}
+        <Route path="/signin" element={<SignIn initialMode="signin" />} />
+        <Route path="/signup" element={<SignIn initialMode="signup" />} />
+
+        {/* Outside the guard. Someone deciding whether to trust this with
+            their email must be able to read both without an account. */}
+        <Route path="/privacy" element={<Privacy />} />
+        <Route path="/terms" element={<Terms />} />
+
+        {/* The guard wraps the SHELL, not each child route: one decision per
+            navigation, and the attempted path is preserved through the
+            redirect so a deep link survives signing in. */}
+        <Route
+          path="/app"
+          element={
+            <RequireSession>
+              <AppShell />
+            </RequireSession>
+          }
+        >
+          <Route index element={<Dashboard />} />
+          <Route path="practice" element={<PracticeHub />} />
+          <Route path="practice/chapter/:chapterId" element={<ChapterPracticeSelector />} />
+          <Route path="practice/topic/:topicId" element={<TopicPractice />} />
+          <Route path="practice/quick" element={<QuickPractice />} />
+          <Route path="practice/custom" element={<CustomPractice />} />
+          <Route path="mock-tests" element={<MockTests />} />
+          <Route path="mock-tests/:testId" element={<MockTestDetail />} />
+          <Route path="mock-tests/:testId/quiz" element={<MockTestQuiz />} />
+          <Route path="study" element={<StudyHub />} />
+          <Route path="study/topic/:topicId" element={<TopicStudy />} />
+          <Route path="flashcards" element={<Flashcards />} />
+          <Route path="bookmarks" element={<Bookmarks />} />
+          <Route path="books" element={<BookPractice />} />
+          <Route path="progress" element={<Progress />} />
+          <Route path="profile" element={<Profile />} />
+          <Route path="settings" element={<Settings />} />
+        </Route>
+        <Route path="*" element={<Navigate to="/" replace />} />
+      </Routes>
+    </Suspense>
   );
 }
diff --git a/frontend/src/services/__tests__/ability.test.ts b/frontend/src/services/__tests__/ability.test.ts
new file mode 100644
index 0000000..55219f2
--- /dev/null
+++ b/frontend/src/services/__tests__/ability.test.ts
@@ -0,0 +1,262 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ABILITY_STORAGE_KEY,
+  INITIAL_ELO,
+  applyObservation,
+  applyObservations,
+  chapterK,
+  chapterTheta,
+  eloForSuccessProbability,
+  emptyAbilitySnapshot,
+  expectedCorrect,
+  itemCalibration,
+  itemElo,
+  itemK,
+  itemsNeedingIrtRefit,
+  learnerK,
+  loadAbilitySnapshot,
+  rebuildAbility,
+  saveAbilitySnapshot,
+} from '../ability';
+import type { AbilityObservation, AbilitySnapshot } from '../ability';
+import { createResponse } from '../responseLog';
+
+/** mulberry32 — deterministic, so a convergence test cannot flake. */
+function seededRandom(seed: number): () => number {
+  let a = seed;
+  return () => {
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function trueProbability(theta: number, difficulty: number): number {
+  return 1 / (1 + Math.pow(10, (difficulty - theta) / 400));
+}
+
+function pearson(xs: number[], ys: number[]): number {
+  const n = xs.length;
+  const mx = xs.reduce((s, v) => s + v, 0) / n;
+  const my = ys.reduce((s, v) => s + v, 0) / n;
+  let num = 0;
+  let dx = 0;
+  let dy = 0;
+  for (let i = 0; i < n; i += 1) {
+    num += (xs[i] - mx) * (ys[i] - my);
+    dx += (xs[i] - mx) ** 2;
+    dy += (ys[i] - my) ** 2;
+  }
+  return num / Math.sqrt(dx * dy);
+}
+
+describe('elo maths', () => {
+  it('is symmetric at equal ratings and matches the 1PL curve', () => {
+    expect(expectedCorrect(1000, 1000)).toBeCloseTo(0.5, 10);
+    expect(expectedCorrect(1400, 1000)).toBeCloseTo(0.909, 3);
+    expect(expectedCorrect(1000, 1400)).toBeCloseTo(0.091, 3);
+  });
+
+  it('inverts to the item difficulty that yields a target success rate', () => {
+    const target = eloForSuccessProbability(1000, 0.8);
+    expect(target).toBeCloseTo(1000 - 240.8, 1);
+    expect(expectedCorrect(1000, target)).toBeCloseTo(0.8, 6);
+  });
+
+  it('decays K as evidence accumulates', () => {
+    expect(learnerK(0)).toBeCloseTo(8, 6);
+    expect(learnerK(350)).toBeCloseTo(1, 6);
+    expect(itemK(0)).toBeCloseTo(400 / 30, 6);
+    expect(chapterK(0)).toBeCloseTo(20, 6);
+    expect(learnerK(100)).toBeLessThan(learnerK(10));
+  });
+});
+
+describe('applyObservations', () => {
+  it('moves the learner up and the item down by the same surprise', () => {
+    const start = emptyAbilitySnapshot(0);
+    const { snapshot, detail } = applyObservation(start, {
+      qid: 'q1',
+      chapterId: 'book-ch1',
+      correct: true,
+    });
+    expect(detail.expected).toBeCloseTo(0.5, 10);
+    expect(snapshot.theta).toBeCloseTo(INITIAL_ELO + learnerK(0) * 0.5, 6);
+    expect(itemElo(snapshot, 'q1')).toBeCloseTo(INITIAL_ELO - itemK(0) * 0.5, 6);
+    expect(chapterTheta(snapshot, 'book-ch1')).toBeCloseTo(INITIAL_ELO + chapterK(0) * 0.5, 6);
+  });
+
+  it('does not mutate the input snapshot', () => {
+    const start = emptyAbilitySnapshot(0);
+    applyObservation(start, { qid: 'q1', chapterId: 'book-ch1', correct: true });
+    expect(start.theta).toBe(INITIAL_ELO);
+    expect(start.items).toEqual({});
+  });
+
+  it('keeps per-chapter ability separate from global ability', () => {
+    let snapshot = emptyAbilitySnapshot(0);
+    const observations: AbilityObservation[] = [];
+    for (let i = 0; i < 40; i += 1) {
+      observations.push({ qid: `strong_${i}`, chapterId: 'book-ch2', correct: true });
+      observations.push({ qid: `weak_${i}`, chapterId: 'book-ch5', correct: false });
+    }
+    snapshot = applyObservations(snapshot, observations).snapshot;
+    expect(chapterTheta(snapshot, 'book-ch2')).toBeGreaterThan(chapterTheta(snapshot, 'book-ch5') + 200);
+    // The global rating averages them out, which is exactly why selection uses
+    // the per-chapter number.
+    expect(snapshot.theta).toBeGreaterThan(chapterTheta(snapshot, 'book-ch5'));
+    expect(snapshot.theta).toBeLessThan(chapterTheta(snapshot, 'book-ch2'));
+  });
+});
+
+describe('convergence on a simulated learner', () => {
+  it('recovers a known ability when item difficulties are already calibrated', () => {
+    // Items pre-seeded with their true difficulty and a large response count,
+    // so itemK is ~0.04 and they stay put. This isolates learner convergence.
+    const trueTheta = 1250;
+    const items: Record<string, number> = {};
+    const snapshotItems: AbilitySnapshot['items'] = {};
+    for (let i = 0; i < 120; i += 1) {
+      const difficulty = 850 + i * (500 / 119);
+      items[`q${i}`] = difficulty;
+      snapshotItems[`q${i}`] = { rating: difficulty, responses: 10_000 };
+    }
+
+    const start: AbilitySnapshot = { ...emptyAbilitySnapshot(0), items: snapshotItems };
+    const random = seededRandom(20260120);
+    const observations: AbilityObservation[] = [];
+    const qids = Object.keys(items);
+    for (let n = 0; n < 4000; n += 1) {
+      const qid = qids[Math.floor(random() * qids.length)];
+      const correct = random() < trueProbability(trueTheta, items[qid]);
+      observations.push({ qid, chapterId: 'book-ch1', correct });
+    }
+
+    // The error closes monotonically. It closes *slowly* on purpose: with
+    // K = 400/(50 + n) the learner's total remaining movement after n responses
+    // is bounded, which is what stops one unlucky chapter from swinging the
+    // rating 200 points. Measured errors for this seed, starting 250 points
+    // below the truth:
+    //   n=50 → 174, n=100 → 129, n=200 → 96, n=400 → 83,
+    //   n=800 → 67, n=1200 → 55, n=2000 → 40, n=3000 → 31, n=4000 → 27
+    const checkpoints = [100, 200, 400, 800, 1200, 2000, 3000, 4000];
+    const errors = checkpoints.map((n) =>
+      Math.abs(applyObservations(start, observations.slice(0, n)).snapshot.theta - trueTheta),
+    );
+    for (let i = 1; i < errors.length; i += 1) {
+      expect(errors[i]).toBeLessThan(errors[i - 1]);
+    }
+    expect(errors[0]).toBeGreaterThan(100);
+    expect(errors[errors.length - 1]).toBeLessThan(30);
+
+    const { snapshot } = applyObservations(start, observations);
+    // The per-chapter ladder, with its faster K = 400/(20 + n), gets there
+    // sooner — which is why question selection reads the chapter rating.
+    expect(Math.abs(chapterTheta(snapshot, 'book-ch1') - trueTheta)).toBeLessThan(20);
+  });
+
+  it('recovers item difficulty ordering when learner and items calibrate together', () => {
+    // Nothing is known at the start: learner and every item sit at 1000.
+    const trueTheta = 1250;
+    const trueDifficulty: Record<string, number> = {};
+    const qids: string[] = [];
+    for (let i = 0; i < 60; i += 1) {
+      const qid = `q${i}`;
+      qids.push(qid);
+      trueDifficulty[qid] = 850 + i * (500 / 59);
+    }
+
+    const random = seededRandom(777);
+    const observations: AbilityObservation[] = [];
+    // 40 exposures per item: enough for an Elo rating, nowhere near the ~300
+    // per item a 2PL fit would need.
+    for (let round = 0; round < 40; round += 1) {
+      for (const qid of qids) {
+        observations.push({
+          qid,
+          chapterId: 'book-ch1',
+          correct: random() < trueProbability(trueTheta, trueDifficulty[qid]),
+        });
+      }
+    }
+
+    const { snapshot } = applyObservations(emptyAbilitySnapshot(0), observations);
+    const estimated = qids.map((qid) => itemElo(snapshot, qid));
+    const actual = qids.map((qid) => trueDifficulty[qid]);
+    // Measured for this seed: Pearson r = 0.935 between the Elo ratings and the
+    // true difficulties, from 40 exposures per item.
+    expect(pearson(estimated, actual)).toBeGreaterThan(0.9);
+
+    // Only the learner-minus-item gap is identified by Elo, not the absolute
+    // level, so that is what the test pins down.
+    const meanEstimated = estimated.reduce((s, v) => s + v, 0) / estimated.length;
+    const meanActual = actual.reduce((s, v) => s + v, 0) / actual.length;
+    const estimatedGap = snapshot.theta - meanEstimated;
+    const actualGap = trueTheta - meanActual;
+    // Measured: 24.5 Elo points of error on a 150-point true gap.
+    expect(Math.abs(estimatedGap - actualGap)).toBeLessThan(40);
+
+    // Calibration: predicted success should track the truth.
+    let absError = 0;
+    for (const qid of qids) {
+      absError += Math.abs(
+        expectedCorrect(snapshot.theta, itemElo(snapshot, qid)) - trueProbability(trueTheta, trueDifficulty[qid]),
+      );
+    }
+    // Measured: 0.094 mean absolute error on the predicted success probability.
+    // That is the honest accuracy of a 1PL/Elo fit at this sample size; a 2PL
+    // with ~300 responses per item would do better, and cannot be run yet.
+    expect(absError / qids.length).toBeLessThan(0.11);
+  });
+});
+
+describe('IRT replacement path', () => {
+  it('labels an item unseen, provisional, calibrated or ready for a 2PL refit', () => {
+    expect(itemCalibration(undefined)).toBe('unseen');
+    expect(itemCalibration({ rating: 1000, responses: 0 })).toBe('unseen');
+    expect(itemCalibration({ rating: 1000, responses: 12 })).toBe('provisional');
+    expect(itemCalibration({ rating: 1000, responses: 120 })).toBe('calibrated');
+    expect(itemCalibration({ rating: 1000, responses: 300 })).toBe('refit-2pl');
+  });
+
+  it('lists the items that have outgrown Elo', () => {
+    const snapshot: AbilitySnapshot = {
+      ...emptyAbilitySnapshot(0),
+      items: {
+        young: { rating: 1000, responses: 20 },
+        mature: { rating: 900, responses: 512 },
+      },
+    };
+    expect(itemsNeedingIrtRefit(snapshot)).toEqual(['mature']);
+  });
+});
+
+describe('rebuild and persistence', () => {
+  it('replays the log in timestamp order regardless of arrival order', () => {
+    const records = [
+      createResponse({ rid: 'b', qid: 'q1', topicId: 'book-ch1', mode: 'topic', chosenIndex: 0, correct: false, latencyMs: 1, flaggedGuess: false, ts: 2000 }),
+      createResponse({ rid: 'a', qid: 'q1', topicId: 'book-ch1', mode: 'topic', chosenIndex: 0, correct: true, latencyMs: 1, flaggedGuess: false, ts: 1000 }),
+    ];
+    const forwards = rebuildAbility(records, 9999);
+    const shuffled = rebuildAbility([records[1], records[0]], 9999);
+    expect(forwards.theta).toBeCloseTo(shuffled.theta, 12);
+    expect(forwards.responses).toBe(2);
+  });
+
+  it('round-trips a snapshot and rejects a cache it cannot understand', () => {
+    const snapshot = applyObservation(emptyAbilitySnapshot(5), {
+      qid: 'q1',
+      chapterId: 'book-ch1',
+      correct: true,
+    }).snapshot;
+    expect(saveAbilitySnapshot(snapshot)).toBe(true);
+    expect(loadAbilitySnapshot()?.theta).toBeCloseTo(snapshot.theta, 12);
+
+    localStorage.setItem(ABILITY_STORAGE_KEY, JSON.stringify({ version: 99, theta: 1 }));
+    expect(loadAbilitySnapshot()).toBeNull();
+
+    localStorage.setItem(ABILITY_STORAGE_KEY, 'not json');
+    expect(loadAbilitySnapshot()).toBeNull();
+  });
+});
diff --git a/frontend/src/services/__tests__/fakeIndexedDb.ts b/frontend/src/services/__tests__/fakeIndexedDb.ts
new file mode 100644
index 0000000..907844e
--- /dev/null
+++ b/frontend/src/services/__tests__/fakeIndexedDb.ts
@@ -0,0 +1,349 @@
+/**
+ * A minimal in-memory IndexedDB fake.
+ *
+ * jsdom ships no IndexedDB and no IDBKeyRange, so without this the IndexedDB
+ * code path in responseLog.ts would be untested and only the in-memory store
+ * would ever run. This implements exactly the surface responseLog uses — open
+ * with an upgrade, readwrite/readonly transactions, `add` with a unique primary
+ * key, `count`, `clear`, and index cursors over a key range — plus switches to
+ * reproduce the three real-world failures: open throwing (private browsing),
+ * a blocked upgrade, and quota exhaustion mid-write.
+ *
+ * Not a general-purpose polyfill. It is deliberately small enough to read.
+ */
+
+import type { KeyRangeFactory } from '../responseLog';
+
+type Row = Record<string, unknown>;
+type Handler = ((event: unknown) => void) | null;
+
+interface RangeLike {
+  lower?: IDBValidKey;
+  upper?: IDBValidKey;
+  lowerOpen?: boolean;
+  upperOpen?: boolean;
+}
+
+/** `IDBKeyRange`-shaped values the fake's cursors understand. */
+export const fakeKeyRange: KeyRangeFactory = {
+  only: (value) =>
+    ({ lower: value, upper: value, lowerOpen: false, upperOpen: false }) as unknown as IDBKeyRange,
+  bound: (lower, upper, lowerOpen = false, upperOpen = false) =>
+    ({ lower, upper, lowerOpen, upperOpen }) as unknown as IDBKeyRange,
+};
+
+function fakeError(name: string, message = name): DOMException {
+  return { name, message } as unknown as DOMException;
+}
+
+function typeRank(key: IDBValidKey): number {
+  if (typeof key === 'number') return 0;
+  if (typeof key === 'string') return 1;
+  return 2; // array
+}
+
+/** IndexedDB key ordering: numbers < strings < arrays, arrays element-wise. */
+export function compareKeys(a: IDBValidKey, b: IDBValidKey): number {
+  const ra = typeRank(a);
+  const rb = typeRank(b);
+  if (ra !== rb) return ra - rb;
+  if (ra === 0) return (a as number) - (b as number);
+  if (ra === 1) return (a as string) < (b as string) ? -1 : (a as string) > (b as string) ? 1 : 0;
+  const arrA = a as IDBValidKey[];
+  const arrB = b as IDBValidKey[];
+  for (let i = 0; i < Math.min(arrA.length, arrB.length); i += 1) {
+    const cmp = compareKeys(arrA[i], arrB[i]);
+    if (cmp !== 0) return cmp;
+  }
+  return arrA.length - arrB.length;
+}
+
+function inRange(key: IDBValidKey, range: RangeLike | null): boolean {
+  if (!range) return true;
+  if (range.lower !== undefined) {
+    const cmp = compareKeys(key, range.lower);
+    if (cmp < 0 || (cmp === 0 && range.lowerOpen === true)) return false;
+  }
+  if (range.upper !== undefined) {
+    const cmp = compareKeys(key, range.upper);
+    if (cmp > 0 || (cmp === 0 && range.upperOpen === true)) return false;
+  }
+  return true;
+}
+
+function extractKey(row: Row, keyPath: string | string[]): IDBValidKey {
+  if (Array.isArray(keyPath)) return keyPath.map((path) => row[path] as IDBValidKey);
+  return row[keyPath] as IDBValidKey;
+}
+
+interface StoreMeta {
+  keyPath: string;
+  indexes: Map<string, string | string[]>;
+  rows: Map<string, Row>;
+}
+
+interface Task {
+  (): void;
+}
+
+export interface FakeIndexedDbOptions {
+  /** `open()` throws synchronously, as Firefox private browsing does. */
+  throwOnOpen?: boolean;
+  /** `open()` reports a VersionError. */
+  versionError?: boolean;
+  /** `open()` fires `onblocked` and never completes. */
+  blockOpen?: boolean;
+  /** Reject writes with QuotaExceededError once the store holds this many rows. */
+  quotaRowLimit?: number;
+}
+
+class FakeTransaction {
+  readonly mode: IDBTransactionMode;
+  error: DOMException | null = null;
+  oncomplete: Handler = null;
+  onabort: Handler = null;
+  onerror: Handler = null;
+  private readonly queue: Task[] = [];
+  private aborted = false;
+  private finished = false;
+  private readonly db: FakeDatabase;
+
+  constructor(db: FakeDatabase, mode: IDBTransactionMode) {
+    this.db = db;
+    this.mode = mode;
+    this.drain();
+  }
+
+  push(task: Task): void {
+    this.queue.push(task);
+  }
+
+  abortWith(error: DOMException | null): void {
+    if (this.aborted || this.finished) return;
+    this.aborted = true;
+    this.error = error;
+    this.onabort?.({});
+  }
+
+  abort(): void {
+    this.abortWith(fakeError('AbortError'));
+  }
+
+  objectStore(name: string): IDBObjectStore {
+    const meta = this.db.stores.get(name);
+    if (!meta) throw fakeError('NotFoundError', `no object store ${name}`);
+    return makeObjectStore(this, this.db, meta) as unknown as IDBObjectStore;
+  }
+
+  private drain(): void {
+    queueMicrotask(() => {
+      if (this.aborted || this.finished) return;
+      const task = this.queue.shift();
+      if (!task) {
+        this.finished = true;
+        this.oncomplete?.({});
+        return;
+      }
+      task();
+      this.drain();
+    });
+  }
+}
+
+interface FakeRequest {
+  result: unknown;
+  error: DOMException | null;
+  onsuccess: Handler;
+  onerror: Handler;
+}
+
+function makeRequest(): FakeRequest {
+  return { result: undefined, error: null, onsuccess: null, onerror: null };
+}
+
+function makeObjectStore(tx: FakeTransaction, db: FakeDatabase, meta: StoreMeta) {
+  const orderedRows = (): Row[] => [...meta.rows.values()];
+
+  return {
+    add(value: Row) {
+      const request = makeRequest();
+      tx.push(() => {
+        const key = String(extractKey(value, meta.keyPath));
+        if (db.options.quotaRowLimit !== undefined && meta.rows.size >= db.options.quotaRowLimit) {
+          request.error = fakeError('QuotaExceededError', 'simulated quota exhaustion');
+          let prevented = false;
+          request.onerror?.({ preventDefault: () => (prevented = true), stopPropagation: () => undefined });
+          if (!prevented) tx.abortWith(request.error);
+          return;
+        }
+        if (meta.rows.has(key)) {
+          request.error = fakeError('ConstraintError', `key ${key} already exists`);
+          let prevented = false;
+          request.onerror?.({ preventDefault: () => (prevented = true), stopPropagation: () => undefined });
+          if (!prevented) tx.abortWith(request.error);
+          return;
+        }
+        meta.rows.set(key, { ...value });
+        request.result = key;
+        request.onsuccess?.({});
+      });
+      return request as unknown as IDBRequest<IDBValidKey>;
+    },
+
+    count() {
+      const request = makeRequest();
+      tx.push(() => {
+        request.result = meta.rows.size;
+        request.onsuccess?.({});
+      });
+      return request as unknown as IDBRequest<number>;
+    },
+
+    clear() {
+      const request = makeRequest();
+      tx.push(() => {
+        meta.rows.clear();
+        request.result = undefined;
+        request.onsuccess?.({});
+      });
+      return request as unknown as IDBRequest<undefined>;
+    },
+
+    createIndex(name: string, keyPath: string | string[]) {
+      meta.indexes.set(name, keyPath);
+      return {} as unknown as IDBIndex;
+    },
+
+    index(name: string) {
+      const keyPath = meta.indexes.get(name);
+      if (!keyPath) throw fakeError('NotFoundError', `no index ${name}`);
+      return {
+        openCursor(range?: IDBKeyRange | null, direction: IDBCursorDirection = 'next') {
+          const request = makeRequest();
+          const entries = orderedRows()
+            .map((row) => ({ row, key: extractKey(row, keyPath), primary: String(extractKey(row, meta.keyPath)) }))
+            // Rows missing the index key are absent from a real index too.
+            .filter((entry) => entry.key !== undefined && entry.key !== null)
+            .filter((entry) => inRange(entry.key, (range ?? null) as RangeLike | null))
+            .sort((a, b) => compareKeys(a.key, b.key) || (a.primary < b.primary ? -1 : 1));
+          const ordered = direction === 'prev' ? entries.reverse() : entries;
+
+          const step = (i: number): Task => () => {
+            if (i >= ordered.length) {
+              request.result = null;
+              request.onsuccess?.({});
+              return;
+            }
+            request.result = {
+              value: ordered[i].row,
+              key: ordered[i].key,
+              primaryKey: ordered[i].primary,
+              continue: () => tx.push(step(i + 1)),
+            };
+            request.onsuccess?.({});
+          };
+          tx.push(step(0));
+          return request as unknown as IDBRequest<IDBCursorWithValue | null>;
+        },
+      } as unknown as IDBIndex;
+    },
+  };
+}
+
+class FakeDatabase {
+  readonly name: string;
+  version: number;
+  readonly stores = new Map<string, StoreMeta>();
+  readonly options: FakeIndexedDbOptions;
+  onversionchange: Handler = null;
+  closed = false;
+
+  constructor(name: string, version: number, options: FakeIndexedDbOptions) {
+    this.name = name;
+    this.version = version;
+    this.options = options;
+  }
+
+  createObjectStore(name: string, params: { keyPath: string }): IDBObjectStore {
+    const meta: StoreMeta = { keyPath: params.keyPath, indexes: new Map(), rows: new Map() };
+    this.stores.set(name, meta);
+    const tx = new FakeTransaction(this, 'versionchange');
+    return makeObjectStore(tx, this, meta) as unknown as IDBObjectStore;
+  }
+
+  transaction(_name: string, mode: IDBTransactionMode = 'readonly'): IDBTransaction {
+    if (this.closed) throw fakeError('InvalidStateError', 'database closed');
+    return new FakeTransaction(this, mode) as unknown as IDBTransaction;
+  }
+
+  close(): void {
+    this.closed = true;
+  }
+}
+
+/**
+ * Creates an `IDBFactory`-compatible fake plus its matching key-range factory.
+ * Pass both into `createIndexedDbResponseLogStore({ factory, keyRange })`.
+ */
+export function createFakeIndexedDb(options: FakeIndexedDbOptions = {}): {
+  factory: IDBFactory;
+  keyRange: KeyRangeFactory;
+  /** Row counts per store, for assertions that bypass the public API. */
+  inspect(): Map<string, number>;
+} {
+  const databases = new Map<string, FakeDatabase>();
+
+  const factory = {
+    open(name: string, version = 1) {
+      if (options.throwOnOpen === true) {
+        throw fakeError('InvalidStateError', 'storage is blocked in this context');
+      }
+      const request = {
+        result: undefined as unknown,
+        error: null as DOMException | null,
+        transaction: null as unknown,
+        onsuccess: null as Handler,
+        onerror: null as Handler,
+        onblocked: null as Handler,
+        onupgradeneeded: null as Handler,
+      };
+
+      queueMicrotask(() => {
+        if (options.versionError === true) {
+          request.error = fakeError('VersionError', 'stored database is newer');
+          request.onerror?.({});
+          return;
+        }
+        if (options.blockOpen === true) {
+          request.onblocked?.({});
+          return;
+        }
+        const existing = databases.get(name);
+        const db = existing ?? new FakeDatabase(name, 0, options);
+        if (!existing) databases.set(name, db);
+        const oldVersion = db.version;
+        if (version > oldVersion) {
+          db.version = version;
+          request.result = db as unknown as IDBDatabase;
+          request.onupgradeneeded?.({ oldVersion, newVersion: version });
+        }
+        request.result = db as unknown as IDBDatabase;
+        request.onsuccess?.({});
+      });
+
+      return request as unknown as IDBOpenDBRequest;
+    },
+  } as unknown as IDBFactory;
+
+  return {
+    factory,
+    keyRange: fakeKeyRange,
+    inspect() {
+      const counts = new Map<string, number>();
+      for (const db of databases.values()) {
+        for (const [storeName, meta] of db.stores) counts.set(storeName, meta.rows.size);
+      }
+      return counts;
+    },
+  };
+}
diff --git a/frontend/src/services/__tests__/localData.test.ts b/frontend/src/services/__tests__/localData.test.ts
new file mode 100644
index 0000000..be23fd7
--- /dev/null
+++ b/frontend/src/services/__tests__/localData.test.ts
@@ -0,0 +1,216 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { orderOptions, assignOptionOrders } from '../localData';
+import { quarantinedIds } from '../../data/quarantine';
+
+const BOOKS_DIR = join(process.cwd(), 'public', 'data', 'books');
+
+interface RawQuestion {
+  qsns: string;
+  opt1: string;
+  opt2: string;
+  opt3: string;
+  opt4: string;
+  correct_option: string;
+  correct_option_index: number;
+}
+
+function loadBank(): Array<{ topicId: string; idx: number; q: RawQuestion }> {
+  const files = readdirSync(BOOKS_DIR)
+    .filter((f) => f.endsWith('.json'))
+    .sort((a, b) => Number(a.match(/\d+/)![0]) - Number(b.match(/\d+/)![0]));
+
+  const out: Array<{ topicId: string; idx: number; q: RawQuestion }> = [];
+  for (const file of files) {
+    const topicId = `book-${file.replace('.json', '')}`;
+    const rows: RawQuestion[] = JSON.parse(readFileSync(join(BOOKS_DIR, file), 'utf8'));
+    rows.forEach((q, idx) => out.push({ topicId, idx, q }));
+  }
+  return out;
+}
+
+/** Chi-square of observed counts against a uniform distribution. */
+function chiSquare(counts: number[]): number {
+  const n = counts.reduce((a, b) => a + b, 0);
+  if (n === 0) return 0;
+  const expected = n / counts.length;
+  return counts.reduce((acc, o) => acc + (o - expected) ** 2 / expected, 0);
+}
+
+describe('orderOptions', () => {
+  it('preserves the set of options and keeps the answer pointing at the same text', () => {
+    const options = ['Alpha', 'Beta', 'Gamma', 'Delta'];
+    for (let correct = 0; correct < options.length; correct++) {
+      const result = orderOptions(options, correct, `seed-${correct}`);
+      expect([...result.options].sort()).toEqual([...options].sort());
+      expect(result.options[result.correctIndex]).toBe(options[correct]);
+    }
+  });
+
+  it('is deterministic for a given seed', () => {
+    const options = ['A', 'B', 'C', 'D'];
+    const a = orderOptions(options, 1, 'book-ch1_42');
+    const b = orderOptions(options, 1, 'book-ch1_42');
+    expect(a.options).toEqual(b.options);
+    expect(a.correctIndex).toBe(b.correctIndex);
+  });
+
+  it('produces different orders for different seeds', () => {
+    const options = ['A', 'B', 'C', 'D'];
+    const orders = new Set(
+      Array.from({ length: 40 }, (_, i) => orderOptions(options, 0, `seed-${i}`).options.join(''))
+    );
+    // With 24 possible permutations, 40 seeds should hit well more than one.
+    expect(orders.size).toBeGreaterThan(5);
+  });
+
+  it('pins "all of the above" style options last', () => {
+    const cases = [
+      ['One', 'Two', 'Three', 'All of the above'],
+      ['One', 'Two', 'None of these', 'Three'],
+      ['Both of the above', 'One', 'Two', 'Three'],
+    ];
+    for (const options of cases) {
+      const positional = options.filter((o) => /^(all|none|both)\s/i.test(o));
+      const result = orderOptions(options, 0, 'any-seed');
+      const tail = result.options.slice(result.options.length - positional.length);
+      expect(tail).toEqual(positional);
+    }
+  });
+
+  it('leaves degenerate inputs untouched', () => {
+    expect(orderOptions(['Only'], 0, 's')).toEqual({ options: ['Only'], correctIndex: 0 });
+    // One free option plus one pinned: nothing meaningful to shuffle.
+    const single = orderOptions(['A', 'All of the above'], 0, 's');
+    expect(single.options).toEqual(['A', 'All of the above']);
+  });
+
+  it('carries the no-answer-key sentinel through unchanged', () => {
+    const result = orderOptions(['A', 'B', 'C', 'D'], -1, 'seed');
+    expect(result.correctIndex).toBe(-1);
+  });
+});
+
+describe('answer-position bias across the real question bank', () => {
+  // As authored the bank is badly skewed: the correct answer sits in option 2
+  // for 32.6% of rows (chi-square 155 on 3 df), reaching 65% in ch9 and 56% in
+  // ch6, while ch3 puts 47% in option 1. Options were never reordered, so a
+  // student could score 65% on ch9 by blind-guessing "2" and would learn the
+  // tell instead of the material.
+  //
+  // assignOptionOrders() removes this by assigning slots across a whole chapter
+  // at once. These assertions are the regression guard, and they are deliberately
+  // tight: balancing by construction leaves no sampling error to absorb, so there
+  // is no reason to leave slack. An earlier version of this code drew an
+  // independent permutation per question, which only fixed the bias in
+  // expectation and left ch1 at 33.5% on one unlucky draw.
+  const bank = loadBank();
+
+  /** The questions a student can actually be served, per chapter. */
+  function servableByChapter(): Map<string, Array<{ id: string; options: string[]; correctIndex: number }>> {
+    const byTopic = new Map<string, Array<{ id: string; options: string[]; correctIndex: number }>>();
+    for (const { topicId, idx, q } of bank) {
+      const id = `${topicId}_${idx}`;
+      if (quarantinedIds.has(id)) continue;
+      const options = [q.opt1, q.opt2, q.opt3, q.opt4].filter(Boolean);
+      const correctIndex = q.correct_option_index - 1;
+      if (correctIndex < 0 || correctIndex >= options.length) continue;
+      if (!byTopic.has(topicId)) byTopic.set(topicId, []);
+      byTopic.get(topicId)!.push({ id, options, correctIndex });
+    }
+    return byTopic;
+  }
+
+  it('has enough questions to be worth measuring', () => {
+    expect(bank.length).toBeGreaterThan(2000);
+  });
+
+  it('confirms the raw bank really is biased (guards against a vacuous test)', () => {
+    // If this ever fails, the underlying data was rebalanced upstream. That is
+    // good news, but it means the assertions below no longer prove anything and
+    // must be re-examined rather than deleted.
+    const raw = [0, 0, 0, 0];
+    for (const { q } of bank) {
+      const ci = q.correct_option_index - 1;
+      if (ci >= 0 && ci < 4) raw[ci]++;
+    }
+    expect(chiSquare(raw)).toBeGreaterThan(100);
+  });
+
+  it('flattens the distribution across the whole bank', () => {
+    const after = [0, 0, 0, 0];
+    for (const questions of servableByChapter().values()) {
+      for (const { correctIndex } of assignOptionOrders(questions)) {
+        if (correctIndex >= 0 && correctIndex < 4) after[correctIndex]++;
+      }
+    }
+
+    const n = after.reduce((a, b) => a + b, 0);
+    expect(n).toBeGreaterThan(2000);
+
+    // Measured 0.02 at the time of writing. p < 0.05 for df=3 would be 7.81, so
+    // this is roughly 400x tighter than statistical indistinguishability.
+    expect(chiSquare(after)).toBeLessThan(1);
+    expect(Math.max(...after) / n).toBeLessThan(0.26);
+  });
+
+  it('flattens every chapter individually, including the small ones', () => {
+    // No minimum-n skip. The previous version skipped chapters under 100
+    // questions, which silently exempted ch5, ch6, ch7 and ch9 - and ch7 (35.8%)
+    // and ch9 (35.2%) were the two worst chapters in the bank.
+    const byTopic = servableByChapter();
+    expect(byTopic.size).toBe(10);
+
+    for (const [topicId, questions] of byTopic) {
+      const counts = [0, 0, 0, 0];
+      for (const { correctIndex } of assignOptionOrders(questions)) {
+        if (correctIndex >= 0 && correctIndex < 4) counts[correctIndex]++;
+      }
+      const n = counts.reduce((a, b) => a + b, 0);
+      const worst = Math.max(...counts) / n;
+      // Every chapter measured 25.0-26.1%. 27% leaves room for a chapter whose
+      // pinned "all of the above" options genuinely constrain the balance.
+      expect(worst, `${topicId} worst slot share (n=${n})`).toBeLessThan(0.27);
+    }
+  });
+
+  it('never changes which option text is correct', () => {
+    // The whole point of reordering is that it is cosmetic. If this fails, the
+    // app is grading against a different answer than the bank specifies.
+    for (const questions of servableByChapter().values()) {
+      const ordered = assignOptionOrders(questions);
+      questions.forEach((q, i) => {
+        const expected = q.options[q.correctIndex];
+        const actual = ordered[i].options[ordered[i].correctIndex];
+        expect(actual, `answer text changed for ${q.id}`).toBe(expected);
+        expect([...ordered[i].options].sort()).toEqual([...q.options].sort());
+      });
+    }
+  });
+
+  it('keeps positional options last in every chapter', () => {
+    const positional = /^\s*(all|none|both)\s+(of\s+)?(the\s+)?(above|these|mentioned)/i;
+    let checked = 0;
+    for (const questions of servableByChapter().values()) {
+      const ordered = assignOptionOrders(questions);
+      for (const { options } of ordered) {
+        const pinned = options.filter((o) => positional.test(o));
+        if (pinned.length === 0) continue;
+        checked++;
+        expect(options.slice(options.length - pinned.length)).toEqual(pinned);
+      }
+    }
+    // The bank contains hundreds of these; a zero here would mean the regex
+    // stopped matching and this test had quietly become a no-op.
+    expect(checked).toBeGreaterThan(100);
+  });
+
+  it('is stable across repeated calls, so stored answer indices stay valid', () => {
+    for (const questions of servableByChapter().values()) {
+      const a = assignOptionOrders(questions);
+      const b = assignOptionOrders(questions);
+      expect(a).toEqual(b);
+    }
+  });
+});
diff --git a/frontend/src/services/__tests__/mastery.test.ts b/frontend/src/services/__tests__/mastery.test.ts
new file mode 100644
index 0000000..6d52890
--- /dev/null
+++ b/frontend/src/services/__tests__/mastery.test.ts
@@ -0,0 +1,254 @@
+import { describe, it, expect } from 'vitest';
+import {
+  DEFAULT_CHAPTER_MEAN,
+  MIN_N_EFF,
+  SHRINKAGE_K,
+  bucketFor,
+  chapterMeanOf,
+  coverageFor,
+  estimateMastery,
+  masteryFromResponses,
+  overallCoverage,
+  recencyWeight,
+  summarise,
+  triage,
+  withUnassessedUnits,
+} from '../mastery';
+import type { MasteryObservation } from '../mastery';
+import { createResponse } from '../responseLog';
+import type { ResponseRecord } from '../responseLog';
+
+const NOW = Date.UTC(2026, 9, 20, 12, 0, 0);
+const DAY = 24 * 60 * 60 * 1000;
+
+function obs(count: number, correct: boolean, ageDays = 0, qidPrefix = 'q'): MasteryObservation[] {
+  return Array.from({ length: count }, (_, i) => ({
+    qid: `${qidPrefix}${i}`,
+    correct,
+    ts: NOW - ageDays * DAY,
+  }));
+}
+
+function record(overrides: Partial<ResponseRecord> & Pick<ResponseRecord, 'qid' | 'topicId'>): ResponseRecord {
+  return createResponse({
+    mode: 'topic',
+    chosenIndex: 0,
+    correct: true,
+    latencyMs: 4000,
+    flaggedGuess: false,
+    ts: NOW,
+    ...overrides,
+  });
+}
+
+describe('recency weighting', () => {
+  it('halves every 30 days', () => {
+    expect(recencyWeight(0)).toBe(1);
+    expect(recencyWeight(30)).toBeCloseTo(0.5, 12);
+    expect(recencyWeight(60)).toBeCloseTo(0.25, 12);
+    expect(recencyWeight(90)).toBeCloseTo(0.125, 12);
+  });
+
+  it('refuses to let a future timestamp inflate the weight above 1', () => {
+    expect(recencyWeight(-500)).toBe(1);
+  });
+
+  it('shrinks the effective sample size, not just the accuracy', () => {
+    const fresh = summarise(obs(10, true, 0), NOW);
+    const stale = summarise(obs(10, true, 60), NOW);
+    expect(fresh.nEff).toBeCloseTo(10, 6);
+    expect(stale.nEff).toBeCloseTo(2.5, 6);
+    expect(stale.responses).toBe(10); // the raw count is unchanged
+  });
+});
+
+describe('the not-assessed state', () => {
+  it('reports never-practised material as not-assessed, never as 0%', () => {
+    const estimate = estimateMastery([], { now: NOW });
+    expect(estimate.state).toBe('not-assessed');
+    // The whole point: there is no `mastery` field to render as "0%".
+    expect('mastery' in estimate).toBe(false);
+    if (estimate.state !== 'not-assessed') throw new Error('expected not-assessed');
+    expect(estimate.reason).toBe('not practised yet');
+    expect(estimate.nEffNeeded).toBe(MIN_N_EFF);
+  });
+
+  it('holds back a score until the effective sample reaches 3', () => {
+    expect(estimateMastery(obs(2, true), { now: NOW }).state).toBe('not-assessed');
+    expect(estimateMastery(obs(3, true), { now: NOW }).state).toBe('assessed');
+  });
+
+  it('falls back to not-assessed when the only evidence has gone stale', () => {
+    // 8 answers two months ago weigh 8 * 0.25 = 2.0, which is below the bar:
+    // "you knew this in August" is not "you know this now".
+    const stale = estimateMastery(obs(8, true, 60), { now: NOW });
+    expect(stale.nEff).toBeCloseTo(2, 6);
+    if (stale.state !== 'not-assessed') throw new Error('expected not-assessed');
+    expect(stale.reason).toMatch(/8 response\(s\)/);
+  });
+
+  it('says so in a form a UI can print without inventing a number', () => {
+    const estimate = estimateMastery(obs(1, false), { now: NOW });
+    if (estimate.state !== 'not-assessed') throw new Error('expected not-assessed');
+    expect(estimate.reason).toMatch(/too little to score/);
+    expect(estimate.distinctQids).toBe(1);
+  });
+});
+
+describe('shrinkage at small n', () => {
+  it('pulls a perfect 3-question sample most of the way back to the chapter mean', () => {
+    const estimate = estimateMastery(obs(3, true), { now: NOW, chapterMean: 0.5 });
+    if (estimate.state !== 'assessed') throw new Error('expected assessed');
+    // (3 + 8*0.5) / (3 + 8) = 0.636, not 1.0.
+    expect(estimate.accHat).toBeCloseTo(7 / 11, 10);
+    expect(estimate.confidence).toBeCloseTo(3 / 11, 10);
+  });
+
+  it('lets a large sample speak for itself', () => {
+    const estimate = estimateMastery(obs(80, true, 0, 'big'), { now: NOW, chapterMean: 0.5 });
+    if (estimate.state !== 'assessed') throw new Error('expected assessed');
+    expect(estimate.accHat).toBeCloseTo((80 + 4) / 88, 10);
+    expect(estimate.accHat).toBeGreaterThan(0.95);
+    expect(estimate.confidence).toBeGreaterThan(0.9);
+  });
+
+  it('monotonically increases confidence with effective sample size', () => {
+    const sizes = [3, 6, 12, 25, 60];
+    const confidences = sizes.map((n) => {
+      const estimate = estimateMastery(obs(n, true, 0, 'c'), { now: NOW, chapterMean: 0.5 });
+      return estimate.state === 'assessed' ? estimate.confidence : 0;
+    });
+    for (let i = 1; i < confidences.length; i += 1) {
+      expect(confidences[i]).toBeGreaterThan(confidences[i - 1]);
+    }
+    expect(confidences[0]).toBeCloseTo(3 / (3 + SHRINKAGE_K), 10);
+  });
+
+  it('borrows the direction of the chapter it belongs to', () => {
+    const strongChapter = estimateMastery(obs(3, true), { now: NOW, chapterMean: 0.9 });
+    const weakChapter = estimateMastery(obs(3, true), { now: NOW, chapterMean: 0.3 });
+    if (strongChapter.state !== 'assessed' || weakChapter.state !== 'assessed') {
+      throw new Error('expected assessed');
+    }
+    expect(strongChapter.accHat).toBeGreaterThan(weakChapter.accHat);
+    expect(strongChapter.accHat).toBeCloseTo((3 + 8 * 0.9) / 11, 10);
+  });
+
+  it('defaults the shrinkage target to 0.5 when the chapter has no data', () => {
+    expect(chapterMeanOf([], NOW)).toBe(DEFAULT_CHAPTER_MEAN);
+  });
+});
+
+describe('coverage', () => {
+  it('reaches 1.0 at 12 distinct questions and no sooner', () => {
+    expect(coverageFor(0)).toBe(0);
+    expect(coverageFor(3)).toBeCloseTo(0.25, 10);
+    expect(coverageFor(12)).toBe(1);
+    expect(coverageFor(50)).toBe(1);
+  });
+
+  it('discounts mastery for a narrow sample even when accuracy is perfect', () => {
+    const narrow = estimateMastery(
+      Array.from({ length: 20 }, (_, i) => ({ qid: `only${i % 3}`, correct: true, ts: NOW })),
+      { now: NOW, chapterMean: 0.9 },
+    );
+    const broad = estimateMastery(obs(20, true, 0, 'wide'), { now: NOW, chapterMean: 0.9 });
+    if (narrow.state !== 'assessed' || broad.state !== 'assessed') throw new Error('expected assessed');
+    expect(narrow.distinctQids).toBe(3);
+    expect(narrow.coverage).toBeCloseTo(0.25, 10);
+    // Same accuracy, far less breadth, so a lower mastery verdict.
+    expect(narrow.accHat).toBeCloseTo(broad.accHat, 10);
+    expect(narrow.mastery).toBeLessThan(broad.mastery);
+    expect(narrow.mastery).toBeCloseTo(narrow.accHat * 0.7, 10);
+  });
+});
+
+describe('buckets', () => {
+  it('uses the documented thresholds', () => {
+    expect(bucketFor(0.2, 1)).toBe('critical');
+    expect(bucketFor(0.449, 1)).toBe('critical');
+    expect(bucketFor(0.45, 1)).toBe('weak');
+    expect(bucketFor(0.64, 1)).toBe('weak');
+    expect(bucketFor(0.65, 1)).toBe('developing');
+    expect(bucketFor(0.84, 1)).toBe('developing');
+    expect(bucketFor(0.85, 1)).toBe('strong');
+  });
+
+  it('withholds `strong` from a high score on a narrow slice', () => {
+    expect(bucketFor(0.95, 0.74)).toBe('developing');
+    expect(bucketFor(0.95, 0.75)).toBe('strong');
+  });
+});
+
+describe('masteryFromResponses', () => {
+  const records: ResponseRecord[] = [
+    // Sub-chapter 1.1: thin but correct.
+    record({ rid: '1', qid: 'book-ch1_1', topicId: 'book-ch1', subchapter: 'ch1.1' }),
+    record({ rid: '2', qid: 'book-ch1_2', topicId: 'book-ch1', subchapter: 'ch1.1' }),
+    record({ rid: '3', qid: 'book-ch1_3', topicId: 'book-ch1', subchapter: 'ch1.1' }),
+    // Sub-chapter 1.2: well sampled and mostly wrong.
+    ...Array.from({ length: 16 }, (_, i) =>
+      record({ rid: `w${i}`, qid: `book-ch1_1${i}`, topicId: 'book-ch1', subchapter: 'ch1.2', correct: i % 5 === 0 }),
+    ),
+    // A chapter with no sub-chapter metadata at all.
+    record({ rid: 'n1', qid: 'book-ch5_1', topicId: 'book-ch5' }),
+    record({ rid: 'n2', qid: 'book-ch5_2', topicId: 'book-ch5' }),
+    record({ rid: 'n3', qid: 'book-ch5_3', topicId: 'book-ch5' }),
+    record({ rid: 'n4', qid: 'book-ch5_4', topicId: 'book-ch5' }),
+  ];
+
+  it('keys units by sub-chapter and falls back to the chapter id', () => {
+    const map = masteryFromResponses(records, { now: NOW });
+    expect([...map.units.keys()].sort()).toEqual(['book-ch5', 'ch1.1', 'ch1.2']);
+    expect(map.units.get('book-ch5')?.subchapter).toBeNull();
+    expect(map.units.get('ch1.1')?.subchapter).toBe('ch1.1');
+    expect(map.units.get('ch1.1')?.topicId).toBe('book-ch1');
+  });
+
+  it('shrinks each sub-chapter toward its own chapter mean', () => {
+    const map = masteryFromResponses(records, { now: NOW });
+    const chapterMean = map.chapterMeans.get('book-ch1');
+    // 3 correct in 1.1 plus 4 of 16 in 1.2 = 7 of 19.
+    expect(chapterMean).toBeCloseTo(7 / 19, 10);
+    const thin = map.units.get('ch1.1')?.estimate;
+    if (thin?.state !== 'assessed') throw new Error('expected assessed');
+    // 3/3 correct becomes 0.63, not 1.0, because its chapter is weak.
+    expect(thin.accHat).toBeCloseTo((3 + 8 * (7 / 19)) / 11, 10);
+    expect(thin.chapterMean).toBeCloseTo(7 / 19, 10);
+  });
+
+  it('separates not-assessed units from weak ones in triage', () => {
+    const map = withUnassessedUnits(masteryFromResponses(records, { now: NOW }), [
+      { unitId: 'ch1.1', topicId: 'book-ch1' },
+      { unitId: 'ch1.2', topicId: 'book-ch1' },
+      { unitId: 'ch1.3', topicId: 'book-ch1' },
+      { unitId: 'book-ch5', topicId: 'book-ch5' },
+      { unitId: 'book-ch9', topicId: 'book-ch9' },
+    ]);
+    const buckets = triage(map);
+    expect(buckets.notAssessed.map((u) => u.unitId).sort()).toEqual(['book-ch9', 'ch1.3']);
+    for (const unit of buckets.notAssessed) {
+      expect(unit.estimate.state).toBe('not-assessed');
+    }
+    expect(buckets.critical.length + buckets.weak.length).toBeGreaterThan(0);
+  });
+
+  it('can exclude migrated records whose timestamps were imputed', () => {
+    const withLegacy = [
+      ...records,
+      record({ rid: 'legacy1', qid: 'book-ch9_1', topicId: 'book-ch9', imputed: ['ts'] }),
+    ];
+    expect(masteryFromResponses(withLegacy, { now: NOW }).units.has('book-ch9')).toBe(true);
+    expect(
+      masteryFromResponses(withLegacy, { now: NOW, excludeImputedTs: true }).units.has('book-ch9'),
+    ).toBe(false);
+  });
+
+  it('measures coverage against the blueprint, not against what was touched', () => {
+    const map = masteryFromResponses(records, { now: NOW });
+    // Three touched units; a 40-unit blueprint means real coverage is low.
+    expect(overallCoverage(map, 3)).toBeGreaterThan(overallCoverage(map, 40));
+    expect(overallCoverage(map, 40)).toBeLessThan(0.1);
+    expect(overallCoverage(map, 0)).toBe(0);
+  });
+});
diff --git a/frontend/src/services/__tests__/responseLog.test.ts b/frontend/src/services/__tests__/responseLog.test.ts
new file mode 100644
index 0000000..f416b8e
--- /dev/null
+++ b/frontend/src/services/__tests__/responseLog.test.ts
@@ -0,0 +1,324 @@
+import { describe, it, expect } from 'vitest';
+import { createFakeIndexedDb } from './fakeIndexedDb';
+import {
+  LEGACY_HISTORY_KEY,
+  LEGACY_PROGRESS_KEY,
+  LEGACY_TS_BACKDATE_DAYS,
+  createIndexedDbResponseLogStore,
+  createMemoryResponseLogStore,
+  createResponse,
+  isResponseLogError,
+  matchesQuery,
+  migrateLegacyProgress,
+  planLegacyMigration,
+  planScan,
+  probeResponseLog,
+  validateResponse,
+} from '../responseLog';
+import type { ResponseInput, ResponseLogStore } from '../responseLog';
+
+const T0 = Date.UTC(2026, 0, 1, 9, 0, 0);
+const DAY = 24 * 60 * 60 * 1000;
+
+function input(overrides: Partial<ResponseInput> = {}): ResponseInput {
+  return {
+    qid: 'book-ch1_1',
+    topicId: 'book-ch1',
+    mode: 'topic',
+    chosenIndex: 1,
+    correct: true,
+    latencyMs: 5000,
+    flaggedGuess: false,
+    ts: T0,
+    ...overrides,
+  };
+}
+
+function idbStore(options: Parameters<typeof createFakeIndexedDb>[0] = {}): ResponseLogStore {
+  const { factory, keyRange } = createFakeIndexedDb(options);
+  return createIndexedDbResponseLogStore({ factory, keyRange, blockedTimeoutMs: 10 });
+}
+
+async function seed(store: ResponseLogStore): Promise<void> {
+  await store.appendMany([
+    input({ rid: 'a', qid: 'book-ch1_1', topicId: 'book-ch1', ts: T0, mode: 'topic' }),
+    input({ rid: 'b', qid: 'book-ch1_2', topicId: 'book-ch1', ts: T0 + DAY, mode: 'quick', correct: false }),
+    input({ rid: 'c', qid: 'book-ch2_5', topicId: 'book-ch2', ts: T0 + 2 * DAY, mode: 'mock' }),
+    input({ rid: 'd', qid: 'book-ch2_6', topicId: 'book-ch2', ts: T0 + 3 * DAY, mode: 'topic', correct: false }),
+    input({ rid: 'e', qid: 'book-ch1_1', topicId: 'book-ch1', ts: T0 + 4 * DAY, mode: 'review' }),
+  ]);
+}
+
+describe('record shape', () => {
+  it('rejects a record that violates the schema instead of storing it', () => {
+    expect(() => createResponse(input({ qid: '' }))).toThrowError(/qid is required/);
+    expect(() => createResponse(input({ latencyMs: -1 }))).toThrowError(/latencyMs/);
+    // `mode` is a closed union; an overloaded pseudo-id like the legacy
+    // `quick-practice` must not sneak in as a mode.
+    expect(() =>
+      createResponse(input({ mode: 'quick-practice' as unknown as ResponseInput['mode'] })),
+    ).toThrowError(/not a PracticeMode/);
+  });
+
+  it('accepts a null chosenIndex, which is how "not recorded" is expressed', () => {
+    const record = createResponse(input({ chosenIndex: null }));
+    expect(validateResponse(record)).toEqual([]);
+    expect(record.chosenIndex).toBeNull();
+  });
+
+  it('mints a rid and freezes the record, so the log cannot be edited in place', () => {
+    const record = createResponse(input({ rid: undefined }));
+    expect(record.rid).toBeTruthy();
+    expect(Object.isFrozen(record)).toBe(true);
+  });
+});
+
+describe('query planning', () => {
+  it('picks the narrowest index available', () => {
+    expect(planScan({ qid: 'book-ch1_1' })).toMatchObject({ index: 'qid', chronological: false });
+    expect(planScan({ attemptId: 'att-1' })).toMatchObject({ index: 'attemptId', chronological: false });
+    expect(planScan({ mode: 'mock' })).toMatchObject({ index: 'mode', chronological: false });
+    expect(planScan({ from: 1, to: 2 })).toMatchObject({ index: 'ts', chronological: true });
+    expect(planScan({})).toMatchObject({ index: 'ts', range: null, chronological: true });
+  });
+
+  it('bounds a topic query by [topicId, ts] so a time window does not scan the chapter', () => {
+    const plan = planScan({ topicId: 'book-ch1', from: 10, to: 20 });
+    expect(plan.index).toBe('topicId_ts');
+    expect(plan.range).toEqual({ kind: 'bound', lower: ['book-ch1', 10], upper: ['book-ch1', 20] });
+  });
+
+  it('matchesQuery is the single source of truth for both stores', () => {
+    const record = createResponse(input({ rid: 'x', imputed: ['ts'] }));
+    expect(matchesQuery(record, { topicId: 'book-ch1' })).toBe(true);
+    expect(matchesQuery(record, { topicId: 'book-ch2' })).toBe(false);
+    expect(matchesQuery(record, { excludeImputedTs: true })).toBe(false);
+  });
+});
+
+/**
+ * Both stores must behave identically — that is the contract that lets the rest
+ * of the model be tested without IndexedDB.
+ */
+function storeContract(name: string, make: () => ResponseLogStore): void {
+  describe(`${name} store`, () => {
+  it('appends and reads back chronologically', async () => {
+    const store = make();
+    await seed(store);
+    const all = await store.query();
+    expect(all.map((r) => r.rid)).toEqual(['a', 'b', 'c', 'd', 'e']);
+    expect(await store.count()).toBe(5);
+  });
+
+  it('filters by topic, mode, qid and time window', async () => {
+    const store = make();
+    await seed(store);
+    expect((await store.query({ topicId: 'book-ch1' })).map((r) => r.rid)).toEqual(['a', 'b', 'e']);
+    expect((await store.query({ mode: 'mock' })).map((r) => r.rid)).toEqual(['c']);
+    expect((await store.query({ qid: 'book-ch1_1' })).map((r) => r.rid)).toEqual(['a', 'e']);
+    expect((await store.query({ from: T0 + DAY, to: T0 + 2 * DAY })).map((r) => r.rid)).toEqual(['b', 'c']);
+    expect(await store.count({ topicId: 'book-ch2' })).toBe(2);
+  });
+
+  it('honours direction and limit', async () => {
+    const store = make();
+    await seed(store);
+    expect((await store.query({ direction: 'desc', limit: 2 })).map((r) => r.rid)).toEqual(['e', 'd']);
+  });
+
+  it('streams through a cursor and stops early when the visitor says so', async () => {
+    const store = make();
+    await seed(store);
+    const seen: string[] = [];
+    const visited = await store.iterate({ topicId: 'book-ch1' }, (record) => {
+      seen.push(record.rid);
+      return false; // answer "has this learner ever touched ch1" without materialising it
+    });
+    expect(seen).toEqual(['a']);
+    expect(visited).toBe(0);
+
+    const allSeen: string[] = [];
+    await store.iterate(undefined, (record) => {
+      allSeen.push(record.rid);
+    });
+    expect(allSeen).toEqual(['a', 'b', 'c', 'd', 'e']);
+  });
+
+  it('treats a repeated rid as an error, because the log is immutable', async () => {
+    const store = make();
+    await store.append(input({ rid: 'dup' }));
+    await expect(store.append(input({ rid: 'dup', correct: false }))).rejects.toMatchObject({
+      code: 'duplicate',
+    });
+    // The original must survive: an append may never rewrite history.
+    expect((await store.query({}))[0].correct).toBe(true);
+  });
+
+  it('absorbs duplicates when asked, which is what makes a device merge idempotent', async () => {
+    const store = make();
+    await store.appendMany([input({ rid: 'x' })]);
+    const result = await store.appendMany([input({ rid: 'x' }), input({ rid: 'y' })], { skipDuplicates: true });
+    expect(result).toEqual({ appended: 1, duplicates: 1 });
+    expect(await store.count()).toBe(2);
+  });
+
+  it('exports every record with a schema tag', async () => {
+    const store = make();
+    await seed(store);
+    const dump = await store.exportAll();
+    expect(dump.schema).toBe('necprep-responselog-v1');
+    expect(dump.count).toBe(5);
+    expect(dump.records).toHaveLength(5);
+  });
+
+  it('clears on an explicit reset', async () => {
+    const store = make();
+    await seed(store);
+    await store.clearAll();
+    expect(await store.count()).toBe(0);
+  });
+  });
+}
+
+storeContract('indexeddb', () => idbStore());
+storeContract('memory', () => createMemoryResponseLogStore());
+
+describe('IndexedDB failure modes', () => {
+  it('reports `unavailable` when open() throws (private browsing)', async () => {
+    const store = idbStore({ throwOnOpen: true });
+    await expect(store.append(input())).rejects.toMatchObject({ code: 'unavailable' });
+    const probe = await probeResponseLog(store);
+    expect(probe).toMatchObject({ ok: false, code: 'unavailable' });
+  });
+
+  it('reports `unavailable` when there is no IndexedDB at all', async () => {
+    const store = createIndexedDbResponseLogStore({ factory: undefined, keyRange: undefined });
+    const probe = await probeResponseLog(store);
+    // jsdom provides no indexedDB, so this is the real private-browsing path.
+    expect(probe).toMatchObject({ ok: false, code: 'unavailable' });
+  });
+
+  it('reports `version-error` when the stored database is newer than this build', async () => {
+    const store = idbStore({ versionError: true });
+    await expect(store.count()).rejects.toMatchObject({ code: 'version-error' });
+  });
+
+  it('reports `blocked` when another tab holds the old version open', async () => {
+    const store = idbStore({ blockOpen: true });
+    await expect(store.count()).rejects.toMatchObject({ code: 'blocked' });
+  });
+
+  it('reports `quota-exceeded` and never pretends the write landed', async () => {
+    const store = idbStore({ quotaRowLimit: 2 });
+    await store.append(input({ rid: '1' }));
+    await store.append(input({ rid: '2' }));
+    const failure = await store.append(input({ rid: '3' })).catch((err: unknown) => err);
+    expect(isResponseLogError(failure) && failure.code).toBe('quota-exceeded');
+    // The whole transaction aborted, so the log still holds exactly two rows.
+    expect(await store.count()).toBe(2);
+  });
+
+  it('retries the open after a transient failure instead of caching it', async () => {
+    const fake = createFakeIndexedDb({ blockOpen: true });
+    const store = createIndexedDbResponseLogStore({
+      factory: fake.factory,
+      keyRange: fake.keyRange,
+      blockedTimeoutMs: 5,
+    });
+    await expect(store.count()).rejects.toMatchObject({ code: 'blocked' });
+    await expect(store.count()).rejects.toMatchObject({ code: 'blocked' });
+  });
+});
+
+// ─── Legacy migration ─────────────────────────────────────────────────────────
+
+function legacyStorage(progress: unknown, history: unknown): Pick<Storage, 'getItem'> {
+  const entries: Record<string, string> = {};
+  if (progress !== undefined) entries[LEGACY_PROGRESS_KEY] = JSON.stringify(progress);
+  if (history !== undefined) entries[LEGACY_HISTORY_KEY] = JSON.stringify(history);
+  return { getItem: (key: string) => entries[key] ?? null };
+}
+
+const LEGACY_PROGRESS = {
+  'book-ch1': { attempted: ['book-ch1_0', 'book-ch1_1', 'book-ch1_2'], correct: ['book-ch1_1'] },
+  'quick-practice': { attempted: ['book-ch2_7'], correct: ['book-ch2_7', 'book-ch2_8'] },
+};
+
+const LEGACY_HISTORY = [
+  { topicId: 'full-mock-1', topicName: 'Full Mock Test 1', score: 42, total: 100, date: '2025-11-02' },
+  { topicId: 'book-ch3', topicName: 'Chapter 3', score: 7, total: 10, date: '2025-11-03' },
+];
+
+describe('migrateLegacyProgress', () => {
+  it('marks every reconstructed field as imputed and never invents a chosen option', () => {
+    const plan = planLegacyMigration({
+      storage: legacyStorage(LEGACY_PROGRESS, LEGACY_HISTORY),
+      now: T0,
+    });
+
+    expect(plan.records).toHaveLength(5);
+    expect(plan.imputedFields).toEqual(['ts', 'chosenIndex', 'latencyMs', 'mode', 'flaggedGuess']);
+
+    for (const record of plan.records) {
+      expect(record.source).toBe('legacy-migration');
+      // The legacy store recorded which questions were answered, never which
+      // option was picked, so this must stay null rather than become a guess.
+      expect(record.chosenIndex).toBeNull();
+      expect(record.imputed).toEqual(['ts', 'chosenIndex', 'latencyMs', 'mode', 'flaggedGuess']);
+      expect(record.latencyMs).toBe(0);
+      expect(record.flaggedGuess).toBe(false);
+      // Timestamps were never stored, so they are backdated one mastery
+      // half-life rather than stamped "now".
+      expect(record.ts).toBe(T0 - LEGACY_TS_BACKDATE_DAYS * DAY);
+    }
+  });
+
+  it('recovers the real chapter from the question id, not the overloaded legacy key', () => {
+    const plan = planLegacyMigration({ storage: legacyStorage(LEGACY_PROGRESS, undefined), now: T0 });
+    const migrated = plan.records.filter((record) => record.qid.startsWith('book-ch2_'));
+    // These sat under the pseudo-id `quick-practice` in the legacy store.
+    expect(migrated.map((record) => record.topicId)).toEqual(['book-ch2', 'book-ch2']);
+  });
+
+  it('carries the correct/incorrect split across, and warns that it is an upper bound', () => {
+    const plan = planLegacyMigration({ storage: legacyStorage(LEGACY_PROGRESS, undefined), now: T0 });
+    const byQid = new Map(plan.records.map((record) => [record.qid, record.correct]));
+    expect(byQid.get('book-ch1_1')).toBe(true);
+    expect(byQid.get('book-ch1_0')).toBe(false);
+    expect(plan.stats.markedCorrect).toBe(3);
+    expect(plan.warnings.join(' ')).toMatch(/upper bound/);
+  });
+
+  it('counts ids that were only ever in `correct` instead of dropping them', () => {
+    const plan = planLegacyMigration({ storage: legacyStorage(LEGACY_PROGRESS, undefined), now: T0 });
+    expect(plan.stats.correctWithoutAttempt).toBe(1);
+    expect(plan.records.some((record) => record.qid === 'book-ch2_8')).toBe(true);
+  });
+
+  it('refuses to fabricate response records out of eng_history rows', () => {
+    const plan = planLegacyMigration({ storage: legacyStorage({}, LEGACY_HISTORY), now: T0 });
+    expect(plan.records).toHaveLength(0);
+    expect(plan.stats.legacyHistoryEntries).toBe(2);
+    expect(plan.skipped[0].what).toMatch(/2 eng_history row/);
+    expect(plan.skipped[0].reason).toMatch(/no question ids/);
+  });
+
+  it('is idempotent: a second run appends nothing', async () => {
+    const store = createMemoryResponseLogStore();
+    const options = { storage: legacyStorage(LEGACY_PROGRESS, LEGACY_HISTORY), now: T0, store };
+    const first = await migrateLegacyProgress(options);
+    const second = await migrateLegacyProgress(options);
+    expect(first).toMatchObject({ appended: 5, duplicates: 0 });
+    expect(second).toMatchObject({ appended: 0, duplicates: 5 });
+    expect(await store.count()).toBe(5);
+  });
+
+  it('survives a missing or corrupt legacy store', () => {
+    const empty = planLegacyMigration({ storage: { getItem: () => null }, now: T0 });
+    expect(empty.records).toHaveLength(0);
+    expect(empty.warnings.join(' ')).toMatch(/missing or unreadable/);
+
+    const corrupt = planLegacyMigration({ storage: { getItem: () => '{not json' }, now: T0 });
+    expect(corrupt.records).toHaveLength(0);
+  });
+});
diff --git a/frontend/src/services/__tests__/scheduler.test.ts b/frontend/src/services/__tests__/scheduler.test.ts
new file mode 100644
index 0000000..893950c
--- /dev/null
+++ b/frontend/src/services/__tests__/scheduler.test.ts
@@ -0,0 +1,372 @@
+import { describe, it, expect } from 'vitest';
+import {
+  CardState,
+  DEFAULT_LATENCY_THRESHOLDS,
+  GRADUATE_GOOD_DAYS,
+  GRADUATE_HARD_DAYS,
+  LEECH_LAPSE_THRESHOLD,
+  MAX_CONSECUTIVE_SAME_SUBCHAPTER,
+  Rating,
+  RELEARN_STEP_MINUTES,
+  difficultyToEase,
+  easeToDifficulty,
+  examReadiness,
+  formatReadiness,
+  gradeCard,
+  isLeech,
+  newCard,
+  normalCdf,
+  ratingFromOutcome,
+  scheduleCard,
+  selectDueQueue,
+  selectNextQuestions,
+} from '../scheduler';
+import type { Card, QuestionCandidate, ReadinessSection } from '../scheduler';
+import { estimateMastery } from '../mastery';
+import type { AssessedMastery, MasteryEstimate } from '../mastery';
+import { eloForSuccessProbability, expectedCorrect } from '../ability';
+
+const NOW = Date.UTC(2026, 9, 20, 12, 0, 0);
+const DAY = 24 * 60 * 60 * 1000;
+
+function assessed(mastery: number, coverage: number, nEff = 20): AssessedMastery {
+  return {
+    state: 'assessed',
+    nEff,
+    xEff: nEff * mastery,
+    distinctQids: Math.round(coverage * 12),
+    coverage,
+    responses: nEff,
+    lastSeen: NOW,
+    accHat: mastery,
+    mastery,
+    confidence: nEff / (nEff + 8),
+    bucket: 'developing',
+    chapterMean: 0.5,
+  };
+}
+
+function notAssessed(): MasteryEstimate {
+  return estimateMastery([], { now: NOW });
+}
+
+describe('rating from outcome', () => {
+  it('maps a wrong answer to Again', () => {
+    expect(ratingFromOutcome({ correct: false, latencyMs: 8000 })).toBe(Rating.Again);
+    expect(ratingFromOutcome({ correct: false, latencyMs: 100 })).toBe(Rating.Again);
+  });
+
+  it('maps correct and fast to Good', () => {
+    expect(ratingFromOutcome({ correct: true, latencyMs: 8000 })).toBe(Rating.Good);
+  });
+
+  it('maps correct and slow to Hard', () => {
+    expect(ratingFromOutcome({ correct: true, latencyMs: DEFAULT_LATENCY_THRESHOLDS.slowMs + 1 })).toBe(
+      Rating.Hard,
+    );
+  });
+
+  it('maps a correct answer under the guess threshold to Hard, not Easy', () => {
+    expect(ratingFromOutcome({ correct: true, latencyMs: DEFAULT_LATENCY_THRESHOLDS.guessMs - 1 })).toBe(
+      Rating.Hard,
+    );
+    expect(ratingFromOutcome({ correct: true, latencyMs: 9000, flaggedGuess: true })).toBe(Rating.Hard);
+  });
+
+  it('never returns Easy, whatever the outcome', () => {
+    for (const correct of [true, false]) {
+      for (const latencyMs of [0, 1, 3999, 4000, 5000, 29999, 30001, 600000]) {
+        for (const flaggedGuess of [true, false]) {
+          expect(ratingFromOutcome({ correct, latencyMs, flaggedGuess })).not.toBe(Rating.Easy);
+        }
+      }
+    }
+  });
+
+  it('ignores the latency bands when latency was imputed by the migration', () => {
+    // A legacy-migrated record carries latencyMs: 0, which must not be read as
+    // an impossibly fast guess.
+    expect(ratingFromOutcome({ correct: true, latencyMs: 0, imputed: ['latencyMs'] })).toBe(Rating.Good);
+    expect(ratingFromOutcome({ correct: true, latencyMs: 0 })).toBe(Rating.Hard);
+    // The default floor matches features/quiz/guess.ts's GUESS_FLOOR_MS.
+    expect(DEFAULT_LATENCY_THRESHOLDS.guessMs).toBe(4000);
+  });
+});
+
+describe('difficulty / ease mapping', () => {
+  it('round-trips across the FSRS 1..10 scale', () => {
+    for (const difficulty of [1, 2.5, 5, 7.5, 10]) {
+      expect(easeToDifficulty(difficultyToEase(difficulty))).toBeCloseTo(difficulty, 10);
+    }
+    expect(difficultyToEase(1)).toBeCloseTo(2.5, 10);
+    expect(difficultyToEase(10)).toBeCloseTo(1.3, 10);
+  });
+});
+
+describe('scheduling', () => {
+  it('starts a card in the New state, due immediately', () => {
+    const card = newCard('q1', NOW);
+    expect(card.state).toBe(CardState.New);
+    expect(card).toMatchObject({ reps: 0, lapses: 0, stability: 0, scheduledDays: 0, lastReview: null });
+    expect(card.due).toBe(NOW);
+  });
+
+  it('graduates a new card to 2 days on Good and 1 day on Hard', () => {
+    const good = scheduleCard(newCard('q1', NOW), Rating.Good, NOW);
+    expect(good.state).toBe(CardState.Review);
+    expect(good.scheduledDays).toBe(GRADUATE_GOOD_DAYS);
+    expect(good.due).toBe(NOW + GRADUATE_GOOD_DAYS * DAY);
+    expect(good.stability).toBe(GRADUATE_GOOD_DAYS);
+
+    const hard = scheduleCard(newCard('q1', NOW), Rating.Hard, NOW);
+    expect(hard.scheduledDays).toBe(GRADUATE_HARD_DAYS);
+    expect(hard.difficulty).toBeGreaterThan(good.difficulty);
+  });
+
+  it('lapses to relearning on Again and re-shows within the session', () => {
+    const mature: Card = { ...newCard('q1', NOW), state: CardState.Review, stability: 30, reps: 5, lapses: 1 };
+    const lapsed = scheduleCard(mature, Rating.Again, NOW);
+    expect(lapsed.state).toBe(CardState.Relearning);
+    expect(lapsed.lapses).toBe(2);
+    expect(lapsed.scheduledDays).toBe(0);
+    expect(lapsed.stability).toBe(0);
+    expect(lapsed.due).toBe(NOW + RELEARN_STEP_MINUTES * 60 * 1000);
+    expect(lapsed.difficulty).toBeGreaterThan(mature.difficulty);
+  });
+
+  it('multiplies the interval by the ease factor on a mature Good', () => {
+    const mature: Card = {
+      ...newCard('q1', NOW),
+      state: CardState.Review,
+      stability: 10,
+      scheduledDays: 10,
+      reps: 3,
+      lastReview: NOW - 10 * DAY,
+    };
+    const next = scheduleCard(mature, Rating.Good, NOW);
+    // Good is ease-neutral in SM-2, so the ease stays at difficulty 5's value.
+    expect(next.scheduledDays).toBe(Math.round(10 * difficultyToEase(5)));
+    expect(next.elapsedDays).toBeCloseTo(10, 6);
+    expect(next.difficulty).toBeCloseTo(5, 6);
+  });
+
+  it('grows the interval only slightly on a mature Hard', () => {
+    const mature: Card = { ...newCard('q1', NOW), state: CardState.Review, stability: 10, reps: 3 };
+    const next = scheduleCard(mature, Rating.Hard, NOW);
+    expect(next.scheduledDays).toBe(12);
+    expect(next.scheduledDays).toBeLessThan(Math.round(10 * difficultyToEase(5)));
+  });
+
+  it('caps the interval', () => {
+    const huge: Card = { ...newCard('q1', NOW), state: CardState.Review, stability: 5000, reps: 20 };
+    expect(scheduleCard(huge, Rating.Good, NOW).scheduledDays).toBe(365);
+  });
+
+  it('does not mutate the card it grades', () => {
+    const card = newCard('q1', NOW);
+    scheduleCard(card, Rating.Good, NOW);
+    expect(card.reps).toBe(0);
+    expect(card.state).toBe(CardState.New);
+  });
+
+  it('grades straight from a quiz outcome', () => {
+    const { card, rating } = gradeCard(newCard('q1', NOW), { correct: true, latencyMs: 6000 }, NOW);
+    expect(rating).toBe(Rating.Good);
+    expect(card.scheduledDays).toBe(GRADUATE_GOOD_DAYS);
+  });
+});
+
+describe('due queue and leeches', () => {
+  it('flags a card as a leech at six lapses', () => {
+    expect(isLeech({ ...newCard('q', NOW), lapses: LEECH_LAPSE_THRESHOLD - 1 })).toBe(false);
+    expect(isLeech({ ...newCard('q', NOW), lapses: LEECH_LAPSE_THRESHOLD })).toBe(true);
+  });
+
+  it('splits due, leech and upcoming cards, most overdue first', () => {
+    const cards: Card[] = [
+      { ...newCard('late', NOW), due: NOW - 5 * DAY },
+      { ...newCard('justDue', NOW), due: NOW - 1000 },
+      { ...newCard('leech', NOW), due: NOW - 2 * DAY, lapses: 7 },
+      { ...newCard('future', NOW), due: NOW + DAY },
+    ];
+    const queue = selectDueQueue(cards, { now: NOW });
+    expect(queue.due.map((c) => c.qid)).toEqual(['late', 'justDue']);
+    expect(queue.leeches.map((c) => c.qid)).toEqual(['leech']);
+    expect(queue.upcoming.map((c) => c.qid)).toEqual(['future']);
+  });
+
+  it('honours the session limit', () => {
+    const cards = Array.from({ length: 10 }, (_, i) => ({ ...newCard(`q${i}`, NOW), due: NOW - i * 1000 }));
+    expect(selectDueQueue(cards, { now: NOW, limit: 3 }).due).toHaveLength(3);
+  });
+});
+
+describe('next-question selection', () => {
+  const theta = 1200;
+
+  function candidate(qid: string, subchapter: string, itemElo: number, due?: number): QuestionCandidate {
+    return { qid, topicId: 'book-ch1', subchapter, itemElo, due };
+  }
+
+  it('targets roughly 80% success, i.e. items easier than the learner', () => {
+    const target = eloForSuccessProbability(theta, 0.8);
+    const picked = selectNextQuestions(
+      [
+        candidate('far-hard', 'a', theta + 400),
+        candidate('on-target', 'b', Math.round(target)),
+        candidate('far-easy', 'c', theta - 700),
+      ],
+      { chapterTheta: theta, count: 1, now: NOW },
+    );
+    expect(picked[0].qid).toBe('on-target');
+    expect(picked[0].predictedSuccess).toBeCloseTo(0.8, 2);
+    // Sanity-check the direction: the on-target item is EASIER than the learner.
+    expect(picked[0].itemElo).toBeLessThan(theta);
+    expect(expectedCorrect(theta, theta + 240)).toBeLessThan(0.25);
+  });
+
+  it('prefers a due item over a slightly better-matched new one', () => {
+    const target = Math.round(eloForSuccessProbability(theta, 0.8));
+    const picked = selectNextQuestions(
+      [
+        candidate('new-perfect', 'a', target),
+        candidate('due-nearby', 'b', target + 100, NOW - DAY),
+      ],
+      { chapterTheta: theta, count: 1, now: NOW },
+    );
+    expect(picked[0].qid).toBe('due-nearby');
+    expect(picked[0].wasDue).toBe(true);
+  });
+
+  it('never emits more than three consecutive items from one sub-chapter', () => {
+    const target = Math.round(eloForSuccessProbability(theta, 0.8));
+    const candidates: QuestionCandidate[] = [
+      // 12 items from 'a' all perfectly on target, so a naive greedy selector
+      // would emit twelve in a row.
+      ...Array.from({ length: 12 }, (_, i) => candidate(`a${String(i).padStart(2, '0')}`, 'a', target)),
+      ...Array.from({ length: 8 }, (_, i) => candidate(`b${String(i).padStart(2, '0')}`, 'b', target + 5)),
+    ];
+    const picked = selectNextQuestions(candidates, { chapterTheta: theta, count: 16, now: NOW });
+    expect(picked).toHaveLength(16);
+
+    let run = 1;
+    let longest = 1;
+    for (let i = 1; i < picked.length; i += 1) {
+      run = picked[i].subchapter === picked[i - 1].subchapter ? run + 1 : 1;
+      longest = Math.max(longest, run);
+    }
+    expect(longest).toBe(MAX_CONSECUTIVE_SAME_SUBCHAPTER);
+    expect(longest).toBeLessThanOrEqual(MAX_CONSECUTIVE_SAME_SUBCHAPTER);
+  });
+
+  it('stops short rather than breaking the interleaving constraint', () => {
+    const candidates = Array.from({ length: 10 }, (_, i) => candidate(`a${i}`, 'only-one', 1000));
+    const picked = selectNextQuestions(candidates, { chapterTheta: theta, count: 10, now: NOW });
+    expect(picked).toHaveLength(MAX_CONSECUTIVE_SAME_SUBCHAPTER);
+  });
+
+  it('never repeats a question inside one selection', () => {
+    const candidates = [candidate('q1', 'a', 1000), candidate('q2', 'b', 1000)];
+    const picked = selectNextQuestions(candidates, { chapterTheta: theta, count: 5, now: NOW });
+    expect(new Set(picked.map((p) => p.qid)).size).toBe(picked.length);
+  });
+
+  it('is deterministic', () => {
+    const candidates = Array.from({ length: 20 }, (_, i) =>
+      candidate(`q${i}`, `s${i % 4}`, 900 + i * 13),
+    );
+    const first = selectNextQuestions(candidates, { chapterTheta: theta, count: 10, now: NOW });
+    const second = selectNextQuestions(candidates, { chapterTheta: theta, count: 10, now: NOW });
+    expect(first.map((p) => p.qid)).toEqual(second.map((p) => p.qid));
+  });
+});
+
+describe('normalCdf', () => {
+  it('matches known values', () => {
+    expect(normalCdf(0)).toBeCloseTo(0.5, 6);
+    expect(normalCdf(1)).toBeCloseTo(0.8413, 4);
+    expect(normalCdf(-1)).toBeCloseTo(0.1587, 4);
+    expect(normalCdf(1.96)).toBeCloseTo(0.975, 3);
+  });
+});
+
+describe('examReadiness', () => {
+  const blueprint = (estimates: MasteryEstimate[]): ReadinessSection[] =>
+    estimates.map((estimate, i) => ({ unitId: `u${i}`, marks: 10, estimate }));
+
+  it('caps the estimate at 0.35 + 0.65 * coverage, and says so', () => {
+    // Ten units, every one answered well but only on a narrow slice.
+    const readiness = examReadiness(blueprint(Array.from({ length: 10 }, () => assessed(0.9, 0.1))));
+    expect(readiness.overallCoverage).toBeCloseTo(0.1, 10);
+    expect(readiness.cap).toBeCloseTo(0.415, 10);
+    expect(readiness.uncappedScore).toBeCloseTo(0.9, 10);
+    expect(readiness.expectedScore).toBeCloseTo(0.415, 10);
+    expect(readiness.cappedBy).toBe('coverage');
+  });
+
+  it('cannot show 90% ready to someone who has seen 4% of the bank', () => {
+    // One unit mastered out of 25; the other 24 untouched.
+    const sections: ReadinessSection[] = [
+      { unitId: 'seen', marks: 10, estimate: assessed(0.95, 1, 40) },
+      ...Array.from({ length: 24 }, (_, i) => ({
+        unitId: `unseen${i}`,
+        marks: 10,
+        estimate: notAssessed(),
+      })),
+    ];
+    const readiness = examReadiness(sections);
+    expect(readiness.overallCoverage).toBeCloseTo(0.04, 10);
+    expect(readiness.cap).toBeCloseTo(0.376, 10);
+    expect(readiness.expectedScore).toBeLessThanOrEqual(readiness.cap);
+    expect(readiness.notAssessedMarks).toBe(240);
+    expect(readiness.assessedMarks).toBe(10);
+  });
+
+  it('leaves a genuinely well-covered learner uncapped', () => {
+    const readiness = examReadiness(blueprint(Array.from({ length: 10 }, () => assessed(0.82, 1, 60))));
+    expect(readiness.cap).toBeCloseTo(1, 10);
+    expect(readiness.cappedBy).toBeNull();
+    expect(readiness.expectedScore).toBeCloseTo(0.82, 10);
+    expect(readiness.probabilityOfPassing).toBeGreaterThan(0.99);
+  });
+
+  it('always returns an interval alongside the point estimate', () => {
+    const readiness = examReadiness(blueprint(Array.from({ length: 10 }, () => assessed(0.6, 0.8, 15))));
+    expect(readiness.interval.level).toBe(0.9);
+    expect(readiness.interval.lower).toBeLessThan(readiness.expectedScore);
+    expect(readiness.interval.upper).toBeGreaterThan(readiness.expectedScore);
+    expect(readiness.interval.lower).toBeGreaterThanOrEqual(0);
+    expect(readiness.interval.upper).toBeLessThanOrEqual(1);
+    expect(readiness.standardDeviation).toBeGreaterThan(0);
+  });
+
+  it('widens the interval when the sample behind it is thin', () => {
+    const thin = examReadiness(blueprint(Array.from({ length: 10 }, () => assessed(0.6, 1, 4))));
+    const thick = examReadiness(blueprint(Array.from({ length: 10 }, () => assessed(0.6, 1, 200))));
+    const width = (r: typeof thin) => r.interval.upper - r.interval.lower;
+    expect(width(thin)).toBeGreaterThan(width(thick));
+  });
+
+  it('treats an unassessed unit as the guess floor with wide uncertainty', () => {
+    const allUnknown = examReadiness(blueprint(Array.from({ length: 10 }, () => notAssessed())));
+    expect(allUnknown.overallCoverage).toBe(0);
+    expect(allUnknown.cap).toBeCloseTo(0.35, 10);
+    expect(allUnknown.uncappedScore).toBeCloseTo(0.25, 10);
+    // Below the cap, so the cap is not what is holding it down here.
+    expect(allUnknown.cappedBy).toBeNull();
+    expect(allUnknown.probabilityOfPassing).toBeLessThan(0.3);
+  });
+
+  it('degrades safely on an empty blueprint', () => {
+    const readiness = examReadiness([]);
+    expect(readiness).toMatchObject({ expectedScore: 0, totalMarks: 0, probabilityOfPassing: 0 });
+  });
+
+  it('formats as a range, never a bare number', () => {
+    const capped = examReadiness(blueprint(Array.from({ length: 10 }, () => assessed(0.9, 0.1))));
+    const text = formatReadiness(capped);
+    expect(text).toMatch(/%\s*\(\d+%–\d+%\)/);
+    expect(text).toMatch(/capped/);
+    expect(formatReadiness(examReadiness(blueprint([assessed(0.7, 1, 50)])))).toMatch(/–/);
+  });
+});
diff --git a/frontend/src/services/__tests__/subchapterClassifier.test.ts b/frontend/src/services/__tests__/subchapterClassifier.test.ts
new file mode 100644
index 0000000..9eb270a
--- /dev/null
+++ b/frontend/src/services/__tests__/subchapterClassifier.test.ts
@@ -0,0 +1,199 @@
+import { describe, it, expect } from 'vitest';
+import {
+  classifySubchapter,
+  confidenceBp,
+  CLASSIFIER_THRESHOLDS,
+} from '../subchapterClassifier';
+import { SUBCHAPTER_TERMS } from '../../data/subchapterTerms';
+import { syllabusChapters, syllabusSubchapters, SUBCHAPTER_COUNT } from '../../data/syllabus';
+
+/**
+ * The classifier's value is not that it labels questions — it is that it
+ * REFUSES to label the ones it cannot separate, because a wrong syllabus
+ * reference shown to a student is worse than none. Most of these tests are
+ * therefore about declining.
+ */
+
+const q = (bookChapterId: string, question: string, options: string[] = []) =>
+  classifySubchapter({ bookChapterId, question, options });
+
+describe('subchapter term lists', () => {
+  it('covers all 60 sub-chapters, with no empty strong list', () => {
+    expect(Object.keys(SUBCHAPTER_TERMS)).toHaveLength(SUBCHAPTER_COUNT);
+    for (const sub of syllabusSubchapters) {
+      const terms = SUBCHAPTER_TERMS[sub.code];
+      expect(terms, sub.code).toBeDefined();
+      expect(terms.strong.length, `${sub.code} has no strong terms`).toBeGreaterThan(0);
+    }
+  });
+
+  it('never gives the same strong term to two sub-chapters of one chapter', () => {
+    // A strong term shared within a chapter can only ever produce a tie, which
+    // the margin rule then declines — so it is dead weight at best and a
+    // silent coverage hole at worst.
+    for (const chapter of syllabusChapters) {
+      const seen = new Map<string, string>();
+      for (const sub of chapter.subchapters) {
+        for (const term of SUBCHAPTER_TERMS[sub.code].strong) {
+          const owner = seen.get(term);
+          expect(
+            owner,
+            `"${term}" is strong in both ${owner ?? ''} and ${sub.code}`
+          ).toBeUndefined();
+          seen.set(term, sub.code);
+        }
+      }
+    }
+  });
+
+  it('stores terms lowercased, since matching is case-insensitive', () => {
+    for (const sub of syllabusSubchapters) {
+      const terms = SUBCHAPTER_TERMS[sub.code];
+      for (const term of [...terms.strong, ...terms.weak]) {
+        expect(term, `${sub.code}: "${term}"`).toBe(term.toLowerCase());
+        expect(term.trim(), `${sub.code}: "${term}" has edge whitespace`).toBe(term);
+      }
+    }
+  });
+});
+
+describe('classifySubchapter', () => {
+  it('labels a question whose stem names its topic', () => {
+    const hit = q('book-ch5', 'Which protocol provides reliable, connection-oriented delivery using a three-way handshake?');
+    expect(hit?.code).toBe('ACtE0504');
+    expect(hit?.displayCode).toBe('5.4');
+    expect(hit?.title).toBe('Transport Layer');
+  });
+
+  it('separates neighbouring topics inside one chapter', () => {
+    expect(q('book-ch5', 'A subnet mask of 255.255.255.0 in CIDR notation is written as:')?.displayCode).toBe('5.3');
+    expect(q('book-ch5', 'Which cipher uses a public key and a private key?')?.displayCode).toBe('5.6');
+    expect(q('book-ch5', 'CSMA/CD is used to resolve collisions in which layer?')?.displayCode).toBe('5.2');
+  });
+
+  it('declines when two sub-chapters are genuinely tied', () => {
+    // One decisive term each — `tcp` for 5.4, `ospf` for 5.3 — so neither
+    // clears the margin and the only honest answer is "chapter 5".
+    expect(q('book-ch5', 'Does TCP sit above OSPF?')).toBeNull();
+  });
+
+  it('still picks a winner when one side has more evidence than the other', () => {
+    // The counterpart to the tie above: three 5.3 terms against two 5.4 terms
+    // is a real difference, not a coin flip, so declining here would be
+    // over-cautious.
+    expect(
+      q('book-ch5', 'Compare TCP congestion control with OSPF link state routing.')?.displayCode
+    ).toBe('5.3');
+  });
+
+  it('declines a stem with no topical vocabulary at all', () => {
+    expect(q('book-ch7', 'Which of the following statements is true?')).toBeNull();
+    expect(q('book-ch7', '')).toBeNull();
+  });
+
+  it('declines on a single weak term, which is noise rather than evidence', () => {
+    // 'voltage' is weak in 1.1 and chapter-1-wide; one weak hit scores 1,
+    // below MIN_SCORE.
+    expect(q('book-ch1', 'The voltage is measured.')).toBeNull();
+  });
+
+  it('returns null for an unknown chapter rather than throwing', () => {
+    expect(q('book-ch99', 'Thevenin equivalent resistance is found by:')).toBeNull();
+    expect(q('', 'Thevenin equivalent resistance is found by:')).toBeNull();
+  });
+
+  it('does not let a distractor overrule a decisive stem', () => {
+    // Regression: the stem names 10.4 outright, while the wrong answer
+    // "Depreciation" is 10.2 vocabulary. Scoring stem and options together
+    // closed the margin and declined a question that was never ambiguous.
+    const hit = q(
+      'book-ch10',
+      'Which of the following is NOT a phase in the project life cycle?',
+      ['Initiation', 'Planning', 'Execution', 'Depreciation']
+    );
+    expect(hit?.displayCode).toBe('10.4');
+  });
+
+  it('falls back to the options when the stem is generic', () => {
+    // Nothing in this stem is topical, so the only evidence is in the options.
+    const hit = q('book-ch6', 'Which of the following is NOT one of these?', [
+      'Dijkstra',
+      'A pushdown automaton',
+      'A context-free grammar',
+      'A parse tree',
+    ]);
+    expect(hit?.displayCode).toBe('6.2');
+  });
+
+  it('matches plural forms of a term', () => {
+    // 'requirement elicitation' must cover "Requirements elicitation", which
+    // is how the bank actually writes it.
+    expect(q('book-ch8', 'Requirements elicitation techniques include:')?.displayCode).toBe('8.1');
+  });
+
+  it('treats hyphens and spaces as interchangeable', () => {
+    const spaced = q('book-ch4', 'An open loop control system:');
+    const hyphenated = q('book-ch4', 'An open-loop control system:');
+    expect(hyphenated?.code).toBe(spaced?.code);
+    expect(hyphenated?.displayCode).toBe('4.5');
+  });
+
+  it('respects word boundaries rather than matching substrings', () => {
+    // 'ac' is weak in 1.3. It must not fire on "accurate", and 'ram' must not
+    // fire on "program".
+    expect(q('book-ch1', 'Which is the most accurate statement?')).toBeNull();
+    expect(q('book-ch4', 'A program is loaded.')).toBeNull();
+  });
+
+  it('reports the terms that drove the decision', () => {
+    const hit = q('book-ch9', 'Backpropagation adjusts the synaptic weights of a multilayer perceptron.');
+    expect(hit?.displayCode).toBe('9.6');
+    expect(hit?.matchedTerms).toContain('backpropagation');
+  });
+
+  it('never reports a sub-chapter outside the question\'s own chapter', () => {
+    // A chapter-5 question must never be labelled with a chapter-3 code, even
+    // when it mentions programming.
+    const hit = q('book-ch5', 'A socket is created with a port number before the three-way handshake.');
+    expect(hit?.code.startsWith('ACtE05')).toBe(true);
+  });
+});
+
+describe('confidence', () => {
+  it('stays inside 0-10000 and never claims certainty', () => {
+    expect(confidenceBp(0, 0)).toBe(0);
+    expect(confidenceBp(100, 0)).toBeLessThanOrEqual(9000);
+    expect(confidenceBp(3, 0)).toBeGreaterThan(0);
+  });
+
+  it('rises with evidence and with separation from the runner-up', () => {
+    expect(confidenceBp(12, 0)).toBeGreaterThan(confidenceBp(3, 0));
+    expect(confidenceBp(6, 0)).toBeGreaterThan(confidenceBp(6, 4));
+  });
+
+  it('is an integer, because D1 stores it in an INTEGER column', () => {
+    for (const [top, runner] of [[3, 0], [7, 2], [11, 5], [4, 1]]) {
+      expect(Number.isInteger(confidenceBp(top, runner))).toBe(true);
+    }
+  });
+
+  it('reports a real confidence on every labelled question', () => {
+    const hit = q('book-ch2', 'What is the decimal equivalent of the binary number 1011?');
+    expect(hit).not.toBeNull();
+    expect(hit?.confidenceBp).toBeGreaterThan(0);
+    expect(hit?.confidenceBp).toBeLessThanOrEqual(9000);
+  });
+});
+
+describe('thresholds', () => {
+  it('requires more than one weak term to label anything', () => {
+    expect(CLASSIFIER_THRESHOLDS.MIN_SCORE).toBeGreaterThan(
+      CLASSIFIER_THRESHOLDS.WEAK_WEIGHT
+    );
+  });
+
+  it('discounts options relative to the stem', () => {
+    expect(CLASSIFIER_THRESHOLDS.OPTION_WEIGHT).toBeLessThan(1);
+    expect(CLASSIFIER_THRESHOLDS.OPTION_WEIGHT).toBeGreaterThan(0);
+  });
+});
diff --git a/frontend/src/services/ability.ts b/frontend/src/services/ability.ts
new file mode 100644
index 0000000..034cb73
--- /dev/null
+++ b/frontend/src/services/ability.ts
@@ -0,0 +1,356 @@
+/**
+ * ability — online Elo for the learner AND for every item.
+ *
+ * WHY ELO AND NOT IRT
+ * -------------------
+ * The honest alternative is item response theory: fit a 2PL per item and get a
+ * difficulty plus a discrimination with real standard errors. It needs roughly
+ * 300 responses *per item* to be stable. This bank has ~2,800 items, so a 2PL
+ * fit needs ~840,000 graded responses before it says anything, and a single
+ * learner preparing for one exam will produce a few thousand. The fit would
+ * never run.
+ *
+ * Elo calibrates from the very first response instead, and it is mathematically
+ * the online-gradient form of the 1PL (Rasch) model: `expected` below is exactly
+ * the Rasch item characteristic curve with a logistic scale of 400/ln(10) and a
+ * fixed discrimination of 1. So what this module produces is a 1PL-equivalent
+ * difficulty estimate, no more:
+ *
+ *   - It cannot represent discrimination. A trick question that everyone with
+ *     real understanding still gets wrong looks simply "hard".
+ *   - It cannot represent guessing. A 4-option MCQ has a ~25% floor that 1PL
+ *     does not model; very hard items therefore drift too easy over time.
+ *   - Its ratings are point estimates with no standard error. Treat an item
+ *     with under ~30 responses as uncalibrated (see {@link itemCalibration}).
+ *
+ * REPLACEMENT PATH: once an item reaches {@link IRT_REFIT_THRESHOLD} (300)
+ * responses, {@link itemsNeedingIrtRefit} will list it and a 2PL fit should
+ * replace that item's rating (and add a discrimination) in the snapshot. The
+ * snapshot's `items` entries carry `responses`, so the cut-over is per item and
+ * needs no data migration — the response log is the source of truth and can be
+ * replayed into either model.
+ *
+ * Everything here is a pure fold over the response log; the persisted snapshot
+ * is a cache, never the truth.
+ */
+
+import type { ResponseRecord } from './responseLog';
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+export const ABILITY_SCHEMA_VERSION = 1;
+
+/** Both learners and items start here. 1000 is an arbitrary, conventional zero. */
+export const INITIAL_ELO = 1000;
+
+/** The logistic scale: a 400-point gap means ~91% expected success. */
+export const ELO_SCALE = 400;
+
+/**
+ * K-factor denominators. Larger denominator = slower, steadier movement.
+ * The learner moves slowest (50) because their ability is genuinely stable over
+ * a session; items move faster (30) because an item's rating is the thing we
+ * know least about; per-chapter ability moves fastest (20) because a learner
+ * revising one chapter really can improve inside a week and the per-chapter
+ * number is what drives question selection.
+ */
+export const K_LEARNER_DENOM = 50;
+export const K_ITEM_DENOM = 30;
+export const K_CHAPTER_DENOM = 20;
+
+/** Below this many responses an item's rating is a guess, not a measurement. */
+export const ITEM_PROVISIONAL_RESPONSES = 30;
+
+/** At or above this, replace the Elo rating with a proper 2PL fit. */
+export const IRT_REFIT_THRESHOLD = 300;
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface RatedEntity {
+  /** Current Elo rating. */
+  rating: number;
+  /** How many graded responses have moved it. */
+  responses: number;
+}
+
+export interface AbilitySnapshot {
+  version: number;
+  /** Global learner ability. */
+  theta: number;
+  responses: number;
+  /** Per-chapter ability, keyed by `topicId`. */
+  chapters: Record<string, RatedEntity>;
+  /** Per-item difficulty, keyed by `qid`. */
+  items: Record<string, RatedEntity>;
+  updatedAt: number;
+}
+
+/** The minimum a response needs to move the ratings. */
+export interface AbilityObservation {
+  qid: string;
+  /** Chapter id; `ResponseRecord.topicId`. */
+  chapterId: string;
+  correct: boolean;
+  ts?: number;
+}
+
+export function emptyAbilitySnapshot(now = 0): AbilitySnapshot {
+  return {
+    version: ABILITY_SCHEMA_VERSION,
+    theta: INITIAL_ELO,
+    responses: 0,
+    chapters: {},
+    items: {},
+    updatedAt: now,
+  };
+}
+
+// ─── Pure Elo maths ───────────────────────────────────────────────────────────
+
+/**
+ * Probability that a learner of ability `theta` answers an item of difficulty
+ * `itemElo` correctly. Identical to the 1PL/Rasch ICC.
+ */
+export function expectedCorrect(theta: number, itemElo: number): number {
+  return 1 / (1 + Math.pow(10, (itemElo - theta) / ELO_SCALE));
+}
+
+/** Inverse of {@link expectedCorrect}: the item difficulty that yields `p`. */
+export function eloForSuccessProbability(theta: number, p: number): number {
+  const clamped = Math.min(0.999, Math.max(0.001, p));
+  return theta + ELO_SCALE * Math.log10((1 - clamped) / clamped);
+}
+
+export function learnerK(responses: number): number {
+  return ELO_SCALE / (K_LEARNER_DENOM + responses);
+}
+
+export function itemK(responses: number): number {
+  return ELO_SCALE / (K_ITEM_DENOM + responses);
+}
+
+export function chapterK(responses: number): number {
+  return ELO_SCALE / (K_CHAPTER_DENOM + responses);
+}
+
+/**
+ * How much to trust an item's rating.
+ *   - `provisional`: under {@link ITEM_PROVISIONAL_RESPONSES}; usable for
+ *     ordering but not for telling a learner an item is "hard".
+ *   - `calibrated`: a usable 1PL difficulty.
+ *   - `refit-2pl`: enough data that Elo is now the weaker model.
+ */
+export function itemCalibration(entity: RatedEntity | undefined): 'unseen' | 'provisional' | 'calibrated' | 'refit-2pl' {
+  if (!entity || entity.responses === 0) return 'unseen';
+  if (entity.responses >= IRT_REFIT_THRESHOLD) return 'refit-2pl';
+  if (entity.responses < ITEM_PROVISIONAL_RESPONSES) return 'provisional';
+  return 'calibrated';
+}
+
+export function itemsNeedingIrtRefit(snapshot: AbilitySnapshot): string[] {
+  return Object.entries(snapshot.items)
+    .filter(([, entity]) => entity.responses >= IRT_REFIT_THRESHOLD)
+    .map(([qid]) => qid);
+}
+
+// ─── Updates ──────────────────────────────────────────────────────────────────
+
+export interface AbilityUpdateDetail {
+  qid: string;
+  chapterId: string;
+  correct: boolean;
+  expected: number;
+  thetaBefore: number;
+  thetaAfter: number;
+  itemBefore: number;
+  itemAfter: number;
+  chapterBefore: number;
+  chapterAfter: number;
+}
+
+function entityOf(map: Record<string, RatedEntity>, key: string): RatedEntity {
+  return map[key] ?? { rating: INITIAL_ELO, responses: 0 };
+}
+
+function cloneSnapshot(snapshot: AbilitySnapshot): AbilitySnapshot {
+  return {
+    version: snapshot.version,
+    theta: snapshot.theta,
+    responses: snapshot.responses,
+    chapters: { ...snapshot.chapters },
+    items: { ...snapshot.items },
+    updatedAt: snapshot.updatedAt,
+  };
+}
+
+/**
+ * Folds a batch of observations into a new snapshot. Pure: the input snapshot
+ * is never mutated, and replaying the same observations in the same order
+ * always yields the same result — which is what makes the whole model
+ * reconstructible from the response log.
+ *
+ * The learner moves *up* and the item moves *down* by the same signed surprise
+ * `(correct - expected)` scaled by their own K, so the pair is zero-sum in
+ * surprise terms, as in chess Elo.
+ */
+export function applyObservations(
+  snapshot: AbilitySnapshot,
+  observations: AbilityObservation[],
+): { snapshot: AbilitySnapshot; details: AbilityUpdateDetail[] } {
+  const next = cloneSnapshot(snapshot);
+  const details: AbilityUpdateDetail[] = [];
+
+  for (const observation of observations) {
+    const item = entityOf(next.items, observation.qid);
+    const chapter = entityOf(next.chapters, observation.chapterId);
+    const score = observation.correct ? 1 : 0;
+
+    const expected = expectedCorrect(next.theta, item.rating);
+    const surprise = score - expected;
+
+    const thetaAfter = next.theta + learnerK(next.responses) * surprise;
+    const itemAfter = item.rating - itemK(item.responses) * surprise;
+
+    // Per-chapter ability is a separate ladder with its own expectation, so a
+    // learner who is strong overall but weak in one chapter gets chapter-level
+    // question selection that reflects the chapter, not the average.
+    const chapterExpected = expectedCorrect(chapter.rating, item.rating);
+    const chapterAfter = chapter.rating + chapterK(chapter.responses) * (score - chapterExpected);
+
+    details.push({
+      qid: observation.qid,
+      chapterId: observation.chapterId,
+      correct: observation.correct,
+      expected,
+      thetaBefore: next.theta,
+      thetaAfter,
+      itemBefore: item.rating,
+      itemAfter,
+      chapterBefore: chapter.rating,
+      chapterAfter,
+    });
+
+    next.theta = thetaAfter;
+    next.responses += 1;
+    next.items[observation.qid] = { rating: itemAfter, responses: item.responses + 1 };
+    next.chapters[observation.chapterId] = { rating: chapterAfter, responses: chapter.responses + 1 };
+    if (observation.ts !== undefined) next.updatedAt = Math.max(next.updatedAt, observation.ts);
+  }
+
+  return { snapshot: next, details };
+}
+
+export function applyObservation(
+  snapshot: AbilitySnapshot,
+  observation: AbilityObservation,
+): { snapshot: AbilitySnapshot; detail: AbilityUpdateDetail } {
+  const { snapshot: next, details } = applyObservations(snapshot, [observation]);
+  return { snapshot: next, detail: details[0] };
+}
+
+export function observationFromResponse(record: ResponseRecord): AbilityObservation {
+  return { qid: record.qid, chapterId: record.topicId, correct: record.correct, ts: record.ts };
+}
+
+/**
+ * Rebuilds the whole model from the log. Records are sorted by `ts` first,
+ * because Elo is order-dependent and the log may arrive out of order after a
+ * cross-device merge.
+ */
+export function rebuildAbility(records: ResponseRecord[], now = Date.now()): AbilitySnapshot {
+  const ordered = [...records].sort((a, b) => (a.ts === b.ts ? (a.rid < b.rid ? -1 : 1) : a.ts - b.ts));
+  const { snapshot } = applyObservations(emptyAbilitySnapshot(now), ordered.map(observationFromResponse));
+  return { ...snapshot, updatedAt: now };
+}
+
+// ─── Reads ────────────────────────────────────────────────────────────────────
+
+export function chapterTheta(snapshot: AbilitySnapshot, chapterId: string): number {
+  return snapshot.chapters[chapterId]?.rating ?? snapshot.theta;
+}
+
+export function itemElo(snapshot: AbilitySnapshot, qid: string): number {
+  return snapshot.items[qid]?.rating ?? INITIAL_ELO;
+}
+
+/** Probability this learner answers this item correctly, chapter-aware. */
+export function successProbability(snapshot: AbilitySnapshot, qid: string, chapterId?: string): number {
+  const theta = chapterId === undefined ? snapshot.theta : chapterTheta(snapshot, chapterId);
+  return expectedCorrect(theta, itemElo(snapshot, qid));
+}
+
+// ─── Persistence ──────────────────────────────────────────────────────────────
+
+export const ABILITY_STORAGE_KEY = 'eng_ability_v1';
+
+type StorageLike = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+
+function resolveStorage(storage?: StorageLike): StorageLike | null {
+  if (storage) return storage;
+  return typeof localStorage === 'undefined' ? null : localStorage;
+}
+
+function isRatedEntityMap(value: unknown): value is Record<string, RatedEntity> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  return Object.values(value).every(
+    (entry) =>
+      typeof entry === 'object' &&
+      entry !== null &&
+      Number.isFinite((entry as RatedEntity).rating) &&
+      Number.isFinite((entry as RatedEntity).responses),
+  );
+}
+
+/**
+ * Upgrades an older snapshot in place. There is only v1 today; the point of the
+ * hook is that a future shape change does not require throwing the cache away
+ * silently — and when it cannot be upgraded we return `null` so the caller
+ * rebuilds from the log rather than trusting a half-understood object.
+ */
+function upgradeSnapshot(raw: unknown): AbilitySnapshot | null {
+  if (typeof raw !== 'object' || raw === null) return null;
+  const candidate = raw as Partial<AbilitySnapshot>;
+  if (candidate.version !== ABILITY_SCHEMA_VERSION) return null;
+  if (!Number.isFinite(candidate.theta) || !Number.isFinite(candidate.responses)) return null;
+  if (!isRatedEntityMap(candidate.chapters) || !isRatedEntityMap(candidate.items)) return null;
+  return {
+    version: ABILITY_SCHEMA_VERSION,
+    theta: candidate.theta as number,
+    responses: candidate.responses as number,
+    chapters: candidate.chapters,
+    items: candidate.items,
+    updatedAt: Number.isFinite(candidate.updatedAt) ? (candidate.updatedAt as number) : 0,
+  };
+}
+
+/** Returns `null` when there is no usable cache; the caller should rebuild. */
+export function loadAbilitySnapshot(storage?: StorageLike): AbilitySnapshot | null {
+  const store = resolveStorage(storage);
+  if (!store) return null;
+  try {
+    const raw = store.getItem(ABILITY_STORAGE_KEY);
+    return raw === null ? null : upgradeSnapshot(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persists the snapshot. Returns false when it could not be written — the
+ * snapshot is only a cache, so a failed write is recoverable, but the caller
+ * should still know rather than assume success.
+ */
+export function saveAbilitySnapshot(snapshot: AbilitySnapshot, storage?: StorageLike): boolean {
+  const store = resolveStorage(storage);
+  if (!store) return false;
+  try {
+    store.setItem(ABILITY_STORAGE_KEY, JSON.stringify(snapshot));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function clearAbilitySnapshot(storage?: StorageLike): void {
+  resolveStorage(storage)?.removeItem(ABILITY_STORAGE_KEY);
+}
diff --git a/frontend/src/services/api.ts b/frontend/src/services/api.ts
new file mode 100644
index 0000000..534a3bf
--- /dev/null
+++ b/frontend/src/services/api.ts
@@ -0,0 +1,611 @@
+/**
+ * The typed HTTP client for the NECPrep Worker API.
+ *
+ * HOW THIS COEXISTS WITH `localData.ts`. It does not replace it. The app must
+ * keep working with no backend configured - that is the deployment that is live
+ * today, questions served from `public/data/*.json` and progress in
+ * localStorage. So every call site branches:
+ *
+ *     import { isBackendConfigured, api } from '../services/api';
+ *     import * as local from '../services/localData';
+ *
+ *     const chapters = isBackendConfigured()
+ *       ? (await api.getChapters()).data?.chapters
+ *       : local.bookChapters;
+ *
+ * `isBackendConfigured()` reads `VITE_API_BASE_URL`. With it unset, nothing in
+ * this module ever issues a request: every function short-circuits to an
+ * `ApiResult` with code `BACKEND_NOT_CONFIGURED`, so a caller that forgets to
+ * branch degrades to "no data" rather than to a stack of failed fetches.
+ *
+ * TYPES ARE NOT DECLARED HERE. They are imported from the Worker's own
+ * `shared/types.ts`, so a response shape exists exactly once in the repository
+ * and a server change that breaks the client is a type error rather than a
+ * runtime surprise. The import is `import type`, which `verbatimModuleSyntax`
+ * erases completely - Vite never resolves a path outside its root, and no
+ * Worker code reaches the browser bundle.
+ *
+ * NOTHING HERE SCORES ANYTHING. There is deliberately no function that compares
+ * an answer to a key, because the client is never given a key to compare
+ * against. `submitMock` posts option refs and reads back a score.
+ */
+
+import type {
+  AdminPublishRequest,
+  AdminPublishResponse,
+  AdminReportQueueResponse,
+  AdminTriageRequest,
+  AdminTriageResponse,
+  ApiError,
+  ApiErrorBody,
+  ApiResult,
+  AttemptHistoryResponse,
+  AuditLogResponse,
+  BookmarkListResponse,
+  BookmarkSetRequest,
+  BookmarkSetResponse,
+  BootstrapResponse,
+  ChapterQuestionsResponse,
+  ChapterSummary,
+  LoginRequest,
+  MockAttemptPaper,
+  MockStartRequest,
+  MockSubmitRequest,
+  MockSubmitResponse,
+  MockSyncRequest,
+  MockSyncResponse,
+  MockTemplateSummary,
+  OutboxEntry,
+  PracticeAnswerRequest,
+  PracticeAnswerResponse,
+  PracticeFinishRequest,
+  PracticeFinishResponse,
+  PracticeSessionPaper,
+  PracticeStartRequest,
+  ProgressOverview,
+  QueuedMutation,
+  ReportListResponse,
+  ReportStatus,
+  ReportSubmitRequest,
+  SearchResponse,
+  SessionResponse,
+  SignupRequest,
+  SrsDueResponse,
+  SrsReviewRequest,
+  SrsReviewResponse,
+  UpgradeAnonymousRequest,
+} from '../../../worker/src/shared/types.ts';
+
+export type * from '../../../worker/src/shared/types.ts';
+
+// --- Configuration ----------------------------------------------------------
+
+/**
+ * Trailing slashes stripped once, here, so every call site can concatenate a
+ * leading-slash path without producing a double slash that some proxies 404.
+ */
+const API_BASE: string = (import.meta.env.VITE_API_BASE_URL ?? '').replace(/\/+$/, '');
+
+/**
+ * Whether a backend is configured for this build.
+ *
+ * Call this before reaching for anything in `api`. With no backend, the app
+ * falls back to `localData.ts` and keeps working offline-first, which is how it
+ * ships today.
+ */
+export function isBackendConfigured(): boolean {
+  return API_BASE.length > 0;
+}
+
+export function apiBaseUrl(): string {
+  return API_BASE;
+}
+
+// --- Transport --------------------------------------------------------------
+
+function clientError(code: ApiError['code'], message: string): { ok: false; error: ApiError } {
+  return { ok: false, error: { code, message } };
+}
+
+const NOT_CONFIGURED = (): { ok: false; error: ApiError } =>
+  clientError(
+    'BACKEND_NOT_CONFIGURED',
+    'No API base URL is configured for this build; using local data instead.',
+  );
+
+interface RequestOptions {
+  query?: Record<string, string | number | boolean | undefined>;
+  body?: unknown;
+  signal?: AbortSignal;
+}
+
+/**
+ * The single fetch in this module.
+ *
+ * - `credentials: 'include'`, because the session is an HttpOnly cookie. There
+ *   is no token in JS to steal, and nothing for XSS to read.
+ * - Never throws for an expected failure. A 4xx comes back as
+ *   `{ ok: false, error }` so callers handle it in the same branch as a
+ *   validation problem, and a thrown error always means a bug.
+ * - A network failure is reported as `NETWORK_UNAVAILABLE`, which is what the
+ *   outbox keys its retry decision on.
+ */
+async function request<T>(
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE',
+  path: string,
+  options: RequestOptions = {},
+): Promise<ApiResult<T>> {
+  if (!isBackendConfigured()) return NOT_CONFIGURED();
+
+  const url = new URL(`${API_BASE}${path}`);
+  for (const [key, value] of Object.entries(options.query ?? {})) {
+    if (value !== undefined) url.searchParams.set(key, String(value));
+  }
+
+  let response: Response;
+  try {
+    response = await fetch(url.toString(), {
+      method,
+      credentials: 'include',
+      headers: options.body === undefined ? undefined : { 'content-type': 'application/json' },
+      body: options.body === undefined ? undefined : JSON.stringify(options.body),
+      signal: options.signal,
+    });
+  } catch {
+    // Offline, DNS failure, CORS rejection, or an aborted request. All of them
+    // mean "the server did not answer", and all of them are retryable.
+    return clientError('NETWORK_UNAVAILABLE', 'Could not reach the server.');
+  }
+
+  const replayed = response.headers.get('idempotent-replay') === 'true';
+
+  // A 204 or an empty body is a success with nothing in it.
+  const text = await response.text();
+  if (text.length === 0) {
+    return response.ok
+      ? { ok: true, data: undefined as T, replayed }
+      : clientError('INTERNAL', `Request failed with status ${response.status}.`);
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text) as unknown;
+  } catch {
+    return clientError('INTERNAL', 'The server returned a malformed response.');
+  }
+
+  if (response.ok) return { ok: true, data: parsed as T, replayed };
+
+  const body = parsed as Partial<ApiErrorBody>;
+  if (body.error && typeof body.error.code === 'string') {
+    return { ok: false, error: body.error };
+  }
+  return clientError('INTERNAL', `Request failed with status ${response.status}.`);
+}
+
+// --- Idempotency keys -------------------------------------------------------
+
+/**
+ * A fresh idempotency key.
+ *
+ * Mint one per logical mutation and then NEVER regenerate it on retry - that is
+ * the whole contract. A retry with a new key is a second mutation as far as the
+ * server is concerned, which for a mock submission means a 409 and for a
+ * practice answer would mean double-counted stats.
+ *
+ * The charset is restricted to what the Worker's validator accepts
+ * (`[A-Za-z0-9_.:-]`, 8-80 characters); `randomUUID` satisfies it.
+ */
+export function newIdempotencyKey(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  // Older Safari on an insecure origin. Still 128 bits from the CSPRNG.
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+
+// --- Endpoints --------------------------------------------------------------
+
+export const api = {
+  // Bootstrap & content
+  bootstrap: () => request<BootstrapResponse>('GET', '/api/bootstrap'),
+
+  getChapters: () => request<{ chapters: ChapterSummary[] }>('GET', '/api/content/chapters'),
+
+  getMockTemplates: () =>
+    request<{ mockTemplates: MockTemplateSummary[] }>('GET', '/api/content/mock-templates'),
+
+  getChapterQuestions: (chapterId: string, page: { offset?: number; limit?: number } = {}) =>
+    request<ChapterQuestionsResponse>(
+      'GET',
+      `/api/content/chapters/${encodeURIComponent(chapterId)}/questions`,
+      { query: { offset: page.offset, limit: page.limit } },
+    ),
+
+  search: (q: string, options: { chapterId?: string; limit?: number } = {}) =>
+    request<SearchResponse>('GET', '/api/content/search', {
+      query: { q, chapterId: options.chapterId, limit: options.limit },
+    }),
+
+  // Auth
+  getSession: () => request<SessionResponse>('GET', '/api/auth/session'),
+
+  startAnonymousSession: () => request<SessionResponse>('POST', '/api/auth/anonymous'),
+
+  signup: (body: SignupRequest) => request<SessionResponse>('POST', '/api/auth/signup', { body }),
+
+  login: (body: LoginRequest) => request<SessionResponse>('POST', '/api/auth/login', { body }),
+
+  logout: () => request<{ ok: true }>('POST', '/api/auth/logout'),
+
+  upgradeAnonymous: (body: UpgradeAnonymousRequest) =>
+    request<SessionResponse>('POST', '/api/auth/upgrade', { body }),
+
+  /**
+   * Google sign-in is a full-page redirect, not a fetch: the OAuth flow has to
+   * run in the browser's top-level context and the callback sets a cookie.
+   */
+  googleSignInUrl: (redirectTo?: string): string => {
+    const url = new URL(`${API_BASE}/api/auth/google/start`);
+    if (redirectTo) url.searchParams.set('redirect_to', redirectTo);
+    return url.toString();
+  },
+
+  // Mock tests
+  startMock: (body: MockStartRequest) =>
+    request<MockAttemptPaper>('POST', '/api/mock/start', { body }),
+
+  getMockAttempt: (attemptId: string) =>
+    request<MockAttemptPaper>('GET', `/api/mock/attempts/${encodeURIComponent(attemptId)}`),
+
+  getMockReview: (attemptId: string) =>
+    request<MockSubmitResponse>(
+      'GET',
+      `/api/mock/attempts/${encodeURIComponent(attemptId)}/review`,
+    ),
+
+  syncMock: (body: MockSyncRequest) =>
+    request<MockSyncResponse>('POST', '/api/mock/sync', { body }),
+
+  submitMock: (body: MockSubmitRequest) =>
+    request<MockSubmitResponse>('POST', '/api/mock/submit', { body }),
+
+  // Practice
+  startPractice: (body: PracticeStartRequest) =>
+    request<PracticeSessionPaper>('POST', '/api/practice/start', { body }),
+
+  getPracticeSession: (sessionId: string) =>
+    request<PracticeSessionPaper>(
+      'GET',
+      `/api/practice/sessions/${encodeURIComponent(sessionId)}`,
+    ),
+
+  answerPractice: (body: PracticeAnswerRequest) =>
+    request<PracticeAnswerResponse>('POST', '/api/practice/answer', { body }),
+
+  finishPractice: (body: PracticeFinishRequest) =>
+    request<PracticeFinishResponse>('POST', '/api/practice/finish', { body }),
+
+  // Progress
+  getProgressOverview: () => request<ProgressOverview>('GET', '/api/progress/overview'),
+
+  getAttemptHistory: (options: { limit?: number; cursor?: string } = {}) =>
+    request<AttemptHistoryResponse>('GET', '/api/progress/history', { query: options }),
+
+  // Bookmarks
+  getBookmarks: () => request<BookmarkListResponse>('GET', '/api/bookmarks'),
+
+  setBookmark: (body: BookmarkSetRequest) =>
+    request<BookmarkSetResponse>('PUT', '/api/bookmarks', { body }),
+
+  // Spaced repetition
+  getSrsDue: (options: { limit?: number } = {}) =>
+    request<SrsDueResponse>('GET', '/api/srs/due', { query: options }),
+
+  /**
+   * `body.revision` is the `revision` the server last reported for this card
+   * (`srs_state.reps`). Send it back unchanged: the server applies the review
+   * only if it still matches, so a replayed outbox entry or a stale review from
+   * a second device is a no-op rather than a conflict. Never invent or
+   * increment it client-side.
+   */
+  reviewSrsCard: (body: SrsReviewRequest) =>
+    request<SrsReviewResponse>('POST', '/api/srs/review', { body }),
+
+  // Errata
+  submitReport: (body: ReportSubmitRequest) =>
+    request<{ reportId: string; created: boolean }>('POST', '/api/reports', { body }),
+
+  getMyReports: () => request<ReportListResponse>('GET', '/api/reports'),
+
+  // Admin
+  // `status` is the `ReportStatus` union and not a bare string on purpose: it
+  // mirrors the CHECK on `question_reports.status`, so a stale value (the
+  // earlier 'fixed', for instance) is a compile error at the call site rather
+  // than a 400 at runtime.
+  getReportQueue: (options: { status?: ReportStatus; limit?: number; cursor?: string } = {}) =>
+    request<AdminReportQueueResponse>('GET', '/api/admin/reports', { query: options }),
+
+  triageReports: (body: AdminTriageRequest) =>
+    request<AdminTriageResponse>('POST', '/api/admin/reports/triage', { body }),
+
+  publishQuestions: (body: AdminPublishRequest) =>
+    request<AdminPublishResponse>('POST', '/api/admin/questions/publish', { body }),
+
+  getAuditLog: (options: { limit?: number; cursor?: string } = {}) =>
+    request<AuditLogResponse>('GET', '/api/admin/audit', { query: options }),
+} as const;
+
+// --- The offline outbox -----------------------------------------------------
+
+const OUTBOX_KEY = 'necprep_outbox_v1';
+const MAX_OUTBOX_ENTRIES = 500;
+const MAX_ATTEMPTS = 8;
+
+/**
+ * Error codes a replay will NEVER recover from.
+ *
+ * Keeping a dead entry in the queue is worse than dropping it: it blocks every
+ * later mutation behind it forever, because the drain is ordered. So these are
+ * discarded, and `onDropped` is how the UI gets told.
+ */
+const PERMANENT: ReadonlySet<ApiError['code']> = new Set<ApiError['code']>([
+  'BAD_REQUEST',
+  'FORBIDDEN',
+  'NOT_FOUND',
+  'CONFLICT',
+  'IDEMPOTENCY_KEY_REUSED',
+  'ATTEMPT_NOT_IN_PROGRESS',
+  'QUESTION_NOT_ON_PAPER',
+  'UNKNOWN_OPTION_REF',
+  'EMAIL_IN_USE',
+  'NOT_ANONYMOUS',
+  'INSUFFICIENT_CONTENT',
+  'PAYLOAD_TOO_LARGE',
+  'UNAUTHENTICATED',
+]);
+
+function readOutbox(): QueuedMutation[] {
+  try {
+    const raw = localStorage.getItem(OUTBOX_KEY);
+    if (!raw) return [];
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (item): item is QueuedMutation =>
+        typeof item === 'object' &&
+        item !== null &&
+        typeof (item as QueuedMutation).localId === 'string' &&
+        typeof (item as QueuedMutation).entry === 'object',
+    );
+  } catch {
+    return [];
+  }
+}
+
+function writeOutbox(queue: QueuedMutation[]): void {
+  try {
+    localStorage.setItem(OUTBOX_KEY, JSON.stringify(queue.slice(0, MAX_OUTBOX_ENTRIES)));
+  } catch {
+    // Storage full or blocked (private browsing). The mutation is lost, which
+    // is bad, but silently corrupting the queue would be worse.
+  }
+}
+
+export function outboxSize(): number {
+  return readOutbox().length;
+}
+
+export function outboxEntries(): QueuedMutation[] {
+  return readOutbox();
+}
+
+export function clearOutbox(): void {
+  writeOutbox([]);
+}
+
+/**
+ * Queues a mutation for replay.
+ *
+ * THE IDEMPOTENCY KEY IS MINTED HERE AND NOWHERE ELSE. It is stored with the
+ * entry, so every replay - this session, after a reload, a week later - sends
+ * the same key, and the server either does the work once or replays its stored
+ * response. Regenerating the key on retry is the one mistake that breaks the
+ * whole contract.
+ *
+ * Entries that carry no key are the endpoints that are idempotent by
+ * construction: `mock.sync` (the map replaces the snapshot), `practice.answer`
+ * (unique on session+question), `bookmark.set` (a desired end state),
+ * `srs.review` (guarded on a revision counter) and `report.submit` (unique on
+ * user+question).
+ */
+export function enqueue(entry: OutboxEntry): QueuedMutation {
+  const withKey = ensureKey(entry);
+  const item: QueuedMutation = {
+    localId: newIdempotencyKey(),
+    entry: withKey,
+    enqueuedAt: Date.now(),
+    attempts: 0,
+    lastError: null,
+  };
+  writeOutbox([...readOutbox(), item]);
+  return item;
+}
+
+/**
+ * Stamps an entry with a key if it has none.
+ *
+ * Generic over the body rather than written per-kind, so adding an outbox kind
+ * does not mean copying the stamping logic again. Each `case` below is listed
+ * separately even though the bodies are identical: grouped case labels widen
+ * the discriminated union back into a union of all bodies, and the spread then
+ * loses the narrowing.
+ */
+function withIdempotencyKey<K extends string, B extends { idempotencyKey?: string }>(entry: {
+  kind: K;
+  body: B;
+}): { kind: K; body: B & { idempotencyKey: string } } {
+  return entry.body.idempotencyKey
+    ? (entry as { kind: K; body: B & { idempotencyKey: string } })
+    : { ...entry, body: { ...entry.body, idempotencyKey: newIdempotencyKey() } };
+}
+
+function ensureKey(entry: OutboxEntry): OutboxEntry {
+  switch (entry.kind) {
+    case 'mock.submit':
+      return withIdempotencyKey(entry);
+    case 'practice.finish':
+      return withIdempotencyKey(entry);
+    // The rest are already idempotent server-side, but carrying a key turns a
+    // replay into a cheap stored-response read instead of a second write.
+    case 'practice.answer':
+      return withIdempotencyKey(entry);
+    case 'bookmark.set':
+      return withIdempotencyKey(entry);
+    case 'srs.review':
+      return withIdempotencyKey(entry);
+    case 'report.submit':
+      return withIdempotencyKey(entry);
+    // `mock.sync` takes no key at all: the answers map REPLACES the stored
+    // snapshot, so a replay is already convergent and a key would only add a
+    // row to `idempotency_keys` for no benefit.
+    case 'mock.sync':
+      return entry;
+  }
+}
+
+async function send(entry: OutboxEntry): Promise<ApiResult<unknown>> {
+  switch (entry.kind) {
+    case 'mock.sync':
+      return await api.syncMock(entry.body);
+    case 'mock.submit':
+      return await api.submitMock(entry.body);
+    case 'practice.answer':
+      return await api.answerPractice(entry.body);
+    case 'practice.finish':
+      return await api.finishPractice(entry.body);
+    case 'bookmark.set':
+      return await api.setBookmark(entry.body);
+    case 'srs.review':
+      return await api.reviewSrsCard(entry.body);
+    case 'report.submit':
+      return await api.submitReport(entry.body);
+    default:
+      return clientError('BAD_REQUEST', 'Unknown outbox entry.');
+  }
+}
+
+export interface DrainReport {
+  sent: number;
+  dropped: number;
+  remaining: number;
+  /** True when the drain stopped early because the server was unreachable. */
+  stalled: boolean;
+}
+
+/**
+ * Replays queued mutations, oldest first.
+ *
+ * STRICTLY ORDERED, AND IT STOPS ON THE FIRST RETRYABLE FAILURE. Order matters
+ * because a `mock.submit` queued behind a `mock.sync` must not overtake it: the
+ * sync is what the expiry clamp scores if the submission turns out to be late.
+ * Skipping ahead past a stalled entry would silently change what gets scored.
+ *
+ * Call it on `online`, on app focus, and after a successful request.
+ */
+export async function drainOutbox(
+  hooks: { onDropped?: (item: QueuedMutation, error: ApiError) => void } = {},
+): Promise<DrainReport> {
+  if (!isBackendConfigured()) {
+    return { sent: 0, dropped: 0, remaining: outboxSize(), stalled: false };
+  }
+
+  let queue = readOutbox();
+  let sent = 0;
+  let dropped = 0;
+  let stalled = false;
+
+  while (queue.length > 0) {
+    const [head, ...rest] = queue;
+    const result = await send(head.entry);
+
+    if (result.ok) {
+      sent++;
+      queue = rest;
+      writeOutbox(queue);
+      continue;
+    }
+
+    const permanent = PERMANENT.has(result.error.code) || head.attempts + 1 >= MAX_ATTEMPTS;
+    if (permanent) {
+      dropped++;
+      hooks.onDropped?.(head, result.error);
+      queue = rest;
+      writeOutbox(queue);
+      continue;
+    }
+
+    // Retryable: record the attempt and stop, preserving order.
+    queue = [{ ...head, attempts: head.attempts + 1, lastError: result.error.code }, ...rest];
+    writeOutbox(queue);
+    stalled = true;
+    break;
+  }
+
+  return { sent, dropped, remaining: queue.length, stalled };
+}
+
+/**
+ * Posts a mutation now, falling back to the outbox if the server cannot be
+ * reached. Returns the live result when there was one.
+ *
+ * This is the function most call sites want: it keeps the optimistic path fast
+ * and makes the offline path automatic, with the same key used for both, so the
+ * eventual replay cannot duplicate a mutation that actually did land.
+ */
+export async function sendOrQueue(
+  entry: OutboxEntry,
+): Promise<{ queued: boolean; result: ApiResult<unknown> }> {
+  const withKey = ensureKey(entry);
+  const result = await send(withKey);
+
+  if (result.ok) return { queued: false, result };
+
+  if (result.error.code === 'NETWORK_UNAVAILABLE' || result.error.code === 'RATE_LIMITED') {
+    writeOutbox([
+      ...readOutbox(),
+      {
+        localId: newIdempotencyKey(),
+        entry: withKey,
+        enqueuedAt: Date.now(),
+        attempts: 1,
+        lastError: result.error.code,
+      },
+    ]);
+    return { queued: true, result };
+  }
+
+  return { queued: false, result };
+}
+
+// --- Timer helper -----------------------------------------------------------
+
+/**
+ * Converts the server's deadline into a countdown the UI can render.
+ *
+ * The `expiresAt` and `serverNow` on a `MockAttemptPaper` are both SERVER
+ * values, so this measures against the server's clock plus the elapsed time on
+ * this device, not against `Date.now()` directly. A device whose clock is
+ * hours off still renders a truthful countdown - and, more to the point,
+ * freezing or faking the local clock changes only what is DISPLAYED. The
+ * scoring deadline is enforced server-side regardless of what the timer shows.
+ */
+export function remainingMs(paper: {
+  expiresAt: number;
+  serverNow: number;
+}, monotonicStart: number = performance.now()): number {
+  const elapsed = performance.now() - monotonicStart;
+  return Math.max(0, paper.expiresAt - paper.serverNow - elapsed);
+}
diff --git a/frontend/src/services/localData.ts b/frontend/src/services/localData.ts
index 109ddcb..871f0fd 100644
--- a/frontend/src/services/localData.ts
+++ b/frontend/src/services/localData.ts
@@ -7,6 +7,10 @@
 import { mockTests, getMockTestById } from '../data/topics';
 import type { Topic, MockTest } from '../data/topics';
 import { bookChapters } from '../data/bookChapters.generated';
+import { quarantinedIds } from '../data/quarantine';
+import { assignOptionOrders, fisherYates } from './optionOrdering';
+import { DRAFT_PREFIX, LEGACY_MOCK_DRAFT_PREFIX } from '../features/quiz/draft';
+export { orderOptions, assignOptionOrders } from './optionOrdering';
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -80,14 +84,14 @@ export async function loadTopicQuestions(topicId: string): Promise<Question[]> {
     // Exam topic JSONs have correct_option_index:0 + correct_option:"" — no answer data.
     const isBookChapter = topic.dataFile.startsWith('books/');
 
-    const questions: Question[] = raw.map((q, i) => {
+    const parsed = raw.map((q, i) => {
       let correctIndex: number;
+      const opts = [q.opt1, q.opt2, q.opt3, q.opt4].filter(Boolean);
       if (isBookChapter) {
         // 1-based → 0-based
         correctIndex = typeof q.correct_option_index === 'number' ? q.correct_option_index - 1 : -1;
       } else {
         // Try matching the correct_option text against the option strings
-        const opts = [q.opt1, q.opt2, q.opt3, q.opt4].filter(Boolean);
         if (q.correct_option) {
           const idx = opts.findIndex(o => o === q.correct_option);
           correctIndex = idx >= 0 ? idx : -1;
@@ -95,17 +99,33 @@ export async function loadTopicQuestions(topicId: string): Promise<Question[]> {
           correctIndex = -1; // no answer data in this file
         }
       }
-      return {
-        id: `${topicId}_${i}`,
-        topicId,
-        question: q.qsns,
-        options: [q.opt1, q.opt2, q.opt3, q.opt4].filter(Boolean),
-        correctIndex,
-      };
+      return { id: `${topicId}_${i}`, question: q.qsns, options: opts, correctIndex };
     });
 
-    questionCache[topicId] = questions;
-    return questions;
+    // Withhold questions the validator proved the app would mis-grade: answer
+    // keys that contradict themselves, indices pointing past the last option,
+    // and duplicated option text. See src/data/quarantine.ts. Filtering happens
+    // after id assignment, so ids stay tied to the original array position.
+    //
+    // Quarantined rows are dropped BEFORE ordering, so they cannot consume slots
+    // in the balance of a chapter a student never sees.
+    const kept = parsed.filter((q) => !quarantinedIds.has(q.id));
+
+    // Assign option order across the whole chapter at once, so the slot holding
+    // the correct answer is balanced by construction rather than sampled. See
+    // optionOrdering.ts for why per-question seeding is not sufficient.
+    const ordered = assignOptionOrders(kept);
+
+    const usable: Question[] = kept.map((q, i) => ({
+      id: q.id,
+      topicId,
+      question: q.question,
+      options: ordered[i].options,
+      correctIndex: ordered[i].correctIndex,
+    }));
+
+    questionCache[topicId] = usable;
+    return usable;
   } catch (err) {
     console.error(`Failed to load questions for ${topicId}:`, err);
     return [];
@@ -114,9 +134,10 @@ export async function loadTopicQuestions(topicId: string): Promise<Question[]> {
 
 export async function loadQuestionsSlice(topicId: string, count: number): Promise<Question[]> {
   const all = await loadTopicQuestions(topicId);
-  // Shuffle and take `count` questions
-  const shuffled = [...all].sort(() => Math.random() - 0.5);
-  return shuffled.slice(0, Math.min(count, shuffled.length));
+  // Fisher-Yates. This was `sort(() => Math.random() - 0.5)`, which is not a
+  // uniform shuffle and is comparator-implementation dependent - and it is the
+  // shuffle that decides which questions a student practises.
+  return fisherYates(all).slice(0, Math.min(count, all.length));
 }
 
 // ─── Progress ─────────────────────────────────────────────────────────────────
@@ -230,8 +251,55 @@ export async function loadBookmarkedQuestions(): Promise<Question[]> {
   return results;
 }
 
+/**
+ * Loads specific questions by id, preserving the order of `ids`.
+ *
+ * Ids are the synthetic `{topicId}_{index}` form minted by loadTopicQuestions,
+ * so this groups by topic, loads each topic once, then maps back. Used to
+ * reconstruct an in-progress mock test after a page reload. Ids that no longer
+ * resolve are dropped, so callers must compare lengths before trusting the
+ * result as a faithful restore.
+ */
+export async function loadQuestionsByIds(ids: string[]): Promise<Question[]> {
+  const topicIds = new Set<string>();
+  for (const id of ids) {
+    const cut = id.lastIndexOf('_');
+    if (cut > 0) topicIds.add(id.slice(0, cut));
+  }
+
+  const lookup = new Map<string, Question>();
+  for (const topicId of topicIds) {
+    for (const q of await loadTopicQuestions(topicId)) lookup.set(q.id, q);
+  }
+
+  return ids
+    .map(id => lookup.get(id))
+    .filter((q): q is Question => q !== undefined);
+}
+
 export function clearAllData() {
   localStorage.removeItem(STORAGE_KEYS.PROGRESS);
   localStorage.removeItem(STORAGE_KEYS.BOOKMARKS);
   localStorage.removeItem(STORAGE_KEYS.QUIZ_HISTORY);
+  // Also drop any in-progress attempt, or a reset would leave a stale draft that
+  // resumes an exam the user believes they deleted. Both prefixes must be swept:
+  // the quiz engine writes `eng_quiz_draft_v1:`, while `eng_mock_draft_v1:` is
+  // the older mock-only scheme that is still read for migration.
+  for (const key of Object.keys(localStorage)) {
+    if (key.startsWith(DRAFT_PREFIX) || key.startsWith(LEGACY_MOCK_DRAFT_PREFIX)) {
+      localStorage.removeItem(key);
+    }
+  }
+}
+
+/** Everything this browser holds for the current user, for the export button. */
+export function exportAllData() {
+  return {
+    schema: 'necprep-export-v1',
+    exportedAt: new Date().toISOString(),
+    userName: localStorage.getItem('userName') ?? null,
+    progress: getProgress(),
+    bookmarks: getBookmarks(),
+    quizHistory: getQuizHistory(),
+  };
 }
diff --git a/frontend/src/services/mastery.ts b/frontend/src/services/mastery.ts
new file mode 100644
index 0000000..0b6db63
--- /dev/null
+++ b/frontend/src/services/mastery.ts
@@ -0,0 +1,385 @@
+/**
+ * mastery — per-sub-chapter mastery with shrinkage, recency and coverage.
+ *
+ * THE PROBLEM WITH RAW ACCURACY
+ * -----------------------------
+ * `correct / attempted` is the number every exam app shows and it is wrong in
+ * three separate ways:
+ *
+ *   1. Small samples. 3 of 3 is not 100% mastery, it is a coin landing heads
+ *      three times. Fixed here by empirical-Bayes shrinkage toward the chapter
+ *      mean with a pseudo-count of k = 8: a 3-question sample is pulled most of
+ *      the way back to the chapter's own average, and only earns its own voice
+ *      as the sample grows.
+ *   2. Stale samples. A chapter answered well in March is not known in October.
+ *      Fixed by an exponential recency weight with a 30-day half-life, so the
+ *      effective sample size itself decays.
+ *   3. Narrow samples. Twelve correct answers on the same three questions is
+ *      memorisation, not mastery. Fixed by a coverage multiplier over distinct
+ *      question ids.
+ *
+ * THE HONESTY REQUIREMENT
+ * -----------------------
+ * When the effective sample is below {@link MIN_N_EFF} the result is a distinct
+ * `not-assessed` state, not a number. Showing "0% mastery" for a sub-chapter
+ * nobody ever practised is the single most common lie in exam apps: it reads as
+ * "you are failing this" when the truth is "we have no idea". The return type
+ * is a discriminated union, so a UI *cannot* read `mastery` off an unassessed
+ * unit — it will not type-check. That is deliberate; the lie is unrepresentable
+ * rather than merely discouraged.
+ *
+ * All functions are pure folds over response records.
+ */
+
+import type { ResponseRecord } from './responseLog';
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+/** Recency half-life in days: a 30-day-old response counts half as much. */
+export const RECENCY_HALF_LIFE_DAYS = 30;
+
+/** Shrinkage pseudo-count. Also the scale of the confidence curve. */
+export const SHRINKAGE_K = 8;
+
+/** Distinct questions that count as full coverage of a sub-chapter. */
+export const COVERAGE_TARGET_QIDS = 12;
+
+/** Below this effective sample size, nothing is reported as a score. */
+export const MIN_N_EFF = 3;
+
+/** Used as the shrinkage target when the chapter itself has no usable data. */
+export const DEFAULT_CHAPTER_MEAN = 0.5;
+
+/** A `strong` verdict additionally requires this much coverage. */
+export const STRONG_MIN_COVERAGE = 0.75;
+
+export const BUCKET_THRESHOLDS = {
+  weak: 0.45,
+  developing: 0.65,
+  strong: 0.85,
+} as const;
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface MasteryObservation {
+  qid: string;
+  correct: boolean;
+  /** Epoch milliseconds. */
+  ts: number;
+}
+
+/** Note: `not-assessed` is a *state*, never a bucket. A bucket implies a score. */
+export type MasteryBucket = 'critical' | 'weak' | 'developing' | 'strong';
+
+export interface MasterySample {
+  /** Recency-weighted sample size, `sum(w_i)`. */
+  nEff: number;
+  /** Recency-weighted correct count, `sum(w_i * correct_i)`. */
+  xEff: number;
+  distinctQids: number;
+  /** `min(1, distinctQids / 12)`. */
+  coverage: number;
+  /** Raw, unweighted response count — for "you have answered N questions" copy. */
+  responses: number;
+  /** Timestamp of the most recent response, or null when there are none. */
+  lastSeen: number | null;
+}
+
+export interface NotAssessedMastery extends MasterySample {
+  state: 'not-assessed';
+  /** How much more effective sample is needed before a score is reportable. */
+  nEffNeeded: number;
+  /** Plain-language reason, safe to show in a UI. */
+  reason: string;
+}
+
+export interface AssessedMastery extends MasterySample {
+  state: 'assessed';
+  /** Shrunk, recency-weighted accuracy estimate in [0, 1]. */
+  accHat: number;
+  /** `accHat * (0.6 + 0.4 * coverage)` — accuracy discounted by breadth. */
+  mastery: number;
+  /** `nEff / (nEff + k)` — how much of `accHat` is the learner's own data. */
+  confidence: number;
+  bucket: MasteryBucket;
+  /** The shrinkage target that was used. */
+  chapterMean: number;
+}
+
+export type MasteryEstimate = NotAssessedMastery | AssessedMastery;
+
+/** A sub-chapter (or a whole chapter, when the bank has no sub-chapters). */
+export interface MasteryUnit {
+  /** `subchapter` when known, else `topicId`. */
+  unitId: string;
+  topicId: string;
+  subchapter: string | null;
+  estimate: MasteryEstimate;
+}
+
+// ─── Pure maths ───────────────────────────────────────────────────────────────
+
+/** `w = 0.5 ^ (ageDays / 30)`. Clamped at 0 age so clock skew cannot inflate. */
+export function recencyWeight(ageDays: number): number {
+  return Math.pow(0.5, Math.max(0, ageDays) / RECENCY_HALF_LIFE_DAYS);
+}
+
+export function ageInDays(ts: number, now: number): number {
+  return (now - ts) / MS_PER_DAY;
+}
+
+export function coverageFor(distinctQids: number): number {
+  return Math.min(1, distinctQids / COVERAGE_TARGET_QIDS);
+}
+
+export function summarise(observations: MasteryObservation[], now: number): MasterySample {
+  let nEff = 0;
+  let xEff = 0;
+  let lastSeen: number | null = null;
+  const qids = new Set<string>();
+
+  for (const observation of observations) {
+    const w = recencyWeight(ageInDays(observation.ts, now));
+    nEff += w;
+    if (observation.correct) xEff += w;
+    qids.add(observation.qid);
+    if (lastSeen === null || observation.ts > lastSeen) lastSeen = observation.ts;
+  }
+
+  return {
+    nEff,
+    xEff,
+    distinctQids: qids.size,
+    coverage: coverageFor(qids.size),
+    responses: observations.length,
+    lastSeen,
+  };
+}
+
+/**
+ * The shrinkage target: the chapter's own recency-weighted accuracy.
+ *
+ * Deliberately *not* shrunk itself — it is already an average over many
+ * sub-chapters, so it is the most stable thing available. When the chapter has
+ * no usable data there is nothing to shrink toward and we fall back to
+ * {@link DEFAULT_CHAPTER_MEAN} (0.5), which is an admission of ignorance rather
+ * than a measurement. Note 0.5 is above the 0.25 four-option guess floor, so
+ * for a brand-new chapter the prior is mildly optimistic; that only matters
+ * while `nEff` is small, and while `nEff` is small nothing is reported at all.
+ */
+export function chapterMeanOf(observations: MasteryObservation[], now: number): number {
+  const sample = summarise(observations, now);
+  if (sample.nEff <= 0) return DEFAULT_CHAPTER_MEAN;
+  return sample.xEff / sample.nEff;
+}
+
+export function bucketFor(mastery: number, coverage: number): MasteryBucket {
+  if (mastery < BUCKET_THRESHOLDS.weak) return 'critical';
+  if (mastery < BUCKET_THRESHOLDS.developing) return 'weak';
+  if (mastery < BUCKET_THRESHOLDS.strong) return 'developing';
+  // A high score on a narrow slice of the sub-chapter is not strength. Without
+  // this clause, 10/10 on the same 4 questions would read as mastered.
+  return coverage >= STRONG_MIN_COVERAGE ? 'strong' : 'developing';
+}
+
+export interface EstimateOptions {
+  now?: number;
+  /** Shrinkage target. Defaults to {@link DEFAULT_CHAPTER_MEAN}. */
+  chapterMean?: number;
+  k?: number;
+  minNEff?: number;
+}
+
+export function estimateMastery(
+  observations: MasteryObservation[],
+  options: EstimateOptions = {},
+): MasteryEstimate {
+  const now = options.now ?? Date.now();
+  const k = options.k ?? SHRINKAGE_K;
+  const minNEff = options.minNEff ?? MIN_N_EFF;
+  const chapterMean = options.chapterMean ?? DEFAULT_CHAPTER_MEAN;
+  const sample = summarise(observations, now);
+
+  if (sample.nEff < minNEff) {
+    const reason =
+      sample.responses === 0
+        ? 'not practised yet'
+        : `only ${sample.responses} response(s), and recency-weighted to ${sample.nEff.toFixed(1)} — too little to score`;
+    return {
+      ...sample,
+      state: 'not-assessed',
+      nEffNeeded: minNEff - sample.nEff,
+      reason,
+    };
+  }
+
+  const accHat = (sample.xEff + k * chapterMean) / (sample.nEff + k);
+  const mastery = accHat * (0.6 + 0.4 * sample.coverage);
+
+  return {
+    ...sample,
+    state: 'assessed',
+    accHat,
+    mastery,
+    confidence: sample.nEff / (sample.nEff + k),
+    bucket: bucketFor(mastery, sample.coverage),
+    chapterMean,
+  };
+}
+
+// ─── Folding the response log ─────────────────────────────────────────────────
+
+export function observationFromResponse(record: ResponseRecord): MasteryObservation {
+  return { qid: record.qid, correct: record.correct, ts: record.ts };
+}
+
+/** `subchapter` when the bank knows one, otherwise the chapter itself. */
+export function unitIdOf(record: Pick<ResponseRecord, 'topicId' | 'subchapter'>): string {
+  return record.subchapter ?? record.topicId;
+}
+
+export interface MasteryMapOptions {
+  now?: number;
+  k?: number;
+  minNEff?: number;
+  /**
+   * Drop records whose timestamps were imputed by the legacy migration. Off by
+   * default: a migrated record's `correct` flag is still real evidence, and its
+   * timestamp is backdated a full half-life so it already counts for half.
+   */
+  excludeImputedTs?: boolean;
+}
+
+export interface MasteryMap {
+  /** Keyed by {@link unitIdOf}. */
+  units: Map<string, MasteryUnit>;
+  /** Shrinkage target actually used per chapter, keyed by `topicId`. */
+  chapterMeans: Map<string, number>;
+  now: number;
+}
+
+/**
+ * Builds the per-sub-chapter mastery map from raw response records.
+ *
+ * Shrinkage happens toward the *chapter* mean (computed from every record in
+ * that chapter, across all its sub-chapters), which is the whole point of
+ * empirical Bayes here: a sub-chapter with three responses borrows strength
+ * from its siblings instead of inventing a confident number from nothing.
+ */
+export function masteryFromResponses(
+  records: ResponseRecord[],
+  options: MasteryMapOptions = {},
+): MasteryMap {
+  const now = options.now ?? Date.now();
+  const usable = options.excludeImputedTs === true
+    ? records.filter((record) => !(record.imputed?.includes('ts') ?? false))
+    : records;
+
+  const byChapter = new Map<string, MasteryObservation[]>();
+  const byUnit = new Map<string, { topicId: string; subchapter: string | null; observations: MasteryObservation[] }>();
+
+  for (const record of usable) {
+    const observation = observationFromResponse(record);
+    const chapterBucket = byChapter.get(record.topicId);
+    if (chapterBucket) chapterBucket.push(observation);
+    else byChapter.set(record.topicId, [observation]);
+
+    const unitId = unitIdOf(record);
+    const unitBucket = byUnit.get(unitId);
+    if (unitBucket) unitBucket.observations.push(observation);
+    else {
+      byUnit.set(unitId, {
+        topicId: record.topicId,
+        subchapter: record.subchapter ?? null,
+        observations: [observation],
+      });
+    }
+  }
+
+  const chapterMeans = new Map<string, number>();
+  for (const [topicId, observations] of byChapter) {
+    chapterMeans.set(topicId, chapterMeanOf(observations, now));
+  }
+
+  const units = new Map<string, MasteryUnit>();
+  for (const [unitId, unit] of byUnit) {
+    units.set(unitId, {
+      unitId,
+      topicId: unit.topicId,
+      subchapter: unit.subchapter,
+      estimate: estimateMastery(unit.observations, {
+        now,
+        k: options.k,
+        minNEff: options.minNEff,
+        chapterMean: chapterMeans.get(unit.topicId) ?? DEFAULT_CHAPTER_MEAN,
+      }),
+    });
+  }
+
+  return { units, chapterMeans, now };
+}
+
+/**
+ * Includes units the learner has never touched, as explicit `not-assessed`
+ * entries. Needed so a dashboard can say "17 sub-chapters not assessed" instead
+ * of quietly omitting them, which would make a 4%-covered bank look complete.
+ */
+export function withUnassessedUnits(
+  map: MasteryMap,
+  allUnits: Array<{ unitId: string; topicId: string; subchapter?: string | null }>,
+  options: MasteryMapOptions = {},
+): MasteryMap {
+  const units = new Map(map.units);
+  for (const unit of allUnits) {
+    if (units.has(unit.unitId)) continue;
+    units.set(unit.unitId, {
+      unitId: unit.unitId,
+      topicId: unit.topicId,
+      subchapter: unit.subchapter ?? null,
+      estimate: estimateMastery([], { now: map.now, minNEff: options.minNEff }),
+    });
+  }
+  return { ...map, units };
+}
+
+// ─── Triage ───────────────────────────────────────────────────────────────────
+
+export interface MasteryTriage {
+  critical: MasteryUnit[];
+  weak: MasteryUnit[];
+  developing: MasteryUnit[];
+  strong: MasteryUnit[];
+  /** Kept separate on purpose: "unknown" is not a weakness. */
+  notAssessed: MasteryUnit[];
+}
+
+export function triage(map: MasteryMap): MasteryTriage {
+  const result: MasteryTriage = { critical: [], weak: [], developing: [], strong: [], notAssessed: [] };
+  for (const unit of map.units.values()) {
+    if (unit.estimate.state === 'not-assessed') result.notAssessed.push(unit);
+    else result[unit.estimate.bucket].push(unit);
+  }
+  const byMastery = (a: MasteryUnit, b: MasteryUnit) =>
+    (a.estimate.state === 'assessed' ? a.estimate.mastery : 0) -
+    (b.estimate.state === 'assessed' ? b.estimate.mastery : 0);
+  result.critical.sort(byMastery);
+  result.weak.sort(byMastery);
+  result.developing.sort(byMastery);
+  result.strong.sort(byMastery);
+  return result;
+}
+
+/**
+ * Fraction of the whole syllabus actually sampled, weighted by unit count.
+ * `totalUnits` must be the blueprint's unit count, not the number of units the
+ * learner happens to have touched — otherwise coverage is trivially 1.0 and the
+ * readiness cap in scheduler.ts never binds.
+ */
+export function overallCoverage(map: MasteryMap, totalUnits: number): number {
+  if (totalUnits <= 0) return 0;
+  let sum = 0;
+  for (const unit of map.units.values()) sum += unit.estimate.coverage;
+  return Math.min(1, sum / totalUnits);
+}
diff --git a/frontend/src/services/optionOrdering.ts b/frontend/src/services/optionOrdering.ts
new file mode 100644
index 0000000..a8d1319
--- /dev/null
+++ b/frontend/src/services/optionOrdering.ts
@@ -0,0 +1,309 @@
+/**
+ * Answer-option ordering.
+ *
+ * ## Why this exists
+ *
+ * The authored question bank has a severe answer-position bias. As written, the
+ * correct answer sits in option 2 for 32.6% of the bank (chi-square 155 on 3 df),
+ * and per chapter it reaches 65% in ch9, 56% in ch6, 50% in ch8, while ch3 puts
+ * 47% in option 1. Options were never reordered anywhere in the app, so a student
+ * could score 65% on ch9 by blind-guessing "2" — learning the tell instead of the
+ * material, then meeting a real exam that has no such tell.
+ *
+ * ## Why ordering is assigned per chapter, not per question
+ *
+ * The obvious fix — give each question an independent pseudo-random permutation
+ * seeded from its id — was tried and is not good enough. An independent draw only
+ * removes the bias *in expectation*; any particular draw still lands a sampling
+ * error of roughly one standard deviation, which at n = 474 (ch1) is about 2
+ * percentage points per slot. One real draw put 159 of 474 ch1 answers in slot 2
+ * against an expectation of 132, i.e. 33.5%, barely better than leaving it alone.
+ * Worse, the draw is a function of question ids, and ids are array positions, so
+ * deleting a single duplicate row reshuffles every seed in the file and re-rolls
+ * the dice on the whole chapter. That makes the distribution unpredictable across
+ * ordinary data edits.
+ *
+ * Assigning positions across a whole chapter at once removes the sampling error
+ * by construction: every slot gets its fair share because the share is computed,
+ * not sampled.
+ *
+ * ## Properties this function guarantees
+ *
+ * - **Balanced.** Within a chapter, correct answers are spread as evenly across
+ *   the available display slots as the content permits.
+ * - **Deterministic.** The output depends only on the input array. Stored answers
+ *   are option *indices* (in localStorage drafts, progress records and, later,
+ *   server rows), so a permutation that varied between loads would silently
+ *   re-point every answer a user has already given.
+ * - **Positional options stay last.** "All of the above" and friends are pinned to
+ *   the end in their original relative order; moving one mid-list makes the
+ *   question nonsense. 585 such options exist in the bank, 583 of them already in
+ *   slot 4. Pinning constrains the balance: a question with one pinned option can
+ *   only place a free correct answer in slots 1-3, so slot 4 can be filled only by
+ *   questions with no pinned option, or by questions whose answer *is* the pinned
+ *   option. In the current bank there are enough of the former that every chapter
+ *   still reaches ~25.1%; a bank with far more positional options would not.
+ * - **No index-correlated pattern.** Slots are assigned least-loaded-first over a
+ *   hash-scrambled traversal, not round-robin in array order. Naive round-robin
+ *   balances just as well but makes consecutive questions cycle 1,2,3,4,1,2,3,4 —
+ *   a new tell, replacing the one being removed.
+ */
+
+/**
+ * Options whose meaning depends on being last. Pinned, never shuffled.
+ */
+export const POSITIONAL_OPTION_RE =
+  /^\s*(all|none|both)\s+(of\s+)?(the\s+)?(above|these|mentioned)/i;
+
+/** FNV-1a: turns a question id into a stable 32-bit seed. */
+export function hashSeed(input: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+/** mulberry32 — small, fast, seedable PRNG. */
+export function seededRandom(seed: number): () => number {
+  let a = seed;
+  return () => {
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** Uniform Fisher-Yates. */
+export function fisherYates<T>(arr: readonly T[], rand: () => number = Math.random): T[] {
+  const a = [...arr];
+  for (let i = a.length - 1; i > 0; i--) {
+    const j = Math.floor(rand() * (i + 1));
+    [a[i], a[j]] = [a[j], a[i]];
+  }
+  return a;
+}
+
+export interface OrderableQuestion {
+  /** Stable key used for seeding. Two questions must not share one. */
+  id: string;
+  options: readonly string[];
+  /** Index into `options`, or -1 for "no answer key". */
+  correctIndex: number;
+}
+
+export interface OrderedOptions {
+  options: string[];
+  correctIndex: number;
+}
+
+/** Splits option indices into pinned (positional) and free, preserving order. */
+function partition(options: readonly string[]): { free: number[]; pinned: number[] } {
+  const free: number[] = [];
+  const pinned: number[] = [];
+  options.forEach((o, i) => {
+    if (POSITIONAL_OPTION_RE.test(o)) pinned.push(i);
+    else free.push(i);
+  });
+  return { free, pinned };
+}
+
+/**
+ * True when there is nothing meaningful to reorder: fewer than two options
+ * overall, or fewer than two *free* options (one free option plus pinned tails
+ * has only one possible arrangement).
+ */
+function isDegenerate(options: readonly string[], free: number[]): boolean {
+  return options.length < 2 || free.length < 2;
+}
+
+/**
+ * Orders the options of one question in isolation.
+ *
+ * Kept for single-question callers and for tests. Prefer
+ * {@link assignOptionOrders} for a whole chapter: this function can only draw
+ * independently and therefore carries the sampling error described above.
+ */
+export function orderOptions(
+  options: readonly string[],
+  correctIndex: number,
+  seedKey: string
+): OrderedOptions {
+  const { free, pinned } = partition(options);
+  if (isDegenerate(options, free)) {
+    return { options: [...options], correctIndex };
+  }
+
+  const order = [...fisherYates(free, seededRandom(hashSeed(seedKey))), ...pinned];
+  return {
+    options: order.map((i) => options[i]),
+    correctIndex: correctIndex >= 0 ? order.indexOf(correctIndex) : correctIndex,
+  };
+}
+
+/**
+ * Orders the options of every question in a chapter, balancing which display
+ * slot holds the correct answer across the chapter as a whole.
+ *
+ * Returns results positionally aligned with `questions`.
+ */
+export function assignOptionOrders(questions: readonly OrderableQuestion[]): OrderedOptions[] {
+  const results = new Array<OrderedOptions>(questions.length);
+
+  // How many correct answers have landed in each display slot so far. Sized to
+  // the widest question so a 5-option set would not overflow.
+  const maxOptions = questions.reduce((m, q) => Math.max(m, q.options.length), 0);
+  const slotLoad = new Array<number>(Math.max(maxOptions, 1)).fill(0);
+
+  interface Plan {
+    index: number;
+    free: number[];
+    pinned: number[];
+    /** Slot the correct answer must occupy, or null if we may choose. */
+    forcedSlot: number | null;
+  }
+
+  const plans: Plan[] = [];
+
+  for (let index = 0; index < questions.length; index++) {
+    const q = questions[index];
+    const { free, pinned } = partition(q.options);
+
+    if (isDegenerate(q.options, free)) {
+      results[index] = { options: [...q.options], correctIndex: q.correctIndex };
+      // A degenerate question still shows its answer in a slot, so it must count
+      // toward the load or the balance would be computed against a partial view.
+      if (q.correctIndex >= 0 && q.correctIndex < slotLoad.length) slotLoad[q.correctIndex]++;
+      continue;
+    }
+
+    // A pinned correct answer cannot move: pinned options are appended after the
+    // free ones in their original relative order.
+    const pinnedRank = pinned.indexOf(q.correctIndex);
+    const forcedSlot =
+      q.correctIndex < 0 ? null : pinnedRank >= 0 ? free.length + pinnedRank : null;
+
+    plans.push({ index, free, pinned, forcedSlot });
+  }
+
+  // Count the forced placements first, so the free ones balance against reality
+  // rather than against an empty board.
+  for (const plan of plans) {
+    if (plan.forcedSlot !== null && plan.forcedSlot < slotLoad.length) {
+      slotLoad[plan.forcedSlot]++;
+    }
+  }
+
+  // Traverse in hash-scrambled order so slot choice does not track array index.
+  const freePlans = plans
+    .filter((p) => p.forcedSlot === null)
+    .sort((a, b) => {
+      const ha = hashSeed(questions[a.index].id);
+      const hb = hashSeed(questions[b.index].id);
+      return ha === hb ? a.index - b.index : ha - hb;
+    });
+
+  const chosenSlot = new Map<number, number>();
+
+  for (const plan of freePlans) {
+    const q = questions[plan.index];
+
+    if (q.correctIndex < 0) {
+      // No answer key: nothing to balance, just shuffle for consistency.
+      chosenSlot.set(plan.index, -1);
+      continue;
+    }
+
+    // Feasible slots are exactly the free slots, 0 .. free.length - 1.
+    let best = 0;
+    let bestLoad = Infinity;
+    const rand = seededRandom(hashSeed(`slot:${q.id}`));
+    for (let slot = 0; slot < plan.free.length; slot++) {
+      const load = slotLoad[slot];
+      // Random tie-break so equal loads do not always resolve to the lowest slot.
+      if (load < bestLoad || (load === bestLoad && rand() < 0.5)) {
+        best = slot;
+        bestLoad = load;
+      }
+    }
+
+    slotLoad[best]++;
+    chosenSlot.set(plan.index, best);
+  }
+
+  // Materialise each permutation.
+  for (const plan of plans) {
+    const q = questions[plan.index];
+    const rand = seededRandom(hashSeed(`perm:${q.id}`));
+
+    let freeOrder: number[];
+
+    if (plan.forcedSlot !== null || q.correctIndex < 0) {
+      // Nothing to place deliberately; a plain shuffle of the free options.
+      freeOrder = fisherYates(plan.free, rand);
+    } else {
+      const target = chosenSlot.get(plan.index) ?? 0;
+      const others = fisherYates(
+        plan.free.filter((i) => i !== q.correctIndex),
+        rand
+      );
+      freeOrder = [];
+      let cursor = 0;
+      for (let slot = 0; slot < plan.free.length; slot++) {
+        freeOrder.push(slot === target ? q.correctIndex : others[cursor++]);
+      }
+    }
+
+    const order = [...freeOrder, ...plan.pinned];
+    results[plan.index] = {
+      options: order.map((i) => q.options[i]),
+      correctIndex: q.correctIndex >= 0 ? order.indexOf(q.correctIndex) : q.correctIndex,
+    };
+  }
+
+  return results;
+}
+
+/**
+ * A lower bound on the worst-slot share a chapter could reach.
+ *
+ * Counts the placements that are forced (the correct answer *is* a pinned
+ * option, so its slot is fixed) and then spreads the remaining answers evenly
+ * over the four slots. This is optimistic: it does not verify that slot 4 is
+ * actually reachable for each remaining answer, which it is not for any question
+ * carrying a pinned option. So treat the result as "no assignment can do better
+ * than this", not as "this is achievable".
+ *
+ * Used by the validator so a chapter failing the bias gate can say whether it hit
+ * an unlucky assignment or a genuine content ceiling. On the current bank the
+ * bound is tight — {@link assignOptionOrders} reaches it for all ten chapters.
+ */
+export function attainableWorstShare(questions: readonly OrderableQuestion[]): number {
+  const slots = new Array<number>(4).fill(0);
+  let keyed = 0;
+
+  for (const q of questions) {
+    if (q.correctIndex < 0) continue;
+    keyed++;
+    const { free, pinned } = partition(q.options);
+    const pinnedRank = pinned.indexOf(q.correctIndex);
+    if (!isDegenerate(q.options, free) && pinnedRank >= 0) {
+      slots[Math.min(free.length + pinnedRank, 3)]++;
+    }
+  }
+
+  // Spread every unconstrained answer as evenly as possible over slots 0..3.
+  const forced = slots.reduce((a, b) => a + b, 0);
+  let remaining = keyed - forced;
+  const ideal = [...slots];
+  while (remaining > 0) {
+    let min = 0;
+    for (let i = 1; i < 4; i++) if (ideal[i] < ideal[min]) min = i;
+    ideal[min]++;
+    remaining--;
+  }
+
+  return keyed === 0 ? 0 : Math.max(...ideal) / keyed;
+}
diff --git a/frontend/src/services/questionReference.ts b/frontend/src/services/questionReference.ts
new file mode 100644
index 0000000..5bccdd3
--- /dev/null
+++ b/frontend/src/services/questionReference.ts
@@ -0,0 +1,84 @@
+/**
+ * What we can tell a student about a question without an explanation.
+ *
+ * No question in the bank has an explanation, and none will be generated here
+ * — no live API is used in this project. That left the post-answer panel saying
+ * "No explanation has been written for this question yet" and nothing else,
+ * which is honest but useless: a student who got it wrong has no idea what to
+ * revise.
+ *
+ * A syllabus reference is the honest thing that CAN be derived. The chapter is
+ * a fact — it is which file the question shipped in — and the sub-chapter is a
+ * deterministic keyword match that declines when it is not sure
+ * (`subchapterClassifier`). So the panel can always say at least
+ *
+ *     Syllabus reference — Chapter 5: Computer Network and Network Security
+ *
+ * and about two thirds of the time it can say
+ *
+ *     Syllabus reference — 5.4 Transport Layer
+ *
+ * This is NOT an explanation and is never presented as one. It points at the
+ * syllabus so revision has somewhere to start.
+ */
+
+import { getChapterByBookChapterId } from '../data/syllabus';
+import { classifySubchapter, type SubchapterMatch } from './subchapterClassifier';
+
+/**
+ * Below this, a match is reported as tentative in the UI. 4000 bp is roughly
+ * "one strong term and a clear runner-up gap" — enough to be worth showing,
+ * not enough to state flatly.
+ */
+const TENTATIVE_BELOW_BP = 4000;
+
+export interface QuestionReference {
+  /** Always present: the chapter is known, not inferred. */
+  readonly chapterNumber: number;
+  readonly chapterTitle: string;
+  /** The matched sub-chapter, or null when the classifier declined. */
+  readonly subchapter: SubchapterMatch | null;
+  /** True when a sub-chapter matched but only weakly. */
+  readonly tentative: boolean;
+  /**
+   * One line fit to render, e.g. `'5.4 Transport Layer'` or
+   * `'Chapter 5: Concept of Computer Network and Network Security System'`.
+   */
+  readonly label: string;
+}
+
+export interface ReferenceInput {
+  /** The chapter id the question shipped under, e.g. `'book-ch5'`. */
+  readonly topicId: string;
+  readonly question: string;
+  readonly options: readonly string[];
+}
+
+/**
+ * Derive a syllabus reference for one question.
+ *
+ * Returns null only when the chapter itself is unrecognised — a custom or
+ * synthetic topic id. Every real question yields at least a chapter.
+ */
+export function describeReference(input: ReferenceInput): QuestionReference | null {
+  const chapter = getChapterByBookChapterId(input.topicId);
+  if (!chapter) return null;
+
+  const subchapter = classifySubchapter({
+    bookChapterId: input.topicId,
+    question: input.question,
+    options: input.options,
+  });
+
+  return {
+    chapterNumber: chapter.number,
+    chapterTitle: chapter.title,
+    subchapter,
+    tentative: subchapter !== null && subchapter.confidenceBp < TENTATIVE_BELOW_BP,
+    label: subchapter
+      ? `${subchapter.displayCode} ${subchapter.title}`
+      : `Chapter ${String(chapter.number)}: ${chapter.title}`,
+  };
+}
+
+export { TENTATIVE_BELOW_BP };
diff --git a/frontend/src/services/responseLog.ts b/frontend/src/services/responseLog.ts
new file mode 100644
index 0000000..8283a35
--- /dev/null
+++ b/frontend/src/services/responseLog.ts
@@ -0,0 +1,1094 @@
+/**
+ * responseLog — the append-only, event-sourced record of every answer.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * The legacy store (`eng_progress` in localStorage) is
+ * `{[topicId]: {attempted: string[], correct: string[]}}` and `recordAttempt`
+ * only ever *pushes* ids and dedupes them. Three consequences:
+ *
+ *   1. A question answered wrong and then right is "correct" forever. Reported
+ *      accuracy is monotonically non-decreasing, so it is an upper bound that
+ *      can never fall — i.e. it is inflated by construction.
+ *   2. There are no response-level events at all: no timestamp, no chosen
+ *      option, no latency. Adaptive practice, item calibration, forgetting
+ *      curves and weak-area diagnosis are all impossible on that shape.
+ *   3. Two devices cannot be merged, because a set-union of ids silently
+ *      discards the history that would have resolved the conflict.
+ *
+ * This module stores one immutable record per response instead. Appending is
+ * the only mutation (plus a destructive `clearAll` for an explicit reset), so
+ * two devices merge by concatenating logs and deduping on `rid` — there is no
+ * conflict to resolve. Every derived number (mastery, Elo, schedule, readiness)
+ * is a pure fold over this log and can be recomputed from scratch at any time.
+ *
+ * STORAGE
+ * -------
+ * Raw IndexedDB, no Dexie. The store is injectable (`ResponseLogStore`) so the
+ * pure logic and the jsdom test suite do not need a real IndexedDB.
+ *
+ * FAILURE POLICY
+ * --------------
+ * A dropped write is worse than a visible error: the log is the only source of
+ * truth, so losing a record silently corrupts every derived statistic forever.
+ * Every entry point therefore rejects with a typed {@link ResponseLogError}
+ * carrying a machine-readable `code`, and nothing is ever swallowed. There is a
+ * `createMemoryResponseLogStore()` the caller may *explicitly* fall back to, but
+ * this module never installs it behind the caller's back.
+ */
+
+// ─── Record shape ─────────────────────────────────────────────────────────────
+
+export const PRACTICE_MODES = [
+  'topic',
+  'quick',
+  'custom',
+  'mock',
+  'review',
+  'flashcard',
+] as const;
+
+export type PracticeMode = (typeof PRACTICE_MODES)[number];
+
+/** Fields that `migrateLegacyProgress` is able to reconstruct but not observe. */
+export const IMPUTED_FIELDS = [
+  'ts',
+  'chosenIndex',
+  'latencyMs',
+  'mode',
+  'flaggedGuess',
+  'subchapter',
+] as const;
+
+export type ImputedField = (typeof IMPUTED_FIELDS)[number];
+
+export interface ResponseRecord {
+  /** Response id. Globally unique; the merge key across devices. */
+  rid: string;
+  /** Question id, the `{topicId}_{index}` form minted by localData. */
+  qid: string;
+  /** Chapter id, e.g. `book-ch1`. */
+  topicId: string;
+  /** Sub-chapter id when the bank knows one; mastery falls back to `topicId`. */
+  subchapter?: string;
+  mode: PracticeMode;
+  /** Groups the responses of one sitting (a mock attempt, a practice session). */
+  attemptId?: string;
+  /** Index into the question's presented options; `null` when not recorded. */
+  chosenIndex: number | null;
+  correct: boolean;
+  /** Time from question shown to answer committed. */
+  latencyMs: number;
+  /** Learner (or heuristic) marked this answer as a guess. */
+  flaggedGuess: boolean;
+  /** Optional self-report, 1 = unsure … 3 = sure. Never required. */
+  confidence?: 1 | 2 | 3;
+  /** Epoch milliseconds. */
+  ts: number;
+  /**
+   * Provenance. Absent means every field above was actually observed. Present
+   * means the listed fields were reconstructed by a migration and must not be
+   * treated as measurements.
+   */
+  imputed?: ImputedField[];
+  /** Absent or `'live'` means the record came from a real answered question. */
+  source?: 'live' | 'legacy-migration';
+}
+
+/** What a caller supplies; `rid` and `ts` are filled in when omitted. */
+export type ResponseInput = Omit<ResponseRecord, 'rid' | 'ts'> & {
+  rid?: string;
+  ts?: number;
+};
+
+// ─── Schema ───────────────────────────────────────────────────────────────────
+
+export const RESPONSE_LOG_DB_NAME = 'necprep-learner';
+export const RESPONSE_LOG_STORE = 'responses';
+/**
+ * Schema version. Bump and extend `applyUpgrade` to add a store or an index.
+ * An upgrade may never rewrite existing rows — the log is append-only, and a
+ * migration that edits history would break cross-device merge by `rid`.
+ */
+export const RESPONSE_LOG_SCHEMA_VERSION = 1;
+
+const INDEX_TS = 'ts';
+const INDEX_TOPIC_TS = 'topicId_ts';
+const INDEX_MODE = 'mode';
+const INDEX_QID = 'qid';
+const INDEX_ATTEMPT = 'attemptId';
+
+/** IndexedDB's own numeric key bounds for dates; safe sentinels for ranges. */
+const MIN_TS = -8.64e15;
+const MAX_TS = 8.64e15;
+
+// ─── Errors ───────────────────────────────────────────────────────────────────
+
+export type ResponseLogErrorCode =
+  /** No IndexedDB at all, or `open()` threw — Firefox private browsing does this. */
+  | 'unavailable'
+  /** The browser refused the write because the origin is out of disk quota. */
+  | 'quota-exceeded'
+  /** Another tab holds an older connection open, so the upgrade cannot run. */
+  | 'blocked'
+  /** The stored database is newer than this build's schema version. */
+  | 'version-error'
+  /** The transaction aborted for any other reason; the write did NOT land. */
+  | 'aborted'
+  /** Append was called with a record that violates the schema. */
+  | 'invalid'
+  /** A record with that `rid` already exists (the log is immutable). */
+  | 'duplicate'
+  | 'unknown';
+
+export class ResponseLogError extends Error {
+  readonly code: ResponseLogErrorCode;
+
+  constructor(code: ResponseLogErrorCode, message: string, cause?: unknown) {
+    super(message, { cause });
+    this.name = 'ResponseLogError';
+    this.code = code;
+  }
+}
+
+export function isResponseLogError(err: unknown): err is ResponseLogError {
+  return err instanceof ResponseLogError;
+}
+
+function errorName(err: unknown): string {
+  if (err instanceof Error) return err.name;
+  if (typeof err === 'object' && err !== null && 'name' in err) {
+    return String((err as { name: unknown }).name);
+  }
+  return '';
+}
+
+function isQuotaError(err: unknown): boolean {
+  const name = errorName(err);
+  return name === 'QuotaExceededError' || name === 'NS_ERROR_DOM_QUOTA_REACHED';
+}
+
+function wrapWriteError(err: unknown, what: string): ResponseLogError {
+  if (isResponseLogError(err)) return err;
+  if (isQuotaError(err)) {
+    return new ResponseLogError(
+      'quota-exceeded',
+      `${what}: storage quota exceeded, the write did not land`,
+      err,
+    );
+  }
+  const name = errorName(err);
+  if (name === 'ConstraintError') {
+    return new ResponseLogError('duplicate', `${what}: a record with that rid already exists`, err);
+  }
+  if (name === 'AbortError' || name === 'TransactionInactiveError') {
+    return new ResponseLogError('aborted', `${what}: transaction aborted, the write did not land`, err);
+  }
+  return new ResponseLogError('unknown', `${what}: ${name || 'unknown failure'}`, err);
+}
+
+// ─── Record construction and validation ───────────────────────────────────────
+
+let ridCounter = 0;
+
+export function makeRid(): string {
+  const cryptoObj: Crypto | undefined = typeof globalThis.crypto === 'undefined' ? undefined : globalThis.crypto;
+  if (cryptoObj && typeof cryptoObj.randomUUID === 'function') return cryptoObj.randomUUID();
+  ridCounter += 1;
+  return `r-${Date.now().toString(36)}-${ridCounter.toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/** Returns a list of schema problems; empty means the record is well formed. */
+export function validateResponse(record: ResponseRecord): string[] {
+  const problems: string[] = [];
+  if (!record.rid) problems.push('rid is required');
+  if (!record.qid) problems.push('qid is required');
+  if (!record.topicId) problems.push('topicId is required');
+  if (!PRACTICE_MODES.includes(record.mode)) problems.push(`mode "${record.mode}" is not a PracticeMode`);
+  if (typeof record.correct !== 'boolean') problems.push('correct must be a boolean');
+  if (!Number.isFinite(record.ts)) problems.push('ts must be a finite epoch-ms number');
+  if (!Number.isFinite(record.latencyMs) || record.latencyMs < 0) {
+    problems.push('latencyMs must be a non-negative finite number');
+  }
+  if (record.chosenIndex !== null && !Number.isInteger(record.chosenIndex)) {
+    problems.push('chosenIndex must be an integer or null');
+  }
+  if (typeof record.flaggedGuess !== 'boolean') problems.push('flaggedGuess must be a boolean');
+  if (record.confidence !== undefined && ![1, 2, 3].includes(record.confidence)) {
+    problems.push('confidence must be 1, 2 or 3 when present');
+  }
+  return problems;
+}
+
+/** Fills in `rid`/`ts`, validates, and freezes. Throws `invalid` on a bad record. */
+export function createResponse(input: ResponseInput, now: number = Date.now()): ResponseRecord {
+  const record: ResponseRecord = {
+    ...input,
+    rid: input.rid ?? makeRid(),
+    ts: input.ts ?? now,
+  };
+  const problems = validateResponse(record);
+  if (problems.length > 0) {
+    throw new ResponseLogError('invalid', `invalid response record: ${problems.join('; ')}`);
+  }
+  return Object.freeze(record);
+}
+
+// ─── Query model ──────────────────────────────────────────────────────────────
+
+export interface ResponseQuery {
+  /** Inclusive lower bound on `ts`. */
+  from?: number;
+  /** Inclusive upper bound on `ts`. */
+  to?: number;
+  topicId?: string;
+  subchapter?: string;
+  mode?: PracticeMode;
+  qid?: string;
+  attemptId?: string;
+  /** Drop records whose timestamps were imputed by a migration. */
+  excludeImputedTs?: boolean;
+  /** Max records returned. Applied after chronological ordering. */
+  limit?: number;
+  /** Chronological direction of the result. Default `'asc'`. */
+  direction?: 'asc' | 'desc';
+}
+
+export function isTsImputed(record: ResponseRecord): boolean {
+  return record.imputed?.includes('ts') ?? false;
+}
+
+/** Pure predicate shared by the IndexedDB and in-memory stores. */
+export function matchesQuery(record: ResponseRecord, query: ResponseQuery = {}): boolean {
+  if (query.from !== undefined && record.ts < query.from) return false;
+  if (query.to !== undefined && record.ts > query.to) return false;
+  if (query.topicId !== undefined && record.topicId !== query.topicId) return false;
+  if (query.subchapter !== undefined && record.subchapter !== query.subchapter) return false;
+  if (query.mode !== undefined && record.mode !== query.mode) return false;
+  if (query.qid !== undefined && record.qid !== query.qid) return false;
+  if (query.attemptId !== undefined && record.attemptId !== query.attemptId) return false;
+  if (query.excludeImputedTs === true && isTsImputed(record)) return false;
+  return true;
+}
+
+export type RangeSpec =
+  | { kind: 'only'; value: IDBValidKey }
+  | { kind: 'bound'; lower: IDBValidKey; upper: IDBValidKey };
+
+export interface ScanPlan {
+  /** Index to cursor over. */
+  index: typeof INDEX_TS | typeof INDEX_TOPIC_TS | typeof INDEX_MODE | typeof INDEX_QID | typeof INDEX_ATTEMPT;
+  range: RangeSpec | null;
+  /**
+   * True when the chosen index yields records in `ts` order, which is what lets
+   * a limited query stop the cursor early instead of scanning the whole log.
+   */
+  chronological: boolean;
+}
+
+/**
+ * Chooses the cheapest index for a query. Exported because it is pure and the
+ * interesting part of query performance.
+ */
+export function planScan(query: ResponseQuery = {}): ScanPlan {
+  if (query.qid !== undefined) {
+    return { index: INDEX_QID, range: { kind: 'only', value: query.qid }, chronological: false };
+  }
+  if (query.attemptId !== undefined) {
+    return { index: INDEX_ATTEMPT, range: { kind: 'only', value: query.attemptId }, chronological: false };
+  }
+  if (query.topicId !== undefined) {
+    return {
+      index: INDEX_TOPIC_TS,
+      range: {
+        kind: 'bound',
+        lower: [query.topicId, query.from ?? MIN_TS],
+        upper: [query.topicId, query.to ?? MAX_TS],
+      },
+      chronological: true,
+    };
+  }
+  if (query.mode !== undefined) {
+    return { index: INDEX_MODE, range: { kind: 'only', value: query.mode }, chronological: false };
+  }
+  if (query.from !== undefined || query.to !== undefined) {
+    return {
+      index: INDEX_TS,
+      range: { kind: 'bound', lower: query.from ?? MIN_TS, upper: query.to ?? MAX_TS },
+      chronological: true,
+    };
+  }
+  return { index: INDEX_TS, range: null, chronological: true };
+}
+
+/**
+ * Visitor for the cursor-based iterator. Return `false` to stop the walk, so a
+ * caller can answer "did this learner ever see qid X" without materialising a
+ * 50,000-record log.
+ */
+export type ResponseVisitor = (record: ResponseRecord, index: number) => boolean | void;
+
+export interface AppendOptions {
+  /**
+   * Treat an existing `rid` as a no-op instead of an error. Needed for the
+   * legacy migration (whose rids are deterministic) and for device merge.
+   */
+  skipDuplicates?: boolean;
+}
+
+export interface AppendManyResult {
+  appended: number;
+  duplicates: number;
+}
+
+export interface ResponseLogExport {
+  schema: 'necprep-responselog-v1';
+  dbVersion: number;
+  exportedAt: string;
+  count: number;
+  records: ResponseRecord[];
+}
+
+export interface ResponseLogStore {
+  readonly kind: 'indexeddb' | 'memory';
+  append(input: ResponseInput): Promise<ResponseRecord>;
+  appendMany(inputs: ResponseInput[], options?: AppendOptions): Promise<AppendManyResult>;
+  /** Materialises the matching records, chronologically ordered. */
+  query(query?: ResponseQuery): Promise<ResponseRecord[]>;
+  /** Streams matching records through a cursor; returns how many were visited. */
+  iterate(query: ResponseQuery | undefined, visit: ResponseVisitor): Promise<number>;
+  count(query?: ResponseQuery): Promise<number>;
+  exportAll(): Promise<ResponseLogExport>;
+  /** Destructive. Only for an explicit "delete my data" action. */
+  clearAll(): Promise<void>;
+  close(): void;
+}
+
+// ─── Shared ordering helpers ──────────────────────────────────────────────────
+
+function orderAndLimit(records: ResponseRecord[], query: ResponseQuery = {}): ResponseRecord[] {
+  const sign = query.direction === 'desc' ? -1 : 1;
+  const sorted = [...records].sort((a, b) => (a.ts === b.ts ? (a.rid < b.rid ? -1 : 1) * sign : (a.ts - b.ts) * sign));
+  return query.limit !== undefined ? sorted.slice(0, Math.max(0, query.limit)) : sorted;
+}
+
+// ─── IndexedDB store ──────────────────────────────────────────────────────────
+
+/**
+ * The subset of `IDBKeyRange`'s static side this module uses. Injectable so a
+ * test fake can supply plain `{lower, upper, lowerOpen, upperOpen}` objects —
+ * jsdom ships no IndexedDB and therefore no `IDBKeyRange`.
+ */
+export interface KeyRangeFactory {
+  only(value: IDBValidKey): IDBKeyRange;
+  bound(lower: IDBValidKey, upper: IDBValidKey, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
+}
+
+export interface IndexedDbStoreConfig {
+  factory?: IDBFactory;
+  keyRange?: KeyRangeFactory;
+  dbName?: string;
+  version?: number;
+  /** How long to wait on a blocked upgrade before reporting `blocked`. */
+  blockedTimeoutMs?: number;
+}
+
+function resolveFactory(config: IndexedDbStoreConfig): IDBFactory {
+  const factory = config.factory ?? (typeof indexedDB === 'undefined' ? undefined : indexedDB);
+  if (!factory) {
+    throw new ResponseLogError(
+      'unavailable',
+      'IndexedDB is not available in this context (private browsing, or a non-browser host)',
+    );
+  }
+  return factory;
+}
+
+function resolveKeyRange(config: IndexedDbStoreConfig): KeyRangeFactory | null {
+  if (config.keyRange) return config.keyRange;
+  if (typeof IDBKeyRange === 'undefined') return null;
+  return IDBKeyRange;
+}
+
+function toKeyRange(spec: RangeSpec | null, keyRange: KeyRangeFactory | null): IDBKeyRange | null {
+  if (!spec || !keyRange) return null;
+  return spec.kind === 'only' ? keyRange.only(spec.value) : keyRange.bound(spec.lower, spec.upper);
+}
+
+function applyUpgrade(db: IDBDatabase, oldVersion: number): void {
+  if (oldVersion < 1) {
+    const store = db.createObjectStore(RESPONSE_LOG_STORE, { keyPath: 'rid' });
+    store.createIndex(INDEX_TS, 'ts');
+    store.createIndex(INDEX_TOPIC_TS, ['topicId', 'ts']);
+    store.createIndex(INDEX_MODE, 'mode');
+    store.createIndex(INDEX_QID, 'qid');
+    store.createIndex(INDEX_ATTEMPT, 'attemptId');
+  }
+  // Future versions add stores or indexes here. They must not rewrite rows:
+  // the log is append-only and `rid` is the cross-device merge key.
+}
+
+function openDatabase(config: IndexedDbStoreConfig): Promise<IDBDatabase> {
+  const factory = resolveFactory(config);
+  const name = config.dbName ?? RESPONSE_LOG_DB_NAME;
+  const version = config.version ?? RESPONSE_LOG_SCHEMA_VERSION;
+  const blockedTimeoutMs = config.blockedTimeoutMs ?? 4000;
+
+  return new Promise<IDBDatabase>((resolve, reject) => {
+    let settled = false;
+    let blockedTimer: ReturnType<typeof setTimeout> | null = null;
+
+    const finish = (fn: () => void) => {
+      if (settled) return;
+      settled = true;
+      if (blockedTimer !== null) clearTimeout(blockedTimer);
+      fn();
+    };
+
+    let request: IDBOpenDBRequest;
+    try {
+      request = factory.open(name, version);
+    } catch (err) {
+      // Firefox in private browsing throws synchronously here rather than
+      // returning a request that errors.
+      reject(new ResponseLogError('unavailable', 'indexedDB.open() threw; storage is blocked', err));
+      return;
+    }
+
+    request.onupgradeneeded = (event) => {
+      try {
+        applyUpgrade(request.result, event.oldVersion);
+      } catch (err) {
+        request.transaction?.abort();
+        finish(() => reject(wrapWriteError(err, 'schema upgrade failed')));
+      }
+    };
+
+    request.onblocked = () => {
+      // Another tab still holds an older connection. Give it a moment to react
+      // to `versionchange` and close; if it does not, the caller needs to know
+      // rather than hang forever behind a pending promise.
+      blockedTimer = setTimeout(() => {
+        finish(() =>
+          reject(
+            new ResponseLogError(
+              'blocked',
+              'the database upgrade is blocked by another open tab; ask the user to close other tabs',
+            ),
+          ),
+        );
+      }, blockedTimeoutMs);
+    };
+
+    request.onsuccess = () => {
+      const database = request.result;
+      // If another tab later triggers an upgrade, release the connection so we
+      // are not the tab that blocks it.
+      database.onversionchange = () => database.close();
+      if (settled) {
+        // We already reported `blocked`; do not leak the late connection.
+        database.close();
+        return;
+      }
+      finish(() => resolve(database));
+    };
+
+    request.onerror = () => {
+      const err = request.error;
+      const code: ResponseLogErrorCode =
+        errorName(err) === 'VersionError'
+          ? 'version-error'
+          : isQuotaError(err)
+            ? 'quota-exceeded'
+            : 'unavailable';
+      finish(() =>
+        reject(
+          new ResponseLogError(
+            code,
+            code === 'version-error'
+              ? `the stored database is newer than schema v${version}; this build cannot read it`
+              : 'could not open IndexedDB',
+            err,
+          ),
+        ),
+      );
+    };
+  });
+}
+
+function requestToPromise<T>(request: IDBRequest<T>, what: string): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(wrapWriteError(request.error, what));
+  });
+}
+
+/**
+ * IndexedDB-backed log. Lazily opens the database on first use so constructing
+ * the store never throws; every method rejects with a {@link ResponseLogError}.
+ */
+export function createIndexedDbResponseLogStore(config: IndexedDbStoreConfig = {}): ResponseLogStore {
+  let dbPromise: Promise<IDBDatabase> | null = null;
+  let closed = false;
+
+  const db = (): Promise<IDBDatabase> => {
+    if (closed) {
+      return Promise.reject(new ResponseLogError('unavailable', 'the response log store was closed'));
+    }
+    if (!dbPromise) {
+      dbPromise = openDatabase(config).catch((err: unknown) => {
+        // Do not cache a failed open: a quota or blocked failure is transient
+        // and the next call should get a fresh attempt.
+        dbPromise = null;
+        throw isResponseLogError(err) ? err : wrapWriteError(err, 'open failed');
+      });
+    }
+    return dbPromise;
+  };
+
+  const write = async (records: ResponseRecord[], options: AppendOptions): Promise<AppendManyResult> => {
+    if (records.length === 0) return { appended: 0, duplicates: 0 };
+    const database = await db();
+    return new Promise<AppendManyResult>((resolve, reject) => {
+      let tx: IDBTransaction;
+      try {
+        tx = database.transaction(RESPONSE_LOG_STORE, 'readwrite');
+      } catch (err) {
+        reject(wrapWriteError(err, 'could not start a write transaction'));
+        return;
+      }
+      let duplicates = 0;
+      let firstError: unknown = null;
+
+      tx.oncomplete = () => {
+        if (firstError) {
+          reject(wrapWriteError(firstError, 'append failed'));
+          return;
+        }
+        resolve({ appended: records.length - duplicates, duplicates });
+      };
+      tx.onabort = () => reject(wrapWriteError(firstError ?? tx.error, 'append aborted; no record landed'));
+
+      const store = tx.objectStore(RESPONSE_LOG_STORE);
+      for (const record of records) {
+        // `add`, never `put`: the log is immutable, so overwriting an existing
+        // rid must be an error rather than a silent history rewrite.
+        const request = store.add(record);
+        request.onerror = (event) => {
+          if (options.skipDuplicates === true && errorName(request.error) === 'ConstraintError') {
+            duplicates += 1;
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+          }
+          if (!firstError) firstError = request.error;
+        };
+      }
+    });
+  };
+
+  const walk = async (query: ResponseQuery | undefined, visit: ResponseVisitor): Promise<number> => {
+    const database = await db();
+    const plan = planScan(query);
+    const keyRange = resolveKeyRange(config);
+    const range = toKeyRange(plan.range, keyRange);
+    const direction: IDBCursorDirection = query?.direction === 'desc' && plan.chronological ? 'prev' : 'next';
+
+    return new Promise<number>((resolve, reject) => {
+      let tx: IDBTransaction;
+      try {
+        tx = database.transaction(RESPONSE_LOG_STORE, 'readonly');
+      } catch (err) {
+        reject(wrapWriteError(err, 'could not start a read transaction'));
+        return;
+      }
+      let visited = 0;
+      let stopped = false;
+      let failure: unknown = null;
+
+      tx.oncomplete = () => (failure ? reject(wrapWriteError(failure, 'iterate failed')) : resolve(visited));
+      tx.onabort = () => reject(wrapWriteError(tx.error, 'iterate aborted'));
+
+      const source = tx.objectStore(RESPONSE_LOG_STORE).index(plan.index);
+      const request = source.openCursor(range, direction);
+      request.onerror = () => {
+        failure = request.error;
+      };
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor || stopped) return;
+        const record = cursor.value as ResponseRecord;
+        // The range already handles what it can; the rest of the predicate is
+        // cheap and keeps one index sufficient for every query shape.
+        if (matchesQuery(record, query)) {
+          if (visit(record, visited) === false) {
+            stopped = true;
+            return;
+          }
+          visited += 1;
+        }
+        cursor.continue();
+      };
+    });
+  };
+
+  const runQuery = async (query: ResponseQuery = {}): Promise<ResponseRecord[]> => {
+    const plan = planScan(query);
+    const collected: ResponseRecord[] = [];
+    // Only a chronological plan may stop early: on a qid/mode/attempt index the
+    // cursor order is index-key order, so an early cut would return the wrong
+    // subset once the caller asked for a limit.
+    const canStopEarly = plan.chronological && query.limit !== undefined;
+    await walk(query, (record, index) => {
+      collected.push(record);
+      if (canStopEarly && index + 1 >= (query.limit ?? 0)) return false;
+      return true;
+    });
+    return orderAndLimit(collected, query);
+  };
+
+  return {
+    kind: 'indexeddb',
+
+    async append(input) {
+      const record = createResponse(input);
+      await write([record], {});
+      return record;
+    },
+
+    async appendMany(inputs, options = {}) {
+      const now = Date.now();
+      const records = inputs.map((input) => createResponse(input, now));
+      return write(records, options);
+    },
+
+    query(query = {}) {
+      return runQuery(query);
+    },
+
+    iterate(query, visit) {
+      return walk(query, visit);
+    },
+
+    async count(query = {}) {
+      const database = await db();
+      const isWholeStore = Object.keys(query).length === 0;
+      if (isWholeStore) {
+        const tx = database.transaction(RESPONSE_LOG_STORE, 'readonly');
+        return requestToPromise(tx.objectStore(RESPONSE_LOG_STORE).count(), 'count failed');
+      }
+      let n = 0;
+      await walk({ ...query, limit: undefined }, () => {
+        n += 1;
+      });
+      return n;
+    },
+
+    async exportAll() {
+      const records = await runQuery({});
+      return {
+        schema: 'necprep-responselog-v1',
+        dbVersion: config.version ?? RESPONSE_LOG_SCHEMA_VERSION,
+        exportedAt: new Date().toISOString(),
+        count: records.length,
+        records,
+      };
+    },
+
+    async clearAll() {
+      const database = await db();
+      const tx = database.transaction(RESPONSE_LOG_STORE, 'readwrite');
+      await requestToPromise(tx.objectStore(RESPONSE_LOG_STORE).clear(), 'clear failed');
+    },
+
+    close() {
+      closed = true;
+      const pending = dbPromise;
+      dbPromise = null;
+      if (pending) void pending.then((database) => database.close()).catch(() => undefined);
+    },
+  };
+}
+
+// ─── In-memory store ──────────────────────────────────────────────────────────
+
+/**
+ * Same contract, no persistence. Two uses, both deliberate:
+ *   - tests, so the pure logic needs no IndexedDB fake;
+ *   - an *explicit* caller-chosen fallback when `createIndexedDbResponseLogStore`
+ *     reports `unavailable` and the product decides a session-only log beats no
+ *     practice at all. This module never installs it silently.
+ */
+export function createMemoryResponseLogStore(seed: ResponseRecord[] = []): ResponseLogStore {
+  const rows = new Map<string, ResponseRecord>();
+  for (const record of seed) rows.set(record.rid, record);
+
+  const all = (): ResponseRecord[] => [...rows.values()].sort((a, b) => a.ts - b.ts);
+
+  const write = (records: ResponseRecord[], options: AppendOptions): AppendManyResult => {
+    // Check before writing anything, so a rejected batch leaves no partial
+    // state — matching the all-or-nothing IndexedDB transaction.
+    if (options.skipDuplicates !== true) {
+      const clash = records.find((record) => rows.has(record.rid));
+      if (clash) {
+        throw new ResponseLogError('duplicate', `rid ${clash.rid} already exists`);
+      }
+    }
+    let duplicates = 0;
+    for (const record of records) {
+      if (rows.has(record.rid)) {
+        duplicates += 1;
+        continue;
+      }
+      rows.set(record.rid, record);
+    }
+    return { appended: records.length - duplicates, duplicates };
+  };
+
+  return {
+    kind: 'memory',
+
+    // Both of these report failure by rejecting, never by throwing
+    // synchronously, so a caller's `.catch` is enough for either store.
+    append(input) {
+      try {
+        const record = createResponse(input);
+        write([record], {});
+        return Promise.resolve(record);
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    },
+
+    appendMany(inputs, options = {}) {
+      try {
+        const now = Date.now();
+        const records = inputs.map((input) => createResponse(input, now));
+        return Promise.resolve(write(records, options));
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    },
+
+    query(query = {}) {
+      return Promise.resolve(orderAndLimit(all().filter((r) => matchesQuery(r, query)), query));
+    },
+
+    iterate(query, visit) {
+      const ordered = query?.direction === 'desc' ? all().reverse() : all();
+      let visited = 0;
+      for (const record of ordered) {
+        if (!matchesQuery(record, query)) continue;
+        if (visit(record, visited) === false) break;
+        visited += 1;
+      }
+      return Promise.resolve(visited);
+    },
+
+    count(query = {}) {
+      return Promise.resolve(all().filter((r) => matchesQuery(r, query)).length);
+    },
+
+    exportAll() {
+      const records = all();
+      return Promise.resolve({
+        schema: 'necprep-responselog-v1' as const,
+        dbVersion: RESPONSE_LOG_SCHEMA_VERSION,
+        exportedAt: new Date().toISOString(),
+        count: records.length,
+        records,
+      });
+    },
+
+    clearAll() {
+      rows.clear();
+      return Promise.resolve();
+    },
+
+    close() {
+      /* nothing to release */
+    },
+  };
+}
+
+// ─── Default store (module singleton) ─────────────────────────────────────────
+
+let defaultConfig: IndexedDbStoreConfig = {};
+let defaultStore: ResponseLogStore | null = null;
+
+/** Point the default store at a different factory/db name. Resets the singleton. */
+export function configureResponseLog(config: IndexedDbStoreConfig): void {
+  defaultConfig = config;
+  defaultStore?.close();
+  defaultStore = null;
+}
+
+/** Install a specific store (tests, or an explicit memory fallback). */
+export function setResponseLogStore(store: ResponseLogStore | null): void {
+  if (defaultStore && defaultStore !== store) defaultStore.close();
+  defaultStore = store;
+}
+
+export function getResponseLogStore(): ResponseLogStore {
+  if (!defaultStore) defaultStore = createIndexedDbResponseLogStore(defaultConfig);
+  return defaultStore;
+}
+
+/**
+ * Cheap availability probe so the UI can warn before the learner answers 40
+ * questions into a log that cannot be written.
+ */
+export async function probeResponseLog(store: ResponseLogStore = getResponseLogStore()): Promise<
+  { ok: true; count: number } | { ok: false; code: ResponseLogErrorCode; message: string }
+> {
+  try {
+    return { ok: true, count: await store.count() };
+  } catch (err) {
+    const wrapped = isResponseLogError(err) ? err : wrapWriteError(err, 'probe failed');
+    return { ok: false, code: wrapped.code, message: wrapped.message };
+  }
+}
+
+export const appendResponse = (input: ResponseInput): Promise<ResponseRecord> =>
+  getResponseLogStore().append(input);
+
+export const appendResponses = (inputs: ResponseInput[], options?: AppendOptions): Promise<AppendManyResult> =>
+  getResponseLogStore().appendMany(inputs, options);
+
+export const queryResponses = (query?: ResponseQuery): Promise<ResponseRecord[]> =>
+  getResponseLogStore().query(query);
+
+export const iterateResponses = (query: ResponseQuery | undefined, visit: ResponseVisitor): Promise<number> =>
+  getResponseLogStore().iterate(query, visit);
+
+export const countResponses = (query?: ResponseQuery): Promise<number> =>
+  getResponseLogStore().count(query);
+
+export const exportResponseLog = (): Promise<ResponseLogExport> => getResponseLogStore().exportAll();
+
+export const clearResponseLog = (): Promise<void> => getResponseLogStore().clearAll();
+
+// ─── Legacy migration ─────────────────────────────────────────────────────────
+
+export const LEGACY_PROGRESS_KEY = 'eng_progress';
+export const LEGACY_HISTORY_KEY = 'eng_history';
+
+/**
+ * Imputed timestamps are backdated by this much rather than stamped "now".
+ *
+ * The legacy store never recorded when anything was answered. Stamping `now`
+ * would hand every migrated record a recency weight of 1.0 in mastery.ts and
+ * make a year-old half-remembered session look like this morning's practice.
+ * 30 days is exactly one mastery half-life, so a migrated record carries weight
+ * 0.5 — a deliberately discounted placeholder, flagged as imputed either way.
+ */
+export const LEGACY_TS_BACKDATE_DAYS = 30;
+
+interface LegacyProgressEntry {
+  attempted?: unknown;
+  correct?: unknown;
+}
+
+export interface LegacyMigrationPlan {
+  records: ResponseRecord[];
+  /** Fields present on every migrated record that were reconstructed, not observed. */
+  imputedFields: ImputedField[];
+  stats: {
+    topics: number;
+    questions: number;
+    markedCorrect: number;
+    correctWithoutAttempt: number;
+    legacyHistoryEntries: number;
+  };
+  /** Things the legacy shape cannot support, with the reason, rather than guesses. */
+  skipped: Array<{ what: string; reason: string }>;
+  warnings: string[];
+}
+
+interface LegacyMigrationOptions {
+  storage?: Pick<Storage, 'getItem'>;
+  now?: number;
+  backdateDays?: number;
+}
+
+function readJson(storage: Pick<Storage, 'getItem'>, key: string): unknown {
+  try {
+    const raw = storage.getItem(key);
+    return raw === null ? null : JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function asStringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((v): v is string => typeof v === 'string') : [];
+}
+
+function topicIdOfQid(qid: string, fallback: string): string {
+  const cut = qid.lastIndexOf('_');
+  return cut > 0 ? qid.slice(0, cut) : fallback;
+}
+
+/**
+ * Pure half of the migration: reads the legacy localStorage shape and builds
+ * response records, without touching IndexedDB.
+ *
+ * WHAT IS REAL AND WHAT IS NOT
+ * ----------------------------
+ * Real: the question id, the chapter id, and the fact that the question was
+ * attempted. `correct` is as recorded — but see the warning below.
+ *
+ * Imputed on every record (listed in `record.imputed`):
+ *   - `ts`          — never stored; backdated by one mastery half-life.
+ *   - `chosenIndex` — never stored; emitted as `null`, never a guessed option.
+ *   - `latencyMs`   — never stored; emitted as 0, which the scheduler must not
+ *                     read as "answered instantly" (see `ratingFromOutcome`,
+ *                     which ignores latency on imputed records).
+ *   - `mode`        — the legacy store overloaded `topicId` across chapter
+ *                     practice, mock tests and pseudo-ids like
+ *                     `quick-practice`, so the real mode is unrecoverable;
+ *                     emitted as `'topic'`.
+ *   - `flaggedGuess`— never stored; emitted as `false`.
+ *
+ * Not migrated at all: `eng_history` rows (`{topicId, topicName, score, total,
+ * date}`). They carry a score but no question ids, so turning them into
+ * response records would mean inventing which questions were answered. They are
+ * counted and reported, never fabricated.
+ *
+ * Known distortion: because `recordAttempt` only ever pushed ids, a question
+ * answered wrong then right appears only as correct. Migrated accuracy is
+ * therefore an upper bound, and the project owner has accepted a clean reset as
+ * the alternative. This is a convenience, not a correctness guarantee.
+ */
+export function planLegacyMigration(options: LegacyMigrationOptions = {}): LegacyMigrationPlan {
+  const storage = options.storage ?? (typeof localStorage === 'undefined' ? undefined : localStorage);
+  const now = options.now ?? Date.now();
+  const backdateDays = options.backdateDays ?? LEGACY_TS_BACKDATE_DAYS;
+  const imputedTs = now - backdateDays * 24 * 60 * 60 * 1000;
+  const imputedFields: ImputedField[] = ['ts', 'chosenIndex', 'latencyMs', 'mode', 'flaggedGuess'];
+
+  const empty: LegacyMigrationPlan = {
+    records: [],
+    imputedFields,
+    stats: { topics: 0, questions: 0, markedCorrect: 0, correctWithoutAttempt: 0, legacyHistoryEntries: 0 },
+    skipped: [],
+    warnings: [],
+  };
+  if (!storage) {
+    return { ...empty, warnings: ['no localStorage in this context; nothing to migrate'] };
+  }
+
+  const progressRaw = readJson(storage, LEGACY_PROGRESS_KEY);
+  const historyRaw = readJson(storage, LEGACY_HISTORY_KEY);
+  const legacyHistoryEntries = Array.isArray(historyRaw) ? historyRaw.length : 0;
+
+  const warnings: string[] = [];
+  const skipped: Array<{ what: string; reason: string }> = [];
+  if (legacyHistoryEntries > 0) {
+    skipped.push({
+      what: `${legacyHistoryEntries} eng_history row(s)`,
+      reason:
+        'a history row stores only score/total/date and no question ids, so per-response records cannot be derived without inventing which questions were answered',
+    });
+  }
+
+  if (progressRaw === null || typeof progressRaw !== 'object' || Array.isArray(progressRaw)) {
+    return {
+      ...empty,
+      stats: { ...empty.stats, legacyHistoryEntries },
+      skipped,
+      warnings: [...warnings, 'eng_progress was missing or unreadable'],
+    };
+  }
+
+  const records: ResponseRecord[] = [];
+  let markedCorrect = 0;
+  let correctWithoutAttempt = 0;
+  let topics = 0;
+
+  for (const [legacyTopicId, rawEntry] of Object.entries(progressRaw as Record<string, LegacyProgressEntry>)) {
+    if (!rawEntry || typeof rawEntry !== 'object') continue;
+    topics += 1;
+    const attempted = asStringArray(rawEntry.attempted);
+    const correct = asStringArray(rawEntry.correct);
+    const correctSet = new Set(correct);
+    const seen = new Set(attempted);
+    for (const qid of correct) {
+      if (!seen.has(qid)) {
+        correctWithoutAttempt += 1;
+        seen.add(qid);
+      }
+    }
+
+    for (const qid of seen) {
+      const isCorrect = correctSet.has(qid);
+      if (isCorrect) markedCorrect += 1;
+      records.push(
+        createResponse(
+          {
+            // Deterministic rid: re-running the migration appends nothing new,
+            // because `add` reports the duplicate and `skipDuplicates` absorbs it.
+            rid: `legacy:${legacyTopicId}:${qid}`,
+            qid,
+            // The legacy key was overloaded (chapter id / mock id / pseudo-id),
+            // so prefer the chapter encoded in the question id itself.
+            topicId: topicIdOfQid(qid, legacyTopicId),
+            mode: 'topic',
+            chosenIndex: null,
+            correct: isCorrect,
+            latencyMs: 0,
+            flaggedGuess: false,
+            ts: imputedTs,
+            imputed: imputedFields,
+            source: 'legacy-migration',
+          },
+          now,
+        ),
+      );
+    }
+  }
+
+  if (records.length > 0) {
+    warnings.push(
+      'legacy `correct` is monotonic: a question answered wrong then right was stored as correct only, so migrated accuracy is an upper bound',
+    );
+    warnings.push(
+      `every migrated record has imputed ${imputedFields.join(', ')}; chosenIndex is null and timestamps are backdated ${backdateDays} days`,
+    );
+  }
+  if (correctWithoutAttempt > 0) {
+    warnings.push(
+      `${correctWithoutAttempt} question(s) appeared in \`correct\` but not in \`attempted\`; counted as attempted`,
+    );
+  }
+
+  return {
+    records,
+    imputedFields,
+    stats: { topics, questions: records.length, markedCorrect, correctWithoutAttempt, legacyHistoryEntries },
+    skipped,
+    warnings,
+  };
+}
+
+export interface LegacyMigrationResult extends LegacyMigrationPlan {
+  appended: number;
+  duplicates: number;
+}
+
+/**
+ * Converts `eng_progress` into response-log records and appends them.
+ *
+ * Idempotent: rids are deterministic, so a second run appends nothing. Best
+ * effort by design — see {@link planLegacyMigration} for exactly which fields
+ * are imputed and what is deliberately not migrated.
+ */
+export async function migrateLegacyProgress(
+  options: LegacyMigrationOptions & { store?: ResponseLogStore } = {},
+): Promise<LegacyMigrationResult> {
+  const plan = planLegacyMigration(options);
+  if (plan.records.length === 0) return { ...plan, appended: 0, duplicates: 0 };
+  const store = options.store ?? getResponseLogStore();
+  const { appended, duplicates } = await store.appendMany(plan.records, { skipDuplicates: true });
+  return { ...plan, appended, duplicates };
+}
diff --git a/frontend/src/services/scheduler.ts b/frontend/src/services/scheduler.ts
new file mode 100644
index 0000000..2a1ceae
--- /dev/null
+++ b/frontend/src/services/scheduler.ts
@@ -0,0 +1,658 @@
+/**
+ * scheduler — spaced repetition, next-question selection, and exam readiness.
+ *
+ * WHY SM-2 IN AN FSRS-SHAPED BOX
+ * ------------------------------
+ * FSRS is the better algorithm: it models memory stability and retrievability
+ * directly and fits its parameters to the learner's own review history. But a
+ * real FSRS needs either the `ts-fsrs` package or a careful reimplementation of
+ * a 17-parameter optimiser, and this phase is not adding a dependency.
+ *
+ * So the *scheduling policy* here is SM-2, while the *persisted state* is
+ * FSRS-shaped: `{stability, difficulty, elapsedDays, scheduledDays, reps,
+ * lapses, state, due, lastReview}`. Dropping in a real FSRS later is then a code
+ * change with no data migration — the fields already exist and already carry the
+ * right meanings:
+ *
+ *   - `stability`  = the current interval in days. Under SM-2 this is the
+ *     scheduled gap; under FSRS it is the memory-stability parameter. They are
+ *     the same quantity measured differently, and SM-2's value is a usable
+ *     starting point for FSRS's.
+ *   - `difficulty` = 1 (easiest) … 10 (hardest), FSRS's scale. SM-2's ease
+ *     factor is derived from it on the fly (see {@link difficultyToEase}) rather
+ *     than stored, so there is no SM-2-only field to migrate away.
+ *
+ * NO SELF-GRADING
+ * ---------------
+ * FSRS and SM-2 both expect the learner to rate their own recall. Asking an
+ * exam candidate "how well did you know that?" after every MCQ is friction they
+ * will not pay, and self-ratings are unreliable anyway. {@link ratingFromOutcome}
+ * derives the rating from what the quiz already measured: correctness, latency
+ * and the guess flag. It never returns `Easy` — see that function for why.
+ */
+
+import { eloForSuccessProbability, expectedCorrect } from './ability';
+import { SHRINKAGE_K } from './mastery';
+import type { MasteryEstimate } from './mastery';
+import type { ImputedField } from './responseLog';
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+const MS_PER_MINUTE = 60 * 1000;
+
+// ─── Card state ───────────────────────────────────────────────────────────────
+
+/** FSRS rating scale. */
+export const Rating = {
+  Again: 1,
+  Hard: 2,
+  Good: 3,
+  Easy: 4,
+} as const;
+
+export type Rating = (typeof Rating)[keyof typeof Rating];
+
+/** FSRS card states: 0 New, 1 Learning, 2 Review, 3 Relearning. */
+export const CardState = {
+  New: 0,
+  Learning: 1,
+  Review: 2,
+  Relearning: 3,
+} as const;
+
+export type CardState = (typeof CardState)[keyof typeof CardState];
+
+export interface Card {
+  qid: string;
+  /** Current interval in days. FSRS will reinterpret this as memory stability. */
+  stability: number;
+  /** 1 (easiest) … 10 (hardest), FSRS's scale. */
+  difficulty: number;
+  /** Days between the previous review and the one just graded. */
+  elapsedDays: number;
+  /** Days until the next review, as set by the last grading. */
+  scheduledDays: number;
+  reps: number;
+  lapses: number;
+  state: CardState;
+  /** Epoch ms when the card next becomes due. */
+  due: number;
+  /** Epoch ms of the last grading, or null for a new card. */
+  lastReview: number | null;
+}
+
+/** FSRS's default starting difficulty: mid-scale, i.e. "we do not know yet". */
+export const INITIAL_DIFFICULTY = 5;
+
+export const MIN_EASE = 1.3;
+export const MAX_EASE = 2.5;
+
+/** Interval granted when a card first graduates, by rating. */
+export const GRADUATE_HARD_DAYS = 1;
+export const GRADUATE_GOOD_DAYS = 2;
+
+/** Re-show a lapsed card after this long, inside the same session. */
+export const RELEARN_STEP_MINUTES = 10;
+
+/** `Hard` on a mature card grows the interval only slightly. */
+export const HARD_INTERVAL_MULTIPLIER = 1.2;
+/** `Easy` bonus, kept for a future FSRS/manual-grade path. */
+export const EASY_INTERVAL_BONUS = 1.3;
+
+export const MAX_INTERVAL_DAYS = 365;
+
+/** Six lapses is Anki's long-standing default, and it holds up: a card that has
+ *  been forgotten six times is not a scheduling problem, it is a comprehension
+ *  problem, and re-showing it on a curve wastes the learner's time. */
+export const LEECH_LAPSE_THRESHOLD = 6;
+
+export function newCard(qid: string, now: number = Date.now()): Card {
+  return {
+    qid,
+    stability: 0,
+    difficulty: INITIAL_DIFFICULTY,
+    elapsedDays: 0,
+    scheduledDays: 0,
+    reps: 0,
+    lapses: 0,
+    state: CardState.New,
+    due: now,
+    lastReview: null,
+  };
+}
+
+/** difficulty 1 → ease 2.5, difficulty 10 → ease 1.3. */
+export function difficultyToEase(difficulty: number): number {
+  const clamped = Math.min(10, Math.max(1, difficulty));
+  return MAX_EASE - ((clamped - 1) * (MAX_EASE - MIN_EASE)) / 9;
+}
+
+export function easeToDifficulty(ease: number): number {
+  const clamped = Math.min(MAX_EASE, Math.max(MIN_EASE, ease));
+  return 1 + ((MAX_EASE - clamped) * 9) / (MAX_EASE - MIN_EASE);
+}
+
+/** SM-2's quality scale, from the FSRS rating. */
+function qualityOf(rating: Rating): number {
+  return rating + 1; // Again→2, Hard→3, Good→4, Easy→5
+}
+
+/** SM-2's ease-factor delta. `Good` is neutral by construction. */
+function easeDelta(rating: Rating): number {
+  const q = qualityOf(rating);
+  return 0.1 - (5 - q) * (0.08 + (5 - q) * 0.02);
+}
+
+// ─── Outcome → rating ─────────────────────────────────────────────────────────
+
+export interface LatencyThresholds {
+  /**
+   * Answers faster than this are treated as guesses rather than recall: a
+   * correct answer under it is either prior memorisation of the *answer
+   * position* or luck, and neither deserves a long interval.
+   *
+   * This is only a fallback. `Outcome.flaggedGuess` is the canonical signal and
+   * is computed per session by `features/quiz/guess.ts`, whose threshold is
+   * `max(4000ms, 0.35 x session median)` — adaptive, and therefore better than
+   * any fixed number. The default here matches that module's absolute floor so
+   * the two layers cannot disagree on an unflagged record.
+   */
+  guessMs: number;
+  /** Correct but slower than this means effortful reconstruction, not recall. */
+  slowMs: number;
+}
+
+export const DEFAULT_LATENCY_THRESHOLDS: LatencyThresholds = {
+  guessMs: 4000,
+  slowMs: 30000,
+};
+
+export interface Outcome {
+  correct: boolean;
+  latencyMs: number;
+  flaggedGuess?: boolean;
+  /**
+   * Fields the record could not observe. When `latencyMs` is imputed (every
+   * legacy-migrated record has it as a fabricated 0) the latency bands are
+   * skipped, because 0 ms would otherwise read as an impossible instant guess.
+   */
+  imputed?: readonly ImputedField[];
+}
+
+/**
+ * Maps a quiz outcome to a scheduling rating without asking the learner to
+ * grade themselves.
+ *
+ *   wrong                        → Again
+ *   correct, flagged as a guess  → Hard
+ *   correct, under `guessMs`     → Hard
+ *   correct, over `slowMs`       → Hard
+ *   correct, in between          → Good
+ *
+ * `Easy` is deliberately unreachable. On a four-option MCQ, "fast and correct"
+ * carries a 25% guess floor, so promoting it to `Easy` (a 1.3x interval bonus
+ * on top of the ease factor) systematically over-schedules lucky guesses. A
+ * learner can only earn long intervals by being right repeatedly over time,
+ * which is the evidence that actually distinguishes recall from luck.
+ */
+export function ratingFromOutcome(
+  outcome: Outcome,
+  thresholds: LatencyThresholds = DEFAULT_LATENCY_THRESHOLDS,
+): Rating {
+  if (!outcome.correct) return Rating.Again;
+  if (outcome.flaggedGuess === true) return Rating.Hard;
+  const latencyUnknown = outcome.imputed?.includes('latencyMs') ?? false;
+  if (latencyUnknown) return Rating.Good;
+  if (outcome.latencyMs < thresholds.guessMs) return Rating.Hard;
+  if (outcome.latencyMs > thresholds.slowMs) return Rating.Hard;
+  return Rating.Good;
+}
+
+// ─── Scheduling ───────────────────────────────────────────────────────────────
+
+export interface ScheduleOptions {
+  maxIntervalDays?: number;
+  relearnStepMinutes?: number;
+}
+
+/**
+ * Grades a card and returns the next card state. Pure: the input card is not
+ * mutated, so the full schedule can be rebuilt by folding the response log.
+ */
+export function scheduleCard(
+  card: Card,
+  rating: Rating,
+  now: number = Date.now(),
+  options: ScheduleOptions = {},
+): Card {
+  const maxIntervalDays = options.maxIntervalDays ?? MAX_INTERVAL_DAYS;
+  const relearnStepMinutes = options.relearnStepMinutes ?? RELEARN_STEP_MINUTES;
+
+  const elapsedDays = card.lastReview === null ? 0 : Math.max(0, (now - card.lastReview) / MS_PER_DAY);
+  const ease = Math.min(MAX_EASE, Math.max(MIN_EASE, difficultyToEase(card.difficulty) + easeDelta(rating)));
+  const difficulty = easeToDifficulty(ease);
+
+  if (rating === Rating.Again) {
+    return {
+      ...card,
+      difficulty,
+      elapsedDays,
+      scheduledDays: 0,
+      stability: 0,
+      reps: card.reps + 1,
+      lapses: card.lapses + 1,
+      state: CardState.Relearning,
+      due: now + relearnStepMinutes * MS_PER_MINUTE,
+      lastReview: now,
+    };
+  }
+
+  const isGraduating =
+    card.state === CardState.New || card.state === CardState.Learning || card.state === CardState.Relearning;
+
+  let scheduledDays: number;
+  if (isGraduating) {
+    scheduledDays = rating === Rating.Hard ? GRADUATE_HARD_DAYS : GRADUATE_GOOD_DAYS;
+  } else if (rating === Rating.Hard) {
+    scheduledDays = Math.round(Math.max(1, card.stability) * HARD_INTERVAL_MULTIPLIER);
+  } else if (rating === Rating.Easy) {
+    scheduledDays = Math.round(Math.max(1, card.stability) * ease * EASY_INTERVAL_BONUS);
+  } else {
+    scheduledDays = Math.round(Math.max(1, card.stability) * ease);
+  }
+  scheduledDays = Math.min(maxIntervalDays, Math.max(1, scheduledDays));
+
+  return {
+    ...card,
+    difficulty,
+    elapsedDays,
+    scheduledDays,
+    stability: scheduledDays,
+    reps: card.reps + 1,
+    lapses: card.lapses,
+    state: CardState.Review,
+    due: now + scheduledDays * MS_PER_DAY,
+    lastReview: now,
+  };
+}
+
+/** Convenience: grade straight from a quiz outcome. */
+export function gradeCard(
+  card: Card,
+  outcome: Outcome,
+  now: number = Date.now(),
+  options: ScheduleOptions & { thresholds?: LatencyThresholds } = {},
+): { card: Card; rating: Rating } {
+  const rating = ratingFromOutcome(outcome, options.thresholds ?? DEFAULT_LATENCY_THRESHOLDS);
+  return { card: scheduleCard(card, rating, now, options), rating };
+}
+
+export function isLeech(card: Card, threshold: number = LEECH_LAPSE_THRESHOLD): boolean {
+  return card.lapses >= threshold;
+}
+
+export interface DueQueue {
+  /** Due now, most overdue first. */
+  due: Card[];
+  /**
+   * Due, but repeatedly forgotten. Separated rather than dropped: the product
+   * should offer to reword, suspend or re-teach these, not keep drilling them.
+   */
+  leeches: Card[];
+  /** Not due yet; the caller tops the session up from new material instead. */
+  upcoming: Card[];
+}
+
+export interface DueQueueOptions {
+  now?: number;
+  limit?: number;
+  leechThreshold?: number;
+}
+
+export function selectDueQueue(cards: Card[], options: DueQueueOptions = {}): DueQueue {
+  const now = options.now ?? Date.now();
+  const leechThreshold = options.leechThreshold ?? LEECH_LAPSE_THRESHOLD;
+  const due: Card[] = [];
+  const leeches: Card[] = [];
+  const upcoming: Card[] = [];
+
+  for (const card of cards) {
+    if (card.due > now) upcoming.push(card);
+    else if (isLeech(card, leechThreshold)) leeches.push(card);
+    else due.push(card);
+  }
+
+  const byDue = (a: Card, b: Card) => a.due - b.due;
+  due.sort(byDue);
+  leeches.sort(byDue);
+  upcoming.sort(byDue);
+
+  return {
+    due: options.limit === undefined ? due : due.slice(0, Math.max(0, options.limit)),
+    leeches,
+    upcoming,
+  };
+}
+
+// ─── Next-question selection ──────────────────────────────────────────────────
+
+/**
+ * The success rate practice aims for.
+ *
+ * 80% is the standard desirable-difficulty target: high enough that the session
+ * is not demoralising, low enough that most items carry information. Note what
+ * this implies for the Elo target. With
+ * `expected = 1 / (1 + 10^((itemElo - theta) / 400))`, an item rated *above*
+ * the learner is the HARDER one, so an 80%-success item sits at
+ * `theta + 400*log10(0.25) ≈ theta - 240`.
+ *
+ * The phase brief specified `targetElo = chapterTheta + 240`. Under the brief's
+ * own `expected` formula that is a ~20% success rate, i.e. the learner gets four
+ * out of five wrong — the opposite of the stated intent. The magnitude of 240
+ * is kept and the sign is taken from the stated 80% target, via
+ * {@link eloForSuccessProbability}, so the constant and the intent agree. A
+ * caller that really wants the other direction can pass
+ * `targetSuccessProbability: 0.2`.
+ */
+export const TARGET_SUCCESS_PROBABILITY = 0.8;
+
+/** Never more than this many consecutive items from one sub-chapter. */
+export const MAX_CONSECUTIVE_SAME_SUBCHAPTER = 3;
+
+export interface QuestionCandidate {
+  qid: string;
+  topicId: string;
+  /** Sub-chapter id, or the chapter id when the bank has no sub-chapters. */
+  subchapter: string;
+  /** Current item Elo from the ability snapshot. */
+  itemElo: number;
+  /** Due timestamp when this item already has a card; omit for unseen items. */
+  due?: number | null;
+}
+
+export interface SelectQuestionsOptions {
+  /** Ability for the chapter being practised, from `chapterTheta()`. */
+  chapterTheta: number;
+  count: number;
+  now?: number;
+  targetSuccessProbability?: number;
+  maxConsecutiveSameSubchapter?: number;
+  /**
+   * Elo-points of preference given to an item that is due for review. 120
+   * points is roughly half the 80%-target offset, so a due item wins against a
+   * better-matched new item only when the difficulty mismatch is modest.
+   */
+  dueBonusElo?: number;
+}
+
+export interface SelectedQuestion extends QuestionCandidate {
+  /** Predicted success probability at selection time. */
+  predictedSuccess: number;
+  /** Distance from the target difficulty, in Elo points, after the due bonus. */
+  cost: number;
+  wasDue: boolean;
+}
+
+/**
+ * Picks the next `count` questions.
+ *
+ * Two jobs at once:
+ *   1. Difficulty targeting — prefer items whose Elo is closest to the
+ *      80%-success point for this learner in this chapter.
+ *   2. Interleaving — never more than `maxConsecutiveSameSubchapter`
+ *      consecutive items from the same sub-chapter. Blocked practice (all of
+ *      5.1, then all of 5.2) produces better in-session performance and worse
+ *      retention; interleaving is one of the few study-design effects that
+ *      replicates reliably.
+ *
+ * The constraint is hard. If the only remaining candidates would violate it,
+ * selection stops short of `count` rather than emitting a run of four — a
+ * shorter honest session beats a longer one that quietly abandons the design.
+ */
+export function selectNextQuestions(
+  candidates: QuestionCandidate[],
+  options: SelectQuestionsOptions,
+): SelectedQuestion[] {
+  const now = options.now ?? Date.now();
+  const maxRun = options.maxConsecutiveSameSubchapter ?? MAX_CONSECUTIVE_SAME_SUBCHAPTER;
+  const targetP = options.targetSuccessProbability ?? TARGET_SUCCESS_PROBABILITY;
+  const dueBonus = options.dueBonusElo ?? 120;
+  const targetElo = eloForSuccessProbability(options.chapterTheta, targetP);
+
+  const scored = candidates.map((candidate) => {
+    const wasDue = candidate.due !== undefined && candidate.due !== null && candidate.due <= now;
+    const cost = Math.abs(candidate.itemElo - targetElo) - (wasDue ? dueBonus : 0);
+    return {
+      ...candidate,
+      predictedSuccess: expectedCorrect(options.chapterTheta, candidate.itemElo),
+      cost,
+      wasDue,
+    };
+  });
+
+  // Stable ordering: cost, then qid, so selection is deterministic and testable.
+  scored.sort((a, b) => (a.cost === b.cost ? (a.qid < b.qid ? -1 : 1) : a.cost - b.cost));
+
+  const picked: SelectedQuestion[] = [];
+  const used = new Set<string>();
+  let runSubchapter: string | null = null;
+  let runLength = 0;
+
+  while (picked.length < options.count) {
+    let chosen: SelectedQuestion | null = null;
+    for (const candidate of scored) {
+      if (used.has(candidate.qid)) continue;
+      if (runSubchapter === candidate.subchapter && runLength >= maxRun) continue;
+      chosen = candidate;
+      break;
+    }
+    if (!chosen) break;
+
+    used.add(chosen.qid);
+    picked.push(chosen);
+    if (runSubchapter === chosen.subchapter) runLength += 1;
+    else {
+      runSubchapter = chosen.subchapter;
+      runLength = 1;
+    }
+  }
+
+  return picked;
+}
+
+// ─── Exam readiness ───────────────────────────────────────────────────────────
+
+/**
+ * Probability assigned to a sub-chapter the learner has never been assessed on.
+ *
+ * 0.25 is the four-option guess floor. It is the only defensible number: the
+ * learner may well know the material, but nothing in the log says so, and the
+ * alternative (borrowing the chapter mean) would let a readiness score rise on
+ * the strength of questions never answered. The wide variance assigned below is
+ * what carries the "we do not know" part.
+ */
+export const UNASSESSED_PROBABILITY = 0.25;
+
+/** NEC-style default. Override per exam; this is an assumption, not a fact. */
+export const DEFAULT_PASS_MARK = 0.4;
+
+export const Z_FOR_LEVEL: Record<string, number> = {
+  '0.5': 0.674,
+  '0.8': 1.282,
+  '0.9': 1.645,
+  '0.95': 1.96,
+};
+
+export interface ReadinessSection {
+  unitId: string;
+  /** Blueprint marks this unit is worth in the real exam. */
+  marks: number;
+  estimate: MasteryEstimate;
+}
+
+export interface ReadinessOptions {
+  passMark?: number;
+  unassessedProbability?: number;
+  intervalLevel?: 0.5 | 0.8 | 0.9 | 0.95;
+  /** Shrinkage pseudo-count used when turning confidence into variance. */
+  k?: number;
+}
+
+export interface ExamReadiness {
+  /** Expected fraction of total marks, AFTER the coverage cap. */
+  expectedScore: number;
+  /** What the model said before the cap; shown so the cap is auditable. */
+  uncappedScore: number;
+  /** Variance of `expectedScore` as a fraction of total marks. */
+  variance: number;
+  standardDeviation: number;
+  /**
+   * Mandatory companion to `expectedScore`. There is no code path that produces
+   * a point estimate without one, so a UI cannot render a bare percentage
+   * without deliberately discarding this field.
+   */
+  interval: { lower: number; upper: number; level: number };
+  probabilityOfPassing: number;
+  cappedBy: 'coverage' | null;
+  /** The cap that was applied: `0.35 + 0.65 * overallCoverage`. */
+  cap: number;
+  overallCoverage: number;
+  totalMarks: number;
+  assessedMarks: number;
+  notAssessedMarks: number;
+  passMark: number;
+}
+
+/** Normal CDF via Abramowitz & Stegun 7.1.26; max error ~1.5e-7. */
+export function normalCdf(z: number): number {
+  const sign = z < 0 ? -1 : 1;
+  const x = Math.abs(z) / Math.SQRT2;
+  const t = 1 / (1 + 0.3275911 * x);
+  const y =
+    1 -
+    ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) *
+      t *
+      Math.exp(-x * x);
+  return 0.5 * (1 + sign * y);
+}
+
+/**
+ * Turns per-sub-chapter mastery plus blueprint marks into a readiness estimate.
+ *
+ * TWO HONESTY CONSTRAINTS, both mandatory:
+ *
+ *   1. COVERAGE CAP. `expectedScore` is capped at `0.35 + 0.65 * overallCoverage`.
+ *      A learner who has seen 4% of the bank gets a ceiling of ~0.38 no matter
+ *      how well they did on those questions, because a sample that small says
+ *      almost nothing about the other 96%. Without the cap, three perfect
+ *      sessions produce "90% ready" and the learner stops revising.
+ *   2. INTERVAL ALWAYS RETURNED. The point estimate is never returned alone —
+ *      see {@link ExamReadiness.interval}.
+ *
+ * `sections` must be the FULL blueprint, including units never practised. If
+ * the caller passes only the units with data, `overallCoverage` is computed over
+ * the wrong denominator, the cap never binds, and constraint 1 silently stops
+ * working. Use `withUnassessedUnits()` from mastery.ts to build the full list.
+ *
+ * The model is a normal approximation to the sum of per-section mark totals.
+ * Each section contributes two sources of variance:
+ *   - sampling:  `marks * p * (1 - p)` — exam-day luck on the questions drawn;
+ *   - estimation: `marks^2 * p * (1 - p) / (nEff + k)` — our uncertainty about
+ *     `p` itself, which is what makes a thin sample widen the interval.
+ */
+export function examReadiness(sections: ReadinessSection[], options: ReadinessOptions = {}): ExamReadiness {
+  const passMark = options.passMark ?? DEFAULT_PASS_MARK;
+  const unassessedP = options.unassessedProbability ?? UNASSESSED_PROBABILITY;
+  const level = options.intervalLevel ?? 0.9;
+  const k = options.k ?? SHRINKAGE_K;
+  const z = Z_FOR_LEVEL[String(level)] ?? 1.645;
+
+  const totalMarks = sections.reduce((sum, section) => sum + Math.max(0, section.marks), 0);
+  if (totalMarks <= 0) {
+    return {
+      expectedScore: 0,
+      uncappedScore: 0,
+      variance: 0,
+      standardDeviation: 0,
+      interval: { lower: 0, upper: 0, level },
+      probabilityOfPassing: 0,
+      cappedBy: null,
+      cap: 0.35,
+      overallCoverage: 0,
+      totalMarks: 0,
+      assessedMarks: 0,
+      notAssessedMarks: 0,
+      passMark,
+    };
+  }
+
+  let expectedMarks = 0;
+  let varianceMarks = 0;
+  let coverageMarks = 0;
+  let assessedMarks = 0;
+  let notAssessedMarks = 0;
+
+  for (const section of sections) {
+    const marks = Math.max(0, section.marks);
+    if (marks === 0) continue;
+    const estimate = section.estimate;
+    const assessed = estimate.state === 'assessed';
+    const p = assessed ? Math.min(1, Math.max(0, estimate.mastery)) : unassessedP;
+    const nEff = assessed ? estimate.nEff : 0;
+
+    if (assessed) assessedMarks += marks;
+    else notAssessedMarks += marks;
+
+    expectedMarks += marks * p;
+    const bernoulli = p * (1 - p);
+    varianceMarks += marks * bernoulli + (marks * marks * bernoulli) / (nEff + k);
+    coverageMarks += marks * estimate.coverage;
+  }
+
+  const overallCoverage = Math.min(1, coverageMarks / totalMarks);
+  const uncappedScore = expectedMarks / totalMarks;
+  const cap = 0.35 + 0.65 * overallCoverage;
+  const expectedScore = Math.min(uncappedScore, cap);
+  const cappedBy = uncappedScore > cap ? 'coverage' : null;
+
+  const variance = varianceMarks / (totalMarks * totalMarks);
+  const standardDeviation = Math.sqrt(variance);
+
+  const probabilityOfPassing =
+    standardDeviation <= 0
+      ? expectedScore >= passMark
+        ? 1
+        : 0
+      : 1 - normalCdf((passMark - expectedScore) / standardDeviation);
+
+  return {
+    expectedScore,
+    uncappedScore,
+    variance,
+    standardDeviation,
+    interval: {
+      lower: Math.max(0, expectedScore - z * standardDeviation),
+      upper: Math.min(1, expectedScore + z * standardDeviation),
+      level,
+    },
+    probabilityOfPassing,
+    cappedBy,
+    cap,
+    overallCoverage,
+    totalMarks,
+    assessedMarks,
+    notAssessedMarks,
+    passMark,
+  };
+}
+
+/**
+ * The only rendering of a readiness figure this module endorses: a range, plus
+ * the reason when the coverage cap is doing the talking.
+ */
+export function formatReadiness(readiness: ExamReadiness): string {
+  const pct = (value: number) => `${Math.round(value * 100)}%`;
+  const range = `${pct(readiness.expectedScore)} (${pct(readiness.interval.lower)}–${pct(readiness.interval.upper)})`;
+  return readiness.cappedBy === 'coverage'
+    ? `${range}, capped — you have covered ${pct(readiness.overallCoverage)} of the syllabus`
+    : range;
+}
diff --git a/frontend/src/services/subchapterClassifier.ts b/frontend/src/services/subchapterClassifier.ts
new file mode 100644
index 0000000..a605211
--- /dev/null
+++ b/frontend/src/services/subchapterClassifier.ts
@@ -0,0 +1,310 @@
+/**
+ * Deterministic, offline sub-chapter classification.
+ *
+ * Given a question and the chapter it is already known to belong to, decide
+ * which of that chapter's six sub-chapters it tests — or decline.
+ *
+ * DESIGN
+ * ------
+ * The chapter is a fact (it comes from which file the question shipped in), so
+ * this is a 1-of-6 decision, never 1-of-60. Within a chapter the six
+ * sub-chapters are deliberately disjoint topics, so discriminating vocabulary
+ * is enough; see `data/subchapterTerms.ts` for the term lists and why they are
+ * weighted.
+ *
+ * Scoring is a sum over DISTINCT matched terms — a stem that says "pointer"
+ * six times scores once. The stem carries full weight and the options carry
+ * half, because distractors are routinely drawn from neighbouring topics: a
+ * question about `malloc` may well list `fopen` as a wrong answer, and letting
+ * options count fully would pull it towards the wrong sub-chapter.
+ *
+ * REFUSAL IS THE POINT
+ * --------------------
+ * Two guards must both pass before a label is returned:
+ *
+ *   - `MIN_SCORE` — the winner needs real evidence, not one weak term.
+ *   - `MIN_MARGIN` — the winner must beat the runner-up by a clear margin.
+ *
+ * A question matching both `tcp` and `subnet` is genuinely ambiguous between
+ * 5.3 and 5.4 on vocabulary alone, and the honest answer is "chapter 5". That
+ * is why `classify` returns `null` rather than a low-confidence guess:
+ * callers cannot accidentally render a coin flip as a syllabus reference.
+ *
+ * `confidence` is reported in basis points so it can be stored in D1's INTEGER
+ * columns without floats, matching `generator_confidence_bp` on `explanations`.
+ */
+
+import {
+  getChapterByBookChapterId,
+  getChapterByCode,
+  type SubchapterCode,
+} from '../data/syllabus';
+import { SUBCHAPTER_TERMS } from '../data/subchapterTerms';
+
+/**
+ * Identifies the term lists AND the thresholds that produced a label.
+ *
+ * Stored in `questions.subchapter_classifier_version`, so a change here makes
+ * every stale heuristic label findable with one query. Bump it whenever a term
+ * list or a threshold changes in a way that could move a decision — which is
+ * any change at all to this file or to `data/subchapterTerms.ts`.
+ */
+export const CLASSIFIER_VERSION = 'subchapter-terms-v1';
+
+/** Weight of one distinct matched `strong` term. */
+const STRONG_WEIGHT = 3;
+/** Weight of one distinct matched `weak` term. */
+const WEAK_WEIGHT = 1;
+/** Options count for half, since distractors borrow neighbouring vocabulary. */
+const OPTION_WEIGHT = 0.5;
+/**
+ * Minimum winning score. 3 = one strong term, or three weak ones in the stem.
+ * Below this the match is noise.
+ */
+const MIN_SCORE = 3;
+/**
+ * The winner must exceed the runner-up by this much. Set to 2 so that one
+ * extra weak term is not enough to break a tie between two sub-chapters that
+ * both matched a strong term — that case is a genuine ambiguity.
+ */
+const MIN_MARGIN = 2;
+
+export interface SubchapterMatch {
+  readonly code: SubchapterCode;
+  /** Human-facing dotted code, e.g. `'5.4'`. */
+  readonly displayCode: string;
+  readonly title: string;
+  /** Confidence in basis points, 0-10000. */
+  readonly confidenceBp: number;
+  /** The distinct terms that drove the decision, strongest first. */
+  readonly matchedTerms: readonly string[];
+}
+
+/**
+ * The chapter must be identified, by either id. The frontend knows questions
+ * by the `book-chN` file they shipped in; the importer and the Worker know
+ * them by the official NEC chapter code. Pass whichever you have — if both
+ * are given, `chapterCode` wins, being the canonical one.
+ */
+export interface ClassifierInput {
+  /** The `book-chN` id the question shipped under, e.g. `'book-ch5'`. */
+  readonly bookChapterId?: string;
+  /** The official NEC chapter code, e.g. `'ACtE05'`. */
+  readonly chapterCode?: string;
+  readonly question: string;
+  readonly options: readonly string[];
+}
+
+/* ------------------------------------------------------------------ *
+ * Term matching.
+ * ------------------------------------------------------------------ */
+
+const REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/g;
+
+/**
+ * A word-boundary matcher for one term.
+ *
+ * `\b` is only asserted on an end that is actually a word character. Several
+ * terms are not word-bounded — `main()`, `vector<`, `a*`, `i/o` — and wrapping
+ * those in `\b` would either never match or match in the wrong place.
+ *
+ * PLURALS
+ * -------
+ * Every word in a term may carry an optional trailing `s` or `es`, so the term
+ * `requirement elicitation` matches "Requirements elicitation" and `pointer`
+ * matches "pointers". Without this, a `\b` sitting immediately before the `s`
+ * fails, and measuring the bank showed that single detail suppressing a large
+ * share of otherwise clean matches.
+ *
+ * This is not stemming. It only ever WIDENS a term — nothing is reduced to a
+ * root — so `routing` can never collapse into `route`, which is the distinction
+ * the term lists depend on.
+ *
+ * SEPARATORS
+ * ----------
+ * Words are split on any run of whitespace or hyphens and rejoined as
+ * `[\s-]+`, so one term covers every way the bank writes a compound: `open
+ * loop` matches "open-loop", `non-functional requirement` matches "non
+ * functional requirements", and a line break between words does not break the
+ * match. Writing both spellings of every compound by hand was the alternative,
+ * and the bank is inconsistent enough that it would have been missed.
+ */
+function termPattern(term: string): RegExp {
+  const words = term.split(/[\s-]+/).map(word => word.replace(REGEX_SPECIALS, '\\$&'));
+  const body = words
+    // An optional plural is only meaningful after a word character.
+    .map(word => (/\w$/.test(word) ? word + '(?:e?s)?' : word))
+    .join('[\\s-]+');
+  const prefix = /^\w/.test(term) ? '\\b' : '';
+  const suffix = /\w$/.test(term) ? '\\b' : '';
+  return new RegExp(prefix + body + suffix, 'i');
+}
+
+/**
+ * Compiled once per term, not once per question. Classifying the whole bank
+ * otherwise rebuilds a few thousand regexes per question.
+ */
+const PATTERN_CACHE = new Map<string, RegExp>();
+
+function patternFor(term: string): RegExp {
+  const cached = PATTERN_CACHE.get(term);
+  if (cached) return cached;
+  const compiled = termPattern(term);
+  PATTERN_CACHE.set(term, compiled);
+  return compiled;
+}
+
+interface Scored {
+  readonly code: SubchapterCode;
+  /** Evidence found in the stem only. */
+  readonly stemScore: number;
+  /** Stem evidence plus option evidence at `OPTION_WEIGHT`. */
+  readonly totalScore: number;
+  readonly matched: readonly string[];
+}
+
+function scoreSubchapter(
+  code: SubchapterCode,
+  stem: string,
+  optionText: string
+): Scored {
+  const terms = SUBCHAPTER_TERMS[code];
+  let stemScore = 0;
+  let optionScore = 0;
+  const matched: string[] = [];
+
+  const tally = (list: readonly string[], weight: number): void => {
+    for (const term of list) {
+      const pattern = patternFor(term);
+      if (pattern.test(stem)) {
+        stemScore += weight;
+        matched.push(term);
+      } else if (pattern.test(optionText)) {
+        optionScore += weight * OPTION_WEIGHT;
+        matched.push(term);
+      }
+    }
+  };
+
+  // Strong terms first, so `matched` reads strongest-first for the caller.
+  tally(terms.strong, STRONG_WEIGHT);
+  tally(terms.weak, WEAK_WEIGHT);
+
+  return { code, stemScore, totalScore: stemScore + optionScore, matched };
+}
+
+/**
+ * Apply the two guards to one ranking and return the winner, or null.
+ *
+ * Shared by both passes in `classifySubchapter` so the thresholds cannot drift
+ * apart between them.
+ */
+function decide(
+  ranked: readonly Scored[],
+  scoreOf: (s: Scored) => number
+): { winner: Scored; runnerUpScore: number } | null {
+  const winner = ranked[0];
+  if (!winner) return null;
+  const top = scoreOf(winner);
+  if (top < MIN_SCORE) return null;
+  const runnerUpScore = ranked[1] ? scoreOf(ranked[1]) : 0;
+  if (top - runnerUpScore < MIN_MARGIN) return null;
+  return { winner, runnerUpScore };
+}
+
+/* ------------------------------------------------------------------ *
+ * Public API.
+ * ------------------------------------------------------------------ */
+
+/**
+ * Classify one question into a sub-chapter of its known chapter.
+ *
+ * Returns `null` when the chapter is unknown, when no sub-chapter clears
+ * `MIN_SCORE`, or when the top two are within `MIN_MARGIN` of each other.
+ * Callers must treat `null` as "chapter only", never as an error.
+ */
+export function classifySubchapter(input: ClassifierInput): SubchapterMatch | null {
+  const chapter = input.chapterCode
+    ? getChapterByCode(input.chapterCode)
+    : input.bookChapterId
+      ? getChapterByBookChapterId(input.bookChapterId)
+      : undefined;
+  if (!chapter) return null;
+
+  const stem = input.question;
+  const optionText = input.options.join(' • ');
+
+  const scored = chapter.subchapters.map(sub =>
+    scoreSubchapter(sub.code, stem, optionText)
+  );
+
+  // Pass 1 — the stem alone. A stem that names its topic outright should not be
+  // overruled by a distractor: "NOT a phase in the project life cycle?" with
+  // "Depreciation" among the wrong answers is a 10.4 question, and letting the
+  // distractor's 10.2 vocabulary close the margin turned a decisive stem into a
+  // refusal. Options can only ever BREAK a tie, never create one.
+  const byStem = [...scored].sort((a, b) => b.stemScore - a.stemScore);
+  const stemCall = decide(byStem, s => s.stemScore);
+  if (stemCall) {
+    return build(chapter.subchapters, stemCall.winner, stemCall.runnerUpScore, s => s.stemScore);
+  }
+
+  // Pass 2 — stem plus options. Reached when the stem is generic ("Which of the
+  // following is NOT...") and the options carry the only topical vocabulary.
+  const byTotal = [...scored].sort((a, b) => b.totalScore - a.totalScore);
+  const totalCall = decide(byTotal, s => s.totalScore);
+  if (totalCall) {
+    return build(
+      chapter.subchapters,
+      totalCall.winner,
+      totalCall.runnerUpScore,
+      s => s.totalScore
+    );
+  }
+
+  return null;
+}
+
+function build(
+  subchapters: readonly { code: SubchapterCode; displayCode: string; title: string }[],
+  winner: Scored,
+  runnerUpScore: number,
+  scoreOf: (s: Scored) => number
+): SubchapterMatch | null {
+  const sub = subchapters.find(s => s.code === winner.code);
+  if (!sub) return null;
+  return {
+    code: sub.code,
+    displayCode: sub.displayCode,
+    title: sub.title,
+    confidenceBp: confidenceBp(scoreOf(winner), runnerUpScore),
+    matchedTerms: winner.matched,
+  };
+}
+
+/**
+ * Map a (score, margin) pair onto 0-10000.
+ *
+ * Deliberately conservative: a question can only reach the top of the range by
+ * matching several strong terms AND leaving the runner-up far behind. The
+ * ceiling is 9000, because no amount of keyword agreement makes a heuristic
+ * certain, and a UI that reads 100% would be lying.
+ */
+export function confidenceBp(topScore: number, runnerUpScore: number): number {
+  // Evidence: saturates at 4 strong-term-equivalents.
+  const evidence = Math.min(topScore / (STRONG_WEIGHT * 4), 1);
+  // Separation: saturates when the winner doubles the runner-up.
+  const separation =
+    topScore <= 0 ? 0 : Math.min((topScore - runnerUpScore) / topScore, 1);
+  const combined = 0.6 * evidence + 0.4 * separation;
+  return Math.round(combined * 9000);
+}
+
+/** Exposed for the coverage report and for tests that assert the thresholds. */
+export const CLASSIFIER_THRESHOLDS = {
+  STRONG_WEIGHT,
+  WEAK_WEIGHT,
+  OPTION_WEIGHT,
+  MIN_SCORE,
+  MIN_MARGIN,
+} as const;
diff --git a/frontend/src/styles/base.css b/frontend/src/styles/base.css
new file mode 100644
index 0000000..3002203
--- /dev/null
+++ b/frontend/src/styles/base.css
@@ -0,0 +1,94 @@
+/* ============================================================================
+   Global base layer — accessibility primitives that must apply everywhere.
+
+   Everything here is deliberately written to WIN the cascade against App.css.
+   App.css is 6,175 unlayered lines loaded AFTER this file, so a plain `:root` or
+   `:focus-visible` rule here would simply lose. The doubled selectors
+   (`:focus-visible:focus-visible`) raise specificity from (0,1,0) to (0,2,0)
+   without adding an `!important`, which is enough to beat App.css's
+   `.search-input:focus { outline: none }` at (0,1,1).
+
+   The doubling is a migration shim, not a style. When App.css is retired the
+   duplicate can be dropped.
+   ========================================================================== */
+
+/* ----------------------------------------------------------------------------
+   FOCUS VISIBILITY
+   App.css contains exactly 6 `:focus` rules in 6,175 lines and 5 of them are
+   `outline: none` with no replacement indicator. A keyboard or switch-control
+   user currently cannot tell where they are anywhere in the app. This restores a
+   single consistent ring on every focusable element.
+
+   `:focus-visible` (not `:focus`) means mouse and touch users never see it.
+
+   Only `outline` is set. A box-shadow halo would read better on accent-filled
+   buttons but would clobber whatever box-shadow the element already carries, so
+   the ring relies on `outline-offset` instead: the 2px gap paints in the page
+   background and gives the ring an edge on any fill.
+   -------------------------------------------------------------------------- */
+:focus-visible:focus-visible {
+  outline: var(--ring-width) solid var(--color-ring);
+  outline-offset: var(--ring-offset);
+}
+
+/* ----------------------------------------------------------------------------
+   REDUCED MOTION
+   App.css has zero `prefers-reduced-motion` blocks and animates aggressively
+   (spinners, slide-ins, hover transforms). For users with vestibular disorders
+   this is an accessibility blocker, not a preference.
+
+   `!important` is required: App.css declares transitions inline on element rules
+   that this file cannot out-specify generically. Durations are collapsed to 1ms
+   rather than 0 so `transitionend`/`animationend` listeners still fire.
+   -------------------------------------------------------------------------- */
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    animation-duration: 1ms !important;
+    animation-iteration-count: 1 !important;
+    animation-delay: 0ms !important;
+    transition-duration: 1ms !important;
+    transition-delay: 0ms !important;
+    scroll-behavior: auto !important;
+  }
+
+  html {
+    scroll-behavior: auto !important;
+  }
+}
+
+/* ----------------------------------------------------------------------------
+   Scrollbars, themed.
+   -------------------------------------------------------------------------- */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+  background: var(--color-border-strong);
+  border-radius: var(--radius-sm);
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: var(--color-fg-subtle);
+}
+
+/* Firefox (both properties inherit, so :root is enough) */
+:root {
+  scrollbar-color: var(--color-border-strong) transparent;
+  scrollbar-width: thin;
+}
+
+/* ----------------------------------------------------------------------------
+   Selection
+   -------------------------------------------------------------------------- */
+::selection {
+  background: var(--color-accent);
+  color: var(--color-accent-fg);
+}
diff --git a/frontend/src/styles/fonts.css b/frontend/src/styles/fonts.css
new file mode 100644
index 0000000..a6c959f
--- /dev/null
+++ b/frontend/src/styles/fonts.css
@@ -0,0 +1,56 @@
+/* ============================================================================
+   Inter, self-hosted.
+   ----------------------------------------------------------------------------
+   Replaces `@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;
+   400;500;600;700;800&display=swap')`, which sat on line 1 of index.css.
+
+   Why it had to go:
+     * A CSS `@import` of a remote stylesheet is render-blocking AND serial. The
+       browser had to (1) download index.css, (2) parse line 1, (3) do a DNS
+       lookup + TCP + TLS handshake with fonts.googleapis.com, (4) download the
+       CSS, (5) do a *second* DNS + TLS handshake with fonts.gstatic.com, and
+       only then (6) request the font. On a 3G link in Nepal that is roughly
+       0.6–1.0s of blank screen before any text can paint.
+     * Nothing in the app can precache a third-party font, so every cold start on
+       intermittent mobile data paid that cost again.
+     * Six weights were requested; the design system defines four.
+
+   What we ship instead: the two Google-subset Inter files (latin, latin-ext),
+   served same-origin from our own bundle, hashed by Vite for immutable caching,
+   and precached by the service worker (woff2 is in the Workbox globPatterns).
+
+   These are VARIABLE font files (verified: both carry fvar/gvar/avar/STAT
+   tables), so one 47 KB file covers 400/500/600/700 as real cuts — no synthetic
+   bolding. The brief asked for two static weights; one variable file is strictly
+   smaller and strictly better, so that is what is here.
+
+   The `unicode-range` descriptors are preserved, so inter-latin-ext (83 KB) is
+   only fetched if a glyph outside Basic Latin is actually rendered. The app's
+   UI text is ASCII apart from `·` (U+00B7) and `©` (U+00A9), both of which live
+   in the latin subset — in practice only the 47 KB file is ever downloaded.
+
+   font-display: swap — text paints immediately in the system fallback and swaps
+   when Inter arrives. Never a blank screen.
+   ========================================================================== */
+
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400 700;
+  font-display: swap;
+  src: url('./fonts/inter-latin-400-700.woff2') format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
+    U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193,
+    U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400 700;
+  font-display: swap;
+  src: url('./fonts/inter-latin-ext-400-700.woff2') format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF,
+    U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020,
+    U+20A0-20AB, U+20AD-20C4, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
diff --git a/frontend/src/styles/fonts/inter-latin-400-700.woff2 b/frontend/src/styles/fonts/inter-latin-400-700.woff2
new file mode 100644
index 0000000..d15208d
Binary files /dev/null and b/frontend/src/styles/fonts/inter-latin-400-700.woff2 differ
diff --git a/frontend/src/styles/fonts/inter-latin-ext-400-700.woff2 b/frontend/src/styles/fonts/inter-latin-ext-400-700.woff2
new file mode 100644
index 0000000..479d010
Binary files /dev/null and b/frontend/src/styles/fonts/inter-latin-ext-400-700.woff2 differ
diff --git a/frontend/src/styles/tokens.css b/frontend/src/styles/tokens.css
new file mode 100644
index 0000000..c7b5562
--- /dev/null
+++ b/frontend/src/styles/tokens.css
@@ -0,0 +1,367 @@
+/* ============================================================================
+   NECPrep design tokens
+   ----------------------------------------------------------------------------
+   Layout of this file:
+
+     1. @theme static   — PRIMITIVES. Theme-independent raw values (colour ramps,
+                          type scale, spacing, radii, breakpoints, motion, z-index).
+                          Emitted as CSS custom properties AND registered with
+                          Tailwind v4 so `text-2xl`, `rounded-lg`, `sm:` etc. work.
+     2. :root           — SEMANTIC tokens for the LIGHT theme (the default).
+     3. @media (prefers-color-scheme: dark) :root:not([data-theme="light"])
+                        — SEMANTIC overrides when the OS asks for dark and the
+                          user has not explicitly pinned light.
+     4. :root[data-theme="dark"]
+                        — SEMANTIC overrides when the user explicitly pins dark.
+     5. @theme inline   — maps Tailwind's `--shadow-*` namespace onto the themed
+                          `--ds-shadow-*` values so `shadow-md` follows the theme.
+
+   Three theme states are supported:
+     data-theme="light"  → explicit light  (blocks 3 and 4 do not apply)
+     data-theme="dark"   → explicit dark   (block 4 applies)
+     no attribute        → follow the OS   (block 3 applies in dark)
+
+   NOTE ON NAMING: the semantic tokens (--color-bg, --color-fg-muted, …) live in
+   plain `:root` rules, NOT inside @theme. @theme is hoisted and static — a value
+   defined there cannot be re-declared per theme. Semantic tokens are therefore
+   consumed directly (`color: var(--color-fg-muted)`) or through Tailwind's
+   arbitrary-value syntax (`text-(--color-fg-muted)`, `bg-(--color-surface)`).
+
+   CONTRAST: every foreground/background pair below was measured with the WCAG 2.1
+   relative-luminance formula, not eyeballed. Numbers are in the comments.
+   ========================================================================== */
+
+@theme static {
+  /* --------------------------------------------------------------------------
+     Reset Tailwind's stock theme. The design system is closed: if a value is not
+     declared below, there is deliberately no utility for it.
+     -------------------------------------------------------------------------- */
+  --color-*: initial;
+  --font-*: initial;
+  --text-*: initial;
+  --font-weight-*: initial;
+  --tracking-*: initial;
+  --leading-*: initial;
+  --spacing: initial;
+  --spacing-*: initial;
+  --radius-*: initial;
+  --shadow-*: initial;
+  --inset-shadow-*: initial;
+  --drop-shadow-*: initial;
+  --breakpoint-*: initial;
+  --container-*: initial;
+  --ease-*: initial;
+  --animate-*: initial;
+  --blur-*: initial;
+  --perspective-*: initial;
+  --aspect-*: initial;
+
+  /* ==========================================================================
+     COLOUR PRIMITIVES
+     ========================================================================== */
+  --color-white: #ffffff;
+  --color-black: #000000;
+  --color-transparent: transparent;
+  --color-current: currentColor;
+
+  /* Neutral ramp */
+  --color-neutral-50: #fafafa;
+  --color-neutral-100: #f4f4f5;
+  --color-neutral-200: #e4e4e7;
+  --color-neutral-300: #d4d4d8;
+  --color-neutral-400: #a1a1aa;
+  --color-neutral-500: #71717a;
+  --color-neutral-600: #52525b;
+  --color-neutral-700: #3f3f46;
+  --color-neutral-800: #27272a;
+  --color-neutral-900: #18181b;
+  --color-neutral-950: #0b0b0f;
+
+  /* Brand ramp (indigo) */
+  --color-brand-50: #eef2ff;
+  --color-brand-100: #e0e7ff;
+  --color-brand-200: #c7d2fe;
+  --color-brand-300: #a5b4fc;
+  --color-brand-400: #818cf8;
+  --color-brand-500: #6366f1;
+  --color-brand-600: #4f46e5;
+  --color-brand-700: #4338ca;
+  --color-brand-800: #3730a3;
+  --color-brand-900: #312e81;
+
+  /* Status */
+  --color-success-500: #22c55e;
+  --color-success-600: #16a34a;
+  --color-warning-500: #f59e0b;
+  --color-warning-600: #d97706;
+  --color-danger-500: #ef4444;
+  --color-danger-600: #dc2626;
+  --color-info-500: #06b6d4;
+  --color-info-600: #0891b2;
+
+  /* ==========================================================================
+     TYPOGRAPHY
+     8 steps + 1 display step. Nothing else. (App.css currently ships 31 distinct
+     font-size values; the migration phase collapses them onto these.)
+     ========================================================================== */
+  --font-sans: 'Inter', system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI',
+    Roboto, 'Helvetica Neue', Arial, sans-serif;
+  --font-mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+
+  --text-xs: 0.75rem;
+  --text-xs--line-height: 1;
+  --text-sm: 0.875rem;
+  --text-sm--line-height: 1.25;
+  --text-base: 1rem;
+  --text-base--line-height: 1.5;
+  --text-lg: 1.125rem;
+  --text-lg--line-height: 1.6;
+  --text-xl: 1.25rem;
+  --text-xl--line-height: 1.5;
+  --text-2xl: 1.5rem;
+  --text-2xl--line-height: 1.3;
+  --text-3xl: 1.875rem;
+  --text-3xl--line-height: 1.2;
+  --text-4xl: 2.25rem;
+  --text-4xl--line-height: 1.1;
+  /* Fluid hero step. Line-height matches 4xl so the two are interchangeable. */
+  --text-display: clamp(2rem, 5vw, 3.5rem);
+  --text-display--line-height: 1.1;
+
+  /* Four weights only. Inter is loaded as a variable font over the 400–700 axis,
+     so every one of these is a real cut — the browser never synthesises. */
+  --font-weight-normal: 400;
+  --font-weight-medium: 500;
+  --font-weight-semibold: 600;
+  --font-weight-bold: 700;
+
+  /* ==========================================================================
+     SPACING — 4px base, closed scale
+     ========================================================================== */
+  --spacing-1: 0.25rem; /*  4px */
+  --spacing-2: 0.5rem; /*   8px */
+  --spacing-3: 0.75rem; /* 12px */
+  --spacing-4: 1rem; /*    16px */
+  --spacing-5: 1.25rem; /* 20px */
+  --spacing-6: 1.5rem; /*  24px */
+  --spacing-8: 2rem; /*    32px */
+  --spacing-10: 2.5rem; /* 40px */
+  --spacing-12: 3rem; /*   48px */
+  --spacing-16: 4rem; /*   64px */
+  --spacing-20: 5rem; /*   80px */
+  --spacing-24: 6rem; /*   96px */
+
+  /* ==========================================================================
+     RADII — exactly 5 (App.css currently has 15 distinct values, incl. a 13px)
+     ========================================================================== */
+  --radius-sm: 6px;
+  --radius-md: 10px;
+  --radius-lg: 14px;
+  --radius-xl: 20px;
+  --radius-full: 9999px;
+
+  /* ==========================================================================
+     BREAKPOINTS — mobile-first min-width.
+     App.css ships 8 max-width queries at 4 inconsistent values (1024/768/640/480);
+     everything new is authored against these.
+     ========================================================================== */
+  --breakpoint-sm: 30rem; /*  480px */
+  --breakpoint-md: 48rem; /*  768px */
+  --breakpoint-lg: 64rem; /* 1024px */
+  --breakpoint-xl: 80rem; /* 1280px */
+
+  /* ==========================================================================
+     MOTION
+     ========================================================================== */
+  --duration-instant: 0ms;
+  --duration-fast: 120ms;
+  --duration-base: 200ms;
+  --duration-slow: 320ms;
+  --ease-out: cubic-bezier(0.2, 0, 0, 1);
+
+  /* ==========================================================================
+     Z-INDEX
+     ========================================================================== */
+  --z-base: 0;
+  --z-dropdown: 1000;
+  --z-sticky: 1100;
+  --z-overlay: 1200;
+  --z-modal: 1300;
+  --z-toast: 1400;
+
+  /* ==========================================================================
+     FOCUS RING geometry (the ring colour is semantic — see below)
+     ========================================================================== */
+  --ring-width: 2px;
+  --ring-offset: 2px;
+}
+
+/* ============================================================================
+   SEMANTIC TOKENS — LIGHT THEME (default)
+   ========================================================================== */
+:root {
+  --color-bg: var(--color-neutral-50); /* #fafafa */
+  --color-surface: var(--color-white); /* #ffffff */
+  --color-surface-2: var(--color-neutral-100); /* #f4f4f5 */
+  --color-border: var(--color-neutral-200); /* #e4e4e7 */
+  --color-border-strong: var(--color-neutral-300); /* #d4d4d8 */
+
+  --color-fg: var(--color-neutral-900); /* #18181b — 16.97:1 on bg */
+  --color-fg-muted: var(--color-neutral-600); /* #52525b —  7.41:1 on bg, 7.73:1 on surface */
+  /* fg-subtle is 4.63:1 on bg. NOT for body copy — dividers, disabled glyphs,
+     decorative labels at >=24px/>=19px-bold only. */
+  --color-fg-subtle: var(--color-neutral-500); /* #71717a */
+
+  --color-accent: var(--color-brand-600); /* #4f46e5 — 6.02:1 on bg */
+  --color-accent-hover: var(--color-brand-700);
+  --color-accent-fg: var(--color-white); /* 6.29:1 on brand-600 fill */
+  /* Link/body-copy grade accent — 7.57:1 on bg, where --color-accent is 6.02:1. */
+  --color-accent-text: var(--color-brand-700); /* #4338ca */
+
+  --color-ring: var(--color-brand-600);
+
+  /* Status, text-grade. The 500/600 ramp steps are vivid enough for fills, icons
+     and borders but too light for body copy on a light background
+     (success-600 is 3.16:1, warning-600 3.05:1). These darker cuts are what text
+     should use. Measured on --color-bg #fafafa. */
+  --color-success-fg: #15803d; /* 4.81:1 */
+  --color-warning-fg: #b45309; /* 4.81:1 */
+  --color-danger-fg: #b91c1c; /*  6.20:1 */
+  --color-info-fg: #0e7490; /*    5.13:1 */
+
+  /* Scrim behind modals / sheets */
+  --color-overlay: rgba(9, 9, 11, 0.5);
+
+  /* Translucent surfaces (frosted cards, sticky nav). Kept as explicit rgba
+     rather than color-mix() so there is no baseline requirement on older
+     Android WebViews. */
+  --color-surface-translucent: rgba(255, 255, 255, 0.8);
+  --color-surface-translucent-hover: rgba(244, 244, 245, 0.92);
+
+  /* ------------------------------------------------------------------------
+     Shadows. Raw values live here (not in @theme) because they change with the
+     theme; @theme inline at the bottom of this file wires them to Tailwind's
+     shadow-* utilities.
+     ------------------------------------------------------------------------ */
+  --ds-shadow-xs: 0 1px 2px rgba(9, 9, 11, 0.06);
+  --ds-shadow-sm: 0 1px 3px rgba(9, 9, 11, 0.1), 0 1px 2px -1px rgba(9, 9, 11, 0.1);
+  --ds-shadow-md: 0 4px 12px -2px rgba(9, 9, 11, 0.12), 0 2px 6px -2px rgba(9, 9, 11, 0.08);
+  --ds-shadow-lg: 0 16px 40px -8px rgba(9, 9, 11, 0.18), 0 4px 12px -4px rgba(9, 9, 11, 0.12);
+  /* Single glow, reserved for the primary CTA. */
+  --ds-shadow-glow: 0 0 0 1px rgba(79, 70, 229, 0.35), 0 8px 24px -4px rgba(79, 70, 229, 0.4);
+
+  /* ------------------------------------------------------------------------
+     LEGACY accents. Not part of the design system — they exist only because
+     App.css still references them. The migration phase deletes them.
+     ------------------------------------------------------------------------ */
+  --color-legacy-violet: #8b5cf6;
+  --color-legacy-pink: #ec4899;
+}
+
+/* ============================================================================
+   SEMANTIC TOKENS — DARK
+   Declared once as a custom-property group, applied by both selectors below.
+   (CSS has no variable groups, so the block is duplicated verbatim; keep the two
+   copies in sync.)
+   ========================================================================== */
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme='light']) {
+    --color-bg: var(--color-neutral-950); /* #0b0b0f */
+    --color-surface: var(--color-neutral-900); /* #18181b */
+    --color-surface-2: #1a1a22;
+    --color-border: rgba(255, 255, 255, 0.1);
+    --color-border-strong: rgba(255, 255, 255, 0.18);
+
+    --color-fg: var(--color-neutral-50); /* #fafafa — 18.82:1 on bg */
+    --color-fg-muted: var(--color-neutral-400); /* #a1a1aa —  7.66:1 on bg, 6.91:1 on surface */
+    --color-fg-subtle: var(--color-neutral-500); /* #71717a —  4.06:1 — non-text use only */
+
+    --color-accent: var(--color-brand-500); /* #6366f1 */
+    --color-accent-hover: var(--color-brand-400);
+    --color-accent-fg: var(--color-white);
+    --color-accent-text: var(--color-brand-400); /* #818cf8 — 6.59:1 on bg */
+
+    --color-ring: var(--color-brand-400);
+
+    --color-success-fg: #4ade80; /* 11.27:1 on bg */
+    --color-warning-fg: #fbbf24; /* 11.77:1 on bg */
+    --color-danger-fg: #f87171; /*  7.10:1 on bg */
+    --color-info-fg: #22d3ee; /*   10.87:1 on bg */
+
+    --color-overlay: rgba(0, 0, 0, 0.65);
+
+    --color-surface-translucent: rgba(26, 26, 34, 0.8);
+    --color-surface-translucent-hover: rgba(39, 39, 52, 0.9);
+
+    --ds-shadow-xs: 0 1px 2px rgba(0, 0, 0, 0.4);
+    --ds-shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.5), 0 1px 2px -1px rgba(0, 0, 0, 0.4);
+    --ds-shadow-md: 0 4px 12px -2px rgba(0, 0, 0, 0.55), 0 2px 6px -2px rgba(0, 0, 0, 0.4);
+    --ds-shadow-lg: 0 25px 50px -12px rgba(0, 0, 0, 0.6), 0 4px 12px -4px rgba(0, 0, 0, 0.4);
+    --ds-shadow-glow: 0 0 0 1px rgba(99, 102, 241, 0.45), 0 8px 28px -4px rgba(99, 102, 241, 0.5);
+  }
+}
+
+:root[data-theme='dark'] {
+  --color-bg: var(--color-neutral-950);
+  --color-surface: var(--color-neutral-900);
+  --color-surface-2: #1a1a22;
+  --color-border: rgba(255, 255, 255, 0.1);
+  --color-border-strong: rgba(255, 255, 255, 0.18);
+
+  --color-fg: var(--color-neutral-50);
+  --color-fg-muted: var(--color-neutral-400);
+  --color-fg-subtle: var(--color-neutral-500);
+
+  --color-accent: var(--color-brand-500);
+  --color-accent-hover: var(--color-brand-400);
+  --color-accent-fg: var(--color-white);
+  --color-accent-text: var(--color-brand-400);
+
+  --color-ring: var(--color-brand-400);
+
+  --color-success-fg: #4ade80;
+  --color-warning-fg: #fbbf24;
+  --color-danger-fg: #f87171;
+  --color-info-fg: #22d3ee;
+
+  --color-overlay: rgba(0, 0, 0, 0.65);
+
+  --color-surface-translucent: rgba(26, 26, 34, 0.8);
+  --color-surface-translucent-hover: rgba(39, 39, 52, 0.9);
+
+  --ds-shadow-xs: 0 1px 2px rgba(0, 0, 0, 0.4);
+  --ds-shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.5), 0 1px 2px -1px rgba(0, 0, 0, 0.4);
+  --ds-shadow-md: 0 4px 12px -2px rgba(0, 0, 0, 0.55), 0 2px 6px -2px rgba(0, 0, 0, 0.4);
+  --ds-shadow-lg: 0 25px 50px -12px rgba(0, 0, 0, 0.6), 0 4px 12px -4px rgba(0, 0, 0, 0.4);
+  --ds-shadow-glow: 0 0 0 1px rgba(99, 102, 241, 0.45), 0 8px 28px -4px rgba(99, 102, 241, 0.5);
+}
+
+/* Tell the UA which form controls / scrollbars to paint. */
+:root {
+  color-scheme: light;
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme='light']) {
+    color-scheme: dark;
+  }
+}
+:root[data-theme='dark'] {
+  color-scheme: dark;
+}
+:root[data-theme='light'] {
+  color-scheme: light;
+}
+
+/* ============================================================================
+   Wire the themed shadows into Tailwind's shadow-* namespace.
+   `inline` means Tailwind emits `var(--ds-shadow-md)` at the use site instead of
+   minting its own `--shadow-md`, so the utility follows the theme at runtime —
+   and the name `--shadow-lg` stays free for the legacy alias in index.css.
+   ========================================================================== */
+@theme inline {
+  --shadow-xs: var(--ds-shadow-xs);
+  --shadow-sm: var(--ds-shadow-sm);
+  --shadow-md: var(--ds-shadow-md);
+  --shadow-lg: var(--ds-shadow-lg);
+  --shadow-glow: var(--ds-shadow-glow);
+}
diff --git a/frontend/src/test/setup.ts b/frontend/src/test/setup.ts
new file mode 100644
index 0000000..d626ff4
--- /dev/null
+++ b/frontend/src/test/setup.ts
@@ -0,0 +1,12 @@
+import '@testing-library/jest-dom/vitest';
+import { afterEach, beforeEach } from 'vitest';
+import { cleanup } from '@testing-library/react';
+
+afterEach(() => {
+  cleanup();
+  localStorage.clear();
+});
+
+beforeEach(() => {
+  localStorage.clear();
+});
diff --git a/frontend/tsconfig.app.json b/frontend/tsconfig.app.json
index a9b5a59..d1dea1c 100644
--- a/frontend/tsconfig.app.json
+++ b/frontend/tsconfig.app.json
@@ -5,7 +5,7 @@
     "useDefineForClassFields": true,
     "lib": ["ES2022", "DOM", "DOM.Iterable"],
     "module": "ESNext",
-    "types": ["vite/client"],
+    "types": ["vite/client", "vite-plugin-pwa/client"],
     "skipLibCheck": true,
 
     /* Bundler mode */
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
index 8b0f57b..ded1b23 100644
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -1,7 +1,125 @@
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import { VitePWA } from 'vite-plugin-pwa'
 
 // https://vite.dev/config/
 export default defineConfig({
-  plugins: [react()],
+  plugins: [
+    react(),
+    tailwindcss(),
+    VitePWA({
+      // 'prompt' never activates a new service worker behind the user's back —
+      // important here because a silent reload mid-quiz would lose answers.
+      // The update UI itself is a component and is NOT defined in this package;
+      // `src/pwa.ts` exports the hook a component should call.
+      registerType: 'prompt',
+      // 'auto' injects a plain registration script when nothing in src imports
+      // `virtual:pwa-register*`. That means offline works from day one, before
+      // any update-prompt component exists. Once a component imports the hook,
+      // the plugin stops injecting and the component owns registration.
+      injectRegister: 'auto',
+      // Keep the service worker out of `vite dev`. Other agents are working in
+      // this repo concurrently and a stale SW in dev is a nasty false bug.
+      devOptions: { enabled: false },
+      includeAssets: ['favicon.svg', 'icons/*.png'],
+      manifest: {
+        id: '/',
+        name: 'NECPrep',
+        short_name: 'NECPrep',
+        description:
+          'Practice platform for the Nepal Engineering Council licence exam. Chapter practice, timed mock tests, flashcards and progress tracking — fully offline.',
+        lang: 'en',
+        dir: 'ltr',
+        start_url: '/',
+        scope: '/',
+        display: 'standalone',
+        orientation: 'portrait-primary',
+        theme_color: '#0b0b0f',
+        background_color: '#0b0b0f',
+        categories: ['education'],
+        icons: [
+          { src: '/icons/icon-192.png', sizes: '192x192', type: 'image/png', purpose: 'any' },
+          { src: '/icons/icon-512.png', sizes: '512x512', type: 'image/png', purpose: 'any' },
+          {
+            src: '/icons/maskable-192.png',
+            sizes: '192x192',
+            type: 'image/png',
+            purpose: 'maskable',
+          },
+          {
+            src: '/icons/maskable-512.png',
+            sizes: '512x512',
+            type: 'image/png',
+            purpose: 'maskable',
+          },
+        ],
+      },
+      workbox: {
+        // App shell: every hashed build output plus the self-hosted woff2.
+        // `.json` is deliberately absent — the question bank under public/data is
+        // ~968 KB and is handled by the runtime cache below instead, so a first
+        // paint is never blocked waiting for the whole bank to precache.
+        globPatterns: ['**/*.{js,css,html,ico,png,svg,webmanifest,woff2}'],
+        // The latin-ext Inter subset (85 KB) covers accented Latin that this
+        // English UI never renders; the browser only requests it if such a glyph
+        // appears. Precaching it would put 85 KB of dead weight on every first
+        // install over 3G. It is still runtime-cached below if ever fetched.
+        globIgnores: ['**/inter-latin-ext-*.woff2'],
+        navigateFallback: '/index.html',
+        navigateFallbackDenylist: [/^\/api\//],
+        cleanupOutdatedCaches: true,
+        clientsClaim: false, // 'prompt' flow: the user decides when to take over.
+        skipWaiting: false,
+        runtimeCaching: [
+          {
+            // The question bank. StaleWhileRevalidate: serve the cached copy
+            // instantly (works with no connection at all) and refresh in the
+            // background when there is one. This is the whole offline story —
+            // ~968 KB of JSON is all the app needs to be fully usable on a
+            // dropped connection.
+            urlPattern: ({ url, sameOrigin }) =>
+              sameOrigin && url.pathname.startsWith('/data/'),
+            handler: 'StaleWhileRevalidate',
+            options: {
+              cacheName: 'necprep-question-bank',
+              expiration: {
+                maxEntries: 64,
+                maxAgeSeconds: 60 * 60 * 24 * 90, // 90 days
+              },
+              cacheableResponse: { statuses: [0, 200] },
+            },
+          },
+          {
+            // Any font not in the precache (currently only the latin-ext Inter
+            // subset). Immutable hashed filenames, so CacheFirst is safe.
+            urlPattern: ({ request, sameOrigin }) => sameOrigin && request.destination === 'font',
+            handler: 'CacheFirst',
+            options: {
+              cacheName: 'necprep-fonts',
+              expiration: { maxEntries: 8, maxAgeSeconds: 60 * 60 * 24 * 365 },
+              cacheableResponse: { statuses: [0, 200] },
+            },
+          },
+        ],
+      },
+    }),
+  ],
+  build: {
+    rollupOptions: {
+      output: {
+        // Split vendor code by package so an app deploy doesn't invalidate the
+        // framework in users' caches. The string-array form of manualChunks
+        // missed react-dom/client, which left the whole reconciler in the entry
+        // chunk; matching on the resolved path is reliable.
+        manualChunks(id) {
+          if (!id.includes('node_modules')) return
+          if (/node_modules\/(framer-motion|motion-dom|motion-utils)\//.test(id)) return 'motion'
+          if (/node_modules\/(react-router|react-router-dom)\//.test(id)) return 'router'
+          if (/node_modules\/(react|react-dom|scheduler)\//.test(id)) return 'react'
+          return 'vendor'
+        },
+      },
+    },
+  },
 })
diff --git a/frontend/vitest.config.ts b/frontend/vitest.config.ts
new file mode 100644
index 0000000..d40d330
--- /dev/null
+++ b/frontend/vitest.config.ts
@@ -0,0 +1,12 @@
+import { defineConfig } from 'vitest/config'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    setupFiles: ['./src/test/setup.ts'],
+    include: ['src/**/*.test.{ts,tsx}', 'test/**/*.test.{ts,tsx}'],
+  },
+})
diff --git a/scripts/classify-subchapters.mjs b/scripts/classify-subchapters.mjs
new file mode 100644
index 0000000..b66d6b0
--- /dev/null
+++ b/scripts/classify-subchapters.mjs
@@ -0,0 +1,197 @@
+/**
+ * Classify the whole question bank into syllabus sub-chapters, offline.
+ *
+ *   node scripts/classify-subchapters.mjs             # coverage report
+ *   node scripts/classify-subchapters.mjs --sample 8  # show N decisions/chapter
+ *   node scripts/classify-subchapters.mjs --review    # write a review sheet
+ *
+ * The classifier itself lives in `frontend/src/services/subchapterClassifier.ts`
+ * and is imported directly — Node 22 strips the types — so this report and the
+ * running app can never disagree about what a question is classified as.
+ *
+ * NOTHING HERE IS A BUILD ARTEFACT
+ * --------------------------------
+ * There is deliberately no generated map. The app classifies at render time
+ * and the importer at import time, both through the same module, so a
+ * precomputed file would have no consumer and nothing to keep it honest — it
+ * would simply drift away from the term lists.
+ *
+ * WHAT THIS MEASURES, AND WHAT IT CANNOT
+ * -------------------------------------
+ * COVERAGE is measurable here: how many questions got a label, and whether
+ * all six sub-chapters of each chapter are being used. PRECISION is not —
+ * there is no ground truth to compare against, so a term list that
+ * confidently mislabels a whole topic would show up as excellent coverage.
+ *
+ * That is what `--review` is for: it writes every label to a TSV, weakest
+ * confidence first, so the least-defensible decisions are the ones a reader
+ * reaches in the first screenful. Spot-checking the top of that file is the
+ * only way precision gets validated.
+ */
+
+import { readFile, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import {
+  classifySubchapter,
+  CLASSIFIER_THRESHOLDS,
+} from '../frontend/src/services/subchapterClassifier.ts';
+import { syllabusChapters } from '../frontend/src/data/syllabus.ts';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const DATA_DIR = join(ROOT, 'frontend', 'public', 'data', 'books');
+const REVIEW_FILE = join(ROOT, 'subchapter-review.tsv');
+
+const args = process.argv.slice(2);
+const REVIEW = args.includes('--review');
+const sampleIdx = args.indexOf('--sample');
+const SAMPLE = sampleIdx === -1 ? 0 : Number(args[sampleIdx + 1] ?? 5);
+
+/**
+ * The frontend's positional id, so a review row can be traced back to the
+ * exact question — `book-ch4_317` locates it in `ch4.json` without a search.
+ */
+function questionId(bookChapterId, index) {
+  return `${bookChapterId}_${index}`;
+}
+
+function optionsOf(row) {
+  return [row.opt1, row.opt2, row.opt3, row.opt4].filter(
+    o => typeof o === 'string' && o.length > 0
+  );
+}
+
+const report = [];
+const reviewRows = [];
+let totalRows = 0;
+let totalMatched = 0;
+let confidenceSum = 0;
+
+for (const chapter of syllabusChapters) {
+  const file = join(DATA_DIR, `${chapter.bookChapterId.replace('book-', '')}.json`);
+  let rows;
+  try {
+    rows = JSON.parse(await readFile(file, 'utf8'));
+  } catch (err) {
+    console.error(`! cannot read ${file}: ${err.message}`);
+    process.exitCode = 1;
+    continue;
+  }
+  if (!Array.isArray(rows)) {
+    console.error(`! ${file} is not an array`);
+    process.exitCode = 1;
+    continue;
+  }
+
+  // Per-sub-chapter tallies, so a chapter whose questions all land on one
+  // sub-chapter is visible as a problem rather than counted as success.
+  const perSub = new Map(chapter.subchapters.map(s => [s.code, 0]));
+  const samples = [];
+  let matched = 0;
+
+  rows.forEach((row, index) => {
+    totalRows += 1;
+    const question = typeof row.qsns === 'string' ? row.qsns : '';
+    const options = optionsOf(row);
+    const hit = classifySubchapter({
+      bookChapterId: chapter.bookChapterId,
+      question,
+      options,
+    });
+    if (!hit) {
+      if (samples.length < SAMPLE) {
+        samples.push({ ok: false, stem: question.slice(0, 64) });
+      }
+      return;
+    }
+    matched += 1;
+    totalMatched += 1;
+    confidenceSum += hit.confidenceBp;
+    perSub.set(hit.code, (perSub.get(hit.code) ?? 0) + 1);
+    reviewRows.push({
+      bp: hit.confidenceBp,
+      id: questionId(chapter.bookChapterId, index),
+      code: hit.displayCode,
+      title: hit.title,
+      stem: question.replace(/\s+/g, ' ').trim(),
+      terms: hit.matchedTerms.slice(0, 4).join('; '),
+    });
+    if (samples.length < SAMPLE) {
+      samples.push({
+        ok: true,
+        stem: question.slice(0, 64),
+        code: hit.displayCode,
+        title: hit.title,
+        bp: hit.confidenceBp,
+        terms: hit.matchedTerms.slice(0, 3),
+      });
+    }
+  });
+
+  report.push({
+    chapter: chapter.number,
+    total: rows.length,
+    matched,
+    perSub: [...perSub.entries()],
+    samples,
+  });
+}
+
+/* ── Report ─────────────────────────────────────────────────────────── */
+
+const pct = (n, d) => (d === 0 ? '  0.0' : ((n / d) * 100).toFixed(1).padStart(5));
+
+console.log('Sub-chapter classification — deterministic, no API calls.');
+console.log(
+  `Thresholds: MIN_SCORE=${CLASSIFIER_THRESHOLDS.MIN_SCORE} ` +
+    `MIN_MARGIN=${CLASSIFIER_THRESHOLDS.MIN_MARGIN} ` +
+    `OPTION_WEIGHT=${CLASSIFIER_THRESHOLDS.OPTION_WEIGHT}\n`
+);
+console.log('  ch   total  labelled       spread across the 6 sub-chapters');
+console.log('  ───────────────────────────────────────────────────────────────');
+for (const r of report) {
+  const spread = r.perSub.map(([, n]) => String(n).padStart(4)).join(' ');
+  const used = r.perSub.filter(([, n]) => n > 0).length;
+  console.log(
+    `  ${String(r.chapter).padStart(2)}  ${String(r.total).padStart(6)}  ` +
+      `${String(r.matched).padStart(5)} ${pct(r.matched, r.total)}%  ` +
+      `${spread}   ${used}/6 used`
+  );
+}
+console.log('  ───────────────────────────────────────────────────────────────');
+console.log(
+  `  all ${String(totalRows).padStart(6)}  ${String(totalMatched).padStart(5)} ` +
+    `${pct(totalMatched, totalRows)}%  ` +
+    `mean confidence ${totalMatched ? Math.round(confidenceSum / totalMatched) : 0} bp`
+);
+
+if (SAMPLE > 0) {
+  for (const r of report) {
+    console.log(`\n  ── chapter ${r.chapter} sample ──`);
+    for (const s of r.samples) {
+      if (s.ok) {
+        console.log(`   ${s.code} ${String(s.bp).padStart(4)}bp  ${s.stem}`);
+        console.log(`          via ${s.terms.join(', ')}`);
+      } else {
+        console.log(`   ---  declined   ${s.stem}`);
+      }
+    }
+  }
+}
+
+if (REVIEW) {
+  // Weakest first, then by sub-chapter, so a reader starts with the labels
+  // most likely to be wrong and related ones sit together.
+  reviewRows.sort((a, b) => a.bp - b.bp || (a.code < b.code ? -1 : 1));
+  const tsv = [
+    ['confidence_bp', 'question_id', 'subchapter', 'title', 'matched_terms', 'stem'].join('\t'),
+    ...reviewRows.map(r =>
+      [r.bp, r.id, r.code, r.title, r.terms, r.stem].join('\t')
+    ),
+  ].join('\n');
+  await writeFile(REVIEW_FILE, tsv + '\n', 'utf8');
+  console.log(`\nwrote ${reviewRows.length} labels, weakest first -> ${REVIEW_FILE}`);
+  console.log('Spot-check the top of that file: coverage is measured above, precision is not.');
+} else {
+  console.log('\n(report only; pass --review to write a reviewable TSV of every label)');
+}
diff --git a/scripts/find-dead-css.mjs b/scripts/find-dead-css.mjs
new file mode 100644
index 0000000..feb2adb
--- /dev/null
+++ b/scripts/find-dead-css.mjs
@@ -0,0 +1,240 @@
+/**
+ * Find — and optionally remove — CSS rules that can never match.
+ *
+ *   node scripts/find-dead-css.mjs            # report
+ *   node scripts/find-dead-css.mjs --write    # rewrite the file
+ *   node scripts/find-dead-css.mjs --list     # also print every dead name
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * `frontend/src/App.css` predates the design system and the CSS-module layout,
+ * and it accumulated the styling of several features that were later removed —
+ * the Supabase sign-in UI abandoned in ADR 0001, and the paginated mock-test
+ * layout dropped when the quiz engine landed. The first pass removed 214 rules
+ * and 1,062 lines. The file is still large, so this is a tool rather than a
+ * one-off: the rest of the migration will keep orphaning rules, and nobody
+ * should have to re-derive which ones.
+ *
+ * THE TEST IT APPLIES
+ * -------------------
+ * A selector that contains a class name appearing NOWHERE in the sources
+ * cannot match any element, so its rule is dead. Compound selectors count:
+ * `.login-page .btn-primary` is dead even though `.btn-primary` is live,
+ * because no element ever carries `.login-page`.
+ *
+ * WHY IT IS SAFE TO BELIEVE
+ * -------------------------
+ * Every step is biased toward keeping a rule:
+ *
+ *   * "Used" means the class name appears anywhere in any `.tsx`, `.ts` or
+ *     other `.css` file, or in `index.html` — including inside a comment or a
+ *     test. One mention anywhere and the rule survives.
+ *   * Class names COMPOSED at runtime are detected and excluded. The script
+ *     scans template literals for `prefix-${...}` and treats everything under
+ *     such a prefix as live, because `panel-${tone}` can produce a name that
+ *     exists nowhere as a literal.
+ *   * A rule whose selector list mixes dead and live selectors keeps the live
+ *     ones; only fully-dead rules are dropped.
+ *   * Only CLASS selectors are examined. Element, id, attribute and pseudo
+ *     selectors are never a reason to remove anything.
+ *
+ * What it cannot see: a class injected by a third-party script, or built by
+ * string concatenation rather than a template literal (`'btn-' + kind`). Both
+ * are absent from this codebase today; if either arrives, this tool needs to
+ * learn about it before being trusted again.
+ */
+
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const FRONTEND = join(ROOT, 'frontend');
+const TARGET = join(FRONTEND, 'src', 'App.css');
+
+const args = process.argv.slice(2);
+const WRITE = args.includes('--write');
+const LIST = args.includes('--list');
+
+/** Every class name in a chunk of CSS or a selector. */
+const CLASS_RE = /\.(-?[A-Za-z_][\w-]*)/g;
+
+async function walk(dir) {
+  const out = [];
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === 'node_modules') continue;
+      out.push(...(await walk(path)));
+    } else {
+      out.push(path);
+    }
+  }
+  return out;
+}
+
+/**
+ * Everything a class name could legitimately be mentioned in.
+ *
+ * Tests are INCLUDED on purpose: a class asserted by a test is a class the app
+ * is expected to render, and removing its rule would make the test pass while
+ * the page looked wrong.
+ */
+async function readSources() {
+  const files = await walk(join(FRONTEND, 'src'));
+  const parts = [];
+  for (const path of files) {
+    if (path === TARGET) continue;
+    if (/\.(tsx|ts|css)$/.test(path)) {
+      parts.push(await readFile(path, 'utf8'));
+    }
+  }
+  const html = join(FRONTEND, 'index.html');
+  if (existsSync(html)) parts.push(await readFile(html, 'utf8'));
+  return parts.join('\n');
+}
+
+/** Class prefixes actually composed as `foo-${x}` inside a template literal. */
+function dynamicPrefixes(source) {
+  const found = new Set();
+  for (const [, literal] of source.matchAll(/`([^`]*)`/gs)) {
+    for (const [, prefix] of literal.matchAll(/([A-Za-z][\w-]*-)\$\{/g)) {
+      found.add(prefix);
+    }
+  }
+  return [...found].sort();
+}
+
+/* ------------------------------------------------------------------ *
+ * A deliberately small CSS splitter.
+ *
+ * App.css is plain CSS: rules and at-blocks, no nesting. Brace matching is
+ * enough, and a real parser would be a dependency for one file.
+ * ------------------------------------------------------------------ */
+
+function splitBlocks(text) {
+  const out = [];
+  let i = 0;
+  while (i < text.length) {
+    if (text.startsWith('/*', i)) {
+      const end = text.indexOf('*/', i + 2);
+      const stop = end === -1 ? text.length : end + 2;
+      out.push({ kind: 'raw', text: text.slice(i, stop) });
+      i = stop;
+      continue;
+    }
+    if (/\s/.test(text[i])) {
+      let j = i;
+      while (j < text.length && /\s/.test(text[j])) j += 1;
+      out.push({ kind: 'raw', text: text.slice(i, j) });
+      i = j;
+      continue;
+    }
+    const brace = text.indexOf('{', i);
+    if (brace === -1) {
+      out.push({ kind: 'raw', text: text.slice(i) });
+      break;
+    }
+    const prelude = text.slice(i, brace);
+    let depth = 1;
+    let j = brace + 1;
+    while (j < text.length && depth > 0) {
+      if (text[j] === '{') depth += 1;
+      else if (text[j] === '}') depth -= 1;
+      j += 1;
+    }
+    out.push({
+      kind: prelude.trimStart().startsWith('@') ? 'at' : 'rule',
+      prelude,
+      body: text.slice(brace + 1, j - 1),
+    });
+    i = j;
+  }
+  return out;
+}
+
+const css = await readFile(TARGET, 'utf8');
+const sources = await readSources();
+const DYNAMIC = dynamicPrefixes(sources);
+
+const allNames = new Set([...css.matchAll(CLASS_RE)].map((m) => m[1]));
+const dead = new Set(
+  [...allNames].filter(
+    (name) => !sources.includes(name) && !DYNAMIC.some((p) => name.startsWith(p)),
+  ),
+);
+
+function selectorIsDead(selector) {
+  return [...selector.matchAll(CLASS_RE)].some((m) => dead.has(m[1]));
+}
+
+const stats = { rulesRemoved: 0, selectorsDropped: 0, atBlocksEmptied: 0 };
+
+/** Nestable at-rules, i.e. the ones whose bodies contain rules. */
+const NESTED_AT = ['@media', '@supports', '@layer', '@container'];
+
+function prune(text) {
+  const pieces = [];
+  for (const block of splitBlocks(text)) {
+    if (block.kind === 'raw') {
+      pieces.push(block.text);
+      continue;
+    }
+    if (block.kind === 'at') {
+      const at = block.prelude.trimStart();
+      if (NESTED_AT.some((k) => at.startsWith(k))) {
+        const inner = prune(block.body);
+        // An at-block whose every rule died has nothing left to say.
+        if (inner.trim() === '') {
+          stats.atBlocksEmptied += 1;
+          continue;
+        }
+        pieces.push(`${block.prelude}{${inner}}`);
+      } else {
+        // @keyframes, @font-face, @import: left exactly as found.
+        pieces.push(`${block.prelude}{${block.body}}`);
+      }
+      continue;
+    }
+
+    const selectors = block.prelude.split(',');
+    const kept = selectors.filter((s) => !selectorIsDead(s));
+    if (kept.length === selectors.length) {
+      pieces.push(`${block.prelude}{${block.body}}`);
+      continue;
+    }
+    stats.selectorsDropped += selectors.length - kept.length;
+    if (kept.length === 0) {
+      stats.rulesRemoved += 1;
+      continue;
+    }
+    pieces.push(`${kept.join(',')}{${block.body}}`);
+  }
+  return pieces.join('');
+}
+
+const result = prune(css);
+const before = css.split('\n').length;
+const after = result.split('\n').length;
+
+console.log(`target                 ${TARGET.replace(ROOT + '/', '')}`);
+console.log(`dynamic prefixes kept  ${DYNAMIC.length ? DYNAMIC.join(', ') : '(none found)'}`);
+console.log(`class names in file    ${allNames.size}`);
+console.log(`dead class names       ${dead.size}`);
+console.log(`rules removed          ${stats.rulesRemoved}`);
+console.log(`at-blocks emptied      ${stats.atBlocksEmptied}`);
+console.log(`selectors dropped      ${stats.selectorsDropped} (from rules that survive)`);
+console.log(`lines                  ${before} -> ${after} (${before - after} removed)`);
+
+if (LIST && dead.size > 0) {
+  console.log('\ndead class names:');
+  for (const name of [...dead].sort()) console.log(`  .${name}`);
+}
+
+if (WRITE) {
+  await writeFile(TARGET, result, 'utf8');
+  console.log('\nwritten. Re-run the frontend suite and the build before committing.');
+} else if (dead.size > 0) {
+  console.log('\n(report only; pass --write to apply)');
+}
diff --git a/scripts/sync-chapters.mjs b/scripts/sync-chapters.mjs
index f95f233..e794da1 100644
--- a/scripts/sync-chapters.mjs
+++ b/scripts/sync-chapters.mjs
@@ -33,7 +33,7 @@ const CHAPTER_META = {
   1:  { name: 'Basic Electrical & Electronics',                        shortName: 'Basic Electrical & Electronics',                        description: "Ohm's Law, circuit analysis, AC/DC circuits and electronic components",        icon: 'chip',       color: '#f59e0b' },
   2:  { name: 'Digital Logic & Number Systems',                        shortName: 'Digital Logic & Number Systems',                        description: 'Number systems, Boolean algebra, logic gates and digital electronics',         icon: 'chip',       color: '#6366f1' },
   3:  { name: 'C / C++ Programming',                                   shortName: 'C / C++ Programming',                                   description: 'C and C++ fundamentals, pointers, data types and OOP concepts',                icon: 'code',       color: '#22c55e' },
-  4:  { name: 'Operating Systems & DBMS',                              shortName: 'Operating Systems & DBMS',                              description: 'OS process management, memory, databases and algorithms',                      icon: 'database',   color: '#ec4899' },
+  4:  { name: 'Computer Organization & Embedded Systems',             shortName: 'Computer Organization & Embedded',                       description: 'CPU architecture, cache, memory hierarchy, RISC/CISC and embedded systems',    icon: 'cpu',        color: '#ec4899' },
   5:  { name: 'Computer Networks & Security',                          shortName: 'Computer Networks & Security',                          description: 'Network protocols, OSI model and network security concepts',                   icon: 'brain',      color: '#06b6d4' },
   6:  { name: 'Theory of Computation and Computer Graphics',           shortName: 'Theory of Computation and Computer Graphics',           description: 'Finite automata, CFGs, Turing machines, 2D/3D transformations and graphics',   icon: 'network',    color: '#a855f7' },
   7:  { name: 'DSA, DBMS and OS',                                      shortName: 'DSA, DBMS and OS',                                      description: 'Data structures, algorithms, database systems and operating systems',          icon: 'monitor',    color: '#f97316' },
diff --git a/scripts/ts-resolve.mjs b/scripts/ts-resolve.mjs
new file mode 100644
index 0000000..3a5df9e
--- /dev/null
+++ b/scripts/ts-resolve.mjs
@@ -0,0 +1,55 @@
+/**
+ * Let Node import the app's TypeScript modules by their extensionless
+ * specifiers.
+ *
+ *   node --import ./scripts/ts-resolve.mjs scripts/<something>.mjs
+ *
+ * WHY
+ * ---
+ * Node >= 22.18 strips TypeScript types natively, so a script can import
+ * `frontend/src/**` directly and share one implementation with the app rather
+ * than keeping a mirrored copy that drifts. What Node will not do is guess
+ * extensions: the app writes `import { x } from '../data/syllabus'` — correct
+ * under Vite and `moduleResolution: "bundler"` — and Node raises
+ * ERR_MODULE_NOT_FOUND because no such file exists.
+ *
+ * The alternative was to write `'../data/syllabus.ts'` in the app source
+ * (tsconfig already sets `allowImportingTsExtensions`), but that bends app code
+ * around a build script and would have to be repeated for every module a script
+ * ever reaches. A resolve hook fixes it once, outside the app.
+ *
+ * SCOPE
+ * -----
+ * Only relative specifiers with no extension are retried, and only with `.ts`
+ * then `.tsx`, then `/index.ts`. Anything else — bare package names, explicit
+ * extensions, absolute URLs — is handed straight back to the default resolver,
+ * so a genuinely missing module still fails as a missing module.
+ */
+
+import { registerHooks } from 'node:module';
+
+const RETRY_SUFFIXES = ['.ts', '.tsx', '/index.ts', '/index.tsx'];
+
+/** Relative, and no extension of any kind on the final segment. */
+function isExtensionlessRelative(specifier) {
+  if (!specifier.startsWith('./') && !specifier.startsWith('../')) return false;
+  const lastSegment = specifier.slice(specifier.lastIndexOf('/') + 1);
+  return !lastSegment.includes('.');
+}
+
+registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (!isExtensionlessRelative(specifier)) {
+      return nextResolve(specifier, context);
+    }
+    for (const suffix of RETRY_SUFFIXES) {
+      try {
+        return nextResolve(specifier + suffix, context);
+      } catch {
+        // Try the next candidate. The original error is re-raised below if
+        // none of them resolve, so a real typo is still reported as a typo.
+      }
+    }
+    return nextResolve(specifier, context);
+  },
+});
diff --git a/scripts/validate-questions.mjs b/scripts/validate-questions.mjs
new file mode 100644
index 0000000..34ddd49
--- /dev/null
+++ b/scripts/validate-questions.mjs
@@ -0,0 +1,500 @@
+#!/usr/bin/env node
+/**
+ * validate-questions.mjs
+ *
+ * Quality gate for the question bank in frontend/public/data/books/.
+ *
+ * The bank is authored as a spreadsheet-shaped JSON array:
+ *   { qsns, opt1..opt4, correct_option, correct_option_index }
+ * with `correct_option_index` 1-based. Nothing has ever checked it, which is
+ * how the live bank came to contain answer keys that disagree with themselves,
+ * indices pointing past the last option, and a correct-answer position so
+ * skewed that guessing "option 2" scores well above chance.
+ *
+ * Usage:
+ *   node scripts/validate-questions.mjs            # human report
+ *   node scripts/validate-questions.mjs --json     # machine report
+ *   node scripts/validate-questions.mjs --csv out.csv
+ *   node scripts/validate-questions.mjs --strict   # also fail on warnings
+ *   node scripts/validate-questions.mjs --check-ids # only: quarantine ids in range
+ *
+ * Exit codes: 0 clean, 1 errors found, 2 could not run.
+ */
+
+import { readFileSync, writeFileSync, readdirSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// Imported directly from the app so there is exactly one implementation of
+// option ordering. Node >= 22.18 strips the TypeScript types natively, which
+// is why CI pins Node 22. A mirrored copy here drifted from the app once and
+// would have gone unnoticed.
+import {
+  assignOptionOrders,
+  attainableWorstShare,
+} from '../frontend/src/services/optionOrdering.ts';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const DATA_DIR = join(ROOT, 'frontend', 'public', 'data', 'books');
+const QUARANTINE_FILE = join(ROOT, 'frontend', 'src', 'data', 'quarantine.json');
+
+/**
+ * Questions already known to be broken and withheld from practice. Their errors
+ * are reported separately so the gate stays green on a known baseline while any
+ * newly introduced bad question fails the build.
+ */
+const quarantined = new Map();
+if (existsSync(QUARANTINE_FILE)) {
+  for (const entry of JSON.parse(readFileSync(QUARANTINE_FILE, 'utf8'))) {
+    quarantined.set(entry.id, entry);
+  }
+}
+const topicIdFor = (file) => 'book-' + file.replace('.json', '');
+const qidFor = (file, idx) => `${topicIdFor(file)}_${idx}`;
+
+const REQUIRED = ['qsns', 'opt1', 'opt2', 'opt3', 'opt4', 'correct_option', 'correct_option_index'];
+const OPT_KEYS = ['opt1', 'opt2', 'opt3', 'opt4'];
+
+// Options whose meaning depends on being last. They must never be shuffled
+// into another slot, and they must not all pile into one position.
+const POSITIONAL_RE = /^\s*(all|none|both)\s+(of\s+)?(the\s+)?(above|these|mentioned)/i;
+
+/** Normalised stem, for duplicate detection. */
+const normStem = (s) => String(s).toLowerCase().replace(/\s+/g, ' ').replace(/[^\w\s?]/g, '').trim();
+
+// --- Collect ----------------------------------------------------------------
+
+if (!existsSync(DATA_DIR)) {
+  console.error(`Data directory not found: ${DATA_DIR}`);
+  process.exit(2);
+}
+
+const files = readdirSync(DATA_DIR)
+  .filter((f) => f.endsWith('.json'))
+  .sort((a, b) => {
+    const na = Number(a.match(/\d+/)?.[0] ?? 0);
+    const nb = Number(b.match(/\d+/)?.[0] ?? 0);
+    return na - nb || a.localeCompare(b);
+  });
+
+if (files.length === 0) {
+  console.error(`No JSON files in ${DATA_DIR}`);
+  process.exit(2);
+}
+
+const errors = [];      // block the build
+const warnings = [];    // report, do not block unless --strict
+const quarantinedFindings = []; // known-bad rows already withheld from practice
+const stemIndex = new Map(); // normalised stem -> [{file, idx}]
+const positionHistogram = [0, 0, 0, 0, 0, 0, 0];       // 1-based index -> count, as authored
+const shuffledHistogram = [0, 0, 0, 0, 0, 0, 0];      // after orderOptions()
+const perFile = [];
+
+const err = (file, idx, code, message, extra = {}) => {
+  const finding = { file, idx, code, message, ...extra };
+  // A row on the quarantine list is a logged, reviewed decision. Reporting it as
+  // a build error every run would make the gate permanently red and therefore
+  // useless for catching the next bad question.
+  if (idx >= 0 && quarantined.has(qidFor(file, idx))) quarantinedFindings.push(finding);
+  else errors.push(finding);
+};
+const warn = (file, idx, code, message, extra = {}) =>
+  warnings.push({ file, idx, code, message, ...extra });
+
+for (const file of files) {
+  let rows;
+  try {
+    rows = JSON.parse(readFileSync(join(DATA_DIR, file), 'utf8'));
+  } catch (e) {
+    err(file, -1, 'PARSE', `Not valid JSON: ${e.message}`);
+    continue;
+  }
+  if (!Array.isArray(rows)) {
+    err(file, -1, 'SHAPE', 'Top level must be a JSON array of question objects');
+    continue;
+  }
+
+  const filePositions = [0, 0, 0, 0, 0, 0, 0];
+  const fileShuffled = [0, 0, 0, 0, 0, 0, 0];
+  // Questions a student can actually be served, in the exact shape the loader
+  // passes to assignOptionOrders(). Ordering is decided per chapter, so it is
+  // computed after the row loop rather than inside it.
+  const orderable = [];
+  let positionalCount = 0;
+
+  rows.forEach((q, idx) => {
+    // -- required fields ---------------------------------------------------
+    const missing = REQUIRED.filter((k) => !(k in (q ?? {})));
+    if (missing.length) {
+      err(file, idx, 'MISSING_FIELD', `Missing field(s): ${missing.join(', ')}`);
+      return;
+    }
+
+    // -- option sanity -----------------------------------------------------
+    const opts = OPT_KEYS.map((k) => q[k]);
+    opts.forEach((o, i) => {
+      if (typeof o !== 'string') err(file, idx, 'OPTION_TYPE', `${OPT_KEYS[i]} is not a string`);
+      else if (!o.trim()) err(file, idx, 'OPTION_EMPTY', `${OPT_KEYS[i]} is empty`);
+    });
+
+    const seen = new Map();
+    opts.forEach((o, i) => {
+      if (typeof o !== 'string') return;
+      const key = o.trim().toLowerCase();
+      if (seen.has(key)) {
+        err(file, idx, 'OPTION_DUPLICATE',
+          `${OPT_KEYS[seen.get(key)]} and ${OPT_KEYS[i]} are both "${o.trim()}" - two options can be simultaneously correct`);
+      } else {
+        seen.set(key, i);
+      }
+    });
+
+    if (typeof q.qsns !== 'string' || !q.qsns.trim()) {
+      err(file, idx, 'STEM_EMPTY', 'Question stem is empty');
+      return;
+    }
+
+    // -- the answer key ----------------------------------------------------
+    const ix = q.correct_option_index;
+    if (!Number.isInteger(ix)) {
+      err(file, idx, 'INDEX_TYPE', `correct_option_index is not an integer (got ${JSON.stringify(ix)})`);
+    } else if (ix < 1 || ix > OPT_KEYS.length) {
+      err(file, idx, 'INDEX_RANGE',
+        `correct_option_index is ${ix} but there are only ${OPT_KEYS.length} options - this question is unanswerable`,
+        { stem: q.qsns.slice(0, 80) });
+    } else {
+      const keyed = opts[ix - 1];
+      const stated = typeof q.correct_option === 'string' ? q.correct_option.trim() : '';
+      if (stated && typeof keyed === 'string' && stated !== keyed.trim()) {
+        const presentAt = opts.findIndex((o) => typeof o === 'string' && o.trim() === stated);
+        err(file, idx, 'KEY_CONFLICT',
+          `correct_option_index ${ix} points at "${keyed}" but correct_option says "${stated}"` +
+          (presentAt === -1
+            ? ' - and that text is not among the options at all'
+            : ` (which is ${OPT_KEYS[presentAt]})`),
+          { stem: q.qsns.slice(0, 80), keyed, stated, statedAt: presentAt + 1 || null });
+      }
+      if (!stated) {
+        warn(file, idx, 'KEY_MISSING_TEXT', 'correct_option is empty; only the index identifies the answer');
+      }
+      filePositions[ix]++;
+      positionHistogram[ix]++;
+
+      // Quarantined rows never reach a student, so they must not count toward
+      // the distribution the student actually experiences.
+      if (!quarantined.has(qidFor(file, idx))) {
+        orderable.push({
+          id: qidFor(file, idx),
+          options: opts.filter(Boolean),
+          correctIndex: ix - 1,
+        });
+      }
+    }
+
+    // -- positional options ------------------------------------------------
+    opts.forEach((o, i) => {
+      if (typeof o === 'string' && POSITIONAL_RE.test(o)) {
+        positionalCount++;
+        if (i !== OPT_KEYS.length - 1) {
+          warn(file, idx, 'POSITIONAL_NOT_LAST',
+            `"${o.trim()}" is in ${OPT_KEYS[i]}; options of this kind must be pinned last when shuffling`);
+        }
+      }
+    });
+
+    // -- truncation / authoring smells -------------------------------------
+    const stem = q.qsns.trim();
+    if (/\.\.\.$|…$/.test(stem)) {
+      warn(file, idx, 'STEM_TRUNCATED', `Stem ends in an ellipsis: "${stem.slice(-50)}"`);
+    }
+    if (stem.length < 15) {
+      warn(file, idx, 'STEM_SHORT', `Stem is only ${stem.length} chars: "${stem}"`);
+    }
+
+    // -- duplicates --------------------------------------------------------
+    const key = normStem(stem);
+    if (!stemIndex.has(key)) stemIndex.set(key, []);
+    stemIndex.get(key).push({ file, idx, stem: stem.slice(0, 90) });
+  });
+
+  // Order the whole chapter at once - exactly what the loader does - and tally
+  // the slot each correct answer actually lands in.
+  for (const { correctIndex } of assignOptionOrders(orderable)) {
+    if (correctIndex >= 0 && correctIndex < OPT_KEYS.length) {
+      fileShuffled[correctIndex + 1]++;
+      shuffledHistogram[correctIndex + 1]++;
+    }
+  }
+
+  perFile.push({
+    file,
+    rows: rows.length,
+    positions: filePositions,
+    shuffled: fileShuffled,
+    attainableWorstPct: attainableWorstShare(orderable) * 100,
+    positionalCount,
+  });
+}
+
+// --- Quarantine id integrity ------------------------------------------------
+
+/**
+ * Quarantine ids are `{topicId}_{arrayIndex}`, so they are tied to array
+ * position: deleting or inserting a row in a chapter JSON silently re-points
+ * every id after it. The failure is invisible and inverted - the loader
+ * withholds an innocent question and serves the broken one it was meant to
+ * withhold. So the list is checked against the files on every run, and
+ * `--check-ids` reports it on its own for a fast CI gate.
+ */
+const rowCountByTopic = new Map(perFile.map((f) => [topicIdFor(f.file), f.rows]));
+const fileByTopic = new Map(perFile.map((f) => [topicIdFor(f.file), f.file]));
+const quarantineIdErrors = [];
+
+for (const id of quarantined.keys()) {
+  const m = /^(.+)_(\d+)$/.exec(id);
+  if (!m) {
+    quarantineIdErrors.push({
+      file: QUARANTINE_FILE.replace(ROOT + '/', ''), idx: -1, id,
+      code: 'QUARANTINE_ID_MALFORMED',
+      message: `Quarantine id "${id}" is not of the form {topicId}_{arrayIndex}`,
+    });
+    continue;
+  }
+  const [, topicId, idxStr] = m;
+  const idx = Number(idxStr);
+  if (!rowCountByTopic.has(topicId)) {
+    quarantineIdErrors.push({
+      file: QUARANTINE_FILE.replace(ROOT + '/', ''), idx: -1, id,
+      code: 'QUARANTINE_ID_UNKNOWN_TOPIC',
+      message: `Quarantine id "${id}" names topic "${topicId}", but no such file exists in ${
+        DATA_DIR.replace(ROOT + '/', '')}`,
+    });
+  } else if (idx >= rowCountByTopic.get(topicId)) {
+    quarantineIdErrors.push({
+      file: fileByTopic.get(topicId), idx: -1, id,
+      code: 'QUARANTINE_ID_OUT_OF_RANGE',
+      message: `Quarantine id "${id}" points at index ${idx}, but ${
+        fileByTopic.get(topicId)} has only ${rowCountByTopic.get(topicId)} rows (0-${
+        rowCountByTopic.get(topicId) - 1}). The question bank was edited without regenerating the list, ` +
+        `so every id at or after the edit now withholds the wrong question.`,
+    });
+  }
+}
+errors.push(...quarantineIdErrors);
+
+// --- Duplicates -------------------------------------------------------------
+
+const dupGroups = [...stemIndex.entries()].filter(([, v]) => v.length > 1);
+const dupRows = dupGroups.reduce((n, [, v]) => n + v.length - 1, 0);
+const crossFileGroups = dupGroups.filter(([, v]) => new Set(v.map((x) => x.file)).size > 1);
+
+for (const [, group] of dupGroups) {
+  const where = group.map((g) => `${g.file}[${g.idx}]`).join(' ');
+  warn(group[0].file, group[0].idx, 'DUPLICATE_STEM',
+    `Appears ${group.length}x: ${where} - "${group[0].stem}"`);
+}
+
+// --- Answer-position bias ---------------------------------------------------
+
+/** Chi-square against a uniform distribution over the 4 option slots. */
+function chiSquare(counts) {
+  const obs = counts.slice(1, 5);
+  const n = obs.reduce((a, b) => a + b, 0);
+  if (n === 0) return { chi2: 0, n: 0, df: 3 };
+  const expected = n / obs.length;
+  const chi2 = obs.reduce((acc, o) => acc + (o - expected) ** 2 / expected, 0);
+  return { chi2, n, df: obs.length - 1 };
+}
+
+const overall = chiSquare(positionHistogram);
+const overallShuffled = chiSquare(shuffledHistogram);
+// Critical values for df=3: p<.05 = 7.81, p<.01 = 11.34, p<.001 = 16.27
+const BIAS_CRITICAL = 16.27;
+const biasFindings = [];
+
+// The gate measures the distribution a student is shown, after orderOptions().
+// Gating on the authored distribution would be permanently red and would push
+// toward re-authoring 2,801 questions to fix something the loader already
+// neutralises. Raw skew is still reported, because it signals how the content
+// was produced and only the loader is holding it in check.
+for (const f of perFile) {
+  const raw = chiSquare(f.positions);
+  const shown = chiSquare(f.shuffled);
+  const rawPct = f.positions.slice(1, 5).map((c) => (raw.n ? (c / raw.n) * 100 : 0));
+  const shownPct = f.shuffled.slice(1, 5).map((c) => (shown.n ? (c / shown.n) * 100 : 0));
+  const worst = Math.max(...shownPct, 0);
+  const worstSlot = shownPct.indexOf(worst) + 1;
+
+  // Lower bound on what any ordering could achieve for this file, given the
+  // options it pins last. Optimistic - see attainableWorstShare().
+  const floorWorst = f.attainableWorstPct ?? 25;
+
+  biasFindings.push({
+    file: f.file,
+    rawN: raw.n, rawChi2: raw.chi2, rawPct,
+    shownN: shown.n, shownChi2: shown.chi2, shownPct,
+    worst, worstSlot,
+    attainableWorst: floorWorst,
+  });
+
+  if (shown.n >= 100 && worst >= 32) {
+    err(f.file, -1, 'ANSWER_POSITION_BIAS',
+      `After option ordering, option ${worstSlot} is still the answer in ${worst.toFixed(1)}% of ` +
+      `${shown.n} questions (chi2=${shown.chi2.toFixed(1)}; uniform is 25%). ` +
+      `No ordering of these same questions could beat a worst slot of ` +
+      `${floorWorst.toFixed(1)}%, ` +
+      (floorWorst >= 32
+        ? `so this file cannot pass while ${f.positionalCount} options are pinned last - the content, not the loader, has to change.`
+        : `so the gate is reachable: the ordering seed is landing badly, not hitting a structural limit.`));
+  }
+  if (raw.n >= 30 && raw.chi2 > BIAS_CRITICAL) {
+    warn(f.file, -1, 'ANSWER_POSITION_SKEW_AS_AUTHORED',
+      `As authored, answer positions are non-uniform (chi2=${raw.chi2.toFixed(1)}, p<0.001): ` +
+      `${rawPct.map((x) => x.toFixed(0) + '%').join(' / ')}. ` +
+      `Neutralised at load time to ${shownPct.map((x) => x.toFixed(0) + '%').join(' / ')} ` +
+      `(chi2=${shown.chi2.toFixed(1)}).`);
+  }
+}
+
+// --- Report -----------------------------------------------------------------
+
+const args = process.argv.slice(2);
+const totalRows = perFile.reduce((n, f) => n + f.rows, 0);
+
+if (args.includes('--check-ids')) {
+  console.log(`\n  Quarantine id check - ${QUARANTINE_FILE.replace(ROOT + '/', '')}\n`);
+  if (!existsSync(QUARANTINE_FILE)) {
+    console.log('  No quarantine file; nothing to check.\n');
+    process.exit(0);
+  }
+  const byTopic = new Map();
+  for (const id of quarantined.keys()) {
+    const topicId = /^(.+)_(\d+)$/.exec(id)?.[1] ?? '(malformed)';
+    if (!byTopic.has(topicId)) byTopic.set(topicId, []);
+    byTopic.get(topicId).push(id);
+  }
+  console.log(`  ${'topic'.padEnd(12)} ${'ids'.padStart(5)} ${'rows'.padStart(6)}   max index used`);
+  for (const [topicId, ids] of [...byTopic.entries()].sort()) {
+    const rows = rowCountByTopic.get(topicId);
+    const maxIdx = Math.max(...ids.map((id) => Number(/_(\d+)$/.exec(id)?.[1] ?? -1)));
+    console.log(`  ${topicId.padEnd(12)} ${String(ids.length).padStart(5)} ` +
+                `${String(rows ?? '-').padStart(6)}   ${maxIdx}` +
+                (rows === undefined ? '  <- no such file' : maxIdx >= rows ? '  <- OUT OF RANGE' : ''));
+  }
+  if (quarantineIdErrors.length) {
+    console.log(`\n  ${quarantineIdErrors.length} bad id(s):`);
+    for (const e of quarantineIdErrors) console.log(`    ${e.code}  ${e.message}`);
+    console.log('\n  Regenerate the list against the current files before shipping.\n');
+  } else {
+    console.log(`\n  All ${quarantined.size} quarantine id(s) are in range for their chapter file.\n`);
+  }
+  process.exit(quarantineIdErrors.length ? 1 : 0);
+}
+const byCode = (list) => list.reduce((m, e) => ((m[e.code] = (m[e.code] || 0) + 1), m), {});
+
+const summary = {
+  files: perFile.length,
+  totalRows,
+  uniqueStems: stemIndex.size,
+  duplicateRows: dupRows,
+  duplicateGroups: dupGroups.length,
+  crossFileDuplicateGroups: crossFileGroups.length,
+  positionHistogram: positionHistogram.slice(1, 6),
+  shuffledHistogram: shuffledHistogram.slice(1, 6),
+  overallChi2: Number(overall.chi2.toFixed(2)),
+  overallChi2AfterOrdering: Number(overallShuffled.chi2.toFixed(2)),
+  quarantined: quarantined.size,
+  quarantinedFindings: quarantinedFindings.length,
+  quarantineIdErrors: quarantineIdErrors.length,
+  positionalOptions: perFile.reduce((n, f) => n + f.positionalCount, 0),
+  errors: errors.length,
+  warnings: warnings.length,
+  errorsByCode: byCode(errors),
+  warningsByCode: byCode(warnings),
+};
+
+if (args.includes('--json')) {
+  console.log(JSON.stringify(
+    { summary, errors, warnings, quarantinedFindings, perFile, biasFindings }, null, 2));
+} else {
+  const bar = (n, max, width = 40) => '#'.repeat(Math.max(0, Math.round((n / (max || 1)) * width)));
+
+  console.log(`\n  Question bank validation - ${DATA_DIR.replace(ROOT + '/', '')}\n`);
+  console.log(`  ${'file'.padEnd(12)} ${'rows'.padStart(6)}   as authored 1/2/3/4        as shown 1/2/3/4`);
+  for (const f of perFile) {
+    const fmt = (counts) => {
+      const n = counts.slice(1, 5).reduce((a, b) => a + b, 0);
+      return counts.slice(1, 5)
+        .map((c) => (n ? ((c / n) * 100).toFixed(0).padStart(3) + '%' : '   - '))
+        .join(' ');
+    };
+    console.log(`  ${f.file.padEnd(12)} ${String(f.rows).padStart(6)}   ${fmt(f.positions)}    ${fmt(f.shuffled)}`);
+  }
+  console.log(`  ${'TOTAL'.padEnd(12)} ${String(totalRows).padStart(6)}`);
+
+  const maxPos = Math.max(...positionHistogram.slice(1, 5));
+  console.log(`\n  Answer-position distribution across the whole bank:`);
+  for (let i = 1; i <= 4; i++) {
+    const c = positionHistogram[i];
+    const pct = overall.n ? ((c / overall.n) * 100).toFixed(1) : '0.0';
+    console.log(`    option ${i}: ${String(c).padStart(5)}  ${pct.padStart(5)}%  ${bar(c, maxPos)}`);
+  }
+  console.log(`    chi-square as authored: ${overall.chi2.toFixed(1)} on ${overall.df} df` +
+              ` | after option ordering: ${overallShuffled.chi2.toFixed(1)}` +
+              ` (uniform expects ~0; p<0.05 above 7.81, p<0.001 above ${BIAS_CRITICAL})`);
+
+  console.log(`\n  Duplicates: ${dupRows} redundant rows in ${dupGroups.length} groups ` +
+              `(${crossFileGroups.length} span more than one file). ` +
+              `${stemIndex.size} unique stems of ${totalRows}.`);
+  console.log(`  Positional options ("all of the above" and similar): ${summary.positionalOptions}`);
+
+  const show = (list, label, limit) => {
+    if (!list.length) return;
+    console.log(`\n  ${label} (${list.length}):`);
+    const counts = byCode(list);
+    for (const [code, n] of Object.entries(counts).sort((a, b) => b[1] - a[1])) {
+      console.log(`    ${String(n).padStart(5)}  ${code}`);
+    }
+    console.log('');
+    for (const e of list.slice(0, limit)) {
+      const at = e.idx >= 0 ? `${e.file}[${e.idx}]` : e.file;
+      console.log(`    ${at}  ${e.code}\n        ${e.message}`);
+    }
+    if (list.length > limit) console.log(`    ... and ${list.length - limit} more (use --json for all)`);
+  };
+
+  show(errors, 'ERRORS - these block the build', 40);
+
+  if (quarantinedFindings.length) {
+    console.log(`\n  QUARANTINED (${quarantinedFindings.length} findings across ${quarantined.size} questions):`);
+    console.log(`    Already withheld from practice via frontend/src/data/quarantine.json.`);
+    console.log(`    These do not block the build. Fix the rows, then remove their ids from that file.`);
+    const codes = byCode(quarantinedFindings);
+    for (const [code, n] of Object.entries(codes).sort((a, b) => b[1] - a[1])) {
+      console.log(`    ${String(n).padStart(5)}  ${code}`);
+    }
+  }
+  show(warnings.filter((w) => w.code !== 'DUPLICATE_STEM'), 'WARNINGS', 15);
+
+  if (dupGroups.length) {
+    console.log(`\n  Worst duplicate groups:`);
+    for (const d of [...dupGroups].sort((a, b) => b[1].length - a[1].length).slice(0, 5)) {
+      console.log(`    x${d[1].length}  ${d[1].map((g) => `${g.file}[${g.idx}]`).join(' ')}\n        "${d[1][0].stem}"`);
+    }
+  }
+
+  console.log(`\n  ${errors.length} error(s), ${warnings.length} warning(s), ` +
+              `${quarantinedFindings.length} finding(s) on quarantined questions\n`);
+}
+
+const csvArg = args.indexOf('--csv');
+if (csvArg !== -1 && args[csvArg + 1]) {
+  const esc = (v) => `"${String(v ?? '').replace(/"/g, '""')}"`;
+  const lines = ['severity,file,index,code,message'];
+  for (const e of errors) lines.push(['error', e.file, e.idx, e.code, e.message].map(esc).join(','));
+  for (const w of warnings) lines.push(['warning', w.file, w.idx, w.code, w.message].map(esc).join(','));
+  writeFileSync(args[csvArg + 1], lines.join('\n') + '\n');
+  console.error(`  triage CSV written to ${args[csvArg + 1]}`);
+}
+
+const failed = errors.length > 0 || (args.includes('--strict') && warnings.length > 0);
+process.exit(failed ? 1 : 0);
diff --git a/worker/.dev.vars.example b/worker/.dev.vars.example
new file mode 100644
index 0000000..0fa749d
--- /dev/null
+++ b/worker/.dev.vars.example
@@ -0,0 +1,36 @@
+# Local secrets for `wrangler dev`. Copy to `.dev.vars` and fill in.
+#
+#   cp .dev.vars.example .dev.vars
+#
+# `.dev.vars` is gitignored. Wrangler reads it and puts these on `env` exactly
+# the way deployed secrets arrive, so the code path you exercise locally is the
+# same one that runs in production — there is no "dev mode" branch anywhere.
+#
+# These are LOCAL values. Nothing here is uploaded, and `wrangler secret put`
+# does not read this file. Production secrets are set separately; see
+# docs/deploy-cloudflare.md step 3.
+
+# Required. Seeds the option shuffle. Any 32+ characters will do locally —
+# it only has to be unguessable in production, where it protects the
+# permutation from being reproduced offline against the public chapter JSON.
+CONTENT_PERMUTATION_SECRET=local-development-only-not-a-real-secret-0123456789
+
+# Optional: Google sign-in. All three or none — a half-configured OAuth app
+# fails at Google with redirect_uri_mismatch, which is a confusing place to
+# debug a missing variable. Leave them blank and the two Google routes 404
+# while email/password and guest keep working.
+#
+# The redirect URI must ALSO be listed on the OAuth client in Google Cloud
+# Console, alongside the production one. Google permits http://localhost as an
+# explicit exception to its HTTPS rule, which is what makes local testing of
+# the real flow possible:
+#
+#   http://localhost:8787/api/auth/google/callback
+#
+# Use the SAME client as production, with two redirect URIs. A second client
+# means a second secret to rotate and a second consent screen to keep in step.
+# Leave all three commented out until you have all three. Filling in only the
+# redirect URI is the half-configured state, and the Google routes will say so.
+#GOOGLE_CLIENT_ID=
+#GOOGLE_CLIENT_SECRET=
+#GOOGLE_REDIRECT_URI=http://localhost:8787/api/auth/google/callback
diff --git a/worker/.gitignore b/worker/.gitignore
new file mode 100644
index 0000000..6ecbd00
--- /dev/null
+++ b/worker/.gitignore
@@ -0,0 +1,13 @@
+# Local SQLite databases built by db/apply.mjs, db/seed/*, db/measure.mjs.
+# Disposable: `npm run db:check` recreates them from migrations/ and the
+# question bank in one command, so there is nothing here worth committing.
+.local/
+
+# Miniflare / wrangler local state, including the local D1 database that
+# `wrangler d1 migrations apply --local` writes to.
+.wrangler/
+
+# Drizzle tooling output. Nothing here is the source of truth -- the SQL in
+# migrations/ is (see db/schema.ts), and a generated migration would silently
+# drop STRICT, the triggers and the FTS5 table.
+drizzle/
diff --git a/worker/README.md b/worker/README.md
new file mode 100644
index 0000000..803a838
--- /dev/null
+++ b/worker/README.md
@@ -0,0 +1,681 @@
+# NECPrep API — Cloudflare Worker + D1
+
+The backend for NECPrep. Why D1 and not Supabase:
+[`docs/adr/0001-cloudflare-d1-over-supabase.md`](../docs/adr/0001-cloudflare-d1-over-supabase.md).
+
+```
+worker/
+  wrangler.toml            Worker + D1 bindings, vars, cron triggers
+  migrations/              THE SCHEMA. Source of truth. Applied in order.
+  db/
+    schema.ts              Drizzle definitions — typed client, NOT a DDL generator
+    apply.mjs              apply every migration to a local SQLite file
+    verify-schema.mjs      prove schema.ts and migrations/*.sql agree
+    smoke.mjs              exercise the schema the way the API will
+    measure.mjs            measure bytes/row and derive the D1 ceiling
+    seed/
+      import-questions.mjs       load the 10 chapter JSONs into the bank
+      generate-reference-sql.mjs regenerate 0007 from the frontend syllabus files
+  src/                     API handlers — reconciled with the schema, see below
+  tsconfig.json            typechecks src/** and db/schema.ts together
+```
+
+## Quick start
+
+```bash
+cd worker
+npm install
+npm run db:check     # apply + seed + verify + smoke + typecheck, from scratch
+```
+
+`db:check` must pass before any schema change is proposed. It is the whole
+contract in one command:
+
+| step | what it proves |
+|---|---|
+| `db:apply:local` | all 8 migrations apply in order, FKs on, integrity clean |
+| `db:seed:local` | the question bank imports; no published question lacks an answer key |
+| `db:verify` | `db/schema.ts` and `migrations/*.sql` describe the same database |
+| `db:smoke` | 72 assertions: grading, rollups, permutation, archival safety, the millisecond round trip, and that no option id encodes its ordinal |
+| `typecheck` | `src/**` and `db/schema.ts` compile under `--strict` |
+
+And the API half, which runs against these exact migrations:
+
+```bash
+npm test            # 89 assertions, node --test, no network
+npm run bundle:check  # the Worker actually bundles
+npm run check       # all of it
+```
+
+Against wrangler's own D1 runner (Miniflare, no network, no account):
+
+```bash
+npm run d1:migrate:local
+```
+
+Last verified run: 8 migrations applied, **32 tables + 1 view + 1 FTS5 virtual
+table, 71 indexes, 11 triggers**, 1 subject, 10 chapters, 60 subchapters,
+3 mock templates; seed wrote **2,290 questions / 9,160 options / 2,290 answer
+keys / 106 errata reports** (2,199 published, 91 flagged); 72/72 smoke
+assertions pass; 332 columns, 71 indexes, 51 foreign keys and 36 enums verified
+identical between SQL and TS; 89/89 API assertions pass against these
+migrations; the Worker bundles at 980 KiB / 170 KiB gzipped.
+
+Those seed counts differ from an earlier revision of this file (2,190 published
+/ 100 flagged / 2,289 keys / 125 reports). The bank changed, not the importer:
+commit 652bd10 applied the adjudicated answer keys and rewrote
+`frontend/src/data/quarantine.json` from 145 entries to 118. `INDEX_RANGE` is
+now zero, which is why there is a key for every question.
+
+## The one rule
+
+> **`question_answer_keys` is server-only. It must not appear in any query
+> whose result can reach a client before that client's attempt is submitted.**
+
+D1 has no row-level security — SQLite has none — so this cannot be a database
+rule. It is enforced structurally instead:
+
+- `questions` has **no** correct-answer column.
+- `question_options` has **no** `is_correct` column.
+- The key exists **only** in `question_answer_keys`, one row per question.
+- `v_question_delivery` is what the delivery path reads. It cannot reference
+  the key table, so `SELECT *` over it is safe by construction.
+
+So leaking the key requires naming `question_answer_keys` in a `FROM` clause —
+a grep-able, reviewable, testable event. These are the only three queries
+allowed to do it. Copy them; do not improvise them.
+
+**NQ-10 grade-one** — an answer submitted mid-attempt. The response carries a
+boolean, never the key:
+
+```sql
+SELECT correct_option_id
+  FROM question_answer_keys
+ WHERE question_id = ?1;
+```
+
+**NQ-10b grade-batch** — attempt submit. One statement for the whole paper,
+because D1 allows 50 queries per Worker invocation and a 100-question mock
+graded one at a time would need 100:
+
+```sql
+SELECT question_id, correct_option_id
+  FROM question_answer_keys
+ WHERE question_id IN (SELECT value FROM json_each(?1));
+```
+
+**NQ-10c review-after-submit** — the only client-visible path, and only for an
+attempt that belongs to the caller and is already submitted. The `EXISTS`
+clause *is* the authorization; on a database with RLS it would be a policy, so
+here it must be in the query, every time:
+
+```sql
+SELECT aa.question_id, aa.selected_option_id, k.correct_option_id
+  FROM attempt_answers aa
+  JOIN question_answer_keys k ON k.question_id = aa.question_id
+ WHERE aa.attempt_id = ?1
+   AND EXISTS (SELECT 1 FROM attempts a
+                WHERE a.id = ?1 AND a.user_id = ?2
+                  AND a.status = 'submitted');
+```
+
+(`aa.selected_option_id` is the VIRTUAL generated column -- zero bytes on disk,
+`question_id || '#' || selected_opt_key` -- so this needs no concatenation and
+no join to `question_options`.)
+
+The API's test suite should assert that **no** response body on a pre-submit
+route ever contains an option id that is not in the delivered paper.
+
+### Why that is not enough on its own, and what closes the gap
+
+The question bank shipped as public JSON under `frontend/public/data/books/`
+and is in git history permanently. Anyone can reconstruct "question X's answer
+is the second option". Hiding the key server-side therefore only solves half
+the problem.
+
+The other half used to be carried entirely by per-attempt option permutation.
+It is not any more, because the id scheme itself was the leak: option ids were
+`question_id || '#' || ordinal`, so any id reaching a client recovered the key
+for a published question with no database access, and permutation was no
+defence because the ordinal travelled INSIDE the id. `question_options.id` is
+now `question_id || '#' || opt_key` with a 12-character CSPRNG key. Read the
+block above that table in `0002_content.sql`.
+
+Permutation still earns its place on top of that:
+
+- `attempt_questions.option_order` is a JSON array of **option ids** in the
+  order that attempt showed them. It is the server-side mapping between what
+  the student saw and what the database knows, and it is the only copy that
+  counts — the client's is a convenience.
+- `attempts.option_seed` reproduces the exact paper for a dispute, without
+  trusting the client's copy.
+- `attempt_answers` stores `selected_opt_key` (the stable, information-free
+  half of the option id) and exposes `selected_option_id` as a VIRTUAL
+  generated column, so an answer references a stable option id at zero storage
+  cost. `delivered_position` records where the option sat on screen and is
+  analytics only — never the grading key.
+- Options flagged `question_options.is_pinned` must stay last. All 450 "All of
+  the above"-style options in the bank were authored in slot 4, and shuffling
+  one into the middle makes the question nonsense.
+
+**Still do not deliver raw option ids to the browser**, even now that they
+carry no ordinal: an id is a stable handle a client could accumulate across
+sessions, and the cost of not sending it is zero. `worker/src/handlers/paper.ts`
+delivers each option as a keyed digest of (server secret, `option_seed`,
+attempt, option id) -- DERIVED, not stored, because `attempt_questions` is the
+second table to watch at scale and four stored tokens per row would add ~60
+bytes to every one of them for something the server can recompute. Resolution
+is four comparisons against `option_order`, server-side.
+
+Be precise about what this does and does not buy. For the 2,290 questions
+already published as JSON, the key is **irrecoverably public** — any client
+that can read a stem can look the answer up by text, and no server-side
+measure changes that. What the design does protect: no question authored from
+now on ever has its key exposed, and a delivered paper cannot be graded by
+position alone. The full argument is in the second block of
+`0004_assessment.sql`.
+
+Permutation also fixes a live fairness problem. Across the 2,190 published
+questions the authored correct option sits at slot 1/2/3/4 in 634/721/496/339 —
+32.9% at slot 2 against the 25% a fair bank would show, and worse per chapter.
+Unpermuted, a student can score well above chance by learning the tell.
+
+## Schema map
+
+| migration | tables |
+|---|---|
+| `0001_identity` | `users`, `user_profiles`, `sessions`, `oauth_accounts`, `oauth_states`, `admin_audit_log` |
+| `0002_content` | `subjects`, `chapters`, `subchapters`, `questions`, `question_options`, `question_answer_keys`, `v_question_delivery`, `explanations`, `tags`, `question_tags`, `question_reports`, `content_versions` |
+| `0003_search` | `questions_fts` (FTS5) + 6 maintenance triggers |
+| `0004_assessment` | `mock_test_templates`, `attempts`, `attempt_questions`, `attempt_answers`, `attempt_answers_archive` |
+| `0005_learning` | `bookmarks`, `srs_state`, `study_sessions`, `streaks`, `user_question_stats` + 5 rollup triggers |
+| `0006_engagement` | `leaderboard_snapshots`, `leaderboard_entries`, `notifications` |
+| `0007_reference_data` | the 1 subject, 10 chapters, 60 NEC syllabus codes, 3 mock templates |
+| `0008_api_infrastructure` | `idempotency_keys`, `rate_limits` |
+
+### Row-count expectations
+
+Bounded unless stated otherwise. "per user" is per *active* user.
+
+| table | growth | at 1,000 MAU | at 10,000 MAU |
+|---|---|---|---|
+| `users`, `user_profiles`, `streaks` | 1 per user | ~1 k each | ~10 k each |
+| `sessions` | 1–3 per user, swept | ~3 k | ~30 k |
+| `subjects` / `chapters` / `subchapters` | reference | 1 / 10 / 60 | same |
+| `questions` | editorial | 2,290 | 10 k–50 k |
+| `question_options` | ~4 per question | 9,160 | 40 k–200 k |
+| `question_answer_keys` | 1 per question | 2,289 | = questions |
+| `explanations` | 0–3 per question | → 2 k | → 50 k |
+| `tags` / `question_tags` | editorial | ~200 / ~8 k | ~500 / ~150 k |
+| `question_reports` | errata | 125 (seeded) | ~5 k |
+| `content_versions` | 1 per edit | ~5 k | ~100 k |
+| `mock_test_templates` | reference | 3 | ~20 |
+| `attempts` | ~10/user/month | ~120 k/yr | ~1.2 M/yr |
+| `attempt_questions` | ~25 per attempt | ~3 M/yr | ~30 M/yr |
+| **`attempt_answers`** | **unbounded — see archival** | **1.5 M live @ 90 d** | **15 M live @ 90 d** |
+| `bookmarks` | ~20 per user | ~20 k | ~200 k |
+| `srs_state` | 1 per (user, studied question) | ~300 k | ~3 M |
+| `study_sessions` | ~30/user/month | ~360 k/yr | ~3.6 M/yr |
+| `user_question_stats` | 1 per (user, seen question) | ~400 k | ~4 M |
+| `leaderboard_snapshots` / `_entries` | pruned to 30 days | ~400 / ~390 k | ~400 / ~3.9 M |
+| `notifications` | expiring | ~50 k | ~500 k |
+| `admin_audit_log` | privileged actions | ~2 k | ~20 k |
+| `oauth_accounts` | 0–1 per user | ~600 | ~6 k |
+| `oauth_states` | in-flight sign-ins, 10 min TTL | <100 | <1 k |
+| `idempotency_keys` | mutations per user, 7 d TTL | ~20 k | ~200 k |
+| `rate_limits` | buckets per window, swept hourly | <5 k | <50 k |
+
+`attempt_questions` deserves a note: it is bounded per attempt (one row per
+delivered question) but attempts accumulate, so at 10,000 MAU it is the
+*second* table to watch. It is far narrower than `attempt_answers` and is what
+makes a submitted attempt reviewable after archival has removed the raw
+answers, so it has a longer retention than they do — but it is not infinite,
+and the same batched-delete pattern applies.
+
+### The unbounded table and the archival plan
+
+Measured, not estimated (`npm run db:measure`, SQLite 3.54, 4 KB pages, all
+three indexes present, rollup triggers live):
+
+```
+attempt_answers (table b-tree)         56.2 bytes/row
+uq_attempt_answers_attempt_question    33.1
+idx_attempt_answers_answered_at        29.7
+idx_attempt_answers_question_correct   30.9
+                                      ------
+TOTAL                                 149.9 bytes/row      63% of it index
+```
+
+Up from 132.4, and both causes are deliberate: `answered_at` in milliseconds
+instead of seconds costs ~3 bytes in the row and ~4 more in the index keyed on
+it, and `selected_opt_key TEXT(12)` instead of `selected_ordinal INTEGER` costs
+the row 13.5. 13% fewer rows in the same database is what not having two
+incompatible time units, and not publishing the answer key in every option id,
+actually cost.
+
+Rest of the schema with the bank seeded: **5.9 MB** (1.0 MB of that is FTS5).
+So a 500 MB free D1 database holds **3,455,265** answer rows; a 10 GB paid one
+holds 71,572,735.
+
+| MAU | rows/month | row-writes/day | 90 d live | 180 d live | fits free 500 MB @ 90 d |
+|---|---|---|---|---|---|
+| 1,000 | 500 k | 66,667 | 1.5 M / 214 MB | 3.0 M / 429 MB | yes |
+| 2,000 | 1.0 M | 133,333 | 3.0 M / 429 MB | 6.0 M / 858 MB | yes |
+| 5,000 | 2.5 M | 333,333 | 7.5 M / 1.05 GB | 15 M / 2.09 GB | no |
+| 10,000 | 5.0 M | 666,667 | 15 M / 2.09 GB | 30 M / 4.19 GB | no |
+| 25,000 | 12.5 M | 1,666,667 | 37.5 M / 5.24 GB | 75 M / 10.5 GB | no |
+
+**The write cap binds before the storage cap.** D1 counts index rows as writes,
+so one answer is four row writes; the free plan's 100,000 row-writes-per-day
+allowance saturates around 1,500 MAU, while storage would tolerate 2,500.
+
+**Retention policy**
+
+- answers on a submitted attempt: **90 days** free / 180 paid
+  (`ANSWER_RETENTION_DAYS` in `wrangler.toml`)
+- answers on an abandoned or expired attempt: **7 days**
+- the `attempts` summary row: kept indefinitely (one row per sitting, ~120 B)
+
+**Why deleting is enough.** D1 exposes no `VACUUM`, so a delete does not shrink
+the file — but it frees the page for reuse. With a fixed retention window the
+live set is bounded, the file grows to about that size and then stays there.
+Without the job it grows forever and the first symptom is writes failing at the
+500 MB wall.
+
+**What is safe to delete.** Nothing user-visible depends on a raw answer row
+older than the review window: per-attempt score and counts live on `attempts`,
+per-question history on `user_question_stats`, scheduling on `srs_state`, and
+leaderboards are precomputed — all trigger- or cron-maintained. Deleting raw
+answers loses the question-by-question review of an *old* attempt and nothing
+else.
+
+**There is deliberately no `DELETE` trigger on `attempt_answers`.** Archival
+deletes millions of rows; a delete trigger that decremented the rollups would
+erase every student's entire progress history the first night the job ran.
+`db/smoke.mjs` asserts the trigger's absence.
+
+**The job** (nightly cron, batched because D1 allows 50 queries per invocation
+and one unbounded `DELETE` would blow both the per-query time limit and the
+daily write budget):
+
+```sql
+-- 1. stage, denormalising user_id because the attempt may be gone later.
+INSERT INTO attempt_answers_archive (id, attempt_id, user_id, question_id,
+                                     selected_opt_key, is_correct,
+                                     delivered_position, time_ms, answered_at)
+SELECT aa.id, aa.attempt_id, a.user_id, aa.question_id, aa.selected_opt_key,
+       aa.is_correct, aa.delivered_position, aa.time_ms, aa.answered_at
+  FROM attempt_answers aa JOIN attempts a ON a.id = aa.attempt_id
+ WHERE aa.answered_at < CAST(unixepoch('now', '-90 days') * 1000 AS INTEGER)
+   AND aa.id > ?1                       -- cursor, 0 on the first page
+ ORDER BY aa.id
+ LIMIT 5000;
+
+-- 2. drain to R2 as NDJSON, then stamp r2_object_key. THIS is the step that
+--    makes the archive an archive; the staging table is in the same database
+--    and frees no space on its own.
+
+-- 3. delete exactly the id range just staged.
+DELETE FROM attempt_answers
+ WHERE id BETWEEN ?1 AND ?2
+   AND answered_at < CAST(unixepoch('now', '-90 days') * 1000 AS INTEGER);
+
+-- 4. the short window for attempts nobody finished.
+DELETE FROM attempt_answers
+ WHERE attempt_id IN (SELECT id FROM attempts
+                       WHERE status IN ('abandoned', 'expired')
+                         AND started_at < CAST(unixepoch('now', '-7 days') * 1000 AS INTEGER)
+                       LIMIT 200);
+```
+
+After a large purge, compact the FTS index — it is the only compaction D1
+offers and it is cheap:
+
+```sql
+INSERT INTO questions_fts (questions_fts, rank) VALUES ('merge', -64);
+```
+
+## Named queries
+
+Every index in `migrations/` carries the `NQ-nn` it exists to serve, in a
+comment directly above it. An index with no named query is a write-amplifier
+with no reader; at 132 bytes/row on the hot table that is not a rounding error.
+
+The full text of each query lives next to its index. Index of names:
+
+| NQ | name | table |
+|---|---|---|
+| 01–04c | session lookup/sweep/revoke, login by email, profile by handle | `sessions`, `users`, `user_profiles` |
+| 05–06b | subject/chapter/subchapter lists and lookups | `subjects`, `chapters`, `subchapters` |
+| **07** | **practice-draw** (the hottest query on the platform) | `questions` |
+| 08 | practice-draw by subchapter | `questions` |
+| 09 | deliver-options | `question_options` |
+| **10 / 10b / 10c** | **grade-one / grade-batch / review-after-submit** | `question_answer_keys` |
+| 11–11d | question search, admin search, index rebuild, index compact | `questions_fts` |
+| 12 / 12b | explanation for question / review queue | `explanations` |
+| 13–14 | tags for question / questions for tag | `question_tags` |
+| 15–17 | report triage queue, reports for question, report dedupe | `question_reports` |
+| 18 / 18b | content history, contributor activity | `content_versions` |
+| 19–19b | template by slug, template list, blueprint expand | `mock_test_templates` |
+| 20–22b | resume attempt, attempt by public id, history, expire stale | `attempts` |
+| 23 / 23b | attempt paper, render paper | `attempt_questions` |
+| 24–26d | answer load/upsert, archival scan, difficulty recompute, archive drain | `attempt_answers` |
+| **27** | **progress-page — one covering index scan, ten groups** | `user_question_stats` |
+| 27b / 27c | progress by subchapter, re-chapter stats | `user_question_stats` |
+| 28 | weak-areas queue | `user_question_stats` |
+| 29 / 29b | SRS due queue, workload forecast | `srs_state` |
+| 30 / 30b | bookmarks list, by folder | `bookmarks` |
+| 31–31c | study history, activity heatmap, open session | `study_sessions` |
+| 32a / 32b | streak touch (idempotent upsert), streak leaderboard source | `streaks` |
+| 33–35d | leaderboard page, my rank, latest snapshot, prune | `leaderboard_*` |
+| 36–36d | unread notifications, history, dedupe, prune | `notifications` |
+| 37a–37c | audit by actor / by entity / recent | `admin_audit_log` |
+| 38 / 38b | moderation queue, unclassified queue | `questions` |
+| 39 / 40 | legacy-id lookup (migration only), import dedupe | `questions` |
+| 41 / 41b | oauth identity, providers for user | `oauth_accounts` |
+| 42 | oauth state sweep | `oauth_states` |
+| 43–43c | idempotency reserve / replay / sweep | `idempotency_keys` |
+| 44 / 44b | rate-limit consume, window sweep | `rate_limits` |
+
+`19b` is now `blueprint-expand` over 60 sub-chapter rules and `19c` is
+`blueprint-draw`, which returns the tagged and chapter-level pools in one
+statement. `11` is a real FTS5 `MATCH`; the LIKE scan it replaced is gone.
+
+Two to internalise:
+
+**NQ-07 practice-draw.** Partial on `status = 'published'`, with `id`
+trailing so the index is covering — the draw never touches the table, and the
+index physically cannot return an unpublished question.
+
+```sql
+SELECT id FROM questions
+ WHERE chapter_id = ?1 AND status = 'published'
+ ORDER BY ... LIMIT ?2;
+```
+
+**NQ-27 progress-page.** One index range scan, ten groups, no join, no temp
+b-tree (asserted by `db/smoke.mjs` via `EXPLAIN QUERY PLAN`). `chapter_id` is
+denormalised onto `user_question_stats` by the rollup trigger specifically so
+this needs no join, and it keeps working after archival deletes the answer log.
+
+```sql
+SELECT chapter_id,
+       COUNT(*)               AS seen,
+       SUM(correct_count > 0) AS ever_correct,
+       SUM(answer_count)      AS answers,
+       SUM(correct_count)     AS corrects
+  FROM user_question_stats
+ WHERE user_id = ?1
+ GROUP BY chapter_id;
+```
+
+## Conventions
+
+**Everything is 1-based.** `question_options.ordinal` is literally the N in the
+source JSON's `optN`, so the 1-based `correct_option_index` maps to it as the
+identity — no arithmetic, nothing to get backwards. Same for
+`attempt_answers.delivered_position`, `attempt_questions.position`,
+`chapters.ordinal`, `subchapters.ordinal`. The
+current client converts to 0-based (`correct_option_index - 1` in
+`frontend/src/services/localData.ts`), which means every read and write has to
+remember which side of the boundary it is on.
+
+**Question identity is content, not position.** `questions.id` is
+`'q_' || substr(content_hash, 1, 16)` where
+
+```
+content_hash = sha256('necprep-question-v1' RS nec_code RS norm(stem) RS
+                      sorted(norm(option))... joined by US)
+RS = U+001E, US = U+001F     norm = NFKC, collapse whitespace, trim, lowercase
+```
+
+Why this matters is not theoretical. The old scheme is
+`{topicId}_{arrayIndex}` — `'book-ch1_238'` means "the 239th element of
+ch1.json". While this schema was being written, a de-duplication pass shrank
+the bank from 2,801 rows to 2,312, and the positional quarantine list in
+`frontend/src/data/quarantine.json` went wrong in both directions at once:
+entries now naming healthy questions, and genuinely mis-keyed questions no
+longer excluded. Every bookmark and progress record in every user's
+`localStorage` has the same defect. `questions.legacy_id` exists only so the
+one-time client migration can translate them, and is expected to be dropped
+after the cutover.
+
+**Option identity is a slot, but the id does not say which slot.**
+`question_options.id` is `question_id || '#' || opt_key`, enforced by a `CHECK`,
+where `opt_key` is 12 CSPRNG base32 characters. It used to be `|| ordinal`, and
+that was a real security hole: `frontend/public/data/books/*.json` publishes
+`correct_option_index` and is in git history forever, so an ordinal-bearing id
+reaching a client recovered the whole answer key with no database access, and
+per-attempt permutation was no defence because the ordinal rode inside the id.
+
+`ordinal` survives as the authored slot and as the editorial identity, assigned
+once and **never reused**: retiring option 3 and adding a replacement gives the
+new one ordinal 5, so a historical answer can never be silently re-pointed at
+different text. It is SERVER-ONLY — in no view, no delivery query and no
+response body. That is the opposite of `questions` on purpose — there identity
+is content, here it is a slot that survives content edits, and between them
+nothing a human does to the bank can change the meaning of an answer already
+recorded.
+
+The `question_id || '#'` prefix is kept rather than swapped for a bare ULID
+because three CHECKs prove same-question-ness with a prefix test:
+`question_answer_keys.correct_option_id`, `explanations.about_option_id` and
+`question_reports.suggested_option_id`.
+
+**SQLite, written as SQLite.** No native enums (`CHECK` constraints — and
+`db:verify` compares each one against the TypeScript union). No `jsonb` (`TEXT`
++ `json_valid()` + json1). No materialised views (precomputed snapshot tables).
+Generated columns are used where they earn their place: `users.email_normalized`,
+`question_options.text_norm`, `attempts.score_bp`,
+`user_question_stats.accuracy_bp`, `study_sessions.duration_s`, and
+`attempt_answers.selected_option_id` (VIRTUAL — zero bytes, fully joinable).
+Every table is `STRICT`.
+
+**Timestamps are INTEGER epoch MILLISECONDS**, and every column that carries
+one says so in a trailing comment. Milliseconds because every consumer is
+JavaScript: `Date.now()` is milliseconds, the API's `EpochMs` wire type is
+milliseconds, and the client's response log, quiz drafts and mock `endsAt` are
+all already milliseconds, so a seconds-based store would mean a conversion at
+every read and write — and the one place it was forgotten would be silent. The
+default is `(CAST(unixepoch('subsec') * 1000 AS INTEGER))`; `db/smoke.mjs`
+asserts that a round-tripped 45-minute deadline is still in the future.
+Durations are named for their unit (`time_ms`, `elapsed_ms`, `duration_s`).
+Calendar days, where a day is the unit of meaning, are TEXT `'YYYY-MM-DD'` in
+the *user's* timezone — Nepal is UTC+05:45, so a UTC-based streak would break
+for anyone studying after 18:15 local.
+
+**Ratios in basis points, not floats.** `score_bp`, `accuracy_bp`, `p_value_bp`
+are integers 0–10000. Exact, sortable, indexable, and immune to the
+"99.99999%" rendering bug.
+
+## Migrations
+
+- `NNNN_lower_snake.sql`, applied in filename order, no gaps.
+  `db/apply.mjs` enforces the naming and the numbering.
+- **No `BEGIN`/`COMMIT`/`ROLLBACK`** — `wrangler d1 migrations apply` wraps each
+  file itself. `db/apply.mjs` rejects them, so you find out locally.
+- **No `PRAGMA`, `ATTACH` or `VACUUM`** — D1 rejects all three. Same check.
+- Foreign keys are on by default in D1; `db/apply.mjs` turns them on explicitly
+  so a broken reference fails locally too (the `sqlite3` CLI leaves them off).
+- SQLite cannot `ALTER TABLE … ADD CONSTRAINT`, so a new constraint means
+  create-copy-rename. Write it as a numbered migration, not a hand-edit.
+
+Applied migrations are immutable. Edit one only before it has run anywhere.
+
+## Seeding
+
+```bash
+npm run db:seed:local                      # import the bank
+node db/seed/import-questions.mjs --dry-run --json   # report without writing
+npm run db:reference                       # regenerate 0007 from the frontend files
+```
+
+The importer is idempotent (content-hash ids make it an upsert), and it
+**re-derives defects from the data** rather than trusting
+`quarantine.json`'s positional ids:
+
+| code | meaning |
+|---|---|
+| `OPTION_DUPLICATE` | two options with identical normalised text |
+| `INDEX_RANGE` | `correct_option_index` outside `1..option_count` |
+| `KEY_CONFLICT` | `correct_option` text is not any of the options |
+| `DUPLICATE_ANSWER_CONFLICT` | two questions share a stem but their keys name different text (cross-row, so it needs the second pass `planCrossRowDefects` makes) |
+| `OPTION_COUNT`, `EMPTY_STEM` | structurally unusable |
+
+A defective question is imported with `status = 'flagged'` and a
+`question_reports` row carrying the evidence (`source = 'validator'`), so it is
+excluded from selection without being deleted — `status` exists exactly so the
+raw row survives for whoever has to adjudicate it. `quarantine.json` is still
+read, but only to *file a report* where its legacy id resolves to a question
+the rules consider healthy: hiding a question that passes every rule, on the
+strength of a stale array index, is the bug this schema exists to end.
+
+Measured on the current bank:
+
+```
+source rows read              2312
+exact duplicates collapsed      22     (identical stem+options within one chapter)
+cross-chapter dup groups         2
+questions written             2290
+  published                   2199
+  flagged (withheld)            91
+options written               9160
+  retired as duplicate text      6
+  pinned ('all of the above')  450 across 450 questions, all in slot 4
+answer keys written           2290     (every question has a reachable answer)
+published without a key          0     ← the importer aborts if this is non-zero
+errata reports filed           106
+
+defect codes  {"DUPLICATE_ANSWER_CONFLICT":74,"OPTION_DUPLICATE":5,"KEY_CONFLICT":12}
+authored correct-option position  {"1":666,"2":747,"3":515,"4":362}
+quarantine.json cross-check  {"entries":118,"resolved":106,"agreed":91,"stale":15,"unresolvable":12}
+```
+
+Read that last line as the argument for content-hash ids: of 118 positional
+quarantine entries, 12 no longer resolve to any array slot at all and 15 point
+at a question the rules find healthy.
+
+The authored correct option still sits at slot 2 in 32.6% of the bank against
+the 25% a fair one would show, which is why per-attempt permutation is not
+optional.
+
+`opt_key` IS RE-MINTED ONLY FOR A NEW OPTION ROW. The importer's upsert
+conflicts on `(question_id, ordinal)` and returns whichever id won, so a
+re-import keeps every existing option's id and the answer keys stay pointed at
+the same rows. Conflicting on `id` — which is what it did when the id was
+derived from the ordinal — would insert a second row per option on every run
+and orphan every answer already recorded.
+
+## Operational notes for handler authors
+
+- **Budget: 50 queries per Worker invocation** on the free plan (1,000 paid).
+  Batch. `NQ-10b` grades a whole paper in one statement; `NQ-19b` expands a
+  ten-rule blueprint in one. Work done inside a trigger belongs to the
+  statement that fired it and does **not** count — which is why eleven triggers
+  maintain the rollups instead of handler code.
+- **D1 is single-threaded per database.** Nothing on a request path may scan a
+  large table. That is why leaderboards are snapshots and the progress page is
+  a rollup.
+- **Fail closed on missing config.** No secret has a default. A missing
+  `wrangler secret` must throw at startup.
+- **`attempts.id` vs `attempts.public_id`.** URLs carry the ULID; the integer
+  is internal, and exists because every `attempt_answers` row references it.
+  Resolve `public_id` → `id` once per request, not per answer.
+- **Deleting a question that has been answered is refused** by a foreign key.
+  Use `status = 'retired'`. Same for options: `retired_at`, never `DELETE`.
+- **Partial-index upserts must restate the predicate.** `ON CONFLICT (user_id,
+  dedupe_key) WHERE dedupe_key IS NOT NULL DO NOTHING` — omit the `WHERE` and
+  `prepare()` fails at runtime with "ON CONFLICT clause does not match any
+  PRIMARY KEY or UNIQUE constraint". This one was found by `db/smoke.mjs`, not
+  by review.
+## Reconciliation with `worker/src/**` (DONE)
+
+`worker/src/**` was written concurrently by another author against an *assumed*
+schema declared in `src/data/tables.ts`. The two did not match. They do now,
+and this is the record of which side moved; the long form, with the argument
+for each call, is at the foot of `src/data/tables.ts`.
+
+| area | resolution | which side moved |
+|---|---|---|
+| **timestamps** | INTEGER epoch **milliseconds** everywhere | **SQL**. Every consumer is JavaScript, and a seconds store meant a conversion at every boundary with one silent failure mode: a 45-minute deadline expiring in 45 ms. |
+| answer key | `question_answer_keys`, its own table | API. `question_options.is_correct` is gone; the isolation is the point. |
+| option ids | `question_id \|\| '#' \|\| opt_key`, 12 CSPRNG chars | **SQL**. The ordinal in the id was a live leak against the published JSON. |
+| attempts | one `attempts` table with `mode` | API. `mock_attempts` + `practice_sessions` and their four child tables collapsed into three. |
+| pre-deadline snapshot | `attempts.synced_answers`, `.last_sync_at` | **SQL**, two columns, plus a CHECK that the snapshot cannot be stamped past the deadline. |
+| rollups | the 0005 triggers | API. Three hand-written upserts deleted; `user_chapter_stats` and `user_daily_activity` replaced by NQ-27 over `user_question_stats`, plus `streaks` and `study_sessions`. |
+| roles | `student \| contributor \| moderator \| admin` | **SQL**. Four: triage is not publish. |
+| identity | `users.email` nullable, `is_anonymous` | **SQL**. A `NOT NULL` email left nowhere to put a guest, and guests are the product's whole first run. |
+| sessions | `id` = sha256 hex of the cookie; idle + absolute expiry | API. A dump of `sessions` now yields nothing anyone can sign in with. |
+| blueprint | sub-chapter level, version 2, 60 rules | **SQL** and API. `frontend/src/data/examBlueprint.ts` was right about the exam. |
+| SRS | FSRS field names on `srs_state` | API. `stability` and `difficulty` were already there; `domain/srs.ts` speaks them now. |
+| names | `srs_state`, `admin_audit_log`, `mock_test_templates`, `question_options.text`/`.ordinal` | API. |
+| four missing tables | `oauth_accounts`, `oauth_states` in 0001; `idempotency_keys`, `rate_limits` in 0008 | **SQL**, DDL reviewed rather than taken as proposed. |
+| dependencies | `hono`, `zod` in `package.json`; `validation/v.ts` deleted | API. The Worker now bundles. |
+
+Three items on the API author's checklist, answered:
+
+1. **"`question_options.id` must be opaque."** Agreed and acted on, and this
+   was the right call rather than a concession. The `question_id` prefix stays,
+   because three CHECKs use it to prove same-question-ness; the discriminator
+   is now random. `lib/permute.ts#browseOptionRef` and the per-attempt refs
+   stay as defence in depth over a sound id scheme rather than as the only
+   thing holding the line.
+2. **"`questions` must not carry `correct_option_index` / `correct_option`."**
+   It does not. Those two source fields are kept as
+   `question_answer_keys.authored_index` / `authored_text` — in the server-only
+   table, where a `SELECT *` on `questions` cannot reach them.
+3. **"Keep the index list short; D1 counts index writes."** Agreed and acted
+   on: `attempt_answers` has exactly three indexes and each carries the named
+   query it serves. 63% of its re-measured 149.9 bytes/row is index, and
+   `idx_attempt_answers_question_correct` is named in `0004` as the first
+   candidate to drop if the ceiling gets close.
+
+## Known gaps
+
+- **Not verified against production D1.** Everything above was verified on
+  SQLite 3.54 and Miniflare's local D1; no Cloudflare account was provisioned.
+  `STRICT` and FTS5 both work in Miniflare and D1 documents full SQLite SQL
+  support, but confirm both on the first real deploy.
+- `database_id` in `wrangler.toml` is a placeholder. It fails loudly rather
+  than plausibly, which is the point.
+- `questions.subchapter_id` is NULL for all 2,290 imported questions. The
+  source JSON has no syllabus field, so the importer does not guess;
+  classifying them is a contributor workflow, and `NQ-38b` is the queue that
+  drives it.
+- `questions.p_value_bp`, `tags`/`question_tags` and `content_versions` are
+  modelled and indexed but unpopulated — the jobs and editor flows that fill
+  them are later phases.
+- **`explanations` is empty until the generator is run**, so every `explanation`
+  field on the wire is `null` today. The owner confirmed no authored
+  explanations are coming, so the content comes from
+  `scripts/generate-explanations.mjs` (Batch API, 50% rates, one cached
+  instruction prefix) and is drained by `scripts/review-explanations.mjs`:
+
+  ```sh
+  npm run explain:estimate          # measured token/cost estimate, no spend
+  npm run explain:generate -- --limit 20   # pilot
+  npm run explain:collect -- <batchId>     # ingest
+  npm run explain:stats             # backlog + confidence buckets
+  npm run explain:review            # drain, least-confident first
+  ```
+
+  Rows land as `origin = 'ai_draft', status = 'published'` — served to students
+  **with an unreviewed badge** and never during a timed mock test. The
+  generator is given the keyed answer and asked to explain it rather than to
+  solve the question; when it disagrees with the key it files a
+  `question_reports` row and publishes nothing, which makes the pass a second
+  independent audit of all 2,184 answer keys.
+- **`strict_subchapter` must stay `false`** in every blueprint while
+  `subchapter_id` is NULL: a strict run would fail all 60 rules. The selection
+  query does not change when tagging arrives, only the mix of its two pools.
+- **The three cron jobs in `wrangler.toml` have no handler yet.** Answer
+  retention, attempt expiry and the leaderboard snapshot are all specified
+  (0004, NQ-22b, 0006) and none is implemented; `src/index.ts` exports a fetch
+  handler only. Until the retention job exists, `attempt_answers` grows
+  without bound and the first symptom is writes failing at the 500 MB wall.
+- **The frontend outbox is still `localStorage`.**
+  `frontend/src/services/responseLog.ts` already keeps an IndexedDB store whose
+  `rid` is documented as the cross-device merge key — i.e. an idempotency key —
+  and `ResponseRecord.chosenIndex` is an INDEX into the presented options,
+  which cannot be replayed against this API. Both are changes to frontend
+  files outside this change's scope.
diff --git a/worker/db/apply.mjs b/worker/db/apply.mjs
new file mode 100644
index 0000000..6120e5b
--- /dev/null
+++ b/worker/db/apply.mjs
@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+/**
+ * apply.mjs -- apply every migration, in order, to a local SQLite file.
+ *
+ * Why this exists alongside `wrangler d1 migrations apply --local`: this runs
+ * with zero network and zero node_modules, using node:sqlite (Node 22+), so
+ * the schema can be proved to apply before anyone installs a toolchain or
+ * creates a Cloudflare account. `npm run d1:migrate:local` is the second
+ * check, against Miniflare's D1 implementation.
+ *
+ * It also enforces the things D1 enforces and plain `sqlite3` does not:
+ *
+ *   * foreign keys ON. D1 enables them by default; the sqlite3 CLI does not,
+ *     so a schema with a broken reference passes there and fails in production.
+ *   * no transaction control inside a migration file. `wrangler d1 migrations
+ *     apply` wraps each file itself, so a BEGIN in a file is an error you find
+ *     at deploy time. Found here instead.
+ *   * no PRAGMA statements, which D1 rejects.
+ *
+ * Usage:
+ *   node db/apply.mjs [--db <path>] [--keep]
+ *     --db    target file (default: .local/necprep.sqlite)
+ *     --keep  apply on top of an existing file instead of recreating it
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { readFileSync, readdirSync, mkdirSync, rmSync, existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const WORKER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const MIGRATIONS_DIR = join(WORKER_ROOT, 'migrations');
+
+const argv = process.argv.slice(2);
+const argOf = (flag, fallback) => {
+  const i = argv.indexOf(flag);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback;
+};
+export const DEFAULT_DB = join(WORKER_ROOT, '.local', 'necprep.sqlite');
+const dbPath = resolve(argOf('--db', DEFAULT_DB));
+const keep = argv.includes('--keep');
+
+// Statements D1 will not run. Checked here so the failure is local and cheap.
+const FORBIDDEN = [
+  // Matches `BEGIN;` / `BEGIN IMMEDIATE TRANSACTION;` but not a trigger body's
+  // `BEGIN`, which is never followed by a semicolon.
+  { re: /^\s*BEGIN(\s+(DEFERRED|IMMEDIATE|EXCLUSIVE))?(\s+TRANSACTION)?\s*;/im,
+    why: 'wrangler wraps each migration in its own transaction' },
+  { re: /^\s*COMMIT\b/im, why: 'wrangler wraps each migration in its own transaction' },
+  { re: /^\s*ROLLBACK\b/im, why: 'wrangler wraps each migration in its own transaction' },
+  { re: /^\s*PRAGMA\s/im, why: 'D1 rejects PRAGMA statements in migrations' },
+  { re: /^\s*ATTACH\s/im, why: 'D1 has no filesystem to attach from' },
+  { re: /^\s*VACUUM/im, why: 'D1 does not expose VACUUM' },
+];
+
+export function migrationFiles() {
+  const files = readdirSync(MIGRATIONS_DIR)
+    .filter((f) => f.endsWith('.sql'))
+    .sort();
+  if (files.length === 0) throw new Error(`no .sql files in ${MIGRATIONS_DIR}`);
+  for (const f of files) {
+    if (!/^\d{4}_[a-z0-9_]+\.sql$/.test(f)) {
+      throw new Error(`migration name must be NNNN_lower_snake.sql: ${f}`);
+    }
+  }
+  const nums = files.map((f) => Number(f.slice(0, 4)));
+  nums.forEach((n, i) => {
+    if (n !== i + 1) throw new Error(`migration numbering has a gap or duplicate at ${files[i]}`);
+  });
+  return files;
+}
+
+export function openApplied(path = DEFAULT_DB, { fresh = true } = {}) {
+  mkdirSync(dirname(path), { recursive: true });
+  if (fresh && existsSync(path)) {
+    for (const suffix of ['', '-wal', '-shm']) rmSync(path + suffix, { force: true });
+  }
+  const db = new DatabaseSync(path);
+  // D1 behaviour, not sqlite3-CLI behaviour.
+  db.exec('PRAGMA foreign_keys = ON');
+  const applied = [];
+  for (const file of migrationFiles()) {
+    const sql = readFileSync(join(MIGRATIONS_DIR, file), 'utf8');
+    // Strip comments before scanning, so the words BEGIN and PRAGMA are
+    // allowed to appear in the explanatory prose that this schema is mostly
+    // made of.
+    const code = sql
+      .split('\n')
+      .filter((l) => !/^\s*--/.test(l))
+      .join('\n');
+    for (const { re, why } of FORBIDDEN) {
+      if (re.test(code)) throw new Error(`${file}: forbidden statement (${why})`);
+    }
+    try {
+      db.exec(sql);
+    } catch (err) {
+      throw new Error(`${file}: ${err.message}`);
+    }
+    applied.push(file);
+  }
+  const fkErrors = db.prepare('PRAGMA foreign_key_check').all();
+  if (fkErrors.length) throw new Error(`foreign_key_check failed: ${JSON.stringify(fkErrors)}`);
+  const integrity = db.prepare('PRAGMA integrity_check').get();
+  if (integrity.integrity_check !== 'ok') throw new Error(`integrity_check: ${integrity.integrity_check}`);
+  return { db, applied };
+}
+
+// pathToFileURL, not a template literal: this repo's path contains spaces and
+// `file://${argv[1]}` would not match the percent-encoded import.meta.url.
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const { db, applied } = openApplied(dbPath, { fresh: !keep });
+  const count = (sql) => db.prepare(sql).get().n;
+
+  console.log(`applied ${applied.length} migrations to ${dbPath}`);
+  for (const f of applied) console.log(`  ok  ${f}`);
+
+  const tables = db
+    .prepare(
+      `SELECT name, type FROM sqlite_master
+        WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%'
+          AND name NOT LIKE 'questions_fts%'
+        ORDER BY type, name`
+    )
+    .all();
+  const idx = count(
+    `SELECT COUNT(*) n FROM sqlite_master WHERE type='index' AND sql IS NOT NULL`
+  );
+  const trig = count(`SELECT COUNT(*) n FROM sqlite_master WHERE type='trigger'`);
+
+  console.log(
+    `\n${tables.filter((t) => t.type === 'table').length} tables, ` +
+      `${tables.filter((t) => t.type === 'view').length} view(s), ` +
+      `${idx} explicit indexes, ${trig} triggers`
+  );
+  for (const t of tables) console.log(`  ${t.type.padEnd(5)} ${t.name}`);
+
+  console.log('\nreference data loaded by 0007:');
+  for (const [label, sql] of [
+    ['subjects', 'SELECT COUNT(*) n FROM subjects'],
+    ['chapters', 'SELECT COUNT(*) n FROM chapters'],
+    ['subchapters', 'SELECT COUNT(*) n FROM subchapters'],
+    ['mock_test_templates', 'SELECT COUNT(*) n FROM mock_test_templates'],
+  ]) {
+    console.log(`  ${label.padEnd(20)} ${count(sql)}`);
+  }
+  db.close();
+}
diff --git a/worker/db/measure.mjs b/worker/db/measure.mjs
new file mode 100644
index 0000000..7654429
--- /dev/null
+++ b/worker/db/measure.mjs
@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+/**
+ * measure.mjs -- measure the real on-disk cost of an `attempt_answers` row,
+ * and project the D1 ceiling from it.
+ *
+ * `attempt_answers` is the only unbounded table on the platform (see the
+ * archival note in migrations/0004_assessment.sql). Everything in that note --
+ * when the free tier runs out, what retention window fits, when the platform
+ * has to move off a single D1 database -- depends on one number: bytes per
+ * row, including every index. Guessing it is how a team discovers the ceiling
+ * by hitting it.
+ *
+ * So this inserts synthetic answers into the real schema, with the real
+ * triggers and the real indexes, and reads the allocated page bytes out of
+ * `dbstat`.
+ *
+ * Usage:
+ *   node db/measure.mjs [--db <path>] [--rows 200000] [--keep]
+ *
+ * Writes to a throwaway copy by default (.local/measure.sqlite) so the
+ * development database is not left full of synthetic rows.
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { copyFileSync, existsSync, rmSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const WORKER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+const ANSWER_BTREES = [
+  'attempt_answers',
+  'uq_attempt_answers_attempt_question',
+  'idx_attempt_answers_answered_at',
+  'idx_attempt_answers_question_correct',
+];
+
+const KiB = 1024;
+const MiB = 1024 * 1024;
+
+function btreeBytes(db, names) {
+  const rows = db
+    .prepare(
+      `SELECT name, SUM(pgsize) AS bytes FROM dbstat
+        WHERE name IN (${names.map(() => '?').join(',')})
+        GROUP BY name`
+    )
+    .all(...names);
+  const out = {};
+  for (const name of names) out[name] = 0;
+  for (const r of rows) out[r.name] = r.bytes;
+  return out;
+}
+
+export function measure(db, { rows = 200_000 } = {}) {
+  db.exec('PRAGMA foreign_keys = ON');
+  const one = (sql, ...p) => db.prepare(sql).get(...p);
+
+  const questionIds = db
+    .prepare(`SELECT id FROM questions WHERE status = 'published' ORDER BY id`)
+    .all()
+    .map((r) => r.id);
+  if (questionIds.length === 0) {
+    throw new Error('no published questions -- run db/seed/import-questions.mjs first');
+  }
+  const minOptions = one(
+    `SELECT MIN(c) AS c FROM (SELECT COUNT(*) c FROM question_options GROUP BY question_id)`
+  ).c;
+
+  const baseline = btreeBytes(db, ANSWER_BTREES);
+  const dbBytesBefore = one('SELECT SUM(pgsize) AS b FROM dbstat').b;
+  const ftsBytes = one(
+    `SELECT SUM(pgsize) AS b FROM dbstat WHERE name LIKE 'questions_fts%'`
+  ).b;
+
+  // Epoch MILLISECONDS -- see migrations/0001_identity.sql.
+  const now = Date.now();
+  const USER = 'U0MEASUREUSER000000000000X';
+  db.prepare(
+    `INSERT INTO users (id, email, role, created_at, updated_at)
+     VALUES (?, 'measure@example.invalid', 'student', ?, ?)
+     ON CONFLICT (id) DO NOTHING`
+  ).run(USER, now, now);
+
+  // Papers of 2,000 questions: large enough that attempt overhead is noise,
+  // and `question_count` has to cover `answered_count` (a CHECK).
+  const perAttempt = Math.min(2000, questionIds.length);
+  const attemptCount = Math.ceil(rows / perAttempt);
+
+  const insertAttempt = db.prepare(
+    `INSERT INTO attempts (public_id, user_id, mode, chapter_id, status, option_seed,
+                           question_count, started_at)
+     VALUES (?, ?, 'practice', NULL, 'in_progress', ?, ?, ?)`
+  );
+  // Real option keys, read back from the bank: `selected_opt_key` has a
+  // composite foreign key to question_options, so a synthetic value would be
+  // rejected -- and measuring the table with that key absent would understate
+  // the index width this whole file exists to report.
+  const optKeyByQuestionOrdinal = new Map();
+  for (const r of db
+    .prepare(`SELECT question_id, ordinal, opt_key FROM question_options`)
+    .all()) {
+    optKeyByQuestionOrdinal.set(`${r.question_id}#${r.ordinal}`, r.opt_key);
+  }
+  const insertAnswer = db.prepare(
+    `INSERT INTO attempt_answers (attempt_id, question_id, selected_opt_key, is_correct,
+                                  delivered_position, time_ms, answered_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+
+  const started = Date.now();
+  let written = 0;
+  db.exec('BEGIN');
+  for (let a = 0; a < attemptCount && written < rows; a++) {
+    insertAttempt.run(`M${String(a).padStart(25, '0')}`, USER, a + 1, perAttempt, now);
+    const attemptId = one('SELECT max(id) AS id FROM attempts').id;
+    for (let k = 0; k < perAttempt && written < rows; k++) {
+      const qid = questionIds[k % questionIds.length];
+      insertAnswer.run(
+        attemptId, qid,
+        optKeyByQuestionOrdinal.get(`${qid}#${(written % minOptions) + 1}`) ?? null,
+        written % 3 === 0 ? 1 : 0,
+        (written % 4) + 1,
+        1500 + (written % 9000),
+        now - (written % 7_776_000_000)
+      );
+      written++;
+    }
+  }
+  db.exec('COMMIT');
+  const elapsedMs = Date.now() - started;
+
+  const after = btreeBytes(db, ANSWER_BTREES);
+  const perRow = {};
+  let totalPerRow = 0;
+  for (const name of ANSWER_BTREES) {
+    const bytes = after[name] - baseline[name];
+    perRow[name] = bytes / written;
+    totalPerRow += perRow[name];
+  }
+
+  const dbBytesAfter = one('SELECT SUM(pgsize) AS b FROM dbstat').b;
+  const schemaBytes = dbBytesBefore; // seeded bank + reference data + FTS, no answers
+
+  // D1 limits, stated so the projection cannot drift from them silently.
+  const FREE_DB_BYTES = 500 * MiB;
+  const PAID_DB_BYTES = 10 * 1024 * MiB;
+  const ANSWERS_PER_MAU_MONTH = 500;
+
+  const capacity = (limitBytes) => Math.floor((limitBytes - schemaBytes) / totalPerRow);
+
+  const projection = [1_000, 2_000, 5_000, 10_000, 25_000].map((mau) => {
+    const perMonth = mau * ANSWERS_PER_MAU_MONTH;
+    const live90 = perMonth * 3;
+    const live180 = perMonth * 6;
+    return {
+      mau,
+      rowsPerMonth: perMonth,
+      // D1 counts index rows as writes, so one answer costs 1 table write plus
+      // one per index on it.
+      rowWritesPerDay: Math.round((perMonth / 30) * (1 + ANSWER_BTREES.length - 1)),
+      live90Rows: live90,
+      live90Bytes: live90 * totalPerRow,
+      live180Rows: live180,
+      live180Bytes: live180 * totalPerRow,
+      fitsFree90: live90 * totalPerRow + schemaBytes <= FREE_DB_BYTES,
+      fitsPaid90: live90 * totalPerRow + schemaBytes <= PAID_DB_BYTES,
+    };
+  });
+
+  return {
+    rowsWritten: written,
+    elapsedMs,
+    rowsPerSecond: Math.round((written / elapsedMs) * 1000),
+    minOptionsPerQuestion: minOptions,
+    perRowBytes: perRow,
+    totalPerRowBytes: totalPerRow,
+    schemaBytes,
+    ftsBytes,
+    dbBytesAfter,
+    freeTierAnswerCapacity: capacity(FREE_DB_BYTES),
+    paidTierAnswerCapacity: capacity(PAID_DB_BYTES),
+    projection,
+  };
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const argv = process.argv.slice(2);
+  const argOf = (flag, fallback) => {
+    const i = argv.indexOf(flag);
+    return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback;
+  };
+  const source = resolve(argOf('--db', join(WORKER_ROOT, '.local', 'necprep.sqlite')));
+  if (!existsSync(source)) {
+    console.error(`no database at ${source}. Run \`npm run db:apply:local && npm run db:seed:local\` first.`);
+    process.exit(2);
+  }
+  const target = join(WORKER_ROOT, '.local', 'measure.sqlite');
+  for (const suffix of ['', '-wal', '-shm']) rmSync(target + suffix, { force: true });
+  copyFileSync(source, target);
+
+  const db = new DatabaseSync(target);
+  const m = measure(db, { rows: Number(argOf('--rows', '200000')) });
+  db.close();
+
+  const fmt = (b) =>
+    b >= 1024 * MiB
+      ? `${(b / (1024 * MiB)).toFixed(2)} GB`
+      : b >= MiB
+        ? `${(b / MiB).toFixed(1)} MB`
+        : `${(b / KiB).toFixed(0)} KB`;
+
+  console.log(`measured on a copy at ${target}`);
+  console.log(`\n${m.rowsWritten.toLocaleString()} synthetic answer rows in ${m.elapsedMs} ms (${m.rowsPerSecond.toLocaleString()} rows/s, triggers live)\n`);
+  console.log('bytes per attempt_answers row, allocated pages, real indexes:');
+  for (const [name, bytes] of Object.entries(m.perRowBytes)) {
+    console.log(`  ${name.padEnd(38)} ${bytes.toFixed(1)}`);
+  }
+  console.log(`  ${'TOTAL'.padEnd(38)} ${m.totalPerRowBytes.toFixed(1)}`);
+  console.log(`\nschema + seeded bank, no answers:   ${fmt(m.schemaBytes)}`);
+  console.log(`  of which the FTS5 index:          ${fmt(m.ftsBytes)}`);
+  console.log(`database after the measurement:     ${fmt(m.dbBytesAfter)}`);
+  console.log(`\nanswer rows that fit a 500 MB D1 free database:  ${m.freeTierAnswerCapacity.toLocaleString()}`);
+  console.log(`answer rows that fit a 10 GB D1 paid database:   ${m.paidTierAnswerCapacity.toLocaleString()}`);
+
+  console.log('\nprojection at ~500 answers per active user per month:');
+  console.log('   MAU   rows/month  row-writes/day   90d live        180d live      free 500MB@90d  paid 10GB@90d');
+  for (const p of m.projection) {
+    console.log(
+      `  ${String(p.mau).padStart(6)}  ${String(p.rowsPerMonth).padStart(10)}  ` +
+        `${String(p.rowWritesPerDay).padStart(14)}  ` +
+        `${(p.live90Rows / 1e6).toFixed(1).padStart(5)}M ${fmt(p.live90Bytes).padStart(8)}  ` +
+        `${(p.live180Rows / 1e6).toFixed(1).padStart(5)}M ${fmt(p.live180Bytes).padStart(8)}  ` +
+        `${(p.fitsFree90 ? 'yes' : 'NO').padStart(14)}  ${(p.fitsPaid90 ? 'yes' : 'NO').padStart(13)}`
+    );
+  }
+  console.log(
+    '\nThe free plan also caps row WRITES at 100,000/day. D1 counts index rows,\n' +
+      `so one answer is ${ANSWER_BTREES.length} row writes here -- the write cap, not the 500 MB\n` +
+      'storage cap, is what actually bites first. See migrations/0004_assessment.sql.'
+  );
+  if (!argv.includes('--keep')) {
+    for (const suffix of ['', '-wal', '-shm']) rmSync(target + suffix, { force: true });
+    console.log(`\nremoved ${target} (pass --keep to inspect it)`);
+  } else {
+    console.log(`\nkept ${target} (${fmt(statSync(target).size)} on disk)`);
+  }
+}
diff --git a/worker/db/schema.ts b/worker/db/schema.ts
new file mode 100644
index 0000000..9191110
--- /dev/null
+++ b/worker/db/schema.ts
@@ -0,0 +1,1574 @@
+/**
+ * schema.ts -- Drizzle definitions for the NECPrep D1 database.
+ *
+ * ===========================================================================
+ * THE SQL IS THE SOURCE OF TRUTH. THIS FILE IS THE TYPED CLIENT.
+ * ===========================================================================
+ *
+ * `worker/migrations/*.sql` is authoritative. This file exists so handlers get
+ * compile-time column names and inferred row types, not so a tool can generate
+ * DDL from it.
+ *
+ * DO NOT RUN `drizzle-kit generate` AGAINST THIS FILE. Drizzle cannot express
+ * several things the schema depends on, and a generated migration would
+ * silently drop them:
+ *
+ *   * STRICT tables
+ *   * triggers (eleven of them, and they maintain every rollup on the platform)
+ *   * FTS5 virtual tables
+ *   * `DESC` in index key columns
+ *   * partial-index predicates in their exact SQLite form
+ *
+ * Instead, `npm run db:verify` introspects a migrated database and compares it
+ * to this file -- table by table, column by column, index by index, CHECK by
+ * CHECK -- and fails if they have drifted. That makes the duplication safe:
+ * the two artefacts cannot disagree without CI saying so.
+ *
+ * The `{ enum: [...] }` option on a text column is TYPES ONLY in Drizzle for
+ * SQLite; the runtime constraint is the CHECK in the migration. `db:verify`
+ * parses those CHECKs and asserts the two lists are identical, so the union
+ * here is not a second, drifting copy of the enum.
+ *
+ * Timestamps are INTEGER epoch MILLISECONDS, exposed as `number`, deliberately
+ * not `{ mode: 'timestamp' }`: a Worker has no local timezone and every date
+ * decision on this platform (streaks, leaderboard periods) is made against the
+ * user's stored timezone, so an automatic Date conversion would hide the one
+ * thing the caller must think about. Milliseconds because every consumer is
+ * JavaScript and `Date.now()` is milliseconds; the wire contract in
+ * `worker/src/shared/types.ts` calls the unit `EpochMs` and means it. Calendar
+ * days are TEXT 'YYYY-MM-DD'.
+ *
+ * ---------------------------------------------------------------------------
+ * ANSWER-KEY RULE, RESTATED HERE BECAUSE THIS IS THE FILE HANDLERS IMPORT
+ * ---------------------------------------------------------------------------
+ * `questionAnswerKeys` is SERVER-ONLY. It must not appear in any query whose
+ * result can reach a client before that client's attempt is submitted. Use
+ * `vQuestionDelivery` to deliver questions -- it physically cannot join the key
+ * table. The three permitted key queries are written out in
+ * migrations/0002_content.sql and in worker/README.md.
+ */
+
+import { sql } from 'drizzle-orm';
+import {
+  check,
+  foreignKey,
+  index,
+  integer,
+  primaryKey,
+  real,
+  sqliteTable,
+  sqliteView,
+  text,
+  uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+import type { AnySQLiteColumn } from 'drizzle-orm/sqlite-core';
+
+/**
+ * INTEGER epoch MILLISECONDS, server-assigned.
+ *
+ * `unixepoch('subsec')` is REAL seconds at millisecond resolution; the CAST is
+ * explicit so a STRICT INTEGER column is never handed a REAL whose conversion
+ * could be lossy. Milliseconds and not seconds because every consumer is
+ * JavaScript -- see the convention block at the top of
+ * migrations/0001_identity.sql for the full argument.
+ */
+const nowMs = sql`(CAST(unixepoch('subsec') * 1000 AS INTEGER))`;
+
+// ===========================================================================
+// 0001_identity.sql
+// ===========================================================================
+
+export const users = sqliteTable(
+  'users',
+  {
+    id: text('id').primaryKey(),
+    /** NULL for an anonymous guest. See the note above `users` in 0001. */
+    email: text('email'),
+    /** Generated + uniquely indexed: case variants of one address cannot both register. */
+    emailNormalized: text('email_normalized').generatedAlwaysAs(sql`(lower(trim(email)))`, {
+      mode: 'stored',
+    }),
+    emailVerifiedAt: integer('email_verified_at'),
+    /** NULL for OAuth-only accounts and for guests. MUST fail closed in the password path. */
+    passwordHash: text('password_hash'),
+    passwordAlgo: text('password_algo', { enum: ['pbkdf2-sha256', 'scrypt', 'argon2id'] }),
+    /**
+     * Four roles, not three. `moderator` works the errata triage queue;
+     * `admin` additionally publishes and retires questions, which changes what
+     * candidates sit. Folding them together would hand every volunteer who
+     * triages a typo report the ability to pull a question from every paper.
+     */
+    role: text('role', { enum: ['student', 'contributor', 'moderator', 'admin'] })
+      .notNull()
+      .default('student'),
+    /** 1 = anonymous guest, upgradable in place without changing `id`. */
+    isAnonymous: integer('is_anonymous').notNull().default(0),
+    status: text('status', { enum: ['active', 'suspended', 'deleted'] })
+      .notNull()
+      .default('active'),
+    deletedAt: integer('deleted_at'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+    lastSeenAt: integer('last_seen_at'),
+  },
+  (t) => [
+    /** PARTIAL: guests all carry a NULL email. The upsert must restate this predicate. */
+    uniqueIndex('uq_users_email_normalized')
+      .on(t.emailNormalized)
+      .where(sql`email_normalized IS NOT NULL`),
+    index('idx_users_role_created')
+      .on(t.role, sql`created_at DESC`)
+      .where(sql`status = 'active'`),
+    check('users_email_length', sql`email IS NULL OR length(email) BETWEEN 3 AND 254`),
+    check('users_anonymous_has_no_email', sql`is_anonymous = 0 OR email IS NULL`),
+    check('users_anonymous_has_no_password', sql`is_anonymous = 0 OR password_hash IS NULL`),
+    check('users_is_anonymous', sql`is_anonymous IN (0, 1)`),
+    check('users_deleted_at', sql`(status = 'deleted') = (deleted_at IS NOT NULL)`),
+    check('users_password_algo', sql`password_hash IS NULL OR password_algo IS NOT NULL`),
+  ]
+);
+
+export const userProfiles = sqliteTable(
+  'user_profiles',
+  {
+    userId: text('user_id')
+      .primaryKey()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    displayName: text('display_name').notNull(),
+    handle: text('handle'),
+    avatarUrl: text('avatar_url'),
+    bio: text('bio'),
+    institution: text('institution'),
+    targetSitting: text('target_sitting'),
+    /** TEXT 'YYYY-MM-DD'. */
+    targetDate: text('target_date'),
+    /** Drives streak day boundaries. Nepal is UTC+05:45; UTC midnight is nobody's day boundary. */
+    timezone: text('timezone').notNull().default('Asia/Kathmandu'),
+    locale: text('locale').notNull().default('en'),
+    /** Default 0: nobody is put on a public ranking without asking. */
+    leaderboardOptIn: integer('leaderboard_opt_in').notNull().default(0),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    uniqueIndex('uq_user_profiles_handle').on(t.handle).where(sql`handle IS NOT NULL`),
+    check(
+      'user_profiles_target_date',
+      sql`target_date IS NULL OR target_date GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]'`
+    ),
+    check('user_profiles_opt_in', sql`leaderboard_opt_in IN (0, 1)`),
+    check('user_profiles_display_name', sql`length(display_name) BETWEEN 1 AND 60`),
+    check(
+      'user_profiles_handle_shape',
+      sql`handle IS NULL OR (length(handle) BETWEEN 3 AND 24 AND handle GLOB '[a-z0-9_]*')`
+    ),
+  ]
+);
+
+export const sessions = sqliteTable(
+  'sessions',
+  {
+    /** sha256 hex of the cookie value. NEVER the cookie value itself. */
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    lastUsedAt: integer('last_used_at').notNull().default(nowMs),
+    /** Idle expiry, slid forward on use. */
+    expiresAt: integer('expires_at').notNull(),
+    /** Hard ceiling. Sliding can never pass this, so a stolen cookie cannot be renewed forever. */
+    absoluteExpiresAt: integer('absolute_expires_at').notNull(),
+    revokedAt: integer('revoked_at'),
+    revokedReason: text('revoked_reason', {
+      enum: ['logout', 'logout_all', 'password_change', 'admin', 'rotated', 'suspicious'],
+    }),
+    ipHash: text('ip_hash'),
+    userAgent: text('user_agent'),
+  },
+  (t) => [
+    index('idx_sessions_user_active')
+      .on(t.userId, sql`last_used_at DESC`)
+      .where(sql`revoked_at IS NULL`),
+    index('idx_sessions_absolute_expires_at').on(t.absoluteExpiresAt),
+    check('sessions_id_is_hash', sql`length(id) = 64 AND id GLOB '[0-9a-f]*'`),
+    check('sessions_expiry_order', sql`expires_at <= absolute_expires_at`),
+    check('sessions_revoked_reason', sql`revoked_at IS NULL OR revoked_reason IS NOT NULL`),
+  ]
+);
+
+/**
+ * The link between a `users` row and a provider identity.
+ *
+ * `(provider, providerAccountId)` is the only stable identifier a provider
+ * gives us, and it is UNIQUE here. Resolving a sign-in by email alone would be
+ * an account-takeover path, because a provider can reassign an address.
+ */
+export const oauthAccounts = sqliteTable(
+  'oauth_accounts',
+  {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    provider: text('provider', { enum: ['google'] }).notNull(),
+    /** The provider's immutable subject id ('sub' for Google). NOT the email. */
+    providerAccountId: text('provider_account_id').notNull(),
+    createdAt: integer('created_at').notNull().default(nowMs),
+  },
+  (t) => [
+    uniqueIndex('uq_oauth_accounts_provider_account').on(t.provider, t.providerAccountId),
+    index('idx_oauth_accounts_user').on(t.userId, t.provider),
+    check(
+      'oauth_accounts_account_id_nonblank',
+      sql`length(trim(provider_account_id)) > 0`
+    ),
+  ]
+);
+
+/**
+ * The CSRF/PKCE parking space for one in-flight OAuth round trip.
+ *
+ * SINGLE USE: the callback consumes the row with `DELETE ... RETURNING`, so a
+ * replayed `?code=` finds nothing. `codeVerifier` never reaches the browser,
+ * which is what makes PKCE worth doing even for a confidential client.
+ */
+export const oauthStates = sqliteTable(
+  'oauth_states',
+  {
+    state: text('state').primaryKey(),
+    codeVerifier: text('code_verifier').notNull(),
+    /** A PATH on our own origin, or NULL. Never an absolute URL. */
+    redirectTo: text('redirect_to'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    expiresAt: integer('expires_at').notNull(),
+  },
+  (t) => [
+    index('idx_oauth_states_expires_at').on(t.expiresAt),
+    check('oauth_states_redirect_is_path', sql`redirect_to IS NULL OR redirect_to GLOB '/*'`),
+    check('oauth_states_expiry_order', sql`expires_at > created_at`),
+    check('oauth_states_verifier_length', sql`length(code_verifier) BETWEEN 43 AND 128`),
+  ]
+);
+
+export const adminAuditLog = sqliteTable(
+  'admin_audit_log',
+  {
+    id: integer('id').primaryKey(),
+    actorUserId: text('actor_user_id').references(() => users.id, { onDelete: 'set null' }),
+    actorRole: text('actor_role', {
+      enum: ['student', 'contributor', 'moderator', 'admin', 'system'],
+    }).notNull(),
+    action: text('action').notNull(),
+    entityType: text('entity_type').notNull(),
+    entityId: text('entity_id'),
+    /** Redacted JSON. Never a password hash, never a session id. */
+    beforeJson: text('before_json'),
+    afterJson: text('after_json'),
+    reason: text('reason'),
+    ipHash: text('ip_hash'),
+    userAgent: text('user_agent'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+  },
+  (t) => [
+    index('idx_admin_audit_log_actor').on(t.actorUserId, sql`id DESC`),
+    index('idx_admin_audit_log_entity').on(t.entityType, t.entityId, sql`id DESC`),
+    index('idx_admin_audit_log_created_at').on(sql`created_at DESC`),
+    check('admin_audit_log_before_json', sql`before_json IS NULL OR json_valid(before_json)`),
+    check('admin_audit_log_after_json', sql`after_json IS NULL OR json_valid(after_json)`),
+  ]
+);
+
+// ===========================================================================
+// 0002_content.sql
+// ===========================================================================
+
+export const subjects = sqliteTable(
+  'subjects',
+  {
+    id: text('id').primaryKey(),
+    code: text('code').notNull(),
+    name: text('name').notNull(),
+    description: text('description'),
+    examBoard: text('exam_board').notNull().default('Nepal Engineering Council'),
+    ordinal: integer('ordinal').notNull().default(1),
+    status: text('status', { enum: ['draft', 'published', 'retired'] })
+      .notNull()
+      .default('published'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [uniqueIndex('uq_subjects_code').on(t.code)]
+);
+
+export const chapters = sqliteTable(
+  'chapters',
+  {
+    /** 'book-ch1'..'book-ch10' -- the existing frontend ids, kept for a frictionless cutover. */
+    id: text('id').primaryKey(),
+    subjectId: text('subject_id')
+      .notNull()
+      .references(() => subjects.id, { onDelete: 'restrict' }),
+    /** Official NEC paper code: 'AExE01'..'AALL10'. Goes into the question content hash. */
+    necCode: text('nec_code').notNull(),
+    ordinal: integer('ordinal').notNull(),
+    slug: text('slug').notNull(),
+    /** Official NEC syllabus title. */
+    title: text('title').notNull(),
+    /** The shorter string the practice cards show. */
+    displayName: text('display_name').notNull(),
+    shortName: text('short_name').notNull(),
+    description: text('description'),
+    color: text('color').notNull().default('#6366f1'),
+    icon: text('icon').notNull().default('book'),
+    legacyDataFile: text('legacy_data_file'),
+    status: text('status', { enum: ['draft', 'published', 'retired'] })
+      .notNull()
+      .default('published'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    index('idx_chapters_subject_ordinal').on(t.subjectId, t.ordinal),
+    uniqueIndex('uq_chapters_nec_code').on(t.necCode),
+    uniqueIndex('uq_chapters_slug').on(t.subjectId, t.slug),
+    check(
+      'chapters_color',
+      sql`color GLOB '#[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'`
+    ),
+    check('chapters_ordinal', sql`ordinal > 0`),
+  ]
+);
+
+/** The 60 official NEC syllabus codes, '1.1'..'10.6'. Six per chapter. */
+export const subchapters = sqliteTable(
+  'subchapters',
+  {
+    id: text('id').primaryKey(),
+    chapterId: text('chapter_id')
+      .notNull()
+      .references(() => chapters.id, { onDelete: 'cascade' }),
+    code: text('code').notNull(),
+    ordinal: integer('ordinal').notNull(),
+    title: text('title').notNull(),
+    /** The NEC syllabus paragraph verbatim. It is the authoritative scope statement. */
+    description: text('description'),
+    status: text('status', { enum: ['draft', 'published', 'retired'] })
+      .notNull()
+      .default('published'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    index('idx_subchapters_chapter_ordinal').on(t.chapterId, t.ordinal),
+    uniqueIndex('uq_subchapters_code').on(t.code),
+    check('subchapters_ordinal', sql`ordinal > 0`),
+    check('subchapters_code', sql`code GLOB '[0-9]*.[0-9]*'`),
+  ]
+);
+
+/**
+ * questions -- NO ANSWER COLUMN, by design. See migrations/0002_content.sql.
+ * `id` is `'q_' || substr(content_hash, 1, 16)`: identity is content, never
+ * array position.
+ */
+export const questions = sqliteTable(
+  'questions',
+  {
+    id: text('id').primaryKey(),
+    /** Full sha256 hex, 64 chars, UNIQUE. A 16-hex prefix collision fails the PK insert. */
+    contentHash: text('content_hash').notNull(),
+    subjectId: text('subject_id')
+      .notNull()
+      .references(() => subjects.id, { onDelete: 'restrict' }),
+    chapterId: text('chapter_id')
+      .notNull()
+      .references(() => chapters.id, { onDelete: 'restrict' }),
+    /**
+     * NULL until classified. A label is never anonymous: `subchapterSource`
+     * records whether a person decided it or the term-matching classifier
+     * derived it, and 0009's triggers refuse any combination where the label
+     * and its provenance disagree.
+     */
+    subchapterId: text('subchapter_id').references(() => subchapters.id, { onDelete: 'set null' }),
+    /** 'human' is authoritative; 'heuristic' is a classifier hint. */
+    subchapterSource: text('subchapter_source', { enum: ['human', 'heuristic'] }),
+    /** Classifier confidence, 0-10000 bp. NULL for human labels. */
+    subchapterConfidenceBp: integer('subchapter_confidence_bp'),
+    /** Which classifier produced a heuristic label, so term-list changes are traceable. */
+    subchapterClassifierVersion: text('subchapter_classifier_version'),
+    stem: text('stem').notNull(),
+    stemFormat: text('stem_format', { enum: ['plain', 'markdown', 'latex'] })
+      .notNull()
+      .default('plain'),
+    /** 'published' is the ONLY status the delivery path may select. */
+    status: text('status', { enum: ['draft', 'published', 'flagged', 'retired'] })
+      .notNull()
+      .default('draft'),
+    statusReason: text('status_reason', {
+      enum: [
+        'KEY_CONFLICT',
+        'INDEX_RANGE',
+        'OPTION_DUPLICATE',
+        'OPTION_MULTIPLE_TRUE',
+        'OPTION_COUNT',
+        'EMPTY_STEM',
+        'DUPLICATE_ANSWER_CONFLICT',
+        'USER_REPORT',
+        'DUPLICATE',
+        'OUT_OF_SYLLABUS',
+        'EDITORIAL',
+      ],
+    }),
+    statusChangedAt: integer('status_changed_at').notNull().default(nowMs),
+    /** Editorial judgement. `pValueBp` is the observed reality. */
+    difficulty: text('difficulty', { enum: ['easy', 'medium', 'hard'] }),
+    pValueBp: integer('p_value_bp'),
+    pValueN: integer('p_value_n').notNull().default(0),
+    /** 1 if any option must stay last ('All of the above'). The permuter must honour it. */
+    hasPinnedOptions: integer('has_pinned_options').notNull().default(0),
+    source: text('source', { enum: ['book-import', 'contributor', 'past-paper', 'generated'] })
+      .notNull()
+      .default('book-import'),
+    sourceRef: text('source_ref'),
+    /** Old `{topicId}_{arrayIndex}` id. Import + one-time client migration ONLY. */
+    legacyId: text('legacy_id'),
+    /** Lineage when an edit replaces this question. Self-referential. */
+    supersededBy: text('superseded_by').references((): AnySQLiteColumn => questions.id, {
+      onDelete: 'set null',
+    }),
+    createdBy: text('created_by').references(() => users.id, { onDelete: 'set null' }),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    uniqueIndex('uq_questions_content_hash').on(t.contentHash),
+    uniqueIndex('uq_questions_legacy_id').on(t.legacyId).where(sql`legacy_id IS NOT NULL`),
+    index('idx_questions_published_chapter')
+      .on(t.chapterId, t.id)
+      .where(sql`status = 'published'`),
+    index('idx_questions_published_subchapter')
+      .on(t.subchapterId, t.id)
+      .where(sql`status = 'published' AND subchapter_id IS NOT NULL`),
+    index('idx_questions_moderation')
+      .on(t.status, t.statusChangedAt)
+      .where(sql`status IN ('draft', 'flagged')`),
+    index('idx_questions_unclassified').on(t.chapterId, t.id).where(sql`subchapter_id IS NULL`),
+    /** The sub-chapter review queue: weakest heuristic labels first. */
+    index('idx_questions_subchapter_review')
+      .on(t.subchapterConfidenceBp, t.chapterId)
+      .where(sql`subchapter_source = 'heuristic'`),
+    check('questions_content_hash', sql`length(content_hash) = 64 AND content_hash GLOB '[0-9a-f]*'`),
+    check('questions_id_from_hash', sql`id = 'q_' || substr(content_hash, 1, 16)`),
+    check('questions_stem_nonblank', sql`length(trim(stem)) > 0`),
+    check('questions_p_value_bp', sql`p_value_bp IS NULL OR p_value_bp BETWEEN 0 AND 10000`),
+    check('questions_has_pinned_options', sql`has_pinned_options IN (0, 1)`),
+    check('questions_flagged_needs_reason', sql`status <> 'flagged' OR status_reason IS NOT NULL`),
+    check('questions_superseded_by', sql`superseded_by IS NULL OR superseded_by <> id`),
+    check(
+      'questions_subchapter_confidence_bp',
+      sql`subchapter_confidence_bp IS NULL OR subchapter_confidence_bp BETWEEN 0 AND 10000`
+    ),
+  ]
+);
+
+/**
+ * question_options -- its own table, never a JSON array.
+ *
+ * `id` is `question_id || '#' || opt_key`, enforced by a CHECK, where `opt_key`
+ * is 12 CSPRNG base32 characters. It USED to be `|| ordinal`, and that was a
+ * real leak: the bank ships as public JSON carrying `correct_option_index` and
+ * is in git history forever, so an ordinal-bearing option id reaching a client
+ * recovered the whole answer key with no database access. Read the block above
+ * `question_options` in migrations/0002_content.sql before changing this.
+ *
+ * `ordinal` survives as the authored slot (1-based, the N in optN) and is NEVER
+ * REUSED, so an option edit can never re-point a historical answer -- but it is
+ * SERVER-ONLY: no view, no delivery query, no response body. Display order is
+ * not here either; see `attemptQuestions.optionOrder`.
+ */
+export const questionOptions = sqliteTable(
+  'question_options',
+  {
+    id: text('id').primaryKey(),
+    questionId: text('question_id')
+      .notNull()
+      .references(() => questions.id, { onDelete: 'cascade' }),
+    /** Authored slot. SERVER-ONLY -- never delivered, never in a view. */
+    ordinal: integer('ordinal').notNull(),
+    /** The id discriminator: 12 CSPRNG base32 chars, carrying no information. */
+    optKey: text('opt_key').notNull(),
+    text: text('text').notNull(),
+    textFormat: text('text_format', { enum: ['plain', 'markdown', 'latex'] })
+      .notNull()
+      .default('plain'),
+    textNorm: text('text_norm').generatedAlwaysAs(sql`(lower(trim(text)))`, { mode: 'stored' }),
+    /** 'All of the above' and friends. The permuter pins these last. */
+    isPinned: integer('is_pinned').notNull().default(0),
+    /** Set instead of deleting, so no ordinal is ever freed for reuse. */
+    retiredAt: integer('retired_at'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    uniqueIndex('uq_question_options_question_ordinal').on(t.questionId, t.ordinal),
+    /** Parent side of attemptAnswers' composite foreign key. */
+    uniqueIndex('uq_question_options_question_opt_key').on(t.questionId, t.optKey),
+    uniqueIndex('uq_question_options_question_text')
+      .on(t.questionId, t.textNorm)
+      .where(sql`retired_at IS NULL`),
+    check('question_options_ordinal', sql`ordinal BETWEEN 1 AND 26`),
+    check('question_options_is_pinned', sql`is_pinned IN (0, 1)`),
+    check(
+      'question_options_opt_key_shape',
+      sql`length(opt_key) = 12 AND opt_key GLOB '[0-9A-Z]*'`
+    ),
+    check('question_options_id_shape', sql`id = question_id || '#' || opt_key`),
+    check('question_options_text_nonblank', sql`length(trim(text)) > 0`),
+  ]
+);
+
+/**
+ * *** SERVER-ONLY. DO NOT NAME THIS TABLE IN A HANDLER THAT RESPONDS BEFORE
+ * *** AN ATTEMPT IS SUBMITTED. ***
+ *
+ * The only place the answer key exists. The three permitted queries are
+ * written out in migrations/0002_content.sql (NQ-10, NQ-10b, NQ-10c) and
+ * repeated in worker/README.md.
+ */
+export const questionAnswerKeys = sqliteTable(
+  'question_answer_keys',
+  {
+    questionId: text('question_id')
+      .primaryKey()
+      .references(() => questions.id, { onDelete: 'cascade' }),
+    correctOptionId: text('correct_option_id')
+      .notNull()
+      .references(() => questionOptions.id, { onDelete: 'cascade' }),
+    source: text('source', { enum: ['import', 'editor', 'adjudication'] })
+      .notNull()
+      .default('import'),
+    /** The source JSON's 1-based `correct_option_index`. Audit only. */
+    authoredIndex: integer('authored_index'),
+    authoredText: text('authored_text'),
+    verifiedBy: text('verified_by').references(() => users.id, { onDelete: 'set null' }),
+    verifiedAt: integer('verified_at'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  () => [
+    check(
+      'question_answer_keys_same_question',
+      sql`substr(correct_option_id, 1, length(question_id) + 1) = question_id || '#'`
+    ),
+    check('question_answer_keys_verified', sql`verified_at IS NULL OR verified_by IS NOT NULL`),
+  ]
+);
+
+/**
+ * The shape the delivery path reads. A SQLite view grants nothing -- its value
+ * is that it is the shortest correct thing to write, and it cannot reference
+ * `question_answer_keys`, so `SELECT *` over it is safe by construction.
+ */
+export const vQuestionDelivery = sqliteView('v_question_delivery', {
+  questionId: text('question_id').notNull(),
+  chapterId: text('chapter_id').notNull(),
+  subchapterId: text('subchapter_id'),
+  stem: text('stem').notNull(),
+  stemFormat: text('stem_format').notNull(),
+  difficulty: text('difficulty'),
+  optionId: text('option_id').notNull(),
+  optionOrdinal: integer('option_ordinal').notNull(),
+  optionText: text('option_text').notNull(),
+  optionTextFormat: text('option_text_format').notNull(),
+  optionIsPinned: integer('option_is_pinned').notNull(),
+}).existing();
+
+export const explanations = sqliteTable(
+  'explanations',
+  {
+    id: integer('id').primaryKey(),
+    questionId: text('question_id')
+      .notNull()
+      .references(() => questions.id, { onDelete: 'cascade' }),
+    body: text('body').notNull(),
+    bodyFormat: text('body_format', { enum: ['plain', 'markdown', 'latex'] })
+      .notNull()
+      .default('markdown'),
+    /** The distractor this paragraph explains, when kind = 'distractor'. */
+    aboutOptionId: text('about_option_id').references(() => questionOptions.id, {
+      onDelete: 'set null',
+    }),
+    kind: text('kind', { enum: ['solution', 'distractor', 'hint', 'reference'] })
+      .notNull()
+      .default('solution'),
+    isPrimary: integer('is_primary').notNull().default(0),
+    status: text('status', { enum: ['draft', 'published', 'rejected'] })
+      .notNull()
+      .default('draft'),
+    /**
+     * Provenance, independent of `status`. The UI badges an `ai_draft`; see the
+     * delivery rule in migrations/0002_content.sql.
+     */
+    origin: text('origin', { enum: ['ai_draft', 'ai_reviewed', 'human'] })
+      .notNull()
+      .default('human'),
+    generatorModel: text('generator_model'),
+    generatorPromptVersion: text('generator_prompt_version'),
+    generatedAt: integer('generated_at'),
+    /** Model-reported confidence in basis points. Advisory; gates nothing. */
+    generatorConfidenceBp: integer('generator_confidence_bp'),
+    authorUserId: text('author_user_id').references(() => users.id, { onDelete: 'set null' }),
+    reviewedBy: text('reviewed_by').references(() => users.id, { onDelete: 'set null' }),
+    reviewedAt: integer('reviewed_at'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    index('idx_explanations_question_published')
+      .on(t.questionId, sql`is_primary DESC`, t.id)
+      .where(sql`status = 'published'`),
+    uniqueIndex('uq_explanations_primary')
+      .on(t.questionId)
+      .where(sql`is_primary = 1 AND status = 'published'`),
+    index('idx_explanations_draft').on(t.id).where(sql`status = 'draft'`),
+    index('idx_explanations_ai_draft_published')
+      .on(t.generatorConfidenceBp, t.questionId)
+      .where(sql`origin = 'ai_draft' AND status = 'published'`),
+    check('explanations_is_primary', sql`is_primary IN (0, 1)`),
+    check(
+      'explanations_confidence_range',
+      sql`generator_confidence_bp IS NULL
+                                          OR generator_confidence_bp BETWEEN 0 AND 10000`
+    ),
+    check(
+      'explanations_generator_provenance',
+      sql`
+    CASE WHEN origin IN ('ai_draft', 'ai_reviewed')
+         THEN generator_model IS NOT NULL
+              AND generator_prompt_version IS NOT NULL
+              AND generated_at IS NOT NULL
+         ELSE generator_model IS NULL
+              AND generator_prompt_version IS NULL
+              AND generated_at IS NULL
+              AND generator_confidence_bp IS NULL
+    END
+  `
+    ),
+    check(
+      'explanations_reviewed_complete',
+      sql`
+    CASE WHEN origin = 'ai_reviewed'
+         THEN reviewed_by IS NOT NULL AND reviewed_at IS NOT NULL
+         ELSE 1
+    END
+  `
+    ),
+    check('explanations_reviewed_pair', sql`(reviewed_by IS NULL) = (reviewed_at IS NULL)`),
+    check(
+      'explanations_same_question',
+      sql`about_option_id IS NULL
+         OR substr(about_option_id, 1, length(question_id) + 1) = question_id || '#'`
+    ),
+    check('explanations_body_nonblank', sql`length(trim(body)) > 0`),
+    check('explanations_distractor_target', sql`kind <> 'distractor' OR about_option_id IS NOT NULL`),
+  ]
+);
+
+export const tags = sqliteTable(
+  'tags',
+  {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    kind: text('kind', { enum: ['concept', 'skill', 'exam_year', 'source', 'formula'] })
+      .notNull()
+      .default('concept'),
+    description: text('description'),
+    /** Trigger-maintained. See 0005. */
+    questionCount: integer('question_count').notNull().default(0),
+    createdAt: integer('created_at').notNull().default(nowMs),
+  },
+  (t) => [
+    index('idx_tags_kind_name').on(t.kind, t.name),
+    check('tags_id_slug', sql`id GLOB '[a-z0-9-]*'`),
+  ]
+);
+
+export const questionTags = sqliteTable(
+  'question_tags',
+  {
+    questionId: text('question_id')
+      .notNull()
+      .references(() => questions.id, { onDelete: 'cascade' }),
+    tagId: text('tag_id')
+      .notNull()
+      .references(() => tags.id, { onDelete: 'cascade' }),
+    /** < 100 means a classifier proposed it and no human confirmed. */
+    confidence: integer('confidence').notNull().default(100),
+    addedBy: text('added_by').references(() => users.id, { onDelete: 'set null' }),
+    createdAt: integer('created_at').notNull().default(nowMs),
+  },
+  (t) => [
+    primaryKey({ columns: [t.questionId, t.tagId] }),
+    index('idx_question_tags_tag').on(t.tagId, t.questionId),
+    check('question_tags_confidence', sql`confidence BETWEEN 0 AND 100`),
+  ]
+);
+
+/** User-reported errata AND the importer's own validator findings. One object, one queue. */
+export const questionReports = sqliteTable(
+  'question_reports',
+  {
+    id: integer('id').primaryKey(),
+    publicId: text('public_id').notNull(),
+    questionId: text('question_id')
+      .notNull()
+      .references(() => questions.id, { onDelete: 'cascade' }),
+    /** NULL for validator/import findings: no human reported them. */
+    reporterUserId: text('reporter_user_id').references(() => users.id, { onDelete: 'set null' }),
+    source: text('source', { enum: ['user', 'validator', 'import', 'admin'] })
+      .notNull()
+      .default('user'),
+    category: text('category', {
+      enum: [
+        'wrong_answer',
+        'typo',
+        'ambiguous',
+        'duplicate',
+        'out_of_syllabus',
+        'bad_option',
+        'other',
+      ],
+    }).notNull(),
+    code: text('code', {
+      enum: [
+        'KEY_CONFLICT',
+        'INDEX_RANGE',
+        'OPTION_DUPLICATE',
+        'OPTION_COUNT',
+        'EMPTY_STEM',
+        'DUPLICATE_ANSWER_CONFLICT',
+        'OPTION_MULTIPLE_TRUE',
+      ],
+    }),
+    detail: text('detail'),
+    /** An unadjudicated claim. It must NOT sit in the table the grader reads. */
+    suggestedOptionId: text('suggested_option_id').references(() => questionOptions.id, {
+      onDelete: 'set null',
+    }),
+    /** Soft reference to attempts.id -- a report must outlive answer archival. */
+    attemptId: integer('attempt_id'),
+    status: text('status', { enum: ['open', 'triaged', 'accepted', 'rejected', 'duplicate'] })
+      .notNull()
+      .default('open'),
+    resolution: text('resolution'),
+    resolvedBy: text('resolved_by').references(() => users.id, { onDelete: 'set null' }),
+    resolvedAt: integer('resolved_at'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    uniqueIndex('uq_question_reports_public_id').on(t.publicId),
+    index('idx_question_reports_open').on(t.createdAt).where(sql`status = 'open'`),
+    index('idx_question_reports_question').on(t.questionId, sql`id DESC`),
+    uniqueIndex('uq_question_reports_open_by_reporter')
+      .on(t.questionId, t.reporterUserId)
+      .where(sql`status = 'open' AND reporter_user_id IS NOT NULL`),
+    check(
+      'question_reports_same_question',
+      sql`suggested_option_id IS NULL
+         OR substr(suggested_option_id, 1, length(question_id) + 1) = question_id || '#'`
+    ),
+    check(
+      'question_reports_resolved',
+      sql`resolved_at IS NULL OR status IN ('accepted', 'rejected', 'duplicate')`
+    ),
+    check(
+      'question_reports_machine_has_no_reporter',
+      sql`source NOT IN ('validator', 'import') OR reporter_user_id IS NULL`
+    ),
+  ]
+);
+
+export const contentVersions = sqliteTable(
+  'content_versions',
+  {
+    id: integer('id').primaryKey(),
+    entityType: text('entity_type', {
+      enum: [
+        'question',
+        'question_option',
+        'question_answer_key',
+        'explanation',
+        'chapter',
+        'subchapter',
+        'tag',
+        'mock_test_template',
+      ],
+    }).notNull(),
+    entityId: text('entity_id').notNull(),
+    version: integer('version').notNull(),
+    op: text('op', { enum: ['create', 'update', 'delete', 'status_change'] }).notNull(),
+    /** Full post-change state. The question an errata dispute always turns into. */
+    snapshotJson: text('snapshot_json').notNull(),
+    diffJson: text('diff_json'),
+    actorUserId: text('actor_user_id').references(() => users.id, { onDelete: 'set null' }),
+    actorKind: text('actor_kind', { enum: ['user', 'importer', 'validator', 'system'] })
+      .notNull()
+      .default('user'),
+    reason: text('reason'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+  },
+  (t) => [
+    uniqueIndex('uq_content_versions_entity_version').on(t.entityType, t.entityId, t.version),
+    index('idx_content_versions_actor').on(t.actorUserId, sql`id DESC`),
+    check('content_versions_version', sql`version > 0`),
+    check('content_versions_snapshot_json', sql`json_valid(snapshot_json)`),
+    check('content_versions_diff_json', sql`diff_json IS NULL OR json_valid(diff_json)`),
+  ]
+);
+
+// ===========================================================================
+// 0003_search.sql
+// ===========================================================================
+
+/**
+ * FTS5 virtual table, maintained by the six triggers in 0003. Declared here
+ * only so NQ-11 can be written with typed columns; Drizzle must never be asked
+ * to generate DDL for it. `rowid` is kept equal to `questions.rowid` so every
+ * trigger deletes by rowid rather than scanning.
+ */
+export const questionsFts = sqliteTable('questions_fts', {
+  rowid: integer('rowid').primaryKey(),
+  questionId: text('question_id').notNull(),
+  chapterId: text('chapter_id').notNull(),
+  status: text('status').notNull(),
+  stem: text('stem').notNull(),
+  options: text('options').notNull(),
+});
+
+// ===========================================================================
+// 0004_assessment.sql
+// ===========================================================================
+
+export const mockTestTemplates = sqliteTable(
+  'mock_test_templates',
+  {
+    id: text('id').primaryKey(),
+    subjectId: text('subject_id')
+      .notNull()
+      .references(() => subjects.id, { onDelete: 'restrict' }),
+    slug: text('slug').notNull(),
+    name: text('name').notNull(),
+    description: text('description'),
+    durationMinutes: integer('duration_minutes').notNull(),
+    totalQuestions: integer('total_questions').notNull(),
+    /** TEXT holding JSON. SQLite has no jsonb. Shape documented in 0004. */
+    blueprint: text('blueprint', { mode: 'json' }).notNull(),
+    selection: text('selection', { enum: ['random', 'static'] })
+      .notNull()
+      .default('random'),
+    status: text('status', { enum: ['draft', 'published', 'retired'] })
+      .notNull()
+      .default('published'),
+    ordinal: integer('ordinal').notNull().default(0),
+    createdBy: text('created_by').references(() => users.id, { onDelete: 'set null' }),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    uniqueIndex('uq_mock_test_templates_slug').on(t.slug),
+    index('idx_mock_test_templates_subject_ordinal')
+      .on(t.subjectId, t.ordinal)
+      .where(sql`status = 'published'`),
+    check('mock_test_templates_duration', sql`duration_minutes BETWEEN 1 AND 600`),
+    check('mock_test_templates_total', sql`total_questions BETWEEN 1 AND 500`),
+    check('mock_test_templates_blueprint_json', sql`json_valid(blueprint)`),
+    check('mock_test_templates_blueprint_rules', sql`json_type(blueprint, '$.rules') = 'array'`),
+    check('mock_test_templates_blueprint_version', sql`json_extract(blueprint, '$.version') = 1`),
+  ]
+);
+
+/**
+ * attempts -- `id` is an INTEGER rowid alias and `publicId` is what appears in
+ * URLs. The split exists because every `attemptAnswers` row carries the
+ * attempt reference, and that table is unbounded (see 0004).
+ */
+export const attempts = sqliteTable(
+  'attempts',
+  {
+    id: integer('id').primaryKey(),
+    publicId: text('public_id').notNull(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    mode: text('mode', {
+      enum: ['practice', 'mock', 'srs', 'bookmark_review', 'weak_areas'],
+    }).notNull(),
+    templateId: text('template_id').references(() => mockTestTemplates.id, {
+      onDelete: 'restrict',
+    }),
+    chapterId: text('chapter_id').references(() => chapters.id, { onDelete: 'restrict' }),
+    subchapterId: text('subchapter_id').references(() => subchapters.id, { onDelete: 'restrict' }),
+    status: text('status', { enum: ['in_progress', 'submitted', 'abandoned', 'expired'] })
+      .notNull()
+      .default('in_progress'),
+    /** Reproduces the exact delivered paper for a dispute. */
+    optionSeed: integer('option_seed').notNull(),
+    questionCount: integer('question_count').notNull().default(0),
+    /** Trigger-maintained (0005), so history survives answer archival. */
+    answeredCount: integer('answered_count').notNull().default(0),
+    correctCount: integer('correct_count').notNull().default(0),
+    /** Basis points, generated STORED. Exact, sortable, indexable. */
+    scoreBp: integer('score_bp').generatedAlwaysAs(
+      sql`(CASE WHEN question_count = 0 THEN 0 ELSE (correct_count * 10000) / question_count END)`,
+      { mode: 'stored' }
+    ),
+    startedAt: integer('started_at').notNull().default(nowMs),
+    /** Server-side clock for a timed mock. The client countdown is a convenience. */
+    deadlineAt: integer('deadline_at'),
+    submittedAt: integer('submitted_at'),
+    elapsedMs: integer('elapsed_ms'),
+    /**
+     * THE PRE-DEADLINE SNAPSHOT: `{ "<question_id>": "<option_ref>" }`, the
+     * last answer map the server accepted strictly before `deadlineAt`.
+     *
+     * Written only by an UPDATE carrying `AND ?now <= deadline_at`, so its
+     * contents are a pre-deadline state by construction, and a CHECK
+     * (`last_sync_at <= deadline_at`) makes that the database's rule rather
+     * than one handler's. On a submission past the grace window the submitted
+     * payload is discarded and THIS is scored, which is what makes freezing
+     * the client timer worthless. Without these two columns a late submission
+     * could only be zeroed or trusted wholesale, and both are wrong.
+     */
+    syncedAnswers: text('synced_answers', { mode: 'json' }).$type<Record<string, string>>(),
+    lastSyncAt: integer('last_sync_at'),
+    clientMeta: text('client_meta', { mode: 'json' }),
+  },
+  (t) => [
+    uniqueIndex('uq_attempts_public_id').on(t.publicId),
+    index('idx_attempts_user_in_progress')
+      .on(t.userId, sql`started_at DESC`)
+      .where(sql`status = 'in_progress'`),
+    index('idx_attempts_user_submitted')
+      .on(t.userId, sql`submitted_at DESC`)
+      .where(sql`status = 'submitted'`),
+    index('idx_attempts_deadline')
+      .on(t.deadlineAt)
+      .where(sql`status = 'in_progress' AND deadline_at IS NOT NULL`),
+    index('idx_attempts_submitted_at').on(t.submittedAt).where(sql`submitted_at IS NOT NULL`),
+    check('attempts_question_count', sql`question_count >= 0`),
+    check('attempts_answered_count', sql`answered_count >= 0`),
+    check('attempts_correct_count', sql`correct_count >= 0`),
+    check('attempts_client_meta_json', sql`client_meta IS NULL OR json_valid(client_meta)`),
+    check('attempts_correct_le_answered', sql`correct_count <= answered_count`),
+    check('attempts_answered_le_total', sql`answered_count <= question_count`),
+    check('attempts_submitted_at', sql`(status = 'submitted') = (submitted_at IS NOT NULL)`),
+    check('attempts_mock_needs_template', sql`mode <> 'mock' OR template_id IS NOT NULL`),
+    check('attempts_subchapter_needs_chapter', sql`subchapter_id IS NULL OR chapter_id IS NOT NULL`),
+    check('attempts_sync_pair', sql`(synced_answers IS NULL) = (last_sync_at IS NULL)`),
+    check(
+      'attempts_sync_before_deadline',
+      sql`last_sync_at IS NULL OR deadline_at IS NULL OR last_sync_at <= deadline_at`
+    ),
+  ]
+);
+
+/**
+ * attempt_questions -- the delivered paper. `optionOrder` is a JSON array of
+ * OPTION IDS in the order this attempt showed them; ids, never indices,
+ * because joining an index against the public JSON bank in git history is the
+ * attack being closed.
+ */
+export const attemptQuestions = sqliteTable(
+  'attempt_questions',
+  {
+    attemptId: integer('attempt_id')
+      .notNull()
+      .references(() => attempts.id, { onDelete: 'cascade' }),
+    position: integer('position').notNull(),
+    questionId: text('question_id')
+      .notNull()
+      .references(() => questions.id, { onDelete: 'restrict' }),
+    optionOrder: text('option_order', { mode: 'json' }).notNull().$type<string[]>(),
+  },
+  (t) => [
+    primaryKey({ columns: [t.attemptId, t.position] }),
+    uniqueIndex('uq_attempt_questions_attempt_question').on(t.attemptId, t.questionId),
+    check('attempt_questions_position', sql`position >= 1`),
+    check(
+      'attempt_questions_option_order_json',
+      sql`json_valid(option_order) AND json_type(option_order) = 'array'`
+    ),
+  ]
+);
+
+/**
+ * attempt_answers -- THE ONLY UNBOUNDED TABLE ON THE PLATFORM. Measured at
+ * 132.4 bytes/row including its three indexes; ~3.9 M rows fit a 500 MB D1
+ * free database. Read the archival note in 0004 before adding a column, and
+ * NEVER add a DELETE trigger: archival deletes millions of these rows and a
+ * delete trigger on the rollups would erase every student's progress.
+ */
+export const attemptAnswers = sqliteTable(
+  'attempt_answers',
+  {
+    /** rowid alias, and the archival cursor (rowid order is insertion order). */
+    id: integer('id').primaryKey(),
+    attemptId: integer('attempt_id')
+      .notNull()
+      .references(() => attempts.id, { onDelete: 'cascade' }),
+    questionId: text('question_id')
+      .notNull()
+      .references(() => questions.id, { onDelete: 'restrict' }),
+    /** NULL = skipped. `questionOptions.optKey`, 12 base32 chars. */
+    selectedOptKey: text('selected_opt_key'),
+    /** VIRTUAL: zero bytes on disk, fully joinable. The stable option id, literally. */
+    selectedOptionId: text('selected_option_id').generatedAlwaysAs(
+      sql`(CASE WHEN selected_opt_key IS NULL THEN NULL
+                ELSE question_id || '#' || selected_opt_key END)`,
+      { mode: 'virtual' }
+    ),
+    /** Graded server-side at write time against questionAnswerKeys, then stored. */
+    isCorrect: integer('is_correct').notNull().default(0),
+    /** Screen position under this attempt's permutation. Analytics only, never grading. */
+    deliveredPosition: integer('delivered_position'),
+    timeMs: integer('time_ms'),
+    revised: integer('revised').notNull().default(0),
+    answeredAt: integer('answered_at').notNull().default(nowMs),
+  },
+  (t) => [
+    /**
+     * Proves the chosen key is a real option of that question. One index probe
+     * per insert, paid deliberately: an answer pointing at a nonexistent option
+     * is an unfixable silent mis-grade. SQLite skips the check when
+     * `selectedOptKey` is NULL, so a skipped answer costs nothing.
+     */
+    foreignKey({
+      columns: [t.questionId, t.selectedOptKey],
+      foreignColumns: [questionOptions.questionId, questionOptions.optKey],
+      name: 'fk_attempt_answers_question_option',
+    }),
+    uniqueIndex('uq_attempt_answers_attempt_question').on(t.attemptId, t.questionId),
+    index('idx_attempt_answers_answered_at').on(t.answeredAt),
+    index('idx_attempt_answers_question_correct').on(t.questionId, t.isCorrect),
+    check('attempt_answers_is_correct', sql`is_correct IN (0, 1)`),
+    check('attempt_answers_time_ms', sql`time_ms IS NULL OR time_ms >= 0`),
+    check('attempt_answers_revised', sql`revised IN (0, 1)`),
+    check(
+      'attempt_answers_opt_key_shape',
+      sql`selected_opt_key IS NULL
+         OR (length(selected_opt_key) = 12 AND selected_opt_key GLOB '[0-9A-Z]*')`
+    ),
+    check('attempt_answers_skipped_is_wrong', sql`selected_opt_key IS NOT NULL OR is_correct = 0`),
+  ]
+);
+
+/**
+ * Staging area for the retention job, in the SAME database -- so moving rows
+ * here frees NO space. The DELETE in 0004 step 2 is what reclaims pages, and
+ * the job that drains this to R2 is what makes the ceiling arithmetic true.
+ */
+export const attemptAnswersArchive = sqliteTable(
+  'attempt_answers_archive',
+  {
+    id: integer('id').primaryKey(),
+    /** Soft reference: the point of an archive row is to outlive its parents. */
+    attemptId: integer('attempt_id').notNull(),
+    /** Denormalised, because the attempt may already be gone. */
+    userId: text('user_id').notNull(),
+    questionId: text('question_id').notNull(),
+    selectedOptKey: text('selected_opt_key'),
+    isCorrect: integer('is_correct').notNull(),
+    deliveredPosition: integer('delivered_position'),
+    timeMs: integer('time_ms'),
+    answeredAt: integer('answered_at').notNull(),
+    archivedAt: integer('archived_at').notNull().default(nowMs),
+    /** NULL means this row is still only in D1 and deleting it would lose data. */
+    r2ObjectKey: text('r2_object_key'),
+  },
+  (t) => [
+    index('idx_attempt_answers_archive_undrained').on(t.id).where(sql`r2_object_key IS NULL`),
+    check('attempt_answers_archive_is_correct', sql`is_correct IN (0, 1)`),
+  ]
+);
+
+// ===========================================================================
+// 0005_learning.sql
+// ===========================================================================
+
+export const bookmarks = sqliteTable(
+  'bookmarks',
+  {
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    questionId: text('question_id')
+      .notNull()
+      .references(() => questions.id, { onDelete: 'cascade' }),
+    note: text('note'),
+    folder: text('folder'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+  },
+  (t) => [
+    primaryKey({ columns: [t.userId, t.questionId] }),
+    index('idx_bookmarks_user_created').on(t.userId, sql`created_at DESC`),
+    index('idx_bookmarks_user_folder').on(t.userId, t.folder).where(sql`folder IS NOT NULL`),
+  ]
+);
+
+/**
+ * One FSRS card per (user, question). Column names and units are FSRS's so the
+ * open-source scheduler drops in without a translation layer. Scheduling runs
+ * in the Worker -- FSRS needs pow/exp and D1 does not guarantee SQLite's math
+ * functions.
+ */
+export const srsState = sqliteTable(
+  'srs_state',
+  {
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    questionId: text('question_id')
+      .notNull()
+      .references(() => questions.id, { onDelete: 'cascade' }),
+    /** Days until recall probability decays to 90%. */
+    stability: real('stability').notNull().default(0),
+    /** 1..10, intrinsic to the item for this user. */
+    difficulty: real('difficulty').notNull().default(5),
+    elapsedDays: real('elapsed_days').notNull().default(0),
+    scheduledDays: real('scheduled_days').notNull().default(0),
+    reps: integer('reps').notNull().default(0),
+    lapses: integer('lapses').notNull().default(0),
+    /** 0 New, 1 Learning, 2 Review, 3 Relearning. */
+    state: integer('state').notNull().default(0),
+    due: integer('due').notNull(),
+    lastReview: integer('last_review'),
+    /** 1..4 = Again, Hard, Good, Easy. */
+    lastRating: integer('last_rating'),
+    suspendedAt: integer('suspended_at'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    primaryKey({ columns: [t.userId, t.questionId] }),
+    index('idx_srs_state_user_due').on(t.userId, t.due).where(sql`suspended_at IS NULL`),
+    check('srs_state_stability', sql`stability >= 0.0`),
+    check('srs_state_difficulty', sql`difficulty BETWEEN 1.0 AND 10.0`),
+    check('srs_state_elapsed_days', sql`elapsed_days >= 0.0`),
+    check('srs_state_scheduled_days', sql`scheduled_days >= 0.0`),
+    check('srs_state_reps', sql`reps >= 0`),
+    check('srs_state_lapses', sql`lapses >= 0`),
+    check('srs_state_state', sql`state IN (0, 1, 2, 3)`),
+    check('srs_state_last_rating', sql`last_rating IS NULL OR last_rating BETWEEN 1 AND 4`),
+    check('srs_state_lapses_le_reps', sql`lapses <= reps`),
+    check('srs_state_reps_need_review', sql`reps = 0 OR last_review IS NOT NULL`),
+  ]
+);
+
+/** Wall-clock engagement, distinct from an `attempt` (a graded artefact). */
+export const studySessions = sqliteTable(
+  'study_sessions',
+  {
+    id: integer('id').primaryKey(),
+    publicId: text('public_id').notNull(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    kind: text('kind', { enum: ['practice', 'mock', 'review', 'srs', 'reading'] }).notNull(),
+    chapterId: text('chapter_id').references(() => chapters.id, { onDelete: 'set null' }),
+    subchapterId: text('subchapter_id').references(() => subchapters.id, { onDelete: 'set null' }),
+    /** Soft reference to attempts.id: activity history must outlive an attempt. */
+    attemptId: integer('attempt_id'),
+    startedAt: integer('started_at').notNull().default(nowMs),
+    endedAt: integer('ended_at'),
+    /** Generated, so "time studied" is never a client-supplied number. */
+    durationS: integer('duration_s').generatedAlwaysAs(
+      sql`(CASE WHEN ended_at IS NULL THEN 0 ELSE (ended_at - started_at) / 1000 END)`,
+      { mode: 'stored' }
+    ),
+    questionsSeen: integer('questions_seen').notNull().default(0),
+    questionsCorrect: integer('questions_correct').notNull().default(0),
+    /** TEXT 'YYYY-MM-DD' in the USER's timezone, written by the API. Never UTC. */
+    localDate: text('local_date').notNull(),
+  },
+  (t) => [
+    uniqueIndex('uq_study_sessions_public_id').on(t.publicId),
+    index('idx_study_sessions_user_started').on(t.userId, sql`started_at DESC`),
+    index('idx_study_sessions_user_local_date').on(
+      t.userId,
+      t.localDate,
+      t.durationS,
+      t.questionsSeen
+    ),
+    index('idx_study_sessions_open').on(t.userId, sql`started_at DESC`).where(sql`ended_at IS NULL`),
+    check('study_sessions_questions_seen', sql`questions_seen >= 0`),
+    check('study_sessions_questions_correct', sql`questions_correct >= 0`),
+    check(
+      'study_sessions_local_date',
+      sql`local_date GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]'`
+    ),
+    check('study_sessions_correct_le_seen', sql`questions_correct <= questions_seen`),
+    check('study_sessions_end_after_start', sql`ended_at IS NULL OR ended_at >= started_at`),
+  ]
+);
+
+/**
+ * One row per user. `lastActiveDate` is a calendar day in the USER's timezone,
+ * not a timestamp -- a streak is a statement about days, and UTC midnight is
+ * nobody's day boundary. Maintained by the API (NQ-32a); `longestLength` is
+ * ratcheted by a trigger so the caller cannot get that arithmetic wrong.
+ */
+export const streaks = sqliteTable(
+  'streaks',
+  {
+    userId: text('user_id')
+      .primaryKey()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    currentLength: integer('current_length').notNull().default(0),
+    longestLength: integer('longest_length').notNull().default(0),
+    lastActiveDate: text('last_active_date'),
+    totalActiveDays: integer('total_active_days').notNull().default(0),
+    /** A one-day grace token, so one missed day does not erase six weeks. */
+    freezesAvailable: integer('freezes_available').notNull().default(0),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  () => [
+    index('idx_streaks_current_length').on(sql`current_length DESC`).where(sql`current_length > 0`),
+    check('streaks_current_length', sql`current_length >= 0`),
+    check('streaks_longest_length', sql`longest_length >= 0`),
+    check(
+      'streaks_last_active_date',
+      sql`last_active_date IS NULL
+                                   OR last_active_date GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]'`
+    ),
+    check('streaks_total_active_days', sql`total_active_days >= 0`),
+    check('streaks_freezes', sql`freezes_available BETWEEN 0 AND 3`),
+    check('streaks_current_le_total', sql`current_length <= total_active_days`),
+  ]
+);
+
+/**
+ * The rollup the progress page reads (NQ-27: one covering index range scan,
+ * no join, ten groups). `chapterId` and `subchapterId` are denormalised from
+ * `questions` by the trigger precisely so that read needs no join.
+ *
+ * THERE IS NO DELETE TRIGGER ON attemptAnswers, and there must never be:
+ * archival deletes millions of answer rows, and a delete trigger that
+ * decremented these counters would erase every student's progress the first
+ * night the retention job ran.
+ */
+export const userQuestionStats = sqliteTable(
+  'user_question_stats',
+  {
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    questionId: text('question_id')
+      .notNull()
+      .references(() => questions.id, { onDelete: 'cascade' }),
+    chapterId: text('chapter_id').notNull(),
+    subchapterId: text('subchapter_id'),
+    /** Times shown, including skips. */
+    exposureCount: integer('exposure_count').notNull().default(0),
+    /** Times an option was actually chosen. */
+    answerCount: integer('answer_count').notNull().default(0),
+    correctCount: integer('correct_count').notNull().default(0),
+    consecutiveCorrect: integer('consecutive_correct').notNull().default(0),
+    /** Basis points, generated STORED -- the sort key for the weak-areas queue. */
+    accuracyBp: integer('accuracy_bp').generatedAlwaysAs(
+      sql`(CASE WHEN answer_count = 0 THEN 0 ELSE (correct_count * 10000) / answer_count END)`,
+      { mode: 'stored' }
+    ),
+    firstAnsweredAt: integer('first_answered_at'),
+    lastAnsweredAt: integer('last_answered_at'),
+    lastIsCorrect: integer('last_is_correct'),
+    updatedAt: integer('updated_at').notNull().default(nowMs),
+  },
+  (t) => [
+    primaryKey({ columns: [t.userId, t.questionId] }),
+    index('idx_user_question_stats_user_chapter').on(
+      t.userId,
+      t.chapterId,
+      t.correctCount,
+      t.answerCount
+    ),
+    index('idx_user_question_stats_user_subchapter')
+      .on(t.userId, t.subchapterId, t.correctCount, t.answerCount)
+      .where(sql`subchapter_id IS NOT NULL`),
+    index('idx_user_question_stats_user_accuracy')
+      .on(t.userId, t.accuracyBp, t.lastAnsweredAt)
+      .where(sql`answer_count > 0`),
+    index('idx_user_question_stats_question').on(t.questionId),
+    check('user_question_stats_exposure_count', sql`exposure_count >= 0`),
+    check('user_question_stats_answer_count', sql`answer_count >= 0`),
+    check('user_question_stats_correct_count', sql`correct_count >= 0`),
+    check('user_question_stats_consecutive_correct', sql`consecutive_correct >= 0`),
+    check('user_question_stats_last_is_correct', sql`last_is_correct IS NULL OR last_is_correct IN (0, 1)`),
+    check('user_question_stats_answer_le_exposure', sql`answer_count <= exposure_count`),
+    check('user_question_stats_correct_le_answer', sql`correct_count <= answer_count`),
+    check('user_question_stats_consecutive_le_correct', sql`consecutive_correct <= correct_count`),
+  ]
+);
+
+// ===========================================================================
+// 0006_engagement.sql
+// ===========================================================================
+
+/**
+ * Precomputed leaderboards. NEVER aggregate `attemptAnswers` live: D1 is
+ * single-threaded per database, so one such scan blocks every write behind it,
+ * bills millions of row reads per page view, and stops being correct the
+ * moment archival runs.
+ */
+export const leaderboardSnapshots = sqliteTable(
+  'leaderboard_snapshots',
+  {
+    id: integer('id').primaryKey(),
+    scope: text('scope', { enum: ['global', 'chapter', 'subchapter', 'template'] }).notNull(),
+    /** '' for global -- empty string, not NULL, so the unique index below works. */
+    scopeRef: text('scope_ref').notNull().default(''),
+    period: text('period', { enum: ['daily', 'weekly', 'monthly', 'all_time'] }).notNull(),
+    /** 'YYYY-MM-DD'. 'all_time' uses '0001-01-01'. */
+    periodStart: text('period_start').notNull(),
+    metric: text('metric', {
+      enum: [
+        'correct_answers',
+        'accuracy_bp',
+        'questions_answered',
+        'streak_length',
+        'mock_score_bp',
+      ],
+    })
+      .notNull()
+      .default('correct_answers'),
+    /** Rendered top-N with display fields denormalised, so the page is one query. */
+    topJson: text('top_json', { mode: 'json' }).notNull(),
+    entrantCount: integer('entrant_count').notNull().default(0),
+    computedAt: integer('computed_at').notNull().default(nowMs),
+    /** How long the snapshot took. The day this gets slow, revisit 0004's arithmetic. */
+    computeMs: integer('compute_ms'),
+  },
+  (t) => [
+    uniqueIndex('uq_leaderboard_snapshots_scope_period').on(
+      t.scope,
+      t.scopeRef,
+      t.period,
+      t.periodStart
+    ),
+    index('idx_leaderboard_snapshots_computed_at').on(t.computedAt),
+    check(
+      'leaderboard_snapshots_period_start',
+      sql`period_start GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]'`
+    ),
+    check(
+      'leaderboard_snapshots_top_json',
+      sql`json_valid(top_json) AND json_type(top_json) = 'array'`
+    ),
+    check('leaderboard_snapshots_entrant_count', sql`entrant_count >= 0`),
+    check(
+      'leaderboard_snapshots_all_time',
+      sql`period = 'all_time' OR period_start <> '0001-01-01'`
+    ),
+    check('leaderboard_snapshots_scope_ref', sql`(scope = 'global') = (scope_ref = '')`),
+  ]
+);
+
+export const leaderboardEntries = sqliteTable(
+  'leaderboard_entries',
+  {
+    /** leaderboard_snapshots.id, deliberately NOT a foreign key (see 0006 NQ-35d). */
+    snapshotId: integer('snapshot_id').notNull(),
+    rank: integer('rank').notNull(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    score: integer('score').notNull(),
+    accuracyBp: integer('accuracy_bp'),
+    /** Rank in the previous snapshot, so the UI shows movement without a second read. */
+    prevRank: integer('prev_rank'),
+  },
+  (t) => [
+    primaryKey({ columns: [t.snapshotId, t.rank] }),
+    uniqueIndex('uq_leaderboard_entries_snapshot_user').on(t.snapshotId, t.userId),
+    index('idx_leaderboard_entries_user').on(t.userId),
+    check('leaderboard_entries_rank', sql`rank >= 1`),
+    check(
+      'leaderboard_entries_accuracy_bp',
+      sql`accuracy_bp IS NULL OR accuracy_bp BETWEEN 0 AND 10000`
+    ),
+    check('leaderboard_entries_prev_rank', sql`prev_rank IS NULL OR prev_rank >= 1`),
+  ]
+);
+
+export const notifications = sqliteTable(
+  'notifications',
+  {
+    id: integer('id').primaryKey(),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    kind: text('kind', {
+      enum: [
+        'streak_risk',
+        'streak_milestone',
+        'srs_due',
+        'mock_result',
+        'report_resolved',
+        'contribution_reviewed',
+        'leaderboard_move',
+        'announcement',
+      ],
+    }).notNull(),
+    title: text('title').notNull(),
+    body: text('body'),
+    link: text('link'),
+    dataJson: text('data_json', { mode: 'json' }),
+    readAt: integer('read_at'),
+    createdAt: integer('created_at').notNull().default(nowMs),
+    expiresAt: integer('expires_at'),
+    /**
+     * Idempotency key, e.g. 'srs_due:2026-10-20'. The upsert MUST restate the
+     * partial predicate -- `ON CONFLICT (user_id, dedupe_key) WHERE dedupe_key
+     * IS NOT NULL DO NOTHING` -- or prepare() fails at runtime.
+     */
+    dedupeKey: text('dedupe_key'),
+  },
+  (t) => [
+    index('idx_notifications_user_unread')
+      .on(t.userId, sql`created_at DESC`)
+      .where(sql`read_at IS NULL`),
+    index('idx_notifications_user').on(t.userId, sql`id DESC`),
+    uniqueIndex('uq_notifications_user_dedupe')
+      .on(t.userId, t.dedupeKey)
+      .where(sql`dedupe_key IS NOT NULL`),
+    index('idx_notifications_expires_at').on(t.expiresAt).where(sql`expires_at IS NOT NULL`),
+    check('notifications_data_json', sql`data_json IS NULL OR json_valid(data_json)`),
+    check('notifications_title_nonblank', sql`length(trim(title)) > 0`),
+    check('notifications_expires_after_created', sql`expires_at IS NULL OR expires_at > created_at`),
+  ]
+);
+
+// ===========================================================================
+// 0008_api_infrastructure.sql
+// ===========================================================================
+
+/**
+ * The offline-replay contract. Keyed by `(userId, key)` because clients mint
+ * these themselves, so a global key space would let one user's key collide
+ * with -- or read back -- another user's stored response.
+ *
+ * A NULL `responseJson` is a RESERVATION, not a result: the handler claimed the
+ * key and is still working, and a concurrent duplicate gets 409
+ * REQUEST_IN_FLIGHT rather than scoring the same attempt twice.
+ */
+export const idempotencyKeys = sqliteTable(
+  'idempotency_keys',
+  {
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    key: text('key').notNull(),
+    endpoint: text('endpoint').notNull(),
+    /** sha256 of endpoint + canonicalised body, minus the key itself. */
+    requestHash: text('request_hash').notNull(),
+    statusCode: integer('status_code'),
+    responseJson: text('response_json', { mode: 'json' }),
+    createdAt: integer('created_at').notNull().default(nowMs),
+  },
+  (t) => [
+    primaryKey({ columns: [t.userId, t.key] }),
+    index('idx_idempotency_keys_created_at').on(t.createdAt),
+    check('idempotency_keys_key_length', sql`length(key) BETWEEN 8 AND 80`),
+    check(
+      'idempotency_keys_request_hash',
+      sql`length(request_hash) = 64 AND request_hash GLOB '[0-9a-f]*'`
+    ),
+    check(
+      'idempotency_keys_status_code',
+      sql`status_code IS NULL OR status_code BETWEEN 100 AND 599`
+    ),
+    check(
+      'idempotency_keys_response_json',
+      sql`response_json IS NULL OR json_valid(response_json)`
+    ),
+    check('idempotency_keys_pair', sql`(status_code IS NULL) = (response_json IS NULL)`),
+  ]
+);
+
+/**
+ * Fixed-window counters. BEST-EFFORT BY CONSTRUCTION: D1 replicates
+ * asynchronously, so the effective limit is "roughly `limit` per window PER
+ * REGION". Adequate for credential stuffing and submit abuse; not a substitute
+ * for a Durable Object. `bucket` is `<rule>:<subject>` and the subject is a
+ * user id or a HASHED address -- this is a counter, not a log.
+ */
+export const rateLimits = sqliteTable(
+  'rate_limits',
+  {
+    bucket: text('bucket').primaryKey(),
+    /** `floor(now / windowMs) * windowMs`, so two Workers agree on the boundary. */
+    windowStart: integer('window_start').notNull(),
+    count: integer('count').notNull().default(0),
+  },
+  (t) => [
+    index('idx_rate_limits_window_start').on(t.windowStart),
+    check('rate_limits_count', sql`count >= 0`),
+    check('rate_limits_bucket_length', sql`length(bucket) BETWEEN 3 AND 160`),
+  ]
+);
+
+// ---------------------------------------------------------------------------
+// Inferred row types. Handlers should use these rather than hand-written
+// interfaces, so a column rename is a compile error.
+// ---------------------------------------------------------------------------
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+export type UserProfile = typeof userProfiles.$inferSelect;
+export type Session = typeof sessions.$inferSelect;
+export type Subject = typeof subjects.$inferSelect;
+export type Chapter = typeof chapters.$inferSelect;
+export type Subchapter = typeof subchapters.$inferSelect;
+export type Question = typeof questions.$inferSelect;
+export type QuestionOption = typeof questionOptions.$inferSelect;
+/** SERVER-ONLY. Never serialise this type into a pre-submit response. */
+export type QuestionAnswerKey = typeof questionAnswerKeys.$inferSelect;
+export type Explanation = typeof explanations.$inferSelect;
+export type Tag = typeof tags.$inferSelect;
+export type QuestionReport = typeof questionReports.$inferSelect;
+export type ContentVersion = typeof contentVersions.$inferSelect;
+export type MockTestTemplate = typeof mockTestTemplates.$inferSelect;
+export type Attempt = typeof attempts.$inferSelect;
+export type AttemptQuestion = typeof attemptQuestions.$inferSelect;
+export type AttemptAnswer = typeof attemptAnswers.$inferSelect;
+export type Bookmark = typeof bookmarks.$inferSelect;
+export type SrsState = typeof srsState.$inferSelect;
+export type StudySession = typeof studySessions.$inferSelect;
+export type Streak = typeof streaks.$inferSelect;
+export type UserQuestionStat = typeof userQuestionStats.$inferSelect;
+export type LeaderboardSnapshot = typeof leaderboardSnapshots.$inferSelect;
+export type LeaderboardEntry = typeof leaderboardEntries.$inferSelect;
+export type Notification = typeof notifications.$inferSelect;
+export type AdminAuditLogRow = typeof adminAuditLog.$inferSelect;
+export type OAuthAccount = typeof oauthAccounts.$inferSelect;
+export type OAuthState = typeof oauthStates.$inferSelect;
+export type IdempotencyKey = typeof idempotencyKeys.$inferSelect;
+export type RateLimit = typeof rateLimits.$inferSelect;
+
+/**
+ * The delivery projection. Note it has no `correctOptionId` field, and cannot:
+ * the view it reads does not join the key table.
+ */
+export type DeliveredQuestionRow = {
+  questionId: string;
+  chapterId: string;
+  subchapterId: string | null;
+  stem: string;
+  stemFormat: string;
+  difficulty: string | null;
+  optionId: string;
+  optionOrdinal: number;
+  optionText: string;
+  optionTextFormat: string;
+  optionIsPinned: number;
+};
diff --git a/worker/db/seed/export-content-sql.mjs b/worker/db/seed/export-content-sql.mjs
new file mode 100644
index 0000000..08fea8a
--- /dev/null
+++ b/worker/db/seed/export-content-sql.mjs
@@ -0,0 +1,166 @@
+/**
+ * Turn the seeded local database into SQL that can be replayed into remote D1.
+ *
+ *   node db/seed/export-content-sql.mjs
+ *   node db/seed/export-content-sql.mjs --out .local/remote --chunk 2000
+ *
+ * WHY THIS EXISTS RATHER THAN `wrangler d1 export`
+ * ------------------------------------------------
+ * `wrangler d1 export --local` exports the database `wrangler dev` uses —
+ * `.wrangler/state/v3/d1/miniflare-D1DatabaseObject/*.sqlite`. That is NOT the
+ * database `npm run db:seed:local` writes, which is `.local/necprep.sqlite`
+ * (see `db/apply.mjs`). Exporting the wrong file succeeds and produces an
+ * empty-looking import, which is the worst possible failure mode for a step
+ * whose whole purpose is "put the questions in production".
+ *
+ * It also emits the schema by default, and replaying CREATE TABLE against a
+ * database that already has the migrations applied fails.
+ *
+ * So: read the file the seed actually wrote, emit data only, and chunk it.
+ *
+ * WHAT IT EXPORTS
+ * ---------------
+ * Content only — questions, their options and their answer keys. Nothing
+ * user-owned: no users, sessions, attempts, answers or progress. That split is
+ * deliberate. Content is derived from files in git and is safe to replace
+ * wholesale; user data is not, and a seeding script that could touch it is a
+ * script that will one day delete somebody's attempt history.
+ *
+ * Reference data (subjects, chapters, sub-chapters, templates) is NOT exported
+ * either: it arrives via migration 0007, so it is already in the remote
+ * database before this file is replayed.
+ *
+ * INSERT OR REPLACE, not INSERT
+ * -----------------------------
+ * Re-running this must be safe. Question ids are content hashes, so a replay
+ * after a bank update overwrites the rows that changed and leaves the rest
+ * identical. `question_options.id` is `{question_id}#{opt_key}`, stable across
+ * re-imports by design (see the `RETURNING` note in import-questions.mjs), so
+ * replacing an option row does not orphan a recorded answer.
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const WORKER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const DEFAULT_DB = join(WORKER_ROOT, '.local', 'necprep.sqlite');
+
+/**
+ * Order matters: options and answer keys reference questions, and D1 enforces
+ * foreign keys. Answer keys last because they reference both.
+ */
+const TABLES = ['questions', 'question_options', 'question_answer_keys'];
+
+/**
+ * Statements per output file.
+ *
+ * `wrangler d1 execute --file` sends the file as one request, and a very large
+ * one is both slow and hard to retry from the middle. A few numbered files
+ * that can each be replayed independently is easier to recover from than one
+ * that half-applied.
+ */
+const DEFAULT_CHUNK = 2000;
+
+function arg(name, fallback) {
+  const i = process.argv.indexOf(name);
+  return i === -1 ? fallback : process.argv[i + 1];
+}
+
+const dbPath = resolve(arg('--db', DEFAULT_DB));
+const outDir = resolve(arg('--out', join(WORKER_ROOT, '.local', 'remote')));
+const chunkSize = Number.parseInt(arg('--chunk', String(DEFAULT_CHUNK)), 10);
+
+if (!Number.isInteger(chunkSize) || chunkSize < 1) {
+  console.error(`invalid --chunk ${String(chunkSize)}`);
+  process.exit(2);
+}
+
+if (!existsSync(dbPath)) {
+  console.error(
+    `no database at ${dbPath}.\n` +
+      'Run `npm run db:apply:local && npm run db:seed:local` first.',
+  );
+  process.exit(2);
+}
+
+/** SQLite literal. Single quotes doubled; blobs are not expected in content. */
+function literal(value) {
+  if (value === null || value === undefined) return 'NULL';
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) {
+      throw new Error(`cannot serialise non-finite number ${String(value)}`);
+    }
+    return String(value);
+  }
+  if (typeof value === 'bigint') return String(value);
+  if (typeof value === 'string') return `'${value.replace(/'/g, "''")}'`;
+  throw new Error(`cannot serialise ${typeof value}`);
+}
+
+const db = new DatabaseSync(dbPath);
+
+const files = [];
+let totalRows = 0;
+
+for (const table of TABLES) {
+  const columns = db
+    .prepare(`PRAGMA table_info(${table})`)
+    .all()
+    // Generated columns cannot be inserted into. `attempts.score_bp` is one;
+    // reading `hidden` rather than hardcoding a list means a future generated
+    // column does not silently break this export.
+    .filter((c) => c.hidden !== 2 && c.hidden !== 3)
+    .map((c) => c.name);
+
+  if (columns.length === 0) {
+    console.error(`! table ${table} not found in ${dbPath}`);
+    process.exit(1);
+  }
+
+  const rows = db.prepare(`SELECT ${columns.join(', ')} FROM ${table}`).all();
+  totalRows += rows.length;
+
+  const statements = rows.map(
+    (row) =>
+      `INSERT OR REPLACE INTO ${table} (${columns.join(', ')}) VALUES (` +
+      columns.map((c) => literal(row[c])).join(', ') +
+      ');',
+  );
+
+  for (let i = 0; i < statements.length; i += chunkSize) {
+    const part = statements.slice(i, i + chunkSize);
+    const index = String(files.length + 1).padStart(3, '0');
+    files.push({
+      name: `${index}-${table}.sql`,
+      table,
+      statements: part.length,
+      body:
+        `-- ${table}: rows ${String(i + 1)}-${String(i + part.length)} of ${String(statements.length)}\n` +
+        '-- Generated by db/seed/export-content-sql.mjs. Safe to replay.\n' +
+        'PRAGMA defer_foreign_keys = TRUE;\n' +
+        part.join('\n') +
+        '\n',
+    });
+  }
+}
+
+db.close();
+
+mkdirSync(outDir, { recursive: true });
+for (const file of files) {
+  writeFileSync(join(outDir, file.name), file.body, 'utf8');
+}
+
+console.log(`read  ${dbPath}`);
+console.log(`wrote ${String(files.length)} file(s) to ${outDir}\n`);
+for (const file of files) {
+  console.log(`  ${file.name.padEnd(28)} ${String(file.statements).padStart(5)} statements`);
+}
+console.log(`\n  total ${String(totalRows)} rows\n`);
+console.log('Replay them into the remote database IN THIS ORDER:');
+console.log('  for f in .local/remote/*.sql; do');
+console.log('    npx wrangler d1 execute necprep --remote --file "$f" -y || break');
+console.log('  done');
+console.log('\nThe `|| break` matters: a later file references rows an earlier one inserts.');
diff --git a/worker/db/seed/generate-reference-sql.mjs b/worker/db/seed/generate-reference-sql.mjs
new file mode 100644
index 0000000..0229947
--- /dev/null
+++ b/worker/db/seed/generate-reference-sql.mjs
@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+// Extracts SYLLABUS from BookPractice.tsx and bookChapters from the generated
+// manifest, and emits 0007_reference_data.sql.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { examFormat, readConfirmed } from '../../../frontend/src/data/examBlueprint.ts';
+
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// worker/db/seed/ -> repo root
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
+const src = readFileSync(`${ROOT}/frontend/src/pages/app/BookPractice.tsx`, 'utf8');
+const start = src.indexOf('const SYLLABUS = [');
+const end = src.indexOf('\n];', start) + 3;
+const literal = src.slice(start + 'const SYLLABUS = '.length, end).replace(/;\s*$/, '');
+const SYLLABUS = eval(literal);
+
+const gen = readFileSync(`${ROOT}/frontend/src/data/bookChapters.generated.ts`, 'utf8');
+const chStart = gen.indexOf('[', gen.indexOf('export const bookChapters'));
+const chEnd = gen.indexOf('\n];', chStart) + 2;
+const chLiteral = gen.slice(chStart, chEnd).replace(/ as Topic\['icon'\]/g, '');
+const chapters = eval(chLiteral);
+
+if (SYLLABUS.length !== 10) throw new Error(`expected 10 syllabus chapters, got ${SYLLABUS.length}`);
+if (chapters.length !== 10) throw new Error(`expected 10 generated chapters, got ${chapters.length}`);
+const subCount = SYLLABUS.reduce((s, c) => s + c.topics.length, 0);
+if (subCount !== 60) throw new Error(`expected 60 subchapters, got ${subCount}`);
+
+const q = (v) => (v === null || v === undefined ? 'NULL' : `'${String(v).replace(/'/g, "''")}'`);
+const slugify = (s) =>
+  s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 60);
+
+const out = [];
+out.push(`-- 0007_reference_data.sql
+--
+-- GENERATED, then reviewed and committed. The source of truth for the official
+-- NEC syllabus in this repo was, until now, a 10-element array literal inside
+-- a React component (frontend/src/pages/app/BookPractice.tsx) plus a second
+-- array generated from the question files
+-- (frontend/src/data/bookChapters.generated.ts). This migration lifts both
+-- into the database once, so there is one copy of the syllabus and the client
+-- reads it instead of shipping it.
+--
+-- It is a migration rather than a seed script because it is reference data:
+-- ten chapters and sixty syllabus codes published by a regulator. It changes
+-- when NEC changes the syllabus, which is a versioned event and exactly what a
+-- migration is for. The 2,290 questions are NOT here -- they are bulk data and
+-- they load through worker/db/seed/import-questions.mjs.
+--
+-- Reproduce with: node worker/db/seed/generate-reference-sql.mjs
+-- which re-extracts from the two frontend files and overwrites this file.
+-- Verified at generation time: 10 chapters, 60 subchapters.
+
+INSERT INTO subjects (id, code, name, description, exam_board, ordinal, status) VALUES
+  ('nec-computer', 'NEC-CE',
+   'NEC Registration Exam -- Computer Engineering',
+   'Nepal Engineering Council registration examination syllabus for Computer Engineering (AExE / ACtE / AALL paper codes).',
+   'Nepal Engineering Council', 1, 'published');
+`);
+
+out.push(`
+-- Chapters. \`id\` keeps the existing frontend identifier so client routes and
+-- stored progress keys survive the cutover. \`title\` is the official NEC
+-- syllabus title, \`display_name\` the shorter string the practice cards show.
+INSERT INTO chapters (id, subject_id, nec_code, ordinal, slug, title, display_name,
+                      short_name, description, color, icon, legacy_data_file, status) VALUES`);
+
+const chapterRows = SYLLABUS.map((s, i) => {
+  const g = chapters[i];
+  const num = s.num;
+  if (num !== i + 1) throw new Error(`syllabus out of order at ${i}`);
+  if (g.id !== `book-ch${num}`) throw new Error(`chapter id mismatch: ${g.id} vs book-ch${num}`);
+  return `  (${q(g.id)}, 'nec-computer', ${q(s.code)}, ${num}, ${q(slugify(s.title))},
+   ${q(s.title)},
+   ${q(g.name)},
+   ${q(g.shortName)},
+   ${q(g.description)},
+   ${q(g.color)}, ${q(g.icon)}, ${q(g.dataFile)}, 'published')`;
+});
+out.push(chapterRows.join(',\n') + ';\n');
+
+out.push(`
+-- The 60 official syllabus codes, 1.1 .. 10.6. \`description\` is the NEC
+-- syllabus paragraph verbatim: it is the authoritative statement of what is
+-- examinable, and paraphrasing it would be a silent change to the spec.
+INSERT INTO subchapters (id, chapter_id, code, ordinal, title, description, status) VALUES`);
+
+const subRows = [];
+for (const s of SYLLABUS) {
+  if (s.topics.length !== 6) throw new Error(`chapter ${s.num} has ${s.topics.length} topics`);
+  s.topics.forEach((t, j) => {
+    const expected = `${s.num}.${j + 1}`;
+    if (t.code !== expected) throw new Error(`subchapter code mismatch: ${t.code} vs ${expected}`);
+    subRows.push(`  (${q('nec-' + t.code)}, ${q('book-ch' + s.num)}, ${q(t.code)}, ${j + 1},
+   ${q(t.title)},
+   ${q(t.desc)}, 'published')`);
+  });
+}
+out.push(subRows.join(',\n') + ';\n');
+
+// Mock templates, reshaped to the sub-chapter-level blueprint of
+// frontend/src/data/examBlueprint.ts.
+//
+// DURATIONS ARE DERIVED, NOT WRITTEN HERE.
+//
+// They used to be literals -- 45 and 20 -- copied from topics.ts at a time
+// when that file also held literals. `examBlueprint.ts` later became the
+// single source of truth and was confirmed at 120 minutes by the project
+// owner; topics.ts was updated to derive from it and this file was not. The
+// result shipped to a live database: templates claiming 100 questions in 45
+// minutes, while the client showed 120. The server owns the deadline, so the
+// server would have won, and every candidate would have lost 75 minutes.
+//
+// `readConfirmed` refuses to return an unverified value, so a future change
+// that un-confirms the duration fails this generator rather than silently
+// seeding a guess.
+const FULL_MOCK_DURATION = readConfirmed(examFormat.durationMinutes);
+const FULL_MOCK_PER_CHAPTER = 10;
+const QUICK_PER_CHAPTER = 5;
+// Pro-rata on question count, matching the arithmetic in topics.ts exactly.
+const QUICK_DURATION = Math.round(
+  (FULL_MOCK_DURATION * QUICK_PER_CHAPTER) / FULL_MOCK_PER_CHAPTER,
+);
+
+const templates = [
+  { id: 'full-mock-1', slug: 'full-mock-1', name: 'Full Mock Test 1',
+    description: '100 questions across all 60 NEC syllabus codes -- a fresh set each time',
+    perChapter: FULL_MOCK_PER_CHAPTER, duration: FULL_MOCK_DURATION, ordinal: 1 },
+  { id: 'full-mock-2', slug: 'full-mock-2', name: 'Full Mock Test 2',
+    description: '100 questions across all 60 NEC syllabus codes -- different selection to Mock 1',
+    perChapter: FULL_MOCK_PER_CHAPTER, duration: FULL_MOCK_DURATION, ordinal: 2 },
+  { id: 'quick-test', slug: 'quick-test', name: 'Quick Assessment',
+    description: '50 questions, five per chapter, for a fast readiness check',
+    perChapter: QUICK_PER_CHAPTER, duration: QUICK_DURATION, ordinal: 3 },
+];
+
+/**
+ * largest-remainder (Hare quota) on EQUAL shares, with the tie broken by
+ * ascending sub-chapter index.
+ *
+ * This is `equal-chapter-weight-largest-remainder` from
+ * frontend/src/data/examBlueprint.ts, implemented here rather than imported
+ * because this script runs under plain node with no TypeScript loader. The
+ * assertion below is what keeps the two honest: the quotas it produces for
+ * `perChapter = 10` must be [2,2,2,2,1,1], which is exactly what that file's
+ * `quotaForIndex` publishes.
+ *
+ * perChapter = 10 over 6 codes: floor = 1 each (6 seats), 4 spare -> 1..4 get 2.
+ * perChapter =  5 over 6 codes: floor = 0 each (0 seats), 5 spare -> 1..5 get 1.
+ */
+function largestRemainder(total, buckets) {
+  const base = Math.floor(total / buckets);
+  const spare = total - base * buckets;
+  return Array.from({ length: buckets }, (_, i) => base + (i < spare ? 1 : 0));
+}
+
+const TEN_OVER_SIX = largestRemainder(10, 6);
+if (JSON.stringify(TEN_OVER_SIX) !== JSON.stringify([2, 2, 2, 2, 1, 1])) {
+  throw new Error(
+    `largest-remainder drift: 10 over 6 gave ${JSON.stringify(TEN_OVER_SIX)}, ` +
+      'but frontend/src/data/examBlueprint.ts publishes [2,2,2,2,1,1]'
+  );
+}
+
+out.push(`
+-- The three mock templates the client currently hardcodes in
+-- frontend/src/data/topics.ts, expressed as SUB-CHAPTER-LEVEL blueprints.
+--
+-- Note what the move buys twice over. 'questionsPerChapter: 10' was a number in
+-- a TypeScript literal that the selection code had to interpret; a blueprint is
+-- data the selection code reads, so a differently weighted mock is a row and
+-- not a deploy. And the rules are now per syllabus code rather than per
+-- chapter, which is the granularity the official NEC syllabus is written in and
+-- the granularity frontend/src/data/examBlueprint.ts already models -- so the
+-- client's exam plan and the server's draw describe the same paper.
+--
+-- Quotas come from \`equal-chapter-weight-largest-remainder\`: ten questions per
+-- chapter split 2/2/2/2/1/1 over its six codes for a full mock, and five split
+-- 1/1/1/1/1/0 for the quick assessment. 60 rules each.
+INSERT INTO mock_test_templates (id, subject_id, slug, name, description,
+                                 duration_minutes, total_questions, blueprint,
+                                 selection, status, ordinal) VALUES`);
+
+const tplRows = templates.map((t) => {
+  const quotas = largestRemainder(t.perChapter, 6);
+  const rules = [];
+  for (const s of SYLLABUS) {
+    s.topics.forEach((topic, j) => {
+      rules.push({
+        chapter_id: `book-ch${s.num}`,
+        subchapter_code: topic.code,
+        count: quotas[j],
+        difficulty: null,
+        tag_ids: null,
+      });
+    });
+  }
+  const total = rules.reduce((sum, r) => sum + r.count, 0);
+  if (total !== t.perChapter * 10) {
+    throw new Error(`blueprint for ${t.id} sums to ${total}, expected ${t.perChapter * 10}`);
+  }
+  const blueprint = {
+    version: 2,
+    weighting_rule: 'equal-chapter-weight-largest-remainder',
+    shuffle_options: true,
+    negative_marking: 0,
+    pass_mark_bp: 5000,
+    // Must stay false while questions.subchapter_id is NULL for every imported
+    // question; a strict run would fail all 60 rules. See 0004_assessment.sql.
+    strict_subchapter: false,
+    rules,
+  };
+  return `  (${q(t.id)}, 'nec-computer', ${q(t.slug)}, ${q(t.name)},
+   ${q(t.description)},
+   ${t.duration}, ${total},
+   ${q(JSON.stringify(blueprint))},
+   'random', 'published', ${t.ordinal})`;
+});
+out.push(tplRows.join(',\n') + ';\n');
+
+writeFileSync(`${ROOT}/worker/migrations/0007_reference_data.sql`, out.join('\n'));
+console.log(`wrote 0007_reference_data.sql: 1 subject, ${chapterRows.length} chapters, ${subRows.length} subchapters, ${tplRows.length} templates`);
diff --git a/worker/db/seed/import-questions.mjs b/worker/db/seed/import-questions.mjs
new file mode 100644
index 0000000..6b4e7cf
--- /dev/null
+++ b/worker/db/seed/import-questions.mjs
@@ -0,0 +1,833 @@
+#!/usr/bin/env node
+/**
+ * import-questions.mjs -- load the ten chapter JSONs from
+ * frontend/public/data/books/ into questions + question_options +
+ * question_answer_keys.
+ *
+ * ===========================================================================
+ * INDEX CONVENTION -- STATED EXPLICITLY, BECAUSE THIS IS WHERE OFF-BY-ONE
+ * BUGS COME FROM
+ * ===========================================================================
+ *
+ * The source rows are spreadsheet-shaped and 1-based:
+ *
+ *     { qsns, opt1, opt2, opt3, opt4, correct_option, correct_option_index }
+ *
+ * with `correct_option_index` in 1..4 meaning opt1..opt4.
+ *
+ * THIS SCHEMA IS 1-BASED THROUGHOUT. `question_options.ordinal` is literally
+ * the N in `optN`, so the mapping is the identity:
+ *
+ *     correct_option_index = 3  ->  ordinal 3
+ *
+ * No arithmetic, nothing to get backwards. The alternative -- 0-based ordinals
+ * -- is what the current client does (`correct_option_index - 1` in
+ * frontend/src/services/localData.ts) and it means every read and every write
+ * has to remember which side of the boundary it is on. Two of the 2,312 source
+ * rows have `correct_option_index = 5` against four options, which is the
+ * INDEX_RANGE defect below; under a 0-based convention that is index 4, which
+ * looks like a plausible fifth option rather than like an error.
+ *
+ * THE ORDINAL DOES NOT APPEAR IN THE OPTION ID. `question_options.id` is
+ * `question_id || '#' || opt_key` with a 12-character CSPRNG `opt_key`, because
+ * the earlier `|| ordinal` scheme made an option id joinable against the
+ * `correct_option_index` this very file reads out of the published JSON -- see
+ * the block above `question_options` in migrations/0002_content.sql. So the
+ * importer MINTS a key per option row and the answer key is resolved from the
+ * (question_id, ordinal) upsert's RETURNING id, never by string-building an id
+ * from the authored index.
+ *
+ * That is also why the option upsert conflicts on (question_id, ordinal) and
+ * not on (id): a re-run must find the EXISTING row by its authored slot and
+ * keep its `opt_key`. Conflicting on a freshly minted id would insert a second
+ * row per option on every run and orphan every answer already recorded.
+ *
+ * Everything downstream follows the same convention:
+ *   attempt_answers.delivered_position 1-based
+ *   attempt_questions.position         1-based
+ *   subchapters.ordinal, chapters.ordinal  1-based
+ *
+ * ===========================================================================
+ * IDENTITY
+ * ===========================================================================
+ *
+ * See the header of migrations/0002_content.sql for the full argument. The
+ * computation is implemented in `contentHash()` below and must stay in sync
+ * with that comment:
+ *
+ *   sha256('necprep-question-v1' RS chapter_code RS norm(stem) RS
+ *          sorted(norm(opt))... joined by US)
+ *   id = 'q_' + first 16 hex chars
+ *
+ * Idempotent: re-running upserts. Re-running after an upstream edit to a stem
+ * creates a new question rather than mutating one, which is correct -- a
+ * different stem is a different question.
+ *
+ * ===========================================================================
+ * DEFECTS
+ * ===========================================================================
+ *
+ * The importer re-derives defects from the data rather than trusting
+ * frontend/src/data/quarantine.json, whose ids are positional
+ * (`{topicId}_{arrayIndex}`) and have already gone stale: a de-duplication
+ * pass shrank the bank from 2,801 rows to 2,312 and 20 of the 23 quarantine
+ * entries now name a different, healthy question. Positional ids are the
+ * reason this schema exists; the importer is not going to depend on them.
+ *
+ * Rules, matching scripts/validate-questions.mjs:
+ *   OPTION_DUPLICATE  two options with identical normalised text
+ *   INDEX_RANGE       correct_option_index outside 1..option_count
+ *   KEY_CONFLICT      `correct_option` text is not any of the options
+ *   OPTION_COUNT      fewer than two usable options
+ *   EMPTY_STEM        blank question text
+ *
+ * A defective question is imported with status='flagged' and a
+ * `question_reports` row carrying the evidence (source='validator'), so it is
+ * excluded from selection without being deleted and an adjudicator has what
+ * they need to fix it.
+ *
+ * quarantine.json is still read, but only to file a report: any entry whose
+ * legacy id resolves to a question the rules consider healthy becomes an open
+ * `question_reports` row (source='import') for a human to look at. The
+ * importer does NOT flag it -- hiding a good question on the strength of a
+ * stale array index is the bug, not the fix.
+ *
+ * Usage:
+ *   node db/seed/import-questions.mjs [--db <path>] [--dry-run] [--json]
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { createHash, randomFillSync } from 'node:crypto';
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import {
+  classifySubchapter,
+  CLASSIFIER_VERSION,
+} from '../../../frontend/src/services/subchapterClassifier.ts';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const WORKER_ROOT = resolve(HERE, '..', '..');
+const REPO_ROOT = resolve(WORKER_ROOT, '..');
+const BOOKS_DIR = join(REPO_ROOT, 'frontend', 'public', 'data', 'books');
+const QUARANTINE_FILE = join(REPO_ROOT, 'frontend', 'src', 'data', 'quarantine.json');
+
+const HASH_NAMESPACE = 'necprep-question-v1';
+const RS = '\u001E'; // record separator -- cannot occur in the source JSON
+const US = '\u001F'; // unit separator
+
+/**
+ * Options whose meaning depends on being last. 'All of the above' shuffled
+ * into slot 2 makes the question nonsense, so the permuter must pin these.
+ * Pattern mirrors POSITIONAL_OPTION_RE in frontend/src/services/localData.ts.
+ */
+const PINNED_OPTION_RE = /^\s*(all|none|both)\s+(of\s+)?(the\s+)?(above|these|mentioned)/i;
+
+/** NFKC, collapse whitespace, trim, lowercase. The only normaliser. */
+export function norm(s) {
+  return String(s ?? '')
+    .normalize('NFKC')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+/**
+ * Normalised stem used ONLY to group rows for duplicate detection.
+ *
+ * Deliberately separate from `norm()`, and deliberately more aggressive: it
+ * also strips punctuation, so `What is the purpose of the "this" pointer` and
+ * `What is the purpose of the this pointer` group together. `norm()` cannot be
+ * changed to do this because `contentHash()` depends on it and every question
+ * id would be re-minted.
+ *
+ * This matches the normalisation the frontend uses in quarantine generation
+ * and in scripts/validate-questions.mjs. When the two disagreed, a pair of
+ * stems differing only in quote marks was withheld by the app and published by
+ * this importer.
+ */
+/**
+ * Sub-chapter classification is shared with the app rather than reimplemented,
+ * for the same reason `stemKey` had to be: the one time this file and the
+ * frontend disagreed about normalisation, the app withheld a pair of questions
+ * that this importer published. `db:seed:local` therefore runs with
+ * `--import ../scripts/ts-resolve.mjs`, which lets Node resolve the
+ * extensionless specifiers the app's own modules use.
+ */
+export function stemKey(stem) {
+  return norm(stem).replace(/[^\w\s?]/g, '').replace(/\s+/g, ' ').trim();
+}
+
+export function contentHash(chapterCode, stem, optionTexts) {
+  const payload = [
+    HASH_NAMESPACE,
+    chapterCode,
+    norm(stem),
+    optionTexts.map(norm).sort().join(US),
+  ].join(RS);
+  return createHash('sha256').update(payload, 'utf8').digest('hex');
+}
+
+export function questionIdFor(contentHashHex) {
+  return 'q_' + contentHashHex.slice(0, 16);
+}
+
+/** Crockford-style base32, matching worker/src/lib/ids.ts. */
+const B32 = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+/**
+ * A fresh 12-character (60-bit) CSPRNG option key.
+ *
+ * DELIBERATELY NOT DERIVED from the question id or the ordinal. A derived key
+ * -- even a hashed one -- would be brute-forceable back to the ordinal in 26
+ * tries per option, which is exactly the leak the random key exists to close.
+ * 256 is a multiple of 32, so masking the low 5 bits of each byte is uniform
+ * and needs no rejection loop.
+ */
+export function newOptionKey() {
+  const bytes = randomFillSync(new Uint8Array(12));
+  let out = '';
+  for (let i = 0; i < 12; i++) out += B32[bytes[i] & 31];
+  return out;
+}
+
+/** Returns the validator codes a source row trips, newest-first in severity. */
+export function defectsFor(row, optionTexts) {
+  const codes = [];
+  if (norm(row.qsns).length === 0) codes.push('EMPTY_STEM');
+  if (optionTexts.length < 2) codes.push('OPTION_COUNT');
+  if (new Set(optionTexts.map(norm)).size !== optionTexts.length) codes.push('OPTION_DUPLICATE');
+  const ci = row.correct_option_index;
+  if (!Number.isInteger(ci) || ci < 1 || ci > optionTexts.length) codes.push('INDEX_RANGE');
+  const authored = row.correct_option;
+  if (authored && !optionTexts.map(norm).includes(norm(authored))) codes.push('KEY_CONFLICT');
+  return codes;
+}
+
+const DEFECT_DETAIL = {
+  EMPTY_STEM: 'question text is blank',
+  OPTION_COUNT: 'fewer than two usable options',
+  OPTION_DUPLICATE: 'two options carry identical text, so two options can be simultaneously correct',
+  INDEX_RANGE: 'correct_option_index is outside 1..option_count, so there is no reachable correct answer',
+  KEY_CONFLICT: 'correct_option text is not among the options, so the index and the text disagree',
+  DUPLICATE_ANSWER_CONFLICT:
+    'another question shares this stem but its answer key names different text, so at least ' +
+    'one of the copies is mis-keyed and the data cannot say which',
+  OPTION_MULTIPLE_TRUE:
+    'more than one option is a true answer to the stem, so a single-answer question cannot ' +
+    'be graded fairly. Human adjudication from quarantine.json; no rule here can derive it, ' +
+    'because deciding it requires subject knowledge',
+};
+
+/** OPTION_DUPLICATE and KEY_CONFLICT are wrong-answer claims; the rest are not. */
+const DEFECT_CATEGORY = {
+  EMPTY_STEM: 'other',
+  OPTION_COUNT: 'bad_option',
+  OPTION_DUPLICATE: 'bad_option',
+  INDEX_RANGE: 'wrong_answer',
+  KEY_CONFLICT: 'wrong_answer',
+  DUPLICATE_ANSWER_CONFLICT: 'duplicate',
+  OPTION_MULTIPLE_TRUE: 'bad_option',
+};
+
+// Monotonic, sortable, opaque. Not a real ULID (no crypto randomness budget
+// needed here) but the same 26-char Crockford shape, so it is interchangeable
+// with whatever the API mints.
+let ulidCounter = 0;
+function ulidish(seedTime = Date.now()) {
+  const alphabet = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+  let t = seedTime;
+  let time = '';
+  for (let i = 0; i < 10; i++) {
+    time = alphabet[t % 32] + time;
+    t = Math.floor(t / 32);
+  }
+  let n = ++ulidCounter;
+  let rand = '';
+  for (let i = 0; i < 16; i++) {
+    rand = alphabet[n % 32] + rand;
+    n = Math.floor(n / 32);
+  }
+  return time + rand;
+}
+
+export function loadSourceRows() {
+  if (!existsSync(BOOKS_DIR)) throw new Error(`question bank not found at ${BOOKS_DIR}`);
+  const chapters = [];
+  for (let n = 1; n <= 10; n++) {
+    const file = `ch${n}.json`;
+    const path = join(BOOKS_DIR, file);
+    if (!existsSync(path)) throw new Error(`missing chapter file ${path}`);
+    const rows = JSON.parse(readFileSync(path, 'utf8'));
+    if (!Array.isArray(rows)) throw new Error(`${file} is not a JSON array`);
+    chapters.push({ chapterId: `book-ch${n}`, file: `books/${file}`, rows });
+  }
+  return chapters;
+}
+
+/**
+ * Cross-row defects, which no single row and therefore no CHECK constraint can
+ * see.
+ *
+ * DUPLICATE_ANSWER_CONFLICT: two or more source rows share a question stem but
+ * their answer keys name different text. One of them is wrong and there is no
+ * way to tell which from the data, so every copy is withheld until a human
+ * picks. 128 such rows are listed in frontend/src/data/quarantine.json.
+ *
+ * This is derived here, from the stems, rather than read from that file,
+ * because the file keys on positional `{topicId}_{arrayIndex}` ids. Deriving
+ * it means the rule survives any reordering of the bank -- which is the whole
+ * argument of migrations/0002_content.sql, applied to the one defect class
+ * that genuinely needs a second pass over the data.
+ *
+ * Grouping is by normalised stem only, NOT by content hash: the hash includes
+ * the option set, so two copies that disagree about both the options and the
+ * answer -- the common case here -- hash differently and must still be caught.
+ *
+ * Returns Map<questionId, string[]>.
+ */
+/**
+ * Quarantine codes that are human adjudications, not rule outputs.
+ *
+ * Nothing in this importer can derive them - OPTION_MULTIPLE_TRUE, for
+ * instance, requires knowing that two option strings are both true statements
+ * about C++ - so a question carrying one must be withheld on the strength of
+ * the human decision alone. The importer is otherwise right to distrust
+ * quarantine.json's positional ids, but `validate-questions.mjs --check-ids`
+ * gates every id for range on each run, so a code that cannot be re-derived is
+ * evidence rather than noise. Publishing a question a human marked unanswerable
+ * is the worse error.
+ */
+export const HUMAN_ADJUDICATED_CODES = new Set(['OPTION_MULTIPLE_TRUE']);
+
+/**
+ * legacy id -> codes, for quarantine entries this importer cannot re-derive.
+ */
+export function planHumanQuarantine(quarantineFile) {
+  const byLegacy = new Map();
+  if (!existsSync(quarantineFile)) return byLegacy;
+  for (const entry of JSON.parse(readFileSync(quarantineFile, 'utf8'))) {
+    const human = (entry.codes ?? []).filter((c) => HUMAN_ADJUDICATED_CODES.has(c));
+    if (human.length > 0) byLegacy.set(entry.id, human);
+  }
+  return byLegacy;
+}
+
+export function planCrossRowDefects(chapters, necCodeByChapter) {
+  // normalised stem -> { questionIds:Set, answerTexts:Set }
+  const byStem = new Map();
+
+  for (const { chapterId, rows } of chapters) {
+    const necCode = necCodeByChapter.get(chapterId);
+    for (const row of rows) {
+      const optionTexts = usableOptions(row);
+      const qid = questionIdFor(contentHash(necCode, row.qsns, optionTexts));
+      const key = stemKey(row.qsns);
+      if (key.length === 0) continue;
+      if (!byStem.has(key)) byStem.set(key, { questionIds: new Set(), answerTexts: new Set() });
+      const group = byStem.get(key);
+      group.questionIds.add(qid);
+      const ci = row.correct_option_index;
+      if (Number.isInteger(ci) && ci >= 1 && ci <= optionTexts.length) {
+        group.answerTexts.add(norm(optionTexts[ci - 1]));
+      }
+    }
+  }
+
+  const codes = new Map();
+  for (const { questionIds, answerTexts } of byStem.values()) {
+    // Disagreement is judged on the ANSWER, not on how many question ids the
+    // group produced. There used to be an additional `questionIds.size < 2`
+    // guard here, and it was the wrong test: contentHash() covers the stem and
+    // the sorted option texts but deliberately NOT the answer key, so two rows
+    // that differ only in correct_option_index hash to the same id. Those rows
+    // collapsed to one question whose id appeared exactly once, the guard
+    // skipped the group, and the question was published carrying whichever
+    // answer happened to be read first - silently resolving a contradiction by
+    // array order. One id with two authored answers is a stronger signal than
+    // two ids with two answers, not a weaker one.
+    if (answerTexts.size < 2) continue;      // same stem, same answer -- benign duplicate
+    for (const qid of questionIds) {
+      if (!codes.has(qid)) codes.set(qid, []);
+      codes.get(qid).push('DUPLICATE_ANSWER_CONFLICT');
+    }
+  }
+  return codes;
+}
+
+/** The option strings a row actually offers, in optN order, blanks dropped. */
+export function usableOptions(row) {
+  return [row.opt1, row.opt2, row.opt3, row.opt4]
+    .map((t) => (t === null || t === undefined ? '' : String(t)))
+    .filter((t) => t.trim().length > 0);
+}
+
+export function importQuestions(db, { dryRun = false } = {}) {
+  const chapters = loadSourceRows();
+
+  // chapter_id -> nec_code. The NEC code goes into the hash, not the
+  // 'book-chN' id: the frontend id is an implementation detail that could be
+  // renamed, and renaming it must not change a single question's identity.
+  const necCodeByChapter = new Map(
+    db.prepare('SELECT id, nec_code FROM chapters').all().map((r) => [r.id, r.nec_code])
+  );
+  const subjectByChapter = new Map(
+    db.prepare('SELECT id, subject_id FROM chapters').all().map((r) => [r.id, r.subject_id])
+  );
+  // '1.1' -> 'nec-1.1'. The classifier reports the dotted display code, which
+  // is exactly `subchapters.code`, so no string building is needed here.
+  const subchapterIdByCode = new Map(
+    db.prepare('SELECT id, code FROM subchapters').all().map((r) => [r.code, r.id])
+  );
+  if (subchapterIdByCode.size !== 60) {
+    throw new Error(
+      `expected 60 subchapters from migration 0007, found ${subchapterIdByCode.size}. ` +
+        'Run db:apply:local first.'
+    );
+  }
+
+  if (necCodeByChapter.size !== 10) {
+    throw new Error(
+      `expected 10 chapters from migration 0007, found ${necCodeByChapter.size}. ` +
+        'Run db/apply.mjs (or `wrangler d1 migrations apply`) first.'
+    );
+  }
+
+  // Two passes. The first sees the whole bank, which is what a cross-row
+  // defect needs; the second writes.
+  const crossRowCodes = planCrossRowDefects(chapters, necCodeByChapter);
+  const humanQuarantine = planHumanQuarantine(QUARANTINE_FILE);
+
+  const insertQuestion = db.prepare(`
+    INSERT INTO questions (
+      id, content_hash, subject_id, chapter_id,
+      subchapter_id, subchapter_source, subchapter_confidence_bp,
+      subchapter_classifier_version,
+      stem, stem_format,
+      status, status_reason, status_changed_at, has_pinned_options,
+      source, source_ref, legacy_id, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'plain', ?, ?, ?, ?, 'book-import', ?, ?, ?, ?)
+    ON CONFLICT (id) DO UPDATE SET
+      stem               = excluded.stem,
+      status             = excluded.status,
+      status_reason      = excluded.status_reason,
+      has_pinned_options = excluded.has_pinned_options,
+      source_ref         = excluded.source_ref,
+      legacy_id          = excluded.legacy_id,
+      updated_at         = excluded.updated_at,
+      -- A person's classification outranks the classifier's, always. 0009 has
+      -- a trigger that refuses the downgrade outright; this CASE means a
+      -- re-import does not have to trip it to do the right thing. Everything
+      -- else is overwritten, so improving the term lists and re-running is the
+      -- intended way to re-label the bank.
+      subchapter_id = CASE WHEN questions.subchapter_source = 'human'
+                          THEN questions.subchapter_id
+                          ELSE excluded.subchapter_id END,
+      subchapter_source = CASE WHEN questions.subchapter_source = 'human'
+                               THEN 'human'
+                               ELSE excluded.subchapter_source END,
+      subchapter_confidence_bp = CASE WHEN questions.subchapter_source = 'human'
+                                      THEN NULL
+                                      ELSE excluded.subchapter_confidence_bp END,
+      subchapter_classifier_version = CASE WHEN questions.subchapter_source = 'human'
+                                           THEN NULL
+                                           ELSE excluded.subchapter_classifier_version END
+  `);
+
+  // Conflict target is the AUTHORED SLOT, not the id. A re-run must find the
+  // existing row for (question, ordinal) and keep its `opt_key` -- the id it
+  // would otherwise mint is fresh every time, so conflicting on `id` would add
+  // a second row per option per run and orphan every recorded answer.
+  // RETURNING hands back whichever id won, which is what the answer key below
+  // references; nothing string-builds an option id from the authored index.
+  const insertOption = db.prepare(`
+    INSERT INTO question_options (id, question_id, ordinal, opt_key, text, text_format,
+                                  is_pinned, retired_at, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, 'plain', ?, ?, ?, ?)
+    ON CONFLICT (question_id, ordinal) DO UPDATE SET
+      text       = excluded.text,
+      is_pinned  = excluded.is_pinned,
+      retired_at = excluded.retired_at,
+      updated_at = excluded.updated_at
+    RETURNING id
+  `);
+
+  const insertKey = db.prepare(`
+    INSERT INTO question_answer_keys (question_id, correct_option_id, source,
+                                      authored_index, authored_text,
+                                      created_at, updated_at)
+    VALUES (?, ?, 'import', ?, ?, ?, ?)
+    ON CONFLICT (question_id) DO UPDATE SET
+      correct_option_id = excluded.correct_option_id,
+      authored_index    = excluded.authored_index,
+      authored_text     = excluded.authored_text,
+      updated_at        = excluded.updated_at
+  `);
+
+  const insertReport = db.prepare(`
+    INSERT INTO question_reports (public_id, question_id, reporter_user_id, source,
+                                  category, code, detail, status, created_at, updated_at)
+    VALUES (?, ?, NULL, ?, ?, ?, ?, 'open', ?, ?)
+  `);
+  const reportExists = db.prepare(`
+    SELECT 1 FROM question_reports
+     WHERE question_id = ? AND source = ? AND COALESCE(code, '') = COALESCE(?, '')
+       AND status = 'open'
+  `);
+
+  // Epoch MILLISECONDS. Every timestamp column in this schema is ms; see the
+  // convention block at the top of migrations/0001_identity.sql.
+  const now = Date.now();
+  const stats = {
+    sourceRows: 0,
+    questionsInserted: 0,
+    collapsedDuplicates: 0,
+    crossChapterDuplicateGroups: 0,
+    optionsInserted: 0,
+    optionsRetiredAsDuplicate: 0,
+    answerKeysInserted: 0,
+    flagged: 0,
+    publishedWithoutKey: 0,
+    reportsFiled: 0,
+    byCode: {},
+    byChapter: {},
+    pinnedOptions: 0,
+    questionsWithPinnedOptions: 0,
+    correctOrdinalHistogram: {},
+    subchapterClassified: 0,
+    subchapterDeclined: 0,
+  };
+
+  // Seen within this run, to collapse exact duplicates and report them rather
+  // than letting the upsert silently absorb them.
+  const seen = new Map(); // questionId -> source_ref of the first occurrence
+  const hashWithoutChapter = new Map();
+
+  db.exec('BEGIN');
+  try {
+    for (const { chapterId, file, rows } of chapters) {
+      const necCode = necCodeByChapter.get(chapterId);
+      const subjectId = subjectByChapter.get(chapterId);
+      const chapterStats = { rows: rows.length, questions: 0, flagged: 0, collapsed: 0 };
+
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        stats.sourceRows++;
+        const optionTexts = usableOptions(row);
+
+        const legacyId = `${chapterId}_${i}`;
+        const sourceRef = `${file}#${i}`;
+        const hash = contentHash(necCode, row.qsns, optionTexts);
+        const qid = questionIdFor(hash);
+
+        // Cross-chapter duplicate telemetry: same text, different chapter.
+        const plainHash = contentHash('', row.qsns, optionTexts);
+        if (!hashWithoutChapter.has(plainHash)) hashWithoutChapter.set(plainHash, new Set());
+        hashWithoutChapter.get(plainHash).add(chapterId);
+
+        if (seen.has(qid)) {
+          stats.collapsedDuplicates++;
+          chapterStats.collapsed++;
+          // Same stem and same option set, so the same question identity. The
+          // answer key may still differ between the two rows; when it does,
+          // planCrossRowDefects has already marked this qid
+          // DUPLICATE_ANSWER_CONFLICT and the kept row is flagged rather than
+          // published, so dropping this row cannot resolve a contradiction by
+          // arrival order.
+          continue;
+        }
+        seen.set(qid, sourceRef);
+
+        const codes = [
+          ...defectsFor(row, optionTexts),
+          ...(crossRowCodes.get(qid) ?? []),
+          ...(humanQuarantine.get(legacyId) ?? []),
+        ];
+        const status = codes.length > 0 ? 'flagged' : 'published';
+        const statusReason = codes.length > 0 ? codes[0] : null;
+
+        const pinned = optionTexts.map((t) => (PINNED_OPTION_RE.test(t) ? 1 : 0));
+        const hasPinned = pinned.some((p) => p === 1) ? 1 : 0;
+
+        // Sub-chapter: derived, declined when the evidence is thin, and always
+        // stamped with where it came from. A NULL label carries NULL
+        // provenance -- 0009's trigger rejects any other combination.
+        const match = classifySubchapter({
+          chapterCode: necCode,
+          question: String(row.qsns ?? ''),
+          options: optionTexts,
+        });
+        const subId = match ? (subchapterIdByCode.get(match.displayCode) ?? null) : null;
+        if (match && !subId) {
+          // The classifier returned a code the reference data does not have,
+          // which means the syllabus and migration 0007 have diverged. Failing
+          // loudly beats importing the whole bank unclassified and wondering
+          // later why the blueprint rules never fire.
+          throw new Error(
+            `classifier returned sub-chapter ${match.displayCode}, absent from the subchapters table`
+          );
+        }
+        if (subId) {
+          stats.subchapterClassified++;
+        } else {
+          stats.subchapterDeclined++;
+        }
+
+        if (!dryRun) {
+          insertQuestion.run(
+            qid, hash, subjectId, chapterId,
+            subId,
+            subId ? 'heuristic' : null,
+            subId ? match.confidenceBp : null,
+            subId ? CLASSIFIER_VERSION : null,
+            String(row.qsns),
+            status, statusReason, now, hasPinned, sourceRef, legacyId, now, now
+          );
+        }
+        stats.questionsInserted++;
+        chapterStats.questions++;
+        if (hasPinned) stats.questionsWithPinnedOptions++;
+
+        // ordinal === the N in optN. 1-based. See the header.
+        //
+        // The second and later copies of an identical option text are imported
+        // RETIRED. `uq_question_options_question_text` is partial on
+        // `retired_at IS NULL`, so this is what lets a defective question in at
+        // all -- and it is the right shape rather than a workaround: the
+        // duplicate option genuinely should not be offered to anyone, the row
+        // is preserved for the editor who has to fix it, and the ordinal stays
+        // claimed forever so no future option can inherit a historical answer.
+        // The question itself is flagged, so nothing is delivered either way.
+        const seenText = new Set();
+        // ordinal -> the option id the database actually holds. Populated from
+        // the upsert's RETURNING, so a re-import reuses the stored `opt_key`.
+        const optionIdByOrdinal = new Map();
+        optionTexts.forEach((text, k) => {
+          const ordinal = k + 1;
+          const optKey = newOptionKey();
+          const key = norm(text);
+          const retiredAt = seenText.has(key) ? now : null;
+          seenText.add(key);
+          if (!dryRun) {
+            const returned = insertOption.get(
+              `${qid}#${optKey}`, qid, ordinal, optKey, text, pinned[k], retiredAt, now, now
+            );
+            optionIdByOrdinal.set(ordinal, returned.id);
+          } else {
+            optionIdByOrdinal.set(ordinal, `${qid}#${optKey}`);
+          }
+          stats.optionsInserted++;
+          if (retiredAt !== null) stats.optionsRetiredAsDuplicate++;
+          stats.pinnedOptions += pinned[k];
+        });
+
+        // The answer key. Written only when the authored index actually names
+        // an option that exists -- an INDEX_RANGE row gets no key at all,
+        // which is honest: there is no correct answer to record. Such a
+        // question is also flagged, so it can never reach a student.
+        //
+        // `correct_option_id` comes from the map above and NOT from the
+        // authored index: the id no longer contains the index, and building one
+        // by hand is how the leak this schema just closed would come back.
+        // `authored_index` keeps the source JSON's number for audit, in the
+        // server-only table where a `SELECT *` on `questions` cannot reach it.
+        const ci = row.correct_option_index;
+        const keyable = Number.isInteger(ci) && ci >= 1 && ci <= optionTexts.length;
+        if (keyable) {
+          const correctOptionId = optionIdByOrdinal.get(ci);
+          if (correctOptionId === undefined) {
+            throw new Error(`no option row for ${qid} ordinal ${ci} -- refusing to key it`);
+          }
+          if (!dryRun) {
+            insertKey.run(
+              qid, correctOptionId, ci,
+              row.correct_option === undefined || row.correct_option === null
+                ? null
+                : String(row.correct_option),
+              now, now
+            );
+          }
+          stats.answerKeysInserted++;
+          stats.correctOrdinalHistogram[ci] = (stats.correctOrdinalHistogram[ci] ?? 0) + 1;
+        }
+
+        if (codes.length > 0) {
+          stats.flagged++;
+          chapterStats.flagged++;
+          for (const code of codes) {
+            stats.byCode[code] = (stats.byCode[code] ?? 0) + 1;
+            if (!dryRun && !reportExists.get(qid, 'validator', code)) {
+              insertReport.run(
+                ulidish(), qid, 'validator', DEFECT_CATEGORY[code], code,
+                `${DEFECT_DETAIL[code]} (source ${sourceRef}, legacy id ${legacyId}, ` +
+                  `correct_option_index=${JSON.stringify(ci)}, ` +
+                  `correct_option=${JSON.stringify(row.correct_option ?? null)})`,
+                now, now
+              );
+              stats.reportsFiled++;
+            }
+          }
+        }
+      }
+      stats.byChapter[chapterId] = chapterStats;
+    }
+
+    stats.crossChapterDuplicateGroups = [...hashWithoutChapter.values()].filter(
+      (set) => set.size > 1
+    ).length;
+
+    // ------------------------------------------------------------------
+    // quarantine.json cross-check. Reported, never acted on -- see header.
+    // ------------------------------------------------------------------
+    const quarantineDrift = { entries: 0, resolved: 0, agreed: 0, stale: 0, unresolvable: 0 };
+    if (existsSync(QUARANTINE_FILE)) {
+      const entries = JSON.parse(readFileSync(QUARANTINE_FILE, 'utf8'));
+      quarantineDrift.entries = entries.length;
+      const byLegacy = db.prepare('SELECT id, status FROM questions WHERE legacy_id = ?');
+      for (const entry of entries) {
+        const hit = byLegacy.get(entry.id);
+        if (!hit) {
+          quarantineDrift.unresolvable++;
+          continue;
+        }
+        quarantineDrift.resolved++;
+        if (hit.status === 'flagged') {
+          quarantineDrift.agreed++;
+          continue;
+        }
+        quarantineDrift.stale++;
+        if (!dryRun && !reportExists.get(hit.id, 'import', null)) {
+          insertReport.run(
+            ulidish(), hit.id, 'import', 'other', null,
+            `quarantine.json lists legacy id ${entry.id} (${entry.codes.join(', ')}: ` +
+              `${entry.notes.join(' / ')}) but this importer's rules find no defect in ` +
+              'the question now at that array position. Two explanations, needing ' +
+              'different fixes: either the legacy id has drifted (it is positional, and ' +
+              'the bank has been re-ordered since the list was written) so the entry now ' +
+              'names the wrong question, or the finding is a near-duplicate stem that ' +
+              'the exact-normalised-stem rule here does not match. Needs human ' +
+              'adjudication. The question has NOT been withheld on this evidence: ' +
+              'hiding a question that passes every rule, on the strength of a stale ' +
+              'array index, is the bug this schema exists to end.',
+            now, now
+          );
+          stats.reportsFiled++;
+        }
+      }
+    }
+    stats.quarantineDrift = quarantineDrift;
+
+    // ------------------------------------------------------------------
+    // Invariant: nothing deliverable may lack an answer key. If this is ever
+    // non-zero the grader would mark a real student wrong for a question it
+    // cannot grade, so it aborts the import rather than reporting it.
+    // ------------------------------------------------------------------
+    stats.publishedWithoutKey = db
+      .prepare(
+        `SELECT COUNT(*) n FROM questions q
+          WHERE q.status = 'published'
+            AND NOT EXISTS (SELECT 1 FROM question_answer_keys k WHERE k.question_id = q.id)`
+      )
+      .get().n;
+    if (stats.publishedWithoutKey > 0) {
+      throw new Error(
+        `${stats.publishedWithoutKey} published questions have no answer key -- refusing to commit`
+      );
+    }
+
+    // One audit row for the whole run. 2,290 content_versions rows would cost
+    // ~1 MB of a 500 MB budget to record a single mechanical event; the event
+    // is the import, not each question.
+    if (!dryRun) {
+      db.prepare(
+        `INSERT INTO admin_audit_log (actor_user_id, actor_role, action, entity_type,
+                                      entity_id, after_json, reason, created_at)
+         VALUES (NULL, 'system', 'questions.import', 'subject', 'nec-computer', ?, ?, ?)`
+      ).run(
+        JSON.stringify({
+          sourceRows: stats.sourceRows,
+          questions: stats.questionsInserted,
+          options: stats.optionsInserted,
+          answerKeys: stats.answerKeysInserted,
+          flagged: stats.flagged,
+          byCode: stats.byCode,
+          collapsedDuplicates: stats.collapsedDuplicates,
+        }),
+        'bulk import from frontend/public/data/books/',
+        now
+      );
+    }
+
+    if (dryRun) db.exec('ROLLBACK');
+    else db.exec('COMMIT');
+  } catch (err) {
+    db.exec('ROLLBACK');
+    throw err;
+  }
+
+  return stats;
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const argv = process.argv.slice(2);
+  const argOf = (flag, fallback) => {
+    const i = argv.indexOf(flag);
+    return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback;
+  };
+  const dbPath = resolve(argOf('--db', join(WORKER_ROOT, '.local', 'necprep.sqlite')));
+  if (!existsSync(dbPath)) {
+    console.error(`no database at ${dbPath}. Run \`npm run db:apply:local\` first.`);
+    process.exit(2);
+  }
+  const db = new DatabaseSync(dbPath);
+  db.exec('PRAGMA foreign_keys = ON');
+
+  const dryRun = argv.includes('--dry-run');
+  const stats = importQuestions(db, { dryRun });
+
+  if (argv.includes('--json')) {
+    console.log(JSON.stringify(stats, null, 2));
+  } else {
+    const q = (sql) => db.prepare(sql).get().n;
+    console.log(`${dryRun ? 'DRY RUN -- ' : ''}import from ${BOOKS_DIR}\n`);
+    console.log(`source rows read              ${stats.sourceRows}`);
+    console.log(`exact duplicates collapsed    ${stats.collapsedDuplicates}`);
+    console.log(`cross-chapter dup groups      ${stats.crossChapterDuplicateGroups}`);
+    console.log(`questions written             ${stats.questionsInserted}`);
+    console.log(`  published                   ${stats.questionsInserted - stats.flagged}`);
+    console.log(`  flagged (withheld)          ${stats.flagged}`);
+    console.log(`options written               ${stats.optionsInserted}`);
+    console.log(`  retired as duplicate text   ${stats.optionsRetiredAsDuplicate}`);
+    console.log(`  pinned ('all of the above') ${stats.pinnedOptions} across ${stats.questionsWithPinnedOptions} questions`);
+    console.log(`answer keys written           ${stats.answerKeysInserted}`);
+    // Declined is not a failure: the classifier refuses rather than guessing,
+    // and a declined question still has its chapter, which is exact.
+    console.log(`sub-chapter labelled          ${stats.subchapterClassified} (heuristic)`);
+    console.log(`  declined, chapter only      ${stats.subchapterDeclined}`);
+    console.log(`published without a key       ${stats.publishedWithoutKey}  (must be 0)`);
+    console.log(`errata reports filed          ${stats.reportsFiled}`);
+    console.log(`\ndefect codes: ${JSON.stringify(stats.byCode)}`);
+    console.log(`authored correct-option position: ${JSON.stringify(stats.correctOrdinalHistogram)}`);
+    console.log(`quarantine.json cross-check: ${JSON.stringify(stats.quarantineDrift)}`);
+
+    console.log('\nper chapter (source rows / questions / flagged / collapsed):');
+    for (const [id, c] of Object.entries(stats.byChapter)) {
+      console.log(`  ${id.padEnd(11)} ${String(c.rows).padStart(5)} ${String(c.questions).padStart(6)} ${String(c.flagged).padStart(8)} ${String(c.collapsed).padStart(10)}`);
+    }
+
+    console.log('\nin-database totals:');
+    for (const [label, sql] of [
+      ['questions', 'SELECT COUNT(*) n FROM questions'],
+      ["  status='published'", "SELECT COUNT(*) n FROM questions WHERE status='published'"],
+      ["  status='flagged'", "SELECT COUNT(*) n FROM questions WHERE status='flagged'"],
+      ['question_options', 'SELECT COUNT(*) n FROM question_options'],
+      ['question_answer_keys', 'SELECT COUNT(*) n FROM question_answer_keys'],
+      ['question_reports', 'SELECT COUNT(*) n FROM question_reports'],
+      ['questions_fts rows', 'SELECT COUNT(*) n FROM questions_fts'],
+      ['v_question_delivery rows', 'SELECT COUNT(*) n FROM v_question_delivery'],
+    ]) {
+      console.log(`  ${label.padEnd(26)} ${q(sql)}`);
+    }
+  }
+  db.close();
+}
diff --git a/worker/db/seed/load-local-d1.mjs b/worker/db/seed/load-local-d1.mjs
new file mode 100644
index 0000000..4043b25
--- /dev/null
+++ b/worker/db/seed/load-local-d1.mjs
@@ -0,0 +1,111 @@
+/**
+ * Load the question bank into the database `wrangler dev` actually uses.
+ *
+ *   npm run dev:setup      # migrations + content, from nothing
+ *   node db/seed/load-local-d1.mjs
+ *
+ * WHY THIS IS NOT `db:seed:local`
+ * -------------------------------
+ * There are TWO local databases and they are easy to confuse:
+ *
+ *   .local/necprep.sqlite                     <- db/apply.mjs + db/seed/*
+ *   .wrangler/state/v3/d1/miniflare-<hash>.sqlite  <- `wrangler dev`, `--local`
+ *
+ * `npm run db:seed:local` fills the first. It is the one the test harness, the
+ * smoke suite and `db:verify` read, and it is driven by plain `node:sqlite`
+ * with no wrangler involved. `wrangler dev` never looks at it.
+ *
+ * So a developer can run the full `db:check`, see 2,290 questions, start
+ * `wrangler dev`, and get an empty API — which is exactly what happens today.
+ * This script closes that gap by replaying the same generated SQL into the
+ * miniflare database through `wrangler d1 execute --local`.
+ *
+ * WHY THROUGH WRANGLER AND NOT STRAIGHT INTO THE FILE
+ * ---------------------------------------------------
+ * The miniflare database is a plain SQLite file and writing to it directly
+ * would be faster. It is also named after a hash that wrangler owns and may
+ * change between versions, and wrangler keeps its own metadata database
+ * alongside. Going through the supported command costs a few seconds once and
+ * cannot desynchronise.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+
+const WORKER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const EXPORT_DIR = join(WORKER_ROOT, '.local', 'remote');
+const DB_NAME = 'necprep';
+
+function run(command, args, label) {
+  process.stdout.write(`  ${label} … `);
+  const result = spawnSync(command, args, {
+    cwd: WORKER_ROOT,
+    encoding: 'utf8',
+    shell: process.platform === 'win32',
+  });
+  if (result.status !== 0) {
+    console.log('FAILED');
+    console.error(result.stdout ?? '');
+    console.error(result.stderr ?? '');
+    process.exit(result.status ?? 1);
+  }
+  console.log('ok');
+  return result.stdout ?? '';
+}
+
+if (!existsSync(EXPORT_DIR) || readdirSync(EXPORT_DIR).filter((f) => f.endsWith('.sql')).length === 0) {
+  console.error(
+    `No SQL to load in ${EXPORT_DIR}.\n` +
+      'Run this first, which builds .local/necprep.sqlite and exports it:\n' +
+      '  npm run db:apply:local && npm run db:seed:local && npm run db:export:remote',
+  );
+  process.exit(2);
+}
+
+// Sorted, because question_options and question_answer_keys reference
+// questions and D1 enforces foreign keys. The filenames are numbered for
+// exactly this reason.
+const files = readdirSync(EXPORT_DIR)
+  .filter((f) => f.endsWith('.sql'))
+  .sort();
+
+console.log(`Loading ${String(files.length)} file(s) into the wrangler-local D1.\n`);
+
+for (const file of files) {
+  run(
+    'npx',
+    ['wrangler', 'd1', 'execute', DB_NAME, '--local', '--file', join(EXPORT_DIR, file), '-y'],
+    file,
+  );
+}
+
+const out = run(
+  'npx',
+  [
+    'wrangler', 'd1', 'execute', DB_NAME, '--local', '--json', '--command',
+    "SELECT (SELECT COUNT(*) FROM questions) AS questions, " +
+      "(SELECT COUNT(*) FROM questions WHERE status='published') AS published, " +
+      '(SELECT COUNT(*) FROM question_options) AS options',
+  ],
+  'verifying',
+);
+
+try {
+  const parsed = JSON.parse(out.slice(out.indexOf('[')));
+  const row = parsed[0].results[0];
+  console.log(
+    `\n  questions ${String(row.questions)} · published ${String(row.published)} · options ${String(row.options)}`,
+  );
+  if (row.questions === 0) {
+    console.error('\nLoaded nothing. Did `d1:migrate:local` run first?');
+    process.exit(1);
+  }
+} catch {
+  // The counts are a convenience; a parse failure here is not a load failure.
+  console.log('\n  (loaded; could not parse the verification output)');
+}
+
+console.log('\nStart the API with `npm run dev`, then point the frontend at it:');
+console.log('  echo "VITE_API_BASE_URL=http://localhost:8787" > ../frontend/.env.local');
diff --git a/worker/db/smoke.mjs b/worker/db/smoke.mjs
new file mode 100644
index 0000000..b1a5e13
--- /dev/null
+++ b/worker/db/smoke.mjs
@@ -0,0 +1,868 @@
+#!/usr/bin/env node
+/**
+ * smoke.mjs -- exercise the schema the way the API will, and assert the
+ * properties the migrations claim.
+ *
+ * This is not a unit test of the API (worker/src/** is not owned here). It is
+ * the proof that the schema's claims are true rather than aspirational:
+ *
+ *   1. a published question can be drawn, delivered and graded, and the
+ *      delivery path never touches question_answer_keys;
+ *   2. the rollup triggers produce the right numbers, including on the
+ *      revise-an-answer path;
+ *   3. a flagged question cannot be drawn;
+ *   4. a bogus option ordinal is refused by the database, not by a handler;
+ *   5. an answer key cannot be pointed at another question's option;
+ *   6. the archival job deletes raw answers WITHOUT destroying progress --
+ *      the single most dangerous property in the whole design.
+ *
+ * Usage: node db/smoke.mjs [--db <path>]
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const WORKER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+let checks = 0;
+let failures = 0;
+function assert(label, actual, expected) {
+  checks++;
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (!ok) {
+    failures++;
+    console.error(`  FAIL  ${label}\n          expected ${JSON.stringify(expected)}\n          actual   ${JSON.stringify(actual)}`);
+  } else {
+    console.log(`  ok    ${label} = ${JSON.stringify(actual)}`);
+  }
+}
+function assertThrows(label, fn, matcher) {
+  checks++;
+  try {
+    fn();
+    failures++;
+    console.error(`  FAIL  ${label}: expected a constraint failure, got none`);
+  } catch (err) {
+    if (matcher && !matcher.test(err.message)) {
+      failures++;
+      console.error(`  FAIL  ${label}: wrong error -- ${err.message}`);
+    } else {
+      console.log(`  ok    ${label} -> ${err.message.split('\n')[0]}`);
+    }
+  }
+}
+
+/** mulberry32, the same PRNG the client already uses, so papers are reproducible. */
+function rng(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/**
+ * The permutation the delivery path owes an attempt: free options shuffled,
+ * pinned options ('All of the above') held at the end in their authored order.
+ */
+export function permuteOptions(options, random) {
+  const free = options.filter((o) => !o.is_pinned);
+  const pinned = options.filter((o) => o.is_pinned);
+  for (let i = free.length - 1; i > 0; i--) {
+    const j = Math.floor(random() * (i + 1));
+    [free[i], free[j]] = [free[j], free[i]];
+  }
+  return [...free, ...pinned];
+}
+
+export function runSmoke(db) {
+  db.exec('PRAGMA foreign_keys = ON');
+  const one = (sql, ...p) => db.prepare(sql).get(...p);
+  const all = (sql, ...p) => db.prepare(sql).all(...p);
+  const run = (sql, ...p) => db.prepare(sql).run(...p);
+  const n = (sql, ...p) => one(sql, ...p).n;
+
+  // Epoch MILLISECONDS throughout -- see migrations/0001_identity.sql.
+  const now = Date.now();
+  const DAY_MS = 86_400_000;
+  const USER = 'U01SMOKETESTUSER0000000000';
+
+  /**
+   * Removes everything this suite creates.
+   *
+   * Called before the first fixture and again at the end, so the suite is
+   * re-runnable and leaves the database exactly as the seed produced it.
+   * Ordered child-first rather than relying on cascades: not every foreign key
+   * here is ON DELETE CASCADE, and a leftover child would fail the closing
+   * foreign_key_check instead of failing loudly at the insert.
+   */
+  const resetFixtures = () => {
+    run(`DELETE FROM attempt_answers_archive WHERE user_id LIKE 'U01SMOKE%'`);
+    run(`DELETE FROM attempt_answers WHERE attempt_id IN (
+           SELECT id FROM attempts WHERE public_id LIKE 'A01SMOKE%' OR user_id LIKE 'U01SMOKE%')`);
+    run(`DELETE FROM attempt_questions WHERE attempt_id IN (
+           SELECT id FROM attempts WHERE public_id LIKE 'A01SMOKE%' OR user_id LIKE 'U01SMOKE%')`);
+    run(`DELETE FROM attempts WHERE public_id LIKE 'A01SMOKE%' OR user_id LIKE 'U01SMOKE%'`);
+    run(`DELETE FROM leaderboard_entries WHERE snapshot_id IN (
+           SELECT id FROM leaderboard_snapshots
+            WHERE scope = 'global' AND period = 'weekly' AND period_start = '2026-10-19')`);
+    run(`DELETE FROM leaderboard_snapshots
+          WHERE scope = 'global' AND period = 'weekly' AND period_start = '2026-10-19'`);
+    // The remaining per-user tables (sessions, user_profiles, bookmarks,
+    // srs_state, streaks, notifications) cascade from users.
+    run(`DELETE FROM users WHERE id LIKE 'U01SMOKE%'`);
+  };
+
+  console.log('\n-- resetting fixtures from any previous run --');
+  resetFixtures();
+
+  console.log('\n-- identity --');
+  run(
+    `INSERT INTO users (id, email, password_hash, password_algo, role, created_at, updated_at)
+     VALUES (?, ?, 'x', 'pbkdf2-sha256', 'student', ?, ?)`,
+    USER, '  Smoke.Tester@Example.COM ', now, now
+  );
+  assert(
+    'users.email_normalized generated',
+    one('SELECT email_normalized e FROM users WHERE id = ?', USER).e,
+    'smoke.tester@example.com'
+  );
+  run(
+    `INSERT INTO user_profiles (user_id, display_name, timezone, created_at, updated_at)
+     VALUES (?, 'Smoke Tester', 'Asia/Kathmandu', ?, ?)`,
+    USER, now, now
+  );
+  assert(
+    'user_profiles holds no credential column',
+    n(`SELECT COUNT(*) n FROM pragma_table_info('user_profiles')
+        WHERE name LIKE '%password%' OR name LIKE '%token%'`),
+    0
+  );
+
+  run(
+    `INSERT INTO sessions (id, user_id, expires_at, absolute_expires_at, created_at, last_used_at)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    'a'.repeat(64), USER, now + 14 * DAY_MS, now + 90 * DAY_MS, now, now
+  );
+  assertThrows(
+    'sessions rejects a raw (non-sha256-hex) token as id',
+    () =>
+      run(
+        `INSERT INTO sessions (id, user_id, expires_at, absolute_expires_at)
+         VALUES ('plaintext-cookie-value', ?, ?, ?)`,
+        USER, now + 10_000, now + 20_000
+      ),
+    /CHECK constraint/
+  );
+
+  console.log('\n-- selection (NQ-07): flagged questions are unreachable --');
+  const PAPER_SIZE = 5;
+  const drawn = all(
+    `SELECT id FROM questions
+      WHERE chapter_id = ?1 AND status = 'published'
+      ORDER BY id LIMIT ?2`,
+    'book-ch2', PAPER_SIZE
+  ).map((r) => r.id);
+  assert('NQ-07 drew a full paper', drawn.length, PAPER_SIZE);
+  assert(
+    'no drawn question is flagged',
+    n(
+      `SELECT COUNT(*) n FROM questions
+        WHERE status <> 'published' AND id IN (${drawn.map(() => '?').join(',')})`,
+      ...drawn
+    ),
+    0
+  );
+  const flaggedSample = one(
+    `SELECT id FROM questions WHERE status = 'flagged' ORDER BY id LIMIT 1`
+  );
+  assert(
+    'the partial index excludes flagged rows entirely',
+    n(
+      `SELECT COUNT(*) n FROM questions
+        WHERE chapter_id = (SELECT chapter_id FROM questions WHERE id = ?1)
+          AND status = 'published' AND id = ?1`,
+      flaggedSample.id
+    ),
+    0
+  );
+
+  console.log('\n-- delivery: v_question_delivery cannot leak the key --');
+  const deliveryCols = all(`SELECT name FROM pragma_table_info('v_question_delivery')`).map(
+    (r) => r.name
+  );
+  assert(
+    'v_question_delivery exposes no answer column',
+    deliveryCols.filter((c) => /correct|answer|key/i.test(c)),
+    []
+  );
+  const deliverySql = one(
+    `SELECT sql FROM sqlite_master WHERE type = 'view' AND name = 'v_question_delivery'`
+  ).sql;
+  assert('v_question_delivery does not name the key table', /question_answer_keys/.test(deliverySql), false);
+
+  console.log('\n-- attempt: paper + per-attempt option permutation --');
+  const seed = 0x5eed1234;
+  const random = rng(seed);
+  run(
+    `INSERT INTO attempts (public_id, user_id, mode, chapter_id, status, option_seed,
+                           question_count, started_at)
+     VALUES ('A01SMOKEATTEMPT0000000000', ?, 'practice', 'book-ch2', 'in_progress', ?, ?, ?)`,
+    USER, seed, PAPER_SIZE, now
+  );
+  const attemptId = one(`SELECT id FROM attempts WHERE public_id = 'A01SMOKEATTEMPT0000000000'`).id;
+
+  const orders = new Map();
+  drawn.forEach((qid, i) => {
+    const options = all(
+      `SELECT option_id AS id, option_ordinal AS ordinal, option_is_pinned AS is_pinned
+         FROM v_question_delivery WHERE question_id = ? ORDER BY option_ordinal`,
+      qid
+    );
+    const order = permuteOptions(options, random).map((o) => o.id);
+    orders.set(qid, order);
+    run(
+      `INSERT INTO attempt_questions (attempt_id, position, question_id, option_order)
+       VALUES (?, ?, ?, ?)`,
+      attemptId, i + 1, qid, JSON.stringify(order)
+    );
+  });
+  assert('paper rows written', n('SELECT COUNT(*) n FROM attempt_questions WHERE attempt_id = ?', attemptId), PAPER_SIZE);
+  assert(
+    'option_order holds option ids, never positions',
+    orders.get(drawn[0]).every((id) => id.startsWith(drawn[0] + '#')),
+    true
+  );
+  assert(
+    'every pinned option stays last in its delivered order',
+    [...orders.entries()].every(([qid, order]) => {
+      const pinned = all(
+        `SELECT id FROM question_options WHERE question_id = ? AND is_pinned = 1`,
+        qid
+      ).map((r) => r.id);
+      return pinned.every((id) => order.indexOf(id) >= order.length - pinned.length);
+    }),
+    true
+  );
+  assertThrows(
+    'a paper cannot ask the same question twice',
+    () =>
+      run(
+        `INSERT INTO attempt_questions (attempt_id, position, question_id, option_order)
+         VALUES (?, 99, ?, '[]')`,
+        attemptId, drawn[0]
+      ),
+    /UNIQUE constraint/
+  );
+
+  console.log('\n-- TIMESTAMPS ARE MILLISECONDS, round-tripped through the database --');
+  // THE REGRESSION THIS GUARDS. Every timestamp here used to be unix SECONDS
+  // while the API was milliseconds, and nothing failed loudly: a 45-minute
+  // deadline written as seconds and compared against Date.now() is 45,000
+  // times too small, so the attempt expires 45 milliseconds after it starts and
+  // every candidate is handed an empty paper. Writing a deadline, reading it
+  // back and asserting it is still in the future is the cheapest possible
+  // detector, and it would have caught the mismatch on the first run.
+  const DURATION_MS = 45 * 60 * 1000;
+  run(
+    `INSERT INTO attempts (public_id, user_id, mode, template_id, status, option_seed,
+                           question_count, deadline_at)
+     VALUES ('A01SMOKEDEADLINE000000000', ?, 'mock', 'full-mock-1', 'in_progress', 1, 0,
+             CAST(unixepoch('subsec') * 1000 AS INTEGER) + ?)`,
+    USER, DURATION_MS
+  );
+  const timed = one(
+    `SELECT started_at, deadline_at FROM attempts WHERE public_id = 'A01SMOKEDEADLINE000000000'`
+  );
+  const clientNow = Date.now();
+  assert('started_at default agrees with Date.now() to within 2s',
+    Math.abs(timed.started_at - clientNow) < 2000, true);
+  assert('a 45-minute deadline is STILL IN THE FUTURE after the round trip',
+    timed.deadline_at > clientNow, true);
+  assert('and it is 45 minutes away, not 45 milliseconds',
+    Math.abs(timed.deadline_at - clientNow - DURATION_MS) < 2000, true);
+  // The same value read as seconds is already decades in the past. This is the
+  // shape of the bug, asserted so nobody can "simplify" the default back.
+  assert('read as seconds, that deadline would already have expired',
+    timed.deadline_at / 1000 < clientNow / 1000 / 1000, false);
+  assert('attempts.deadline_at is an INTEGER, not a REAL from the *1000',
+    one(`SELECT typeof(deadline_at) t FROM attempts WHERE public_id = 'A01SMOKEDEADLINE000000000'`).t,
+    'integer');
+  assertThrows(
+    'a sync snapshot cannot be stamped after the deadline, even by hand',
+    () =>
+      run(
+        `UPDATE attempts SET synced_answers = '{}', last_sync_at = deadline_at + 1
+          WHERE public_id = 'A01SMOKEDEADLINE000000000'`
+      ),
+    /CHECK constraint/
+  );
+  run(
+    `UPDATE attempts SET synced_answers = '{}', last_sync_at = deadline_at - 1000
+      WHERE public_id = 'A01SMOKEDEADLINE000000000'`
+  );
+  assert('a pre-deadline snapshot is accepted',
+    one(`SELECT last_sync_at IS NOT NULL ok FROM attempts WHERE public_id = 'A01SMOKEDEADLINE000000000'`).ok,
+    1);
+  run(`DELETE FROM attempts WHERE public_id = 'A01SMOKEDEADLINE000000000'`);
+
+  console.log('\n-- OPTION IDS CARRY NO ORDINAL (the published-key leak) --');
+  // frontend/public/data/books/*.json publishes `correct_option_index` and is
+  // in git history forever. While option ids were `question_id || '#' ||
+  // ordinal`, any id that reached a client WAS the answer. Asserted over the
+  // whole seeded bank, because one counter-example is the whole hole.
+  assert(
+    'not one of the 9,160 option ids ends in # followed by its ordinal',
+    n(`SELECT COUNT(*) n FROM question_options
+        WHERE id = question_id || '#' || ordinal`),
+    0
+  );
+  assert(
+    'every opt_key is 12 base32 characters',
+    n(`SELECT COUNT(*) n FROM question_options
+        WHERE length(opt_key) <> 12 OR opt_key NOT GLOB '[0-9A-Z]*'`),
+    0
+  );
+  assert(
+    'and no opt_key is a bare number, so none is a disguised ordinal',
+    n(`SELECT COUNT(*) n FROM question_options WHERE opt_key GLOB '[0-9]*'
+        AND opt_key NOT GLOB '*[A-Z]*'`),
+    0
+  );
+  assert(
+    'the ordinal is still recorded, server-side, for every option',
+    n(`SELECT COUNT(*) n FROM question_options WHERE ordinal IS NULL`),
+    0
+  );
+
+  console.log('\n-- grading (NQ-10b): one statement for the whole paper --');
+  const keys = new Map(
+    all(
+      `SELECT question_id, correct_option_id FROM question_answer_keys
+        WHERE question_id IN (SELECT value FROM json_each(?1))`,
+      JSON.stringify(drawn)
+    ).map((r) => [r.question_id, r.correct_option_id])
+  );
+  assert('NQ-10b returned a key per question in one query', keys.size, PAPER_SIZE);
+
+  // answer 0: correct. answer 1: wrong. answer 2: skipped. 3 and 4: untouched.
+  const answerOne = (qid, optionId) => {
+    const order = orders.get(qid);
+    const correct = keys.get(qid) === optionId ? 1 : 0;
+    run(
+      `INSERT INTO attempt_answers (attempt_id, question_id, selected_opt_key, is_correct,
+                                    delivered_position, time_ms, answered_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (attempt_id, question_id) DO UPDATE SET
+         selected_opt_key = excluded.selected_opt_key,
+         is_correct       = excluded.is_correct,
+         time_ms          = excluded.time_ms,
+         revised          = 1,
+         answered_at      = excluded.answered_at`,
+      attemptId, qid,
+      // The opt_key half of the option id -- a 12-char token, never an index.
+      optionId === null ? null : optionId.split('#')[1],
+      correct,
+      optionId === null ? null : order.indexOf(optionId) + 1,
+      4200, now
+    );
+    return correct;
+  };
+
+  answerOne(drawn[0], keys.get(drawn[0]));
+  const wrongOption = all(
+    `SELECT id FROM question_options WHERE question_id = ? AND id <> ? ORDER BY ordinal LIMIT 1`,
+    drawn[1], keys.get(drawn[1])
+  )[0].id;
+  answerOne(drawn[1], wrongOption);
+  answerOne(drawn[2], null); // skipped
+
+  let a = one('SELECT answered_count, correct_count, score_bp FROM attempts WHERE id = ?', attemptId);
+  assert('attempts.answered_count after 2 answers + 1 skip', a.answered_count, 2);
+  assert('attempts.correct_count', a.correct_count, 1);
+  assert('attempts.score_bp generated (1 of 5)', a.score_bp, 2000);
+
+  assert(
+    'attempt_answers.selected_option_id generated column resolves',
+    one('SELECT selected_option_id s FROM attempt_answers WHERE attempt_id = ? AND question_id = ?', attemptId, drawn[0]).s,
+    keys.get(drawn[0])
+  );
+  assert(
+    'a skipped answer has a NULL option id, not a sentinel',
+    one('SELECT selected_option_id s FROM attempt_answers WHERE attempt_id = ? AND question_id = ?', attemptId, drawn[2]).s,
+    null
+  );
+
+  console.log('\n-- revision: the delta path, not a second exposure --');
+  answerOne(drawn[1], keys.get(drawn[1])); // student changes their mind, now right
+  a = one('SELECT answered_count, correct_count, score_bp FROM attempts WHERE id = ?', attemptId);
+  assert('answered_count unchanged by a revision', a.answered_count, 2);
+  assert('correct_count follows the revision', a.correct_count, 2);
+  assert('score_bp recomputed', a.score_bp, 4000);
+  const revised = one(
+    'SELECT exposure_count, answer_count, correct_count, consecutive_correct, accuracy_bp FROM user_question_stats WHERE user_id = ? AND question_id = ?',
+    USER, drawn[1]
+  );
+  assert('user_question_stats: one exposure despite the revision', revised.exposure_count, 1);
+  assert('user_question_stats: one answer', revised.answer_count, 1);
+  assert('user_question_stats: credited correct', revised.correct_count, 1);
+  assert('user_question_stats: accuracy_bp generated', revised.accuracy_bp, 10000);
+
+  answerOne(drawn[2], keys.get(drawn[2])); // the skip becomes an answer
+  a = one('SELECT answered_count, correct_count FROM attempts WHERE id = ?', attemptId);
+  assert('skip -> answer raises answered_count', a.answered_count, 3);
+  assert('skip -> answer raises correct_count', a.correct_count, 3);
+
+  console.log('\n-- the progress page (NQ-27): one indexed read --');
+  const plan = all(
+    `EXPLAIN QUERY PLAN
+     SELECT chapter_id, COUNT(*) seen, SUM(correct_count > 0) ever_correct,
+            SUM(answer_count) answers, SUM(correct_count) corrects
+       FROM user_question_stats WHERE user_id = ?1 GROUP BY chapter_id`
+  )
+    .map((r) => r.detail)
+    .join(' | ');
+  assert('NQ-27 uses the covering index', /idx_user_question_stats_user_chapter/.test(plan), true);
+  assert('NQ-27 needs no temp b-tree for the GROUP BY', /TEMP B-TREE/.test(plan), false);
+  const progress = all(
+    `SELECT chapter_id, COUNT(*) seen, SUM(correct_count > 0) ever_correct
+       FROM user_question_stats WHERE user_id = ?1 GROUP BY chapter_id`,
+    USER
+  );
+  assert('progress rows', progress, [{ chapter_id: 'book-ch2', seen: 3, ever_correct: 3 }]);
+
+  console.log('\n-- integrity the database enforces, not a handler --');
+  assertThrows(
+    'an answer cannot name an option key that does not exist',
+    () =>
+      run(
+        `INSERT INTO attempt_answers (attempt_id, question_id, selected_opt_key, is_correct, delivered_position)
+         VALUES (?, ?, 'ZZZZZZZZZZZZ', 1, 1)`,
+        attemptId, drawn[3]
+      ),
+    /FOREIGN KEY constraint/
+  );
+  assertThrows(
+    'an answer cannot smuggle a bare ordinal in where an option key belongs',
+    () =>
+      run(
+        `INSERT INTO attempt_answers (attempt_id, question_id, selected_opt_key, is_correct, delivered_position)
+         VALUES (?, ?, '3', 1, 1)`,
+        attemptId, drawn[3]
+      ),
+    /CHECK constraint/
+  );
+  assertThrows(
+    "an answer key cannot point at another question's option",
+    () =>
+      run(
+        `UPDATE question_answer_keys SET correct_option_id = ? WHERE question_id = ?`,
+        keys.get(drawn[1]), drawn[0]
+      ),
+    /CHECK constraint/
+  );
+  assertThrows(
+    'a question whose answers exist cannot be deleted (use status = retired)',
+    () => run('DELETE FROM questions WHERE id = ?', drawn[0]),
+    /FOREIGN KEY constraint/
+  );
+  assertThrows(
+    'an option id must equal question_id || # || opt_key',
+    () =>
+      run(
+        `INSERT INTO question_options (id, question_id, ordinal, opt_key, text)
+         VALUES ('bogus', ?, 9, 'ABCDEFGHJKMN', 'x')`,
+        drawn[3]
+      ),
+    /CHECK constraint/
+  );
+  assertThrows(
+    'an opt_key cannot BE the ordinal -- that was the leak, and the CHECK closes it',
+    () =>
+      run(
+        `INSERT INTO question_options (id, question_id, ordinal, opt_key, text)
+         VALUES (? || '#9', ?, 9, '9', 'x')`,
+        drawn[3], drawn[3]
+      ),
+    /CHECK constraint/
+  );
+  assertThrows(
+    'STRICT refuses a text value in an integer column',
+    () => run(`UPDATE attempts SET question_count = 'five' WHERE id = ?`, attemptId),
+    /cannot store TEXT value in INTEGER column/
+  );
+
+  console.log('\n-- srs, bookmarks, streaks, notifications, leaderboard --');
+  run(
+    `INSERT INTO srs_state (user_id, question_id, stability, difficulty, elapsed_days,
+                            scheduled_days, reps, lapses, state, due, last_review, last_rating,
+                            created_at, updated_at)
+     VALUES (?, ?, 3.1734, 5.2, 0.0, 1.0, 1, 0, 1, ?, ?, 3, ?, ?)`,
+    USER, drawn[0], now + DAY_MS, now, now, now
+  );
+  assert(
+    'NQ-29 due queue',
+    all(
+      `SELECT question_id FROM srs_state
+        WHERE user_id = ?1 AND due <= ?2 AND suspended_at IS NULL ORDER BY due LIMIT 10`,
+      USER, now + DAY_MS + 3_600_000
+    ).length,
+    1
+  );
+  assertThrows(
+    'srs difficulty is bounded to the FSRS 1..10 range',
+    () => run('UPDATE srs_state SET difficulty = 42.0 WHERE user_id = ?', USER),
+    /CHECK constraint/
+  );
+
+  run('INSERT INTO bookmarks (user_id, question_id, created_at) VALUES (?, ?, ?)', USER, drawn[0], now);
+  assert('bookmark stored against a content-hash id', one('SELECT question_id q FROM bookmarks WHERE user_id = ?', USER).q, drawn[0]);
+
+  const touchStreak = db.prepare(`
+    INSERT INTO streaks (user_id, current_length, last_active_date, total_active_days)
+    VALUES (?1, 1, ?2, 1)
+    ON CONFLICT (user_id) DO UPDATE SET
+      current_length = CASE
+        WHEN last_active_date = ?2                     THEN current_length
+        WHEN last_active_date = date(?2, '-1 day')     THEN current_length + 1
+        WHEN freezes_available > 0
+             AND last_active_date = date(?2, '-2 day') THEN current_length + 1
+        ELSE 1 END,
+      freezes_available = CASE
+        WHEN last_active_date = date(?2, '-2 day') AND freezes_available > 0
+             THEN freezes_available - 1 ELSE freezes_available END,
+      total_active_days = total_active_days
+        + CASE WHEN last_active_date IS NULL OR last_active_date <> ?2 THEN 1 ELSE 0 END,
+      last_active_date  = ?2,
+      updated_at        = CAST(unixepoch('subsec') * 1000 AS INTEGER)
+    WHERE last_active_date IS NULL OR last_active_date <= ?2
+  `);
+  touchStreak.run(USER, '2026-10-18');
+  touchStreak.run(USER, '2026-10-18'); // same day twice: must be a no-op
+  touchStreak.run(USER, '2026-10-19');
+  touchStreak.run(USER, '2026-10-20');
+  const streak = one('SELECT current_length c, longest_length l, total_active_days t FROM streaks WHERE user_id = ?', USER);
+  assert('streak length after 3 consecutive days (one submitted twice)', streak.c, 3);
+  assert('streak ratchet trigger raised longest_length', streak.l, 3);
+  assert('total_active_days counted days, not requests', streak.t, 3);
+  touchStreak.run(USER, '2026-10-25'); // gap, no freeze available
+  assert('a gap resets current_length', one('SELECT current_length c FROM streaks WHERE user_id = ?', USER).c, 1);
+  assert('but longest_length is a ratchet', one('SELECT longest_length l FROM streaks WHERE user_id = ?', USER).l, 3);
+
+  // Note the repeated WHERE: SQLite only matches a conflict target to a
+  // PARTIAL unique index if the predicate is restated. Without it this
+  // prepare() fails with 'ON CONFLICT clause does not match any PRIMARY KEY or
+  // UNIQUE constraint' -- at runtime, in production, on the cron path.
+  const notify = db.prepare(`
+    INSERT INTO notifications (user_id, kind, title, dedupe_key, created_at)
+    VALUES (?, 'srs_due', '3 cards due', ?, ?)
+    ON CONFLICT (user_id, dedupe_key) WHERE dedupe_key IS NOT NULL DO NOTHING`);
+  notify.run(USER, 'srs_due:2026-10-20', now);
+  notify.run(USER, 'srs_due:2026-10-20', now);
+  assert('notification dedupe_key stops a duplicate nag', n('SELECT COUNT(*) n FROM notifications WHERE user_id = ?', USER), 1);
+
+  run(
+    `INSERT INTO leaderboard_snapshots (scope, scope_ref, period, period_start, metric,
+                                        top_json, entrant_count, computed_at, compute_ms)
+     VALUES ('global', '', 'weekly', '2026-10-19', 'correct_answers', ?, 1, ?, 12)`,
+    JSON.stringify([{ rank: 1, user_id: USER, display_name: 'Smoke Tester', score: 3 }]),
+    now
+  );
+  const snapId = one(`SELECT id FROM leaderboard_snapshots ORDER BY id DESC LIMIT 1`).id;
+  run(
+    `INSERT INTO leaderboard_entries (snapshot_id, rank, user_id, score, accuracy_bp)
+     VALUES (?, 1, ?, 3, 10000)`,
+    snapId, USER
+  );
+  assert('NQ-34 my-rank is a unique-index hit', one('SELECT rank r FROM leaderboard_entries WHERE snapshot_id = ? AND user_id = ?', snapId, USER).r, 1);
+  assertThrows(
+    'one user cannot hold two ranks on one board',
+    () => run('INSERT INTO leaderboard_entries (snapshot_id, rank, user_id, score) VALUES (?, 2, ?, 1)', snapId, USER),
+    /UNIQUE constraint/
+  );
+
+  console.log('\n-- ARCHIVAL: raw answers go, progress stays --');
+  run(`UPDATE attempts SET status = 'submitted', submitted_at = ?, elapsed_ms = 60000 WHERE id = ?`, now, attemptId);
+  const beforeStats = all(
+    'SELECT question_id, exposure_count, answer_count, correct_count FROM user_question_stats WHERE user_id = ? ORDER BY question_id',
+    USER
+  );
+  const beforeAttempt = one('SELECT answered_count, correct_count, score_bp FROM attempts WHERE id = ?', attemptId);
+  const rawBefore = n('SELECT COUNT(*) n FROM attempt_answers WHERE attempt_id = ?', attemptId);
+
+  // Step 1 of the job in 0004: stage to the archive table (denormalising
+  // user_id, because the attempt may be gone by the time the drain runs).
+  const cutoff = now + 1; // pretend everything is older than the retention window
+  run(
+    `INSERT INTO attempt_answers_archive (id, attempt_id, user_id, question_id, selected_opt_key,
+                                          is_correct, delivered_position, time_ms, answered_at)
+     SELECT aa.id, aa.attempt_id, a.user_id, aa.question_id, aa.selected_opt_key,
+            aa.is_correct, aa.delivered_position, aa.time_ms, aa.answered_at
+       FROM attempt_answers aa JOIN attempts a ON a.id = aa.attempt_id
+      WHERE aa.answered_at < ?1
+      ORDER BY aa.id LIMIT 5000`,
+    cutoff
+  );
+  // Step 2: delete the range just staged.
+  const purged = run('DELETE FROM attempt_answers WHERE answered_at < ?1', cutoff).changes;
+
+  assert('answers staged to the archive', n('SELECT COUNT(*) n FROM attempt_answers_archive'), rawBefore);
+  assert('raw answers purged', purged, rawBefore);
+  assert('attempt_answers is now empty', n('SELECT COUNT(*) n FROM attempt_answers'), 0);
+  assert(
+    'user_question_stats SURVIVED the purge',
+    all('SELECT question_id, exposure_count, answer_count, correct_count FROM user_question_stats WHERE user_id = ? ORDER BY question_id', USER),
+    beforeStats
+  );
+  assert(
+    'attempts summary SURVIVED the purge',
+    one('SELECT answered_count, correct_count, score_bp FROM attempts WHERE id = ?', attemptId),
+    beforeAttempt
+  );
+  assert(
+    'no DELETE trigger exists on attempt_answers (one would have erased the rollups)',
+    all(`SELECT name FROM sqlite_master WHERE type = 'trigger' AND sql LIKE '%DELETE ON attempt_answers%'`),
+    []
+  );
+  assert('the paper is still reviewable after the purge', n('SELECT COUNT(*) n FROM attempt_questions WHERE attempt_id = ?', attemptId), PAPER_SIZE);
+
+  console.log('\n-- full-text search (NQ-11) --');
+  const hits = all(
+    `SELECT question_id, bm25(questions_fts, 0.0, 0.0, 0.0, 10.0, 3.0) rank
+       FROM questions_fts
+      WHERE questions_fts MATCH ?1 AND status = 'published'
+      ORDER BY rank LIMIT 5`,
+    'karnaugh'
+  );
+  assert('FTS5 returns ranked hits', hits.length > 0, true);
+  assert('FTS row count tracks the question count', n('SELECT COUNT(*) n FROM questions_fts'), n('SELECT COUNT(*) n FROM questions'));
+  // An edit must reindex, including through an option change.
+  //
+  // This mutates real seeded content, so the original values are captured and
+  // restored at the end of the block. Previously they were not: a question was
+  // left permanently reading "Zzyzx smoke marker stem" and one of its options
+  // "Quuxinator option marker", so anyone who ran the smoke suite and then
+  // looked at the database found a corrupted question and no hint as to why.
+  const victim = drawn[4];
+  const originalStem = one(`SELECT stem FROM questions WHERE id = ?`, victim).stem;
+  const originalOption = one(
+    `SELECT text FROM question_options WHERE question_id = ? AND ordinal = 1`,
+    victim
+  ).text;
+
+  run(`UPDATE questions SET stem = ?, updated_at = ? WHERE id = ?`, 'Zzyzx smoke marker stem', now, victim);
+  assert('stem edit reindexes', all(`SELECT question_id FROM questions_fts WHERE questions_fts MATCH 'zzyzx'`).map((r) => r.question_id), [victim]);
+  // Addressed by (question_id, ordinal), not by a hand-built `id`: option ids
+  // no longer encode the ordinal, so `victim + '#1'` names nothing.
+  run(
+    `UPDATE question_options SET text = ?, updated_at = ?
+      WHERE question_id = ? AND ordinal = 1`,
+    'Quuxinator option marker', now, victim
+  );
+  assert('option edit reindexes', all(`SELECT question_id FROM questions_fts WHERE questions_fts MATCH 'quuxinator'`).map((r) => r.question_id), [victim]);
+  assert('FTS has no duplicate row after two reindexes', n(`SELECT COUNT(*) n FROM questions_fts WHERE question_id = ?`, victim), 1);
+
+  // Put the borrowed question back, and prove the restore itself reindexed -
+  // a restore that left the FTS table pointing at the marker text would be a
+  // silently corrupt search index.
+  run(`UPDATE questions SET stem = ?, updated_at = ? WHERE id = ?`, originalStem, now, victim);
+  run(
+    `UPDATE question_options SET text = ?, updated_at = ? WHERE question_id = ? AND ordinal = 1`,
+    originalOption, now, victim
+  );
+  assert('restored stem', one(`SELECT stem FROM questions WHERE id = ?`, victim).stem, originalStem);
+  assert(
+    'restored option text',
+    one(`SELECT text FROM question_options WHERE question_id = ? AND ordinal = 1`, victim).text,
+    originalOption
+  );
+  assert(
+    'marker text is gone from the search index',
+    all(`SELECT question_id FROM questions_fts WHERE questions_fts MATCH 'zzyzx OR quuxinator'`),
+    []
+  );
+
+  console.log('\n-- sub-chapter classification carries its provenance (0009) --');
+
+  // The bank is labelled by a heuristic, so the question is never "is this
+  // label right" -- it is "can a reader tell that it is a guess". These assert
+  // the database refuses every state where it could not.
+  const labelled = one(
+    `SELECT id, subchapter_id, subchapter_source, subchapter_confidence_bp,
+            subchapter_classifier_version
+       FROM questions
+      WHERE subchapter_source = 'heuristic'
+      LIMIT 1`
+  );
+  assert('a heuristic label records its source', labelled.subchapter_source, 'heuristic');
+  assert(
+    'a heuristic label records a confidence',
+    typeof labelled.subchapter_confidence_bp === 'number',
+    true
+  );
+  assert(
+    'a heuristic label records the classifier version',
+    typeof labelled.subchapter_classifier_version === 'string',
+    true
+  );
+  assert(
+    'no row carries provenance without a label',
+    one(
+      `SELECT COUNT(*) n FROM questions
+        WHERE subchapter_id IS NULL
+          AND (subchapter_source IS NOT NULL
+               OR subchapter_confidence_bp IS NOT NULL
+               OR subchapter_classifier_version IS NOT NULL)`
+    ).n,
+    0
+  );
+  assert(
+    'no row carries a label without provenance',
+    one(
+      `SELECT COUNT(*) n FROM questions
+        WHERE subchapter_id IS NOT NULL AND subchapter_source IS NULL`
+    ).n,
+    0
+  );
+
+  assertThrows(
+    'a sub-chapter label cannot be written without saying where it came from',
+    () =>
+      run(
+        `UPDATE questions SET subchapter_source = NULL WHERE id = ?`,
+        labelled.id
+      ),
+    /provenance disagree/
+  );
+  assertThrows(
+    'clearing a label must clear its confidence with it',
+    () => run(`UPDATE questions SET subchapter_id = NULL WHERE id = ?`, labelled.id),
+    /provenance disagree/
+  );
+  assertThrows(
+    'a heuristic label cannot omit its confidence',
+    () =>
+      run(
+        `UPDATE questions SET subchapter_confidence_bp = NULL WHERE id = ?`,
+        labelled.id
+      ),
+    /provenance disagree/
+  );
+  assertThrows(
+    'a human label cannot carry a machine confidence score',
+    () =>
+      run(
+        `UPDATE questions SET subchapter_source = 'human' WHERE id = ?`,
+        labelled.id
+      ),
+    /provenance disagree/
+  );
+  assertThrows(
+    'a confidence outside 0-10000 bp is rejected',
+    () =>
+      run(
+        `UPDATE questions SET subchapter_confidence_bp = 10001 WHERE id = ?`,
+        labelled.id
+      ),
+    /CHECK constraint/
+  );
+
+  // A librarian's decision must survive the next classifier run. Promote one
+  // row to 'human' the way the review tool would -- clearing the machine
+  // fields in the same statement, which is the only way the trigger allows --
+  // then try to demote it.
+  run(
+    `UPDATE questions
+        SET subchapter_source = 'human',
+            subchapter_confidence_bp = NULL,
+            subchapter_classifier_version = NULL
+      WHERE id = ?`,
+    labelled.id
+  );
+  assert(
+    'a label can be promoted to human when the machine fields go with it',
+    one('SELECT subchapter_source s FROM questions WHERE id = ?', labelled.id).s,
+    'human'
+  );
+  assertThrows(
+    'a classifier re-run cannot overwrite a human classification',
+    () =>
+      run(
+        `UPDATE questions
+            SET subchapter_source = 'heuristic',
+                subchapter_confidence_bp = 4200,
+                subchapter_classifier_version = 'subchapter-terms-v2'
+          WHERE id = ?`,
+        labelled.id
+      ),
+    /may not overwrite a human one/
+  );
+  // Put the borrowed row back, so this suite stays re-runnable.
+  //
+  // This takes two statements, and that is the point of the trigger rather
+  // than a limitation of it: there is no single UPDATE that turns a human
+  // classification back into a machine one. Undoing a human decision means
+  // first clearing it, which is a deliberate act, and not something a
+  // re-import can do by accident.
+  run(
+    `UPDATE questions
+        SET subchapter_id = NULL,
+            subchapter_source = NULL,
+            subchapter_confidence_bp = NULL,
+            subchapter_classifier_version = NULL
+      WHERE id = ?`,
+    labelled.id
+  );
+  run(
+    `UPDATE questions
+        SET subchapter_id = ?,
+            subchapter_source = 'heuristic',
+            subchapter_confidence_bp = ?,
+            subchapter_classifier_version = ?
+      WHERE id = ?`,
+    labelled.subchapter_id,
+    labelled.subchapter_confidence_bp,
+    labelled.subchapter_classifier_version,
+    labelled.id
+  );
+  assert(
+    'the borrowed row is restored',
+    one(
+      `SELECT subchapter_id i, subchapter_source s, subchapter_confidence_bp c
+         FROM questions WHERE id = ?`,
+      labelled.id
+    ),
+    {
+      i: labelled.subchapter_id,
+      s: 'heuristic',
+      c: labelled.subchapter_confidence_bp,
+    }
+  );
+
+  // Leave the database exactly as the seed produced it.
+  resetFixtures();
+
+  const fk = all('PRAGMA foreign_key_check');
+  assert('foreign_key_check clean at the end', fk, []);
+
+  return { checks, failures };
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const argv = process.argv.slice(2);
+  const i = argv.indexOf('--db');
+  const dbPath = resolve(i >= 0 && argv[i + 1] ? argv[i + 1] : join(WORKER_ROOT, '.local', 'necprep.sqlite'));
+  if (!existsSync(dbPath)) {
+    console.error(`no database at ${dbPath}. Run \`npm run db:apply:local && npm run db:seed:local\` first.`);
+    process.exit(2);
+  }
+  const db = new DatabaseSync(dbPath);
+  const result = runSmoke(db);
+  db.close();
+  console.log(`\n${result.checks - result.failures}/${result.checks} checks passed`);
+  process.exit(result.failures === 0 ? 0 : 1);
+}
diff --git a/worker/db/verify-schema.mjs b/worker/db/verify-schema.mjs
new file mode 100644
index 0000000..45411ab
--- /dev/null
+++ b/worker/db/verify-schema.mjs
@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+/**
+ * verify-schema.mjs -- prove that db/schema.ts and worker/migrations/*.sql
+ * describe the same database.
+ *
+ * The migrations are the source of truth; the Drizzle file is a typed client.
+ * Two hand-maintained descriptions of one schema is normally a liability, and
+ * this script is what makes it safe: it introspects a freshly migrated
+ * database and fails if the two have drifted, so the duplication cannot rot
+ * quietly between them.
+ *
+ * It checks, in both directions:
+ *
+ *   * tables            -- present in SQL and in TS, nothing extra either side
+ *   * columns           -- names, nullability, primary-key membership
+ *   * generated columns -- which ones, and stored vs virtual
+ *   * indexes           -- names, key columns, uniqueness, partial-ness
+ *   * foreign keys      -- (child columns, parent table, parent columns, ON DELETE)
+ *   * enums             -- the TS literal union against the SQL CHECK ... IN (...)
+ *
+ * That last one matters most. Drizzle's `{ enum: [...] }` is types-only for
+ * SQLite: the runtime constraint is the CHECK in the migration. Without this
+ * check, adding a value to one and not the other produces either a TypeScript
+ * type that lies or a database that rejects a value the compiler blessed.
+ *
+ * Runs db/schema.ts directly through Node's type stripping (Node 22+), so
+ * there is no build step and no tsc in the loop.
+ *
+ * Usage: node db/verify-schema.mjs [--db <path>] [--verbose]
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { getTableConfig, getViewConfig } from 'drizzle-orm/sqlite-core';
+import { is } from 'drizzle-orm';
+import { SQLiteTable, SQLiteView } from 'drizzle-orm/sqlite-core';
+
+const WORKER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+/** `d1_migrations` belongs to wrangler's migration runner, not to this schema. */
+const SQL_ONLY_TABLES = new Set(['d1_migrations']);
+
+/**
+ * FTS5 shadow tables (questions_fts_data, _idx, _docsize, _config) are engine
+ * internals. The virtual table `questions_fts` itself is NOT internal: it is
+ * declared in schema.ts so NQ-11 can be written with typed columns, and its
+ * existence is checked -- but its column and index shape is FTS5's business,
+ * not Drizzle's, so structural comparison is skipped for it.
+ */
+const isFtsShadow = (name) => /^questions_fts_/.test(name);
+const isVirtual = (ddl) => /^\s*CREATE\s+VIRTUAL\s+TABLE/i.test(ddl ?? '');
+
+const problems = [];
+const notes = [];
+const fail = (where, message) => problems.push(`${where}: ${message}`);
+
+function sqlTables(db) {
+  return db
+    .prepare(
+      `SELECT name, sql FROM sqlite_master
+        WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+        ORDER BY name`
+    )
+    .all()
+    .filter((t) => !SQL_ONLY_TABLES.has(t.name) && !isFtsShadow(t.name));
+}
+
+function sqlColumns(db, table) {
+  // table_xinfo includes generated columns; table_info does not.
+  return db.prepare(`SELECT * FROM pragma_table_xinfo(?)`).all(table);
+}
+
+function sqlIndexes(db, table) {
+  return db
+    .prepare(
+      `SELECT name, sql FROM sqlite_master
+        WHERE type = 'index' AND tbl_name = ? AND sql IS NOT NULL
+        ORDER BY name`
+    )
+    .all(table)
+    .map((idx) => ({
+      name: idx.name,
+      unique: /CREATE\s+UNIQUE\s+INDEX/i.test(idx.sql),
+      partial: /\)\s*WHERE\s/i.test(idx.sql),
+      // Key columns as written, lowercased, with DESC/ASC kept: 'DESC' is part
+      // of the index's identity and Drizzle cannot express it in .on(column)
+      // form, which is exactly the kind of difference this must catch.
+      keys: indexKeyColumns(idx.sql),
+    }));
+}
+
+/**
+ * The key columns of a CREATE INDEX, as written.
+ *
+ * Parsed by walking balanced parentheses rather than by slicing to the last
+ * ')': a partial index's WHERE clause contains both parentheses and commas
+ * (`WHERE status IN ('draft', 'flagged')`), and a naive slice folds that
+ * predicate into the key list.
+ *
+ * DESC/ASC is kept. It is part of the index's identity, Drizzle cannot express
+ * it in `.on(column)` form, and silently losing it would turn a no-sort index
+ * scan into a sort -- exactly the regression this verifier exists to catch.
+ */
+function indexKeyColumns(ddl) {
+  const start = ddl.indexOf('(');
+  if (start < 0) return [];
+  let depth = 0;
+  let end = -1;
+  for (let i = start; i < ddl.length; i++) {
+    if (ddl[i] === '(') depth++;
+    else if (ddl[i] === ')') {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end < 0) return [];
+  // Split on top-level commas only, so a key expression containing its own
+  // parentheses stays in one piece.
+  const inner = ddl.slice(start + 1, end);
+  const parts = [];
+  let buf = '';
+  depth = 0;
+  for (const ch of inner) {
+    if (ch === '(') depth++;
+    else if (ch === ')') depth--;
+    if (ch === ',' && depth === 0) {
+      parts.push(buf);
+      buf = '';
+    } else {
+      buf += ch;
+    }
+  }
+  parts.push(buf);
+  return parts.map((x) => x.trim().toLowerCase()).filter(Boolean);
+}
+
+function sqlForeignKeys(db, table) {
+  const rows = db.prepare(`SELECT * FROM pragma_foreign_key_list(?)`).all(table);
+  const byId = new Map();
+  for (const r of rows) {
+    if (!byId.has(r.id)) byId.set(r.id, { table: r.table, from: [], to: [], onDelete: r.on_delete });
+    byId.get(r.id).from.push(r.from);
+    byId.get(r.id).to.push(r.to);
+  }
+  return [...byId.values()].map(
+    (fk) =>
+      `${fk.from.join('+')} -> ${fk.table}(${fk.to.join('+')}) ON DELETE ${fk.onDelete.toUpperCase()}`
+  );
+}
+
+/**
+ * Pulls the value list out of a `... <column> IN ('a', 'b')` CHECK in the
+ * table DDL. Returns null when the column has no such CHECK, which is itself
+ * a finding when the TS side declares an enum.
+ */
+function sqlEnumValues(tableSql, column) {
+  const re = new RegExp(`\\b${column}\\s+IN\\s*\\(([^)]*)\\)`, 'i');
+  const m = tableSql.match(re);
+  if (!m) return null;
+  const values = [...m[1].matchAll(/'((?:[^']|'')*)'/g)].map((v) => v[1].replace(/''/g, "'"));
+  return values.length ? values : null;
+}
+
+export async function verify(db, { verbose = false } = {}) {
+  const schema = await import(pathToFileURL(join(WORKER_ROOT, 'db', 'schema.ts')).href);
+
+  const tsTables = new Map();
+  const tsViews = new Map();
+  for (const value of Object.values(schema)) {
+    if (is(value, SQLiteTable)) {
+      const cfg = getTableConfig(value);
+      tsTables.set(cfg.name, cfg);
+    } else if (is(value, SQLiteView)) {
+      tsViews.set(getViewConfig(value).name, value);
+    }
+  }
+
+  const dbTables = sqlTables(db);
+  const dbTableNames = new Set(dbTables.map((t) => t.name));
+
+  // ---- table presence, both directions -----------------------------------
+  for (const name of dbTableNames) {
+    if (!tsTables.has(name)) fail('tables', `${name} exists in SQL but not in schema.ts`);
+  }
+  for (const name of tsTables.keys()) {
+    if (!dbTableNames.has(name)) fail('tables', `${name} exists in schema.ts but not in SQL`);
+  }
+
+  const dbViews = db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'view' ORDER BY name`)
+    .all()
+    .map((r) => r.name);
+  for (const name of dbViews) {
+    if (!tsViews.has(name)) fail('views', `${name} exists in SQL but not in schema.ts`);
+  }
+  for (const name of tsViews.keys()) {
+    if (!dbViews.includes(name)) fail('views', `${name} exists in schema.ts but not in SQL`);
+  }
+
+  let columnsChecked = 0;
+  let indexesChecked = 0;
+  let enumsChecked = 0;
+  let fksChecked = 0;
+
+  for (const { name: table, sql: tableSql } of dbTables) {
+    const cfg = tsTables.get(table);
+    if (!cfg) continue;
+
+    if (isVirtual(tableSql)) {
+      // Existence was checked above. The rest is FTS5's internal shape.
+      notes.push(`${table} is an FTS5 virtual table; column/index shape not compared`);
+      continue;
+    }
+
+    // ---- columns ---------------------------------------------------------
+    const dbCols = sqlColumns(db, table);
+    const dbColByName = new Map(dbCols.map((c) => [c.name, c]));
+    const tsColByName = new Map(cfg.columns.map((c) => [c.name, c]));
+
+    for (const c of dbCols) {
+      if (!tsColByName.has(c.name)) fail(table, `column ${c.name} missing from schema.ts`);
+    }
+    for (const name of tsColByName.keys()) {
+      if (!dbColByName.has(name)) fail(table, `column ${name} in schema.ts is not in SQL`);
+    }
+
+    for (const [name, tsCol] of tsColByName) {
+      const dbCol = dbColByName.get(name);
+      if (!dbCol) continue;
+      columnsChecked++;
+
+      const sqlNotNull = dbCol.notnull === 1;
+      if (sqlNotNull !== tsCol.notNull) {
+        fail(
+          table,
+          `column ${name}: NOT NULL is ${sqlNotNull} in SQL, ${tsCol.notNull} in schema.ts`
+        );
+      }
+
+      // pragma_table_xinfo: hidden 2 = VIRTUAL generated, 3 = STORED generated.
+      const sqlGenerated = dbCol.hidden === 2 ? 'virtual' : dbCol.hidden === 3 ? 'stored' : null;
+      const tsGenerated = tsCol.generated ? (tsCol.generated.mode ?? 'virtual') : null;
+      if (sqlGenerated !== tsGenerated) {
+        fail(
+          table,
+          `column ${name}: generated is ${sqlGenerated ?? 'no'} in SQL, ` +
+            `${tsGenerated ?? 'no'} in schema.ts`
+        );
+      }
+
+      const sqlPk = dbCol.pk > 0;
+      const tsPk =
+        tsCol.primary || cfg.primaryKeys.some((pk) => pk.columns.some((c) => c.name === name));
+      if (sqlPk !== tsPk) {
+        fail(table, `column ${name}: primary key is ${sqlPk} in SQL, ${tsPk} in schema.ts`);
+      }
+
+      // ---- enum parity ---------------------------------------------------
+      if (tsCol.enumValues && tsCol.enumValues.length) {
+        enumsChecked++;
+        const fromSql = sqlEnumValues(tableSql, name);
+        if (!fromSql) {
+          fail(table, `column ${name}: schema.ts declares an enum but SQL has no CHECK ... IN (...)`);
+        } else {
+          const a = [...fromSql].sort();
+          const b = [...tsCol.enumValues].sort();
+          if (JSON.stringify(a) !== JSON.stringify(b)) {
+            fail(
+              table,
+              `column ${name}: enum drift.\n      SQL: ${JSON.stringify(a)}\n      TS : ${JSON.stringify(b)}`
+            );
+          }
+        }
+      }
+    }
+
+    // ---- indexes ---------------------------------------------------------
+    const dbIdx = sqlIndexes(db, table);
+    const tsIdxByName = new Map(cfg.indexes.map((i) => [i.config.name, i.config]));
+    for (const idx of dbIdx) {
+      indexesChecked++;
+      const tsIdx = tsIdxByName.get(idx.name);
+      if (!tsIdx) {
+        fail(table, `index ${idx.name} exists in SQL but not in schema.ts`);
+        continue;
+      }
+      if (!!tsIdx.unique !== idx.unique) {
+        fail(table, `index ${idx.name}: UNIQUE is ${idx.unique} in SQL, ${!!tsIdx.unique} in TS`);
+      }
+      if (!!tsIdx.where !== idx.partial) {
+        fail(
+          table,
+          `index ${idx.name}: partial is ${idx.partial} in SQL, ${!!tsIdx.where} in TS`
+        );
+      }
+      // Key columns: Drizzle entries are either a Column or a raw SQL chunk
+      // (used for 'col DESC'). Render both sides to lowercase text.
+      const tsKeys = tsIdx.columns.map((c) => {
+        if (c && typeof c === 'object' && 'name' in c && typeof c.name === 'string') {
+          return c.name.toLowerCase();
+        }
+        return String(c?.queryChunks?.map((q) => q?.value?.join?.('') ?? '').join('') ?? c)
+          .trim()
+          .toLowerCase();
+      });
+      if (JSON.stringify(tsKeys) !== JSON.stringify(idx.keys)) {
+        fail(
+          table,
+          `index ${idx.name}: key columns differ.\n      SQL: ${JSON.stringify(idx.keys)}\n      TS : ${JSON.stringify(tsKeys)}`
+        );
+      }
+    }
+    for (const name of tsIdxByName.keys()) {
+      if (!dbIdx.some((i) => i.name === name)) {
+        fail(table, `index ${name} exists in schema.ts but not in SQL`);
+      }
+    }
+
+    // ---- foreign keys ----------------------------------------------------
+    const dbFks = sqlForeignKeys(db, table).sort();
+    const tsFks = cfg.foreignKeys
+      .map((fk) => {
+        const ref = fk.reference();
+        const parent = getTableConfig(ref.foreignTable).name;
+        return (
+          `${ref.columns.map((c) => c.name).join('+')} -> ` +
+          `${parent}(${ref.foreignColumns.map((c) => c.name).join('+')}) ` +
+          `ON DELETE ${(fk.onDelete ?? 'no action').toUpperCase()}`
+        );
+      })
+      .sort();
+    fksChecked += dbFks.length;
+    if (JSON.stringify(dbFks) !== JSON.stringify(tsFks)) {
+      const onlySql = dbFks.filter((f) => !tsFks.includes(f));
+      const onlyTs = tsFks.filter((f) => !dbFks.includes(f));
+      for (const f of onlySql) fail(table, `foreign key only in SQL: ${f}`);
+      for (const f of onlyTs) fail(table, `foreign key only in schema.ts: ${f}`);
+    }
+
+    if (verbose) {
+      console.log(
+        `  ${table.padEnd(26)} ${String(dbCols.length).padStart(2)} cols, ` +
+          `${String(dbIdx.length).padStart(2)} idx, ${dbFks.length} fk`
+      );
+    }
+  }
+
+  // ---- things only the SQL has, listed so they are a decision, not a gap --
+  const triggers = db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'trigger' ORDER BY name`)
+    .all()
+    .map((r) => r.name);
+  notes.push(`${triggers.length} triggers exist only in SQL (Drizzle cannot express them): ${triggers.join(', ')}`);
+  const realTables = dbTables.filter((t) => !isVirtual(t.sql));
+  const notStrict = realTables.filter((t) => !/\)\s*STRICT\s*$/i.test(t.sql.trim()));
+  for (const t of notStrict) fail('tables', `${t.name} is not STRICT`);
+  notes.push(`${realTables.length - notStrict.length}/${realTables.length} ordinary tables are STRICT`);
+
+  return { problems, notes, columnsChecked, indexesChecked, enumsChecked, fksChecked, tables: dbTables.length };
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const argv = process.argv.slice(2);
+  const i = argv.indexOf('--db');
+  const dbPath = resolve(
+    i >= 0 && argv[i + 1] ? argv[i + 1] : join(WORKER_ROOT, '.local', 'necprep.sqlite')
+  );
+  if (!existsSync(dbPath)) {
+    console.error(`no database at ${dbPath}. Run \`npm run db:apply:local\` first.`);
+    process.exit(2);
+  }
+  const db = new DatabaseSync(dbPath);
+  const r = await verify(db, { verbose: argv.includes('--verbose') });
+  db.close();
+
+  console.log(
+    `\nchecked ${r.tables} tables: ${r.columnsChecked} columns, ${r.indexesChecked} indexes, ` +
+      `${r.fksChecked} foreign keys, ${r.enumsChecked} enums`
+  );
+  for (const note of r.notes) console.log(`  note: ${note}`);
+  if (r.problems.length === 0) {
+    console.log('\nschema.ts and migrations/*.sql agree.');
+    process.exit(0);
+  }
+  console.error(`\n${r.problems.length} drift problem(s):`);
+  for (const p of r.problems) console.error(`  - ${p}`);
+  process.exit(1);
+}
diff --git a/worker/migrations/0001_identity.sql b/worker/migrations/0001_identity.sql
new file mode 100644
index 0000000..a832976
--- /dev/null
+++ b/worker/migrations/0001_identity.sql
@@ -0,0 +1,287 @@
+-- 0001_identity.sql
+-- Users, public profiles, cookie sessions, admin audit log.
+--
+-- Conventions used by every migration in this directory:
+--
+--   * Real SQLite, not Postgres with renamed types. No native enums (CHECK
+--     constraints instead), no jsonb (TEXT + json_valid() + the json1
+--     functions), no materialised views (precomputed snapshot tables instead),
+--     no sequences (INTEGER PRIMARY KEY is the rowid alias).
+--   * Every table is STRICT. SQLite's default type affinity would happily
+--     store 'yes' in an INTEGER column; STRICT makes that an error. Verified
+--     on SQLite 3.54 and on Miniflare's D1 (see worker/README.md).
+--   * TIMESTAMPS ARE INTEGER EPOCH MILLISECONDS (UTC). Every column that
+--     carries one says so in a trailing comment, because the unit is the one
+--     property of this schema that cannot be inferred by looking at a value:
+--     1792484350457 and 1792484350 are both plausible integers, and mistaking
+--     one for the other makes a 45-minute deadline expire in 45 milliseconds.
+--     Milliseconds and not seconds because every consumer is JavaScript:
+--     `Date.now()` is milliseconds, the API's wire contract (`EpochMs` in
+--     worker/src/shared/types.ts) is milliseconds, and the client's response
+--     log, quiz drafts and mock `endsAt` are all already milliseconds. One
+--     conversion boundary is one place to get it wrong, so there is none.
+--     The server-side default is
+--     `(CAST(unixepoch('subsec') * 1000 AS INTEGER))`: `unixepoch('subsec')`
+--     returns REAL seconds with millisecond resolution, and the CAST is
+--     explicit so a STRICT INTEGER column can never be handed a REAL whose
+--     conversion is lossy. The cost against seconds is about 3 bytes per
+--     column on SQLite's varint encoding. On the one unbounded table
+--     (attempt_answers, 0004) that is measurable: `answered_at` is both a
+--     column and an index key, so the re-measured row cost went from 132.4 to
+--     ~138 bytes on this change alone. That is the price of not having two
+--     incompatible time units in one system, and it is paid deliberately.
+--     Durations are named for their unit (`time_ms`, `elapsed_ms`,
+--     `duration_s`). Calendar days, where a day is the unit of meaning
+--     (streaks, leaderboard periods), are TEXT 'YYYY-MM-DD'.
+--   * Booleans are INTEGER 0/1 with a CHECK.
+--   * No BEGIN/COMMIT: `wrangler d1 migrations apply` wraps each file itself.
+--   * No PRAGMA: D1 rejects all but a handful. Foreign keys are enforced by
+--     default on D1; the local verification harness turns them on explicitly.
+--   * Surrogate keys are TEXT ULIDs for anything a URL or another service may
+--     name, and INTEGER rowid aliases for high-volume internal rows. See
+--     0004_assessment.sql for why attempt_answers pays this much attention to
+--     8 bytes.
+--   * Every index carries the named query (NQ-nn) it exists to serve. An index
+--     with no named query is a write-amplifier with no reader; worker/README.md
+--     lists the queries and the API handler expected to issue each one.
+
+-- ---------------------------------------------------------------------------
+-- users: the authentication record. Nothing here is safe to return to a
+-- client.
+--
+-- `users` and `user_profiles` are deliberately two tables rather than one with
+-- a careful SELECT list. D1 has no row-level security and no column-level
+-- grants, so "don't leak password_hash" cannot be a database rule; it can only
+-- be a property of the query. Splitting the table makes the leaderboard and
+-- the contributor byline join `user_profiles`, a table that physically does not
+-- contain a credential. The safe query becomes the short one.
+--
+-- ANONYMOUS GUESTS ARE REAL ROWS. `email` is NULLABLE and `is_anonymous`
+-- distinguishes a guest from a claimed account. This is not a convenience: the
+-- product's entire first-run experience is "type a name and start practising",
+-- and a server-scored mock test with a server-authored deadline is only
+-- possible if the sitting belongs to a real `users` row from the first
+-- question. Requiring an email here would force the alternative -- let the
+-- browser own the attempt -- which is precisely the hole worker/src exists to
+-- close. An upgrade (worker/src/handlers/auth.ts) fills in `email` and
+-- `password_hash` and flips the flag IN PLACE, so `id` never changes and every
+-- attempt, bookmark and SRS card written as a guest stays attached.
+--
+-- Three identity shapes share this row:
+--   anonymous guest   is_anonymous = 1, email NULL,  password_hash NULL
+--   email + password  is_anonymous = 0, email set,   password_hash set
+--   OAuth only        is_anonymous = 0, email set,   password_hash NULL
+--
+-- ROLES. Four, and each one exists because something refuses to work without
+-- it: `student` is everyone; `contributor` authors content but cannot publish
+-- it; `moderator` works the errata triage queue (NQ-15) but cannot change what
+-- candidates sit; `admin` publishes and retires questions. Folding moderator
+-- into admin would mean every volunteer who triages a typo report can also
+-- retire a question out of every future paper.
+-- ---------------------------------------------------------------------------
+CREATE TABLE users (
+  id                TEXT    NOT NULL PRIMARY KEY,          -- ULID, 26 chars
+  -- NULL for an anonymous guest. See the note above.
+  email             TEXT,
+  -- Generated + uniquely indexed, so case/whitespace variants of one address
+  -- cannot both register. Doing this in application code is how duplicate
+  -- accounts happen. NULL propagates, so guests do not collide with each other.
+  email_normalized  TEXT    GENERATED ALWAYS AS (lower(trim(email))) STORED,
+  email_verified_at INTEGER,                                      -- epoch ms (UTC)
+  -- NULL for an account that only ever signs in through an OAuth provider, and
+  -- for a guest. A NULL here must fail closed in the password path, never match.
+  password_hash     TEXT,
+  password_algo     TEXT    CHECK (password_algo IS NULL OR password_algo IN ('pbkdf2-sha256', 'scrypt', 'argon2id')),
+  role              TEXT    NOT NULL DEFAULT 'student'
+                            CHECK (role IN ('student', 'contributor', 'moderator', 'admin')),
+  -- 1 = guest. Never serialised as a credential; the API reads it to decide
+  -- which features need a claimed account (`requireRealAccount`).
+  is_anonymous      INTEGER NOT NULL DEFAULT 0 CHECK (is_anonymous IN (0, 1)),
+  status            TEXT    NOT NULL DEFAULT 'active'
+                            CHECK (status IN ('active', 'suspended', 'deleted')),
+  -- Soft delete: the row survives so attempt history and leaderboard snapshots
+  -- keep referential integrity, but every auth path must treat it as absent.
+  deleted_at        INTEGER,                                      -- epoch ms (UTC)
+  created_at        INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at        INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  last_seen_at      INTEGER,                                      -- epoch ms (UTC)
+  CHECK (email IS NULL OR length(email) BETWEEN 3 AND 254),
+  -- A guest has no address, and an account with an address is not a guest. The
+  -- upgrade sets both halves in one UPDATE, so this never blocks it.
+  CHECK (is_anonymous = 0 OR email IS NULL),
+  -- A guest cannot hold a credential either, which is what makes "log in as a
+  -- guest" structurally impossible rather than merely unimplemented.
+  CHECK (is_anonymous = 0 OR password_hash IS NULL),
+  CHECK ((status = 'deleted') = (deleted_at IS NOT NULL)),
+  CHECK (password_hash IS NULL OR password_algo IS NOT NULL)
+) STRICT;
+
+-- NQ-04 login-by-email, NQ-04b registration collision check.
+-- PARTIAL, because every anonymous guest carries a NULL email. SQLite treats
+-- NULLs as distinct in a unique index, so a plain index would also work -- but
+-- the predicate keeps the index to claimed accounts only, which is both smaller
+-- and the thing the upsert in `data/auth.ts#createUser` names as its conflict
+-- target. A bare `ON CONFLICT (email)` against a partial index fails at
+-- prepare() time, so the predicate has to be restated there; see that comment.
+CREATE UNIQUE INDEX uq_users_email_normalized ON users (email_normalized)
+  WHERE email_normalized IS NOT NULL;
+
+-- NQ-38b admin user list filtered by role, and the "who are my contributors"
+-- query behind the contributor dashboard.
+CREATE INDEX idx_users_role_created ON users (role, created_at DESC)
+  WHERE status = 'active';
+
+-- ---------------------------------------------------------------------------
+-- user_profiles: the half of a user that is safe to show another user.
+-- ---------------------------------------------------------------------------
+CREATE TABLE user_profiles (
+  user_id        TEXT    NOT NULL PRIMARY KEY REFERENCES users (id) ON DELETE CASCADE,
+  display_name   TEXT    NOT NULL,
+  handle         TEXT,                                     -- optional public @handle
+  avatar_url     TEXT,
+  bio            TEXT,
+  institution    TEXT,
+  -- Exam the student is sitting, e.g. '2026-chaitra'. Free text on purpose:
+  -- NEC publishes sitting names, not a stable enum.
+  target_sitting TEXT,
+  target_date    TEXT    CHECK (target_date IS NULL OR target_date GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]'),
+  timezone       TEXT    NOT NULL DEFAULT 'Asia/Kathmandu', -- drives streak day boundaries
+  locale         TEXT    NOT NULL DEFAULT 'en',
+  -- 1 = appear on public leaderboards. Default 0: opting a student into a
+  -- public ranking without asking is not a default we get to choose for them.
+  leaderboard_opt_in INTEGER NOT NULL DEFAULT 0 CHECK (leaderboard_opt_in IN (0, 1)),
+  created_at     INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at     INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (length(display_name) BETWEEN 1 AND 60),
+  CHECK (handle IS NULL OR (length(handle) BETWEEN 3 AND 24 AND handle GLOB '[a-z0-9_]*'))
+) STRICT;
+
+-- NQ-04c profile-by-handle (public profile URLs).
+CREATE UNIQUE INDEX uq_user_profiles_handle ON user_profiles (handle)
+  WHERE handle IS NOT NULL;
+
+-- ---------------------------------------------------------------------------
+-- sessions: server-side cookie sessions.
+--
+-- `id` is the SHA-256 hex digest of the cookie value, never the cookie value
+-- itself. A dump of this table therefore does not let anyone sign in. Lookup
+-- is still a primary-key hit because the Worker hashes the cookie before it
+-- queries. Rotation is modelled explicitly: `expires_at` is the idle window
+-- the Worker slides forward, `absolute_expires_at` is the hard ceiling that
+-- sliding cannot pass, so a stolen cookie cannot be renewed indefinitely.
+-- ---------------------------------------------------------------------------
+CREATE TABLE sessions (
+  id                  TEXT    NOT NULL PRIMARY KEY,        -- sha256 hex of the cookie value, 64 chars
+  user_id             TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  created_at          INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  last_used_at        INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  expires_at          INTEGER NOT NULL,                    -- idle expiry, slid forward on use
+  absolute_expires_at INTEGER NOT NULL,                    -- hard ceiling, never slid
+  revoked_at          INTEGER,                                    -- epoch ms (UTC)
+  revoked_reason      TEXT    CHECK (revoked_reason IS NULL OR revoked_reason IN ('logout', 'logout_all', 'password_change', 'admin', 'rotated', 'suspicious')),
+  -- Salted hash, not the address. Enough to spot a session hopping countries;
+  -- not a stored identifier for a person.
+  ip_hash             TEXT,
+  user_agent          TEXT,
+  CHECK (length(id) = 64 AND id GLOB '[0-9a-f]*'),
+  CHECK (expires_at <= absolute_expires_at),
+  CHECK (revoked_at IS NULL OR revoked_reason IS NOT NULL)
+) STRICT;
+
+-- NQ-03 session-revoke-all: UPDATE sessions SET revoked_at = ? WHERE user_id = ?
+--       AND revoked_at IS NULL. Also serves "list my devices".
+CREATE INDEX idx_sessions_user_active ON sessions (user_id, last_used_at DESC)
+  WHERE revoked_at IS NULL;
+
+-- NQ-02 session-sweep: DELETE FROM sessions WHERE absolute_expires_at < ?
+--       LIMIT ? -- cron, batched to stay inside the free-tier write budget.
+CREATE INDEX idx_sessions_absolute_expires_at ON sessions (absolute_expires_at);
+
+-- ---------------------------------------------------------------------------
+-- admin_audit_log: every privileged action, append-only.
+--
+-- Separate from content_versions (0002) on purpose. content_versions answers
+-- "what did this question look like last Tuesday"; this answers "who did
+-- something they needed a role for". The two have different retention and
+-- different readers.
+-- ---------------------------------------------------------------------------
+CREATE TABLE admin_audit_log (
+  id             INTEGER NOT NULL PRIMARY KEY,             -- rowid alias
+  actor_user_id  TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  actor_role     TEXT    NOT NULL CHECK (actor_role IN ('student', 'contributor', 'moderator', 'admin', 'system')),
+  action         TEXT    NOT NULL,                         -- 'question.publish', 'user.suspend', ...
+  entity_type    TEXT    NOT NULL,
+  entity_id      TEXT,
+  -- Redacted JSON snapshots. Never a password hash, never a session id.
+  before_json    TEXT    CHECK (before_json IS NULL OR json_valid(before_json)),
+  after_json     TEXT    CHECK (after_json  IS NULL OR json_valid(after_json)),
+  reason         TEXT,
+  ip_hash        TEXT,
+  user_agent     TEXT,
+  created_at     INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)) -- epoch ms (UTC)
+) STRICT;
+
+-- NQ-37a audit-by-actor: SELECT ... WHERE actor_user_id = ? ORDER BY id DESC.
+CREATE INDEX idx_admin_audit_log_actor ON admin_audit_log (actor_user_id, id DESC);
+
+-- NQ-37b audit-by-entity: SELECT ... WHERE entity_type = ? AND entity_id = ?
+--       ORDER BY id DESC -- "who touched this question".
+CREATE INDEX idx_admin_audit_log_entity ON admin_audit_log (entity_type, entity_id, id DESC);
+
+-- NQ-37c audit-recent: SELECT ... WHERE created_at >= ? ORDER BY created_at DESC.
+CREATE INDEX idx_admin_audit_log_created_at ON admin_audit_log (created_at DESC);
+
+-- ---------------------------------------------------------------------------
+-- oauth_accounts: the link between a `users` row and a provider identity.
+--
+-- A separate table rather than two columns on `users`, because one account may
+-- legitimately carry several providers and because the provider's subject id is
+-- the only stable identifier it gives us -- an email address can be reassigned
+-- by the provider, so resolving a sign-in by email alone is an account-takeover
+-- path. `(provider, provider_account_id)` is therefore UNIQUE and is the first
+-- thing the callback looks up.
+-- ---------------------------------------------------------------------------
+CREATE TABLE oauth_accounts (
+  id                  TEXT    NOT NULL PRIMARY KEY,         -- 'oac_...'
+  user_id             TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  provider            TEXT    NOT NULL CHECK (provider IN ('google')),
+  -- The provider's immutable subject id ('sub' for Google). NOT the email.
+  provider_account_id TEXT    NOT NULL,
+  created_at          INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (length(trim(provider_account_id)) > 0)
+) STRICT;
+
+-- NQ-41 oauth-identity: SELECT u.* FROM oauth_accounts oa JOIN users u
+--       ON u.id = oa.user_id WHERE oa.provider = ?1 AND oa.provider_account_id = ?2.
+-- Unique, so a repeat sign-in links once and a second row is a write error
+-- rather than two accounts for one Google identity.
+CREATE UNIQUE INDEX uq_oauth_accounts_provider_account
+  ON oauth_accounts (provider, provider_account_id);
+
+-- NQ-41b oauth-accounts-for-user: "which providers is this account linked to",
+--        and the index that makes deleting a departing user's links cheap.
+CREATE INDEX idx_oauth_accounts_user ON oauth_accounts (user_id, provider);
+
+-- ---------------------------------------------------------------------------
+-- oauth_states: the CSRF/PKCE parking space for one in-flight round trip.
+--
+-- Short-lived (10 minutes) and SINGLE USE: the callback consumes the row with
+-- `DELETE ... RETURNING`, so a replayed `?code=` finds nothing and is rejected.
+-- The code verifier lives here and never reaches the browser, which is what
+-- makes PKCE worth doing even for a confidential client with a secret.
+-- ---------------------------------------------------------------------------
+CREATE TABLE oauth_states (
+  state         TEXT    NOT NULL PRIMARY KEY,               -- 'oas_...', 130 bits
+  code_verifier TEXT    NOT NULL,
+  -- A PATH on our own origin, or NULL. Never an absolute URL: the state must
+  -- not be usable to bounce a freshly signed-in user to someone else's site.
+  redirect_to   TEXT    CHECK (redirect_to IS NULL OR redirect_to GLOB '/*'),
+  created_at    INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  expires_at    INTEGER NOT NULL,                                 -- epoch ms (UTC)
+  CHECK (expires_at > created_at),
+  CHECK (length(code_verifier) BETWEEN 43 AND 128)          -- RFC 7636 section 4.1
+) STRICT;
+
+-- NQ-42 oauth-state-sweep (cron): DELETE FROM oauth_states WHERE expires_at < ?1
+--       LIMIT ?2. The consume path is a primary-key hit and needs no index.
+CREATE INDEX idx_oauth_states_expires_at ON oauth_states (expires_at);
diff --git a/worker/migrations/0002_content.sql b/worker/migrations/0002_content.sql
new file mode 100644
index 0000000..61bd302
--- /dev/null
+++ b/worker/migrations/0002_content.sql
@@ -0,0 +1,779 @@
+-- 0002_content.sql
+-- The question bank: syllabus tree, questions, options, the answer key,
+-- explanations, tags, errata reports, and the content audit trail.
+--
+-- ===========================================================================
+-- TWO DESIGN DECISIONS THAT THE REST OF THE PLATFORM DEPENDS ON
+-- ===========================================================================
+--
+-- (1) QUESTION IDENTITY IS CONTENT, NOT POSITION.
+--
+-- The app being replaced identifies a question as `{topicId}_{arrayIndex}` --
+-- 'book-ch1_238' is "the 239th element of ch1.json". That id is a pointer into
+-- an array, so any edit that changes array length silently re-points every
+-- stored reference to it. This is not hypothetical. While this schema was
+-- being written, a de-duplication pass shrank the bank from 2,801 rows to
+-- 2,312, and the 23-entry quarantine list in
+-- frontend/src/data/quarantine.json immediately went wrong in both directions:
+-- 20 of its 23 ids now name a perfectly healthy question (so a good question
+-- is hidden), and 18 genuinely mis-graded questions are no longer excluded (so
+-- a student is marked wrong for being right). Every bookmark, progress record
+-- and saved mock draft in every user's localStorage has the same defect.
+--
+-- So `questions.id` is derived from the question's content:
+--
+--     content_hash = sha256(
+--         'necprep-question-v1' || RS ||
+--         chapter_code          || RS ||
+--         norm(stem)            || RS ||
+--         norm(option_1) || US || ... || norm(option_n)   -- sorted, so option
+--     )                                                  -- reordering is a
+--     id = 'q_' || substr(content_hash, 1, 16)            -- no-op
+--
+--   RS = U+001E, US = U+001F (cannot occur in the source JSON).
+--   norm(s) = NFKC, collapse whitespace runs to one space, trim, lowercase.
+--
+-- Properties this buys:
+--   * Inserting, deleting or reordering questions changes nothing about the
+--     surviving ones. Stored references stay valid.
+--   * Re-running the importer is idempotent: the same source row produces the
+--     same id, so it is an upsert, not a duplicate.
+--   * Exact duplicates inside one chapter collapse to one row by construction.
+--   * `chapter_code` is inside the hash, so a question that legitimately
+--     appears in two chapters stays two rows and each chapter keeps its own
+--     practice attribution. (Measured on the current bank: 24 exact-text
+--     duplicate groups ignoring chapter, 22 of them inside a single chapter.)
+--   * Editing a question's stem changes its hash, i.e. its identity. That is
+--     correct and deliberate: a changed stem is a different question, and
+--     answer history for the old wording should not be credited to the new
+--     one. `superseded_by` records the lineage so the editor can show it.
+--
+-- `content_hash` keeps the full 64-hex digest under a UNIQUE constraint while
+-- `id` uses the 16-hex prefix. A 64-bit prefix collision between two different
+-- questions would therefore fail the primary-key insert and stop the importer
+-- rather than silently merge two questions.
+--
+-- `legacy_id` holds the old `{topicId}_{arrayIndex}` string. It exists so the
+-- one-time localStorage migration can translate a user's saved bookmarks and
+-- progress, and so the quarantine list can be cross-checked. It is nullable,
+-- it is never used for delivery, and it is expected to be dropped once the
+-- migration window closes.
+--
+--
+-- (2) THE ANSWER KEY LIVES IN ITS OWN TABLE.
+--
+-- D1 has no row-level security -- SQLite has none to expose -- so there is no
+-- database rule that can stop a query returning the answer. The protection has
+-- to be structural: the answer cannot be in a column that the delivery query
+-- selects, because the delivery query selects every column of the tables it
+-- touches sooner or later.
+--
+--   * `questions`        -- no correct-answer column of any kind.
+--   * `question_options` -- no `is_correct` column.
+--   * `question_answer_keys` -- one row per question, holding
+--     `correct_option_id`. This is the ONLY place the key exists.
+--
+-- So `SELECT * FROM questions JOIN question_options ...`, the shape every
+-- delivery handler actually writes, cannot leak the key even if it is written
+-- carelessly, even if a `SELECT *` sneaks past review, even if a future
+-- endpoint forgets. Leaking requires naming `question_answer_keys` in a FROM
+-- clause, which is a grep-able, review-able, test-able event. `v_question_delivery`
+-- below is the view the delivery path reads from, so the safe query is also
+-- the shortest one to write.
+--
+-- Per-attempt option permutation (0004_assessment.sql) closes the second half
+-- of the hole: the public JSON bank is in git history forever, so anyone can
+-- reconstruct "the answer to this question is option 2". Delivering options in
+-- a per-attempt permuted order, and recording answers by stable option id
+-- rather than by screen position, means a captured paper cannot be joined
+-- against that JSON by position.
+-- ===========================================================================
+
+-- ---------------------------------------------------------------------------
+-- subjects: an exam. One row today (NEC Computer Engineering registration).
+-- Modelled because NEC runs the same platform shape for Civil, Electrical and
+-- the rest, and a second subject must not need a migration.
+-- ---------------------------------------------------------------------------
+CREATE TABLE subjects (
+  id          TEXT    NOT NULL PRIMARY KEY,                -- 'nec-computer'
+  code        TEXT    NOT NULL,                            -- 'NEC-CE'
+  name        TEXT    NOT NULL,
+  description TEXT,
+  exam_board  TEXT    NOT NULL DEFAULT 'Nepal Engineering Council',
+  ordinal     INTEGER NOT NULL DEFAULT 1,
+  status      TEXT    NOT NULL DEFAULT 'published'
+                      CHECK (status IN ('draft', 'published', 'retired')),
+  created_at  INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at  INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)) -- epoch ms (UTC)
+) STRICT;
+
+CREATE UNIQUE INDEX uq_subjects_code ON subjects (code);   -- NQ-05a subject-by-code
+
+-- ---------------------------------------------------------------------------
+-- chapters: the 10 official NEC papers (AExE01 .. AALL10).
+--
+-- `id` keeps the existing frontend identifiers ('book-ch1' .. 'book-ch10') so
+-- the client's routes, saved drafts and progress keys survive the cutover
+-- without a translation table. `nec_code` is the official code; `title` is the
+-- official syllabus title; `display_name` is the shorter string the practice
+-- cards already show. Both are kept because they genuinely differ and the UI
+-- uses each in a different place.
+-- ---------------------------------------------------------------------------
+CREATE TABLE chapters (
+  id               TEXT    NOT NULL PRIMARY KEY,           -- 'book-ch1'
+  subject_id       TEXT    NOT NULL REFERENCES subjects (id) ON DELETE RESTRICT,
+  nec_code         TEXT    NOT NULL,                       -- 'AExE01'
+  ordinal          INTEGER NOT NULL,                       -- 1..10
+  slug             TEXT    NOT NULL,                       -- 'basic-electrical-and-electronics'
+  title            TEXT    NOT NULL,                       -- official NEC title
+  display_name     TEXT    NOT NULL,                       -- practice-card title
+  short_name       TEXT    NOT NULL,
+  description      TEXT,
+  color            TEXT    NOT NULL DEFAULT '#6366f1' CHECK (color GLOB '#[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'),
+  icon             TEXT    NOT NULL DEFAULT 'book',
+  -- Which file the importer read this chapter from. Audit only.
+  legacy_data_file TEXT,
+  status           TEXT    NOT NULL DEFAULT 'published'
+                           CHECK (status IN ('draft', 'published', 'retired')),
+  created_at       INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at       INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (ordinal > 0)
+) STRICT;
+
+-- NQ-05 chapter-list: SELECT ... FROM chapters WHERE subject_id = ?
+--       AND status = 'published' ORDER BY ordinal. One index scan, no sort.
+CREATE INDEX idx_chapters_subject_ordinal ON chapters (subject_id, ordinal);
+
+CREATE UNIQUE INDEX uq_chapters_nec_code ON chapters (nec_code);   -- NQ-05b chapter-by-nec-code
+CREATE UNIQUE INDEX uq_chapters_slug ON chapters (subject_id, slug); -- NQ-05c chapter-by-slug (routing)
+
+-- ---------------------------------------------------------------------------
+-- subchapters: the 60 official NEC syllabus codes, 1.1 .. 10.6.
+--
+-- Six per chapter, exactly as published. These are the unit the syllabus is
+-- written in, so they are the unit a student wants to practise and the unit a
+-- mock-test blueprint should be able to name. Questions carry a nullable
+-- subchapter_id: the imported bank has no subchapter metadata (the source JSON
+-- has no such field), so the import leaves it NULL and classification is a
+-- separate contributor workflow. Nullable-and-honest beats guessed-and-wrong.
+-- ---------------------------------------------------------------------------
+CREATE TABLE subchapters (
+  id          TEXT    NOT NULL PRIMARY KEY,                -- 'nec-1.1'
+  chapter_id  TEXT    NOT NULL REFERENCES chapters (id) ON DELETE CASCADE,
+  code        TEXT    NOT NULL,                            -- '1.1'
+  ordinal     INTEGER NOT NULL,                            -- 1..6
+  title       TEXT    NOT NULL,
+  description TEXT,                                        -- the syllabus paragraph verbatim
+  status      TEXT    NOT NULL DEFAULT 'published'
+                      CHECK (status IN ('draft', 'published', 'retired')),
+  created_at  INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at  INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (ordinal > 0),
+  CHECK (code GLOB '[0-9]*.[0-9]*')
+) STRICT;
+
+-- NQ-06 subchapter-list: SELECT ... FROM subchapters WHERE chapter_id = ?
+--       ORDER BY ordinal -- the syllabus accordion on the practice page.
+CREATE INDEX idx_subchapters_chapter_ordinal ON subchapters (chapter_id, ordinal);
+
+CREATE UNIQUE INDEX uq_subchapters_code ON subchapters (code);  -- NQ-06b subchapter-by-code
+
+-- ---------------------------------------------------------------------------
+-- questions: the stem and its metadata. NO ANSWER COLUMN. See header note (2).
+-- ---------------------------------------------------------------------------
+CREATE TABLE questions (
+  id              TEXT    NOT NULL PRIMARY KEY,            -- 'q_' || substr(content_hash,1,16)
+  content_hash    TEXT    NOT NULL,                        -- full sha256 hex, 64 chars
+  subject_id      TEXT    NOT NULL REFERENCES subjects (id) ON DELETE RESTRICT,
+  chapter_id      TEXT    NOT NULL REFERENCES chapters (id) ON DELETE RESTRICT,
+  -- NULL until a contributor classifies it. The importer never guesses.
+  subchapter_id   TEXT    REFERENCES subchapters (id) ON DELETE SET NULL,
+  stem            TEXT    NOT NULL,
+  stem_format     TEXT    NOT NULL DEFAULT 'plain'
+                          CHECK (stem_format IN ('plain', 'markdown', 'latex')),
+
+  -- Lifecycle. The reason the 23 mis-grading questions are excluded rather
+  -- than deleted: a quarantined question is evidence of an authoring defect
+  -- and the raw row is what an adjudicator needs to fix it.
+  --   draft     -- authored or imported, not yet releasable
+  --   published -- the ONLY status the delivery path may select
+  --   flagged   -- known or suspected defect, withheld pending adjudication
+  --   retired   -- deliberately removed from circulation, history preserved
+  status          TEXT    NOT NULL DEFAULT 'draft'
+                          CHECK (status IN ('draft', 'published', 'flagged', 'retired')),
+  -- Machine-readable reason a question is not published. Mirrors the validator
+  -- codes in scripts/validate-questions.mjs so the importer and the human
+  -- reviewer speak the same vocabulary.
+  status_reason   TEXT    CHECK (status_reason IS NULL OR status_reason IN (
+                            'KEY_CONFLICT',      -- correct_option text and index disagree
+                            'INDEX_RANGE',       -- correct_option_index past the last option
+                            'OPTION_DUPLICATE',  -- two options carry identical text
+                            -- More than one option is a true answer to the
+                            -- stem. Not derivable by rule -- deciding it needs
+                            -- subject knowledge -- so it arrives from a human
+                            -- adjudication recorded in quarantine.json.
+                            'OPTION_MULTIPLE_TRUE',
+                            'OPTION_COUNT',      -- fewer than two usable options
+                            'EMPTY_STEM',
+                            -- Two questions share a stem but disagree on the
+                            -- answer. Cross-row, so it cannot be a CHECK: the
+                            -- importer derives it and the editor resolves it.
+                            'DUPLICATE_ANSWER_CONFLICT',
+                            'USER_REPORT',       -- a question_reports row was accepted
+                            'DUPLICATE',         -- superseded by another question
+                            'OUT_OF_SYLLABUS',
+                            'EDITORIAL'
+                          )),
+  status_changed_at INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+
+  difficulty      TEXT    CHECK (difficulty IS NULL OR difficulty IN ('easy', 'medium', 'hard')),
+  -- Observed difficulty in basis points (0..10000) of correct answers, filled
+  -- by the nightly job from user_question_stats. Separate from `difficulty`,
+  -- which is an editorial judgement.
+  p_value_bp      INTEGER CHECK (p_value_bp IS NULL OR p_value_bp BETWEEN 0 AND 10000),
+  p_value_n       INTEGER NOT NULL DEFAULT 0,
+
+  -- Positional-meaning guard. 'All of the above' and friends are nonsense
+  -- anywhere but last; all 450 such options in the current bank sit in slot 4
+  -- (measured after import). The delivery permuter must pin options flagged
+  -- here. Computed by the importer, overridable by an editor.
+  has_pinned_options INTEGER NOT NULL DEFAULT 0 CHECK (has_pinned_options IN (0, 1)),
+
+  source          TEXT    NOT NULL DEFAULT 'book-import'
+                          CHECK (source IN ('book-import', 'contributor', 'past-paper', 'generated')),
+  source_ref      TEXT,                                    -- e.g. 'books/ch1.json#238'
+  -- Old `{topicId}_{arrayIndex}` id. Import + one-time client migration only.
+  -- Never read by the delivery path. Expected to be dropped after cutover.
+  legacy_id       TEXT,
+  -- Set when this question is replaced by an edited version, so the editor can
+  -- show lineage and the SRS can retire the old card.
+  superseded_by   TEXT    REFERENCES questions (id) ON DELETE SET NULL,
+  created_by      TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  created_at      INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at      INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (length(content_hash) = 64 AND content_hash GLOB '[0-9a-f]*'),
+  CHECK (id = 'q_' || substr(content_hash, 1, 16)),
+  CHECK (length(trim(stem)) > 0),
+  -- A withheld question must say why it is withheld, or nobody can ever clear it.
+  CHECK (status <> 'flagged' OR status_reason IS NOT NULL),
+  CHECK (superseded_by IS NULL OR superseded_by <> id)
+) STRICT;
+
+-- NQ-40 import-dedupe: SELECT id FROM questions WHERE content_hash = ?.
+-- Also the structural guarantee that two different questions cannot share the
+-- 16-hex id prefix without the importer failing loudly.
+CREATE UNIQUE INDEX uq_questions_content_hash ON questions (content_hash);
+
+-- NQ-39 legacy-lookup: SELECT id FROM questions WHERE legacy_id = ? -- the
+-- one-time localStorage bookmark/progress migration endpoint. Partial, because
+-- contributor-authored questions have no legacy id and should not pay for it.
+CREATE UNIQUE INDEX uq_questions_legacy_id ON questions (legacy_id)
+  WHERE legacy_id IS NOT NULL;
+
+-- NQ-07 practice-draw, the hottest query on the platform:
+--   SELECT id FROM questions
+--    WHERE chapter_id = ?1 AND status = 'published'
+--    ORDER BY ... LIMIT ?2
+-- Partial on status so the index holds only deliverable rows: it is both
+-- smaller and impossible to use for an unpublished question. `id` is trailing
+-- so the index is covering -- the draw never touches the table.
+CREATE INDEX idx_questions_published_chapter
+  ON questions (chapter_id, id) WHERE status = 'published';
+
+-- NQ-08 practice-draw-subchapter: same query narrowed to one syllabus code.
+CREATE INDEX idx_questions_published_subchapter
+  ON questions (subchapter_id, id)
+  WHERE status = 'published' AND subchapter_id IS NOT NULL;
+
+-- NQ-38 moderation-queue: SELECT ... FROM questions
+--        WHERE status IN ('draft','flagged') ORDER BY status_changed_at
+--        -- the contributor/admin review list.
+CREATE INDEX idx_questions_moderation
+  ON questions (status, status_changed_at) WHERE status IN ('draft', 'flagged');
+
+-- NQ-38b unclassified-queue: SELECT ... FROM questions
+--        WHERE subchapter_id IS NULL AND chapter_id = ? -- the "assign a
+--        syllabus code" workflow, which starts with all 2,290 imported rows.
+CREATE INDEX idx_questions_unclassified
+  ON questions (chapter_id, id) WHERE subchapter_id IS NULL;
+
+-- ---------------------------------------------------------------------------
+-- question_options: one row per option. Its own table, not a JSON array on
+-- `questions`, for three reasons that all showed up in the existing data:
+--
+--   * An answer and an errata report must reference a stable option id. A JSON
+--     array can only be referenced by index, which is the same positional bug
+--     as `{topicId}_{arrayIndex}` one level down.
+--   * Editing one option must not rewrite the others. A JSON blob is a single
+--     value: fixing a typo in option 3 rewrites option 1, 2 and 4 too, so the
+--     audit trail cannot tell which option actually changed and two editors
+--     cannot touch one question without clobbering each other.
+--   * 5 questions in the current bank have two options with identical text.
+--     A UNIQUE index catches that at write time; a JSON array cannot.
+--
+-- ===========================================================================
+-- OPTION IDENTITY, AND WHY THE ID DOES NOT CARRY THE AUTHORED SLOT
+-- ===========================================================================
+--
+-- Option identity is `question_id || '#' || opt_key`, enforced by a CHECK so a
+-- malformed id cannot be inserted. `opt_key` is 12 CSPRNG base32 characters,
+-- minted once per option row and never changed.
+--
+-- IT USED TO BE `question_id || '#' || ordinal`, AND THAT WAS A REAL SECURITY
+-- HOLE. The 2,290-question bank shipped as public JSON under
+-- `frontend/public/data/books/` and is in git history permanently; each row
+-- there publishes `correct_option_index`. With the ordinal readable straight
+-- off the id, any option id that reached a client -- in a payload, a log, an
+-- error message -- joined against that published index and recovered the
+-- entire answer key with no database access at all. Per-attempt option
+-- permutation is no defence against it, because the ordinal travels INSIDE the
+-- id rather than as a position in the delivered array. Two independent reviews
+-- of this backend found the same hole, which is a good sign it was not subtle.
+--
+-- A random discriminator closes it at the root: there is nothing in
+-- `q_ab12cd34#7K3MQW9XZ2VB` to join against. The API still never delivers raw
+-- option ids -- `lib/permute.ts#browseOptionRef` and the per-attempt refs in
+-- `handlers/paper.ts` stay exactly as they are -- but those are now defence in
+-- depth over a sound id scheme rather than the only thing standing between the
+-- published JSON and the key.
+--
+-- WHAT THIS DOES NOT FIX, STATED PLAINLY. For the 2,290 questions already
+-- published as JSON the key is IRRECOVERABLY PUBLIC: anyone who can read a
+-- stem can look the answer up by its text, and no id scheme, permutation or
+-- server-side measure changes that. What is fixed: no question authored from
+-- now on has an exposed key, and a delivered paper cannot be graded by
+-- position alone.
+--
+-- `ordinal` SURVIVES, as the authored slot and as the editorial identity:
+-- assigned once and NEVER REUSED, so retiring option 3 and adding a
+-- replacement gives the new one ordinal 5 and a historical answer that
+-- selected option 3 can never be silently re-pointed at different text. It is
+-- server-only -- it is in no view, no delivery query and no response body --
+-- and `question_answer_keys.authored_index` is the only place the source
+-- JSON's index is kept, which is the server-only table by construction.
+--
+-- Two UNIQUE indexes, because two different things reference an option:
+--   (question_id, ordinal)  the authored-slot invariant, and the importer's
+--                           upsert target -- a re-import must find the EXISTING
+--                           row by its slot and keep its `opt_key`, or every
+--                           re-run would mint new ids and orphan every answer.
+--   (question_id, opt_key)  the parent side of attempt_answers' composite
+--                           foreign key.
+--
+-- Display order is NOT this table's job. What a student sees is
+-- `attempt_questions.option_order` (0004), permuted per attempt.
+-- ---------------------------------------------------------------------------
+CREATE TABLE question_options (
+  id          TEXT    NOT NULL PRIMARY KEY,                -- 'q_abc123#7K3MQW9XZ2VB'
+  question_id TEXT    NOT NULL REFERENCES questions (id) ON DELETE CASCADE,
+  -- The authored slot, 1-based (literally the N in the source JSON's `optN`).
+  -- SERVER-ONLY: never delivered, never in a view, never in a response.
+  ordinal     INTEGER NOT NULL CHECK (ordinal BETWEEN 1 AND 26),
+  -- The id discriminator. 12 CSPRNG base32 characters (60 bits), carrying no
+  -- information about the option at all -- in particular not its position.
+  -- Fixed-length and charset-restricted so a bare ordinal ('3') cannot be
+  -- smuggled in here and quietly restore the leak.
+  opt_key     TEXT    NOT NULL,
+  text        TEXT    NOT NULL,
+  text_format TEXT    NOT NULL DEFAULT 'plain'
+                      CHECK (text_format IN ('plain', 'markdown', 'latex')),
+  -- Normalised text, generated. Backs the uniqueness check that catches the
+  -- OPTION_DUPLICATE defect at write time instead of at grading time.
+  text_norm   TEXT    GENERATED ALWAYS AS (lower(trim(text))) STORED,
+  -- 1 for options whose meaning depends on being last ('All of the above',
+  -- 'None of these', 'Both of the above'). The permuter must not move these.
+  is_pinned   INTEGER NOT NULL DEFAULT 0 CHECK (is_pinned IN (0, 1)),
+  -- Set instead of deleting, so no ordinal is ever freed for reuse.
+  retired_at  INTEGER,                                            -- epoch ms (UTC)
+  created_at  INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at  INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (length(opt_key) = 12 AND opt_key GLOB '[0-9A-Z]*'),
+  CHECK (id = question_id || '#' || opt_key),
+  CHECK (length(trim(text)) > 0)
+) STRICT;
+
+-- NQ-09 deliver-options: SELECT id, ordinal, text, is_pinned
+--       FROM question_options WHERE question_id IN (...) AND retired_at IS NULL
+--       ORDER BY question_id, ordinal.
+-- Also the authored-slot invariant and the importer's upsert conflict target.
+CREATE UNIQUE INDEX uq_question_options_question_ordinal
+  ON question_options (question_id, ordinal);
+
+-- The parent side of attempt_answers' composite foreign key (0004), which
+-- requires a UNIQUE index on exactly these columns. It is also what proves the
+-- `opt_key` space is collision-free within a question, so `id` and
+-- `(question_id, opt_key)` are two spellings of the same identity.
+CREATE UNIQUE INDEX uq_question_options_question_opt_key
+  ON question_options (question_id, opt_key);
+
+-- Catches OPTION_DUPLICATE at write time. Retired options are excluded so a
+-- corrected option may reuse the text of the one it replaced.
+CREATE UNIQUE INDEX uq_question_options_question_text
+  ON question_options (question_id, text_norm) WHERE retired_at IS NULL;
+
+-- ---------------------------------------------------------------------------
+-- question_answer_keys  *** SERVER-ONLY. NEVER NAME THIS TABLE IN A HANDLER
+-- ***                   *** THAT RESPONDS BEFORE AN ATTEMPT IS SUBMITTED. ***
+--
+-- The single source of truth for which option is correct. One row per
+-- question, so the key is a 1:1 fact about the question rather than a property
+-- smuggled inside the option rows.
+--
+-- The three queries allowed to read this table, and nothing else:
+--
+--   NQ-10 grade-one (answer submitted during an attempt; the response carries
+--         only a boolean, never the key):
+--           SELECT correct_option_id
+--             FROM question_answer_keys
+--            WHERE question_id = ?1;
+--
+--   NQ-10b grade-batch (attempt submit; one statement for the whole paper,
+--          because D1 allows 50 queries per Worker invocation and a 100-question
+--          mock graded one question at a time would need 100):
+--           SELECT question_id, correct_option_id
+--             FROM question_answer_keys
+--            WHERE question_id IN (SELECT value FROM json_each(?1));
+--
+--   NQ-10c review-after-submit (the only client-visible path, and only for an
+--          attempt that belongs to the caller and is already submitted):
+--           SELECT aa.question_id, aa.selected_option_id, k.correct_option_id
+--             FROM attempt_answers aa
+--             JOIN question_answer_keys k ON k.question_id = aa.question_id
+--            WHERE aa.attempt_id = ?1
+--              AND EXISTS (SELECT 1 FROM attempts a
+--                           WHERE a.id = ?1 AND a.user_id = ?2
+--                             AND a.status = 'submitted');
+--
+-- The EXISTS clause is the authorisation. On a database with row-level
+-- security that predicate would live in a policy; here it must be in the
+-- query, every time, which is why it is written out above rather than left to
+-- each handler to remember. worker/README.md carries the same text, and the
+-- API's test suite should assert that no response body on a pre-submit route
+-- ever contains an option id that is not in the delivered paper.
+--
+-- `authored_index` keeps the source JSON's 1-based `correct_option_index` so
+-- an import can be re-verified against the file it came from without
+-- re-deriving the mapping.
+-- ---------------------------------------------------------------------------
+CREATE TABLE question_answer_keys (
+  question_id       TEXT    NOT NULL PRIMARY KEY REFERENCES questions (id) ON DELETE CASCADE,
+  correct_option_id TEXT    NOT NULL REFERENCES question_options (id) ON DELETE CASCADE,
+  -- 'import'       -- derived from the source JSON's correct_option_index
+  -- 'adjudication' -- a human resolved a reported defect
+  -- 'editor'       -- authored directly in the contributor tool
+  source            TEXT    NOT NULL DEFAULT 'import'
+                            CHECK (source IN ('import', 'editor', 'adjudication')),
+  authored_index    INTEGER,                               -- source 1-based index, audit only
+  authored_text     TEXT,                                  -- source `correct_option` string, audit only
+  verified_by       TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  verified_at       INTEGER,                                      -- epoch ms (UTC)
+  created_at        INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at        INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  -- Structural proof that a key cannot point at another question's option.
+  -- Option ids are `question_id || '#' || opt_key`, so same-question-ness is
+  -- checkable with a prefix test and needs no composite foreign key. Without
+  -- it, one bad UPDATE could make question A's key an option of question B and
+  -- every grade for A would be silently wrong, with no error raised anywhere.
+  CHECK (substr(correct_option_id, 1, length(question_id) + 1) = question_id || '#'),
+  CHECK (verified_at IS NULL OR verified_by IS NOT NULL)
+) STRICT;
+
+-- ---------------------------------------------------------------------------
+-- v_question_delivery: the shape the delivery path reads.
+--
+-- A view in SQLite is a macro, not a security boundary -- it grants nothing and
+-- revokes nothing. Its value is that it is the shortest correct thing to
+-- write, so the handler that reaches for the convenient option is reaching for
+-- the safe one. It cannot reference question_answer_keys, so a `SELECT *` over
+-- it is safe by construction.
+-- ---------------------------------------------------------------------------
+CREATE VIEW v_question_delivery AS
+SELECT
+  q.id            AS question_id,
+  q.chapter_id    AS chapter_id,
+  q.subchapter_id AS subchapter_id,
+  q.stem          AS stem,
+  q.stem_format   AS stem_format,
+  q.difficulty    AS difficulty,
+  o.id            AS option_id,
+  o.ordinal       AS option_ordinal,
+  o.text          AS option_text,
+  o.text_format   AS option_text_format,
+  o.is_pinned     AS option_is_pinned
+FROM questions q
+JOIN question_options o ON o.question_id = q.id AND o.retired_at IS NULL
+WHERE q.status = 'published';
+
+-- ---------------------------------------------------------------------------
+-- explanations: why the answer is the answer. Separate from `questions`
+-- because an explanation is long, is edited on a different cadence, has its
+-- own author and review state, and must never be shipped with the question
+-- before the student has answered.
+-- ---------------------------------------------------------------------------
+CREATE TABLE explanations (
+  id             INTEGER NOT NULL PRIMARY KEY,
+  question_id    TEXT    NOT NULL REFERENCES questions (id) ON DELETE CASCADE,
+  body           TEXT    NOT NULL,
+  body_format    TEXT    NOT NULL DEFAULT 'markdown'
+                         CHECK (body_format IN ('plain', 'markdown', 'latex')),
+  -- Optional pointer at the option this paragraph explains, so a distractor
+  -- rationale ("why option 2 is tempting but wrong") can be attached.
+  about_option_id TEXT    REFERENCES question_options (id) ON DELETE SET NULL,
+  kind           TEXT    NOT NULL DEFAULT 'solution'
+                         CHECK (kind IN ('solution', 'distractor', 'hint', 'reference')),
+  is_primary     INTEGER NOT NULL DEFAULT 0 CHECK (is_primary IN (0, 1)),
+  status         TEXT    NOT NULL DEFAULT 'draft'
+                         CHECK (status IN ('draft', 'published', 'rejected')),
+  -- WHO WROTE IT, which is a different question from whether it is published.
+  --
+  -- `status` is the delivery gate; `origin` is the provenance, and the UI keys
+  -- its "AI draft, unreviewed" badge off this column. The two are independent
+  -- on purpose: a published ai_draft is shown to students *with* the badge,
+  -- because an explanation that merely says "the correct answer is B" teaches
+  -- nothing and a flagged draft is better than that. What is not acceptable is
+  -- showing an unreviewed draft without saying so, or showing one mid-exam
+  -- where a wrong explanation is worse than none at all -- see the delivery
+  -- rule below the table.
+  --
+  --   ai_draft    generated, passed automated validation, no human has read it
+  --   ai_reviewed generated, then read and accepted by a human
+  --   human       written or substantially rewritten by a human
+  origin         TEXT    NOT NULL DEFAULT 'human'
+                         CHECK (origin IN ('ai_draft', 'ai_reviewed', 'human')),
+  -- Generator provenance. Required for an AI origin and forbidden otherwise, so
+  -- a draft can never lose the record of what produced it, and a human-written
+  -- explanation can never carry a misleading model attribution. Needed to
+  -- re-generate or invalidate a cohort when a prompt or model turns out bad.
+  generator_model          TEXT,
+  generator_prompt_version TEXT,
+  generated_at             INTEGER,                               -- epoch ms (UTC)
+  -- Model-reported confidence, 0..10000 basis points. Advisory only: it informs
+  -- review order, and nothing gates delivery on it, because a model's own
+  -- confidence is not evidence about a licensing exam answer.
+  generator_confidence_bp  INTEGER CHECK (generator_confidence_bp IS NULL
+                                          OR generator_confidence_bp BETWEEN 0 AND 10000),
+  author_user_id TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  reviewed_by    TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  reviewed_at    INTEGER,                                         -- epoch ms (UTC)
+  created_at     INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at     INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (about_option_id IS NULL
+         OR substr(about_option_id, 1, length(question_id) + 1) = question_id || '#'),
+  CHECK (length(trim(body)) > 0),
+  CHECK (kind <> 'distractor' OR about_option_id IS NOT NULL),
+  -- An AI origin must carry its generator record; a human one must not.
+  CHECK (
+    CASE WHEN origin IN ('ai_draft', 'ai_reviewed')
+         THEN generator_model IS NOT NULL
+              AND generator_prompt_version IS NOT NULL
+              AND generated_at IS NOT NULL
+         ELSE generator_model IS NULL
+              AND generator_prompt_version IS NULL
+              AND generated_at IS NULL
+              AND generator_confidence_bp IS NULL
+    END
+  ),
+  -- Accepting a draft is one transition, and it must be complete: an
+  -- ai_reviewed row names its reviewer and when. Conversely nothing may claim a
+  -- review it did not have.
+  CHECK (
+    CASE WHEN origin = 'ai_reviewed'
+         THEN reviewed_by IS NOT NULL AND reviewed_at IS NOT NULL
+         ELSE 1
+    END
+  ),
+  CHECK ((reviewed_by IS NULL) = (reviewed_at IS NULL))
+) STRICT;
+
+-- NQ-12 explanation-for-question: SELECT ... FROM explanations
+--       WHERE question_id = ? AND status = 'published'
+--       ORDER BY is_primary DESC, id. Partial: drafts are never delivered.
+CREATE INDEX idx_explanations_question_published
+  ON explanations (question_id, is_primary DESC, id) WHERE status = 'published';
+
+-- Exactly one primary published explanation per question, so the review screen
+-- never has to pick between two.
+CREATE UNIQUE INDEX uq_explanations_primary
+  ON explanations (question_id) WHERE is_primary = 1 AND status = 'published';
+
+-- NQ-12b explanation-review-queue: SELECT ... WHERE status = 'draft' ORDER BY id.
+CREATE INDEX idx_explanations_draft ON explanations (id) WHERE status = 'draft';
+
+-- NQ-12c unreviewed-published: the queue that actually matters. These rows ARE
+-- being served to students, badged, with no human having read them -- so this
+-- is the backlog to drain, ordered by the model's own least-confident first.
+--   SELECT ... FROM explanations
+--    WHERE origin = 'ai_draft' AND status = 'published'
+--    ORDER BY generator_confidence_bp
+CREATE INDEX idx_explanations_ai_draft_published
+  ON explanations (generator_confidence_bp, question_id)
+  WHERE origin = 'ai_draft' AND status = 'published';
+
+-- ---------------------------------------------------------------------------
+-- DELIVERY RULE for explanations, which the API must enforce rather than
+-- leaving to each caller:
+--
+--   practice / post-exam review -> status = 'published', any origin.
+--                                  Send `origin` on the wire so the client can
+--                                  badge an ai_draft. A client that drops the
+--                                  field shows an unlabelled draft, so the
+--                                  field is not optional in the response type.
+--
+--   during a timed mock test    -> never. Not even a published human one: the
+--                                  explanation names the answer. The mock
+--                                  delivery view cannot reach this table at
+--                                  all, which is why the answer key lives in
+--                                  question_answer_keys and not here.
+--
+--   status = 'draft'            -> never delivered, any origin. This is the
+--                                  pre-validation state.
+-- ---------------------------------------------------------------------------
+
+-- ---------------------------------------------------------------------------
+-- tags + question_tags: cross-cutting labels (concepts, past-paper years,
+-- skills). Orthogonal to the syllabus tree, which is strictly hierarchical and
+-- cannot express "this question needs Karnaugh maps AND two's complement".
+-- ---------------------------------------------------------------------------
+CREATE TABLE tags (
+  id          TEXT    NOT NULL PRIMARY KEY,                -- slug: 'karnaugh-map'
+  name        TEXT    NOT NULL,
+  kind        TEXT    NOT NULL DEFAULT 'concept'
+                      CHECK (kind IN ('concept', 'skill', 'exam_year', 'source', 'formula')),
+  description TEXT,
+  question_count INTEGER NOT NULL DEFAULT 0,               -- maintained by trigger in 0005
+  created_at  INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (id GLOB '[a-z0-9-]*')
+) STRICT;
+
+CREATE INDEX idx_tags_kind_name ON tags (kind, name);      -- NQ-13b tag-picker
+
+CREATE TABLE question_tags (
+  question_id TEXT    NOT NULL REFERENCES questions (id) ON DELETE CASCADE,
+  tag_id      TEXT    NOT NULL REFERENCES tags (id) ON DELETE CASCADE,
+  -- 0..100. Below 100 means a classifier proposed it and no human confirmed.
+  confidence  INTEGER NOT NULL DEFAULT 100 CHECK (confidence BETWEEN 0 AND 100),
+  added_by    TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  created_at  INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  PRIMARY KEY (question_id, tag_id)
+) STRICT;
+
+-- NQ-14 questions-for-tag: SELECT question_id FROM question_tags
+--       WHERE tag_id = ? -- "practise everything tagged Karnaugh maps".
+-- The primary key already covers NQ-13 tags-for-question.
+CREATE INDEX idx_question_tags_tag ON question_tags (tag_id, question_id);
+
+-- ---------------------------------------------------------------------------
+-- question_reports: user-reported errata, and the importer's own findings.
+--
+-- One table for both, because they are the same object: a claim that a
+-- question is defective, awaiting adjudication. The importer files its
+-- validator findings here with source='validator', which means the 23
+-- quarantined questions arrive with their evidence attached rather than as a
+-- hand-maintained JSON list whose ids go stale the moment the bank is
+-- reordered -- which is exactly what happened to
+-- frontend/src/data/quarantine.json.
+-- ---------------------------------------------------------------------------
+CREATE TABLE question_reports (
+  id                  INTEGER NOT NULL PRIMARY KEY,
+  public_id           TEXT    NOT NULL,                    -- ULID, for the URL
+  question_id         TEXT    NOT NULL REFERENCES questions (id) ON DELETE CASCADE,
+  -- NULL for validator/import findings: no human reported them.
+  reporter_user_id    TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  source              TEXT    NOT NULL DEFAULT 'user'
+                              CHECK (source IN ('user', 'validator', 'import', 'admin')),
+  category            TEXT    NOT NULL
+                              CHECK (category IN ('wrong_answer', 'typo', 'ambiguous',
+                                                  'duplicate', 'out_of_syllabus',
+                                                  'bad_option', 'other')),
+  -- Validator code when source <> 'user'. Same vocabulary as
+  -- questions.status_reason.
+  code                TEXT    CHECK (code IS NULL OR code IN (
+                                'KEY_CONFLICT', 'INDEX_RANGE', 'OPTION_DUPLICATE',
+                                'OPTION_COUNT', 'EMPTY_STEM',
+                                'DUPLICATE_ANSWER_CONFLICT',
+                                'OPTION_MULTIPLE_TRUE')),
+  detail              TEXT,
+  -- What the reporter thinks the answer should be. Belongs here, not in
+  -- question_answer_keys: an unadjudicated claim must not sit in the table the
+  -- grader reads.
+  suggested_option_id TEXT    REFERENCES question_options (id) ON DELETE SET NULL,
+  -- Which attempt the student was in when they reported it. A deliberately
+  -- unenforced soft reference to attempts.id: a report must outlive the
+  -- attempt rows that archival deletes (0004), so a hard FK would either block
+  -- archival or cascade the evidence away.
+  attempt_id          INTEGER,
+  status              TEXT    NOT NULL DEFAULT 'open'
+                              CHECK (status IN ('open', 'triaged', 'accepted', 'rejected', 'duplicate')),
+  resolution          TEXT,
+  resolved_by         TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  resolved_at         INTEGER,                                    -- epoch ms (UTC)
+  created_at          INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at          INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (suggested_option_id IS NULL
+         OR substr(suggested_option_id, 1, length(question_id) + 1) = question_id || '#'),
+  CHECK (resolved_at IS NULL OR status IN ('accepted', 'rejected', 'duplicate')),
+  -- A machine finding has no human reporter. Keeps the triage inbox honest
+  -- about which rows a person is waiting on an answer for.
+  CHECK (source NOT IN ('validator', 'import') OR reporter_user_id IS NULL)
+) STRICT;
+
+CREATE UNIQUE INDEX uq_question_reports_public_id ON question_reports (public_id);
+
+-- NQ-15 report-triage-queue: SELECT ... FROM question_reports
+--       WHERE status = 'open' ORDER BY created_at -- the moderation inbox.
+CREATE INDEX idx_question_reports_open ON question_reports (created_at)
+  WHERE status = 'open';
+
+-- NQ-16 reports-for-question: SELECT ... WHERE question_id = ? ORDER BY id DESC
+--       -- shown next to the question in the editor, and used to decide
+--       whether an incoming report is the fifth of its kind.
+CREATE INDEX idx_question_reports_question ON question_reports (question_id, id DESC);
+
+-- NQ-17 report-dedupe: one open report per user per question, enforced rather
+-- than checked, so a frustrated student tapping the button five times does not
+-- create five rows in the triage queue.
+CREATE UNIQUE INDEX uq_question_reports_open_by_reporter
+  ON question_reports (question_id, reporter_user_id)
+  WHERE status = 'open' AND reporter_user_id IS NOT NULL;
+
+-- ---------------------------------------------------------------------------
+-- content_versions: append-only audit trail for everything in this file.
+--
+-- A single table rather than one per entity, because the reader is always the
+-- same ("show me the history of this thing") and SQLite has no partitioning to
+-- gain from splitting it. `snapshot_json` is the full post-change state --
+-- storage is cheap relative to the cost of not being able to answer "what did
+-- this question say when the student answered it", which is the question an
+-- errata dispute always turns into.
+-- ---------------------------------------------------------------------------
+CREATE TABLE content_versions (
+  id             INTEGER NOT NULL PRIMARY KEY,
+  entity_type    TEXT    NOT NULL
+                         CHECK (entity_type IN ('question', 'question_option',
+                                                'question_answer_key', 'explanation',
+                                                'chapter', 'subchapter', 'tag',
+                                                'mock_test_template')),
+  entity_id      TEXT    NOT NULL,
+  version        INTEGER NOT NULL CHECK (version > 0),
+  op             TEXT    NOT NULL
+                         CHECK (op IN ('create', 'update', 'delete', 'status_change')),
+  snapshot_json  TEXT    NOT NULL CHECK (json_valid(snapshot_json)),
+  -- Null for 'create'. A field-level diff, so the history list can say
+  -- "stem changed" without the reader diffing two snapshots.
+  diff_json      TEXT    CHECK (diff_json IS NULL OR json_valid(diff_json)),
+  actor_user_id  TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  actor_kind     TEXT    NOT NULL DEFAULT 'user'
+                         CHECK (actor_kind IN ('user', 'importer', 'validator', 'system')),
+  reason         TEXT,
+  created_at     INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)) -- epoch ms (UTC)
+) STRICT;
+
+-- NQ-18 content-history: SELECT ... FROM content_versions
+--       WHERE entity_type = ? AND entity_id = ? ORDER BY version DESC.
+-- Unique, so a concurrent double-write cannot produce two version 7s.
+CREATE UNIQUE INDEX uq_content_versions_entity_version
+  ON content_versions (entity_type, entity_id, version);
+
+-- NQ-18b content-activity-feed: SELECT ... WHERE actor_user_id = ?
+--        ORDER BY id DESC -- the contributor's own contribution list.
+CREATE INDEX idx_content_versions_actor ON content_versions (actor_user_id, id DESC);
diff --git a/worker/migrations/0003_search.sql b/worker/migrations/0003_search.sql
new file mode 100644
index 0000000..8e0f8fa
--- /dev/null
+++ b/worker/migrations/0003_search.sql
@@ -0,0 +1,154 @@
+-- 0003_search.sql
+-- Full-text search over the question bank.
+--
+-- SQLite has no trigram index, no tsvector and no pg_trgm. It has FTS5, which
+-- D1 supports. A LIKE '%...%' scan over 2,290 questions would work today and
+-- stop working at 50,000; FTS5 costs one extra index now and nothing later.
+--
+-- Shape: a standalone (not external-content) FTS5 table whose rowid is kept
+-- equal to `questions.rowid`. Standalone means the indexed text is stored
+-- twice -- about 1.3 MB of stems and options becomes roughly 3 MB total, which
+-- is a real cost against a 500 MB free-tier ceiling and is accepted because
+-- the alternatives all require the triggers to carry the OLD row's full text
+-- through every update, which is exactly the kind of bookkeeping that rots.
+--
+-- Keying the FTS rowid to `questions.rowid` is what makes maintenance cheap:
+-- every trigger below deletes by rowid (an O(log n) lookup) instead of by
+-- `question_id` (a full scan of the FTS content table on every option edit,
+-- which is fine at 2,290 questions and ruinous at 100,000).
+--
+-- `options` is denormalised into the index on purpose. Students search for the
+-- text of an answer they half-remember at least as often as for the stem.
+--
+-- `tokenize = 'porter unicode61'` so 'resonating' finds 'resonance'. The
+-- bank is English with embedded code and formulae; `unicode61` keeps
+-- '74LS138' and 'CSMA/CD' searchable as units.
+
+CREATE VIRTUAL TABLE questions_fts USING fts5(
+  question_id UNINDEXED,
+  chapter_id  UNINDEXED,
+  status      UNINDEXED,
+  stem,
+  options,
+  tokenize = 'porter unicode61'
+);
+
+-- ---------------------------------------------------------------------------
+-- Maintenance triggers.
+--
+-- These are triggers rather than application code for a reason specific to
+-- this platform: D1 allows 50 queries per Worker invocation on the free plan.
+-- A content edit that had to hand-maintain the search index would spend two of
+-- those on bookkeeping. Work done inside a trigger is part of the statement
+-- that fired it and does not count against that budget.
+-- ---------------------------------------------------------------------------
+
+CREATE TRIGGER questions_fts_ai AFTER INSERT ON questions BEGIN
+  INSERT INTO questions_fts (rowid, question_id, chapter_id, status, stem, options)
+  VALUES (
+    NEW.rowid, NEW.id, NEW.chapter_id, NEW.status, NEW.stem,
+    -- Empty at import time: the importer writes the question before its
+    -- options. The question_options triggers below refresh the row.
+    COALESCE((SELECT group_concat(text, ' ')
+                FROM question_options
+               WHERE question_id = NEW.id AND retired_at IS NULL), '')
+  );
+END;
+
+CREATE TRIGGER questions_fts_ad AFTER DELETE ON questions BEGIN
+  DELETE FROM questions_fts WHERE rowid = OLD.rowid;
+END;
+
+-- Scoped to the columns the index actually holds, so the hourly
+-- `UPDATE questions SET p_value_bp = ...` statistics job does not reindex the
+-- entire bank.
+CREATE TRIGGER questions_fts_au
+AFTER UPDATE OF stem, status, chapter_id ON questions BEGIN
+  DELETE FROM questions_fts WHERE rowid = OLD.rowid;
+  INSERT INTO questions_fts (rowid, question_id, chapter_id, status, stem, options)
+  VALUES (
+    NEW.rowid, NEW.id, NEW.chapter_id, NEW.status, NEW.stem,
+    COALESCE((SELECT group_concat(text, ' ')
+                FROM question_options
+               WHERE question_id = NEW.id AND retired_at IS NULL), '')
+  );
+END;
+
+-- Option changes refresh the parent question's single FTS row. One delete and
+-- one insert, both by rowid.
+CREATE TRIGGER question_options_fts_ai AFTER INSERT ON question_options BEGIN
+  DELETE FROM questions_fts
+   WHERE rowid = (SELECT rowid FROM questions WHERE id = NEW.question_id);
+  INSERT INTO questions_fts (rowid, question_id, chapter_id, status, stem, options)
+  SELECT q.rowid, q.id, q.chapter_id, q.status, q.stem,
+         COALESCE((SELECT group_concat(o.text, ' ')
+                     FROM question_options o
+                    WHERE o.question_id = q.id AND o.retired_at IS NULL), '')
+    FROM questions q WHERE q.id = NEW.question_id;
+END;
+
+CREATE TRIGGER question_options_fts_au
+AFTER UPDATE OF text, retired_at ON question_options BEGIN
+  DELETE FROM questions_fts
+   WHERE rowid = (SELECT rowid FROM questions WHERE id = NEW.question_id);
+  INSERT INTO questions_fts (rowid, question_id, chapter_id, status, stem, options)
+  SELECT q.rowid, q.id, q.chapter_id, q.status, q.stem,
+         COALESCE((SELECT group_concat(o.text, ' ')
+                     FROM question_options o
+                    WHERE o.question_id = q.id AND o.retired_at IS NULL), '')
+    FROM questions q WHERE q.id = NEW.question_id;
+END;
+
+-- Option rows are retired, not deleted (see 0002). This trigger exists for the
+-- one legitimate delete path: cascading removal of a question that nobody has
+-- answered. The parent question row is gone by the time it fires in that case,
+-- so the SELECT yields nothing and only the DELETE does work -- which is
+-- correct, and is why the INSERT is a SELECT rather than a VALUES.
+CREATE TRIGGER question_options_fts_ad AFTER DELETE ON question_options BEGIN
+  DELETE FROM questions_fts
+   WHERE rowid = (SELECT rowid FROM questions WHERE id = OLD.question_id);
+  INSERT INTO questions_fts (rowid, question_id, chapter_id, status, stem, options)
+  SELECT q.rowid, q.id, q.chapter_id, q.status, q.stem,
+         COALESCE((SELECT group_concat(o.text, ' ')
+                     FROM question_options o
+                    WHERE o.question_id = q.id AND o.retired_at IS NULL), '')
+    FROM questions q WHERE q.id = OLD.question_id;
+END;
+
+-- ---------------------------------------------------------------------------
+-- NQ-11 question-search (student-facing). `status` is an UNINDEXED column of
+-- the FTS table so it can be filtered without a join back to `questions`,
+-- keeping the whole search to one query:
+--
+--   SELECT question_id, chapter_id,
+--          snippet(questions_fts, 3, '<mark>', '</mark>', '...', 24) AS excerpt,
+--          bm25(questions_fts, 0.0, 0.0, 0.0, 10.0, 3.0) AS rank
+--     FROM questions_fts
+--    WHERE questions_fts MATCH ?1
+--      AND status = 'published'
+--    ORDER BY rank
+--    LIMIT ?2;
+--
+-- The bm25 weights are positional over the table's five columns: the three
+-- UNINDEXED ones get 0.0, a stem hit is weighted 10 and an option hit 3. A
+-- student searching 'Thevenin' wants the question about Thevenin's theorem
+-- ahead of one that merely lists it as a wrong answer.
+--
+-- NQ-11b admin-search is the same query without the status filter.
+--
+-- NQ-11c index-rebuild, after a bulk import or a tokenizer change:
+--   INSERT INTO questions_fts (questions_fts) VALUES ('rebuild');
+-- -- not usable here, because 'rebuild' is only defined for external-content
+--    tables. The standalone equivalent is:
+--   DELETE FROM questions_fts;
+--   INSERT INTO questions_fts (rowid, question_id, chapter_id, status, stem, options)
+--   SELECT q.rowid, q.id, q.chapter_id, q.status, q.stem,
+--          COALESCE((SELECT group_concat(o.text, ' ') FROM question_options o
+--                     WHERE o.question_id = q.id AND o.retired_at IS NULL), '')
+--     FROM questions q;
+--
+-- NQ-11d index-compact, cheap and worth running after a bulk import because
+-- D1 never shrinks a database file and FTS5 segment merging is the only
+-- compaction available:
+--   INSERT INTO questions_fts (questions_fts, rank) VALUES ('merge', -64);
+-- ---------------------------------------------------------------------------
diff --git a/worker/migrations/0004_assessment.sql b/worker/migrations/0004_assessment.sql
new file mode 100644
index 0000000..8d0d773
--- /dev/null
+++ b/worker/migrations/0004_assessment.sql
@@ -0,0 +1,659 @@
+-- 0004_assessment.sql
+-- Mock test templates, attempts, the per-attempt delivered paper, and answers.
+--
+-- ===========================================================================
+-- PER-ATTEMPT OPTION PERMUTATION
+-- ===========================================================================
+--
+-- The question bank shipped as public JSON under frontend/public/data/books/
+-- and is in git history permanently. Anyone can reconstruct "question X's
+-- answer is the second option". Hiding the key in a server-only table (0002)
+-- therefore only solves half the problem: if the API delivers options in their
+-- authored order, a captured paper can be joined against that JSON by
+-- position and graded without ever asking the server.
+--
+-- So the paper is permuted per attempt, and the permutation is recorded:
+--
+--   * `attempt_questions.option_order` is a JSON array of option ids in the
+--     order this attempt's paper showed them. Option ids, not indices --
+--     joining an index against the public JSON is the attack being closed.
+--   * `attempts.option_seed` is the PRNG seed, so the exact paper can be
+--     reproduced for a dispute without trusting the client's copy.
+--   * `attempt_answers` records the option the student chose as its stable
+--     `opt_key` (exposed as a full option id by a VIRTUAL generated column),
+--     plus the screen position it occupied. The position is analytics only;
+--     grading resolves the client's handle through `option_order` and compares
+--     ids.
+--
+-- The authored bank has a severe answer-position bias. Measured over the 2,190
+-- published questions after import, the authored correct option sits at slot
+-- 1/2/3/4 in 634/721/496/339 of them -- 32.9% at slot 2 against the 25% a fair
+-- bank would show, and considerably worse per chapter. So permutation is also
+-- the only thing that stops a student scoring well above chance without
+-- learning anything. Options flagged `question_options.is_pinned` ('All of the
+-- above' and friends, 450 of them, every single one authored in slot 4) must
+-- stay last: shuffling one into the middle makes the question nonsense.
+--
+-- Note what this costs. The existing client permutes with a seed derived from
+-- the question id, so the order is stable per question forever; that is weaker
+-- (one captured paper reveals the order for everyone) and the reason it was
+-- done that way was to stop saved drafts re-pointing. Storing `option_order`
+-- per attempt gets the stronger property and keeps drafts stable, at the price
+-- of one extra row per delivered question -- see the ceiling arithmetic below.
+--
+-- WHAT PERMUTATION DOES NOT BUY, STATED PLAINLY.
+--
+-- Option ids no longer leak the authored slot: 0002 mints them as
+-- `question_id || '#' || opt_key` with a 60-bit CSPRNG `opt_key`, precisely
+-- because the earlier `|| ordinal` form made an option id joinable against the
+-- `correct_option_index` published in `frontend/public/data/books/*.json`. Read
+-- the block above `question_options` in 0002 for that argument in full.
+--
+-- What remains true after the fix, and is worth being exact about rather than
+-- papering over:
+--
+--   * For the 2,290 questions already published as public JSON, the answer key
+--     is irrecoverably public. Any client that can read a stem can look the
+--     answer up by stem text. No server-side measure restores secrecy for
+--     those, and a schema that pretends otherwise is lying to its reader.
+--   * What IS defensible, and what this design actually protects, is: (a) no
+--     question authored FROM NOW ON ever has its key exposed, because the key
+--     lives only in `question_answer_keys`; and (b) a delivered paper cannot
+--     be graded by POSITION alone, so the attack requires text matching per
+--     question rather than one join.
+--
+-- Defence in depth stays on top of that: the delivery layer still ships no raw
+-- option ids. `option_order` is the server-side mapping, and the API hands the
+-- client a per-attempt ref derived as a keyed digest of
+-- (server secret, option_seed, attempt, option id) -- see
+-- `worker/src/handlers/paper.ts` and `lib/permute.ts#attemptOptionRef`. The
+-- refs are DERIVED rather than stored: `attempt_questions` is the second table
+-- to watch at scale (one row per delivered question, ~3 M rows a year at 1,000
+-- MAU), and four stored 12-character tokens per row would add ~60 bytes to
+-- every one of them for information the server can recompute in microseconds
+-- from two columns it already has.
+--
+-- The `question_id || '#' || <key>` SHAPE is deliberately kept rather than
+-- swapped for a bare random ULID, because the prefix buys two things a free
+-- random id does not: the `question_answer_keys` CHECK can prove with a prefix
+-- test that a key cannot point at another question's option, and the same test
+-- guards `explanations.about_option_id` and
+-- `question_reports.suggested_option_id`. `attempt_answers` stores the 12-char
+-- `opt_key` rather than the full ~30-char id, which is what keeps the one
+-- unbounded table narrow -- see the measured arithmetic below.
+-- ===========================================================================
+
+-- ---------------------------------------------------------------------------
+-- mock_test_templates: a named exam shape.
+--
+-- `blueprint` is TEXT holding JSON. SQLite has no jsonb; TEXT plus
+-- json_valid() plus the json1 functions is the real equivalent, and json_each()
+-- makes a blueprint queryable where it matters (see NQ-19b below).
+--
+-- ===========================================================================
+-- THE BLUEPRINT IS SUB-CHAPTER LEVEL. Version 2.
+-- ===========================================================================
+--
+-- Version 1 of this shape carried one rule per CHAPTER ("10 from book-ch1"),
+-- which is what `frontend/src/data/topics.ts` hardcoded. That is not the exam.
+-- The official NEC syllabus for Computer Engineering publishes 10 chapters of
+-- exactly 6 sub-chapters each -- 60 syllabus codes, seeded as `subchapters` in
+-- 0007 -- and `frontend/src/data/examBlueprint.ts` already models the paper at
+-- that level, with a documented weighting rule:
+--
+--   equal-chapter-weight-largest-remainder
+--     1. each of the 10 chapters contributes 100/10 = 10 questions. This is the
+--        only split the syllabus supports: it lists ten chapters of identical
+--        structure and publishes no weights, so any uneven chapter weighting
+--        would be invented.
+--     2. within a chapter, 10 questions over 6 sub-chapters by largest
+--        remainder (Hare quota) on equal shares: floor(10/6) = 1 each (6 seats)
+--        with a remainder of 0.667 each and 4 seats left.
+--     3. all six remainders tie, so the spare seats go in ascending
+--        sub-chapter index -- the standard deterministic tie-break, documented
+--        as arbitrary in content terms because it is.
+--   Per chapter: 2+2+2+2+1+1 = 10. Across ten chapters: exactly 100.
+--
+-- So a blueprint is 60 rules, not 10, and the frontend and the database now
+-- describe the same paper. `generate-reference-sql.mjs` derives 0007's rules
+-- from that same file, so the two cannot drift.
+--
+-- Blueprint schema, version 2:
+--
+--   {
+--     "version": 2,
+--     "weighting_rule": "equal-chapter-weight-largest-remainder",
+--     "shuffle_options": true,
+--     "negative_marking": 0,          -- marks deducted per wrong answer
+--     "pass_mark_bp": 5000,           -- basis points, 5000 = 50%
+--     -- false: a sub-chapter with too few TAGGED questions is topped up from
+--     -- its chapter's pool and the shortfall is reported. true: it is a hard
+--     -- failure. Ships false, and must, because `questions.subchapter_id` is
+--     -- NULL for all 2,290 imported questions -- the source JSON has no
+--     -- syllabus field and the importer does not guess. A strict run today
+--     -- would fail on all 60 rules. Flip it when tagging coverage is real;
+--     -- it is a data change in this column, not a code change anywhere.
+--     "strict_subchapter": false,
+--     "rules": [
+--       { "chapter_id": "book-ch1",
+--         "subchapter_code": "1.1",   -- NULL for a chapter-wide rule
+--         "count": 2,
+--         "difficulty": null,         -- or "easy" | "medium" | "hard"
+--         "tag_ids": null }           -- or ["karnaugh-map"]
+--       -- ... 60 of them
+--     ]
+--   }
+--
+-- 0007 seeds the three templates the app currently hardcodes, reshaped:
+-- the two 100-question full mocks get the 2/2/2/2/1/1 split per chapter, and
+-- the 50-question quick assessment gets largest-remainder on 5 per chapter
+-- (floor(5/6) = 0 each, five spare seats to indexes 1..5), i.e. 1/1/1/1/1/0.
+--
+-- `total_questions` is stored, not generated. It is derivable from the
+-- blueprint with a json_each sum, but a STORED generated column may only use
+-- deterministic scalar expressions -- no subqueries, which json_each requires.
+-- A CHECK keeps it non-negative; the API asserts the sum on write.
+-- ---------------------------------------------------------------------------
+CREATE TABLE mock_test_templates (
+  id               TEXT    NOT NULL PRIMARY KEY,           -- 'full-mock-1'
+  subject_id       TEXT    NOT NULL REFERENCES subjects (id) ON DELETE RESTRICT,
+  slug             TEXT    NOT NULL,
+  name             TEXT    NOT NULL,
+  description      TEXT,
+  duration_minutes INTEGER NOT NULL CHECK (duration_minutes BETWEEN 1 AND 600),
+  total_questions  INTEGER NOT NULL CHECK (total_questions BETWEEN 1 AND 500),
+  blueprint        TEXT    NOT NULL CHECK (json_valid(blueprint)),
+  -- 'static' draws the same questions every time (a published past paper);
+  -- 'random' redraws per attempt, which is what every current template does.
+  selection        TEXT    NOT NULL DEFAULT 'random'
+                           CHECK (selection IN ('random', 'static')),
+  status           TEXT    NOT NULL DEFAULT 'published'
+                           CHECK (status IN ('draft', 'published', 'retired')),
+  ordinal          INTEGER NOT NULL DEFAULT 0,
+  created_by       TEXT    REFERENCES users (id) ON DELETE SET NULL,
+  created_at       INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at       INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  CHECK (json_type(blueprint, '$.rules') = 'array'),
+  -- Version 2 is the sub-chapter-level shape. The CHECK is an equality rather
+  -- than a range so a version-1 chapter-level blueprint cannot be inserted by
+  -- accident and then silently drawn at the wrong granularity.
+  CHECK (json_extract(blueprint, '$.version') = 2),
+  CHECK (json_type(blueprint, '$.strict_subchapter') IN ('true', 'false'))
+) STRICT;
+
+-- NQ-19 template-by-slug: SELECT ... FROM mock_test_templates WHERE slug = ?.
+CREATE UNIQUE INDEX uq_mock_test_templates_slug ON mock_test_templates (slug);
+
+-- NQ-19a template-list: SELECT ... WHERE subject_id = ? AND status = 'published'
+--       ORDER BY ordinal.
+CREATE INDEX idx_mock_test_templates_subject_ordinal
+  ON mock_test_templates (subject_id, ordinal) WHERE status = 'published';
+
+-- NQ-19b blueprint-expand, issued once when an attempt starts. ONE query for
+-- all 60 rules, because D1 allows 50 queries per invocation and a blueprint
+-- that looped per rule would exceed the whole budget before drawing a question:
+--   SELECT json_extract(r.value, '$.chapter_id')      AS chapter_id,
+--          json_extract(r.value, '$.subchapter_code') AS subchapter_code,
+--          json_extract(r.value, '$.count')           AS want
+--     FROM mock_test_templates t, json_each(t.blueprint, '$.rules') r
+--    WHERE t.id = ?1;
+--
+-- NQ-19c blueprint-draw, the sub-chapter-level selection, also ONE query. It
+-- returns two pools and lets the pure allocator in
+-- `worker/src/domain/blueprint.ts` spend them, which is what keeps the
+-- largest-remainder and fallback policy testable without a database:
+--
+--   WITH rules AS (
+--     SELECT json_extract(r.value, '$.chapter_id')      AS chapter_id,
+--            json_extract(r.value, '$.subchapter_code') AS subchapter_code,
+--            json_extract(r.value, '$.count')           AS want
+--       FROM mock_test_templates t, json_each(t.blueprint, '$.rules') r
+--      WHERE t.id = ?1),
+--   chapter_want AS (
+--     SELECT chapter_id, SUM(want) AS want FROM rules GROUP BY chapter_id),
+--   tagged AS (                        -- questions carrying a syllabus code
+--     SELECT q.id, q.chapter_id, s.code AS subchapter_code, r.want,
+--            ROW_NUMBER() OVER (PARTITION BY s.code ORDER BY RANDOM()) AS rn
+--       FROM rules r
+--       JOIN subchapters s ON s.code = r.subchapter_code
+--       JOIN questions q ON q.subchapter_id = s.id AND q.status = 'published'),
+--   pool AS (                          -- the chapter-level fallback pool
+--     SELECT q.id, q.chapter_id, cw.want,
+--            ROW_NUMBER() OVER (PARTITION BY q.chapter_id ORDER BY RANDOM()) AS rn
+--       FROM chapter_want cw
+--       JOIN questions q ON q.chapter_id = cw.chapter_id
+--                       AND q.status = 'published')
+--   SELECT 'subchapter' AS src, id, chapter_id, subchapter_code
+--     FROM tagged WHERE rn <= want
+--   UNION ALL
+--   SELECT 'chapter' AS src, id, chapter_id, NULL
+--     FROM pool WHERE rn <= want;
+--
+-- `tagged` is empty today -- `questions.subchapter_id` is NULL for every
+-- imported question -- so every rule is satisfied from `pool` and the allocator
+-- reports all 60 sub-chapters as approximated. That is the honest behaviour and
+-- it matches `selectionBlueprint.strictBlueprint = false` in the frontend
+-- exactly. The query does not change when tagging arrives; only its output mix
+-- does. `pool` draws a chapter's whole quota, so the two arms can overlap and
+-- the allocator de-duplicates -- bounded at 2 x total_questions rows.
+
+-- ---------------------------------------------------------------------------
+-- attempts: one sitting of a practice set, mock test or review queue.
+--
+-- `id` is an INTEGER rowid alias, not a ULID, and `public_id` carries the
+-- opaque identifier that appears in URLs. The reason is one table down:
+-- `attempt_answers` is the only unbounded table on the platform, and every
+-- answer row carries an attempt reference. A 26-character ULID there costs 26
+-- bytes plus overhead per row against an 8-byte integer; across the 3 million
+-- rows a 180-day retention window holds at 1,000 MAU, that choice alone is
+-- most of a percent of the 500 MB free-tier database limit, repeated in the
+-- index. Opaque ids in URLs and compact ids in the hot table are not in
+-- conflict; they just need two columns.
+-- ---------------------------------------------------------------------------
+CREATE TABLE attempts (
+  id               INTEGER NOT NULL PRIMARY KEY,           -- rowid alias, internal
+  public_id        TEXT    NOT NULL,                       -- ULID, appears in URLs
+  user_id          TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  mode             TEXT    NOT NULL
+                           CHECK (mode IN ('practice', 'mock', 'srs', 'bookmark_review', 'weak_areas')),
+  -- Set for mode='mock'. RESTRICT rather than CASCADE: deleting a template
+  -- must not delete the attempts students already sat under it.
+  template_id      TEXT    REFERENCES mock_test_templates (id) ON DELETE RESTRICT,
+  -- Set for a single-chapter or single-subchapter practice set. NULL for a
+  -- mock, which spans all ten.
+  chapter_id       TEXT    REFERENCES chapters (id) ON DELETE RESTRICT,
+  subchapter_id    TEXT    REFERENCES subchapters (id) ON DELETE RESTRICT,
+  status           TEXT    NOT NULL DEFAULT 'in_progress'
+                           CHECK (status IN ('in_progress', 'submitted', 'abandoned', 'expired')),
+  -- Seed for the per-attempt option permutation. Lets the exact paper be
+  -- reproduced from the question ids alone, for an errata dispute.
+  option_seed      INTEGER NOT NULL,
+  question_count   INTEGER NOT NULL DEFAULT 0 CHECK (question_count >= 0),
+  -- Maintained by the triggers in 0005 so the history list never has to count
+  -- rows in attempt_answers -- which matters because those rows get archived
+  -- away while the attempt summary must survive.
+  answered_count   INTEGER NOT NULL DEFAULT 0 CHECK (answered_count >= 0),
+  correct_count    INTEGER NOT NULL DEFAULT 0 CHECK (correct_count >= 0),
+  -- Basis points, 0..10000. Generated and STORED so the history list and the
+  -- leaderboard job read a number instead of computing one, and so it can be
+  -- indexed. Integer basis points rather than REAL: exact, sortable, and
+  -- immune to the "99.99999%" rendering bug.
+  score_bp         INTEGER GENERATED ALWAYS AS (
+                     CASE WHEN question_count = 0 THEN 0
+                          ELSE (correct_count * 10000) / question_count END
+                   ) STORED,
+  started_at       INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  -- Server-side clock for a timed mock. The client's countdown is a
+  -- convenience; this is the authority.
+  deadline_at      INTEGER,                                       -- epoch ms (UTC)
+  submitted_at     INTEGER,                                       -- epoch ms (UTC)
+  -- Wall time the student actually spent, which is not deadline minus start:
+  -- they can submit early, and a resumed attempt has gaps.
+  elapsed_ms       INTEGER,                                       -- duration, milliseconds
+  -- ========================================================================
+  -- THE PRE-DEADLINE SNAPSHOT. These two columns are what make the expiry
+  -- clamp honest, and without them a late submission can only be scored as
+  -- zero or trusted wholesale -- and both of those are wrong.
+  --
+  -- A mock client pushes its whole answer map to POST /api/mock/sync every
+  -- ten to fifteen seconds. The UPDATE that writes it carries
+  -- `AND ?now <= deadline_at` (see worker/src/data/attempts.ts#syncAnswers),
+  -- so whatever is stored here is BY CONSTRUCTION a state that existed before
+  -- the deadline. On a submission after the grace window the submitted payload
+  -- is discarded and THIS is scored instead, so freezing the client timer and
+  -- working for another hour cannot gain a single mark -- it can only lose the
+  -- answers that were never synced.
+  --
+  -- The map REPLACES rather than merges, which is what makes the endpoint
+  -- idempotent and safe for the offline outbox to replay: the last write to
+  -- arrive before the deadline wins, and that is the honest answer.
+  --
+  -- JSON, `{ "<question_id>": "<option_ref>" }` -- per-attempt opaque refs,
+  -- never option ids and never positions. Bounded by MAX_MOCK_ANSWERS (250) in
+  -- the request schema, so one row cannot grow without limit.
+  -- ========================================================================
+  synced_answers   TEXT    CHECK (synced_answers IS NULL
+                                  OR (json_valid(synced_answers)
+                                      AND json_type(synced_answers) = 'object')),
+  last_sync_at     INTEGER,                                       -- epoch ms (UTC)
+  -- Small JSON bag for user-agent class, screen size, 'resumed' flags.
+  -- Diagnostics, never read by business logic.
+  client_meta      TEXT    CHECK (client_meta IS NULL OR json_valid(client_meta)),
+  CHECK (correct_count <= answered_count),
+  CHECK (answered_count <= question_count),
+  CHECK ((status = 'submitted') = (submitted_at IS NOT NULL)),
+  CHECK (mode <> 'mock' OR template_id IS NOT NULL),
+  CHECK (subchapter_id IS NULL OR chapter_id IS NOT NULL),
+  CHECK ((synced_answers IS NULL) = (last_sync_at IS NULL)),
+  -- The pre-deadline property, enforced by the database and not only by the
+  -- WHERE clause that writes it. If a future handler forgets the clamp, the
+  -- write fails instead of quietly accepting post-deadline work.
+  CHECK (last_sync_at IS NULL OR deadline_at IS NULL OR last_sync_at <= deadline_at)
+) STRICT;
+
+-- NQ-21 attempt-by-public-id: every attempt route resolves its URL segment
+--       here first. SELECT id, user_id, status FROM attempts WHERE public_id = ?.
+CREATE UNIQUE INDEX uq_attempts_public_id ON attempts (public_id);
+
+-- NQ-20 resume-attempt: SELECT ... FROM attempts
+--       WHERE user_id = ? AND status = 'in_progress'
+--       ORDER BY started_at DESC LIMIT 1.
+-- Partial, because exactly one row per user is normally in this state and the
+-- index should be a few hundred entries platform-wide rather than millions.
+-- This replaces the `eng_mock_draft_v1:` localStorage keys.
+CREATE INDEX idx_attempts_user_in_progress
+  ON attempts (user_id, started_at DESC) WHERE status = 'in_progress';
+
+-- NQ-22 attempt-history: SELECT public_id, mode, chapter_id, question_count,
+--       correct_count, score_bp, submitted_at FROM attempts
+--       WHERE user_id = ? AND status = 'submitted'
+--       ORDER BY submitted_at DESC LIMIT ? OFFSET ?.
+CREATE INDEX idx_attempts_user_submitted
+  ON attempts (user_id, submitted_at DESC) WHERE status = 'submitted';
+
+-- NQ-22b expire-stale-attempts (cron): SELECT id FROM attempts
+--        WHERE status = 'in_progress' AND deadline_at < ? LIMIT ?.
+CREATE INDEX idx_attempts_deadline
+  ON attempts (deadline_at) WHERE status = 'in_progress' AND deadline_at IS NOT NULL;
+
+-- NQ-26b archival-candidates (see the archival note at the end of this file):
+--        SELECT id FROM attempts WHERE submitted_at < ? ORDER BY id LIMIT ?.
+CREATE INDEX idx_attempts_submitted_at ON attempts (submitted_at)
+  WHERE submitted_at IS NOT NULL;
+
+-- NQ-35b leaderboard-source: SELECT user_id, SUM(correct_count), SUM(question_count)
+--        FROM attempts WHERE submitted_at >= ?1 AND submitted_at < ?2
+--        GROUP BY user_id -- run by the snapshot cron only, never by a request.
+--        Served by idx_attempts_submitted_at above.
+
+-- ---------------------------------------------------------------------------
+-- attempt_questions: the delivered paper. One row per question in the attempt,
+-- in delivery order, with the option permutation that attempt saw.
+--
+-- This table is why an attempt can be resumed exactly, why a dispute can be
+-- adjudicated against what the student was actually shown, and why the paper
+-- does not have to be regenerated (and so cannot come back different) when the
+-- page reloads.
+--
+-- Bounded at question_count rows per attempt: 100 for the largest mock.
+-- ---------------------------------------------------------------------------
+CREATE TABLE attempt_questions (
+  attempt_id   INTEGER NOT NULL REFERENCES attempts (id) ON DELETE CASCADE,
+  position     INTEGER NOT NULL CHECK (position >= 1),
+  question_id  TEXT    NOT NULL REFERENCES questions (id) ON DELETE RESTRICT,
+  -- JSON array of option ids in the order this attempt showed them, e.g.
+  -- ["q_ab12#3","q_ab12#1","q_ab12#4","q_ab12#2"]. Ids, never indices.
+  option_order TEXT    NOT NULL CHECK (json_valid(option_order)
+                                       AND json_type(option_order) = 'array'),
+  PRIMARY KEY (attempt_id, position)
+) STRICT;
+
+-- One appearance per question per attempt. A paper that asks the same question
+-- twice is a selection bug, and it should fail at the write rather than be
+-- discovered by the student.
+CREATE UNIQUE INDEX uq_attempt_questions_attempt_question
+  ON attempt_questions (attempt_id, question_id);
+
+-- NQ-23 attempt-paper: SELECT position, question_id, option_order
+--       FROM attempt_questions WHERE attempt_id = ? ORDER BY position
+--       -- served by the primary key, no sort.
+--
+-- NQ-23b render-paper, the full page in one query. Note that it joins
+-- v_question_delivery and so structurally cannot return the key:
+--   SELECT aq.position, aq.option_order, d.stem, d.option_id, d.option_text
+--     FROM attempt_questions aq
+--     JOIN v_question_delivery d ON d.question_id = aq.question_id
+--    WHERE aq.attempt_id = ?1
+--    ORDER BY aq.position;
+--   -- the Worker then sorts each question's options by their index in
+--      option_order, which is the permutation this attempt is owed.
+
+-- ---------------------------------------------------------------------------
+-- attempt_answers: THE ONLY UNBOUNDED TABLE ON THE PLATFORM.
+--
+-- Everything about this table's shape is a consequence of that. Read the
+-- archival note at the bottom of this file before changing any column here.
+--
+-- Width discipline, and what each choice buys:
+--
+--   * `id INTEGER PRIMARY KEY` -- the rowid alias. No ULID, no UUID. Also the
+--     archival cursor, because rowid order is insertion order.
+--   * `attempt_id INTEGER` -- 8 bytes against a 26-byte ULID. Resolved from
+--     `attempts.public_id` once per request, not stored per answer.
+--   * `selected_opt_key TEXT(12)` rather than `selected_option_id TEXT(~30)`.
+--     Option ids are `question_id || '#' || opt_key` by construction (0002),
+--     and `question_id` is already in this row, so the key is the only part
+--     that is not. The full id is exposed as a VIRTUAL generated column: zero
+--     bytes on disk, fully joinable, and the requirement that an answer
+--     reference a stable option id is met literally rather than by convention.
+--     This column used to be `selected_ordinal INTEGER` and was 4 bytes
+--     narrower; the change is the cost of the id scheme in 0002 no longer
+--     encoding the authored slot, and 12 bytes against a measured 132.4
+--     bytes/row is the price of not publishing the answer key in every option
+--     id. It is also why the key is 12 characters and not 26.
+--   * NULL `selected_opt_key` means skipped. SQLite skips a foreign-key check
+--     when any child column is NULL, so a skipped answer costs no parent
+--     lookup and needs no sentinel value.
+--   * No `user_id`. It is one join away through `attempt_id`, and the only
+--     per-user read of this table is scoped to one attempt. Denormalising it
+--     would add 26 bytes per row to save a join that nothing performs.
+--   * No authored ordinal. It is one join away through
+--     `question_options (question_id, opt_key)` and nothing on a request path
+--     needs it; the position-bias analytics read `delivered_position`.
+--
+-- Integrity: the composite foreign key proves the chosen key is a real option
+-- of that question. It costs one index probe per insert, paid
+-- deliberately -- an answer pointing at a nonexistent option is an
+-- unfixable silent mis-grade, and the existing bank already contains two
+-- questions whose authored key points past the last option.
+--
+-- `is_correct` is graded by the server at write time against
+-- question_answer_keys (NQ-10) and stored, so review, scoring, rollups and
+-- the leaderboard never re-derive it and never need the key table.
+-- ---------------------------------------------------------------------------
+CREATE TABLE attempt_answers (
+  id                 INTEGER NOT NULL PRIMARY KEY,         -- rowid alias, archival cursor
+  attempt_id         INTEGER NOT NULL REFERENCES attempts (id) ON DELETE CASCADE,
+  question_id        TEXT    NOT NULL REFERENCES questions (id) ON DELETE RESTRICT,
+  -- NULL = skipped / unanswered. `question_options.opt_key`, 12 base32 chars.
+  selected_opt_key   TEXT,
+  -- Virtual: costs nothing to store, everything to clarity.
+  selected_option_id TEXT    GENERATED ALWAYS AS (
+                               CASE WHEN selected_opt_key IS NULL THEN NULL
+                                    ELSE question_id || '#' || selected_opt_key END
+                             ) VIRTUAL,
+  is_correct         INTEGER NOT NULL DEFAULT 0 CHECK (is_correct IN (0, 1)),
+  -- Where the chosen option sat on screen, 1-based, under this attempt's
+  -- permutation. Analytics only (position-bias measurement). Never grading.
+  delivered_position INTEGER,
+  -- Milliseconds on this question. Feeds the FSRS rating heuristic in 0005.
+  time_ms            INTEGER CHECK (time_ms IS NULL OR time_ms >= 0), -- duration, milliseconds
+  -- 1 if the student changed their answer at least once. Cheap signal for
+  -- "guessed" versus "knew it", stored as a flag rather than as a revision log
+  -- precisely because this table may not grow a second row per answer.
+  revised            INTEGER NOT NULL DEFAULT 0 CHECK (revised IN (0, 1)),
+  answered_at        INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  FOREIGN KEY (question_id, selected_opt_key)
+    REFERENCES question_options (question_id, opt_key),
+  CHECK (selected_opt_key IS NULL
+         OR (length(selected_opt_key) = 12 AND selected_opt_key GLOB '[0-9A-Z]*')),
+  CHECK (selected_opt_key IS NOT NULL OR is_correct = 0)
+) STRICT;
+
+-- NQ-24 attempt-answers-load / NQ-25 answer-upsert. One row per question per
+-- attempt, enforced, so the client's retry-on-flaky-network does not create
+-- two answers:
+--   INSERT INTO attempt_answers (attempt_id, question_id, selected_opt_key,
+--                                is_correct, delivered_position, time_ms)
+--   VALUES (?1, ?2, ?3, ?4, ?5, ?6)
+--   ON CONFLICT (attempt_id, question_id) DO UPDATE SET
+--     selected_opt_key = excluded.selected_opt_key,
+--     is_correct       = excluded.is_correct,
+--     time_ms          = excluded.time_ms,
+--     revised          = 1,
+--     answered_at      = CAST(unixepoch('subsec') * 1000 AS INTEGER);
+-- This is also the index that serves loading an attempt for review.
+CREATE UNIQUE INDEX uq_attempt_answers_attempt_question
+  ON attempt_answers (attempt_id, question_id);
+
+-- NQ-26 archival-scan: SELECT id FROM attempt_answers WHERE answered_at < ?
+--       ORDER BY id LIMIT ?. The only reason this index exists; it is also the
+--       index that makes the retention job cheap enough to run inside the free
+--       tier's write budget. See the archival note below.
+CREATE INDEX idx_attempt_answers_answered_at ON attempt_answers (answered_at);
+
+-- NQ-26c question-difficulty-recompute (nightly, bounded by the retention
+--        window): SELECT question_id, COUNT(*) n, SUM(is_correct) k
+--        FROM attempt_answers WHERE answered_at >= ?1 GROUP BY question_id
+--        -- writes questions.p_value_bp. Served by the index below, which is
+--        covering for this query so the nightly job never touches the table.
+CREATE INDEX idx_attempt_answers_question_correct
+  ON attempt_answers (question_id, is_correct);
+
+-- ===========================================================================
+-- ARCHIVAL: THE CEILING, MEASURED, AND THE JOB THAT KEEPS US UNDER IT
+-- ===========================================================================
+--
+-- MEASURED ROW COST. Not estimated. 200,000 synthetic answer rows were
+-- inserted into this exact schema, with these exact indexes and the rollup
+-- triggers from 0005 live, and the allocated page bytes read back out of
+-- `dbstat` (SQLite 3.54, 4 KB pages). Reproduce with `npm run db:measure`:
+--
+--     attempt_answers (table b-tree)         56.2 bytes/row
+--     uq_attempt_answers_attempt_question    33.1
+--     idx_attempt_answers_answered_at        29.7
+--     idx_attempt_answers_question_correct   30.9
+--     ------------------------------------------------
+--     TOTAL                                 149.9 bytes/row
+--
+-- RE-MEASURED after two deliberate changes, and both costs are real:
+--   * `answered_at` in MILLISECONDS instead of seconds -- about 3 bytes in the
+--     table and the same again in idx_attempt_answers_answered_at, which is
+--     keyed on it (25.7 -> 29.7).
+--   * `selected_opt_key TEXT(12)` instead of `selected_ordinal INTEGER` -- the
+--     table row grows 42.7 -> 56.2.
+-- 132.4 -> 149.9 bytes/row, i.e. 13% fewer rows in the same database, is what
+-- not publishing the answer key in every option id and not having two
+-- incompatible time units actually cost. It is the right trade and it is
+-- written down here so nobody has to rediscover the price.
+--
+-- Note that 63% of the cost is index, not row. That is the price of the three
+-- queries above and it is the first thing to revisit if the ceiling gets
+-- close: dropping idx_attempt_answers_question_correct alone would buy 21%
+-- more rows at the cost of making the nightly difficulty recompute a table
+-- scan.
+--
+-- The rest of the schema -- 2,290 questions, 9,160 options, the 60 syllabus
+-- codes, and the FTS5 index -- measures 5.9 MB, of which FTS5 is 1.0 MB. So a
+-- 500 MB D1 free database holds 3,455,265 answer rows; a 10 GB paid one holds
+-- 71,572,735.
+--
+-- VOLUME, at ~500 answers per active user per month (generated by
+-- `npm run db:measure`, not by hand):
+--
+--     MAU    rows/month  row-writes/day   90d live      180d live    fits free 500MB@90d
+--     ------ ----------  --------------  ------------  ------------  -------------------
+--      1,000    500,000          66,667  1.5M  214 MB  3.0M  429 MB  yes
+--      2,000  1,000,000         133,333  3.0M  429 MB  6.0M  858 MB  yes
+--      5,000  2,500,000         333,333  7.5M  1.05 GB 15.0M 2.09 GB  no
+--     10,000  5,000,000         666,667  15.0M 2.09 GB 30.0M 4.19 GB  no
+--     25,000 12,500,000       1,666,667  37.5M 5.24 GB 75.0M 10.5 GB  no
+--
+-- Conclusions, stated now rather than discovered later:
+--   * The free plan's 100,000 row-writes-per-DAY cap binds long before its
+--     500 MB storage cap. D1 counts index rows as writes, so one answer is
+--     FOUR row writes here (table + three indexes). 1,500 MAU is about
+--     100,000 row writes a day. Storage would tolerate 2,500 MAU at 90-day
+--     retention; writes will not.
+--   * Workers Paid ($5/mo, 10 GB/db, 50 M row writes/mo) covers 10,000 MAU at
+--     90-day retention with room to spare, and 10,000 MAU is 20 M answer row
+--     writes a month against the 50 M allowance.
+--   * Beyond ~25,000 MAU the next step is sharding answers across D1
+--     databases by user id, or moving this one table to Durable Object SQL
+--     storage. Both are schema-compatible with what is written here, because
+--     nothing joins attempt_answers across users -- which is itself a design
+--     constraint worth keeping.
+--
+-- WHY DELETING IS ENOUGH. D1 exposes no VACUUM, so a deleted row does not
+-- shrink the database file. It does free the page for reuse by subsequent
+-- inserts. That is the property that matters: with a fixed retention window
+-- the live set is bounded, the file grows to roughly that size and then stays
+-- there, reusing its own free pages. Without the retention job the file grows
+-- forever and the first symptom is writes failing at the 500 MB wall.
+--
+-- WHAT IS SAFE TO DELETE. Nothing user-visible depends on a raw answer row
+-- older than the review window:
+--   * per-attempt score and counts -- `attempts.answered_count`,
+--     `correct_count`, `score_bp`, maintained by trigger (0005).
+--   * per-question history -- `user_question_stats` (0005), also by trigger.
+--   * scheduling -- `srs_state` (0005).
+--   * leaderboards -- `leaderboard_snapshots` (0006), precomputed.
+-- Deleting raw answers loses the question-by-question review of an old
+-- attempt, and nothing else. That is the trade, and it is the right one.
+--
+-- RETENTION POLICY.
+--   * answers belonging to a submitted attempt: 90 days (free) / 180 (paid).
+--   * answers belonging to an abandoned or expired attempt: 7 days.
+--   * the `attempts` summary row itself: kept indefinitely. It is one row per
+--     sitting, ~120 bytes, bounded by human stamina rather than by anything
+--     unbounded.
+--
+-- THE JOB. A scheduled Worker, run nightly, three statements per batch. The
+-- LIMIT exists because D1 allows 50 queries per invocation and because a
+-- single unbounded DELETE would blow the per-query time limit and the daily
+-- write budget at once:
+--
+--   -- 1. export, so the raw rows are not simply destroyed. NDJSON to R2.
+--   --    Paged by rowid, 5,000 rows a batch to stay under D1's 1 MB
+--   --    response and 2 MB row limits.
+--   SELECT id, attempt_id, question_id, selected_opt_key, is_correct,
+--          delivered_position, time_ms, revised, answered_at
+--     FROM attempt_answers
+--    WHERE answered_at < CAST(unixepoch('now', '-90 days') * 1000 AS INTEGER)
+--      AND id > ?1                                   -- cursor, 0 on first page
+--    ORDER BY id
+--    LIMIT 5000;
+--
+--   -- 2. delete exactly what was exported, by the id range just read.
+--   DELETE FROM attempt_answers
+--    WHERE id BETWEEN ?1 AND ?2                      -- first/last id of the page
+--      AND answered_at < CAST(unixepoch('now', '-90 days') * 1000 AS INTEGER);
+--
+--   -- 3. the short window for attempts nobody finished.
+--   DELETE FROM attempt_answers
+--    WHERE attempt_id IN (
+--            SELECT id FROM attempts
+--             WHERE status IN ('abandoned', 'expired')
+--               AND started_at < CAST(unixepoch('now', '-7 days') * 1000 AS INTEGER)
+--             LIMIT 200);
+--
+-- After a large purge, compact the FTS index (NQ-11d) -- it is the only
+-- compaction D1 offers and it is cheap.
+--
+-- `attempt_answers_archive` below exists for the case where R2 is not wired up
+-- yet, or where a purge needs to be reversible for a few days. It is in the
+-- SAME database, so moving rows into it frees NO space -- it is a staging
+-- area, not the archive. Step 2 above is the thing that reclaims pages. Do not
+-- let this table become the permanent home for old answers; the job that
+-- drains it to R2 is what makes the ceiling arithmetic above true.
+-- ===========================================================================
+CREATE TABLE attempt_answers_archive (
+  id                 INTEGER NOT NULL PRIMARY KEY,         -- the original attempt_answers.id
+  attempt_id         INTEGER NOT NULL,                     -- soft reference, deliberately unenforced
+  user_id            TEXT    NOT NULL,                     -- denormalised: the attempt may be gone
+  question_id        TEXT    NOT NULL,
+  selected_opt_key   TEXT,
+  is_correct         INTEGER NOT NULL CHECK (is_correct IN (0, 1)),
+  delivered_position INTEGER,
+  time_ms            INTEGER,                                     -- duration, milliseconds
+  answered_at        INTEGER NOT NULL,                            -- epoch ms (UTC)
+  archived_at        INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  -- Where the NDJSON for this row went, once it is in R2. NULL means this row
+  -- is still only in D1 and deleting it would lose data.
+  r2_object_key      TEXT
+) STRICT;
+-- No foreign keys: the point of an archive row is to outlive its parents.
+-- One index only, because this table is written in bulk and read almost never.
+-- NQ-26d archive-drain: SELECT ... WHERE r2_object_key IS NULL ORDER BY id LIMIT ?.
+CREATE INDEX idx_attempt_answers_archive_undrained
+  ON attempt_answers_archive (id) WHERE r2_object_key IS NULL;
diff --git a/worker/migrations/0005_learning.sql b/worker/migrations/0005_learning.sql
new file mode 100644
index 0000000..d9fad4a
--- /dev/null
+++ b/worker/migrations/0005_learning.sql
@@ -0,0 +1,424 @@
+-- 0005_learning.sql
+-- Per-user learning state: bookmarks, spaced repetition, study sessions,
+-- streaks, and the trigger-maintained rollup the progress page reads.
+
+-- ---------------------------------------------------------------------------
+-- bookmarks: "come back to this one". Replaces the `eng_bookmarks`
+-- localStorage array, which stored `{topicId}_{index}` strings and therefore
+-- quietly re-pointed at different questions whenever the bank was edited.
+-- ---------------------------------------------------------------------------
+CREATE TABLE bookmarks (
+  user_id     TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  question_id TEXT    NOT NULL REFERENCES questions (id) ON DELETE CASCADE,
+  note        TEXT,
+  -- Free-text folder. A separate table would be the textbook answer; it would
+  -- also be a join and a second query on a page that exists to show a list,
+  -- and nobody has asked to rename a folder.
+  folder      TEXT,
+  created_at  INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  PRIMARY KEY (user_id, question_id)
+) STRICT;
+
+-- NQ-30 bookmarks-list: SELECT question_id FROM bookmarks WHERE user_id = ?
+--       ORDER BY created_at DESC LIMIT ?. The primary key cannot serve the
+--       sort; this index is covering for it.
+CREATE INDEX idx_bookmarks_user_created ON bookmarks (user_id, created_at DESC);
+
+-- NQ-30b bookmarks-by-folder: ... WHERE user_id = ? AND folder = ?.
+CREATE INDEX idx_bookmarks_user_folder ON bookmarks (user_id, folder)
+  WHERE folder IS NOT NULL;
+
+-- ---------------------------------------------------------------------------
+-- srs_state: one FSRS card per (user, question).
+--
+-- Column names and units are FSRS's, deliberately, so the open-source
+-- scheduler can be dropped in without a translation layer and so a parameter
+-- upgrade does not need a migration:
+--
+--   stability      -- days until recall probability decays to 90%
+--   difficulty     -- 1..10, intrinsic to the item for this user
+--   elapsed_days   -- real days since last_review at the moment of review
+--   scheduled_days -- the interval the scheduler had asked for
+--   reps           -- total reviews
+--   lapses         -- reviews rated 'Again'
+--   state          -- 0 New, 1 Learning, 2 Review, 3 Relearning
+--   due            -- when it next comes up
+--   last_review    -- when it was last graded
+--
+-- REAL, not INTEGER, for the four continuous fields: FSRS's update equations
+-- are continuous and rounding stability to whole days compounds into visibly
+-- wrong intervals after a dozen reviews. REAL is 8 bytes in SQLite, same as
+-- a large INTEGER, so there is nothing to save by rounding.
+--
+-- Scheduling runs in the Worker, not in SQL. FSRS needs `pow` and `exp`;
+-- SQLite's math functions are a compile-time option and D1 does not guarantee
+-- them. The Worker computes the new card and writes it back in one statement.
+-- ---------------------------------------------------------------------------
+CREATE TABLE srs_state (
+  user_id        TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  question_id    TEXT    NOT NULL REFERENCES questions (id) ON DELETE CASCADE,
+  stability      REAL    NOT NULL DEFAULT 0.0 CHECK (stability >= 0.0),
+  difficulty     REAL    NOT NULL DEFAULT 5.0 CHECK (difficulty BETWEEN 1.0 AND 10.0),
+  elapsed_days   REAL    NOT NULL DEFAULT 0.0 CHECK (elapsed_days >= 0.0),
+  scheduled_days REAL    NOT NULL DEFAULT 0.0 CHECK (scheduled_days >= 0.0),
+  reps           INTEGER NOT NULL DEFAULT 0 CHECK (reps >= 0),
+  lapses         INTEGER NOT NULL DEFAULT 0 CHECK (lapses >= 0),
+  state          INTEGER NOT NULL DEFAULT 0 CHECK (state IN (0, 1, 2, 3)),
+  due            INTEGER NOT NULL,                               -- epoch ms (UTC)
+  last_review    INTEGER,                                         -- epoch ms (UTC)
+  -- 1..4 (Again, Hard, Good, Easy). The last rating, kept so the review screen
+  -- can show it and so a scheduler-parameter change can be replayed against
+  -- recent history without the raw answer rows, which archival removes.
+  last_rating    INTEGER CHECK (last_rating IS NULL OR last_rating BETWEEN 1 AND 4),
+  -- Suspended cards stay out of the due queue without losing their history.
+  suspended_at   INTEGER,                                         -- epoch ms (UTC)
+  created_at     INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  updated_at     INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  PRIMARY KEY (user_id, question_id),
+  CHECK (lapses <= reps),
+  CHECK (reps = 0 OR last_review IS NOT NULL)
+) STRICT;
+
+-- NQ-29 srs-due-queue, the query the review screen opens with:
+--   SELECT question_id FROM srs_state
+--    WHERE user_id = ?1 AND due <= ?2 AND suspended_at IS NULL
+--    ORDER BY due LIMIT ?3;
+-- Partial on suspended_at so suspended cards are not merely filtered out but
+-- absent from the index.
+CREATE INDEX idx_srs_state_user_due ON srs_state (user_id, due)
+  WHERE suspended_at IS NULL;
+
+-- NQ-29b srs-forecast: SELECT date(due / 1000, 'unixepoch') d, COUNT(*) FROM srs_state
+--        WHERE user_id = ? AND due BETWEEN ? AND ? GROUP BY d -- the "how much
+--        work is coming" chart. Served by the same index.
+
+-- ---------------------------------------------------------------------------
+-- study_sessions: a contiguous block of studying, for the activity heatmap and
+-- for time-on-task reporting.
+--
+-- Distinct from `attempts`: an attempt is a graded artefact with a score, a
+-- session is wall-clock engagement. One session can contain several attempts
+-- (a student doing three chapters back to back) and a session can contain no
+-- attempt at all (reading explanations, browsing bookmarks), which is exactly
+-- the activity a study tracker should not throw away.
+-- ---------------------------------------------------------------------------
+CREATE TABLE study_sessions (
+  id                INTEGER NOT NULL PRIMARY KEY,
+  public_id         TEXT    NOT NULL,
+  user_id           TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  kind              TEXT    NOT NULL
+                            CHECK (kind IN ('practice', 'mock', 'review', 'srs', 'reading')),
+  chapter_id        TEXT    REFERENCES chapters (id) ON DELETE SET NULL,
+  subchapter_id     TEXT    REFERENCES subchapters (id) ON DELETE SET NULL,
+  -- Soft reference to attempts.id. Unenforced on purpose: a session is
+  -- activity history and must survive an attempt being deleted.
+  attempt_id        INTEGER,
+  started_at        INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  ended_at          INTEGER,                                      -- epoch ms (UTC)
+  -- Generated so "time studied" is never a client-supplied number.
+  duration_s        INTEGER GENERATED ALWAYS AS (                 -- duration, whole seconds
+                      CASE WHEN ended_at IS NULL THEN 0 ELSE (ended_at - started_at) / 1000 END
+                    ) STORED,
+  questions_seen    INTEGER NOT NULL DEFAULT 0 CHECK (questions_seen >= 0),
+  questions_correct INTEGER NOT NULL DEFAULT 0 CHECK (questions_correct >= 0),
+  -- The calendar day this session is credited to, in the USER's timezone, not
+  -- UTC. Written by the API, which knows the timezone; a generated column
+  -- would have to assume UTC and would misattribute every late-night session
+  -- in Kathmandu (UTC+05:45) to the wrong day, which is precisely the bug that
+  -- breaks a streak.
+  local_date        TEXT    NOT NULL
+                            CHECK (local_date GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]'),
+  CHECK (questions_correct <= questions_seen),
+  CHECK (ended_at IS NULL OR ended_at >= started_at)
+) STRICT;
+
+CREATE UNIQUE INDEX uq_study_sessions_public_id ON study_sessions (public_id);
+
+-- NQ-31 study-history: SELECT ... FROM study_sessions WHERE user_id = ?
+--       ORDER BY started_at DESC LIMIT ?.
+CREATE INDEX idx_study_sessions_user_started
+  ON study_sessions (user_id, started_at DESC);
+
+-- NQ-31b activity-heatmap, one query for a year of squares:
+--   SELECT local_date, SUM(duration_s), SUM(questions_seen)
+--     FROM study_sessions
+--    WHERE user_id = ?1 AND local_date >= ?2
+--    GROUP BY local_date;
+-- Covering, so the heatmap is an index-only scan.
+CREATE INDEX idx_study_sessions_user_local_date
+  ON study_sessions (user_id, local_date, duration_s, questions_seen);
+
+-- NQ-31c open-session: SELECT id FROM study_sessions
+--        WHERE user_id = ? AND ended_at IS NULL ORDER BY started_at DESC LIMIT 1.
+CREATE INDEX idx_study_sessions_open ON study_sessions (user_id, started_at DESC)
+  WHERE ended_at IS NULL;
+
+-- ---------------------------------------------------------------------------
+-- streaks: one row per user.
+--
+-- `last_active_date` is a TEXT calendar day in the user's timezone, not a
+-- timestamp, because a streak is a statement about days and UTC midnight is
+-- not a day boundary for anyone on this platform (Nepal is UTC+05:45, so a
+-- UTC-based streak would break for any student studying after 18:15 local).
+--
+-- Maintained by the API, not by a trigger, for the same reason: resolving
+-- "what day is it for this user" needs the timezone from user_profiles and a
+-- real timezone database, and SQLite's date functions only know UTC and
+-- fixed offsets. ?2 below is that resolved local date, 'YYYY-MM-DD'.
+--
+-- NQ-32a streak-touch. Idempotent: called on every answer, it moves the streak
+-- at most once per local day, so a double-submit or a retry cannot
+-- double-count. `longest_length` is NOT set here -- the trigger below owns it,
+-- so the caller cannot get the "ratchet the record" arithmetic wrong:
+--
+--   INSERT INTO streaks (user_id, current_length, last_active_date,
+--                        total_active_days)
+--   VALUES (?1, 1, ?2, 1)
+--   ON CONFLICT (user_id) DO UPDATE SET
+--     current_length = CASE
+--       WHEN last_active_date = ?2                     THEN current_length
+--       WHEN last_active_date = date(?2, '-1 day')     THEN current_length + 1
+--       WHEN freezes_available > 0
+--            AND last_active_date = date(?2, '-2 day') THEN current_length + 1
+--       ELSE 1 END,
+--     freezes_available = CASE
+--       WHEN last_active_date = date(?2, '-2 day') AND freezes_available > 0
+--            THEN freezes_available - 1 ELSE freezes_available END,
+--     total_active_days = total_active_days
+--       + CASE WHEN last_active_date IS NULL OR last_active_date <> ?2
+--              THEN 1 ELSE 0 END,
+--     last_active_date  = ?2,
+--     updated_at        = CAST(unixepoch('subsec') * 1000 AS INTEGER)
+--   WHERE last_active_date IS NULL OR last_active_date <= ?2;
+--                                     -- never let a stale request move it back
+-- ---------------------------------------------------------------------------
+CREATE TABLE streaks (
+  user_id           TEXT    NOT NULL PRIMARY KEY REFERENCES users (id) ON DELETE CASCADE,
+  current_length    INTEGER NOT NULL DEFAULT 0 CHECK (current_length >= 0),
+  longest_length    INTEGER NOT NULL DEFAULT 0 CHECK (longest_length >= 0),
+  last_active_date  TEXT    CHECK (last_active_date IS NULL
+                                   OR last_active_date GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]'),
+  total_active_days INTEGER NOT NULL DEFAULT 0 CHECK (total_active_days >= 0),
+  -- A one-day grace token, so a single missed day does not erase six weeks of
+  -- work. Earned, spent by the upsert above.
+  freezes_available INTEGER NOT NULL DEFAULT 0 CHECK (freezes_available BETWEEN 0 AND 3),
+  updated_at        INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  -- Note there is deliberately NO `longest_length >= current_length` CHECK.
+  -- NQ-32a raises current_length without touching longest_length, so such a
+  -- CHECK would reject the very statement that extends a streak. The invariant
+  -- is maintained one statement later, by the trigger below.
+  CHECK (current_length <= total_active_days)
+) STRICT;
+
+-- `longest_length` is a ratchet and this trigger owns it, because the obvious
+-- hand-written version is wrong: inside an UPDATE,
+-- `longest_length = max(longest_length, current_length)` reads the OLD
+-- current_length and so lags a day behind the streak it is supposed to record.
+--
+-- It is a trigger rather than a CHECK because the two cannot coexist: column
+-- CHECKs are evaluated before any AFTER trigger runs, so a
+-- `longest_length >= current_length` constraint would reject NQ-32a's row
+-- before this trigger ever got the chance to repair it. A BEFORE trigger is no
+-- help either -- SQLite cannot rewrite NEW. So the invariant is eventually
+-- consistent across two statements of one transaction, which is exactly as
+-- consistent as it needs to be for a number shown on a profile page.
+CREATE TRIGGER streaks_longest_ratchet
+AFTER UPDATE OF current_length ON streaks
+WHEN NEW.current_length > NEW.longest_length
+BEGIN
+  UPDATE streaks SET longest_length = NEW.current_length WHERE user_id = NEW.user_id;
+END;
+
+-- NQ-32b streak-leaderboard-source (snapshot cron only):
+--   SELECT user_id, current_length FROM streaks ORDER BY current_length DESC LIMIT ?.
+CREATE INDEX idx_streaks_current_length ON streaks (current_length DESC)
+  WHERE current_length > 0;
+
+-- ===========================================================================
+-- user_question_stats: THE ROLLUP THE PROGRESS PAGE READS.
+--
+-- One row per (user, question) the user has ever been shown. Maintained by the
+-- triggers below, which means:
+--
+--   * the progress page is ONE indexed read, not an aggregate over the answer
+--     log. `chapter_id` and `subchapter_id` are denormalised onto this row
+--     specifically so that read needs no join:
+--
+--       NQ-27 progress-page:
+--         SELECT chapter_id,
+--                COUNT(*)                        AS seen,
+--                SUM(correct_count > 0)          AS ever_correct,
+--                SUM(answer_count)               AS answers,
+--                SUM(correct_count)              AS corrects
+--           FROM user_question_stats
+--          WHERE user_id = ?1
+--          GROUP BY chapter_id;
+--
+--     Ten groups, one index range scan, covering. The alternative -- scanning
+--     a user's rows in attempt_answers -- grows without bound and stops
+--     working entirely once archival deletes those rows.
+--
+--   * the rollup is kept inside the statement that writes the answer. D1
+--     allows 50 queries per Worker invocation; a handler that updated this
+--     table itself would spend two or three of them on bookkeeping per
+--     answer, and would be wrong the first time an error path returned early.
+--
+-- WHAT IS DELIBERATELY ABSENT: there is NO DELETE trigger on attempt_answers.
+-- Archival (0004) deletes millions of answer rows; a delete trigger that
+-- decremented these counters would silently erase every student's entire
+-- progress history the first night the retention job ran. The rollup is an
+-- append-only summary of what happened, not a cache of what is still stored.
+-- If you add a delete trigger here, you have deleted the product.
+-- ===========================================================================
+CREATE TABLE user_question_stats (
+  user_id             TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  question_id         TEXT    NOT NULL REFERENCES questions (id) ON DELETE CASCADE,
+  -- Denormalised from `questions` by the trigger. Makes NQ-27 join-free.
+  -- Drifts only if a question is moved between chapters, which is an admin
+  -- action that must re-stamp these rows (NQ-27c below).
+  chapter_id          TEXT    NOT NULL,
+  subchapter_id       TEXT,
+  -- Times the question was put in front of the user, including skips.
+  exposure_count      INTEGER NOT NULL DEFAULT 0 CHECK (exposure_count >= 0),
+  -- Times an option was actually chosen.
+  answer_count        INTEGER NOT NULL DEFAULT 0 CHECK (answer_count >= 0),
+  correct_count       INTEGER NOT NULL DEFAULT 0 CHECK (correct_count >= 0),
+  consecutive_correct INTEGER NOT NULL DEFAULT 0 CHECK (consecutive_correct >= 0),
+  -- Basis points so it is exact and indexable. STORED, because it is the sort
+  -- key for the weak-areas queue (NQ-28).
+  accuracy_bp         INTEGER GENERATED ALWAYS AS (
+                        CASE WHEN answer_count = 0 THEN 0
+                             ELSE (correct_count * 10000) / answer_count END
+                      ) STORED,
+  first_answered_at   INTEGER,                                    -- epoch ms (UTC)
+  last_answered_at    INTEGER,                                    -- epoch ms (UTC)
+  last_is_correct     INTEGER CHECK (last_is_correct IS NULL OR last_is_correct IN (0, 1)),
+  updated_at          INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  PRIMARY KEY (user_id, question_id),
+  CHECK (answer_count <= exposure_count),
+  CHECK (correct_count <= answer_count),
+  CHECK (consecutive_correct <= correct_count)
+) STRICT;
+
+-- NQ-27 progress-page (above). Covering: every column the query reads is in
+-- the index, so it never touches the table.
+CREATE INDEX idx_user_question_stats_user_chapter
+  ON user_question_stats (user_id, chapter_id, correct_count, answer_count);
+
+-- NQ-27b progress-page-by-subchapter: same shape, narrowed to one chapter's
+--        six syllabus codes.
+CREATE INDEX idx_user_question_stats_user_subchapter
+  ON user_question_stats (user_id, subchapter_id, correct_count, answer_count)
+  WHERE subchapter_id IS NOT NULL;
+
+-- NQ-28 weak-areas: SELECT question_id FROM user_question_stats
+--       WHERE user_id = ?1 AND answer_count > 0 AND accuracy_bp <= ?2
+--       ORDER BY accuracy_bp, last_answered_at LIMIT ?3
+--       -- feeds the 'weak_areas' attempt mode.
+CREATE INDEX idx_user_question_stats_user_accuracy
+  ON user_question_stats (user_id, accuracy_bp, last_answered_at)
+  WHERE answer_count > 0;
+
+-- NQ-27c rechapter-stats, after an admin moves a question between chapters:
+--   UPDATE user_question_stats
+--      SET chapter_id = ?2, subchapter_id = ?3
+--    WHERE question_id = ?1;
+-- Served by the index below, which is the only reason it exists -- without it
+-- that UPDATE is a full table scan over every user's rows.
+CREATE INDEX idx_user_question_stats_question ON user_question_stats (question_id);
+
+-- ---------------------------------------------------------------------------
+-- Rollup triggers.
+-- ---------------------------------------------------------------------------
+
+-- A new answer row is a new exposure. `attempt_count` on the attempt and the
+-- per-question stats move together, inside the insert.
+CREATE TRIGGER attempt_answers_ai_rollup
+AFTER INSERT ON attempt_answers
+BEGIN
+  INSERT INTO user_question_stats (
+    user_id, question_id, chapter_id, subchapter_id,
+    exposure_count, answer_count, correct_count, consecutive_correct,
+    first_answered_at, last_answered_at, last_is_correct, updated_at
+  )
+  SELECT
+    a.user_id, NEW.question_id, q.chapter_id, q.subchapter_id,
+    1,
+    CASE WHEN NEW.selected_opt_key IS NULL THEN 0 ELSE 1 END,
+    NEW.is_correct,
+    NEW.is_correct,
+    CASE WHEN NEW.selected_opt_key IS NULL THEN NULL ELSE NEW.answered_at END,
+    CASE WHEN NEW.selected_opt_key IS NULL THEN NULL ELSE NEW.answered_at END,
+    CASE WHEN NEW.selected_opt_key IS NULL THEN NULL ELSE NEW.is_correct END,
+    CAST(unixepoch('subsec') * 1000 AS INTEGER)
+  FROM attempts a
+  JOIN questions q ON q.id = NEW.question_id
+  WHERE a.id = NEW.attempt_id
+  ON CONFLICT (user_id, question_id) DO UPDATE SET
+    exposure_count      = exposure_count + 1,
+    answer_count        = answer_count
+                          + CASE WHEN NEW.selected_opt_key IS NULL THEN 0 ELSE 1 END,
+    correct_count       = correct_count + NEW.is_correct,
+    consecutive_correct = CASE WHEN NEW.is_correct = 1
+                               THEN consecutive_correct + 1 ELSE 0 END,
+    first_answered_at   = COALESCE(first_answered_at,
+                                   CASE WHEN NEW.selected_opt_key IS NULL
+                                        THEN NULL ELSE NEW.answered_at END),
+    last_answered_at    = CASE WHEN NEW.selected_opt_key IS NULL
+                               THEN last_answered_at ELSE NEW.answered_at END,
+    last_is_correct     = CASE WHEN NEW.selected_opt_key IS NULL
+                               THEN last_is_correct ELSE NEW.is_correct END,
+    updated_at          = CAST(unixepoch('subsec') * 1000 AS INTEGER);
+
+  UPDATE attempts
+     SET answered_count = answered_count
+                        + CASE WHEN NEW.selected_opt_key IS NULL THEN 0 ELSE 1 END,
+         correct_count  = correct_count + NEW.is_correct
+   WHERE id = NEW.attempt_id;
+END;
+
+-- A revision (the ON CONFLICT DO UPDATE arm of NQ-25) is not a new exposure.
+-- Only the correctness facts move, and they move by delta so the counters stay
+-- consistent however many times a student changes their mind.
+CREATE TRIGGER attempt_answers_au_rollup
+AFTER UPDATE OF selected_opt_key, is_correct ON attempt_answers
+BEGIN
+  UPDATE attempts
+     SET answered_count = answered_count
+                        + CASE WHEN NEW.selected_opt_key IS NULL THEN 0 ELSE 1 END
+                        - CASE WHEN OLD.selected_opt_key IS NULL THEN 0 ELSE 1 END,
+         correct_count  = correct_count + NEW.is_correct - OLD.is_correct
+   WHERE id = NEW.attempt_id;
+
+  UPDATE user_question_stats
+     SET answer_count        = answer_count
+                             + CASE WHEN NEW.selected_opt_key IS NULL THEN 0 ELSE 1 END
+                             - CASE WHEN OLD.selected_opt_key IS NULL THEN 0 ELSE 1 END,
+         correct_count       = correct_count + NEW.is_correct - OLD.is_correct,
+         consecutive_correct = CASE
+                                 WHEN NEW.is_correct = OLD.is_correct THEN consecutive_correct
+                                 WHEN NEW.is_correct = 1              THEN consecutive_correct + 1
+                                 ELSE 0
+                               END,
+         first_answered_at   = COALESCE(first_answered_at,
+                                        CASE WHEN NEW.selected_opt_key IS NULL
+                                             THEN NULL ELSE NEW.answered_at END),
+         last_answered_at    = CASE WHEN NEW.selected_opt_key IS NULL
+                                    THEN last_answered_at ELSE NEW.answered_at END,
+         last_is_correct     = CASE WHEN NEW.selected_opt_key IS NULL
+                                    THEN last_is_correct ELSE NEW.is_correct END,
+         updated_at          = CAST(unixepoch('subsec') * 1000 AS INTEGER)
+   WHERE question_id = NEW.question_id
+     AND user_id = (SELECT user_id FROM attempts WHERE id = NEW.attempt_id);
+END;
+
+-- tags.question_count is a display counter on the tag picker. Kept by trigger
+-- for the same reason as everything else in this file: it is one more query
+-- the handler does not have to spend from its budget of 50.
+CREATE TRIGGER question_tags_ai_count AFTER INSERT ON question_tags BEGIN
+  UPDATE tags SET question_count = question_count + 1 WHERE id = NEW.tag_id;
+END;
+
+CREATE TRIGGER question_tags_ad_count AFTER DELETE ON question_tags BEGIN
+  UPDATE tags SET question_count = max(0, question_count - 1) WHERE id = OLD.tag_id;
+END;
diff --git a/worker/migrations/0006_engagement.sql b/worker/migrations/0006_engagement.sql
new file mode 100644
index 0000000..75bf850
--- /dev/null
+++ b/worker/migrations/0006_engagement.sql
@@ -0,0 +1,200 @@
+-- 0006_engagement.sql
+-- Precomputed leaderboards and notifications.
+
+-- ===========================================================================
+-- LEADERBOARDS ARE PRECOMPUTED. NEVER AGGREGATE THE ANSWER LOG LIVE.
+--
+-- The naive leaderboard is
+--
+--   SELECT user_id, SUM(is_correct) FROM attempt_answers GROUP BY user_id
+--   ORDER BY 2 DESC LIMIT 50;
+--
+-- which is a full scan of the largest table on the platform, on a database
+-- that is single-threaded per instance (D1 serialises writes and runs about
+-- 1,000 queries/second at 1 ms each). At 3 million answer rows that scan is
+-- seconds long, it blocks every write behind it, it bills 3 million of the
+-- free plan's 5 million daily row reads per page view, and it gets slower
+-- every day. One student refreshing a leaderboard would be a platform-wide
+-- outage. It also stops being correct the moment archival (0004) deletes old
+-- answers.
+--
+-- So: a cron Worker computes a snapshot on a schedule, writes the ranking
+-- once, and every request reads the finished rows. SQLite has no materialised
+-- views, so the snapshot IS the table.
+--
+-- Two tables rather than one, because there are two readers with different
+-- shapes:
+--   * `leaderboard_snapshots` -- metadata plus a `top_json` payload, so
+--     rendering the visible top 50 is a single row read: one query, one row,
+--     no sort, no join.
+--   * `leaderboard_entries` -- one row per ranked user, so "you are 312th of
+--     1,480" is a primary-key hit rather than a scan of the payload. Without
+--     this table, the only way to answer it is to rank everyone at request
+--     time, which is the thing this whole file exists to avoid.
+-- ===========================================================================
+
+CREATE TABLE leaderboard_snapshots (
+  id            INTEGER NOT NULL PRIMARY KEY,
+  -- What is being ranked.
+  scope         TEXT    NOT NULL
+                        CHECK (scope IN ('global', 'chapter', 'subchapter', 'template')),
+  -- The chapter/subchapter/template id for a narrowed board; '' for global.
+  -- Empty string rather than NULL so the unique index below works without
+  -- SQLite's NULL-distinctness rules letting duplicates in.
+  scope_ref     TEXT    NOT NULL DEFAULT '',
+  period        TEXT    NOT NULL
+                        CHECK (period IN ('daily', 'weekly', 'monthly', 'all_time')),
+  -- First calendar day of the period, in the platform timezone. 'all_time'
+  -- uses '0001-01-01' so the column is never NULL and ordering still works.
+  period_start  TEXT    NOT NULL
+                        CHECK (period_start GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]'),
+  -- What the ranking sorts on. Recorded because changing it silently would
+  -- make two snapshots incomparable.
+  metric        TEXT    NOT NULL DEFAULT 'correct_answers'
+                        CHECK (metric IN ('correct_answers', 'accuracy_bp',
+                                          'questions_answered', 'streak_length',
+                                          'mock_score_bp')),
+  -- Rendered top-N, in rank order:
+  --   [{"rank":1,"user_id":"...","display_name":"...","avatar_url":null,
+  --     "score":4821,"accuracy_bp":7340}, ...]
+  -- Denormalised display fields on purpose: the leaderboard must render
+  -- without joining `user_profiles`, so one query serves the whole page, and
+  -- a user who later opts out of leaderboards is removed at the next snapshot
+  -- rather than leaving a hole in a join.
+  top_json      TEXT    NOT NULL CHECK (json_valid(top_json)
+                                        AND json_type(top_json) = 'array'),
+  entrant_count INTEGER NOT NULL DEFAULT 0 CHECK (entrant_count >= 0),
+  computed_at   INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  -- How long the computation took. Kept because this job is the one thing on
+  -- the platform allowed to scan a large table, and the day it gets slow is
+  -- the day the ceiling arithmetic in 0004 needs revisiting.
+  compute_ms    INTEGER,                                          -- duration, milliseconds
+  CHECK (period = 'all_time' OR period_start <> '0001-01-01'),
+  CHECK ((scope = 'global') = (scope_ref = ''))
+) STRICT;
+
+-- NQ-35 latest-snapshot: SELECT id, top_json, entrant_count, computed_at
+--       FROM leaderboard_snapshots
+--      WHERE scope = ?1 AND scope_ref = ?2 AND period = ?3
+--      ORDER BY period_start DESC LIMIT 1.
+-- Unique as well as indexed: the cron is at-least-once, and a retry must
+-- overwrite the snapshot (ON CONFLICT DO UPDATE) rather than add a second one
+-- that the query above would then pick between arbitrarily.
+CREATE UNIQUE INDEX uq_leaderboard_snapshots_scope_period
+  ON leaderboard_snapshots (scope, scope_ref, period, period_start);
+
+-- NQ-35c snapshot-prune (cron): DELETE FROM leaderboard_snapshots
+--        WHERE computed_at < ? AND period <> 'all_time'.
+CREATE INDEX idx_leaderboard_snapshots_computed_at
+  ON leaderboard_snapshots (computed_at);
+
+-- ---------------------------------------------------------------------------
+-- leaderboard_entries: the full ranking behind one snapshot.
+--
+-- Bounded, unlike attempt_answers: rows = snapshots retained x opted-in users.
+-- With daily/weekly/monthly global boards plus ten chapter boards, pruned to
+-- 30 days, that is roughly 13 boards x 30 snapshots x entrants. At 1,000
+-- opted-in users that is ~390k rows of about 60 bytes, so ~25 MB -- which is
+-- why NQ-35c prunes and why `period = 'all_time'` is exempt from the prune.
+-- ---------------------------------------------------------------------------
+CREATE TABLE leaderboard_entries (
+  -- leaderboard_snapshots.id. NOT a foreign key -- see the note below.
+  snapshot_id INTEGER NOT NULL,
+  rank        INTEGER NOT NULL CHECK (rank >= 1),
+  user_id     TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  score       INTEGER NOT NULL,
+  accuracy_bp INTEGER CHECK (accuracy_bp IS NULL OR accuracy_bp BETWEEN 0 AND 10000),
+  -- Rank in the previous snapshot of the same board, so the UI can show a
+  -- movement arrow without reading two snapshots.
+  prev_rank   INTEGER CHECK (prev_rank IS NULL OR prev_rank >= 1),
+  PRIMARY KEY (snapshot_id, rank)
+) STRICT;
+
+-- NQ-33 leaderboard-page: SELECT rank, user_id, score FROM leaderboard_entries
+--       WHERE snapshot_id = ?1 AND rank > ?2 ORDER BY rank LIMIT ?3
+--       -- paging deeper than the `top_json` payload. Served by the primary
+--       key, no sort.
+--
+-- NQ-34 my-rank: SELECT rank, score, prev_rank FROM leaderboard_entries
+--       WHERE snapshot_id = ?1 AND user_id = ?2.
+-- Unique, because one user cannot hold two ranks on one board, and making
+-- that a constraint means a buggy snapshot job fails rather than ships a
+-- leaderboard where somebody appears twice.
+CREATE UNIQUE INDEX uq_leaderboard_entries_snapshot_user
+  ON leaderboard_entries (snapshot_id, user_id);
+
+-- NQ-34b my-boards: SELECT snapshot_id, rank FROM leaderboard_entries
+--        WHERE user_id = ? -- "where do I stand everywhere", and the index
+--        that makes deleting a departing user's entries cheap.
+CREATE INDEX idx_leaderboard_entries_user ON leaderboard_entries (user_id);
+
+-- `snapshot_id` is deliberately NOT a foreign key. The prune (NQ-35c) deletes
+-- snapshots in bulk; an ON DELETE CASCADE would turn each of those deletes
+-- into an unbounded child delete inside one statement, which is exactly the
+-- shape that blows D1's per-query time limit. Instead the job deletes children
+-- first, in bounded batches it controls:
+--
+--   NQ-35d entries-prune, run BEFORE NQ-35c or the entries are orphaned:
+--     DELETE FROM leaderboard_entries
+--      WHERE snapshot_id IN (SELECT id FROM leaderboard_snapshots
+--                             WHERE computed_at < ?1 AND period <> 'all_time'
+--                             LIMIT 50);
+
+-- ---------------------------------------------------------------------------
+-- notifications: in-app only. No email, no push -- those are a delivery
+-- concern and belong to a queue, not to a table a page reads.
+--
+-- Bounded by `expires_at` plus the prune below. A notification nobody reads is
+-- not evidence of anything, so unlike attempt_answers these rows are deleted
+-- outright rather than archived.
+-- ---------------------------------------------------------------------------
+CREATE TABLE notifications (
+  id         INTEGER NOT NULL PRIMARY KEY,
+  user_id    TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  kind       TEXT    NOT NULL
+                     CHECK (kind IN ('streak_risk', 'streak_milestone',
+                                     'srs_due', 'mock_result', 'report_resolved',
+                                     'contribution_reviewed', 'leaderboard_move',
+                                     'announcement')),
+  title      TEXT    NOT NULL,
+  body       TEXT,
+  -- Route the notification deep-links to, e.g. '/app/attempt/01HX...'.
+  link       TEXT,
+  -- Small JSON bag of render parameters. Never business state.
+  data_json  TEXT    CHECK (data_json IS NULL OR json_valid(data_json)),
+  read_at    INTEGER,                                             -- epoch ms (UTC)
+  created_at INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  expires_at INTEGER,                                             -- epoch ms (UTC)
+  -- Idempotency key, so the cron that says "your streak is at risk" cannot say
+  -- it twice. Format: kind || ':' || natural key, e.g. 'srs_due:2026-10-20'.
+  dedupe_key TEXT,
+  CHECK (length(trim(title)) > 0),
+  CHECK (expires_at IS NULL OR expires_at > created_at)
+) STRICT;
+
+-- NQ-36 unread-notifications: SELECT id, kind, title, body, link, created_at
+--       FROM notifications WHERE user_id = ?1 AND read_at IS NULL
+--       ORDER BY created_at DESC LIMIT ?2.
+-- Partial on read_at: the index holds only the rows the bell badge counts, so
+-- it stays small no matter how much history a user accumulates.
+CREATE INDEX idx_notifications_user_unread
+  ON notifications (user_id, created_at DESC) WHERE read_at IS NULL;
+
+-- NQ-36b notification-history: ... WHERE user_id = ? ORDER BY id DESC LIMIT ?.
+CREATE INDEX idx_notifications_user ON notifications (user_id, id DESC);
+
+-- NQ-36c notification-dedupe, the insert the cron actually issues. Note the
+-- repeated WHERE clause: SQLite matches a conflict target to a PARTIAL unique
+-- index only if the index predicate is restated, and omitting it fails at
+-- prepare() time with 'ON CONFLICT clause does not match any PRIMARY KEY or
+-- UNIQUE constraint' rather than at review time:
+--   INSERT INTO notifications (user_id, kind, title, dedupe_key, expires_at)
+--   VALUES (?1, ?2, ?3, ?4, ?5)
+--   ON CONFLICT (user_id, dedupe_key) WHERE dedupe_key IS NOT NULL DO NOTHING;
+CREATE UNIQUE INDEX uq_notifications_user_dedupe
+  ON notifications (user_id, dedupe_key) WHERE dedupe_key IS NOT NULL;
+
+-- NQ-36d notification-prune (cron): DELETE FROM notifications
+--        WHERE expires_at < CAST(unixepoch('subsec') * 1000 AS INTEGER) LIMIT ?.
+CREATE INDEX idx_notifications_expires_at ON notifications (expires_at)
+  WHERE expires_at IS NOT NULL;
diff --git a/worker/migrations/0007_reference_data.sql b/worker/migrations/0007_reference_data.sql
new file mode 100644
index 0000000..2031457
--- /dev/null
+++ b/worker/migrations/0007_reference_data.sql
@@ -0,0 +1,312 @@
+-- 0007_reference_data.sql
+--
+-- GENERATED, then reviewed and committed. The source of truth for the official
+-- NEC syllabus in this repo was, until now, a 10-element array literal inside
+-- a React component (frontend/src/pages/app/BookPractice.tsx) plus a second
+-- array generated from the question files
+-- (frontend/src/data/bookChapters.generated.ts). This migration lifts both
+-- into the database once, so there is one copy of the syllabus and the client
+-- reads it instead of shipping it.
+--
+-- It is a migration rather than a seed script because it is reference data:
+-- ten chapters and sixty syllabus codes published by a regulator. It changes
+-- when NEC changes the syllabus, which is a versioned event and exactly what a
+-- migration is for. The 2,290 questions are NOT here -- they are bulk data and
+-- they load through worker/db/seed/import-questions.mjs.
+--
+-- Reproduce with: node worker/db/seed/generate-reference-sql.mjs
+-- which re-extracts from the two frontend files and overwrites this file.
+-- Verified at generation time: 10 chapters, 60 subchapters.
+
+INSERT INTO subjects (id, code, name, description, exam_board, ordinal, status) VALUES
+  ('nec-computer', 'NEC-CE',
+   'NEC Registration Exam -- Computer Engineering',
+   'Nepal Engineering Council registration examination syllabus for Computer Engineering (AExE / ACtE / AALL paper codes).',
+   'Nepal Engineering Council', 1, 'published');
+
+
+-- Chapters. `id` keeps the existing frontend identifier so client routes and
+-- stored progress keys survive the cutover. `title` is the official NEC
+-- syllabus title, `display_name` the shorter string the practice cards show.
+INSERT INTO chapters (id, subject_id, nec_code, ordinal, slug, title, display_name,
+                      short_name, description, color, icon, legacy_data_file, status) VALUES
+  ('book-ch1', 'nec-computer', 'AExE01', 1, 'concept-of-basic-electrical-and-electronics-engineering',
+   'Concept of Basic Electrical and Electronics Engineering',
+   'Chapter 1: Basic Electrical & Electronics',
+   'Ch1 - Basic Electrical & Electronics',
+   'Ohm''s Law, circuit analysis, AC/DC circuits and electronic components',
+   '#f59e0b', 'chip', 'books/ch1.json', 'published'),
+  ('book-ch2', 'nec-computer', 'AExE02', 2, 'digital-logic-and-microprocessor',
+   'Digital Logic and Microprocessor',
+   'Chapter 2: Digital Logic & Number Systems',
+   'Ch2 - Digital Logic & Number Systems',
+   'Number systems, Boolean algebra, logic gates and digital electronics',
+   '#6366f1', 'chip', 'books/ch2.json', 'published'),
+  ('book-ch3', 'nec-computer', 'ACtE03', 3, 'programming-language-and-its-applications',
+   'Programming Language and Its Applications',
+   'Chapter 3: C / C++ Programming',
+   'Ch3 - C / C++ Programming',
+   'C and C++ fundamentals, pointers, data types and OOP concepts',
+   '#22c55e', 'code', 'books/ch3.json', 'published'),
+  ('book-ch4', 'nec-computer', 'ACtE04', 4, 'computer-organization-and-embedded-system',
+   'Computer Organization and Embedded System',
+   'Chapter 4: Computer Organization & Embedded Systems',
+   'Ch4 - Computer Organization & Embedded',
+   'CPU architecture, cache, memory hierarchy, RISC/CISC and embedded systems',
+   '#ec4899', 'cpu', 'books/ch4.json', 'published'),
+  ('book-ch5', 'nec-computer', 'ACtE05', 5, 'concept-of-computer-network-and-network-security-system',
+   'Concept of Computer Network and Network Security System',
+   'Chapter 5: Computer Networks & Security',
+   'Ch5 - Computer Networks & Security',
+   'Network protocols, OSI model and network security concepts',
+   '#06b6d4', 'brain', 'books/ch5.json', 'published'),
+  ('book-ch6', 'nec-computer', 'ACtE06', 6, 'theory-of-computation-and-computer-graphics',
+   'Theory of Computation and Computer Graphics',
+   'Chapter 6: Theory of Computation and Computer Graphics',
+   'Ch6 - Theory of Computation and Computer Graphics',
+   'Finite automata, CFGs, Turing machines, 2D/3D transformations and graphics',
+   '#a855f7', 'network', 'books/ch6.json', 'published'),
+  ('book-ch7', 'nec-computer', 'ACtE07', 7, 'data-structures-and-algorithm-database-system-and-operating-',
+   'Data Structures and Algorithm, Database System and Operating System',
+   'Chapter 7: DSA, DBMS and OS',
+   'Ch7 - DSA, DBMS and OS',
+   'Data structures, algorithms, database systems and operating systems',
+   '#f97316', 'monitor', 'books/ch7.json', 'published'),
+  ('book-ch8', 'nec-computer', 'ACtE08', 8, 'software-engineering-and-object-oriented-analysis-design',
+   'Software Engineering and Object-Oriented Analysis & Design',
+   'Chapter 8: Software Engineering and Object-Oriented Analysis & Design',
+   'Ch8 - Software Engineering and Object-Oriented Analysis & Design',
+   'Software processes, testing, UML, design patterns and OOAD',
+   '#10b981', 'calculator', 'books/ch8.json', 'published'),
+  ('book-ch9', 'nec-computer', 'ACtE09', 9, 'artificial-intelligence-and-neural-networks',
+   'Artificial Intelligence and Neural Networks',
+   'Chapter 9: AI & Machine Learning',
+   'Ch9 - AI & Machine Learning',
+   'Artificial intelligence, neural networks and machine learning concepts',
+   '#3b82f6', 'book', 'books/ch9.json', 'published'),
+  ('book-ch10', 'nec-computer', 'AALL10', 10, 'project-planning-design-and-implementation',
+   'Project Planning, Design and Implementation',
+   'Chapter 10: Project Planning, Design and Implementation',
+   'Ch10 - Project Planning, Design and Implementation',
+   'Engineering drawings, economics, project management and professional practice',
+   '#8b5cf6', 'settings', 'books/ch10.json', 'published');
+
+
+-- The 60 official syllabus codes, 1.1 .. 10.6. `description` is the NEC
+-- syllabus paragraph verbatim: it is the authoritative statement of what is
+-- examinable, and paraphrasing it would be a silent change to the spec.
+INSERT INTO subchapters (id, chapter_id, code, ordinal, title, description, status) VALUES
+  ('nec-1.1', 'book-ch1', '1.1', 1,
+   'Basic Concept',
+   'Ohm''s law, electric voltage, current, power and energy, conducting and insulating materials. Series and parallel electric circuits, star-delta and delta-star conversion, Kirchhoff''s law, linear and non-linear circuit, bilateral and unilateral circuits, active and passive circuits.', 'published'),
+  ('nec-1.2', 'book-ch1', '1.2', 2,
+   'Network Theorems',
+   'Superposition theorem, Thevenin''s theorem, Norton''s theorem, maximum power transfer theorem. R-L, R-C, R-L-C circuits, resonance in AC series and parallel circuit, active and reactive power.', 'published'),
+  ('nec-1.3', 'book-ch1', '1.3', 3,
+   'Alternating Current Fundamentals',
+   'Principle of generation of alternating voltages and currents, equations and waveforms, average, peak and RMS values. Three-phase system.', 'published'),
+  ('nec-1.4', 'book-ch1', '1.4', 4,
+   'Semiconductor Devices',
+   'Semiconductor diode characteristics, BJT configuration and biasing, small and large signal model, working principle and application of MOSFET and CMOS.', 'published'),
+  ('nec-1.5', 'book-ch1', '1.5', 5,
+   'Signal Generators',
+   'Basic principles of oscillators: RC, LC and Crystal oscillator circuits, waveform generators.', 'published'),
+  ('nec-1.6', 'book-ch1', '1.6', 6,
+   'Amplifiers',
+   'Class A, B, AB output stages, biasing, power BJTs, transformer-coupled push-pull stages, tuned amplifiers, op-amps.', 'published'),
+  ('nec-2.1', 'book-ch2', '2.1', 1,
+   'Digital Logic',
+   'Number systems, logic levels, logic gates, Boolean algebra, Sum-of-Products method, Product-of-Sums method, truth table to Karnaugh map.', 'published'),
+  ('nec-2.2', 'book-ch2', '2.2', 2,
+   'Combinational and Arithmetic Circuits',
+   'Multiplexers, demultiplexers, decoder, encoder, binary addition/subtraction, unsigned and signed binary number operations.', 'published'),
+  ('nec-2.3', 'book-ch2', '2.3', 3,
+   'Sequential Logic Circuits',
+   'RS, gated, edge-triggered, master-slave flip-flops. Types of registers, shift register applications, asynchronous and synchronous counters.', 'published'),
+  ('nec-2.4', 'book-ch2', '2.4', 4,
+   'Microprocessor',
+   'Internal architecture and features of microprocessors, assembly language programming.', 'published'),
+  ('nec-2.5', 'book-ch2', '2.5', 5,
+   'Microprocessor System',
+   'Memory device classification and hierarchy, I/O and memory parallel interface, PPI, serial interface, synchronous/asynchronous transmission, serial interface standards, DMA and DMA controllers.', 'published'),
+  ('nec-2.6', 'book-ch2', '2.6', 6,
+   'Interrupt Operations',
+   'Interrupt, interrupt service routine (ISR), and interrupt processing.', 'published'),
+  ('nec-3.1', 'book-ch3', '3.1', 1,
+   'Introduction to C Programming',
+   'C tokens, operators, formatted/unformatted I/O, control statements, looping, user-defined functions, recursive functions, arrays (1-D, 2-D, multi-dimensional), string manipulations.', 'published'),
+  ('nec-3.2', 'book-ch3', '3.2', 2,
+   'Pointers, Structure and Data Files in C',
+   'Pointer arithmetic, pointer and arrays, passing pointers to functions. Structure vs union, array of structures, passing structure to function, structure and pointer. I/O operations on files, sequential and random access.', 'published'),
+  ('nec-3.3', 'book-ch3', '3.3', 3,
+   'C++ with Objects and Classes',
+   'Namespace, function overloading, inline functions, default arguments, pass/return by reference. Classes, access specifiers, member functions, constructors, destructors, dynamic memory, this pointer, static members, friend functions and classes.', 'published'),
+  ('nec-3.4', 'book-ch3', '3.4', 4,
+   'Object-Oriented Programming Features',
+   'Operator overloading (unary, binary), data conversion, inheritance (single, multiple, multilevel, hybrid, multipath), constructor/destructor in single/multilevel inheritance.', 'published'),
+  ('nec-3.5', 'book-ch3', '3.5', 5,
+   'Virtual Functions and File Handling',
+   'Virtual functions, dynamic binding, file operations (open/close), I/O operations on files, error handling, stream class hierarchy, formatted/unformatted I/O, manipulators.', 'published'),
+  ('nec-3.6', 'book-ch3', '3.6', 6,
+   'Generic Programming and Exception Handling',
+   'Function templates, class templates, STL (containers, algorithms, iterators), try/catch/throw, multiple exception handling, rethrowing, catching all exceptions, exception specifications, uncaught/unexpected exceptions.', 'published'),
+  ('nec-4.1', 'book-ch4', '4.1', 1,
+   'Control and Central Processing Units',
+   'Control memory, addressing sequencing, computer configuration, microinstruction format, CPU structure and function, ALU, instruction formats, addressing modes, data transfer and manipulation, RISC/CISC, pipelining, parallel processing.', 'published'),
+  ('nec-4.2', 'book-ch4', '4.2', 2,
+   'Computer Arithmetic and Memory System',
+   'Arithmetic and logical operations, memory hierarchy, internal and external memory, cache memory principles, cache design elements (size, mapping, replacement algorithm, write policy, number of caches), memory write-ability and storage permanence.', 'published'),
+  ('nec-4.3', 'book-ch4', '4.3', 3,
+   'Input-Output Organization and Multiprocessor',
+   'Peripheral devices, I/O modules, input-output interface, modes of transfer, DMA, multiprocessor characteristics, interconnection structure, inter-processor communication and synchronization.', 'published'),
+  ('nec-4.4', 'book-ch4', '4.4', 4,
+   'Embedded System Design',
+   'Embedded systems overview, classification, custom single-purpose processor design, optimization, architecture, operation and programmer''s view, development environment, application-specific instruction-set processors (ASIP).', 'published'),
+  ('nec-4.5', 'book-ch4', '4.5', 5,
+   'Real-Time OS and Control Systems',
+   'OS basics, tasks/processes/threads, multiprocessing and multitasking, task scheduling, task synchronization, device drivers, open-loop and closed-loop control system overview.', 'published'),
+  ('nec-4.6', 'book-ch4', '4.6', 6,
+   'HDL and IC Technology',
+   'VHDL overview, overflow and data representation using VHDL, design of combinational and sequential logic using VHDL, pipelining using VHDL.', 'published'),
+  ('nec-5.1', 'book-ch5', '5.1', 1,
+   'Introduction and Physical Layer',
+   'Networking models, protocols and standards, OSI model and TCP/IP model, networking devices (hubs, bridges, switches, routers) and transmission media.', 'published'),
+  ('nec-5.2', 'book-ch5', '5.2', 2,
+   'Data Link Layer',
+   'Services, error detection and correction, flow control, data link protocol, multiple access protocols, LAN addressing and ARP, Ethernet, IEEE 802.3/802.4/802.5, CSMA/CD, wireless LANs, PPP, wide area protocols.', 'published'),
+  ('nec-5.3', 'book-ch5', '5.3', 3,
+   'Network Layer',
+   'Internet addressing, classful address, subnetting, routing protocols (RIP, OSPF, BGP, unicast/multicast), routing algorithms (shortest path, flooding, distance vector, link state), ARP/RARP/IP/ICMP, IPv6 (packet formats, extension headers, IPv4-to-IPv6 transition, multicasting).', 'published'),
+  ('nec-5.4', 'book-ch5', '5.4', 4,
+   'Transport Layer',
+   'Transport service, transport protocols, ports and sockets, connection establishment and release, flow control and buffering, multiplexing/de-multiplexing, congestion control algorithms.', 'published'),
+  ('nec-5.5', 'book-ch5', '5.5', 5,
+   'Application Layer',
+   'Web (HTTP/HTTPS), FTP, PuTTY, WinSCP, electronic mail, DNS, P2P applications, socket programming, application server concepts, traffic analyzers (MRTG, PRTG, SNMP, Packet Tracer, Wireshark).', 'published'),
+  ('nec-5.6', 'book-ch5', '5.6', 6,
+   'Network Security',
+   'Types of computer security and security attacks, cryptography principles, RSA algorithm, digital signatures, securing e-mail (PGP), SSL, network layer security (IPsec, VPN), wireless LAN security (WEP), firewalls.', 'published'),
+  ('nec-6.1', 'book-ch6', '6.1', 1,
+   'Finite Automata',
+   'Introduction to finite automata and FSM, equivalence of DFA and NDFA, minimization of FSMs, regular expressions, equivalence of regular expression and finite automata, pumping lemma for regular languages.', 'published'),
+  ('nec-6.2', 'book-ch6', '6.2', 2,
+   'Context-Free Languages',
+   'CFG, derivative trees, parse tree construction, ambiguous grammar, CNF, GNF, BNF, pushdown automata, equivalence of CFL and PDA, pumping lemma for CFLs, properties of context-free languages.', 'published'),
+  ('nec-6.3', 'book-ch6', '6.3', 3,
+   'Turing Machines',
+   'Turing machine notation, acceptance of strings, TM as language recognizer/computing function/enumerator, multi-track/multi-tape TMs, non-deterministic TMs, Church-Turing thesis, universal Turing machine, computational complexity, time/space complexity, intractability, reducibility.', 'published'),
+  ('nec-6.4', 'book-ch6', '6.4', 4,
+   'Introduction to Computer Graphics',
+   'Overview of computer graphics, graphics hardware (display technology, raster-scan displays, vector displays, display processors, output/input devices), graphics software and standards.', 'published'),
+  ('nec-6.5', 'book-ch6', '6.5', 5,
+   '2D Transformations',
+   '2D translation, rotation, scaling, reflection, shear transformation, 2D composite transformation, 2D viewing pipeline, world-to-screen viewing transformation, clipping (Cohen-Sutherland, Liang-Barsky).', 'published'),
+  ('nec-6.6', 'book-ch6', '6.6', 6,
+   '3D Transformations',
+   '3D translation, rotation, scaling, reflection, shear transformation, 3D composite transformation, 3D viewing pipeline, projection concepts (orthographic, parallel, perspective projection).', 'published'),
+  ('nec-7.1', 'book-ch7', '7.1', 1,
+   'Data Structures, Lists and Trees',
+   'Data types, abstract data types, time/space analysis (Big-O, Omega, Theta). Stacks, queues, infix-to-postfix conversion, array implementation of lists. Singly, doubly, circular linked lists, basic linked-list operations. Binary trees, tree search, insertion/deletion, traversals (pre/in/post-order), height/level/depth, AVL balanced trees.', 'published'),
+  ('nec-7.2', 'book-ch7', '7.2', 2,
+   'Sorting, Searching and Graphs',
+   'Internal/external sorting, insertion/selection/exchange/merge/radix/shell/heap sort, Big-O efficiency. Sequential/binary/tree search, hashing (hash functions, hash tables, collision resolution). Directed/undirected graphs, graph representation, transitive closure, Warshall''s algorithm, DFS/BFS, topological sorting, MST (Prim''s, Kruskal''s), shortest-path (Greedy, Dijkstra''s).', 'published'),
+  ('nec-7.3', 'book-ch7', '7.3', 3,
+   'Data Models, Normalization and SQL',
+   'Data abstraction and independence, schema and instances, E-R model, strong/weak entity sets, E-R diagrams. Normal forms (1NF, 2NF, 3NF, BCNF), functional dependencies, integrity/domain constraints, DDL/DML commands, views, assertions, triggers, relational algebra, query cost estimation, query optimization and decomposition.', 'published'),
+  ('nec-7.4', 'book-ch7', '7.4', 4,
+   'Transaction Processing and Concurrency Control',
+   'ACID properties, concurrent executions, serializability, lock-based protocols, deadlock handling and prevention, failure classification, recovery and atomicity, log-based recovery.', 'published'),
+  ('nec-7.5', 'book-ch7', '7.5', 5,
+   'Introduction to OS and Process Management',
+   'OS evolution, types, components, structure and services. Process description, states, control, threads, scheduling types. Concurrency principles, critical region, race condition, mutual exclusion, semaphores, mutex, message passing, monitors, classical synchronization problems.', 'published'),
+  ('nec-7.6', 'book-ch7', '7.6', 6,
+   'Memory Management, File Systems and Administration',
+   'Memory addressing, swapping, free memory management, virtual memory, demand paging, page replacement algorithms. File and directory concepts, file system implementation, allocation policy and fragmentation, disk block mapping, file system performance. User account management, startup/shutdown procedures.', 'published'),
+  ('nec-8.1', 'book-ch8', '8.1', 1,
+   'Software Process and Requirements',
+   'Software characteristics, quality attributes, process models (Agile, V-Model, Iterative, Prototype, Big Bang), CASE tools. Functional/non-functional requirements, user/system requirements, interface specification, SRS document, requirements elicitation/analysis/validation/management.', 'published'),
+  ('nec-8.2', 'book-ch8', '8.2', 2,
+   'Software Design',
+   'Design process, concepts, modes and heuristics. Architectural design decisions, system organization, modular decomposition, control styles, reference architectures, multiprocessor/client-server/distributed object architectures, real-time software design, component-based software engineering.', 'published'),
+  ('nec-8.3', 'book-ch8', '8.3', 3,
+   'Testing, Cost Estimation and Quality Management',
+   'Unit, integration, system, component, acceptance testing. Test case design, test automation, metrics for testing. Algorithmic cost modeling, project duration and staffing. SQA, formal reviews, statistical SQA, ISO standards, CMMI, SQA plan. Configuration management: change management, version/release management, CASE tools.', 'published'),
+  ('nec-8.4', 'book-ch8', '8.4', 4,
+   'OO Fundamentals and Analysis',
+   'Defining models, requirements process, use cases, OO development cycle, UML, building conceptual models, adding associations and attributes, representation of system behavior.', 'published'),
+  ('nec-8.5', 'book-ch8', '8.5', 5,
+   'OO Design',
+   'Analysis to design, elaborating use cases, collaboration diagrams, objects and patterns, determining visibility, class diagrams.', 'published'),
+  ('nec-8.6', 'book-ch8', '8.6', 6,
+   'OO Design Implementation',
+   'Programming and development process, mapping design to code, creating class definitions from design class diagrams, creating methods from collaboration diagrams, updating class definitions, classes in code, exception and error handling.', 'published'),
+  ('nec-9.1', 'book-ch9', '9.1', 1,
+   'Introduction to AI and Intelligent Agents',
+   'AI concepts, perspectives, history, applications, foundations. Intelligent agent structure and properties, PEAS description. Agent types: simple reflexive, model-based, goal-based, utility-based. Environment types: deterministic, stochastic, static, dynamic, observable, semi-observable, single/multi-agent.', 'published'),
+  ('nec-9.2', 'book-ch9', '9.2', 2,
+   'Problem Solving and Searching Techniques',
+   'State space search, problem formulation, well-defined problems, constraint satisfaction. Uninformed search (DFS, BFS, DLS, IDS, bidirectional). Informed search (greedy best-first, A*, hill climbing, simulated annealing). Game playing, adversarial search, minimax, alpha-beta pruning.', 'published'),
+  ('nec-9.3', 'book-ch9', '9.3', 3,
+   'Knowledge Representation',
+   'Knowledge representations and mappings, approaches and issues. Semantic nets, frames, propositional logic (syntax, semantics, formal logic, tautology, well-formed formula, resolution), predicate logic (FOPL, quantification, rules of inference, unification, resolution refutation), Bayes'' rule, Bayesian networks, reasoning in belief networks.', 'published'),
+  ('nec-9.4', 'book-ch9', '9.4', 4,
+   'Expert Systems and NLP',
+   'Expert system architecture, knowledge acquisition, declarative vs procedural knowledge, development of expert systems. NLP terminology, natural language understanding/generation, NLP steps, applications and challenges. Machine vision concepts and stages, robotics.', 'published'),
+  ('nec-9.5', 'book-ch9', '9.5', 5,
+   'Machine Learning',
+   'Introduction to ML, concepts of learning. Supervised, unsupervised, reinforcement learning. Inductive learning (decision trees), statistical-based learning (Naive Bayes), fuzzy learning, fuzzy inference systems and methods. Genetic algorithms (operators, encoding, selection, fitness function, parameters).', 'published'),
+  ('nec-9.6', 'book-ch9', '9.6', 6,
+   'Neural Networks',
+   'Biological vs artificial neural networks, McCulloch-Pitts neuron, mathematical model of ANN, activation functions, architectures. Perceptron, learning rate, gradient descent, delta rule, Hebbian learning, Adaline. Multilayer perceptron, backpropagation algorithm, Hopfield neural network.', 'published'),
+  ('nec-10.1', 'book-ch10', '10.1', 1,
+   'Engineering Drawings and Concepts',
+   'Fundamentals of standard drawing sheets, dimensions, scale, line diagrams, orthographic projection, isometric projection/view, pictorial views, sectional drawing.', 'published'),
+  ('nec-10.2', 'book-ch10', '10.2', 2,
+   'Engineering Economics',
+   'Project cash flow, discount rate, interest and time value of money. Engineering economics analysis methodologies: Discounted Payback Period, NPV, IRR and MARR. Comparison of alternatives, depreciation system and taxation system in Nepal.', 'published'),
+  ('nec-10.3', 'book-ch10', '10.3', 3,
+   'Project Planning and Scheduling',
+   'Project classifications, life cycle phases, planning process, scheduling (bar chart, CPM, PERT), resource levelling and smoothing, monitoring/evaluation/controlling.', 'published'),
+  ('nec-10.4', 'book-ch10', '10.4', 4,
+   'Project Management',
+   'Information system, project risk analysis and management, project financing, tender and its process, contract management.', 'published'),
+  ('nec-10.5', 'book-ch10', '10.5', 5,
+   'Engineering Professional Practice',
+   'Environment and society, professional ethics, regulatory environment, contemporary issues in engineering, occupational health and safety, roles and responsibilities of Nepal Engineers Association (NEA).', 'published'),
+  ('nec-10.6', 'book-ch10', '10.6', 6,
+   'Engineering Regulatory Body',
+   'Nepal Engineering Council (NEC) Acts and Regulations.', 'published');
+
+
+-- The three mock templates the client currently hardcodes in
+-- frontend/src/data/topics.ts, expressed as SUB-CHAPTER-LEVEL blueprints.
+--
+-- Note what the move buys twice over. 'questionsPerChapter: 10' was a number in
+-- a TypeScript literal that the selection code had to interpret; a blueprint is
+-- data the selection code reads, so a differently weighted mock is a row and
+-- not a deploy. And the rules are now per syllabus code rather than per
+-- chapter, which is the granularity the official NEC syllabus is written in and
+-- the granularity frontend/src/data/examBlueprint.ts already models -- so the
+-- client's exam plan and the server's draw describe the same paper.
+--
+-- Quotas come from `equal-chapter-weight-largest-remainder`: ten questions per
+-- chapter split 2/2/2/2/1/1 over its six codes for a full mock, and five split
+-- 1/1/1/1/1/0 for the quick assessment. 60 rules each.
+INSERT INTO mock_test_templates (id, subject_id, slug, name, description,
+                                 duration_minutes, total_questions, blueprint,
+                                 selection, status, ordinal) VALUES
+  ('full-mock-1', 'nec-computer', 'full-mock-1', 'Full Mock Test 1',
+   '100 questions across all 60 NEC syllabus codes -- a fresh set each time',
+   120, 100,
+   '{"version":2,"weighting_rule":"equal-chapter-weight-largest-remainder","shuffle_options":true,"negative_marking":0,"pass_mark_bp":5000,"strict_subchapter":false,"rules":[{"chapter_id":"book-ch1","subchapter_code":"1.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.6","count":1,"difficulty":null,"tag_ids":null}]}',
+   'random', 'published', 1),
+  ('full-mock-2', 'nec-computer', 'full-mock-2', 'Full Mock Test 2',
+   '100 questions across all 60 NEC syllabus codes -- different selection to Mock 1',
+   120, 100,
+   '{"version":2,"weighting_rule":"equal-chapter-weight-largest-remainder","shuffle_options":true,"negative_marking":0,"pass_mark_bp":5000,"strict_subchapter":false,"rules":[{"chapter_id":"book-ch1","subchapter_code":"1.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.6","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.1","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.2","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.3","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.4","count":2,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.6","count":1,"difficulty":null,"tag_ids":null}]}',
+   'random', 'published', 2),
+  ('quick-test', 'nec-computer', 'quick-test', 'Quick Assessment',
+   '50 questions, five per chapter, for a fast readiness check',
+   60, 50,
+   '{"version":2,"weighting_rule":"equal-chapter-weight-largest-remainder","shuffle_options":true,"negative_marking":0,"pass_mark_bp":5000,"strict_subchapter":false,"rules":[{"chapter_id":"book-ch1","subchapter_code":"1.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch1","subchapter_code":"1.6","count":0,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch2","subchapter_code":"2.6","count":0,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch3","subchapter_code":"3.6","count":0,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch4","subchapter_code":"4.6","count":0,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch5","subchapter_code":"5.6","count":0,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch6","subchapter_code":"6.6","count":0,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch7","subchapter_code":"7.6","count":0,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch8","subchapter_code":"8.6","count":0,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch9","subchapter_code":"9.6","count":0,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.1","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.2","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.3","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.4","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.5","count":1,"difficulty":null,"tag_ids":null},{"chapter_id":"book-ch10","subchapter_code":"10.6","count":0,"difficulty":null,"tag_ids":null}]}',
+   'random', 'published', 3);
diff --git a/worker/migrations/0008_api_infrastructure.sql b/worker/migrations/0008_api_infrastructure.sql
new file mode 100644
index 0000000..9e28e77
--- /dev/null
+++ b/worker/migrations/0008_api_infrastructure.sql
@@ -0,0 +1,124 @@
+-- 0008_api_infrastructure.sql
+-- The two pieces of cross-cutting D1 state the API needs and nothing else in
+-- this schema does: idempotency records and fixed-window rate-limit counters.
+--
+-- They are in their own migration rather than folded into 0001 because they are
+-- not identity, not content and not assessment: they are properties of the HTTP
+-- layer. Both are swept by cron and neither is ever read by a report, a rollup
+-- or a page. (`oauth_accounts` and `oauth_states`, which the API also needs,
+-- ARE identity and live in 0001 next to `users` and `sessions`.)
+--
+-- Same conventions as every other file here: STRICT tables, INTEGER epoch
+-- MILLISECONDS, booleans as 0/1 with a CHECK, every index naming the query it
+-- serves.
+
+-- ---------------------------------------------------------------------------
+-- idempotency_keys: the entire offline-replay contract rests on this table.
+--
+-- THE PROBLEM IT SOLVES. The client is a browser on a mobile connection in
+-- Nepal. The failure that matters is not "the request failed" -- it is "the
+-- request committed and the response never arrived". Without a record of what
+-- happened, the client's retry either double-submits a mock test or gets a 409
+-- for work it cannot see. `frontend/src/services/api.ts` keeps an outbox and
+-- mints a key ONCE at enqueue time, never regenerating it on retry, so a
+-- replayed entry can be recognised here.
+--
+-- KEYED BY (user_id, key), not by key alone. Clients mint these themselves, so
+-- a global key space would let one user's key collide with -- or read back --
+-- another user's stored response. A composite primary key makes that
+-- impossible rather than unlikely.
+--
+-- `request_hash` is sha256 of the endpoint plus a canonicalised body with the
+-- idempotency key itself removed (`worker/src/lib/canonical.ts`). Same key,
+-- same body -> replay the stored response. Same key, DIFFERENT body -> 409
+-- IDEMPOTENCY_KEY_REUSED, never a guess: replaying the stored response would
+-- be a lie about what the server did, and executing the new body would be a
+-- second write under a key that already named one.
+--
+-- A row with a NULL `response_json` is a RESERVATION, not a result: the handler
+-- claimed the key and is still working. A second copy of the same request
+-- arriving in that window gets 409 REQUEST_IN_FLIGHT and retries, which is what
+-- stops two concurrent tabs from both scoring one attempt. The reservation and
+-- the finalisation are therefore two separate writes, and the second one rides
+-- in the handler's own batch so the result and its idempotency record commit
+-- together.
+-- ---------------------------------------------------------------------------
+CREATE TABLE idempotency_keys (
+  user_id       TEXT    NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  -- Client-minted. Bounded and charset-restricted by the request schema
+  -- (`v.idempotencyKey()`), because it becomes half of a primary key and is
+  -- echoed in logs.
+  key           TEXT    NOT NULL,
+  -- 'POST /api/mock/submit'. Part of the match: the same key used against a
+  -- different endpoint is a client bug, not a replay.
+  endpoint      TEXT    NOT NULL,
+  request_hash  TEXT    NOT NULL,                           -- sha256 hex, 64 chars
+  -- NULL while the request is in flight. Set together, by the finalise
+  -- statement, so "has a status" and "has a body" cannot disagree.
+  status_code   INTEGER CHECK (status_code IS NULL OR status_code BETWEEN 100 AND 599),
+  response_json TEXT    CHECK (response_json IS NULL OR json_valid(response_json)),
+  created_at    INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)), -- epoch ms (UTC)
+  PRIMARY KEY (user_id, key),
+  CHECK (length(key) BETWEEN 8 AND 80),
+  CHECK (length(request_hash) = 64 AND request_hash GLOB '[0-9a-f]*'),
+  CHECK ((status_code IS NULL) = (response_json IS NULL))
+) STRICT;
+
+-- NQ-43 idempotency-reserve / NQ-43b idempotency-replay are both primary-key
+-- hits and need no index.
+--
+-- NQ-43c idempotency-sweep (cron): DELETE FROM idempotency_keys
+--        WHERE created_at < ?1 LIMIT ?2. Retention is seven days
+--        (IDEMPOTENCY_TTL_MS), which is longer than any plausible offline
+--        window and short enough that the table stays small -- it is bounded by
+--        mutations per user per week, not by anything unbounded.
+CREATE INDEX idx_idempotency_keys_created_at ON idempotency_keys (created_at);
+
+-- ---------------------------------------------------------------------------
+-- rate_limits: fixed-window counters.
+--
+-- BEST-EFFORT BY CONSTRUCTION, and the honest reason is worth writing in the
+-- schema rather than only in a doc: D1 replicates asynchronously, so two
+-- requests served from different Cloudflare locations can both read a stale
+-- counter and both be allowed. The effective limit is "roughly `limit` per
+-- window PER REGION". That is adequate for what it defends against --
+-- credential stuffing, mock-submit hammering, search abuse -- and it is not a
+-- substitute for a Durable Object or for Cloudflare's own WAF rate limiting,
+-- neither of which is on the free plan.
+--
+-- One row per bucket, where a bucket is `<rule>:<subject>` and the subject is
+-- either a user id or a HASHED client address -- never a raw IP. This table is
+-- a counter, not a log, and there is no reason for it to be reversible.
+--
+-- The whole operation is ONE upsert with RETURNING, so there is no
+-- read-then-write race within a region:
+--
+--   NQ-44 rate-limit-consume:
+--     INSERT INTO rate_limits (bucket, window_start, count) VALUES (?1, ?2, 1)
+--     ON CONFLICT (bucket) DO UPDATE SET
+--       count = CASE WHEN rate_limits.window_start < ?2
+--                    THEN 1 ELSE rate_limits.count + 1 END,
+--       window_start = CASE WHEN rate_limits.window_start < ?2
+--                          THEN ?2 ELSE rate_limits.window_start END
+--     RETURNING count, window_start;
+--
+-- `window_start` is `floor(now / window_ms) * window_ms`, so the window
+-- boundary is derived from the clock rather than from the first request -- two
+-- Workers computing it independently agree, which a "first request starts the
+-- window" scheme would not.
+--
+-- No foreign key to `users`: a bucket subject may be a hashed address with no
+-- account behind it, and a counter must not block or cascade a user deletion.
+-- ---------------------------------------------------------------------------
+CREATE TABLE rate_limits (
+  bucket       TEXT    NOT NULL PRIMARY KEY,                -- '<rule>:<subject>'
+  window_start INTEGER NOT NULL,                                 -- epoch ms (UTC)
+  count        INTEGER NOT NULL DEFAULT 0 CHECK (count >= 0),
+  CHECK (length(bucket) BETWEEN 3 AND 160)
+) STRICT;
+
+-- NQ-44b rate-limit-sweep (cron): DELETE FROM rate_limits
+--        WHERE window_start < ?1 LIMIT ?2. Without it the table accumulates one
+--        row per address that ever hit a limited endpoint; with it, the live set
+--        is bounded by the longest window (one hour).
+CREATE INDEX idx_rate_limits_window_start ON rate_limits (window_start);
diff --git a/worker/migrations/0009_subchapter_classification.sql b/worker/migrations/0009_subchapter_classification.sql
new file mode 100644
index 0000000..ab7ca0d
--- /dev/null
+++ b/worker/migrations/0009_subchapter_classification.sql
@@ -0,0 +1,137 @@
+-- ===========================================================================
+-- 0009_subchapter_classification.sql
+--
+-- Make `questions.subchapter_id` fillable without losing the fact that most
+-- of it was DERIVED rather than decided by a person.
+--
+-- THE PROBLEM THIS SOLVES
+-- -----------------------
+-- 0002 set out the honest position: "NULL until a contributor classifies it.
+-- The importer never guesses." Nobody ever classified anything, so the column
+-- is NULL for all 2,312 rows, and the consequences are not cosmetic:
+--
+--   * All 60 sub-chapter blueprint rules in `domain/blueprint.ts` fall back to
+--     chapter-level sampling, so a "Transport Layer" practice set is really a
+--     "chapter 5" practice set.
+--   * `user_question_stats.subchapter_id` is NULL on every rollup row, so
+--     per-sub-chapter mastery cannot be computed at all.
+--
+-- A deterministic classifier now exists (`frontend/src/services/
+-- subchapterClassifier.ts`): it matches discriminating vocabulary within the
+-- question's already-known chapter, and declines when two sub-chapters tie.
+-- It labels about two thirds of the bank and refuses the rest.
+--
+-- WHY PROVENANCE COLUMNS AND NOT JUST THE ID
+-- ------------------------------------------
+-- A classifier label is a good guess, not a fact, and writing it into
+-- `subchapter_id` alone would make it indistinguishable from a librarian's
+-- decision a year from now. That is the same mistake `explanations.origin`
+-- exists to prevent, so this follows the same shape: the label carries its
+-- source, its confidence and the classifier version that produced it.
+--
+-- What that buys:
+--   * A reviewer can list the weakest labels first and fix those.
+--   * Re-running a better classifier can overwrite `heuristic` rows while
+--     leaving every `human` row untouched.
+--   * The delivery path can require `human` for anything high-stakes and
+--     accept `heuristic` for practice, as a policy decision rather than an
+--     accident.
+--
+-- SQLite's ALTER TABLE ADD COLUMN cannot add table-level CHECKs, and
+-- rebuilding `questions` would mean recreating every dependent index, trigger
+-- and foreign key for the sake of three columns. So the single-column
+-- constraints are CHECKs and the cross-column invariants are triggers, which
+-- 0003 and 0005 already use.
+-- ===========================================================================
+
+-- How the label was arrived at.
+--   human     -- a person classified this question. Authoritative.
+--   heuristic -- derived by the term-matching classifier. A hint.
+ALTER TABLE questions ADD COLUMN subchapter_source TEXT
+  CONSTRAINT questions_subchapter_source
+  CHECK (subchapter_source IS NULL OR subchapter_source IN ('human', 'heuristic'));
+
+-- Classifier confidence in basis points, 0-10000. NULL for human labels,
+-- where confidence is not a meaningful quantity. Basis points rather than a
+-- float, matching `explanations.generator_confidence_bp`.
+ALTER TABLE questions ADD COLUMN subchapter_confidence_bp INTEGER
+  CONSTRAINT questions_subchapter_confidence_bp
+  CHECK (subchapter_confidence_bp IS NULL
+         OR subchapter_confidence_bp BETWEEN 0 AND 10000);
+
+-- Which classifier produced a heuristic label, so a change in the term lists
+-- or the thresholds is visible as a version bump and the affected rows can be
+-- found and re-run. Term lists are a maintained artefact, not a constant.
+ALTER TABLE questions ADD COLUMN subchapter_classifier_version TEXT;
+
+-- ---------------------------------------------------------------------------
+-- Invariants.
+--
+-- Three rules, each enforced on INSERT and on UPDATE because a row can reach
+-- an invalid state either way:
+--
+--   1. No provenance without a label. If `subchapter_id` is NULL, all three
+--      new columns must be NULL -- otherwise a cleared label leaves orphaned
+--      confidence behind, which reads as though the row were still classified.
+--   2. A labelled row must say where the label came from.
+--   3. `heuristic` requires a confidence and a version; `human` must carry
+--      neither. A human label with a confidence number is the tell that some
+--      code path wrote a guess and called it a decision.
+-- ---------------------------------------------------------------------------
+
+CREATE TRIGGER questions_subchapter_provenance_bi
+BEFORE INSERT ON questions
+WHEN
+  (NEW.subchapter_id IS NULL AND (NEW.subchapter_source IS NOT NULL
+                                  OR NEW.subchapter_confidence_bp IS NOT NULL
+                                  OR NEW.subchapter_classifier_version IS NOT NULL))
+  OR (NEW.subchapter_id IS NOT NULL AND NEW.subchapter_source IS NULL)
+  OR (NEW.subchapter_source = 'heuristic' AND (NEW.subchapter_confidence_bp IS NULL
+                                               OR NEW.subchapter_classifier_version IS NULL))
+  OR (NEW.subchapter_source = 'human' AND (NEW.subchapter_confidence_bp IS NOT NULL
+                                           OR NEW.subchapter_classifier_version IS NOT NULL))
+BEGIN
+  SELECT RAISE(ABORT, 'questions: subchapter label and its provenance disagree');
+END;
+
+CREATE TRIGGER questions_subchapter_provenance_bu
+BEFORE UPDATE ON questions
+WHEN
+  (NEW.subchapter_id IS NULL AND (NEW.subchapter_source IS NOT NULL
+                                  OR NEW.subchapter_confidence_bp IS NOT NULL
+                                  OR NEW.subchapter_classifier_version IS NOT NULL))
+  OR (NEW.subchapter_id IS NOT NULL AND NEW.subchapter_source IS NULL)
+  OR (NEW.subchapter_source = 'heuristic' AND (NEW.subchapter_confidence_bp IS NULL
+                                               OR NEW.subchapter_classifier_version IS NULL))
+  OR (NEW.subchapter_source = 'human' AND (NEW.subchapter_confidence_bp IS NOT NULL
+                                           OR NEW.subchapter_classifier_version IS NOT NULL))
+BEGIN
+  SELECT RAISE(ABORT, 'questions: subchapter label and its provenance disagree');
+END;
+
+-- A human decision must never be silently replaced by a later classifier run.
+-- The importer is written to respect this, but the importer is not the only
+-- thing that will ever touch these rows.
+CREATE TRIGGER questions_subchapter_human_label_is_final
+BEFORE UPDATE OF subchapter_id, subchapter_source ON questions
+WHEN OLD.subchapter_source = 'human' AND NEW.subchapter_source = 'heuristic'
+BEGIN
+  SELECT RAISE(ABORT, 'questions: a heuristic label may not overwrite a human one');
+END;
+
+-- ---------------------------------------------------------------------------
+-- The review queue: weakest heuristic labels first.
+--
+-- Partial, because the rows worth reviewing are a minority and will shrink as
+-- they are confirmed -- there is no reason to carry the whole bank in this
+-- index.
+-- ---------------------------------------------------------------------------
+-- Blueprint sampling needs no new index: `idx_questions_published_subchapter`
+-- from 0002 already covers (subchapter_id, id) WHERE published AND NOT NULL,
+-- and it has been waiting for a non-NULL column to be useful.
+-- Ascending is SQLite's default and is what the review queue wants (weakest
+-- label first); it is left implicit because Drizzle cannot emit an explicit
+-- ASC and `db:verify` compares the two key lists literally.
+CREATE INDEX idx_questions_subchapter_review
+  ON questions (subchapter_confidence_bp, chapter_id)
+  WHERE subchapter_source = 'heuristic';
diff --git a/worker/migrations/0010_exam_duration.sql b/worker/migrations/0010_exam_duration.sql
new file mode 100644
index 0000000..c96d36e
--- /dev/null
+++ b/worker/migrations/0010_exam_duration.sql
@@ -0,0 +1,53 @@
+-- ===========================================================================
+-- 0010_exam_duration.sql
+--
+-- Correct the mock-test durations to the exam format the project owner
+-- confirmed: 100 questions x 1 mark, 120 MINUTES, pass mark 50.
+--
+-- WHAT WENT WRONG
+-- ---------------
+-- `db/seed/generate-reference-sql.mjs` carried the durations as literals --
+-- 45 and 20 -- copied from `frontend/src/data/topics.ts` back when that file
+-- also held literals. `examBlueprint.ts` later became the single source of
+-- truth and was confirmed at 120 minutes; `topics.ts` was changed to derive
+-- from it and the generator was not.
+--
+-- So 0007 seeded, and this database served, templates claiming 100 questions
+-- in 45 minutes while the client's own clock said 120. That is not a cosmetic
+-- disagreement: `attempts.deadline_at` is computed server-side from
+-- `duration_minutes` and the submit path clamps against it
+-- (`src/domain/expiry.ts`). The server owns the deadline, so the server would
+-- have won, and every candidate would have been cut off 75 minutes early in
+-- what is meant to be a full-length rehearsal of a licence exam.
+--
+-- `pass_mark_bp` was already 5000 and `total_questions` already 100; only the
+-- duration was wrong.
+--
+-- THE FIX IS IN TWO PLACES, DELIBERATELY
+-- --------------------------------------
+--   * The generator now DERIVES the duration via `readConfirmed(
+--     examFormat.durationMinutes)`, so a fresh database gets 120 from 0007 and
+--     a future change that un-confirms the value fails the generator instead
+--     of silently seeding a guess.
+--   * This migration repairs databases where 0007 has already been applied.
+--     Editing 0007 alone would fix new deployments and leave the live one
+--     wrong, which is the worse half of the problem.
+--
+-- Running it on a database that already has the right values is a no-op, which
+-- is why it is written as a plain UPDATE with no guard.
+--
+-- The quick test is pro-rata on question count -- 50 questions, so half the
+-- time -- matching the arithmetic in `topics.ts` and in the generator.
+-- ===========================================================================
+
+UPDATE mock_test_templates
+   SET duration_minutes = 120,
+       updated_at = CAST(unixepoch('subsec') * 1000 AS INTEGER)
+ WHERE id IN ('full-mock-1', 'full-mock-2')
+   AND duration_minutes <> 120;
+
+UPDATE mock_test_templates
+   SET duration_minutes = 60,
+       updated_at = CAST(unixepoch('subsec') * 1000 AS INTEGER)
+ WHERE id = 'quick-test'
+   AND duration_minutes <> 60;
diff --git a/worker/package-lock.json b/worker/package-lock.json
new file mode 100644
index 0000000..e28ac03
--- /dev/null
+++ b/worker/package-lock.json
@@ -0,0 +1,1819 @@
+{
+  "name": "necprep-worker",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "necprep-worker",
+      "version": "0.1.0",
+      "dependencies": {
+        "@anthropic-ai/sdk": "^0.135.0",
+        "drizzle-orm": "^0.45.4",
+        "hono": "^4.13.13",
+        "zod": "^4.6.7"
+      },
+      "devDependencies": {
+        "@cloudflare/workers-types": "^5.20261019.1",
+        "@types/node": "^22.20.5",
+        "typescript": "^5.9.0",
+        "wrangler": "^4.151.2"
+      }
+    },
+    "node_modules/@anthropic-ai/sdk": {
+      "version": "0.135.0",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.135.0.tgz",
+      "integrity": "sha512-WWrdL57JhU5KoynpTjt9GXK6k7ud9nPw2uw/Trn+oBXh6s0KpjhAccWZm2Qxw08ARYG1UDQj5iC+JO42j1rt/g==",
+      "license": "MIT",
+      "dependencies": {
+        "@opentelemetry/api": "^1.4.1",
+        "json-schema-to-ts": "^3.1.1",
+        "standardwebhooks": "^1.0.0"
+      },
+      "bin": {
+        "anthropic-ai-sdk": "bin/cli"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.0 || ^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.10",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.10.tgz",
+      "integrity": "sha512-NpugTzbKgGrNe45Ui32cN8vCFFMxVtP/9rtfwv0nP5FRDAjvYBxJcLVpYA9mr1jxP6cnIT7x9LUzuDTbWYYNRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@cloudflare/kv-asset-handler": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/@cloudflare/kv-asset-handler/-/kv-asset-handler-0.5.0.tgz",
+      "integrity": "sha512-jxQYkj8dSIzc0cD6cMMNdOc1UVjqSqu8BZdor5s8cGjW2I8BjODt/kWPVdY+u9zj3ms75Q5qaZgnxUad83+eAg==",
+      "dev": true,
+      "license": "MIT OR Apache-2.0",
+      "engines": {
+        "node": ">=22.0.0"
+      }
+    },
+    "node_modules/@cloudflare/unenv-preset": {
+      "version": "2.16.2",
+      "resolved": "https://registry.npmjs.org/@cloudflare/unenv-preset/-/unenv-preset-2.16.2.tgz",
+      "integrity": "sha512-JBP1+Z7ZSNG/d4mRP+y8VC5dka3tZVMLEZRvS+rzQ4DGV1EoxRFQckcJTTkXbHSQiTj0DtNI01Zwb/V2fX0mvQ==",
+      "dev": true,
+      "license": "MIT OR Apache-2.0",
+      "peerDependencies": {
+        "unenv": "2.0.0-rc.24",
+        "workerd": ">1.20260305.0 <2.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "workerd": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@cloudflare/workerd-darwin-64": {
+      "version": "1.20261019.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-64/-/workerd-darwin-64-1.20261019.1.tgz",
+      "integrity": "sha512-5ZILbAta/fBQvhmAYeCE7dKMMYIr7N9wJEX50fEGLKSIwGtvT0HzSfHNIK/O7cBQ4gHQ2WfIiPClvwcye6E0fA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/@cloudflare/workerd-darwin-arm64": {
+      "version": "1.20261019.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-arm64/-/workerd-darwin-arm64-1.20261019.1.tgz",
+      "integrity": "sha512-cww2Ab6lVMxpTiEEjKmPI58p5EMo0vYTZSH+3WkqXJdQgc3ES66GuL247+U2B2YWajhhu2tqj7jySrXneU749g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/@cloudflare/workerd-linux-64": {
+      "version": "1.20261019.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-64/-/workerd-linux-64-1.20261019.1.tgz",
+      "integrity": "sha512-4++VRi9vkQROYqrpZYOixIJuVDmujkwrT4kszsxNFlvcmsX6Mr2GumvxIN3gIixS3vJUh3Umdtkthqj5X0S3Xw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/@cloudflare/workerd-linux-arm64": {
+      "version": "1.20261019.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-arm64/-/workerd-linux-arm64-1.20261019.1.tgz",
+      "integrity": "sha512-75PVtJOwfjScQ53sbLtQXI7D8yP1c21t+WEUPaYbqkzaz4ZqfR5wAd+zuWs8G5Q7kOj2SQIvEfY5Sn8Y+UVrnA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/@cloudflare/workerd-windows-64": {
+      "version": "1.20261019.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-windows-64/-/workerd-windows-64-1.20261019.1.tgz",
+      "integrity": "sha512-z49fvKTETMCnG6wnMcQwxx9CpryFceiKz04FRjq26EkhCyzRNJ6c3UXhyZz3r5f1CXnnBZc5DcU8ZouPkUJCqw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/@cloudflare/workers-types": {
+      "version": "5.20261019.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workers-types/-/workers-types-5.20261019.1.tgz",
+      "integrity": "sha512-llvvy7WBVhK+OfykyBkG9A7OgsGvgwHSNyU40XGVkiy/xVFy0t/xflyhEBHT+U59yQECZQbmcZsJtqCNnLpIRg==",
+      "devOptional": true,
+      "license": "MIT OR Apache-2.0"
+    },
+    "node_modules/@cspotcode/source-map-support": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
+      "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "0.3.9"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.3.tgz",
+      "integrity": "sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
+      "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz",
+      "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz",
+      "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz",
+      "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz",
+      "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz",
+      "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz",
+      "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz",
+      "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz",
+      "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz",
+      "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz",
+      "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz",
+      "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz",
+      "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz",
+      "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz",
+      "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz",
+      "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz",
+      "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz",
+      "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz",
+      "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz",
+      "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz",
+      "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@img/colour": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz",
+      "integrity": "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@img/sharp-darwin-arm64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.35.5.tgz",
+      "integrity": "sha512-QRUlFQ0WxvdWyqqG/WtI3iupfD5rBzmCHXSdPsY91sAtVtTo7Q4cb6zOccZ3gqEqkr0f1As1ehLqmEpDsRf+lg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-arm64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-darwin-x64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.35.5.tgz",
+      "integrity": "sha512-+BR255RhDlpygUpOc/Jdt1nT6DQ3XG/ERo5wbcdOf5Q320dKtPCKPLR1LJs9VGXRaMa8l1uUa0tkCNOXiAxZUw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-x64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-freebsd-wasm32": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-freebsd-wasm32/-/sharp-freebsd-wasm32-0.35.5.tgz",
+      "integrity": "sha512-Y/z91nEZ4uIBX5X3nfTovjU9lHNKFYbL2lpHCLVNmXQK03VIZvXBBt0KxbPGp2SdGSF+2mQU4e+hQaWOt86iAw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "dependencies": {
+        "@img/sharp-wasm32": "0.35.5"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-arm64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.3.4.tgz",
+      "integrity": "sha512-5R89nBYiRdUlSWJxPhO+GVtaXzXSxKnRu/xqMn3KTA3L9EB9Oy/P+Nn2f2vlhPuUdy/Zusb2DarbyTpGCfEDuw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-x64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.3.4.tgz",
+      "integrity": "sha512-iR2OKH80yi0U+dUplyh3/xdpFvps6YkCwsXenIJxqxR1v9o+xtKTGbS9H7cps+2Vxjc8B1j96p75NmTGjIhtpQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.3.4.tgz",
+      "integrity": "sha512-LmRtTsOHuvM2+wlO2Db37dx5MiZhB0FvSunciw48YjdOkZz9KAiRbm8ujeMOA1INqmei5NapFxYEK1D1ZSidmw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.3.4.tgz",
+      "integrity": "sha512-Y3dgX/6lE2QhQb+Gxy0WZxfg9MEm/JBjamZpS2IklP7xIQoKN4hzAm7KcMVGtaVDt3neE9OKBC7vAfonA/Lr1A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-ppc64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.3.4.tgz",
+      "integrity": "sha512-Le6boB8Tai0Nis+gIxIpKx68UDVVIqdR8Tin5Yf1z2LJJQLDJvCDRqRu+jC2qCoD+eIomonmOwB4smBRxfVpYQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-riscv64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.3.4.tgz",
+      "integrity": "sha512-aHkkIEHPRdQEegJN20MLmGtxYD9R2wQr3Cwpddnu5+YKMt6Uzax7S9h5gpZTo8wyrGuZSlfQ63OevL5mTyOC7Q==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-s390x": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.3.4.tgz",
+      "integrity": "sha512-ra/mB6MikESDUO7Yg+Mi95bFBb9GsObURuhnOv3OqknjGe9sZrG8tCe9q0xSIGrtLgvgw0gKnFWcK4blSgQOuQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-x64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.4.tgz",
+      "integrity": "sha512-GJ//SSXbnwSDes02umB3nDJLFcQzw8a18V8fyhqr6tV515tOEMdImjjxj1AoafMRz56F3PHgftnj1QEKSU1zkw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.3.4.tgz",
+      "integrity": "sha512-hvulFwtjUcagsis6BBxHwGFwWoNZjgYmULGVrZcyfNbjA8hKILbRxGg15/7w5HDyXHXUos/j6baAWqnCyQ2DWA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-x64": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.4.tgz",
+      "integrity": "sha512-6zXKeE/p39I1AmA3cJG35eyBGNqNddLnUXjhwBnsGjFPWqf5VKkDBEqaEkPDoTEtkxwi2vv8Tcr2mDyP4So7Fg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.35.5.tgz",
+      "integrity": "sha512-LEaXK2WdXVK5ykcw0buWyPMsmLLL2vpHLD6yrNSW+JGEL3BZPA4tpKN6iaMc4AxTTAoaX/sU1rOL51lcIz48ZQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.35.5.tgz",
+      "integrity": "sha512-LYVx5JTsOM2CBzmxreh+nl64/3H6Xb09iSLknqH47z2T2DFFxDeFLP5y4dJwe6H7uGQlHPyEEtIqyo3DYsRwdQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-ppc64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.35.5.tgz",
+      "integrity": "sha512-QVxAAq8evVRI9ia2vqgwrmWucn5Dfv+JdWzj75pD8omHLPSP7f8p20O8jxzjCcuCEQEOtYOZUmX1hkiZ0kdevA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-ppc64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-riscv64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.35.5.tgz",
+      "integrity": "sha512-LtdreXguaavKODPIfzJ4kffx7UNt1omwtK0rch4EBbbSTXPnxWmYSayXdLJw0fJzQ97kHt1gL/yh4tvU+nCyRQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-riscv64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-s390x": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.35.5.tgz",
+      "integrity": "sha512-UZasTOFiYzotTsGOCu42BfUzP6Tu6Do/947iRm1RsLKvlllxwGcn4RN27LibGWceix4Y+Pmw3jsnTcCQIgWjqA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-s390x": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-x64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.5.tgz",
+      "integrity": "sha512-SxFtLTeJInhAA9Q836kux2vZNeOBQEx658qvbboZScr0wIARym3IcGmW7KpVD5sbVg0Ojy+udFQdayYIZyoNog==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-x64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-arm64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.35.5.tgz",
+      "integrity": "sha512-9HbMclmI1zlNkFRs3z9/eBtDjfD0sGlrX1z6b1qwmiFY5ElDLh4BC0LPBdVp7z1DXFiKlIcznf+ZlsuZzLxQqg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-x64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.5.tgz",
+      "integrity": "sha512-4KOphqB035HrVdqLZfCgMzzERrQkkzOwRhl4OAkRO1YCldbaFjySXMaK534Mo0V+LndnlJk+sbUyLeU0ULyD1A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.4"
+      }
+    },
+    "node_modules/@img/sharp-wasm32": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.5.tgz",
+      "integrity": "sha512-Ptsga1su4tQx+LLF1ECS9U6nz5kmrXKo6XVbtR48Ke3ZRxxgaWBu7IDtEe1quo8hiupwm6WFqxVlXaSf7IINGQ==",
+      "dev": true,
+      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/runtime": "^1.11.3"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-webcontainers-wasm32": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-webcontainers-wasm32/-/sharp-webcontainers-wasm32-0.35.5.tgz",
+      "integrity": "sha512-hfhF/FmoQyTUkA0bIKFOtw536BQSeBMe6BF6QyWlrPxT754+TFLaZ7sKKTfvvM0yJgKgaYTwnFCIZ/GuDw5SUA==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "@img/sharp-wasm32": "0.35.5"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-arm64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.35.5.tgz",
+      "integrity": "sha512-X4t7g+7ZA5DKblCBEXGjUqqemj4vczING/5viFwAL8h4N3qYeyjwdCvRLHi4EdOUI+2Z7UFlp1VM+p/AuEtm6Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-ia32": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.35.5.tgz",
+      "integrity": "sha512-5Zm82LoBc43nhwNybZlG7Y1KO//Zhsn306fQl29ZOuStHLGTo3BWL83q3cznX0poxSAMuYL1On/BHBxkBeKr6A==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-x64": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.35.5.tgz",
+      "integrity": "sha512-x76eH0vEiHlcMQu8Y8IenntaACtddpT6W0wmXtWrnKcnKI7ME5DdgqhAD6SEWOEl1v2zDvkZDhFA9KnURwpfqg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz",
+      "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.9",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
+      "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
+    "node_modules/@opentelemetry/api": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.1.tgz",
+      "integrity": "sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
+    "node_modules/@poppinss/colors": {
+      "version": "4.1.6",
+      "resolved": "https://registry.npmjs.org/@poppinss/colors/-/colors-4.1.6.tgz",
+      "integrity": "sha512-H9xkIdFswbS8n1d6vmRd8+c10t2Qe+rZITbbDHHkQixH5+2x1FDGmi/0K+WgWiqQFKPSlIYB7jlH6Kpfn6Fleg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "kleur": "^4.1.5"
+      }
+    },
+    "node_modules/@poppinss/dumper": {
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@poppinss/dumper/-/dumper-0.6.5.tgz",
+      "integrity": "sha512-NBdYIb90J7LfOI32dOewKI1r7wnkiH6m920puQ3qHUeZkxNkQiFnXVWoE6YtFSv6QOiPPf7ys6i+HWWecDz7sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@poppinss/colors": "^4.1.5",
+        "@sindresorhus/is": "^7.0.2",
+        "supports-color": "^10.0.0"
+      }
+    },
+    "node_modules/@poppinss/exception": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@poppinss/exception/-/exception-1.2.3.tgz",
+      "integrity": "sha512-dCED+QRChTVatE9ibtoaxc+WkdzOSjYTKi/+uacHWIsfodVfpsueo3+DKpgU5Px8qXjgmXkSvhXvSCz3fnP9lw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@sindresorhus/is": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-7.2.0.tgz",
+      "integrity": "sha512-P1Cz1dWaFfR4IR+U13mqqiGsLFf1KbayybWwdd2vfctdV6hDpUkgCY0nKOLLTMSoRd/jJNjtbqzf13K8DCCXQw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/is?sponsor=1"
+      }
+    },
+    "node_modules/@speed-highlight/core": {
+      "version": "1.2.24",
+      "resolved": "https://registry.npmjs.org/@speed-highlight/core/-/core-1.2.24.tgz",
+      "integrity": "sha512-qeW2e1l78afw8VhRPfPQ1Gjj+KU5XFQ/OFV5ti6eTa9bruO7mJyZtA4vw0ofqmA3tKCkROE9xLk3VZoeRc98nw==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
+    "node_modules/@stablelib/base64": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@stablelib/base64/-/base64-1.0.1.tgz",
+      "integrity": "sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ==",
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "22.20.5",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.20.5.tgz",
+      "integrity": "sha512-U2+DNr+wSjpsTS/wZGYHq7GcwfuSmKiKvoPvK22zwTlRhU91yOniN4qRR5KhIjvif7ysw/dz/hKmfDH0Ris4aA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/blake3-wasm": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/blake3-wasm/-/blake3-wasm-2.1.5.tgz",
+      "integrity": "sha512-F1+K8EbfOZE49dtoPtmxUQrpXaBIl3ICvasLh+nJta0xkz+9kF/7uet9fLnwKqhDrmj6g+6K3Tw9yQPUg2ka5g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cookie": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz",
+      "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/drizzle-orm": {
+      "version": "0.45.4",
+      "resolved": "https://registry.npmjs.org/drizzle-orm/-/drizzle-orm-0.45.4.tgz",
+      "integrity": "sha512-NiM1YZpJ2UxyeE67DpDDZ+Tsw4YLX3trSlkNT7Tm9eKoUNb1LvaAaQzXgYQsWs+AQ9TUmmwMmBOCXuqqxUWKKQ==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@aws-sdk/client-rds-data": ">=3",
+        "@cloudflare/workers-types": ">=4",
+        "@electric-sql/pglite": ">=0.2.0",
+        "@libsql/client": ">=0.10.0",
+        "@libsql/client-wasm": ">=0.10.0",
+        "@neondatabase/serverless": ">=0.10.0",
+        "@netlify/db": ">=0.4.0",
+        "@op-engineering/op-sqlite": ">=2",
+        "@opentelemetry/api": "^1.4.1",
+        "@planetscale/database": ">=1.13",
+        "@prisma/client": "*",
+        "@tidbcloud/serverless": "*",
+        "@types/better-sqlite3": "*",
+        "@types/pg": "*",
+        "@types/sql.js": "*",
+        "@upstash/redis": ">=1.34.7",
+        "@vercel/postgres": ">=0.8.0",
+        "@xata.io/client": "*",
+        "better-sqlite3": ">=7",
+        "bun-types": "*",
+        "expo-sqlite": ">=14.0.0",
+        "gel": ">=2",
+        "knex": "*",
+        "kysely": "*",
+        "mysql2": ">=2",
+        "pg": ">=8",
+        "postgres": ">=3",
+        "sql.js": ">=1",
+        "sqlite3": ">=5"
+      },
+      "peerDependenciesMeta": {
+        "@aws-sdk/client-rds-data": {
+          "optional": true
+        },
+        "@cloudflare/workers-types": {
+          "optional": true
+        },
+        "@electric-sql/pglite": {
+          "optional": true
+        },
+        "@libsql/client": {
+          "optional": true
+        },
+        "@libsql/client-wasm": {
+          "optional": true
+        },
+        "@neondatabase/serverless": {
+          "optional": true
+        },
+        "@netlify/db": {
+          "optional": true
+        },
+        "@op-engineering/op-sqlite": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@planetscale/database": {
+          "optional": true
+        },
+        "@prisma/client": {
+          "optional": true
+        },
+        "@tidbcloud/serverless": {
+          "optional": true
+        },
+        "@types/better-sqlite3": {
+          "optional": true
+        },
+        "@types/pg": {
+          "optional": true
+        },
+        "@types/sql.js": {
+          "optional": true
+        },
+        "@upstash/redis": {
+          "optional": true
+        },
+        "@vercel/postgres": {
+          "optional": true
+        },
+        "@xata.io/client": {
+          "optional": true
+        },
+        "better-sqlite3": {
+          "optional": true
+        },
+        "bun-types": {
+          "optional": true
+        },
+        "expo-sqlite": {
+          "optional": true
+        },
+        "gel": {
+          "optional": true
+        },
+        "knex": {
+          "optional": true
+        },
+        "kysely": {
+          "optional": true
+        },
+        "mysql2": {
+          "optional": true
+        },
+        "pg": {
+          "optional": true
+        },
+        "postgres": {
+          "optional": true
+        },
+        "prisma": {
+          "optional": true
+        },
+        "sql.js": {
+          "optional": true
+        },
+        "sqlite3": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/error-stack-parser-es": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/error-stack-parser-es/-/error-stack-parser-es-1.0.5.tgz",
+      "integrity": "sha512-5qucVt2XcuGMcEGgWI7i+yZpmpByQ8J1lHhcL7PwqCwu9FPP3VUXzT4ltHe5i2z9dePwEHcDVOAfSnHsOlCXRA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
+      "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.28.2",
+        "@esbuild/android-arm": "0.28.2",
+        "@esbuild/android-arm64": "0.28.2",
+        "@esbuild/android-x64": "0.28.2",
+        "@esbuild/darwin-arm64": "0.28.2",
+        "@esbuild/darwin-x64": "0.28.2",
+        "@esbuild/freebsd-arm64": "0.28.2",
+        "@esbuild/freebsd-x64": "0.28.2",
+        "@esbuild/linux-arm": "0.28.2",
+        "@esbuild/linux-arm64": "0.28.2",
+        "@esbuild/linux-ia32": "0.28.2",
+        "@esbuild/linux-loong64": "0.28.2",
+        "@esbuild/linux-mips64el": "0.28.2",
+        "@esbuild/linux-ppc64": "0.28.2",
+        "@esbuild/linux-riscv64": "0.28.2",
+        "@esbuild/linux-s390x": "0.28.2",
+        "@esbuild/linux-x64": "0.28.2",
+        "@esbuild/netbsd-arm64": "0.28.2",
+        "@esbuild/netbsd-x64": "0.28.2",
+        "@esbuild/openbsd-arm64": "0.28.2",
+        "@esbuild/openbsd-x64": "0.28.2",
+        "@esbuild/openharmony-arm64": "0.28.2",
+        "@esbuild/sunos-x64": "0.28.2",
+        "@esbuild/win32-arm64": "0.28.2",
+        "@esbuild/win32-ia32": "0.28.2",
+        "@esbuild/win32-x64": "0.28.2"
+      }
+    },
+    "node_modules/fast-sha256": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/fast-sha256/-/fast-sha256-1.3.0.tgz",
+      "integrity": "sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==",
+      "license": "Unlicense"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/hono": {
+      "version": "4.13.13",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.13.13.tgz",
+      "integrity": "sha512-CQ46U0ZkAGmbT/4UxdzzGJpacP2IeKgY4a5/tOI9AABbpOMfK739wfDXmv1usCk+3RkKj1hQy4/fjhiwa2xlrA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.9.0"
+      }
+    },
+    "node_modules/json-schema-to-ts": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/json-schema-to-ts/-/json-schema-to-ts-3.1.1.tgz",
+      "integrity": "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.18.3",
+        "ts-algebra": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/kleur": {
+      "version": "4.1.5",
+      "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz",
+      "integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/miniflare": {
+      "version": "5.20261019.0-beta",
+      "resolved": "https://registry.npmjs.org/miniflare/-/miniflare-5.20261019.0-beta.tgz",
+      "integrity": "sha512-NmE6Yz7MSdjrfr3lMaMAVO55rIm3+6YXllOkJOMy6pPQITDuDeo0PYRedp7pju2olNWmrAlf1i1LIWYfGQvvuw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@cspotcode/source-map-support": "0.8.1",
+        "sharp": "0.35.5",
+        "undici": "7.29.1",
+        "workerd": "1.20261019.1",
+        "ws": "8.21.0",
+        "youch": "4.1.0-beta.10"
+      },
+      "engines": {
+        "node": ">=22.0.0"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz",
+      "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.8.5",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/sharp": {
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.5.tgz",
+      "integrity": "sha512-Ywn4OnzGukp7CDMrp08RQ50YKmuwG47brZgIVPTvBaaAfQlRlygrRqSrxdCiL9M+LlzLBiJ68IR1QqvzHyjC7g==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@img/colour": "^1.1.0",
+        "detect-libc": "^2.1.2",
+        "semver": "^7.8.5"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-darwin-arm64": "0.35.5",
+        "@img/sharp-darwin-x64": "0.35.5",
+        "@img/sharp-freebsd-wasm32": "0.35.5",
+        "@img/sharp-libvips-darwin-arm64": "1.3.4",
+        "@img/sharp-libvips-darwin-x64": "1.3.4",
+        "@img/sharp-libvips-linux-arm": "1.3.4",
+        "@img/sharp-libvips-linux-arm64": "1.3.4",
+        "@img/sharp-libvips-linux-ppc64": "1.3.4",
+        "@img/sharp-libvips-linux-riscv64": "1.3.4",
+        "@img/sharp-libvips-linux-s390x": "1.3.4",
+        "@img/sharp-libvips-linux-x64": "1.3.4",
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.4",
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.4",
+        "@img/sharp-linux-arm": "0.35.5",
+        "@img/sharp-linux-arm64": "0.35.5",
+        "@img/sharp-linux-ppc64": "0.35.5",
+        "@img/sharp-linux-riscv64": "0.35.5",
+        "@img/sharp-linux-s390x": "0.35.5",
+        "@img/sharp-linux-x64": "0.35.5",
+        "@img/sharp-linuxmusl-arm64": "0.35.5",
+        "@img/sharp-linuxmusl-x64": "0.35.5",
+        "@img/sharp-webcontainers-wasm32": "0.35.5",
+        "@img/sharp-win32-arm64": "0.35.5",
+        "@img/sharp-win32-ia32": "0.35.5",
+        "@img/sharp-win32-x64": "0.35.5"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/standardwebhooks": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/standardwebhooks/-/standardwebhooks-1.1.1.tgz",
+      "integrity": "sha512-bCbX9ZEyFkWPsRz7Bl3NuQUJohmwGSev/yhr7vhaGPlc4AfIrspIRa6cPTBuI1ItmrTDJ4d/S2hCsfe4+vQGnQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@stablelib/base64": "^1.0.0",
+        "fast-sha256": "^1.3.0"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "10.2.2",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-10.2.2.tgz",
+      "integrity": "sha512-SS+jx45GF1QjgEXQx4NJZV9ImqmO2NPz5FNsIHrsDjh2YsHnawpan7SNQ1o8NuhrbHZy9AZhIoCUiCeaW/C80g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/ts-algebra": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
+      "integrity": "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==",
+      "license": "MIT"
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici": {
+      "version": "7.29.1",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.29.1.tgz",
+      "integrity": "sha512-RYONW2MeafgYlkVOKYKkA/Ag7BmXqgIWCa8t1m0JcxrQg9pI9lEqRhAOruOBCbAohOa/gkCF+iPi9hrgvTzu6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.18.1"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/unenv": {
+      "version": "2.0.0-rc.24",
+      "resolved": "https://registry.npmjs.org/unenv/-/unenv-2.0.0-rc.24.tgz",
+      "integrity": "sha512-i7qRCmY42zmCwnYlh9H2SvLEypEFGye5iRmEMKjcGi7zk9UquigRjFtTLz0TYqr0ZGLZhaMHl/foy1bZR+Cwlw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "pathe": "^2.0.3"
+      }
+    },
+    "node_modules/workerd": {
+      "version": "1.20261019.1",
+      "resolved": "https://registry.npmjs.org/workerd/-/workerd-1.20261019.1.tgz",
+      "integrity": "sha512-UUYRUq/7DmeCl11YriNbcVbjUZVLtt8uuCXFu+nz77hGFf8d4DEVXoCYtnA+MlBatE4+wxoj47DVqzK3xGBAiw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "workerd": "bin/workerd"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "optionalDependencies": {
+        "@cloudflare/workerd-darwin-64": "1.20261019.1",
+        "@cloudflare/workerd-darwin-arm64": "1.20261019.1",
+        "@cloudflare/workerd-linux-64": "1.20261019.1",
+        "@cloudflare/workerd-linux-arm64": "1.20261019.1",
+        "@cloudflare/workerd-windows-64": "1.20261019.1"
+      }
+    },
+    "node_modules/wrangler": {
+      "version": "4.151.2",
+      "resolved": "https://registry.npmjs.org/wrangler/-/wrangler-4.151.2.tgz",
+      "integrity": "sha512-yIT5Q08eVP2ZSE4XHGZ81Y+Y1b25uzp7LANwV2siaEt/O7TpeiFiEih/xHwARHGQo8sufs2ZaILGxCccHgjQPg==",
+      "dev": true,
+      "license": "MIT OR Apache-2.0",
+      "dependencies": {
+        "@cloudflare/kv-asset-handler": "0.5.0",
+        "@cloudflare/unenv-preset": "2.16.2",
+        "blake3-wasm": "2.1.5",
+        "esbuild": "0.28.2",
+        "miniflare": "5.20261019.0-beta",
+        "path-to-regexp": "6.3.0",
+        "unenv": "2.0.0-rc.24",
+        "workerd": "1.20261019.1"
+      },
+      "bin": {
+        "cf-wrangler": "bin/cf-wrangler.js",
+        "wrangler": "bin/wrangler.js",
+        "wrangler2": "bin/wrangler.js"
+      },
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "2.3.3"
+      },
+      "peerDependencies": {
+        "@cloudflare/workers-types": "^5.20261019.1"
+      },
+      "peerDependenciesMeta": {
+        "@cloudflare/workers-types": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.21.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
+      "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/youch": {
+      "version": "4.1.0-beta.10",
+      "resolved": "https://registry.npmjs.org/youch/-/youch-4.1.0-beta.10.tgz",
+      "integrity": "sha512-rLfVLB4FgQneDr0dv1oddCVZmKjcJ6yX6mS4pU82Mq/Dt9a3cLZQ62pDBL4AUO+uVrCvtWz3ZFUL2HFAFJ/BXQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@poppinss/colors": "^4.1.5",
+        "@poppinss/dumper": "^0.6.4",
+        "@speed-highlight/core": "^1.2.7",
+        "cookie": "^1.0.2",
+        "youch-core": "^0.3.3"
+      }
+    },
+    "node_modules/youch-core": {
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/youch-core/-/youch-core-0.3.3.tgz",
+      "integrity": "sha512-ho7XuGjLaJ2hWHoK8yFnsUGy2Y5uDpqSTq1FkHLK4/oqKtyUU1AFbOOxY4IpC9f0fTLjwYbslUz0Po5BpD1wrA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@poppinss/exception": "^1.2.2",
+        "error-stack-parser-es": "^1.0.5"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.6.7",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.7.tgz",
+      "integrity": "sha512-g8W2D2kU6a8untc053fX1uVBKzM7yqAxW/3zwk83+6RyF2+SKOuV+c0wBDhUwzV1PaGapmZH+rmcUzPf+3CGwg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}
diff --git a/worker/package.json b/worker/package.json
new file mode 100644
index 0000000..8650414
--- /dev/null
+++ b/worker/package.json
@@ -0,0 +1,43 @@
+{
+  "name": "necprep-worker",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Cloudflare Worker + D1 API for NECPrep. Schema in migrations/, Drizzle definitions in db/.",
+  "scripts": {
+    "db:apply:local": "node db/apply.mjs",
+    "db:seed:local": "node --import ../scripts/ts-resolve.mjs db/seed/import-questions.mjs",
+    "db:reference": "node --import ../scripts/ts-resolve.mjs db/seed/generate-reference-sql.mjs",
+    "db:verify": "node db/verify-schema.mjs",
+    "db:measure": "node db/measure.mjs",
+    "db:smoke": "node db/smoke.mjs",
+    "db:export:remote": "node db/seed/export-content-sql.mjs",
+    "db:check": "npm run db:apply:local && npm run db:seed:local && npm run db:verify && npm run db:smoke && npm run typecheck",
+    "dev": "wrangler dev",
+    "dev:setup": "npm run db:apply:local && npm run db:seed:local && npm run db:export:remote && npm run d1:migrate:local && npm run d1:load:local",
+    "d1:load:local": "node db/seed/load-local-d1.mjs",
+    "d1:migrate:local": "wrangler d1 migrations apply necprep --local",
+    "d1:migrate:remote": "wrangler d1 migrations apply necprep --remote",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "node --test \"src/__tests__/*.test.ts\"",
+    "bundle:check": "wrangler deploy --dry-run --outdir .local/wbuild",
+    "check": "npm run db:check && npm run test && npm run bundle:check",
+    "explain:estimate": "node scripts/generate-explanations.mjs --estimate",
+    "explain:generate": "node scripts/generate-explanations.mjs",
+    "explain:collect": "node scripts/generate-explanations.mjs --collect",
+    "explain:review": "node scripts/review-explanations.mjs",
+    "explain:stats": "node scripts/review-explanations.mjs --stats"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.135.0",
+    "drizzle-orm": "^0.45.4",
+    "hono": "^4.13.13",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^5.20261019.1",
+    "@types/node": "^22.20.5",
+    "typescript": "^5.9.0",
+    "wrangler": "^4.151.2"
+  }
+}
diff --git a/worker/scripts/generate-explanations.mjs b/worker/scripts/generate-explanations.mjs
new file mode 100644
index 0000000..cd6ec3d
--- /dev/null
+++ b/worker/scripts/generate-explanations.mjs
@@ -0,0 +1,617 @@
+#!/usr/bin/env node
+/**
+ * generate-explanations.mjs
+ *
+ * Drafts an explanation for every published question that lacks one, using the
+ * Anthropic Batch API, and writes the results into `explanations` with
+ * `origin = 'ai_draft'`.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * Not one of the 2,290 imported questions carries an explanation. A student who
+ * answers wrong is told "the correct answer is B" and nothing else, so the bank
+ * can test but never teach. That is the largest remaining quality gap in the
+ * product, and the owner has confirmed no authored explanations are coming.
+ *
+ * THE KEY IS AN INPUT, NOT A QUESTION
+ * -----------------------------------
+ * The model is told which option the bank keys as correct and asked to explain
+ * *that* option. It is NOT asked to solve the question, because a model that
+ * disagrees with the key and silently explains its own answer produces an
+ * explanation that contradicts the grading -- the worst possible output.
+ *
+ * Instead the model must report `agrees_with_key`, and a disagreement is
+ * treated as an errata signal rather than an explanation: the row is withheld
+ * and a `question_reports` entry is filed for human adjudication. This makes
+ * the pass a second, independent audit of all 2,184 answer keys at no extra
+ * cost -- which matters, because the first audit found 17 questions whose own
+ * two answer fields contradicted each other.
+ *
+ * COST
+ * ----
+ * The Batch API is 50% of standard rates and the shared instruction block is
+ * cached, so the marginal cost is dominated by per-question output tokens. At
+ * Claude Opus 5 batch rates ($2.50 / $12.50 per MTok) a full run over ~2,180
+ * questions costs roughly $25-30. Run with --estimate for a measured figure
+ * from the real bank before spending anything.
+ *
+ * USAGE
+ *   node scripts/generate-explanations.mjs --estimate          # token/cost estimate, no API calls
+ *   node scripts/generate-explanations.mjs --dry-run           # build and print one request, no API calls
+ *   node scripts/generate-explanations.mjs --limit 20          # submit a 20-question pilot batch
+ *   node scripts/generate-explanations.mjs                     # submit the full backlog
+ *   node scripts/generate-explanations.mjs --collect <batchId> # poll and ingest a submitted batch
+ *
+ * Requires ANTHROPIC_API_KEY, or an `ant auth login` profile (the SDK resolves
+ * either; see `ant auth status`).
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash, randomUUID } from 'node:crypto';
+import Anthropic from '@anthropic-ai/sdk';
+
+const WORKER_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const DEFAULT_DB = join(WORKER_ROOT, '.local', 'necprep.sqlite');
+const STATE_DIR = join(WORKER_ROOT, '.local', 'explanations');
+
+/**
+ * Bumped whenever the instruction block below changes in a way that could
+ * change output. Stored on every row so a bad cohort can be found and redone.
+ */
+const PROMPT_VERSION = 'explain-v1';
+const MODEL = 'claude-opus-5';
+
+// Claude Opus 5 list price, per million tokens. Batch is 50%.
+const PRICE_IN_PER_MTOK = 5.0;
+const PRICE_OUT_PER_MTOK = 25.0;
+const BATCH_DISCOUNT = 0.5;
+
+// --- The instruction block --------------------------------------------------
+// Stable across every request in the run and placed before the per-question
+// content, so it is a cacheable prefix. Prompt caching needs >= 512 tokens on
+// Claude Opus 5; this block clears that, which is why it is one block rather
+// than being inlined per question.
+const SYSTEM_PROMPT = `You write explanations for multiple-choice questions on the Nepal Engineering Council (NEC) licensing examination, Computer Engineering stream. Your readers are graduate engineers preparing for a professional licence. They have just answered the question and are now looking at the explanation.
+
+You are given the question, its options, and which option the question bank keys as correct. Your job is to explain why the keyed option is correct — not to decide what the answer should be.
+
+If you believe the keyed option is NOT correct, say so via the agrees_with_key field and explain the discrepancy in key_disagreement_reason. Do not write an explanation arguing for a different answer: the bank grades against the keyed option, so an explanation that contradicts it would tell a student they were marked wrong unfairly without fixing anything. A disagreement from you is routed to a human for adjudication, which is the useful outcome.
+
+Set agrees_with_key to false when any of these hold:
+- The keyed option is factually wrong.
+- More than one option is defensibly correct, so the question cannot be graded fairly as single-answer.
+- No option is correct.
+- The stem is ambiguous, self-contradictory, or missing information needed to answer it.
+
+Writing the explanation:
+- summary: one to three sentences stating why the keyed option is correct. This is the part most students read, so it must stand alone. Lead with the reason, not with restating the question.
+- detail: the working, when the question needs it — a derivation, a formula with its substitution, a truth table, a worked conversion. Omit it entirely for pure recall questions where there is nothing to work through; padding a definition question with filler teaches nothing. Markdown. Keep formulas in plain text or simple LaTeX; this renders in a small panel on a phone.
+- distractor_rationales: for each incorrect option, one sentence on why it is wrong AND, where there is one, what misconception makes it tempting. "Confuses series and parallel resonance" teaches; "this is incorrect" does not. Skip an option only when it is arbitrary filler with no instructive content.
+- confidence: 0-10, your confidence that the keyed option is correct and your explanation of it is sound. Be honest and use the low end: these drafts are shown to students labelled as unreviewed, and your confidence sets the order in which humans review them. A 4 that is actually uncertain is far more useful than an inflated 8.
+
+Constraints:
+- Be correct before being complete. If you are unsure of a numeric result, show the method and say what you are unsure about rather than asserting a number.
+- Never refer to the options by position ("the second option"). Options are reordered per student, so positions are not stable. Name the option's text, or use the letter given to you in this prompt only inside distractor_rationales, where it is mapped back by label.
+- Do not address the reader as "you" having chosen a particular option; the same explanation is shown to students who answered correctly and incorrectly.
+- No preamble, no "Great question", no restating the stem.`;
+
+const RESPONSE_SCHEMA = {
+  type: 'object',
+  properties: {
+    agrees_with_key: {
+      type: 'boolean',
+      description: 'True if the keyed option is correct and gradeable as single-answer.',
+    },
+    key_disagreement_reason: {
+      type: ['string', 'null'],
+      description:
+        'Required when agrees_with_key is false: what is wrong with the key, stem, or options.',
+    },
+    summary: {
+      type: 'string',
+      description:
+        'One to three sentences on why the keyed option is correct. Empty string if agrees_with_key is false.',
+    },
+    detail: {
+      type: ['string', 'null'],
+      description: 'Optional markdown working. Null for pure recall questions.',
+    },
+    distractor_rationales: {
+      type: 'array',
+      description: 'Why each incorrect option is wrong, and the misconception behind it.',
+      items: {
+        type: 'object',
+        properties: {
+          option_label: { type: 'string', description: 'The label given in the prompt, e.g. "B".' },
+          why: { type: 'string' },
+        },
+        required: ['option_label', 'why'],
+        additionalProperties: false,
+      },
+    },
+    confidence: { type: 'integer', description: '0-10, honest.' },
+  },
+  required: ['agrees_with_key', 'summary', 'distractor_rationales', 'confidence'],
+  additionalProperties: false,
+};
+
+// --- Selection --------------------------------------------------------------
+
+/**
+ * Questions needing an explanation, hardest-first.
+ *
+ * Priority is `responses * (1 - pCorrect)` — the questions the most students
+ * get wrong, which is where an explanation does the most good. That data does
+ * not exist yet (no attempt has ever been recorded), so the fallback is
+ * deterministic and states its own reasoning: questions that appear in a mock
+ * test blueprint come first, then by chapter so an interrupted run leaves whole
+ * chapters done rather than a thin scatter.
+ */
+function selectQuestions(db, limit) {
+  const rows = db
+    .prepare(
+      `SELECT q.id,
+              q.stem,
+              q.chapter_id,
+              q.p_value_bp,
+              COALESCE(q.p_value_n, 0) AS p_value_n,
+              c.nec_code               AS chapter_code,
+              c.title                  AS chapter_title
+         FROM questions q
+         JOIN chapters c ON c.id = q.chapter_id
+        WHERE q.status = 'published'
+          AND NOT EXISTS (
+                SELECT 1 FROM explanations e
+                 WHERE e.question_id = q.id
+                   AND e.kind = 'solution'
+                   AND e.status IN ('draft', 'published'))
+        -- responses * (1 - pCorrect), negated so the most-missed come first.
+        -- p_value_n is 0 for every question today (no attempt has been
+        -- recorded), so this term is currently a no-op and the chapter order
+        -- below is what actually decides. It starts working the moment real
+        -- attempt data exists, with no change here.
+     ORDER BY CASE WHEN COALESCE(q.p_value_n, 0) > 0
+                   THEN -(q.p_value_n * (10000 - COALESCE(q.p_value_bp, 5000)))
+                   ELSE 0 END,
+              c.ordinal,
+              q.id`
+    )
+    .all();
+
+  const withOptions = db.prepare(
+    `SELECT o.id, o.ordinal, o.text, o.is_pinned,
+            CASE WHEN k.correct_option_id = o.id THEN 1 ELSE 0 END AS is_correct
+       FROM question_options o
+       JOIN question_answer_keys k ON k.question_id = o.question_id
+      WHERE o.question_id = ? AND o.retired_at IS NULL
+   ORDER BY o.ordinal`
+  );
+
+  const out = [];
+  for (const row of rows) {
+    const options = withOptions.all(row.id);
+    // A question with no reachable key cannot be explained; it is a data
+    // defect, and the importer already filed a report for it.
+    if (!options.some((o) => o.is_correct)) continue;
+    out.push({ ...row, options });
+    if (limit && out.length >= limit) break;
+  }
+  return out;
+}
+
+const LABELS = ['A', 'B', 'C', 'D', 'E', 'F'];
+
+function buildUserContent(q) {
+  const lines = [
+    `Chapter: ${q.chapter_code} — ${q.chapter_title}`,
+    '',
+    `Question: ${q.stem}`,
+    '',
+    'Options:',
+  ];
+  q.options.forEach((o, i) => {
+    lines.push(`  ${LABELS[i]}. ${o.text}`);
+  });
+  const correctIndex = q.options.findIndex((o) => o.is_correct);
+  lines.push('', `The question bank keys ${LABELS[correctIndex]} as the correct answer.`);
+  return lines.join('\n');
+}
+
+function buildRequest(q) {
+  return {
+    custom_id: q.id,
+    params: {
+      model: MODEL,
+      max_tokens: 4096,
+      // The instruction block is identical across every request in the run, so
+      // caching it turns ~2,180 full-price reads of it into one write plus
+      // ~2,180 reads at a tenth of the price.
+      system: [{ type: 'text', text: SYSTEM_PROMPT, cache_control: { type: 'ephemeral' } }],
+      output_config: { format: { type: 'json_schema', schema: RESPONSE_SCHEMA } },
+      messages: [{ role: 'user', content: buildUserContent(q) }],
+    },
+  };
+}
+
+// --- Estimate ---------------------------------------------------------------
+
+async function estimate(client, questions) {
+  const sampleSize = Math.min(25, questions.length);
+  const sample = questions.slice(0, sampleSize);
+
+  let inputTokens = 0;
+  for (const q of sample) {
+    const counted = await client.messages.countTokens({
+      model: MODEL,
+      system: [{ type: 'text', text: SYSTEM_PROMPT }],
+      messages: [{ role: 'user', content: buildUserContent(q) }],
+    });
+    inputTokens += counted.input_tokens;
+  }
+  const avgInput = inputTokens / sampleSize;
+
+  const systemOnly = await client.messages.countTokens({
+    model: MODEL,
+    system: [{ type: 'text', text: SYSTEM_PROMPT }],
+    messages: [{ role: 'user', content: 'x' }],
+  });
+  const sharedPrefix = systemOnly.input_tokens;
+  const perQuestion = Math.max(0, avgInput - sharedPrefix);
+
+  // Thinking is on by default on Claude Opus 5 and its tokens are billed as
+  // output. 900 is a deliberately pessimistic per-question figure for thinking
+  // plus a structured answer; the real number lands lower on recall questions.
+  const ASSUMED_OUTPUT = 900;
+
+  const n = questions.length;
+  const cachedReads = (sharedPrefix * (n - 1) * 0.1) / 1e6;
+  const cacheWrite = (sharedPrefix * 1.25) / 1e6;
+  const uniqueInput = (perQuestion * n) / 1e6;
+  const output = (ASSUMED_OUTPUT * n) / 1e6;
+
+  const inCost = (cachedReads + cacheWrite + uniqueInput) * PRICE_IN_PER_MTOK * BATCH_DISCOUNT;
+  const outCost = output * PRICE_OUT_PER_MTOK * BATCH_DISCOUNT;
+
+  console.log(`
+  questions needing an explanation   ${n}
+  measured shared prefix            ${sharedPrefix} tokens (cached)
+  measured per-question input       ${perQuestion.toFixed(0)} tokens  (mean of ${sampleSize})
+  assumed output per question        ${ASSUMED_OUTPUT} tokens  (thinking + structured answer)
+
+  at Claude Opus 5 batch rates ($${(PRICE_IN_PER_MTOK * BATCH_DISCOUNT).toFixed(2)} / $${(PRICE_OUT_PER_MTOK * BATCH_DISCOUNT).toFixed(2)} per MTok):
+    input   $${inCost.toFixed(2)}
+    output  $${outCost.toFixed(2)}
+    TOTAL   $${(inCost + outCost).toFixed(2)}
+
+  Output is the dominant term and is an assumption, not a measurement. Run a
+  --limit 20 pilot first and read its reported usage before committing.
+`);
+}
+
+// --- Submit -----------------------------------------------------------------
+
+async function submit(client, db, questions) {
+  const requests = questions.map(buildRequest);
+  console.log(`  submitting ${requests.length} requests...`);
+
+  const batch = await client.messages.batches.create({ requests });
+
+  mkdirSync(STATE_DIR, { recursive: true });
+  const statePath = join(STATE_DIR, `${batch.id}.json`);
+  writeFileSync(
+    statePath,
+    JSON.stringify(
+      {
+        batchId: batch.id,
+        model: MODEL,
+        promptVersion: PROMPT_VERSION,
+        submittedAt: new Date().toISOString(),
+        questionIds: questions.map((q) => q.id),
+      },
+      null,
+      2
+    ) + '\n'
+  );
+
+  console.log(`  batch id      ${batch.id}`);
+  console.log(`  status        ${batch.processing_status}`);
+  console.log(`  state written ${statePath}`);
+  console.log(`\n  collect with: node scripts/generate-explanations.mjs --collect ${batch.id}\n`);
+  return batch;
+}
+
+// --- Collect ----------------------------------------------------------------
+
+async function collect(client, db, batchId) {
+  let batch = await client.messages.batches.retrieve(batchId);
+  while (batch.processing_status !== 'ended') {
+    const c = batch.request_counts;
+    console.log(
+      `  ${batch.processing_status}: processing ${c.processing}, succeeded ${c.succeeded}, errored ${c.errored}`
+    );
+    await new Promise((r) => setTimeout(r, 30_000));
+    batch = await client.messages.batches.retrieve(batchId);
+  }
+
+  return ingest(db, await client.messages.batches.results(batchId), batchId);
+}
+
+/**
+ * Writes one batch's results into the database.
+ *
+ * Separated from the poll loop above so it can run against a local file of
+ * results — both to test this path without spending anything, and to re-ingest
+ * after a crash without re-submitting a batch. `results` is any async iterable
+ * of batch result objects, which is what `batches.results()` returns.
+ */
+async function ingest(db, results, batchId) {
+  const stats = {
+    succeeded: 0,
+    refused: 0,
+    errored: 0,
+    expired: 0,
+    canceled: 0,
+    disagreed: 0,
+    written: 0,
+    rationalesWritten: 0,
+    invalidShape: 0,
+    unmatchedOption: 0,
+    confidence: [],
+  };
+
+  const optionsFor = db.prepare(
+    `SELECT id, ordinal, text FROM question_options
+      WHERE question_id = ? AND retired_at IS NULL ORDER BY ordinal`
+  );
+  const insertExplanation = db.prepare(
+    `INSERT INTO explanations
+       (question_id, body, body_format, about_option_id, kind, is_primary, status,
+        origin, generator_model, generator_prompt_version, generated_at,
+        generator_confidence_bp, created_at, updated_at)
+     VALUES (?, ?, 'markdown', ?, ?, ?, ?, 'ai_draft', ?, ?, ?, ?, ?, ?)`
+  );
+  // `reporter_user_id` must be NULL when source is 'validator' (CHECK), and
+  // `code` is left NULL deliberately: the model's reason is free text and the
+  // code vocabulary is for defects a rule detected. The detail is prefixed so
+  // these are greppable among user-filed reports.
+  const insertReport = db.prepare(
+    `INSERT INTO question_reports
+       (public_id, question_id, reporter_user_id, source, category, code, detail,
+        status, created_at, updated_at)
+     VALUES (?, ?, NULL, 'validator', 'wrong_answer', NULL, ?, 'open', ?, ?)`
+  );
+  // The unique index that would catch a duplicate only covers user-filed
+  // reports (it is partial on reporter_user_id IS NOT NULL), so a re-ingest of
+  // the same batch would otherwise file the same report twice. Check first.
+  const reportExists = db.prepare(
+    `SELECT 1 FROM question_reports
+      WHERE question_id = ? AND source = 'validator' AND status = 'open'
+        AND detail LIKE 'explanation-generator-disagreement%'`
+  );
+
+  const now = Date.now();
+  const generatedAt = now;
+
+  for await (const result of results) {
+    const qid = result.custom_id;
+
+    if (result.result.type !== 'succeeded') {
+      stats[result.result.type] = (stats[result.result.type] ?? 0) + 1;
+      if (result.result.type === 'errored') {
+        console.error(`  errored  ${qid}: ${result.result.error?.type ?? 'unknown'}`);
+      }
+      continue;
+    }
+
+    const message = result.result.message;
+
+    // A refusal is HTTP 200 with an empty or partial content array. Reading
+    // content[0] unconditionally would throw here.
+    if (message.stop_reason === 'refusal') {
+      stats.refused++;
+      console.error(`  refused  ${qid}: ${message.stop_details?.category ?? 'uncategorised'}`);
+      continue;
+    }
+
+    const textBlock = message.content.find((b) => b.type === 'text');
+    if (!textBlock) {
+      stats.invalidShape++;
+      continue;
+    }
+
+    let parsed;
+    try {
+      parsed = JSON.parse(textBlock.text);
+    } catch {
+      stats.invalidShape++;
+      console.error(`  unparseable JSON for ${qid}`);
+      continue;
+    }
+
+    stats.succeeded++;
+    if (Number.isInteger(parsed.confidence)) stats.confidence.push(parsed.confidence);
+
+    // A model that disagrees with the key produces an errata report, not an
+    // explanation. Nothing is published on this path.
+    if (parsed.agrees_with_key === false) {
+      stats.disagreed++;
+      if (!reportExists.get(qid)) {
+        insertReport.run(
+          randomUUID().replace(/-/g, '').slice(0, 26).toUpperCase(),
+          qid,
+          `explanation-generator-disagreement (${MODEL}, ${PROMPT_VERSION}): ` +
+            (parsed.key_disagreement_reason ?? '(no reason given)'),
+          now,
+          now
+        );
+      }
+      continue;
+    }
+
+    const summary = String(parsed.summary ?? '').trim();
+    if (!summary) {
+      stats.invalidShape++;
+      continue;
+    }
+
+    const confidenceBp = Number.isInteger(parsed.confidence)
+      ? Math.max(0, Math.min(10000, parsed.confidence * 1000))
+      : null;
+
+    const body =
+      parsed.detail && String(parsed.detail).trim()
+        ? `${summary}\n\n${String(parsed.detail).trim()}`
+        : summary;
+
+    insertExplanation.run(
+      qid,
+      body,
+      null,
+      'solution',
+      1,
+      'published',
+      MODEL,
+      PROMPT_VERSION,
+      generatedAt,
+      confidenceBp,
+      now,
+      now
+    );
+    stats.written++;
+
+    // Distractor rationales are matched back to options by label position,
+    // which is the one place the label-to-option mapping has to be reconstructed
+    // the same way buildUserContent assigned it. A label that does not resolve
+    // is dropped rather than guessed.
+    const opts = optionsFor.all(qid);
+    for (const r of parsed.distractor_rationales ?? []) {
+      const idx = LABELS.indexOf(String(r.option_label ?? '').trim().toUpperCase());
+      const opt = idx >= 0 ? opts[idx] : undefined;
+      if (!opt || !String(r.why ?? '').trim()) {
+        stats.unmatchedOption++;
+        continue;
+      }
+      insertExplanation.run(
+        qid,
+        String(r.why).trim(),
+        opt.id,
+        'distractor',
+        0,
+        'published',
+        MODEL,
+        PROMPT_VERSION,
+        generatedAt,
+        confidenceBp,
+        now,
+        now
+      );
+      stats.rationalesWritten++;
+    }
+  }
+
+  const conf = stats.confidence;
+  const mean = conf.length ? conf.reduce((a, b) => a + b, 0) / conf.length : 0;
+  const low = conf.filter((c) => c <= 5).length;
+
+  console.log(`
+  batch ${batchId} ingested
+
+    succeeded                 ${stats.succeeded}
+    primary explanations      ${stats.written}
+    distractor rationales     ${stats.rationalesWritten}
+    KEY DISAGREEMENTS         ${stats.disagreed}  -> filed as errata, nothing published
+    refused                   ${stats.refused}
+    errored / expired / cxl   ${stats.errored} / ${stats.expired} / ${stats.canceled}
+    unparseable or empty      ${stats.invalidShape}
+    dropped rationales        ${stats.unmatchedOption}
+
+    mean confidence           ${mean.toFixed(1)} / 10
+    confidence <= 5           ${low}  -> review these first
+
+  Everything written is origin='ai_draft', status='published': served to
+  students WITH an unreviewed badge, and never during a timed mock test.
+  Review with: node scripts/review-explanations.mjs
+`);
+
+  return stats;
+}
+
+// --- Main -------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+const flag = (name) => args.includes(name);
+const value = (name, fallback) => {
+  const i = args.indexOf(name);
+  return i >= 0 && args[i + 1] ? args[i + 1] : fallback;
+};
+
+const dbPath = resolve(value('--db', DEFAULT_DB));
+if (!existsSync(dbPath)) {
+  console.error(`no database at ${dbPath}. Run \`npm run db:apply:local && npm run db:seed:local\`.`);
+  process.exit(2);
+}
+const db = new DatabaseSync(dbPath);
+db.exec('PRAGMA foreign_keys = ON');
+
+const limit = Number(value('--limit', '0')) || 0;
+
+if (flag('--ingest-file')) {
+  const path = value('--ingest-file');
+  if (!path || path.startsWith('--')) {
+    console.error('--ingest-file requires a path to a JSONL file of batch results');
+    process.exit(2);
+  }
+  const lines = readFileSync(resolve(path), 'utf8').split('\n').filter((l) => l.trim());
+  async function* fromFile() {
+    for (const line of lines) yield JSON.parse(line);
+  }
+  await ingest(db, fromFile(), `file:${path}`);
+  db.close();
+  process.exit(0);
+}
+
+if (flag('--collect')) {
+  const batchId = value('--collect');
+  if (!batchId || batchId.startsWith('--')) {
+    console.error('--collect requires a batch id');
+    process.exit(2);
+  }
+  await collect(new Anthropic(), db, batchId);
+  db.close();
+  process.exit(0);
+}
+
+const questions = selectQuestions(db, limit);
+console.log(`\n  ${questions.length} published question(s) without an explanation`);
+
+if (questions.length === 0) {
+  console.log('  nothing to do\n');
+  db.close();
+  process.exit(0);
+}
+
+if (flag('--dry-run')) {
+  const req = buildRequest(questions[0]);
+  console.log('\n  --- first request (not sent) ---\n');
+  console.log(`  custom_id: ${req.custom_id}`);
+  console.log(`  model:     ${req.params.model}`);
+  console.log('\n' + req.params.messages[0].content.replace(/^/gm, '  '));
+  console.log(`\n  system prompt: ${SYSTEM_PROMPT.length} chars, cache_control ephemeral`);
+  console.log(`  schema keys:   ${Object.keys(RESPONSE_SCHEMA.properties).join(', ')}\n`);
+  db.close();
+  process.exit(0);
+}
+
+const client = new Anthropic();
+
+if (flag('--estimate')) {
+  await estimate(client, questions);
+  db.close();
+  process.exit(0);
+}
+
+await submit(client, db, questions);
+db.close();
diff --git a/worker/scripts/review-explanations.mjs b/worker/scripts/review-explanations.mjs
new file mode 100644
index 0000000..231f722
--- /dev/null
+++ b/worker/scripts/review-explanations.mjs
@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+/**
+ * review-explanations.mjs
+ *
+ * Drains the AI-draft explanation backlog: shows one question, its options, the
+ * keyed answer, and the generated explanation, then records accept / edit /
+ * reject.
+ *
+ * WHY A REVIEW TOOL AT ALL
+ * ------------------------
+ * The generator publishes drafts with `origin = 'ai_draft'`, which students see
+ * badged as unreviewed. That is a deliberate trade — a flagged draft beats "the
+ * correct answer is B" — but it is only defensible if the backlog actually gets
+ * drained, and a backlog with no tool is a backlog that never shrinks.
+ *
+ * REVIEW ORDER
+ * ------------
+ * Least model-confident first. The generator is told its confidence sets review
+ * order, so a 3 is the model saying "check this one", and reviewing in that
+ * order finds the bad drafts fastest. Once attempt data exists, the better
+ * order is `responses * (1 - pCorrect)` — the drafts the most students read —
+ * and `--order impact` switches to that; it falls back to confidence while
+ * every question still has zero recorded answers.
+ *
+ * USAGE
+ *   node scripts/review-explanations.mjs                      # interactive queue
+ *   node scripts/review-explanations.mjs --stats              # backlog summary only
+ *   node scripts/review-explanations.mjs --order impact       # most-read first
+ *   node scripts/review-explanations.mjs --chapter AExE01     # one chapter
+ *   node scripts/review-explanations.mjs --limit 25
+ *   node scripts/review-explanations.mjs --reviewer <user_id> # attribute to a real user
+ *
+ * Keys: [a]ccept  [r]eject  [e]dit  [f]lag the question  [s]kip  [q]uit
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createInterface } from 'node:readline';
+import { randomUUID } from 'node:crypto';
+
+const WORKER_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const DEFAULT_DB = join(WORKER_ROOT, '.local', 'necprep.sqlite');
+
+const args = process.argv.slice(2);
+const flag = (n) => args.includes(n);
+const value = (n, d) => {
+  const i = args.indexOf(n);
+  return i >= 0 && args[i + 1] && !args[i + 1].startsWith('--') ? args[i + 1] : d;
+};
+
+const dbPath = resolve(value('--db', DEFAULT_DB));
+if (!existsSync(dbPath)) {
+  console.error(`no database at ${dbPath}`);
+  process.exit(2);
+}
+const db = new DatabaseSync(dbPath);
+db.exec('PRAGMA foreign_keys = ON');
+
+// A reviewer id is recorded on every acceptance. `explanations` has a CHECK
+// that an ai_reviewed row names its reviewer, and reviewed_by is a foreign key
+// to users, so an unknown id would fail — hence the existence check rather than
+// writing whatever was passed.
+const reviewerArg = value('--reviewer', null);
+let reviewerId = null;
+if (reviewerArg) {
+  const found = db.prepare('SELECT id FROM users WHERE id = ?').get(reviewerArg);
+  if (!found) {
+    console.error(`--reviewer ${reviewerArg} is not a user id in this database`);
+    process.exit(2);
+  }
+  reviewerId = found.id;
+}
+
+// --- Stats ------------------------------------------------------------------
+
+function printStats() {
+  const row = db
+    .prepare(
+      `SELECT
+         SUM(origin = 'ai_draft'    AND status = 'published') AS unreviewed,
+         SUM(origin = 'ai_reviewed')                          AS reviewed,
+         SUM(origin = 'human')                                AS human,
+         SUM(status = 'rejected')                             AS rejected
+       FROM explanations WHERE kind = 'solution'`
+    )
+    .get();
+
+  const total = db
+    .prepare(`SELECT COUNT(*) n FROM questions WHERE status = 'published'`)
+    .get().n;
+  const covered = db
+    .prepare(
+      `SELECT COUNT(DISTINCT question_id) n FROM explanations
+        WHERE kind = 'solution' AND status = 'published'`
+    )
+    .get().n;
+
+  const buckets = db
+    .prepare(
+      `SELECT CASE
+                WHEN generator_confidence_bp IS NULL     THEN 'unknown'
+                WHEN generator_confidence_bp <= 4000     THEN '0-4  (check first)'
+                WHEN generator_confidence_bp <= 6000     THEN '5-6'
+                WHEN generator_confidence_bp <= 8000     THEN '7-8'
+                ELSE                                          '9-10'
+              END AS bucket,
+              COUNT(*) n
+         FROM explanations
+        WHERE kind = 'solution' AND origin = 'ai_draft' AND status = 'published'
+     GROUP BY bucket ORDER BY bucket`
+    )
+    .all();
+
+  const disagreements = db
+    .prepare(
+      `SELECT COUNT(*) n FROM question_reports
+        WHERE status = 'open' AND detail LIKE 'explanation-generator-disagreement%'`
+    )
+    .get().n;
+
+  console.log(`
+  explanation coverage      ${covered} / ${total} published questions  (${((covered / total) * 100).toFixed(1)}%)
+
+  unreviewed AI drafts      ${row.unreviewed ?? 0}   <- served to students, badged
+  reviewed AI drafts        ${row.reviewed ?? 0}
+  human-written             ${row.human ?? 0}
+  rejected                  ${row.rejected ?? 0}
+
+  open key disagreements    ${disagreements}   <- the generator refused to explain these
+`);
+  if (buckets.length) {
+    console.log('  unreviewed drafts by model confidence:');
+    for (const b of buckets) console.log(`    ${String(b.n).padStart(5)}  ${b.bucket}`);
+    console.log('');
+  }
+}
+
+if (flag('--stats')) {
+  printStats();
+  db.close();
+  process.exit(0);
+}
+
+// --- Queue ------------------------------------------------------------------
+
+const chapter = value('--chapter', null);
+const limit = Number(value('--limit', '0')) || 0;
+const order = value('--order', 'confidence');
+
+const queue = db
+  .prepare(
+    `SELECT e.id, e.question_id, e.body, e.generator_confidence_bp AS conf,
+            e.generator_model, e.generator_prompt_version,
+            q.stem, q.p_value_n, q.p_value_bp,
+            c.nec_code AS chapter_code, c.title AS chapter_title,
+            k.correct_option_id
+       FROM explanations e
+       JOIN questions q ON q.id = e.question_id
+       JOIN chapters  c ON c.id = q.chapter_id
+       JOIN question_answer_keys k ON k.question_id = q.id
+      WHERE e.kind = 'solution'
+        AND e.origin = 'ai_draft'
+        AND e.status = 'published'
+        AND (? IS NULL OR c.nec_code = ?)
+   ORDER BY CASE WHEN ? = 'impact' AND COALESCE(q.p_value_n, 0) > 0
+                 THEN -(q.p_value_n * (10000 - COALESCE(q.p_value_bp, 5000)))
+                 ELSE 0 END,
+            COALESCE(e.generator_confidence_bp, 0),
+            e.id`
+  )
+  .all(chapter, chapter, order);
+
+const work = limit ? queue.slice(0, limit) : queue;
+
+printStats();
+
+if (work.length === 0) {
+  console.log('  nothing to review\n');
+  db.close();
+  process.exit(0);
+}
+
+const optionsFor = db.prepare(
+  `SELECT id, ordinal, text FROM question_options
+    WHERE question_id = ? AND retired_at IS NULL ORDER BY ordinal`
+);
+const rationalesFor = db.prepare(
+  `SELECT e.body, o.text AS option_text
+     FROM explanations e JOIN question_options o ON o.id = e.about_option_id
+    WHERE e.question_id = ? AND e.kind = 'distractor' AND e.status = 'published'
+ ORDER BY o.ordinal`
+);
+
+const accept = db.prepare(
+  `UPDATE explanations
+      SET origin = 'ai_reviewed', reviewed_by = ?, reviewed_at = ?, updated_at = ?
+    WHERE question_id = ? AND origin = 'ai_draft' AND status = 'published'`
+);
+const rejectAll = db.prepare(
+  `UPDATE explanations
+      SET status = 'rejected', reviewed_by = ?, reviewed_at = ?, updated_at = ?
+    WHERE question_id = ? AND origin = 'ai_draft' AND status = 'published'`
+);
+const editBody = db.prepare(
+  `UPDATE explanations
+      SET body = ?, origin = 'human',
+          generator_model = NULL, generator_prompt_version = NULL,
+          generated_at = NULL, generator_confidence_bp = NULL,
+          author_user_id = ?, reviewed_by = ?, reviewed_at = ?, updated_at = ?
+    WHERE id = ?`
+);
+const flagQuestion = db.prepare(
+  `INSERT INTO question_reports
+     (public_id, question_id, reporter_user_id, source, category, code, detail,
+      status, created_at, updated_at)
+   VALUES (?, ?, NULL, 'admin', 'wrong_answer', NULL, ?, 'open', ?, ?)`
+);
+
+/**
+ * Line reader that works both interactively and from a pipe.
+ *
+ * `readline.question` does not queue: with piped stdin every line arrives at
+ * once, only the prompt with a callback registered at that moment captures one,
+ * and the rest are dropped — the next `await` then never settles and the
+ * process hangs on an unsettled top-level await. So when stdin is not a TTY,
+ * read it to EOF first and serve answers from the buffer. That also makes the
+ * tool scriptable, e.g. bulk-accepting a chapter you have already spot-checked:
+ *
+ *   yes a | node scripts/review-explanations.mjs --chapter ACtE03 --reviewer <id>
+ */
+async function makeAsk() {
+  if (process.stdin.isTTY) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return {
+      ask: (q) => new Promise((res) => rl.question(q, res)),
+      close: () => rl.close(),
+    };
+  }
+
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const lines = Buffer.concat(chunks).toString('utf8').split('\n');
+  let i = 0;
+  return {
+    // Past end of input, answer 'q' so the queue stops cleanly rather than
+    // looping on an empty string and silently skipping every remaining draft.
+    ask: async (q) => {
+      const line = i < lines.length ? lines[i++] : 'q';
+      process.stdout.write(q + line + '\n');
+      return line;
+    },
+    close: () => {},
+  };
+}
+
+const { ask, close: closeInput } = await makeAsk();
+
+const tally = { accepted: 0, rejected: 0, edited: 0, flagged: 0, skipped: 0 };
+
+console.log(`  ${work.length} draft(s) queued, least-confident first`);
+if (!reviewerId) {
+  console.log('  NOTE: no --reviewer given; acceptances will be recorded without a reviewer id,');
+  console.log('        which the ai_reviewed CHECK forbids. Accept is disabled this run.\n');
+}
+
+for (let i = 0; i < work.length; i++) {
+  const d = work[i];
+  const opts = optionsFor.all(d.question_id);
+  const correct = opts.find((o) => o.id === d.correct_option_id);
+
+  console.log('\n' + '='.repeat(74));
+  console.log(`  ${i + 1}/${work.length}   ${d.chapter_code}   confidence ${d.conf / 1000}/10`);
+  console.log(`  ${d.question_id}   ${d.generator_model} / ${d.generator_prompt_version}`);
+  console.log('='.repeat(74));
+  console.log(`\n  ${d.stem}\n`);
+  for (const o of opts) {
+    console.log(`    ${o.id === d.correct_option_id ? '->' : '  '} ${o.text}`);
+  }
+  console.log(`\n  KEYED ANSWER: ${correct ? correct.text : '(unresolved)'}`);
+  console.log('\n  --- draft explanation ---\n');
+  console.log(
+    d.body
+      .split('\n')
+      .map((l) => '  ' + l)
+      .join('\n')
+  );
+  const rats = rationalesFor.all(d.question_id);
+  if (rats.length) {
+    console.log('\n  --- why the others are wrong ---');
+    for (const r of rats) console.log(`    ${r.option_text}: ${r.body}`);
+  }
+
+  const prompt = reviewerId
+    ? '\n  [a]ccept  [r]eject  [e]dit  [f]lag question  [s]kip  [q]uit > '
+    : '\n  [r]eject  [f]lag question  [s]kip  [q]uit > ';
+  const answer = (await ask(prompt)).trim().toLowerCase();
+  const now = Date.now();
+
+  if (answer === 'q') break;
+
+  if (answer === 'a' && reviewerId) {
+    accept.run(reviewerId, now, now, d.question_id);
+    tally.accepted++;
+    console.log('  accepted — badge removed, now reads "AI draft, reviewed"');
+  } else if (answer === 'r') {
+    // `reviewed_by` and `reviewed_at` must be set or unset together (CHECK), so
+    // an anonymous rejection records neither rather than a timestamp with no
+    // reviewer. Rejecting without --reviewer is still allowed: withdrawing a
+    // bad draft should never be blocked on having a user row to attribute it to.
+    rejectAll.run(reviewerId, reviewerId ? now : null, now, d.question_id);
+    tally.rejected++;
+    console.log('  rejected — withdrawn from delivery; the question has no explanation again');
+  } else if (answer === 'e' && reviewerId) {
+    console.log('  Enter the corrected explanation. Blank line ends input.');
+    const lines = [];
+    for (;;) {
+      const line = await ask('  | ');
+      if (!line.trim()) break;
+      lines.push(line);
+    }
+    const body = lines.join('\n').trim();
+    if (body) {
+      // An edited explanation is human-authored, so the generator metadata is
+      // cleared — the CHECK requires it absent for a human origin, and leaving
+      // a model attribution on text a person wrote would be a false record.
+      editBody.run(body, reviewerId, reviewerId, now, now, d.id);
+      tally.edited++;
+      console.log('  saved as human-written');
+    } else {
+      tally.skipped++;
+      console.log('  empty — skipped');
+    }
+  } else if (answer === 'f') {
+    const why = (await ask('  what is wrong with the question? > ')).trim();
+    flagQuestion.run(
+      randomUUID().replace(/-/g, '').slice(0, 26).toUpperCase(),
+      d.question_id,
+      `explanation-review: ${why || '(no reason given)'}`,
+      now,
+      now
+    );
+    tally.flagged++;
+    console.log('  flagged for triage');
+  } else {
+    tally.skipped++;
+  }
+}
+
+closeInput();
+
+console.log(`
+  accepted ${tally.accepted}   rejected ${tally.rejected}   edited ${tally.edited}   flagged ${tally.flagged}   skipped ${tally.skipped}
+`);
+printStats();
+db.close();
diff --git a/worker/src/__tests__/auth.test.ts b/worker/src/__tests__/auth.test.ts
new file mode 100644
index 0000000..e1c57c0
--- /dev/null
+++ b/worker/src/__tests__/auth.test.ts
@@ -0,0 +1,302 @@
+/**
+ * Authentication, including the thing that makes the whole anti-cheat model
+ * usable: upgrading an anonymous guest in place, without changing their id.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createWorld, expectFailure, measure } from './harness.ts';
+import {
+  login,
+  logout,
+  signup,
+  startAnonymousSession,
+  upgradeAnonymous,
+} from '../handlers/auth.ts';
+import { startMock } from '../handlers/mock.ts';
+import { putBookmark, getBookmarks } from '../handlers/progress.ts';
+import { getUserById } from '../data/auth.ts';
+import { hashPassword, verifyPassword } from '../lib/password.ts';
+import { readCookie, SESSION_COOKIE } from '../lib/cookies.ts';
+import type { HandlerContext } from '../handlers/context.ts';
+import type { TestWorld } from './harness.ts';
+
+/** A context with no session, as an unauthenticated request produces. */
+function anonContext(world: TestWorld): HandlerContext {
+  const ctx = world.contextFor(world.makeUser());
+  ctx.auth = null;
+  ctx.cookies = [];
+  return ctx;
+}
+
+function cookieSessionId(ctx: HandlerContext): string {
+  assert.equal(ctx.cookies.length, 1, 'exactly one Set-Cookie should be emitted');
+  const value = readCookie(ctx.cookies[0].split(';')[0], SESSION_COOKIE);
+  assert.ok(value, 'the cookie must carry a session id');
+  return value;
+}
+
+test('the session cookie is HttpOnly, SameSite and path-scoped', async () => {
+  const world = createWorld();
+  const ctx = anonContext(world);
+
+  await startAnonymousSession(ctx);
+  const cookie = ctx.cookies[0];
+
+  assert.match(cookie, /^necprep_session=ses_/);
+  assert.match(cookie, /HttpOnly/);
+  assert.match(cookie, /SameSite=Lax/);
+  assert.match(cookie, /Path=\//);
+  // The test config is not production, so Secure is correctly absent here;
+  // `loadConfig` sets `isProduction` from ENVIRONMENT and the cookie helper
+  // ties Secure to it.
+  assert.ok(!cookie.includes('Secure'));
+
+  // The cookie carries NOTHING but an opaque id - no user id, no role, no
+  // signed claims to tamper with.
+  const sessionId = cookieSessionId(ctx);
+  assert.match(sessionId, /^ses_[0-9A-Z]{26}$/);
+
+  world.close();
+});
+
+test('an anonymous guest is a real user row that can own attempts', async () => {
+  const world = createWorld();
+  const ctx = anonContext(world);
+
+  const result = await startAnonymousSession(ctx);
+  const guest = result.body.user;
+  assert.ok(guest);
+  assert.equal(guest.isAnonymous, true);
+  assert.equal(guest.email, null);
+  assert.equal(guest.hasPassword, false);
+  // 'student', not 'user': the role enum is the one on `users.role`, and it has
+  // four values -- student, contributor, moderator, admin -- because the API
+  // needs a triage role that is not a publish role.
+  assert.equal(guest.role, 'student');
+
+  // And the guest can immediately start a server-scored mock, which is the
+  // entire reason guests get a row instead of a client-side identity.
+  const start = await measure(world, guest, (c) =>
+    startMock(c, { templateId: world.templateId, idempotencyKey: 'guest-start-aaaaaaaa' }),
+  );
+  assert.equal(start.result.body.questions.length, 12);
+  assert.equal(start.result.body.expiresAt - start.result.body.startedAt, 45 * 60 * 1000);
+
+  world.close();
+});
+
+test('calling /auth/anonymous again does not orphan the first guest', async () => {
+  const world = createWorld();
+  const ctx = anonContext(world);
+
+  const first = await startAnonymousSession(ctx);
+  const guest = first.body.user;
+  assert.ok(guest);
+
+  // The client calls this on every cold start. With a live session it must be
+  // a no-op, or every reload would strand the previous guest's progress.
+  const withSession = world.contextFor(guest);
+  const second = await startAnonymousSession(withSession);
+
+  assert.equal(second.body.user?.id, guest.id);
+  assert.equal(withSession.cookies.length, 0, 'no new session should be minted');
+
+  world.close();
+});
+
+test('UPGRADING A GUEST KEEPS THE USER ID AND THE PROGRESS', async () => {
+  const world = createWorld();
+  const ctx = anonContext(world);
+
+  const guest = (await startAnonymousSession(ctx)).body.user;
+  assert.ok(guest);
+  const originalId = guest.id;
+
+  // Do some work as a guest.
+  await measure(world, guest, (c) =>
+    putBookmark(c, { questionId: world.questions[0].id, desired: true }),
+  );
+
+  const upgradeCtx = world.contextFor(guest);
+  const upgraded = await upgradeAnonymous(upgradeCtx, {
+    email: 'claimed@test.local',
+    password: 'a-good-enough-password',
+    displayName: 'Claimed',
+  });
+
+  assert.equal(upgraded.body.user?.id, originalId, 'the user id must not change');
+  assert.equal(upgraded.body.user?.email, 'claimed@test.local');
+  assert.equal(upgraded.body.user?.isAnonymous, false);
+  assert.equal(upgraded.body.user?.hasPassword, true);
+
+  // The bookmark is still there, because nothing was migrated.
+  const bookmarks = await measure(world, upgraded.body.user, (c) => getBookmarks(c));
+  assert.equal(bookmarks.result.body.items.length, 1);
+
+  // And the new password actually works.
+  const db = world.invocation();
+  const row = await getUserById(db, originalId);
+  assert.ok(row);
+  const check = await verifyPassword('a-good-enough-password', row.password_hash, 10_000);
+  assert.equal(check.valid, true);
+
+  world.close();
+});
+
+test('upgrading twice is refused rather than overwriting a claimed account', async () => {
+  const world = createWorld();
+  const ctx = anonContext(world);
+  const guest = (await startAnonymousSession(ctx)).body.user;
+  assert.ok(guest);
+
+  await upgradeAnonymous(world.contextFor(guest), {
+    email: 'once@test.local',
+    password: 'first-password-here',
+  });
+
+  // A replayed upgrade - from a retried request or a second tab - must not be
+  // able to reset the password of an account that has since been claimed.
+  const failure = await expectFailure(() =>
+    upgradeAnonymous(world.contextFor(guest), {
+      email: 'attacker@test.local',
+      password: 'attacker-password',
+    }),
+  );
+  assert.equal(failure.code, 'NOT_ANONYMOUS');
+  assert.equal(failure.status, 409);
+
+  const db = world.invocation();
+  const row = await getUserById(db, guest.id);
+  assert.equal(row?.email, 'once@test.local');
+
+  world.close();
+});
+
+test('a guest cannot claim an email that is already taken', async () => {
+  const world = createWorld();
+
+  const owner = anonContext(world);
+  await signup(owner, { email: 'taken@test.local', password: 'owner-password-1' });
+
+  const guestCtx = anonContext(world);
+  const guest = (await startAnonymousSession(guestCtx)).body.user;
+  assert.ok(guest);
+
+  const failure = await expectFailure(() =>
+    upgradeAnonymous(world.contextFor(guest), {
+      email: 'taken@test.local',
+      password: 'guest-password-1',
+    }),
+  );
+  assert.equal(failure.code, 'EMAIL_IN_USE');
+
+  world.close();
+});
+
+test('signup then login, and a wrong password is refused', async () => {
+  const world = createWorld();
+
+  const signupCtx = anonContext(world);
+  const created = await signup(signupCtx, {
+    email: 'Someone@Test.Local',
+    password: 'correct-horse-battery',
+    displayName: 'Someone',
+  });
+
+  assert.equal(created.status, 201);
+  // The email was normalised by the schema, so a login with different casing
+  // resolves to the same account.
+  assert.equal(created.body.user?.email, 'someone@test.local');
+
+  const loginCtx = anonContext(world);
+  const session = await login(loginCtx, {
+    email: 'SOMEONE@test.local',
+    password: 'correct-horse-battery',
+  });
+  assert.equal(session.body.user?.id, created.body.user?.id);
+  assert.ok(cookieSessionId(loginCtx));
+
+  const failure = await expectFailure(() =>
+    login(anonContext(world), { email: 'someone@test.local', password: 'wrong' }),
+  );
+  assert.equal(failure.code, 'INVALID_CREDENTIALS');
+  assert.equal(failure.status, 401);
+
+  world.close();
+});
+
+test('a duplicate signup is a clean 409, not a database error', async () => {
+  const world = createWorld();
+  await signup(anonContext(world), { email: 'dup@test.local', password: 'password-one-1' });
+
+  const failure = await expectFailure(() =>
+    signup(anonContext(world), { email: 'dup@test.local', password: 'password-two-2' }),
+  );
+  assert.equal(failure.code, 'EMAIL_IN_USE');
+  assert.equal(failure.status, 409);
+
+  world.close();
+});
+
+test('login on an unknown email and on a guest row both report the same error', async () => {
+  const world = createWorld();
+
+  // A guest has no password, so logging in as one must be indistinguishable
+  // from an address with no account at all - otherwise the error message
+  // enumerates which addresses exist.
+  const guestCtx = anonContext(world);
+  await startAnonymousSession(guestCtx);
+
+  const unknown = await expectFailure(() =>
+    login(anonContext(world), { email: 'nobody@test.local', password: 'whatever-1' }),
+  );
+  assert.equal(unknown.code, 'INVALID_CREDENTIALS');
+  assert.equal(unknown.message, 'That email or password is incorrect.');
+
+  world.close();
+});
+
+test('logout revokes the session and clears the cookie, idempotently', async () => {
+  const world = createWorld();
+  const ctx = anonContext(world);
+  const guest = (await startAnonymousSession(ctx)).body.user;
+  assert.ok(guest);
+
+  const logoutCtx = world.contextFor(guest);
+  await logout(logoutCtx);
+  assert.match(logoutCtx.cookies[0], /Max-Age=0/);
+
+  // Calling it again is harmless.
+  const again = world.contextFor(guest);
+  const result = await logout(again);
+  assert.equal(result.body.ok, true);
+
+  world.close();
+});
+
+test('password hashes are salted, self-describing, and verify constant-time', async () => {
+  const a = await hashPassword('same-password', 10_000);
+  const b = await hashPassword('same-password', 10_000);
+
+  assert.notEqual(a, b, 'two hashes of the same password must differ (unique salt)');
+  assert.match(a, /^pbkdf2\$sha256\$10000\$[A-Za-z0-9_-]+\$[A-Za-z0-9_-]+$/);
+
+  assert.equal((await verifyPassword('same-password', a, 10_000)).valid, true);
+  assert.equal((await verifyPassword('other-password', a, 10_000)).valid, false);
+
+  // A stored hash with fewer iterations than the current setting verifies and
+  // asks to be rehashed, so the cost can be raised without locking anyone out.
+  const upgrade = await verifyPassword('same-password', a, 20_000);
+  assert.equal(upgrade.valid, true);
+  assert.equal(upgrade.needsRehash, true);
+});
+
+test('a corrupt stored hash reads as a wrong password, never as a crash', async () => {
+  for (const stored of [null, '', 'not-a-hash', 'pbkdf2$sha256$abc$x$y', 'pbkdf2$sha512$1000$x$y']) {
+    const result = await verifyPassword('anything', stored, 10_000);
+    assert.equal(result.valid, false, `stored=${String(stored)}`);
+    assert.equal(result.needsRehash, false);
+  }
+});
diff --git a/worker/src/__tests__/config.test.ts b/worker/src/__tests__/config.test.ts
new file mode 100644
index 0000000..7dbe39d
--- /dev/null
+++ b/worker/src/__tests__/config.test.ts
@@ -0,0 +1,112 @@
+/**
+ * `loadConfig`, and specifically the blast radius of a misconfiguration.
+ *
+ * This runs in the `/api/*` middleware, once per request, before any handler.
+ * So anything it throws for takes down EVERY endpoint — and the cases where
+ * that is right are narrow.
+ *
+ * It was not narrow enough. A half-configured Google OAuth app threw, which
+ * meant one missing secret 500'd the chapter list, guest sign-in and paper
+ * submission, each reporting "Google OAuth needs GOOGLE_CLIENT_ID..." — a
+ * baffling thing to read when you asked for a list of chapters. Found by
+ * running `wrangler dev` against a `.dev.vars` with one of the three filled in.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { loadConfig } from '../env.ts';
+import type { Env } from '../env.ts';
+
+const SECRET = 'test-permutation-secret-0123456789abcdef';
+
+function env(overrides: Partial<Env> = {}): Env {
+  return {
+    DB: null as unknown as Env['DB'],
+    APP_ORIGIN: 'https://app.test',
+    CONTENT_PERMUTATION_SECRET: SECRET,
+    ...overrides,
+  } as Env;
+}
+
+const GOOGLE = {
+  GOOGLE_CLIENT_ID: 'id.apps.googleusercontent.com',
+  GOOGLE_CLIENT_SECRET: 'secret',
+  GOOGLE_REDIRECT_URI: 'https://api.test/api/auth/google/callback',
+};
+
+// --- What must still fail hard -----------------------------------------------
+
+test('a missing APP_ORIGIN fails closed', () => {
+  // This one genuinely affects every request: it is the CORS policy.
+  assert.throws(() => loadConfig(env({ APP_ORIGIN: undefined })), /not configured/i);
+  assert.throws(() => loadConfig(env({ APP_ORIGIN: '   ' })), /not configured/i);
+});
+
+test('a missing or short CONTENT_PERMUTATION_SECRET fails closed', () => {
+  assert.throws(() => loadConfig(env({ CONTENT_PERMUTATION_SECRET: undefined })), /not configured/i);
+  // Short enough to be reproduced offline against the public chapter JSON.
+  assert.throws(() => loadConfig(env({ CONTENT_PERMUTATION_SECRET: 'too-short' })), /not configured/i);
+});
+
+test('an out-of-range numeric setting fails closed rather than clamping', () => {
+  assert.throws(() => loadConfig(env({ D1_QUERY_BUDGET: '9999' })), /not configured/i);
+  assert.throws(() => loadConfig(env({ PASSWORD_HASH_ITERATIONS: 'lots' })), /not configured/i);
+});
+
+// --- What must NOT take the platform down ------------------------------------
+
+test('no Google configuration at all is a normal, working deployment', () => {
+  const config = loadConfig(env());
+  assert.equal(config.google, null);
+  assert.equal(config.googleConfigError, null);
+});
+
+test('a HALF-configured Google app does not throw', () => {
+  // The regression. An optional feature must not be able to break a required
+  // one; `requireGoogle` reports it on the Google routes instead.
+  for (const partial of [
+    { GOOGLE_CLIENT_ID: GOOGLE.GOOGLE_CLIENT_ID },
+    { GOOGLE_REDIRECT_URI: GOOGLE.GOOGLE_REDIRECT_URI },
+    { GOOGLE_CLIENT_ID: GOOGLE.GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET: GOOGLE.GOOGLE_CLIENT_SECRET },
+  ]) {
+    const config = loadConfig(env(partial));
+    assert.equal(config.google, null, JSON.stringify(partial));
+    assert.match(config.googleConfigError ?? '', /GOOGLE_CLIENT_ID/);
+    // And the rest of the config is intact, so every other endpoint works.
+    assert.equal(config.appOrigin, 'https://app.test');
+    assert.equal(config.permutationSecret, SECRET);
+  }
+});
+
+test('an empty-string Google value counts as unset, not as set', () => {
+  // `.dev.vars` and `wrangler secret` both make it easy to end up with an
+  // empty value rather than an absent one.
+  const config = loadConfig(env({ GOOGLE_CLIENT_ID: '', GOOGLE_CLIENT_SECRET: '   ' }));
+  assert.equal(config.google, null);
+  assert.equal(config.googleConfigError, null);
+});
+
+test('all three set gives a usable Google config', () => {
+  const config = loadConfig(env(GOOGLE));
+  assert.equal(config.googleConfigError, null);
+  assert.ok(config.google);
+  assert.equal(config.google.clientId, GOOGLE.GOOGLE_CLIENT_ID);
+  assert.equal(config.google.redirectUri, GOOGLE.GOOGLE_REDIRECT_URI);
+});
+
+test('surrounding whitespace is trimmed off the Google values', () => {
+  // A redirect URI with a trailing newline, pasted from a terminal, is the
+  // classic cause of redirect_uri_mismatch — which Google reports at its end,
+  // far from the cause.
+  const config = loadConfig(
+    env({
+      GOOGLE_CLIENT_ID: `  ${GOOGLE.GOOGLE_CLIENT_ID}  `,
+      GOOGLE_CLIENT_SECRET: GOOGLE.GOOGLE_CLIENT_SECRET,
+      GOOGLE_REDIRECT_URI: `${GOOGLE.GOOGLE_REDIRECT_URI}\n`,
+    }),
+  );
+  assert.ok(config.google);
+  assert.equal(config.google.clientId, GOOGLE.GOOGLE_CLIENT_ID);
+  assert.equal(config.google.redirectUri, GOOGLE.GOOGLE_REDIRECT_URI);
+});
diff --git a/worker/src/__tests__/content-refs.test.ts b/worker/src/__tests__/content-refs.test.ts
new file mode 100644
index 0000000..0ae0710
--- /dev/null
+++ b/worker/src/__tests__/content-refs.test.ts
@@ -0,0 +1,256 @@
+/**
+ * An option's AUTHORED ORDINAL must not be recoverable - not from an id, and
+ * not from a payload.
+ *
+ * THE BUG THESE TESTS EXIST FOR, and how it was actually fixed. The schema used
+ * to mint option ids as `question_id || '#' || ordinal`. The first version of
+ * `getChapterQuestions` returned that id as the public `ref`, on the reasoning
+ * that an id carries no key. Against that id scheme it was false:
+ * `frontend/public/data/books/*.json` publishes `correct_option_index` and sits
+ * in git history forever, so `ref: "q_abc#3"` next to a published key of 3 is
+ * the whole answer - for every question in the bank, with no database access.
+ * The per-viewer permutation was no defence, because the ordinal travelled
+ * INSIDE the id instead of as an array position.
+ *
+ * Two things changed, and only the second one is a real fix:
+ *
+ *   1. `browseOptionRef`, a keyed non-reversible digest, replaced the raw id in
+ *      the payload. That stopped the leak at ONE endpoint. It is a patch: the
+ *      ids were still answer keys, and the next endpoint, log line or error
+ *      message to include one would have reopened it.
+ *   2. `migrations/0002_content.sql` now mints ids as
+ *      `question_id || '#' || opt_key` with a 12-character CSPRNG key, so there
+ *      is nothing in an option id to join against. That is the fix.
+ *
+ * Both are tested here. The digest stays because it still buys something: a
+ * per-viewer handle, so two accounts comparing payloads learn nothing from each
+ * other, and no stable token a client can accumulate across sessions.
+ *
+ * WHAT NONE OF THIS FIXES, and the tests do not pretend otherwise: for the
+ * 2,290 questions already published as JSON the key is irrecoverably public.
+ * Anyone who can read a stem can look the answer up by its text. What is fixed
+ * is that no question authored from now on has an exposed key, and that a
+ * delivered paper cannot be graded by position alone.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createWorld, measure } from './harness.ts';
+import { getChapterQuestions } from '../handlers/content.ts';
+import { getSrsDue } from '../handlers/progress.ts';
+import { answerPractice, startPractice } from '../handlers/practice.ts';
+import { browseOptionRef } from '../lib/permute.ts';
+
+test('AN OPTION ID DOES NOT ENCODE ITS AUTHORED ORDINAL', () => {
+  const world = createWorld();
+
+  // Checked over the whole seeded bank, because one counter-example is the
+  // whole hole. The fixture mints keys exactly as `db/seed/import-questions.mjs`
+  // does, so if this ever regresses the id scheme has regressed, not the test.
+  for (const question of world.questions) {
+    question.optionIds.forEach((id, index) => {
+      const ordinal = index + 1;
+      assert.notEqual(
+        id,
+        `${question.id}#${ordinal}`,
+        'an ordinal-bearing option id IS the answer key for a published question',
+      );
+      const key = id.slice(question.id.length + 1);
+      assert.ok(id.startsWith(`${question.id}#`), 'the question-id prefix must survive');
+      assert.match(key, /^[0-9A-Z]{12}$/, 'the discriminator must be a 12-char token');
+      assert.notEqual(key, String(ordinal));
+      // Not a number in any guise, so no arithmetic recovers the slot.
+      assert.ok(Number.isNaN(Number(key)) || /[A-Z]/.test(key));
+    });
+    // Four options, four distinct keys.
+    assert.equal(new Set(question.optionIds).size, question.optionIds.length);
+  }
+
+  world.close();
+});
+
+test('the question-id prefix survives, so the answer-key CHECK still holds', () => {
+  const world = createWorld();
+  // `question_answer_keys` proves a key cannot point at another question's
+  // option with a prefix test rather than a composite foreign key, and
+  // `explanations.about_option_id` and `question_reports.suggested_option_id`
+  // lean on the same shape. Changing the discriminator must not cost that.
+  for (const question of world.questions) {
+    assert.ok(question.correctOptionId.startsWith(`${question.id}#`));
+  }
+  world.close();
+});
+
+test('chapter questions never expose an option id or its ordinal', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const result = await measure(world, user, (ctx) =>
+    getChapterQuestions(ctx, { chapterId: world.chapterIds[0], offset: 0, limit: 50 }),
+  );
+  const serialised = JSON.stringify(result.result.body);
+
+  // No option id, in whole or in the `#ordinal` suffix form.
+  for (const question of world.questions) {
+    for (const optionId of question.optionIds) {
+      assert.ok(!serialised.includes(optionId), `leaked option id ${optionId}`);
+    }
+  }
+  assert.ok(!serialised.includes('#'), 'no ref may carry the ordinal separator');
+
+  // And still no key, of course.
+  assert.ok(!serialised.includes('is_correct'));
+  assert.ok(!serialised.includes('isCorrect'));
+  assert.ok(!serialised.includes('correct'));
+
+  for (const question of result.result.body.questions) {
+    assert.equal(question.options.length, 4);
+    for (const option of question.options) {
+      assert.match(option.ref, /^[0-9A-Z]{13}$/);
+    }
+  }
+
+  world.close();
+});
+
+test('a browse ref is stable for one viewer and different for another', () => {
+  const world = createWorld();
+  const secret = world.config.permutationSecret;
+  const question = world.questions[0];
+  const optionId = question.optionIds[0];
+
+  const a1 = browseOptionRef(secret, 'usr_a', question.id, optionId);
+  const a2 = browseOptionRef(secret, 'usr_a', question.id, optionId);
+  const b1 = browseOptionRef(secret, 'usr_b', question.id, optionId);
+
+  // Stable: a reload must not re-point a selection the client stored by ref.
+  assert.equal(a1, a2);
+  // Per-viewer: two accounts comparing payloads learn nothing from each other.
+  assert.notEqual(a1, b1);
+
+  // Rotating the secret reshuffles every ref, which is why rotation is safe
+  // but not free.
+  assert.notEqual(a1, browseOptionRef(`${secret}-rotated`, 'usr_a', question.id, optionId));
+
+  // The four options of one question get four distinct refs.
+  const refs = new Set(
+    question.optionIds.map((id) => browseOptionRef(secret, 'usr_a', question.id, id)),
+  );
+  assert.equal(refs.size, 4);
+
+  world.close();
+});
+
+test('browse refs across the whole seeded bank do not collide', () => {
+  const world = createWorld({ chapters: 3, questionsPerChapter: 40 });
+  const secret = world.config.permutationSecret;
+
+  // Within a question is what matters - a collision there would make two
+  // options share a display token. Checked across the bank anyway, as a
+  // distribution sanity check on the digest.
+  const all = new Set<string>();
+  let total = 0;
+  for (const question of world.questions) {
+    const perQuestion = new Set<string>();
+    for (const optionId of question.optionIds) {
+      const ref = browseOptionRef(secret, 'usr_a', question.id, optionId);
+      perQuestion.add(ref);
+      all.add(ref);
+      total++;
+    }
+    assert.equal(perQuestion.size, question.optionIds.length);
+  }
+  assert.equal(all.size, total, 'no collisions across 480 refs');
+
+  world.close();
+});
+
+test('the SRS due payload uses opaque refs too', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  // Answer a practice question so a card exists and becomes due.
+  const session = await measure(world, user, (ctx) =>
+    startPractice(ctx, {
+      mode: 'chapter',
+      chapterIds: [world.chapterIds[0]],
+      questionCount: 3,
+      idempotencyKey: 'srs-seed-aaaaaaaa',
+    }),
+  );
+  const question = session.result.body.questions[0];
+  await measure(world, user, (ctx) =>
+    answerPractice(ctx, {
+      sessionId: session.result.body.sessionId,
+      questionId: question.questionId,
+      optionRef: question.options[0].ref,
+    }),
+  );
+
+  // Wind past the scheduled interval so the card is due.
+  world.clock.advance(10 * 24 * 60 * 60 * 1000);
+
+  const due = await measure(world, user, (ctx) => getSrsDue(ctx, { limit: 20 }));
+  assert.ok(due.result.body.dueCount > 0, 'a card should be due after the interval');
+
+  const serialised = JSON.stringify(due.result.body);
+  for (const seeded of world.questions) {
+    for (const optionId of seeded.optionIds) {
+      assert.ok(!serialised.includes(optionId), `leaked option id ${optionId}`);
+    }
+  }
+  assert.ok(!serialised.includes('#'));
+
+  world.close();
+});
+
+test('a practice paper ref is per-attempt, not the stable browse ref', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const first = await measure(world, user, (ctx) =>
+    startPractice(ctx, {
+      mode: 'chapter',
+      chapterIds: [world.chapterIds[0]],
+      questionCount: 12,
+      idempotencyKey: 'pref-one-aaaaaaaa',
+    }),
+  );
+  const second = await measure(world, user, (ctx) =>
+    startPractice(ctx, {
+      mode: 'chapter',
+      chapterIds: [world.chapterIds[0]],
+      questionCount: 12,
+      idempotencyKey: 'pref-two-bbbbbbbb',
+    }),
+  );
+
+  const shared = first.result.body.questions.find((a) =>
+    second.result.body.questions.some((b) => b.questionId === a.questionId),
+  );
+  assert.ok(shared, 'two 12-question draws from one chapter should overlap');
+  const inSecond = second.result.body.questions.find((q) => q.questionId === shared.questionId);
+  assert.ok(inSecond);
+
+  const firstRefs = new Set(shared.options.map((o) => o.ref));
+  for (const option of inSecond.options) {
+    assert.ok(
+      !firstRefs.has(option.ref),
+      'practice refs must be per-session, so a revealed key cannot be carried over',
+    );
+  }
+
+  // And they are not the browse refs either - an attempt ref is CSPRNG, so
+  // knowing the browse ref for an option tells you nothing inside an attempt.
+  const browse = new Set(
+    (world.questionById.get(shared.questionId)?.optionIds ?? []).map((id) =>
+      browseOptionRef(world.config.permutationSecret, user.id, shared.questionId, id),
+    ),
+  );
+  for (const option of shared.options) {
+    assert.ok(!browse.has(option.ref));
+  }
+
+  world.close();
+});
diff --git a/worker/src/__tests__/expiry.test.ts b/worker/src/__tests__/expiry.test.ts
new file mode 100644
index 0000000..0228f73
--- /dev/null
+++ b/worker/src/__tests__/expiry.test.ts
@@ -0,0 +1,171 @@
+/**
+ * The expiry clamp.
+ *
+ * Each case below corresponds to something the current client-side timer
+ * cannot defend against.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { clampSubmission, deadlineFor, syncDecision, SUBMIT_GRACE_MS } from '../domain/expiry.ts';
+import { MINUTE } from '../lib/time.ts';
+
+const START = Date.parse('2026-03-01T04:00:00.000Z');
+const DEADLINE = deadlineFor(START, 45 * 60);
+
+test('deadlineFor is derived from the server start time and the duration', () => {
+  assert.equal(DEADLINE - START, 45 * MINUTE);
+});
+
+test('a submission inside the window scores the submitted payload', () => {
+  const result = clampSubmission({
+    now: START + 30 * MINUTE,
+    startedAt: START,
+    expiresAt: DEADLINE,
+    submitted: { q1: 'r1', q2: 'r2' },
+    syncedSnapshot: { q1: 'r1' },
+  });
+
+  assert.equal(result.timing, 'on_time');
+  assert.equal(result.usedPayload, true);
+  assert.deepEqual(result.answers, { q1: 'r1', q2: 'r2' });
+  assert.equal(result.droppedLateAnswers, 0);
+  assert.equal(result.scoredAt, START + 30 * MINUTE);
+  assert.equal(result.remainingMs, 15 * MINUTE);
+});
+
+test('a submission right on the buzzer is still on time', () => {
+  const result = clampSubmission({
+    now: DEADLINE,
+    startedAt: START,
+    expiresAt: DEADLINE,
+    submitted: { q1: 'r1' },
+    syncedSnapshot: null,
+  });
+
+  assert.equal(result.timing, 'on_time');
+  assert.equal(result.scoredAt, DEADLINE);
+  assert.equal(result.remainingMs, 0);
+});
+
+test('the grace window absorbs network latency but not working time', () => {
+  const justInside = clampSubmission({
+    now: DEADLINE + SUBMIT_GRACE_MS,
+    startedAt: START,
+    expiresAt: DEADLINE,
+    submitted: { q1: 'r1' },
+    syncedSnapshot: null,
+  });
+  assert.equal(justInside.timing, 'on_time');
+
+  const justOutside = clampSubmission({
+    now: DEADLINE + SUBMIT_GRACE_MS + 1,
+    startedAt: START,
+    expiresAt: DEADLINE,
+    submitted: { q1: 'r1' },
+    syncedSnapshot: null,
+  });
+  assert.equal(justOutside.timing, 'expired');
+});
+
+test('STALLING PAST THE DEADLINE GAINS NOTHING', () => {
+  // The whole point. The client froze its timer, kept working for an hour, then
+  // submitted a full paper. Only what the server had already accepted before
+  // the deadline is scored.
+  const result = clampSubmission({
+    now: DEADLINE + 60 * MINUTE,
+    startedAt: START,
+    expiresAt: DEADLINE,
+    submitted: { q1: 'r1', q2: 'r2', q3: 'r3', q4: 'r4' },
+    syncedSnapshot: { q1: 'r1', q2: 'rX' },
+  });
+
+  assert.equal(result.timing, 'expired');
+  assert.equal(result.usedPayload, false);
+  assert.deepEqual(
+    result.answers,
+    { q1: 'r1', q2: 'rX' },
+    'the pre-deadline snapshot is scored, including the answer the stalling client later changed',
+  );
+  assert.equal(
+    result.droppedLateAnswers,
+    3,
+    'q2 (changed), q3 and q4 (added after the deadline) are all dropped',
+  );
+  assert.equal(result.scoredAt, DEADLINE, 'the paper was frozen at the deadline, not at submit time');
+});
+
+test('a late submission with no snapshot at all scores nothing', () => {
+  // Harsh but honest: the client never told the server a single answer before
+  // the deadline, so the server has nothing it can verify was answered in time.
+  const result = clampSubmission({
+    now: DEADLINE + 10 * MINUTE,
+    startedAt: START,
+    expiresAt: DEADLINE,
+    submitted: { q1: 'r1', q2: 'r2' },
+    syncedSnapshot: null,
+  });
+
+  assert.equal(result.timing, 'expired');
+  assert.deepEqual(result.answers, {});
+  assert.equal(result.droppedLateAnswers, 2);
+});
+
+test('a late submission identical to the snapshot drops nothing', () => {
+  // An honest client that synced everything and then lost its connection on the
+  // final submit must not be told it lost answers.
+  const result = clampSubmission({
+    now: DEADLINE + 30 * MINUTE,
+    startedAt: START,
+    expiresAt: DEADLINE,
+    submitted: { q1: 'r1', q2: 'r2' },
+    syncedSnapshot: { q1: 'r1', q2: 'r2' },
+  });
+
+  assert.equal(result.timing, 'expired');
+  assert.deepEqual(result.answers, { q1: 'r1', q2: 'r2' });
+  assert.equal(result.droppedLateAnswers, 0);
+});
+
+test('syncDecision refuses a snapshot past the deadline or on a finished attempt', () => {
+  assert.deepEqual(
+    syncDecision({ now: DEADLINE - 1, expiresAt: DEADLINE, status: 'in_progress' }),
+    { accepted: true },
+  );
+  assert.deepEqual(
+    syncDecision({ now: DEADLINE + 1, expiresAt: DEADLINE, status: 'in_progress' }),
+    { accepted: false, reason: 'past_deadline' },
+  );
+  assert.deepEqual(
+    syncDecision({ now: START, expiresAt: DEADLINE, status: 'submitted' }),
+    { accepted: false, reason: 'not_in_progress' },
+  );
+});
+
+test('no client-supplied value can influence the clamp', () => {
+  // A regression guard with teeth: if someone adds an `answeredAt` or a
+  // `clientNow` to the submit body later, the clamp signature is the thing that
+  // has to change, and this assertion documents that it currently cannot.
+  const inputKeys = [
+    'now',
+    'startedAt',
+    'expiresAt',
+    'submitted',
+    'syncedSnapshot',
+    'graceMs',
+  ];
+
+  const result = clampSubmission({
+    now: DEADLINE + MINUTE,
+    startedAt: START,
+    expiresAt: DEADLINE,
+    submitted: {},
+    syncedSnapshot: {},
+  });
+
+  // `now`, `startedAt` and `expiresAt` are all server-authored; `submitted` is
+  // the only client input and it is discarded on the expired path.
+  assert.equal(result.usedPayload, false);
+  assert.ok(inputKeys.includes('now'));
+});
diff --git a/worker/src/__tests__/harness.ts b/worker/src/__tests__/harness.ts
new file mode 100644
index 0000000..ec69902
--- /dev/null
+++ b/worker/src/__tests__/harness.ts
@@ -0,0 +1,515 @@
+/**
+ * Test harness: a local SQLite database behind the same interface as D1.
+ *
+ * `node:sqlite` is in the Node 22 standard library, so the whole suite runs
+ * with `node --test` and no network. The shim below implements exactly the four
+ * methods `data/d1.ts` declares, which is why the tests can drive the REAL
+ * handlers - ownership checks, scoring, the expiry clamp, idempotency, the
+ * actual SQL - rather than a re-implementation.
+ *
+ * ===========================================================================
+ * THE SCHEMA IS `worker/migrations/*.sql`, APPLIED VERBATIM
+ * ===========================================================================
+ *
+ * This used to apply `ASSUMED_SCHEMA_DDL` from `src/data/tables.ts` -- a second,
+ * hand-written description of the database, written because the API and the
+ * migrations were being built concurrently. The suite therefore proved the API
+ * against its own assumptions, which is exactly as useful as it sounds: 88
+ * tests passed green against a schema that did not exist, while the real one
+ * stored seconds where the API read milliseconds.
+ *
+ * So the migrations are read off disk and executed in order. Everything the
+ * suite asserts is now asserted against the DDL that will be deployed:
+ * `STRICT` typing, every CHECK, every composite foreign key, the eleven rollup
+ * triggers, the FTS5 index and its six maintenance triggers, and the generated
+ * columns. A handler that gets a column name wrong fails here instead of on the
+ * first real request.
+ *
+ * `0007_reference_data.sql` IS APPLIED TOO, so the fixture runs against the
+ * real syllabus rows and the three real mock templates as well as its own. The
+ * fixture's chapters and template sit alongside them with their own codes,
+ * which is also the honest shape of the production database: ten official
+ * chapters that a seed fills, plus whatever a migration adds later.
+ */
+
+import { DatabaseSync } from 'node:sqlite';
+import { createHash, randomFillSync } from 'node:crypto';
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { Db } from '../data/d1.ts';
+import type { D1Database, D1PreparedStatement, D1Result, SqlValue } from '../data/d1.ts';
+import { fixedClock } from '../lib/time.ts';
+import type { Clock } from '../lib/time.ts';
+import type { Config } from '../env.ts';
+import type { HandlerContext } from '../handlers/context.ts';
+import type { SessionUser } from '../shared/types.ts';
+
+const WORKER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const MIGRATIONS_DIR = join(WORKER_ROOT, 'migrations');
+
+// --- The D1 shim ------------------------------------------------------------
+
+class SqliteStatement implements D1PreparedStatement {
+  #db: DatabaseSync;
+  #sql: string;
+  #binds: SqlValue[] = [];
+
+  constructor(db: DatabaseSync, sql: string) {
+    this.#db = db;
+    this.#sql = sql;
+  }
+
+  bind(...values: SqlValue[]): D1PreparedStatement {
+    this.#binds = values;
+    return this;
+  }
+
+  #prepared() {
+    return this.#db.prepare(this.#sql);
+  }
+
+  async first<T>(): Promise<T | null> {
+    const row = this.#prepared().get(...(this.#binds as never[]));
+    return (row as T | undefined) ?? null;
+  }
+
+  async all<T>(): Promise<D1Result<T>> {
+    const rows = this.#prepared().all(...(this.#binds as never[])) as T[];
+    return {
+      results: rows,
+      success: true,
+      meta: { changes: 0, last_row_id: 0 },
+    };
+  }
+
+  async run<T>(): Promise<D1Result<T>> {
+    const result = this.#prepared().run(...(this.#binds as never[]));
+    return {
+      results: [],
+      success: true,
+      meta: {
+        changes: Number(result.changes),
+        last_row_id: Number(result.lastInsertRowid),
+      },
+    };
+  }
+}
+
+class SqliteD1 implements D1Database {
+  readonly raw: DatabaseSync;
+
+  constructor(raw: DatabaseSync) {
+    this.raw = raw;
+  }
+
+  prepare(query: string): D1PreparedStatement {
+    return new SqliteStatement(this.raw, query);
+  }
+
+  /**
+   * Mirrors D1's batch semantics: one implicit transaction, statements applied
+   * in order, all-or-nothing on error.
+   *
+   * Running a batch as a real transaction matters for the submission tests -
+   * the guard-and-flip ordering in `data/attempts.ts` is only correct if the
+   * statements see each other's effects in sequence and roll back together.
+   */
+  async batch<T>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]> {
+    this.raw.exec('BEGIN');
+    try {
+      const out: D1Result<T>[] = [];
+      for (const statement of statements) {
+        out.push((await statement.run<T>()) as D1Result<T>);
+      }
+      this.raw.exec('COMMIT');
+      return out;
+    } catch (err) {
+      this.raw.exec('ROLLBACK');
+      throw err;
+    }
+  }
+}
+
+// --- The real schema --------------------------------------------------------
+
+/**
+ * Applies every migration, in filename order, with foreign keys ON.
+ *
+ * Foreign keys are enabled explicitly because D1 enables them by default and
+ * `node:sqlite` does not: without this, a handler that writes a dangling
+ * reference passes here and fails in production, which is the single most
+ * expensive kind of test-environment difference there is.
+ */
+function applyMigrations(raw: DatabaseSync): void {
+  raw.exec('PRAGMA foreign_keys = ON');
+  const files = readdirSync(MIGRATIONS_DIR)
+    .filter((f) => f.endsWith('.sql'))
+    .sort();
+  if (files.length === 0) throw new Error(`no migrations found in ${MIGRATIONS_DIR}`);
+  for (const file of files) {
+    raw.exec(readFileSync(join(MIGRATIONS_DIR, file), 'utf8'));
+  }
+}
+
+// --- Fixtures ---------------------------------------------------------------
+
+export interface SeededQuestion {
+  id: string;
+  chapterId: string;
+  stem: string;
+  /** All option ids, in authored order. */
+  optionIds: string[];
+  correctOptionId: string;
+  bodies: Map<string, string>;
+}
+
+export interface SeedOptions {
+  chapters?: number;
+  questionsPerChapter?: number;
+  /** Blueprint quota per chapter for the seeded template. */
+  quotaPerChapter?: number;
+  durationMinutes?: number;
+}
+
+export interface TestWorld {
+  d1: SqliteD1;
+  clock: ReturnType<typeof fixedClock>;
+  config: Config;
+  questions: SeededQuestion[];
+  questionById: Map<string, SeededQuestion>;
+  chapterIds: string[];
+  templateId: string;
+  /** A fresh query-counting Db, i.e. one simulated Worker invocation. */
+  invocation(budget?: number): Db;
+  /** Context for a given user, with its own invocation budget. */
+  contextFor(user: SessionUser, options?: { db?: Db }): HandlerContext;
+  makeUser(overrides?: Partial<SessionUser>): SessionUser;
+  close(): void;
+}
+
+export const T0 = Date.parse('2026-03-01T04:00:00.000Z');
+
+const TEST_CONFIG: Config = {
+  appOrigin: 'https://app.test',
+  // Google is deliberately unconfigured in the fixture, and unconfigured is
+  // not the same as misconfigured -- see `requireGoogle`.
+  googleConfigError: null,
+  // 32+ chars, as `loadConfig` requires.
+  permutationSecret: 'test-permutation-secret-0123456789abcdef',
+  passwordIterations: 10_000,
+  queryBudget: 45,
+  isProduction: false,
+  google: null,
+};
+
+/** The sub-chapters a chapter is divided into, as the official syllabus does. */
+const SUBCHAPTERS_PER_CHAPTER = 6;
+
+/**
+ * `equal-chapter-weight-largest-remainder`, the rule
+ * `frontend/src/data/examBlueprint.ts` publishes and
+ * `db/seed/generate-reference-sql.mjs` implements.
+ *
+ * Reimplemented here rather than imported because the fixture needs it for an
+ * arbitrary per-chapter quota, not just for 10. The assertion that it agrees
+ * with the frontend lives in the generator; this is the same three lines.
+ */
+function largestRemainder(total: number, buckets: number): number[] {
+  const base = Math.floor(total / buckets);
+  const spare = total - base * buckets;
+  return Array.from({ length: buckets }, (_, i) => base + (i < spare ? 1 : 0));
+}
+
+/** The real `questions.id` derivation: content, never position. */
+function questionIdFor(payload: string): { id: string; hash: string } {
+  const hash = createHash('sha256').update(payload, 'utf8').digest('hex');
+  return { id: `q_${hash.slice(0, 16)}`, hash };
+}
+
+const B32 = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+/**
+ * A 12-character CSPRNG option key, exactly as the importer mints them.
+ *
+ * THE FIXTURE MUST NOT DERIVE THIS FROM THE ORDINAL. The whole point of the id
+ * scheme in `migrations/0002_content.sql` is that an option id carries no
+ * information about the authored slot; a fixture that quietly encoded one would
+ * make every "no option id reaches a client" assertion in this suite a test of
+ * nothing.
+ */
+function newOptionKey(): string {
+  const bytes = randomFillSync(new Uint8Array(12));
+  let out = '';
+  for (let i = 0; i < 12; i++) out += B32[bytes[i] & 31];
+  return out;
+}
+
+function insertUser(
+  raw: DatabaseSync,
+  user: { id: string; email: string | null; displayName: string; role: string; isAnonymous: boolean; now: number },
+): void {
+  // Two rows per user, as `data/auth.ts#createUser` writes them: the credential
+  // in `users` and the display half in `user_profiles`, which physically holds
+  // no credential column.
+  raw
+    .prepare(
+      `INSERT INTO users (id, email, email_verified_at, password_hash, password_algo,
+                          role, is_anonymous, status, created_at, updated_at)
+       VALUES (?, ?, NULL, NULL, NULL, ?, ?, 'active', ?, ?)`,
+    )
+    .run(user.id, user.email, user.role, user.isAnonymous ? 1 : 0, user.now, user.now);
+  raw
+    .prepare(
+      `INSERT INTO user_profiles (user_id, display_name, created_at, updated_at)
+       VALUES (?, ?, ?, ?)`,
+    )
+    .run(user.id, user.displayName, user.now, user.now);
+}
+
+export function createWorld(options: SeedOptions = {}): TestWorld {
+  const chapterCount = options.chapters ?? 3;
+  const perChapter = options.questionsPerChapter ?? 12;
+  const quota = options.quotaPerChapter ?? 4;
+  const durationMinutes = options.durationMinutes ?? 45;
+
+  const raw = new DatabaseSync(':memory:');
+  applyMigrations(raw);
+
+  const questions: SeededQuestion[] = [];
+  const chapterIds: string[] = [];
+
+  // The fixture's chapters live under the subject 0007 already seeded, with
+  // their own NEC codes and slugs so the unique indexes on both are satisfied
+  // alongside the ten real ones.
+  const SUBJECT = 'nec-computer';
+
+  const insertChapter = raw.prepare(
+    `INSERT INTO chapters (id, subject_id, nec_code, ordinal, slug, title, display_name,
+                           short_name, description, color, icon, legacy_data_file, status,
+                           created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, '', '#000000', 'book', NULL, 'published', ?, ?)`,
+  );
+  const insertSubchapter = raw.prepare(
+    `INSERT INTO subchapters (id, chapter_id, code, ordinal, title, description, status,
+                              created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, NULL, 'published', ?, ?)`,
+  );
+  const insertQuestion = raw.prepare(
+    `INSERT INTO questions (id, content_hash, subject_id, chapter_id, subchapter_id, stem,
+                            stem_format, status, status_reason, status_changed_at,
+                            difficulty, has_pinned_options, source, source_ref, legacy_id,
+                            created_at, updated_at)
+     VALUES (?, ?, ?, ?, NULL, ?, 'plain', 'published', NULL, ?, 'medium', 0,
+             'book-import', NULL, NULL, ?, ?)`,
+  );
+  const insertOption = raw.prepare(
+    `INSERT INTO question_options (id, question_id, ordinal, opt_key, text, text_format,
+                                   is_pinned, retired_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, 'plain', 0, NULL, ?, ?)`,
+  );
+  const insertKey = raw.prepare(
+    `INSERT INTO question_answer_keys (question_id, correct_option_id, source,
+                                       authored_index, authored_text, created_at, updated_at)
+     VALUES (?, ?, 'import', ?, NULL, ?, ?)`,
+  );
+
+  const subchapterCodes: string[][] = [];
+
+  for (let c = 1; c <= chapterCount; c++) {
+    const chapterId = `ch${c}`;
+    chapterIds.push(chapterId);
+    insertChapter.run(
+      chapterId,
+      SUBJECT,
+      `TEST${String(c).padStart(2, '0')}`,
+      100 + c,
+      `test-chapter-${c}`,
+      `Test Chapter ${c}`,
+      `Chapter ${c}`,
+      `Ch${c}`,
+      T0,
+      T0,
+    );
+
+    const codes: string[] = [];
+    for (let j = 1; j <= SUBCHAPTERS_PER_CHAPTER; j++) {
+      const code = `9${c}.${j}`;
+      codes.push(code);
+      insertSubchapter.run(`test-${code}`, chapterId, code, j, `Topic ${code}`, T0, T0);
+    }
+    subchapterCodes.push(codes);
+
+    for (let q = 1; q <= perChapter; q++) {
+      const stem = `Stem ${chapterId} item ${q}`;
+      const { id: questionId, hash } = questionIdFor(`${chapterId}${stem}`);
+      insertQuestion.run(questionId, hash, SUBJECT, chapterId, stem, T0, T0, T0);
+
+      // Option ids follow the REAL schema's convention,
+      // `question_id || '#' || opt_key` with a 12-character CSPRNG key, so the
+      // authored ordinal is NOT recoverable from the id. That is the property
+      // `content-refs.test.ts` exists to hold, and seeding it any other way
+      // would make that suite prove nothing.
+      const optionIds: string[] = [];
+      const bodies = new Map<string, string>();
+      // Rotate which authored slot is correct, so a test that accidentally
+      // depends on "slot 1 is always right" fails.
+      const correctSlot = (q % 4) + 1;
+      let correctOptionId = '';
+
+      for (let o = 1; o <= 4; o++) {
+        const optionId = `${questionId}#${newOptionKey()}`;
+        const body = `${chapterId} q${q} choice ${o}`;
+        insertOption.run(optionId, questionId, o, optionId.split('#')[1], body, T0, T0);
+        optionIds.push(optionId);
+        bodies.set(optionId, body);
+        if (o === correctSlot) correctOptionId = optionId;
+      }
+
+      // The key lives in its own table, one row per question. `questions` and
+      // `question_options` have no answer column at all.
+      insertKey.run(questionId, correctOptionId, correctSlot, T0, T0);
+
+      questions.push({ id: questionId, chapterId, stem, optionIds, correctOptionId, bodies });
+    }
+  }
+
+  // A version-2, SUB-CHAPTER-LEVEL blueprint, split by the same
+  // largest-remainder rule the real templates use. With no question carrying a
+  // `subchapter_id`, every rule is satisfied from its chapter's pool -- which
+  // is the production situation too, and the reason the fallback is exercised
+  // by every test in this suite rather than by one.
+  const quotas = largestRemainder(quota, SUBCHAPTERS_PER_CHAPTER);
+  const rules = chapterIds.flatMap((chapterId, index) =>
+    subchapterCodes[index].map((code, j) => ({
+      chapter_id: chapterId,
+      subchapter_code: code,
+      count: quotas[j],
+      difficulty: null,
+      tag_ids: null,
+    })),
+  );
+  const totalQuestions = rules.reduce((sum, r) => sum + r.count, 0);
+
+  const templateId = 'tpl_main';
+  raw
+    .prepare(
+      `INSERT INTO mock_test_templates (id, subject_id, slug, name, description,
+                                        duration_minutes, total_questions, blueprint,
+                                        selection, status, ordinal, created_by,
+                                        created_at, updated_at)
+       VALUES (?, ?, 'main', 'Full Mock', '', ?, ?, ?, 'random', 'published', 99, NULL, ?, ?)`,
+    )
+    .run(
+      templateId,
+      SUBJECT,
+      durationMinutes,
+      totalQuestions,
+      JSON.stringify({
+        version: 2,
+        weighting_rule: 'equal-chapter-weight-largest-remainder',
+        shuffle_options: true,
+        negative_marking: 0,
+        pass_mark_bp: 5000,
+        strict_subchapter: false,
+        rules,
+      }),
+      T0,
+      T0,
+    );
+
+  const clock = fixedClock(T0);
+  const d1 = new SqliteD1(raw);
+
+  let userSeq = 0;
+
+  const world: TestWorld = {
+    d1,
+    clock,
+    config: TEST_CONFIG,
+    questions,
+    questionById: new Map(questions.map((q) => [q.id, q])),
+    chapterIds,
+    templateId,
+
+    invocation(budget = 45) {
+      return new Db(d1, { budget });
+    },
+
+    contextFor(user, opts = {}) {
+      return {
+        db: opts.db ?? new Db(d1, { budget: TEST_CONFIG.queryBudget }),
+        clock: clock as Clock,
+        config: TEST_CONFIG,
+        // A synthetic session id. It is deliberately not a real `sessions` row:
+        // these tests drive handlers directly, and the session lookup is
+        // exercised by `auth.test.ts` through the real cookie path.
+        auth: { user, sessionId: `ses_${user.id}` },
+        meta: { ipHash: 'test-ip-hash', userAgent: 'node-test' },
+        cookies: [],
+      };
+    },
+
+    makeUser(overrides = {}) {
+      userSeq += 1;
+      const isAnonymous = overrides.isAnonymous ?? false;
+      const user: SessionUser = {
+        id: overrides.id ?? `usr_test_${userSeq}`,
+        // A guest has no address, and the schema has a CHECK that says so.
+        email: isAnonymous ? null : (overrides.email ?? `user${userSeq}@test.local`),
+        displayName: overrides.displayName ?? `User ${userSeq}`,
+        role: overrides.role ?? 'student',
+        isAnonymous,
+        hasPassword: overrides.hasPassword ?? !isAnonymous,
+        createdAt: overrides.createdAt ?? T0,
+      };
+      insertUser(raw, {
+        id: user.id,
+        email: user.email,
+        displayName: user.displayName ?? `User ${userSeq}`,
+        role: user.role,
+        isAnonymous: user.isAnonymous,
+        now: T0,
+      });
+      return user;
+    },
+
+    close() {
+      raw.close();
+    },
+  };
+
+  return world;
+}
+
+/** Runs a handler on its own invocation budget and reports what it spent. */
+export async function measure<T>(
+  world: TestWorld,
+  user: SessionUser,
+  run: (ctx: HandlerContext) => Promise<T>,
+): Promise<{ result: T; queries: number; ctx: HandlerContext }> {
+  const ctx = world.contextFor(user);
+  const result = await run(ctx);
+  return { result, queries: ctx.db.queryCount, ctx };
+}
+
+/** Asserts a thrown `ApiException` and returns its code. */
+export async function expectFailure(
+  run: () => Promise<unknown>,
+): Promise<{ code: string; status: number; message: string }> {
+  try {
+    await run();
+  } catch (err) {
+    const e = err as { name?: string; code?: string; status?: number; message?: string };
+    if (e.name !== 'ApiException') {
+      throw new Error(`Expected an ApiException, got ${String(err)}`);
+    }
+    return {
+      code: e.code ?? '',
+      status: e.status ?? 0,
+      message: e.message ?? '',
+    };
+  }
+  throw new Error('Expected the call to fail, but it succeeded.');
+}
diff --git a/worker/src/__tests__/idempotency.test.ts b/worker/src/__tests__/idempotency.test.ts
new file mode 100644
index 0000000..4b27950
--- /dev/null
+++ b/worker/src/__tests__/idempotency.test.ts
@@ -0,0 +1,353 @@
+/**
+ * Idempotency, which is the contract the offline outbox depends on.
+ *
+ * The scenarios are the ones a flaky mobile connection in Nepal actually
+ * produces: the request committed but the response never arrived; the queue
+ * replayed an entry it had already sent; two tabs submitted at once.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createWorld, expectFailure, measure } from './harness.ts';
+import { startMock, submitMock } from '../handlers/mock.ts';
+import { answerPractice, finishPractice, startPractice } from '../handlers/practice.ts';
+import { putBookmark } from '../handlers/progress.ts';
+import { submitErrataReport } from '../handlers/moderation.ts';
+import { reserveIdempotency } from '../data/infra.ts';
+import { canonicalJson } from '../lib/canonical.ts';
+import { sha256Hex } from '../lib/password.ts';
+import { MINUTE } from '../lib/time.ts';
+
+/**
+ * `idempotency_keys.request_hash` has a CHECK that it is 64 lowercase hex
+ * characters, because the production path always stores `sha256Hex(endpoint +
+ * canonical body)` and a shorter value would mean something had bypassed
+ * `withIdempotency`. These tests therefore hash their fixtures too, rather than
+ * passing a readable placeholder the database is right to reject.
+ */
+const HASH_A = await sha256Hex('request-body-a');
+const HASH_B = await sha256Hex('request-body-b');
+
+test('canonical JSON ignores key order and the idempotency key itself', () => {
+  assert.equal(
+    canonicalJson({ b: 1, a: 2, idempotencyKey: 'one' }),
+    canonicalJson({ a: 2, b: 1, idempotencyKey: 'two' }),
+  );
+  assert.notEqual(canonicalJson({ a: 1 }), canonicalJson({ a: 2 }));
+  // A missing key and an explicit undefined must fingerprint identically.
+  assert.equal(canonicalJson({ a: 1 }), canonicalJson({ a: 1, b: undefined }));
+  // Nested objects are canonicalised too.
+  assert.equal(
+    canonicalJson({ answers: { q2: 'b', q1: 'a' } }),
+    canonicalJson({ answers: { q1: 'a', q2: 'b' } }),
+  );
+});
+
+test('replaying mock/start with the same key returns the SAME paper', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const idempotencyKey = 'start-key-aaaaaaaa';
+
+  const first = await measure(world, user, (ctx) =>
+    startMock(ctx, { templateId: world.templateId, idempotencyKey }),
+  );
+  const second = await measure(world, user, (ctx) =>
+    startMock(ctx, { templateId: world.templateId, idempotencyKey }),
+  );
+
+  assert.equal(first.result.replayed ?? false, false);
+  assert.equal(second.result.replayed, true);
+  assert.equal(second.result.body.attemptId, first.result.body.attemptId);
+  assert.deepEqual(
+    second.result.body.questions.map((q) => q.options.map((o) => o.ref)),
+    first.result.body.questions.map((q) => q.options.map((o) => o.ref)),
+    'the replayed paper must carry the identical refs, or the client would submit refs the server never minted',
+  );
+
+  world.close();
+});
+
+test('replaying mock/submit with the same key returns the SAME score', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const start = await measure(world, user, (ctx) =>
+    startMock(ctx, { templateId: world.templateId, idempotencyKey: 'sk-aaaaaaaa' }),
+  );
+  const paper = start.result.body;
+
+  const answers: Record<string, string> = {};
+  for (const question of paper.questions.slice(0, 4)) {
+    answers[question.questionId] = question.options[0].ref;
+  }
+
+  world.clock.advance(MINUTE);
+  const idempotencyKey = 'submit-key-bbbbbbbb';
+
+  const first = await measure(world, user, (ctx) =>
+    submitMock(ctx, { attemptId: paper.attemptId, idempotencyKey, answers }),
+  );
+  const second = await measure(world, user, (ctx) =>
+    submitMock(ctx, { attemptId: paper.attemptId, idempotencyKey, answers }),
+  );
+
+  assert.equal(second.result.replayed, true);
+  assert.equal(second.result.body.score, first.result.body.score);
+  assert.deepEqual(second.result.body.review, first.result.body.review);
+
+  // Critically, the replay does NOT re-score the attempt or double-count the
+  // user's stats - it never reaches the write path at all.
+  assert.ok(
+    second.queries < first.queries,
+    `a replay should be cheaper than the original (${second.queries} vs ${first.queries})`,
+  );
+
+  world.close();
+});
+
+test('a resubmit with a DIFFERENT key is refused, not scored twice', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const start = await measure(world, user, (ctx) =>
+    startMock(ctx, { templateId: world.templateId, idempotencyKey: 'sk2-aaaaaaaa' }),
+  );
+  const paper = start.result.body;
+
+  world.clock.advance(MINUTE);
+  await measure(world, user, (ctx) =>
+    submitMock(ctx, {
+      attemptId: paper.attemptId,
+      idempotencyKey: 'first-key-cccccccc',
+      answers: { [paper.questions[0].questionId]: paper.questions[0].options[0].ref },
+    }),
+  );
+
+  const failure = await expectFailure(() =>
+    measure(world, user, (ctx) =>
+      submitMock(ctx, {
+        attemptId: paper.attemptId,
+        idempotencyKey: 'second-key-dddddddd',
+        answers: { [paper.questions[0].questionId]: paper.questions[0].options[1].ref },
+      }),
+    ),
+  );
+
+  assert.equal(failure.code, 'ATTEMPT_NOT_IN_PROGRESS');
+  assert.equal(failure.status, 409);
+
+  world.close();
+});
+
+test('the same key with a different body is a conflict, never a wrong replay', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const start = await measure(world, user, (ctx) =>
+    startMock(ctx, { templateId: world.templateId, idempotencyKey: 'sk3-aaaaaaaa' }),
+  );
+  const paper = start.result.body;
+  const sharedKey = 'shared-key-eeeeeeee';
+
+  world.clock.advance(MINUTE);
+  await measure(world, user, (ctx) =>
+    submitMock(ctx, {
+      attemptId: paper.attemptId,
+      idempotencyKey: sharedKey,
+      answers: { [paper.questions[0].questionId]: paper.questions[0].options[0].ref },
+    }),
+  );
+
+  const failure = await expectFailure(() =>
+    measure(world, user, (ctx) =>
+      submitMock(ctx, {
+        attemptId: paper.attemptId,
+        idempotencyKey: sharedKey,
+        // Same key, different answers. Replaying the stored response would be
+        // a lie; scoring it would be a double submission.
+        answers: { [paper.questions[1].questionId]: paper.questions[1].options[0].ref },
+      }),
+    ),
+  );
+
+  assert.equal(failure.code, 'IDEMPOTENCY_KEY_REUSED');
+  assert.equal(failure.status, 409);
+
+  world.close();
+});
+
+test('an in-flight reservation is reported, not silently duplicated', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const db = world.invocation();
+
+  const args = {
+    userId: user.id,
+    key: 'inflight-key-ffffffff',
+    endpoint: 'POST /api/mock/submit',
+    requestHash: HASH_A,
+    now: world.clock.now(),
+  };
+
+  assert.deepEqual(await reserveIdempotency(db, args), { kind: 'proceed' });
+  assert.deepEqual(await reserveIdempotency(db, args), { kind: 'in_flight' });
+  assert.deepEqual(
+    await reserveIdempotency(db, { ...args, requestHash: HASH_B }),
+    { kind: 'reused' },
+  );
+
+  world.close();
+});
+
+test('one user\'s idempotency key cannot collide with another\'s', async () => {
+  const world = createWorld();
+  const alice = world.makeUser();
+  const bob = world.makeUser();
+  const db = world.invocation();
+
+  const shared = {
+    key: 'collide-key-gggggggg',
+    endpoint: 'POST /api/mock/start',
+    requestHash: HASH_A,
+    now: world.clock.now(),
+  };
+
+  assert.deepEqual(
+    await reserveIdempotency(db, { ...shared, userId: alice.id }),
+    { kind: 'proceed' },
+  );
+  assert.deepEqual(
+    await reserveIdempotency(db, { ...shared, userId: bob.id }),
+    { kind: 'proceed' },
+    'Bob must get his own reservation, not Alice\'s in-flight marker',
+  );
+
+  world.close();
+});
+
+test('practice/answer is idempotent on (session, question) with NO key', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const session = await measure(world, user, (ctx) =>
+    startPractice(ctx, {
+      mode: 'chapter',
+      chapterIds: [world.chapterIds[0]],
+      questionCount: 5,
+      idempotencyKey: 'practice-start-hhhhhhhh',
+    }),
+  );
+  const paper = session.result.body;
+  const question = paper.questions[0];
+
+  const first = await measure(world, user, (ctx) =>
+    answerPractice(ctx, {
+      sessionId: paper.sessionId,
+      questionId: question.questionId,
+      optionRef: question.options[0].ref,
+    }),
+  );
+
+  // Replay the identical mutation, exactly as a drained outbox would.
+  const second = await measure(world, user, (ctx) =>
+    answerPractice(ctx, {
+      sessionId: paper.sessionId,
+      questionId: question.questionId,
+      optionRef: question.options[0].ref,
+    }),
+  );
+
+  assert.equal(first.result.body.answeredCount, 1);
+  assert.equal(
+    second.result.body.answeredCount,
+    1,
+    'a replayed answer must not inflate the counters',
+  );
+  assert.equal(second.result.body.correctRef, first.result.body.correctRef);
+  assert.equal(second.result.body.isCorrect, first.result.body.isCorrect);
+
+  world.close();
+});
+
+test('practice/finish replays its totals rather than conflicting', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const session = await measure(world, user, (ctx) =>
+    startPractice(ctx, {
+      mode: 'chapter',
+      chapterIds: [world.chapterIds[0]],
+      questionCount: 3,
+      idempotencyKey: 'practice-start-iiiiiiii',
+    }),
+  );
+  const sessionId = session.result.body.sessionId;
+  const finishKey = 'practice-finish-jjjjjjjj';
+
+  const first = await measure(world, user, (ctx) =>
+    finishPractice(ctx, { sessionId, idempotencyKey: finishKey }),
+  );
+  const second = await measure(world, user, (ctx) =>
+    finishPractice(ctx, { sessionId, idempotencyKey: finishKey }),
+  );
+
+  assert.equal(second.result.replayed, true);
+  assert.deepEqual(second.result.body, first.result.body);
+
+  world.close();
+});
+
+test('bookmarks converge on replay because they express a desired state', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const questionId = world.questions[0].id;
+
+  const add1 = await measure(world, user, (ctx) =>
+    putBookmark(ctx, { questionId, desired: true }),
+  );
+  const add2 = await measure(world, user, (ctx) =>
+    putBookmark(ctx, { questionId, desired: true }),
+  );
+
+  assert.equal(add1.result.body.bookmarked, true);
+  assert.equal(add1.result.body.total, 1);
+  assert.equal(add2.result.body.bookmarked, true);
+  assert.equal(add2.result.body.total, 1, 'replaying an add must not create a second row');
+
+  const remove1 = await measure(world, user, (ctx) =>
+    putBookmark(ctx, { questionId, desired: false }),
+  );
+  const remove2 = await measure(world, user, (ctx) =>
+    putBookmark(ctx, { questionId, desired: false }),
+  );
+
+  assert.equal(remove1.result.body.bookmarked, false);
+  assert.equal(remove2.result.body.bookmarked, false);
+  assert.equal(remove2.result.body.total, 0);
+
+  world.close();
+});
+
+test('errata reports converge on replay without an idempotency key', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const questionId = world.questions[3].id;
+
+  const first = await measure(world, user, (ctx) =>
+    submitErrataReport(ctx, { questionId, reason: 'wrong_answer', detail: 'Key looks wrong.' }),
+  );
+  const second = await measure(world, user, (ctx) =>
+    submitErrataReport(ctx, { questionId, reason: 'wrong_answer', detail: 'Key looks wrong.' }),
+  );
+
+  assert.equal(first.result.body.created, true);
+  assert.equal(second.result.body.created, false);
+  assert.equal(
+    second.result.body.reportId,
+    first.result.body.reportId,
+    'the second call must update the existing report, not file a duplicate',
+  );
+
+  world.close();
+});
diff --git a/worker/src/__tests__/jobs.test.ts b/worker/src/__tests__/jobs.test.ts
new file mode 100644
index 0000000..59fd8e7
--- /dev/null
+++ b/worker/src/__tests__/jobs.test.ts
@@ -0,0 +1,544 @@
+/**
+ * The three scheduled jobs, against a real SQLite database with every
+ * migration applied.
+ *
+ * These existed as cron expressions in `wrangler.toml` with no implementation
+ * behind them, which is worse than not having them: Cloudflare fires the
+ * trigger, finds no `scheduled` export, and the job silently never runs.
+ * `attempt_answers` was growing toward D1's 500 MB wall with no bound at all.
+ *
+ * So the tests here are mostly about the properties that make these jobs safe
+ * to run unattended — that retention cannot overspend the day's write
+ * allowance, that it cannot destroy a score, that the sweep cannot free a
+ * student from a paper they are still sitting, and that an unknown cron
+ * expression fails loudly instead of running the wrong work.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createWorld, measure, T0 } from './harness.ts';
+import type { TestWorld } from './harness.ts';
+import { startMock, submitMock } from '../handlers/mock.ts';
+import type { MockAttemptPaper } from '../shared/types.ts';
+import type { SessionUser } from '../shared/types.ts';
+import { DAY, MINUTE, fixedClock } from '../lib/time.ts';
+import {
+  runAnswerRetention,
+  ABANDONED_RETENTION_DAYS,
+  WRITE_COST_PER_ANSWER,
+} from '../jobs/retention.ts';
+import { runNightlySweep } from '../jobs/sweep.ts';
+import { runLeaderboardSnapshot, periodWindow } from '../jobs/leaderboard.ts';
+import {
+  handleScheduled,
+  retentionDays,
+  CRON_RETENTION,
+  CRON_SWEEP,
+  CRON_LEADERBOARD,
+} from '../jobs/index.ts';
+import type { Env } from '../env.ts';
+
+let keyCounter = 0;
+function key(prefix: string): string {
+  keyCounter += 1;
+  return `${prefix}-job-key-${keyCounter}`;
+}
+
+async function start(world: TestWorld, user: SessionUser): Promise<MockAttemptPaper> {
+  const { result } = await measure(world, user, (ctx) =>
+    startMock(ctx, { templateId: world.templateId, idempotencyKey: key('start') }),
+  );
+  return result.body;
+}
+
+/** The option ref the fixture says is correct, for a given delivered question. */
+function correctRefFor(world: TestWorld, paper: MockAttemptPaper, questionId: string): string {
+  const delivered = paper.questions.find((q) => q.questionId === questionId);
+  assert.ok(delivered, 'question not in paper');
+  const seeded = world.questionById.get(questionId);
+  assert.ok(seeded, 'question not in fixture');
+  const ref = delivered.options.find(
+    (o) => seeded.bodies.get(seeded.correctOptionId) === o.body,
+  );
+  assert.ok(ref, 'correct option not delivered');
+  return ref.ref;
+}
+
+/** Submit a whole paper correctly, so the attempt carries a real score. */
+async function submitAllCorrect(
+  world: TestWorld,
+  user: SessionUser,
+  paper: MockAttemptPaper,
+): Promise<void> {
+  // The wire shape is questionId -> optionRef, which is also what makes a
+  // cross-attempt ref impossible to smuggle in.
+  const answers: Record<string, string> = {};
+  for (const q of paper.questions) {
+    answers[q.questionId] = correctRefFor(world, paper, q.questionId);
+  }
+  await measure(world, user, (ctx) =>
+    submitMock(ctx, {
+      attemptId: paper.attemptId,
+      answers,
+      idempotencyKey: key('submit'),
+    }),
+  );
+}
+
+/** Ages an attempt and its answers by rewriting their timestamps directly. */
+function ageAttempt(world: TestWorld, publicId: string, toMs: number): void {
+  const row = world.d1.raw
+    .prepare('SELECT id FROM attempts WHERE public_id = ?')
+    .get(publicId) as { id: number } | undefined;
+  assert.ok(row, 'attempt not found');
+  world.d1.raw
+    .prepare('UPDATE attempts SET submitted_at = ? WHERE id = ?')
+    .run(toMs, row.id);
+  world.d1.raw
+    .prepare('UPDATE attempt_answers SET answered_at = ? WHERE attempt_id = ?')
+    .run(toMs, row.id);
+}
+
+function countAnswers(world: TestWorld): number {
+  const row = world.d1.raw
+    .prepare('SELECT COUNT(*) AS n FROM attempt_answers')
+    .get() as { n: number };
+  return row.n;
+}
+
+// --- Retention ---------------------------------------------------------------
+
+test('retention deletes answers past the window and keeps the score', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+  await submitAllCorrect(world, user, paper);
+
+  const before = world.d1.raw
+    .prepare('SELECT correct_count, answered_count, score_bp FROM attempts WHERE public_id = ?')
+    .get(paper.attemptId) as { correct_count: number; answered_count: number; score_bp: number };
+  assert.ok(before.answered_count > 0, 'fixture should have answers');
+  assert.equal(before.correct_count, before.answered_count);
+
+  // Age it past a 90-day window.
+  ageAttempt(world, paper.attemptId, T0 - 120 * DAY);
+
+  const result = await runAnswerRetention(world.invocation(), {
+    submittedRetentionDays: 90,
+    rowWriteBudget: 100_000,
+    now: T0,
+  });
+
+  assert.equal(result.answersDeleted, before.answered_count);
+  assert.equal(countAnswers(world), 0);
+
+  // The point of the whole design: the score is trigger-maintained on
+  // `attempts`, so deleting the raw answers must not touch it.
+  const after = world.d1.raw
+    .prepare('SELECT correct_count, answered_count, score_bp FROM attempts WHERE public_id = ?')
+    .get(paper.attemptId) as { correct_count: number; answered_count: number; score_bp: number };
+  assert.deepEqual(after, before);
+
+  world.close();
+});
+
+test('retention leaves answers inside the window alone', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+  await submitAllCorrect(world, user, paper);
+
+  const total = countAnswers(world);
+  ageAttempt(world, paper.attemptId, T0 - 10 * DAY);
+
+  const result = await runAnswerRetention(world.invocation(), {
+    submittedRetentionDays: 90,
+    rowWriteBudget: 100_000,
+    now: T0,
+  });
+
+  assert.equal(result.answersDeleted, 0);
+  assert.equal(countAnswers(world), total);
+  world.close();
+});
+
+test('an abandoned paper loses its answers far sooner than a submitted one', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  // Answer without submitting, so the attempt stays 'in_progress', then mark
+  // it abandoned the way the sweep would.
+  const row = world.d1.raw
+    .prepare('SELECT id FROM attempts WHERE public_id = ?')
+    .get(paper.attemptId) as { id: number };
+  const q = paper.questions[0];
+  world.d1.raw
+    .prepare(
+      `INSERT INTO attempt_answers
+         (attempt_id, question_id, selected_opt_key, is_correct, delivered_position, answered_at)
+       VALUES (?, ?, NULL, 0, 1, ?)`,
+    )
+    .run(row.id, q.questionId, T0 - (ABANDONED_RETENTION_DAYS + 1) * DAY);
+  world.d1.raw.prepare(`UPDATE attempts SET status = 'abandoned' WHERE id = ?`).run(row.id);
+
+  const result = await runAnswerRetention(world.invocation(), {
+    // Deliberately generous: the submitted window must not rescue an
+    // abandoned attempt's answers.
+    submittedRetentionDays: 365,
+    rowWriteBudget: 100_000,
+    now: T0,
+  });
+
+  assert.equal(result.answersDeleted, 1);
+  world.close();
+});
+
+test('retention stops at its row-write budget rather than taking the platform read-only', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+  await submitAllCorrect(world, user, paper);
+  const total = countAnswers(world);
+  assert.ok(total >= 4, 'need several answers to see a partial run');
+
+  ageAttempt(world, paper.attemptId, T0 - 200 * DAY);
+
+  // Budget for exactly two answers.
+  const result = await runAnswerRetention(world.invocation(), {
+    submittedRetentionDays: 90,
+    rowWriteBudget: 2 * WRITE_COST_PER_ANSWER,
+    now: T0,
+  });
+
+  assert.equal(result.answersDeleted, 2);
+  assert.equal(result.budgetExhausted, true);
+  assert.equal(countAnswers(world), total - 2);
+  // And the rest is still there for tomorrow, oldest-first having made
+  // progress on the rows closest to being a problem.
+  assert.ok(result.oldestRemainingAt !== null);
+  world.close();
+});
+
+// --- Sweep -------------------------------------------------------------------
+
+test('the sweep expires a paper whose deadline has passed', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  const deadline = world.d1.raw
+    .prepare('SELECT deadline_at, started_at FROM attempts WHERE public_id = ?')
+    .get(paper.attemptId) as { deadline_at: number; started_at: number };
+  assert.ok(deadline.deadline_at > T0, 'fixture paper should be timed and open');
+
+  const result = await runNightlySweep(world.invocation(), {
+    now: deadline.deadline_at + MINUTE,
+  });
+
+  assert.equal(result.attemptsExpired, 1);
+  const after = world.d1.raw
+    .prepare('SELECT status, submitted_at, elapsed_ms FROM attempts WHERE public_id = ?')
+    .get(paper.attemptId) as { status: string; submitted_at: number | null; elapsed_ms: number };
+  assert.equal(after.status, 'expired');
+  // The CHECK on `attempts` ties submitted_at to status='submitted'; an
+  // expired paper was never submitted.
+  assert.equal(after.submitted_at, null);
+  // Credited only up to the deadline, not up to whenever the cron happened to
+  // run — the student stopped working at an unknown earlier point, and the
+  // deadline is the only defensible upper bound. Running the sweep a week late
+  // must not inflate the recorded time.
+  assert.equal(after.elapsed_ms, deadline.deadline_at - deadline.started_at);
+  world.close();
+});
+
+test('the sweep does not touch a paper that is still inside its deadline', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  const result = await runNightlySweep(world.invocation(), { now: T0 + MINUTE });
+
+  assert.equal(result.attemptsExpired, 0);
+  const after = world.d1.raw
+    .prepare('SELECT status FROM attempts WHERE public_id = ?')
+    .get(paper.attemptId) as { status: string };
+  assert.equal(after.status, 'in_progress');
+  world.close();
+});
+
+test('the sweep deletes sessions past their absolute ceiling, not their idle one', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const mk = (id: string, idle: number, absolute: number) =>
+    world.d1.raw
+      .prepare(
+        `INSERT INTO sessions (id, user_id, created_at, expires_at, absolute_expires_at)
+         VALUES (?, ?, ?, ?, ?)`,
+      )
+      .run(id, user.id, T0, idle, absolute);
+
+  // Idle-expired but inside its absolute ceiling: must survive, because the
+  // idle clock slides and a live tab can legitimately revive it.
+  mk('a'.repeat(64), T0 - DAY, T0 + 30 * DAY);
+  // Past the hard ceiling: nothing revives this.
+  mk('b'.repeat(64), T0 - 60 * DAY, T0 - 30 * DAY);
+
+  const result = await runNightlySweep(world.invocation(), { now: T0 });
+
+  assert.equal(result.sessionsDeleted, 1);
+  const left = world.d1.raw.prepare('SELECT id FROM sessions').all() as { id: string }[];
+  assert.deepEqual(
+    left.map((r) => r.id),
+    ['a'.repeat(64)],
+  );
+  world.close();
+});
+
+test('the sweep prunes expired notifications but keeps open-ended ones', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const mk = (kind: string, expiresAt: number | null) =>
+    world.d1.raw
+      .prepare(
+        `INSERT INTO notifications (user_id, kind, title, body, created_at, expires_at)
+         VALUES (?, ?, 'T', NULL, ?, ?)`,
+      )
+      .run(user.id, kind, T0 - DAY, expiresAt);
+
+  mk('streak_risk', T0 - MINUTE);
+  mk('streak_risk', null);
+
+  const result = await runNightlySweep(world.invocation(), { now: T0 });
+
+  assert.equal(result.notificationsDeleted, 1);
+  const row = world.d1.raw
+    .prepare('SELECT COUNT(*) AS n FROM notifications')
+    .get() as { n: number };
+  assert.equal(row.n, 1);
+  world.close();
+});
+
+// --- Leaderboard -------------------------------------------------------------
+
+test('a snapshot ranks only users who opted in', async () => {
+  const world = createWorld();
+  const optedIn = world.makeUser();
+  const optedOut = world.makeUser();
+
+  for (const u of [optedIn, optedOut]) {
+    const paper = await start(world, u);
+    await submitAllCorrect(world, u, paper);
+  }
+
+  world.d1.raw
+    .prepare('UPDATE user_profiles SET leaderboard_opt_in = 1 WHERE user_id = ?')
+    .run(optedIn.id);
+  world.d1.raw
+    .prepare('UPDATE user_profiles SET leaderboard_opt_in = 0 WHERE user_id = ?')
+    .run(optedOut.id);
+
+  const result = await runLeaderboardSnapshot(world.invocation(), { now: T0 });
+
+  const allTime = result.boards.find((b) => b.period === 'all_time');
+  assert.ok(allTime);
+  assert.equal(allTime.ranked, 1);
+  assert.equal(allTime.entrants, 1);
+
+  const top = world.d1.raw
+    .prepare('SELECT top_json FROM leaderboard_snapshots WHERE id = ?')
+    .get(allTime.snapshotId) as { top_json: string };
+  const parsed = JSON.parse(top.top_json) as { user_id: string; rank: number }[];
+  assert.equal(parsed.length, 1);
+  assert.equal(parsed[0].user_id, optedIn.id);
+  assert.equal(parsed[0].rank, 1);
+
+  world.close();
+});
+
+test('a snapshot writes one entry row per rank, and they agree with top_json', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+  await submitAllCorrect(world, user, paper);
+  world.d1.raw
+    .prepare('UPDATE user_profiles SET leaderboard_opt_in = 1 WHERE user_id = ?')
+    .run(user.id);
+
+  const result = await runLeaderboardSnapshot(world.invocation(), { now: T0 });
+  const allTime = result.boards.find((b) => b.period === 'all_time');
+  assert.ok(allTime);
+
+  const entries = world.d1.raw
+    .prepare('SELECT rank, user_id, score, accuracy_bp, prev_rank FROM leaderboard_entries WHERE snapshot_id = ? ORDER BY rank')
+    .all(allTime.snapshotId) as {
+    rank: number;
+    user_id: string;
+    score: number;
+    accuracy_bp: number | null;
+    prev_rank: number | null;
+  }[];
+
+  assert.equal(entries.length, 1);
+  assert.equal(entries[0].rank, 1);
+  assert.equal(entries[0].user_id, user.id);
+  // Every answer was correct, so accuracy is 100% in basis points.
+  assert.equal(entries[0].accuracy_bp, 10_000);
+  // First snapshot of this board, so there is no previous rank to show.
+  assert.equal(entries[0].prev_rank, null);
+
+  world.close();
+});
+
+test('the second snapshot carries the first run’s rank forward', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+  await submitAllCorrect(world, user, paper);
+  world.d1.raw
+    .prepare('UPDATE user_profiles SET leaderboard_opt_in = 1 WHERE user_id = ?')
+    .run(user.id);
+
+  await runLeaderboardSnapshot(world.invocation(), { now: T0 });
+  const second = await runLeaderboardSnapshot(world.invocation(), { now: T0 + 60 * MINUTE });
+
+  const allTime = second.boards.find((b) => b.period === 'all_time');
+  assert.ok(allTime);
+  const entry = world.d1.raw
+    .prepare('SELECT prev_rank FROM leaderboard_entries WHERE snapshot_id = ? AND user_id = ?')
+    .get(allTime.snapshotId, user.id) as { prev_rank: number | null };
+  assert.equal(entry.prev_rank, 1);
+
+  world.close();
+});
+
+test('a board with nobody on it is still written, with an empty array', async () => {
+  const world = createWorld();
+  // Nobody has opted in, so every board is empty. The read path reads the
+  // latest snapshot; if the job skipped empty boards it would serve a stale
+  // one forever.
+  const result = await runLeaderboardSnapshot(world.invocation(), { now: T0 });
+
+  assert.equal(result.boards.length, 4);
+  for (const board of result.boards) {
+    assert.equal(board.ranked, 0);
+    assert.equal(board.entrants, 0);
+    const row = world.d1.raw
+      .prepare('SELECT top_json FROM leaderboard_snapshots WHERE id = ?')
+      .get(board.snapshotId) as { top_json: string };
+    assert.equal(row.top_json, '[]');
+  }
+  world.close();
+});
+
+test('period windows are bucketed in Nepal time, not UTC', () => {
+  // 23:30 UTC on 1 March is 05:15 on 2 March in Kathmandu (UTC+05:45), so the
+  // daily board belongs to the 2nd. Bucketing in UTC would put a late-evening
+  // Nepali study session on the wrong day, which is the same bug the streak
+  // code avoids.
+  const lateUtc = Date.parse('2026-03-01T23:30:00.000Z');
+  assert.equal(periodWindow('daily', lateUtc).periodStart, '2026-03-02');
+
+  // all_time uses the sentinel the schema's CHECK requires.
+  assert.equal(periodWindow('all_time', lateUtc).periodStart, '0001-01-01');
+  assert.equal(periodWindow('all_time', lateUtc).startMs, 0);
+
+  // A monthly window starts on the first of the local month.
+  assert.equal(periodWindow('monthly', lateUtc).periodStart, '2026-03-01');
+});
+
+// --- Dispatch ----------------------------------------------------------------
+
+function envFor(world: TestWorld, overrides: Partial<Env> = {}): Env {
+  return {
+    DB: world.d1,
+    APP_ORIGIN: 'https://app.test',
+    CONTENT_PERMUTATION_SECRET: 'test-permutation-secret-0123456789abcdef',
+    ...overrides,
+  } as Env;
+}
+
+test('each declared cron expression reaches its job', async () => {
+  const world = createWorld();
+  const clock = fixedClock(T0);
+
+  for (const [cron, job] of [
+    [CRON_RETENTION, 'answer-retention'],
+    [CRON_SWEEP, 'nightly-sweep'],
+    [CRON_LEADERBOARD, 'leaderboard-snapshot'],
+  ] as const) {
+    const outcome = await handleScheduled({ cron }, envFor(world), { clock });
+    assert.equal(outcome.ok, true, `${cron} should succeed`);
+    assert.equal(outcome.job, job);
+  }
+
+  world.close();
+});
+
+test('an unregistered cron expression fails loudly', async () => {
+  const world = createWorld();
+  await assert.rejects(
+    () => handleScheduled({ cron: '0 0 * * 0' }, envFor(world), { clock: fixedClock(T0) }),
+    /No scheduled job is registered/,
+  );
+  world.close();
+});
+
+test('a delayed invocation computes the window it was scheduled for', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+  await submitAllCorrect(world, user, paper);
+  ageAttempt(world, paper.attemptId, T0 - 120 * DAY);
+
+  // The clock says a week later than the scheduled time. Using the clock
+  // would be harmless here, but using `scheduledTime` is what makes a retried
+  // invocation compute the same window as the original.
+  const outcome = await handleScheduled(
+    { cron: CRON_RETENTION, scheduledTime: T0 },
+    envFor(world),
+    { clock: fixedClock(T0 + 7 * DAY) },
+  );
+
+  assert.equal(outcome.ok, true);
+  assert.equal(outcome.retentionDays, 90);
+  assert.ok((outcome.answersDeleted as number) > 0);
+  world.close();
+});
+
+test('ANSWER_RETENTION_DAYS is validated, not silently defaulted', () => {
+  assert.equal(retentionDays({} as Env), 90);
+  assert.equal(retentionDays({ ANSWER_RETENTION_DAYS: '180' } as Env), 180);
+  // A typo must not quietly become a 90-day window, or a 7-day one.
+  assert.throws(() => retentionDays({ ANSWER_RETENTION_DAYS: '90 days' } as Env), /Invalid/);
+  assert.throws(() => retentionDays({ ANSWER_RETENTION_DAYS: '3' } as Env), /Invalid/);
+  assert.throws(() => retentionDays({ ANSWER_RETENTION_DAYS: '9999' } as Env), /Invalid/);
+});
+
+test('every job stays inside one Worker invocation’s query budget', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+  await submitAllCorrect(world, user, paper);
+  world.d1.raw
+    .prepare('UPDATE user_profiles SET leaderboard_opt_in = 1 WHERE user_id = ?')
+    .run(user.id);
+
+  // D1's free plan allows 50 queries per invocation. A job that needs more
+  // than that cannot run at all, so this is a hard ceiling rather than a
+  // performance note.
+  for (const cron of [CRON_RETENTION, CRON_SWEEP, CRON_LEADERBOARD]) {
+    const outcome = await handleScheduled({ cron, scheduledTime: T0 }, envFor(world), {
+      clock: fixedClock(T0),
+    });
+    assert.ok(
+      (outcome.queries as number) <= 48,
+      `${cron} used ${String(outcome.queries)} queries`,
+    );
+  }
+
+  world.close();
+});
diff --git a/worker/src/__tests__/mock-anticheat.test.ts b/worker/src/__tests__/mock-anticheat.test.ts
new file mode 100644
index 0000000..4d02802
--- /dev/null
+++ b/worker/src/__tests__/mock-anticheat.test.ts
@@ -0,0 +1,455 @@
+/**
+ * The anti-cheat guarantees, end to end against a real SQLite database through
+ * the real handlers.
+ *
+ * Every test here is phrased as the attack it defeats, because that is what the
+ * code is for. The baseline it is measured against is
+ * `frontend/src/pages/app/MockTestQuiz.tsx`, which fetches
+ * `correct_option_index` to the browser and scores there.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createWorld, expectFailure, measure, T0 } from './harness.ts';
+import { getMockAttempt, getMockReview, startMock, submitMock, syncMock } from '../handlers/mock.ts';
+import { MINUTE } from '../lib/time.ts';
+import type { MockAttemptPaper } from '../shared/types.ts';
+import type { SessionUser } from '../shared/types.ts';
+import type { TestWorld } from './harness.ts';
+
+let keyCounter = 0;
+function key(prefix: string): string {
+  keyCounter += 1;
+  return `${prefix}-idem-key-${keyCounter}`;
+}
+
+async function start(world: TestWorld, user: SessionUser): Promise<MockAttemptPaper> {
+  const { result } = await measure(world, user, (ctx) =>
+    startMock(ctx, { templateId: world.templateId, idempotencyKey: key('start') }),
+  );
+  return result.body;
+}
+
+/** Picks the ref the key says is correct, by looking at the seeded fixture. */
+function correctRefFor(world: TestWorld, paper: MockAttemptPaper, questionId: string): string {
+  const seeded = world.questionById.get(questionId);
+  assert.ok(seeded, `unknown question ${questionId}`);
+  const question = paper.questions.find((q) => q.questionId === questionId);
+  assert.ok(question);
+
+  // The client cannot do this - it is reaching into the fixture's record of
+  // which option id is correct and then finding the ref whose BODY matches.
+  const correctBody = seeded.bodies.get(seeded.correctOptionId);
+  const option = question.options.find((o) => o.body === correctBody);
+  assert.ok(option, 'the correct option body must be on the paper');
+  return option.ref;
+}
+
+test('ATTACK: read the answer key out of the start payload', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const paper = await start(world, user);
+  const serialised = JSON.stringify(paper);
+
+  // Nothing resembling a key is anywhere in the payload.
+  assert.ok(!serialised.includes('is_correct'));
+  assert.ok(!serialised.includes('isCorrect'));
+  assert.ok(!serialised.includes('correct_option_index'));
+  assert.ok(!serialised.includes('correctRef'));
+  assert.ok(!serialised.includes('correctIndex'));
+
+  // And no option id leaks either, which is what stops a ref from being joined
+  // to anything durable.
+  for (const seeded of world.questions) {
+    for (const optionId of seeded.optionIds) {
+      assert.ok(
+        !serialised.includes(optionId),
+        `option id ${optionId} must never reach a client`,
+      );
+    }
+  }
+
+  // Each question has its options, labelled only by opaque ref.
+  assert.equal(paper.questions.length, 12);
+  for (const question of paper.questions) {
+    assert.equal(question.options.length, 4);
+    for (const option of question.options) {
+      assert.match(option.ref, /^[0-9A-Z]{12}$/);
+      assert.ok(option.body.length > 0);
+    }
+  }
+
+  world.close();
+});
+
+test('ATTACK: join option position against the public chapter JSON in git', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  // The authored order is position 1..4, which is what the public JSON encodes
+  // via `correct_option_index`. Across a 12-question paper, the served order
+  // must not match the authored order often enough to be useful.
+  const paper = await start(world, user);
+
+  let identicalOrders = 0;
+  for (const question of paper.questions) {
+    const seeded = world.questionById.get(question.questionId);
+    assert.ok(seeded);
+    const authoredBodies = seeded.optionIds.map((id) => seeded.bodies.get(id));
+    const servedBodies = question.options.map((o) => o.body);
+    if (JSON.stringify(authoredBodies) === JSON.stringify(servedBodies)) identicalOrders++;
+  }
+
+  // 1 in 24 permutations of four options is the identity, so a handful of
+  // matches across 12 questions is expected. More than half would mean the
+  // permutation is not happening.
+  assert.ok(
+    identicalOrders < 6,
+    `${identicalOrders}/12 questions were served in authored order - the permutation is not working`,
+  );
+
+  world.close();
+});
+
+test('ATTACK: reuse a ref learned from a previous attempt', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const first = await start(world, user);
+  const second = await start(world, user);
+
+  // Find a question that appears on both papers.
+  const shared = first.questions.find((a) =>
+    second.questions.some((b) => b.questionId === a.questionId),
+  );
+  assert.ok(shared, 'the two papers should overlap on at least one question');
+  const sameInSecond = second.questions.find((q) => q.questionId === shared.questionId);
+  assert.ok(sameInSecond);
+
+  const firstRefs = new Set(shared.options.map((o) => o.ref));
+  for (const option of sameInSecond.options) {
+    assert.ok(
+      !firstRefs.has(option.ref),
+      'refs must be minted per attempt, so one attempt teaches nothing about another',
+    );
+  }
+
+  // And submitting the first attempt's ref against the second attempt is a
+  // hard error, not a silent miss.
+  const failure = await expectFailure(() =>
+    measure(world, user, (ctx) =>
+      submitMock(ctx, {
+        attemptId: second.attemptId,
+        idempotencyKey: key('cross'),
+        answers: { [shared.questionId]: [...firstRefs][0] },
+      }),
+    ),
+  );
+  assert.equal(failure.code, 'UNKNOWN_OPTION_REF');
+  assert.equal(failure.status, 422);
+
+  world.close();
+});
+
+test('submit scores on the server and discloses the key only in the review', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  // Answer the first six correctly, the next three wrongly, skip the rest.
+  const answers: Record<string, string> = {};
+  paper.questions.forEach((question, index) => {
+    const correct = correctRefFor(world, paper, question.questionId);
+    if (index < 6) {
+      answers[question.questionId] = correct;
+    } else if (index < 9) {
+      const wrong = question.options.find((o) => o.ref !== correct);
+      assert.ok(wrong);
+      answers[question.questionId] = wrong.ref;
+    }
+  });
+
+  world.clock.advance(20 * MINUTE);
+
+  const { result } = await measure(world, user, (ctx) =>
+    submitMock(ctx, {
+      attemptId: paper.attemptId,
+      idempotencyKey: key('submit'),
+      answers,
+    }),
+  );
+  const body = result.body;
+
+  assert.equal(body.timing, 'on_time');
+  assert.equal(body.total, 12);
+  assert.equal(body.correct, 6);
+  assert.equal(body.incorrect, 3);
+  assert.equal(body.skipped, 3);
+  assert.equal(body.score, 6);
+  assert.equal(body.accuracyPct, 50);
+  assert.equal(body.droppedLateAnswers, 0);
+  assert.equal(body.scoredAt, T0 + 20 * MINUTE);
+
+  // The review is the ONLY key disclosure, and it is complete and consistent.
+  assert.equal(body.review.length, 12);
+  for (const item of body.review) {
+    const refs = item.options.map((o) => o.ref);
+    assert.ok(refs.includes(item.correctRef), 'the correct ref must be one of the shown options');
+    assert.equal(
+      item.correctRef,
+      correctRefFor(world, paper, item.questionId),
+      'the server-disclosed key must match the seeded key',
+    );
+    if (item.selectedRef !== null) {
+      assert.equal(item.isCorrect, item.selectedRef === item.correctRef);
+    } else {
+      assert.equal(item.isCorrect, false);
+    }
+  }
+
+  world.close();
+});
+
+test('a submission cannot assert its own score', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  // Every answer deliberately wrong, plus fields a cheater would wish existed.
+  const answers: Record<string, string> = {};
+  for (const question of paper.questions) {
+    const correct = correctRefFor(world, paper, question.questionId);
+    const wrong = question.options.find((o) => o.ref !== correct);
+    assert.ok(wrong);
+    answers[question.questionId] = wrong.ref;
+  }
+
+  const { result } = await measure(world, user, (ctx) =>
+    submitMock(ctx, {
+      attemptId: paper.attemptId,
+      idempotencyKey: key('wrong'),
+      answers,
+      // Note there is no `score`, `isCorrect` or `answeredAt` field in
+      // MockSubmitRequest at all - the schema is strict, so adding one here
+      // would be rejected as an unexpected field rather than ignored.
+    }),
+  );
+
+  assert.equal(result.body.correct, 0);
+  assert.equal(result.body.score, 0);
+  assert.equal(result.body.incorrect, 12);
+
+  world.close();
+});
+
+test('ATTACK: answer a question that is not on this paper', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  const onPaper = new Set(paper.questions.map((q) => q.questionId));
+  const offPaper = world.questions.find((q) => !onPaper.has(q.id));
+  assert.ok(offPaper, 'the seeded bank is larger than one paper');
+
+  const failure = await expectFailure(() =>
+    measure(world, user, (ctx) =>
+      submitMock(ctx, {
+        attemptId: paper.attemptId,
+        idempotencyKey: key('offpaper'),
+        answers: { [offPaper.id]: 'ABCDEFGHJKMN' },
+      }),
+    ),
+  );
+
+  assert.equal(failure.code, 'QUESTION_NOT_ON_PAPER');
+  assert.equal(failure.status, 422);
+
+  world.close();
+});
+
+test('ATTACK: freeze the timer, keep working, submit an hour late', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  // Ten minutes in, the honest client has synced three correct answers.
+  world.clock.advance(10 * MINUTE);
+  const synced: Record<string, string> = {};
+  for (const question of paper.questions.slice(0, 3)) {
+    synced[question.questionId] = correctRefFor(world, paper, question.questionId);
+  }
+
+  const syncResult = await measure(world, user, (ctx) =>
+    syncMock(ctx, { attemptId: paper.attemptId, answers: synced }),
+  );
+  assert.equal(syncResult.result.body.accepted, true);
+
+  // Now the cheater freezes the timer and keeps going for an hour past the
+  // 45-minute deadline, finishing the whole paper correctly.
+  world.clock.advance(100 * MINUTE);
+
+  const everything: Record<string, string> = {};
+  for (const question of paper.questions) {
+    everything[question.questionId] = correctRefFor(world, paper, question.questionId);
+  }
+
+  const { result } = await measure(world, user, (ctx) =>
+    submitMock(ctx, {
+      attemptId: paper.attemptId,
+      idempotencyKey: key('late'),
+      answers: everything,
+    }),
+  );
+  const body = result.body;
+
+  assert.equal(body.timing, 'expired');
+  assert.equal(
+    body.correct,
+    3,
+    'only the three answers the server received before the deadline are scored',
+  );
+  assert.equal(body.droppedLateAnswers, 9);
+  assert.equal(body.scoredAt, paper.expiresAt, 'the paper was frozen at the server deadline');
+
+  world.close();
+});
+
+test('a sync after the deadline cannot overwrite the pre-deadline snapshot', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  const early = { [paper.questions[0].questionId]: paper.questions[0].options[0].ref };
+  world.clock.advance(5 * MINUTE);
+  await measure(world, user, (ctx) =>
+    syncMock(ctx, { attemptId: paper.attemptId, answers: early }),
+  );
+
+  // Past the deadline, try to replace the snapshot with a full paper.
+  world.clock.advance(60 * MINUTE);
+  const late: Record<string, string> = {};
+  for (const question of paper.questions) {
+    late[question.questionId] = correctRefFor(world, paper, question.questionId);
+  }
+
+  const { result } = await measure(world, user, (ctx) =>
+    syncMock(ctx, { attemptId: paper.attemptId, answers: late }),
+  );
+
+  assert.equal(result.body.accepted, false);
+  assert.equal(result.body.reason, 'past_deadline');
+  assert.equal(result.body.remainingMs, 0);
+
+  // The stored snapshot is untouched: resuming shows only the early answer.
+  // Spread before comparing - `parseSyncedAnswers` deliberately returns a
+  // null-prototype map so a stored key like `__proto__` cannot be read back as
+  // an inherited property, and `deepStrictEqual` compares prototypes.
+  const resumed = await measure(world, user, (ctx) => getMockAttempt(ctx, paper.attemptId));
+  assert.deepEqual({ ...resumed.result.body.savedAnswers }, early);
+
+  world.close();
+});
+
+test('the expiry clamp uses SERVER time, not an attempt-supplied deadline', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  // The paper tells the client the deadline, and that value is server-derived.
+  assert.equal(paper.expiresAt, paper.startedAt + 45 * MINUTE);
+  assert.equal(paper.startedAt, T0);
+  assert.equal(paper.serverNow, T0);
+
+  // Resuming reports the server's clock, so a client with a skewed or frozen
+  // clock still renders a truthful countdown.
+  world.clock.advance(44 * MINUTE);
+  const resumed = await measure(world, user, (ctx) => getMockAttempt(ctx, paper.attemptId));
+  assert.equal(resumed.result.body.serverNow, T0 + 44 * MINUTE);
+  assert.equal(resumed.result.body.expiresAt, paper.expiresAt);
+
+  world.close();
+});
+
+test('A ROUND-TRIPPED DEADLINE IS STILL IN THE FUTURE (milliseconds, not seconds)', async () => {
+  // THE REGRESSION THIS GUARDS. `attempts.deadline_at` used to default to
+  // `unixepoch()` -- whole SECONDS -- while every comparison in this Worker is
+  // `Date.now()` milliseconds. Nothing threw: a 45-minute deadline written as
+  // seconds is 45,000 times too small, so every attempt is already expired
+  // when it is created, every submission takes the `expired` branch, and every
+  // candidate is scored on an empty snapshot. The paper below is written to the
+  // database and READ BACK, so this asserts the stored unit and not an
+  // in-memory number.
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const paper = await start(world, user);
+  assert.ok(paper.expiresAt > paper.serverNow, 'a fresh attempt must not be expired');
+  assert.equal(paper.expiresAt - paper.startedAt, 45 * MINUTE);
+  assert.equal(paper.durationSeconds, 45 * 60);
+
+  // Re-read from `attempts`, so the assertion is about what was stored.
+  const resumed = await measure(world, user, (ctx) => getMockAttempt(ctx, paper.attemptId));
+  assert.equal(resumed.result.body.expiresAt, paper.expiresAt);
+  assert.ok(resumed.result.body.expiresAt - resumed.result.body.serverNow > 44 * MINUTE);
+
+  // And the clamp agrees: a sync 44 minutes in is accepted, one a minute later
+  // is not. Under a seconds-based store the first would already be refused.
+  world.clock.advance(44 * MINUTE);
+  const inTime = await measure(world, user, (ctx) =>
+    syncMock(ctx, { attemptId: paper.attemptId, answers: {} }),
+  );
+  assert.equal(inTime.result.body.accepted, true);
+
+  world.clock.advance(2 * MINUTE);
+  const tooLate = await measure(world, user, (ctx) =>
+    syncMock(ctx, { attemptId: paper.attemptId, answers: {} }),
+  );
+  assert.equal(tooLate.result.body.accepted, false);
+  assert.equal(tooLate.result.body.reason, 'past_deadline');
+
+  world.close();
+});
+
+test('the review endpoint refuses an attempt that is still in progress', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  const failure = await expectFailure(() =>
+    measure(world, user, (ctx) => getMockReview(ctx, paper.attemptId)),
+  );
+  assert.equal(failure.code, 'ATTEMPT_NOT_IN_PROGRESS');
+
+  world.close();
+});
+
+test('the review endpoint reproduces a submitted attempt exactly', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+  const paper = await start(world, user);
+
+  const answers: Record<string, string> = {};
+  paper.questions.slice(0, 5).forEach((question) => {
+    answers[question.questionId] = correctRefFor(world, paper, question.questionId);
+  });
+
+  world.clock.advance(MINUTE);
+  const submitted = await measure(world, user, (ctx) =>
+    submitMock(ctx, { attemptId: paper.attemptId, idempotencyKey: key('sub'), answers }),
+  );
+
+  const review = await measure(world, user, (ctx) => getMockReview(ctx, paper.attemptId));
+
+  assert.equal(review.result.body.score, submitted.result.body.score);
+  assert.equal(review.result.body.correct, 5);
+  assert.equal(review.result.body.total, 12);
+  assert.equal(review.result.body.review.length, 12);
+
+  for (const item of review.result.body.review) {
+    assert.equal(item.correctRef, correctRefFor(world, paper, item.questionId));
+  }
+
+  world.close();
+});
diff --git a/worker/src/__tests__/ownership.test.ts b/worker/src/__tests__/ownership.test.ts
new file mode 100644
index 0000000..80c6849
--- /dev/null
+++ b/worker/src/__tests__/ownership.test.ts
@@ -0,0 +1,294 @@
+/**
+ * Ownership, which on D1 is entirely the application's problem.
+ *
+ * There is no row-level security to fall back on, so every one of these tests
+ * is checking that a `WHERE user_id = ?` is actually present in the SQL rather
+ * than a filter applied after the rows came back. A regression here is a data
+ * breach, not a bug.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createWorld, expectFailure, measure } from './harness.ts';
+import { getMockAttempt, getMockReview, startMock, submitMock, syncMock } from '../handlers/mock.ts';
+import {
+  answerPractice,
+  finishPractice,
+  getPracticeSession,
+  startPractice,
+} from '../handlers/practice.ts';
+import { getProgressOverview, putBookmark, getBookmarks } from '../handlers/progress.ts';
+import { getAuditLog, getReportQueue, publishQuestions, triage } from '../handlers/moderation.ts';
+import { requireAdmin, requireUser } from '../handlers/context.ts';
+import { MINUTE } from '../lib/time.ts';
+
+test('a mock attempt is invisible to another user', async () => {
+  const world = createWorld();
+  const alice = world.makeUser();
+  const bob = world.makeUser();
+
+  const start = await measure(world, alice, (ctx) =>
+    startMock(ctx, { templateId: world.templateId, idempotencyKey: 'own-start-aaaaaaaa' }),
+  );
+  const paper = start.result.body;
+
+  // Read.
+  const read = await expectFailure(() =>
+    measure(world, bob, (ctx) => getMockAttempt(ctx, paper.attemptId)),
+  );
+  assert.equal(read.code, 'NOT_FOUND');
+
+  // Sync.
+  const sync = await expectFailure(() =>
+    measure(world, bob, (ctx) => syncMock(ctx, { attemptId: paper.attemptId, answers: {} })),
+  );
+  assert.equal(sync.code, 'NOT_FOUND');
+
+  // Submit.
+  const submit = await expectFailure(() =>
+    measure(world, bob, (ctx) =>
+      submitMock(ctx, {
+        attemptId: paper.attemptId,
+        idempotencyKey: 'own-submit-bbbbbbbb',
+        answers: { [paper.questions[0].questionId]: paper.questions[0].options[0].ref },
+      }),
+    ),
+  );
+  assert.equal(submit.code, 'NOT_FOUND');
+
+  // Review, after Alice submits it.
+  world.clock.advance(MINUTE);
+  await measure(world, alice, (ctx) =>
+    submitMock(ctx, {
+      attemptId: paper.attemptId,
+      idempotencyKey: 'own-submit-cccccccc',
+      answers: {},
+    }),
+  );
+  const review = await expectFailure(() =>
+    measure(world, bob, (ctx) => getMockReview(ctx, paper.attemptId)),
+  );
+  assert.equal(review.code, 'NOT_FOUND');
+
+  // And Alice can still read her own.
+  const mine = await measure(world, alice, (ctx) => getMockReview(ctx, paper.attemptId));
+  assert.equal(mine.result.body.attemptId, paper.attemptId);
+
+  world.close();
+});
+
+test('a practice session is invisible to another user', async () => {
+  const world = createWorld();
+  const alice = world.makeUser();
+  const bob = world.makeUser();
+
+  const start = await measure(world, alice, (ctx) =>
+    startPractice(ctx, {
+      mode: 'chapter',
+      chapterIds: [world.chapterIds[0]],
+      questionCount: 4,
+      idempotencyKey: 'own-pstart-dddddddd',
+    }),
+  );
+  const paper = start.result.body;
+
+  const read = await expectFailure(() =>
+    measure(world, bob, (ctx) => getPracticeSession(ctx, paper.sessionId)),
+  );
+  assert.equal(read.code, 'NOT_FOUND');
+
+  // The answer endpoint is the interesting one: it is the key-disclosure path,
+  // so it must not even confirm that the session exists.
+  const answer = await expectFailure(() =>
+    measure(world, bob, (ctx) =>
+      answerPractice(ctx, {
+        sessionId: paper.sessionId,
+        questionId: paper.questions[0].questionId,
+        optionRef: paper.questions[0].options[0].ref,
+      }),
+    ),
+  );
+  assert.equal(answer.code, 'QUESTION_NOT_ON_PAPER');
+
+  const finish = await expectFailure(() =>
+    measure(world, bob, (ctx) =>
+      finishPractice(ctx, { sessionId: paper.sessionId, idempotencyKey: 'own-pfin-eeeeeeee' }),
+    ),
+  );
+  assert.equal(finish.code, 'NOT_FOUND');
+
+  world.close();
+});
+
+test('ATTACK: farm the practice key reveal through another user\'s session', async () => {
+  const world = createWorld();
+  const alice = world.makeUser();
+  const bob = world.makeUser();
+
+  const start = await measure(world, alice, (ctx) =>
+    startPractice(ctx, {
+      mode: 'chapter',
+      chapterIds: [world.chapterIds[0]],
+      questionCount: 6,
+      idempotencyKey: 'farm-start-ffffffff',
+    }),
+  );
+  const paper = start.result.body;
+
+  // Bob knows Alice's session id and every question id on her paper. Each
+  // attempt must still fail, and fail without disclosing anything.
+  for (const question of paper.questions) {
+    const failure = await expectFailure(() =>
+      measure(world, bob, (ctx) =>
+        answerPractice(ctx, {
+          sessionId: paper.sessionId,
+          questionId: question.questionId,
+          optionRef: null,
+        }),
+      ),
+    );
+    assert.equal(failure.code, 'QUESTION_NOT_ON_PAPER');
+    assert.ok(!failure.message.includes('correct'));
+  }
+
+  world.close();
+});
+
+test('progress and bookmarks are per-user', async () => {
+  const world = createWorld();
+  const alice = world.makeUser();
+  const bob = world.makeUser();
+
+  await measure(world, alice, (ctx) =>
+    putBookmark(ctx, { questionId: world.questions[0].id, desired: true }),
+  );
+  await measure(world, alice, (ctx) =>
+    putBookmark(ctx, { questionId: world.questions[1].id, desired: true }),
+  );
+
+  const aliceList = await measure(world, alice, (ctx) => getBookmarks(ctx));
+  const bobList = await measure(world, bob, (ctx) => getBookmarks(ctx));
+
+  assert.equal(aliceList.result.body.items.length, 2);
+  assert.equal(bobList.result.body.items.length, 0);
+
+  // Alice answers a practice question; Bob's stats stay empty.
+  const session = await measure(world, alice, (ctx) =>
+    startPractice(ctx, {
+      mode: 'chapter',
+      chapterIds: [world.chapterIds[0]],
+      questionCount: 2,
+      idempotencyKey: 'prog-start-gggggggg',
+    }),
+  );
+  const question = session.result.body.questions[0];
+  await measure(world, alice, (ctx) =>
+    answerPractice(ctx, {
+      sessionId: session.result.body.sessionId,
+      questionId: question.questionId,
+      optionRef: question.options[0].ref,
+    }),
+  );
+
+  const aliceProgress = await measure(world, alice, (ctx) => getProgressOverview(ctx));
+  const bobProgress = await measure(world, bob, (ctx) => getProgressOverview(ctx));
+
+  assert.equal(aliceProgress.result.body.stats.totalAnswered, 1);
+  assert.equal(bobProgress.result.body.stats.totalAnswered, 0);
+  assert.equal(aliceProgress.result.body.streak.currentStreak, 1);
+  assert.equal(bobProgress.result.body.streak.currentStreak, 0);
+
+  world.close();
+});
+
+test('requireUser refuses an unauthenticated context', () => {
+  const world = createWorld();
+  const ctx = world.contextFor(world.makeUser());
+  ctx.auth = null;
+
+  assert.throws(() => requireUser(ctx), (err: Error & { code?: string }) => {
+    assert.equal(err.name, 'ApiException');
+    assert.equal(err.code, 'UNAUTHENTICATED');
+    return true;
+  });
+
+  world.close();
+});
+
+test('the admin surface is closed to a plain user and open to a moderator', async () => {
+  const world = createWorld();
+  const user = world.makeUser({ role: 'student' });
+  const moderator = world.makeUser({ role: 'moderator' });
+  const admin = world.makeUser({ role: 'admin' });
+
+  const queue = await expectFailure(() =>
+    measure(world, user, (ctx) => getReportQueue(ctx, { status: 'open', limit: 10 })),
+  );
+  assert.equal(queue.code, 'FORBIDDEN');
+  assert.equal(queue.status, 403);
+
+  const audit = await expectFailure(() =>
+    measure(world, user, (ctx) => getAuditLog(ctx, { limit: 10 })),
+  );
+  assert.equal(audit.code, 'FORBIDDEN');
+
+  const triaged = await expectFailure(() =>
+    measure(world, user, (ctx) =>
+      triage(ctx, {
+        reportIds: ['rep_x'],
+        status: 'accepted',
+        idempotencyKey: 'triage-key-hhhhhhhh',
+      }),
+    ),
+  );
+  assert.equal(triaged.code, 'FORBIDDEN');
+
+  // A moderator may triage.
+  const modQueue = await measure(world, moderator, (ctx) =>
+    getReportQueue(ctx, { status: 'open', limit: 10 }),
+  );
+  assert.equal(modQueue.result.status, 200);
+
+  // But publishing is admin-only, because it changes what candidates sit.
+  const modPublish = await expectFailure(() =>
+    measure(world, moderator, (ctx) =>
+      publishQuestions(ctx, {
+        questionIds: [world.questions[0].id],
+        state: 'retired',
+        idempotencyKey: 'pub-key-iiiiiiii',
+      }),
+    ),
+  );
+  assert.equal(modPublish.code, 'FORBIDDEN');
+
+  const adminPublish = await measure(world, admin, (ctx) =>
+    publishQuestions(ctx, {
+      questionIds: [world.questions[0].id],
+      state: 'retired',
+      idempotencyKey: 'pub-key-jjjjjjjj',
+    }),
+  );
+  assert.equal(adminPublish.result.body.updated, 1);
+
+  // The mutation left an audit row.
+  const log = await measure(world, admin, (ctx) => getAuditLog(ctx, { limit: 10 }));
+  assert.equal(log.result.body.items.length, 1);
+  assert.equal(log.result.body.items[0].action, 'question.set_state');
+  assert.equal(log.result.body.items[0].actorUserId, admin.id);
+
+  world.close();
+});
+
+test('an unrecognised role reads as the least privileged', () => {
+  const world = createWorld();
+  // `toUserRole` normalises anything unexpected to 'student', the least
+  // privileged of the four; this checks the gate itself rather than trusting
+  // that normalisation happened upstream.
+  const ctx = world.contextFor(world.makeUser({ role: 'student' }));
+  assert.throws(() => requireAdmin(ctx), (err: Error & { code?: string }) => {
+    assert.equal(err.code, 'FORBIDDEN');
+    return true;
+  });
+  world.close();
+});
diff --git a/worker/src/__tests__/query-cost.test.ts b/worker/src/__tests__/query-cost.test.ts
new file mode 100644
index 0000000..49717f4
--- /dev/null
+++ b/worker/src/__tests__/query-cost.test.ts
@@ -0,0 +1,187 @@
+/**
+ * D1 query cost.
+ *
+ * The tightest constraint on this platform is 50 queries per Worker invocation
+ * on the free plan. The failure mode it produces is nasty: an N+1 inside a
+ * handler works fine on a 12-question paper in development and breaks on a
+ * 100-question mock in production. So the cost is asserted, not estimated, and
+ * the key assertion is that submitting a 100-question paper costs the SAME
+ * number of queries as submitting a 12-question one.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createWorld, measure } from './harness.ts';
+import { startMock, submitMock, syncMock } from '../handlers/mock.ts';
+import { answerPractice, startPractice } from '../handlers/practice.ts';
+import { bootstrap } from '../handlers/content.ts';
+import { getProgressOverview } from '../handlers/progress.ts';
+import { QueryBudgetExceeded, TooManyBoundParams, Db } from '../data/d1.ts';
+import { MINUTE } from '../lib/time.ts';
+
+/** The free-plan ceiling this whole design is built around. */
+const D1_FREE_QUERY_LIMIT = 50;
+
+async function costOfFullMock(questionsPerChapter: number, quotaPerChapter: number) {
+  const world = createWorld({
+    chapters: 3,
+    questionsPerChapter,
+    quotaPerChapter,
+  });
+  const user = world.makeUser();
+
+  const start = await measure(world, user, (ctx) =>
+    startMock(ctx, { templateId: world.templateId, idempotencyKey: 'cost-start-aaaaaaaa' }),
+  );
+  const paper = start.result.body;
+
+  const answers: Record<string, string> = {};
+  for (const question of paper.questions) {
+    answers[question.questionId] = question.options[0].ref;
+  }
+
+  world.clock.advance(5 * MINUTE);
+  const sync = await measure(world, user, (ctx) =>
+    syncMock(ctx, { attemptId: paper.attemptId, answers }),
+  );
+
+  world.clock.advance(MINUTE);
+  const submit = await measure(world, user, (ctx) =>
+    submitMock(ctx, {
+      attemptId: paper.attemptId,
+      idempotencyKey: 'cost-submit-bbbbbbbb',
+      answers,
+    }),
+  );
+
+  const result = {
+    questionCount: paper.questions.length,
+    start: start.queries,
+    sync: sync.queries,
+    submit: submit.queries,
+    score: submit.result.body.correct,
+    total: submit.result.body.total,
+  };
+  world.close();
+  return result;
+}
+
+test('mock submit costs the same for 100 questions as for 12', async () => {
+  const small = await costOfFullMock(12, 4);
+  const large = await costOfFullMock(40, 34);
+
+  assert.equal(small.questionCount, 12);
+  assert.equal(large.questionCount, 102);
+
+  assert.equal(
+    large.submit,
+    small.submit,
+    `submit cost must be constant in paper size (12q: ${small.submit}, 102q: ${large.submit})`,
+  );
+  assert.equal(
+    large.start,
+    small.start,
+    `start cost must be constant in paper size (12q: ${small.start}, 102q: ${large.start})`,
+  );
+  assert.equal(large.sync, small.sync);
+
+  // And the real numbers, well inside the free-plan ceiling.
+  assert.ok(
+    large.submit < D1_FREE_QUERY_LIMIT,
+    `submit spent ${large.submit} of ${D1_FREE_QUERY_LIMIT}`,
+  );
+  assert.ok(large.start < D1_FREE_QUERY_LIMIT, `start spent ${large.start}`);
+
+  console.log(
+    `  cost: start=${small.start} sync=${small.sync} submit=${small.submit} ` +
+      `(identical at 12 and 102 questions)`,
+  );
+});
+
+test('a 102-question submission scores every question it was given', async () => {
+  // Guards against the cost test passing because the batch silently dropped
+  // rows: the scored total has to equal the paper size.
+  const large = await costOfFullMock(40, 34);
+  assert.equal(large.total, 102);
+});
+
+test('other endpoints stay well inside the free-plan budget', async () => {
+  const world = createWorld();
+  const user = world.makeUser();
+
+  const boot = await measure(world, user, (ctx) => bootstrap(ctx));
+  assert.ok(boot.queries <= 6, `bootstrap spent ${boot.queries}`);
+
+  const practice = await measure(world, user, (ctx) =>
+    startPractice(ctx, {
+      mode: 'chapter',
+      chapterIds: world.chapterIds,
+      questionCount: 50,
+      idempotencyKey: 'cost-p-cccccccc',
+    }),
+  );
+  assert.ok(practice.queries <= 10, `practice/start spent ${practice.queries}`);
+
+  const question = practice.result.body.questions[0];
+  const answer = await measure(world, user, (ctx) =>
+    answerPractice(ctx, {
+      sessionId: practice.result.body.sessionId,
+      questionId: question.questionId,
+      optionRef: question.options[0].ref,
+    }),
+  );
+  assert.ok(answer.queries <= 12, `practice/answer spent ${answer.queries}`);
+
+  const overview = await measure(world, user, (ctx) => getProgressOverview(ctx));
+  assert.ok(overview.queries <= 5, `progress/overview spent ${overview.queries}`);
+
+  console.log(
+    `  cost: bootstrap=${boot.queries} practice.start=${practice.queries} ` +
+      `practice.answer=${answer.queries} progress=${overview.queries}`,
+  );
+
+  world.close();
+});
+
+test('the budget fails the request rather than letting it run away', async () => {
+  const world = createWorld();
+  const db = new Db(world.d1, { budget: 3 });
+
+  await db.all('SELECT 1');
+  await db.all('SELECT 1');
+  await db.all('SELECT 1');
+
+  await assert.rejects(
+    () => db.all('SELECT 1'),
+    (err: unknown) => {
+      assert.ok(err instanceof QueryBudgetExceeded);
+      assert.equal(err.spent, 4);
+      assert.equal(err.budget, 3);
+      return true;
+    },
+  );
+
+  world.close();
+});
+
+test('a statement over D1\'s 100-parameter limit is refused up front', async () => {
+  const world = createWorld();
+  const db = world.invocation();
+
+  const binds = Array.from({ length: 101 }, (_, i) => String(i));
+  const placeholders = binds.map((_, i) => `?${i + 1}`).join(',');
+
+  await assert.rejects(
+    () => db.all(`SELECT 1 WHERE 'x' IN (${placeholders})`, ...binds),
+    (err: unknown) => {
+      assert.ok(err instanceof TooManyBoundParams);
+      // The message points at the fix, because this is a mistake that will be
+      // made again.
+      assert.match(err.message, /json_each/);
+      return true;
+    },
+  );
+
+  world.close();
+});
diff --git a/worker/src/__tests__/scoring.test.ts b/worker/src/__tests__/scoring.test.ts
new file mode 100644
index 0000000..bcb3a2d
--- /dev/null
+++ b/worker/src/__tests__/scoring.test.ts
@@ -0,0 +1,158 @@
+/**
+ * Scoring: the pure function, in isolation.
+ *
+ * These are the cases a browser-side scorer could not get right, because it had
+ * to be handed the key to do its job at all.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { refForOption, resolveOptionRef, scorePaper } from '../domain/scoring.ts';
+import type { KeyEntry, PaperQuestion } from '../domain/scoring.ts';
+
+function paperQuestion(
+  n: number,
+  optionIds: string[],
+  refs: string[],
+): PaperQuestion {
+  return {
+    questionId: `q${n}`,
+    chapterId: 'ch1',
+    position: n,
+    optionOrder: optionIds,
+    optionRefs: refs,
+  };
+}
+
+const paper: PaperQuestion[] = [
+  paperQuestion(1, ['oA', 'oB', 'oC'], ['r1a', 'r1b', 'r1c']),
+  paperQuestion(2, ['oD', 'oE', 'oF'], ['r2a', 'r2b', 'r2c']),
+  paperQuestion(3, ['oG', 'oH', 'oI'], ['r3a', 'r3b', 'r3c']),
+];
+
+const key: KeyEntry[] = [
+  { questionId: 'q1', correctOptionId: 'oB' },
+  { questionId: 'q2', correctOptionId: 'oD' },
+  { questionId: 'q3', correctOptionId: 'oI' },
+];
+
+test('resolveOptionRef maps an opaque ref back to the option it names', () => {
+  assert.equal(resolveOptionRef(paper[0], 'r1b'), 'oB');
+  assert.equal(resolveOptionRef(paper[0], 'r2a'), null, 'a ref from another question must not resolve');
+  assert.equal(resolveOptionRef(paper[0], 'nonsense'), null);
+});
+
+test('refForOption is the inverse, and is what the review payload discloses', () => {
+  assert.equal(refForOption(paper[2], 'oI'), 'r3c');
+  assert.equal(refForOption(paper[2], 'oB'), null);
+});
+
+test('scores a fully correct paper', () => {
+  const result = scorePaper({
+    paper,
+    key,
+    answers: { q1: 'r1b', q2: 'r2a', q3: 'r3c' },
+    options: { strict: true },
+  });
+
+  assert.equal(result.total, 3);
+  assert.equal(result.correct, 3);
+  assert.equal(result.incorrect, 0);
+  assert.equal(result.skipped, 0);
+  assert.equal(result.accuracyPct, 100);
+});
+
+test('scores a mixed paper and counts skips separately from wrong answers', () => {
+  const result = scorePaper({
+    paper,
+    key,
+    // q1 right, q2 wrong, q3 omitted entirely.
+    answers: { q1: 'r1b', q2: 'r2b' },
+    options: { strict: true },
+  });
+
+  assert.equal(result.correct, 1);
+  assert.equal(result.incorrect, 1);
+  assert.equal(result.skipped, 1);
+  assert.equal(result.total, 3);
+  assert.equal(result.accuracyPct, 33);
+
+  // A skipped question still appears in the review, with the key, so the
+  // candidate can learn from what they ran out of time for.
+  const q3 = result.questions.find((q) => q.questionId === 'q3');
+  assert.ok(q3);
+  assert.equal(q3.selectedRef, null);
+  assert.equal(q3.answered, false);
+  assert.equal(q3.correctRef, 'r3c');
+});
+
+test('an answer for a question not on the paper is rejected, never scored', () => {
+  const result = scorePaper({
+    paper,
+    key,
+    answers: { q1: 'r1b', q_not_on_paper: 'whatever' },
+    options: { strict: true },
+  });
+
+  assert.deepEqual(result.rejectedQuestionIds, ['q_not_on_paper']);
+  assert.equal(result.total, 3, 'the paper size is the paper, not the submission');
+  assert.equal(result.correct, 1);
+});
+
+test('a ref harvested from a different attempt does not score', () => {
+  // This is the concrete attack the per-attempt refs defeat: the cheater knows
+  // from a previous attempt's review that the correct body was "choice 2", but
+  // the ref that named it then is meaningless now.
+  const result = scorePaper({
+    paper,
+    key,
+    answers: { q1: 'ref-from-last-week' },
+    options: { strict: true },
+  });
+
+  assert.deepEqual(result.unknownRefQuestionIds, ['q1']);
+  assert.equal(result.correct, 0);
+  assert.equal(result.skipped, 3, 'an unresolvable ref counts as unanswered');
+});
+
+test('a question whose key points off the paper is excluded, not marked wrong', () => {
+  // The authored bank genuinely contains these - see
+  // frontend/src/data/quarantine.json. Marking them wrong would punish the
+  // candidate for a content bug.
+  const result = scorePaper({
+    paper,
+    key: [
+      { questionId: 'q1', correctOptionId: 'oB' },
+      { questionId: 'q2', correctOptionId: 'option-that-does-not-exist' },
+      // q3 has no key row at all.
+    ],
+    answers: { q1: 'r1b', q2: 'r2a', q3: 'r3c' },
+    options: { strict: true },
+  });
+
+  assert.deepEqual(result.unscorableQuestionIds.sort(), ['q2', 'q3']);
+  assert.equal(result.total, 1, 'only the scorable question counts toward the total');
+  assert.equal(result.correct, 1);
+  assert.equal(result.accuracyPct, 100);
+});
+
+test('an empty submission scores zero without dividing by zero', () => {
+  const result = scorePaper({ paper, key, answers: {}, options: { strict: true } });
+  assert.equal(result.correct, 0);
+  assert.equal(result.skipped, 3);
+  assert.equal(result.accuracyPct, 0);
+
+  const empty = scorePaper({ paper: [], key: [], answers: {}, options: { strict: true } });
+  assert.equal(empty.total, 0);
+  assert.equal(empty.accuracyPct, 0);
+});
+
+test('an inherited object property is not mistaken for an answer', () => {
+  // A hostile or buggy client could send a body whose prototype carries a
+  // question id. `hasOwnProperty` is why that reads as unanswered.
+  const hostile = Object.create({ q1: 'r1b' }) as Record<string, string>;
+  const result = scorePaper({ paper, key, answers: hostile, options: { strict: true } });
+  assert.equal(result.correct, 0);
+  assert.equal(result.skipped, 3);
+});
diff --git a/worker/src/__tests__/validation.test.ts b/worker/src/__tests__/validation.test.ts
new file mode 100644
index 0000000..012cf5f
--- /dev/null
+++ b/worker/src/__tests__/validation.test.ts
@@ -0,0 +1,283 @@
+/**
+ * Request validation. The point of these tests is that it FAILS CLOSED.
+ *
+ * A validator that strips unknown fields is worse than useless at this
+ * boundary: validated bodies are passed straight into the data layer, so a
+ * silently-dropped `attemptID` typo reads as a missing required field, and a
+ * silently-KEPT extra field is a way to append columns to a write.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { safeParse } from '../validation/parse.ts';
+import {
+  adminPublishSchema,
+  bookmarkSetSchema,
+  chapterQuestionsQuerySchema,
+  loginSchema,
+  mockStartSchema,
+  mockSubmitSchema,
+  practiceStartSchema,
+  searchQuerySchema,
+  signupSchema,
+  srsReviewSchema,
+  MAX_MOCK_ANSWERS,
+} from '../validation/schemas.ts';
+
+test('an unknown field is an error, not something to strip or keep', () => {
+  const result = safeParse(mockSubmitSchema, {
+    attemptId: 'mat_1',
+    idempotencyKey: 'key-aaaaaaaa',
+    answers: {},
+    // The fields a cheater would wish existed.
+    score: 100,
+    expiresAt: 9_999_999_999_999,
+  });
+
+  assert.equal(result.success, false);
+  if (result.success) return;
+  assert.equal(result.error.issues.score, 'Unexpected field.');
+  assert.equal(result.error.issues.expiresAt, 'Unexpected field.');
+});
+
+test('a submission has nowhere to assert a score, a time, or a correctness bit', () => {
+  // Enumerated explicitly, so adding one of these to the schema later trips
+  // this test and forces the decision to be deliberate.
+  for (const field of ['score', 'isCorrect', 'answeredAt', 'clientNow', 'durationSeconds', 'expiresAt']) {
+    const result = safeParse(mockSubmitSchema, {
+      attemptId: 'mat_1',
+      idempotencyKey: 'key-aaaaaaaa',
+      answers: {},
+      [field]: 1,
+    });
+    assert.equal(result.success, false, `${field} must be rejected`);
+  }
+});
+
+test('a prototype-polluting answers map is rejected', () => {
+  const raw = JSON.parse('{"attemptId":"mat_1","idempotencyKey":"key-aaaaaaaa","answers":{"__proto__":"x"}}') as unknown;
+  const result = safeParse(mockSubmitSchema, raw);
+  assert.equal(result.success, false);
+  if (result.success) return;
+  assert.equal(result.error.issues['answers.__proto__'], 'Reserved key.');
+});
+
+test('the answers map is bounded, so one statement cannot do unbounded work', () => {
+  const answers: Record<string, string> = {};
+  for (let i = 0; i < MAX_MOCK_ANSWERS + 1; i++) answers[`q_${i}`] = 'REF123456789';
+
+  const result = safeParse(mockSubmitSchema, {
+    attemptId: 'mat_1',
+    idempotencyKey: 'key-aaaaaaaa',
+    answers,
+  });
+
+  assert.equal(result.success, false);
+  if (result.success) return;
+  assert.match(result.error.issues.answers, /at most 250 entries/);
+});
+
+test('an answers map of exactly the limit is accepted', () => {
+  const answers: Record<string, string> = {};
+  for (let i = 0; i < MAX_MOCK_ANSWERS; i++) answers[`q_${i}`] = 'REF123456789';
+  const result = safeParse(mockSubmitSchema, {
+    attemptId: 'mat_1',
+    idempotencyKey: 'key-aaaaaaaa',
+    answers,
+  });
+  assert.equal(result.success, true);
+});
+
+test('ids and refs are charset-restricted, because they reach a primary key', () => {
+  for (const bad of ["mat'; DROP TABLE users;--", 'mat 1', 'mat/1', '', 'a'.repeat(65)]) {
+    const result = safeParse(mockStartSchema, {
+      templateId: bad,
+      idempotencyKey: 'key-aaaaaaaa',
+    });
+    assert.equal(result.success, false, `templateId=${JSON.stringify(bad)} must be rejected`);
+  }
+
+  assert.equal(
+    safeParse(mockStartSchema, { templateId: 'tpl_main', idempotencyKey: 'key-aaaaaaaa' }).success,
+    true,
+  );
+});
+
+test('an idempotency key has a minimum length, so it cannot be trivially guessed', () => {
+  assert.equal(
+    safeParse(mockStartSchema, { templateId: 'tpl_main', idempotencyKey: 'short' }).success,
+    false,
+  );
+});
+
+test('numbers are not coerced from strings', () => {
+  const result = safeParse(practiceStartSchema, {
+    mode: 'chapter',
+    chapterIds: ['ch1'],
+    questionCount: '10',
+    idempotencyKey: 'key-aaaaaaaa',
+  });
+  assert.equal(result.success, false);
+  if (result.success) return;
+  assert.equal(result.error.issues.questionCount, 'Expected a finite number.');
+});
+
+test('NaN and Infinity are rejected, not silently stored', () => {
+  for (const value of [Number.NaN, Number.POSITIVE_INFINITY, -Number.POSITIVE_INFINITY]) {
+    const result = safeParse(practiceStartSchema, {
+      mode: 'custom',
+      questionCount: value,
+      idempotencyKey: 'key-aaaaaaaa',
+    });
+    assert.equal(result.success, false);
+  }
+});
+
+test('enums reject anything not on the list', () => {
+  assert.equal(
+    safeParse(practiceStartSchema, {
+      mode: 'free-for-all',
+      questionCount: 5,
+      idempotencyKey: 'key-aaaaaaaa',
+    }).success,
+    false,
+  );
+
+  assert.equal(
+    safeParse(srsReviewSchema, { questionId: 'q1', grade: 'perfect', revision: 0 }).success,
+    false,
+  );
+  assert.equal(
+    safeParse(srsReviewSchema, { questionId: 'q1', grade: 'good', revision: 0 }).success,
+    true,
+  );
+});
+
+test('emails are normalised and obvious non-addresses are refused', () => {
+  const good = safeParse(signupSchema, {
+    email: '  Someone@Example.COM ',
+    password: 'long-enough-password',
+  });
+  assert.equal(good.success, true);
+  if (!good.success) return;
+  assert.equal(good.data.email, 'someone@example.com');
+
+  for (const bad of ['no-at-sign', 'a@b', 'a@@b.com', 'spaces in@x.com', `${'a'.repeat(250)}@x.com`]) {
+    assert.equal(
+      safeParse(signupSchema, { email: bad, password: 'long-enough-password' }).success,
+      false,
+      `${bad} must be rejected`,
+    );
+  }
+});
+
+test('passwords have a floor and a ceiling', () => {
+  assert.equal(
+    safeParse(signupSchema, { email: 'a@b.com', password: 'short' }).success,
+    false,
+  );
+  assert.equal(
+    safeParse(signupSchema, { email: 'a@b.com', password: 'x'.repeat(201) }).success,
+    false,
+    'an unbounded password is a CPU-exhaustion vector against PBKDF2',
+  );
+
+  // Login has no minimum, because rejecting a short password at the schema
+  // would tell an attacker their guess was too short to be anyone's password.
+  assert.equal(
+    safeParse(loginSchema, { email: 'a@b.com', password: 'x' }).success,
+    true,
+  );
+});
+
+test('query defaults are applied, and out-of-range values are refused', () => {
+  const defaults = safeParse(chapterQuestionsQuerySchema, { chapterId: 'ch1' });
+  assert.equal(defaults.success, true);
+  if (!defaults.success) return;
+  assert.equal(defaults.data.offset, 0);
+  assert.equal(defaults.data.limit, 50);
+
+  assert.equal(
+    safeParse(chapterQuestionsQuerySchema, { chapterId: 'ch1', limit: 5000 }).success,
+    false,
+    'an unbounded page size is a bulk-extraction vector',
+  );
+  assert.equal(
+    safeParse(chapterQuestionsQuerySchema, { chapterId: 'ch1', offset: -1 }).success,
+    false,
+  );
+  assert.equal(
+    safeParse(chapterQuestionsQuerySchema, { chapterId: 'ch1', limit: 10.5 }).success,
+    false,
+  );
+});
+
+test('a search query has a minimum length and a maximum length', () => {
+  assert.equal(safeParse(searchQuerySchema, { q: 'a' }).success, false);
+  assert.equal(safeParse(searchQuerySchema, { q: 'ab' }).success, true);
+  assert.equal(safeParse(searchQuerySchema, { q: 'x'.repeat(121) }).success, false);
+});
+
+test('admin batches are bounded and deduplicated', () => {
+  assert.equal(
+    safeParse(adminPublishSchema, {
+      questionIds: ['q1', 'q1'],
+      state: 'retired',
+      idempotencyKey: 'key-aaaaaaaa',
+    }).success,
+    false,
+    'a duplicated id in a batch is a client bug worth surfacing',
+  );
+
+  assert.equal(
+    safeParse(adminPublishSchema, {
+      questionIds: Array.from({ length: 101 }, (_, i) => `q${i}`),
+      state: 'retired',
+      idempotencyKey: 'key-aaaaaaaa',
+    }).success,
+    false,
+  );
+});
+
+test('booleans are not coerced', () => {
+  assert.equal(
+    safeParse(bookmarkSetSchema, { questionId: 'q1', desired: 'true' }).success,
+    false,
+  );
+  assert.equal(
+    safeParse(bookmarkSetSchema, { questionId: 'q1', desired: 1 }).success,
+    false,
+  );
+  assert.equal(
+    safeParse(bookmarkSetSchema, { questionId: 'q1', desired: true }).success,
+    true,
+  );
+});
+
+test('a non-object body is refused with an issue, never an empty error', () => {
+  for (const raw of [null, 'a string', 42, [], true, undefined]) {
+    const result = safeParse(mockStartSchema, raw);
+    assert.equal(result.success, false);
+    if (result.success) continue;
+    assert.ok(Object.keys(result.error.issues).length > 0, 'every failure must carry an issue');
+  }
+});
+
+test('every issue is reported at once, keyed by dotted path', () => {
+  const result = safeParse(practiceStartSchema, {
+    mode: 'nope',
+    questionCount: 0,
+    idempotencyKey: 'x',
+    extra: 1,
+  });
+
+  assert.equal(result.success, false);
+  if (result.success) return;
+  assert.deepEqual(Object.keys(result.error.issues).sort(), [
+    'extra',
+    'idempotencyKey',
+    'mode',
+    'questionCount',
+  ]);
+});
diff --git a/worker/src/data/attempts.ts b/worker/src/data/attempts.ts
new file mode 100644
index 0000000..3ecb620
--- /dev/null
+++ b/worker/src/data/attempts.ts
@@ -0,0 +1,798 @@
+/**
+ * Attempts: one table for every sitting.
+ *
+ * ===========================================================================
+ * ONE TABLE, NOT TWO
+ * ===========================================================================
+ *
+ * This file replaces `data/mock.ts` and `data/practice.ts`, which assumed
+ * `mock_attempts` + `practice_sessions` with parallel question and answer
+ * tables on each side -- six tables for one concept. `attempts` with a `mode`
+ * column is the shape in `migrations/0004_assessment.sql` and it is better for
+ * reasons that showed up immediately: `readAttemptHistory` stops being a
+ * UNION ALL, the rollup triggers exist once instead of twice, and the archival
+ * job has one table to page through instead of two.
+ *
+ * TWO IDS, DELIBERATELY. `attempts.id` is an INTEGER rowid and `public_id` is
+ * the ULID that appears in URLs. The reason is one table down: `attempt_answers`
+ * is the only unbounded table on the platform and every row carries an attempt
+ * reference, so a 26-character ULID there costs 26 bytes against 8 across
+ * millions of rows. Everything above `data/` speaks `public_id`; this file
+ * resolves it to the numeric id ONCE per request and never emits the integer,
+ * which is enumerable.
+ *
+ * THE QUERY COST of every function is in its doc comment, because D1 Free
+ * allows 50 queries per Worker invocation and `submitAttempt` is the endpoint
+ * that would blow that budget if it were written the obvious way. It costs a
+ * fixed 5 statements in one batch whether the paper has 10 questions or 250.
+ */
+
+import { Db, sql } from './d1.ts';
+import type { PendingStatement } from './d1.ts';
+import { T } from './tables.ts';
+import { SUBMIT_GRACE_MS } from '../domain/expiry.ts';
+import type { AnswerMap, SubmissionTiming } from '../domain/expiry.ts';
+import type { AttemptStatus, PracticeMode } from '../shared/types.ts';
+import {
+  attemptGuard,
+  bumpStudySessionStatement,
+  closeStudySessionStatement,
+  createStudySessionStatement,
+  touchStreakStatement,
+  unansweredGuard,
+  upsertSrsFromAnswersStatement,
+} from './progress.ts';
+import type { RollupAnswer } from './progress.ts';
+
+/** The `attempts.mode` CHECK. The database's vocabulary, so it wins. */
+export type AttemptMode = 'practice' | 'mock' | 'srs' | 'bookmark_review' | 'weak_areas';
+
+export interface AttemptRow {
+  /** Internal rowid. NEVER serialised. */
+  id: number;
+  public_id: string;
+  user_id: string;
+  mode: string;
+  template_id: string | null;
+  chapter_id: string | null;
+  status: string;
+  option_seed: number;
+  question_count: number;
+  answered_count: number;
+  correct_count: number;
+  started_at: number;
+  deadline_at: number | null;
+  submitted_at: number | null;
+  elapsed_ms: number | null;
+  synced_answers: string | null;
+  last_sync_at: number | null;
+  /** Joined from `mock_test_templates`, for the history label. */
+  template_name?: string | null;
+}
+
+const ATTEMPT_SELECT = `a.id, a.public_id, a.user_id, a.mode, a.template_id, a.chapter_id,
+                        a.status, a.option_seed, a.question_count, a.answered_count,
+                        a.correct_count, a.started_at, a.deadline_at, a.submitted_at,
+                        a.elapsed_ms, a.synced_answers, a.last_sync_at`;
+
+export function attemptStatus(row: AttemptRow): AttemptStatus {
+  switch (row.status) {
+    case 'in_progress':
+    case 'submitted':
+    case 'expired':
+    case 'abandoned':
+      return row.status;
+    default:
+      // Fail closed: an unrecognised status must not read as in progress.
+      return 'abandoned';
+  }
+}
+
+/**
+ * The wire vocabulary for a practice mode -> the `attempts.mode` CHECK.
+ *
+ * Four vocabularies describe this concept across the repository
+ * (`shared/types.ts`, `attempts.mode`, `responseLog.PRACTICE_MODES`,
+ * `features/quiz/types.ts`). `attempts.mode` is the one with a constraint
+ * behind it, so it is canonical, and this is the ONE place that maps.
+ */
+export function modeForPractice(mode: PracticeMode): AttemptMode {
+  switch (mode) {
+    case 'srs':
+      return 'srs';
+    case 'bookmarks':
+      return 'bookmark_review';
+    case 'wrong':
+      return 'weak_areas';
+    case 'chapter':
+    case 'custom':
+    default:
+      return 'practice';
+  }
+}
+
+/** The reverse map, for reading an attempt back as a practice session. */
+export function practiceModeFor(mode: string): PracticeMode {
+  switch (mode) {
+    case 'srs':
+      return 'srs';
+    case 'bookmark_review':
+      return 'bookmarks';
+    case 'weak_areas':
+      return 'wrong';
+    default:
+      return 'custom';
+  }
+}
+
+/**
+ * Derived, not stored. An attempt submitted inside the grace window was scored
+ * from its payload; one submitted after it was scored from the pre-deadline
+ * snapshot. `attempts` keeps `submitted_at` and `deadline_at`, so a `timing`
+ * column would be a third copy of a fact those two already determine -- and
+ * the kind of column that goes stale when the grace window changes.
+ */
+export function attemptTiming(row: AttemptRow): SubmissionTiming {
+  if (row.deadline_at === null || row.submitted_at === null) return 'on_time';
+  return row.submitted_at > row.deadline_at + SUBMIT_GRACE_MS ? 'expired' : 'on_time';
+}
+
+/** `min(submittedAt, deadlineAt)` -- the instant the paper was frozen. */
+export function attemptScoredAt(row: AttemptRow): number {
+  const submitted = row.submitted_at ?? row.started_at;
+  return row.deadline_at === null ? submitted : Math.min(submitted, row.deadline_at);
+}
+
+/** Server-authored duration, recovered from the two timestamps. */
+export function attemptDurationSeconds(row: AttemptRow): number {
+  if (row.deadline_at === null) return 0;
+  return Math.max(0, Math.round((row.deadline_at - row.started_at) / 1000));
+}
+
+/** Parses the stored snapshot. A corrupt blob reads as "no snapshot". */
+export function parseSyncedAnswers(row: AttemptRow): AnswerMap | null {
+  if (!row.synced_answers) return null;
+  try {
+    const parsed = JSON.parse(row.synced_answers) as unknown;
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return null;
+    const out: Record<string, string> = Object.create(null) as Record<string, string>;
+    for (const [key, value] of Object.entries(parsed as Record<string, unknown>)) {
+      if (typeof value === 'string') out[key] = value;
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+
+/** A pick as the paper writer receives it, with its stored option order. */
+export interface PaperRowInput {
+  questionId: string;
+  position: number;
+  optionOrder: readonly string[];
+}
+
+/**
+ * Creates the attempt, its paper and its study session. 3 statements, 1 batch,
+ * 1 round trip.
+ *
+ * THE PAPER ROWS ARE ONE STATEMENT. A hundred questions means a hundred rows,
+ * and a hundred separate INSERTs would exceed D1's 50-queries-per-invocation
+ * limit before the handler got to the response. A multi-row VALUES list would
+ * exceed the 100-bound-parameter limit at four columns per row. So the whole
+ * paper travels as a single JSON parameter and is expanded by `json_each`,
+ * which keeps the cost at one statement and one parameter for any paper size.
+ *
+ * `option_order` is pre-stringified by the caller rather than nested as a real
+ * JSON array, so the statement never relies on `json_extract` returning a text
+ * representation for a nested array.
+ *
+ * The paper insert resolves the attempt's numeric id with a subselect on
+ * `public_id`, which is what lets all three statements share one batch.
+ */
+export function createAttemptBatch(args: {
+  publicId: string;
+  userId: string;
+  mode: AttemptMode;
+  templateId: string | null;
+  chapterId: string | null;
+  optionSeed: number;
+  startedAt: number;
+  /** `null` for an untimed practice session. */
+  deadlineAt: number | null;
+  paper: readonly PaperRowInput[];
+}): PendingStatement[] {
+  const rows = args.paper.map((q) => ({
+    qid: q.questionId,
+    pos: q.position,
+    ord: JSON.stringify(q.optionOrder),
+  }));
+
+  return [
+    sql(
+      `INSERT INTO ${T.attempts}
+         (public_id, user_id, mode, template_id, chapter_id, status, option_seed,
+          question_count, answered_count, correct_count, started_at, deadline_at,
+          submitted_at, elapsed_ms, synced_answers, last_sync_at, client_meta)
+       VALUES (?1, ?2, ?3, ?4, ?5, 'in_progress', ?6, ?7, 0, 0, ?8, ?9,
+               NULL, NULL, NULL, NULL, NULL)`,
+      args.publicId,
+      args.userId,
+      args.mode,
+      args.templateId,
+      args.chapterId,
+      args.optionSeed,
+      args.paper.length,
+      args.startedAt,
+      args.deadlineAt,
+    ),
+    sql(
+      `INSERT INTO ${T.attemptQuestions}
+         (attempt_id, position, question_id, option_order)
+       SELECT (SELECT id FROM ${T.attempts} WHERE public_id = ?2),
+              json_extract(j.value, '$.pos'),
+              json_extract(j.value, '$.qid'),
+              json_extract(j.value, '$.ord')
+         FROM json_each(?1) j`,
+      JSON.stringify(rows),
+      args.publicId,
+    ),
+    createStudySessionStatement({
+      userId: args.userId,
+      attemptPublicId: args.publicId,
+      mode: args.mode,
+      chapterId: args.chapterId,
+      now: args.startedAt,
+    }),
+  ];
+}
+
+/**
+ * Loads an attempt by its PUBLIC id, scoped to its owner. 1 query.
+ *
+ * `user_id = ?2` is in the WHERE clause, not checked afterwards, so there is no
+ * version of this function that can return another user's attempt. Every
+ * handler that touches an attempt starts here.
+ */
+export async function loadAttempt(
+  db: Db,
+  publicId: string,
+  userId: string,
+): Promise<AttemptRow | null> {
+  return await db.first<AttemptRow>(
+    `SELECT ${ATTEMPT_SELECT}
+       FROM ${T.attempts} a
+      WHERE a.public_id = ?1 AND a.user_id = ?2`,
+    publicId,
+    userId,
+  );
+}
+
+/** One delivered question, as stored. Refs are derived, not stored. */
+export interface StoredPaperRow {
+  questionId: string;
+  chapterId: string;
+  position: number;
+  optionOrder: string[];
+  stem: string;
+  explanation: string | null;
+}
+
+/**
+ * NQ-23b render-paper. The paper with stems, scoped to its owner. 1 query.
+ *
+ * Joins `attempts` purely to carry the `user_id` predicate, so a caller cannot
+ * read a paper by guessing an attempt id. Does NOT join `question_options` --
+ * option bodies come from `loadOptionsForQuestions`, over a table with no
+ * answer column -- and does not join `question_answer_keys`, which it could not
+ * reach without naming it.
+ *
+ * `chapter_id` comes from `questions` rather than from a denormalised column on
+ * `attempt_questions`: one join against a primary key, against four bytes per
+ * row on the second-largest table.
+ */
+export async function loadPaper(
+  db: Db,
+  publicId: string,
+  userId: string,
+): Promise<StoredPaperRow[]> {
+  const rows = await db.all<{
+    question_id: string;
+    chapter_id: string;
+    position: number;
+    option_order: string;
+    stem: string;
+    explanation: string | null;
+  }>(
+    `SELECT aq.question_id, q.chapter_id, aq.position, aq.option_order, q.stem,
+            (SELECT e.body FROM ${T.explanations} e
+              WHERE e.question_id = q.id AND e.status = 'published'
+              ORDER BY e.is_primary DESC, e.id LIMIT 1) AS explanation
+       FROM ${T.attemptQuestions} aq
+       JOIN ${T.attempts} a ON a.id = aq.attempt_id
+       JOIN ${T.questions} q ON q.id = aq.question_id
+      WHERE a.public_id = ?1 AND a.user_id = ?2
+      ORDER BY aq.position`,
+    publicId,
+    userId,
+  );
+
+  return rows.map((r) => ({
+    questionId: r.question_id,
+    chapterId: r.chapter_id,
+    position: r.position,
+    optionOrder: parseStringArray(r.option_order),
+    stem: r.stem,
+    explanation: r.explanation,
+  }));
+}
+
+function parseStringArray(raw: string): string[] {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return Array.isArray(parsed) ? parsed.filter((x): x is string => typeof x === 'string') : [];
+  } catch {
+    return [];
+  }
+}
+
+/** ONE stored question of a paper, for the practice reveal. */
+export interface PaperQuestionRow extends StoredPaperRow {
+  attemptId: number;
+  optionSeed: number;
+  attemptStatus: string;
+}
+
+/**
+ * ONE question of the paper, with its key. 1 query.
+ *
+ * This is the practice reveal, and it is the narrowest key disclosure in the
+ * API: a single question id, scoped to an attempt the caller owns. There is no
+ * variant that takes a list. The correlated subquery over
+ * `question_answer_keys` is the one place outside `loadAnswerKey` that reaches
+ * the key table, and it is bounded to exactly one question by the outer
+ * predicate.
+ */
+export async function loadPaperQuestionWithKey(
+  db: Db,
+  args: { publicId: string; userId: string; questionId: string },
+): Promise<{ row: PaperQuestionRow; correctOptionId: string | null } | null> {
+  const row = await db.first<{
+    attempt_id: number;
+    option_seed: number;
+    attempt_status: string;
+    question_id: string;
+    chapter_id: string;
+    position: number;
+    option_order: string;
+    stem: string;
+    explanation: string | null;
+    correct_option_id: string | null;
+  }>(
+    `SELECT a.id AS attempt_id, a.option_seed, a.status AS attempt_status,
+            aq.question_id, q.chapter_id, aq.position, aq.option_order, q.stem,
+            (SELECT e.body FROM ${T.explanations} e
+              WHERE e.question_id = q.id AND e.status = 'published'
+              ORDER BY e.is_primary DESC, e.id LIMIT 1) AS explanation,
+            (SELECT k.correct_option_id FROM ${T.questionAnswerKeys} k
+              WHERE k.question_id = aq.question_id) AS correct_option_id
+       FROM ${T.attemptQuestions} aq
+       JOIN ${T.attempts} a ON a.id = aq.attempt_id
+       JOIN ${T.questions} q ON q.id = aq.question_id
+      WHERE a.public_id = ?1 AND a.user_id = ?2 AND aq.question_id = ?3`,
+    args.publicId,
+    args.userId,
+    args.questionId,
+  );
+
+  if (!row) return null;
+
+  return {
+    row: {
+      attemptId: row.attempt_id,
+      optionSeed: row.option_seed,
+      attemptStatus: row.attempt_status,
+      questionId: row.question_id,
+      chapterId: row.chapter_id,
+      position: row.position,
+      optionOrder: parseStringArray(row.option_order),
+      stem: row.stem,
+      explanation: row.explanation,
+    },
+    correctOptionId: row.correct_option_id,
+  };
+}
+
+/**
+ * Stores an answer snapshot. 1 query.
+ *
+ * THE CLAMP LIVES IN THIS WHERE CLAUSE. `?4 <= deadline_at` uses the server's
+ * clock against the deadline the server wrote at start, so the stored snapshot
+ * is by construction a state that existed before the deadline. A client that
+ * keeps working past the buzzer can keep calling this endpoint; the UPDATE
+ * matches zero rows and the stored snapshot does not move. The same property is
+ * ALSO a CHECK on the table (`last_sync_at <= deadline_at`), so a future
+ * handler that forgets this predicate fails the write rather than quietly
+ * accepting post-deadline work.
+ *
+ * The map REPLACES the previous snapshot rather than merging into it, which is
+ * what makes the endpoint idempotent and safe for the offline outbox to replay
+ * out of order within a window - the last write to arrive before the deadline
+ * wins, and that is the honest answer.
+ */
+export async function syncAnswers(
+  db: Db,
+  args: {
+    publicId: string;
+    userId: string;
+    answers: AnswerMap;
+    now: number;
+  },
+): Promise<boolean> {
+  const meta = await db.run(
+    `UPDATE ${T.attempts}
+        SET synced_answers = ?3, last_sync_at = ?4
+      WHERE public_id = ?1 AND user_id = ?2
+        AND status = 'in_progress'
+        AND deadline_at IS NOT NULL
+        AND ?4 <= deadline_at`,
+    args.publicId,
+    args.userId,
+    JSON.stringify(args.answers),
+    args.now,
+  );
+  return meta.changes === 1;
+}
+
+/** One scored answer row, as written to `attempt_answers`. */
+export interface SubmissionAnswer extends RollupAnswer {
+  selectedOptionId: string | null;
+  /** 1-based screen position under this attempt's permutation. Analytics only. */
+  deliveredPosition: number | null;
+}
+
+export interface SubmitArgs {
+  attemptId: number;
+  publicId: string;
+  userId: string;
+  answers: readonly SubmissionAnswer[];
+  submittedAt: number;
+  scoredAt: number;
+  elapsedMs: number;
+}
+
+/** `question_options.opt_key` out of a full option id. */
+export function optKeyOf(optionId: string): string | null {
+  const hash = optionId.indexOf('#');
+  return hash < 0 ? null : optionId.slice(hash + 1);
+}
+
+/**
+ * Commits a submission. 5 statements, ONE batch, ONE round trip.
+ *
+ * Returns `applied: false` when the attempt was no longer in progress, in which
+ * case nothing at all was written and the caller should replay the stored
+ * result instead of scoring again.
+ *
+ * ORDERING IS LOAD-BEARING. Each of the first four statements carries
+ * `WHERE EXISTS (... status = 'in_progress')` and the status flip runs LAST, so
+ * a duplicate submission arriving after the first one committed finds the guard
+ * false, writes nothing, and reports zero changes on the final UPDATE. That is
+ * what makes the endpoint safe without a transaction, which D1 does not offer.
+ *
+ * NOTE WHAT IS NOT HERE. There is no statement updating `attempts.correct_count`
+ * or `user_question_stats`: the triggers in 0005 do both, inside the answer
+ * INSERT, and so cost nothing against the 50-query budget. Three statements
+ * that used to be in this batch are gone with them, and the rollup can no
+ * longer drift from the answer log because nothing can write one without the
+ * other.
+ */
+export async function submitAttempt(
+  db: Db,
+  args: SubmitArgs,
+): Promise<{ applied: boolean }> {
+  const guard = attemptGuard(args.attemptId, args.userId);
+  const answered = args.answers.filter((a) => a.answered);
+  const correct = answered.filter((a) => a.isCorrect).length;
+
+  const answerRows = answered.map((a) => ({
+    q: a.questionId,
+    o: a.selectedOptionId === null ? null : optKeyOf(a.selectedOptionId),
+    k: a.isCorrect ? 1 : 0,
+    p: a.deliveredPosition,
+  }));
+
+  const statements: PendingStatement[] = [
+    // 1. The answers. ONE statement for the whole paper, and the triggers on
+    //    this INSERT are what maintain every counter below it.
+    sql(
+      `INSERT INTO ${T.attemptAnswers}
+         (attempt_id, question_id, selected_opt_key, is_correct,
+          delivered_position, time_ms, revised, answered_at)
+       SELECT ?2,
+              json_extract(j.value, '$.q'),
+              json_extract(j.value, '$.o'),
+              json_extract(j.value, '$.k'),
+              json_extract(j.value, '$.p'),
+              NULL, 0, ?3
+         FROM json_each(?1) j
+        WHERE ${guard.fragment(4)}
+       ON CONFLICT (attempt_id, question_id) DO NOTHING`,
+      JSON.stringify(answerRows),
+      args.attemptId,
+      args.scoredAt,
+      ...guard.binds,
+    ),
+
+    // 2. The revision schedule.
+    upsertSrsFromAnswersStatement({
+      userId: args.userId,
+      answers: args.answers,
+      now: args.scoredAt,
+      guard,
+    }),
+
+    // 3. The streak, in the candidate's own calendar day.
+    touchStreakStatement({ userId: args.userId, now: args.scoredAt, guard }),
+
+    // 4. Close the wall-clock session.
+    closeStudySessionStatement({
+      userId: args.userId,
+      attemptId: args.attemptId,
+      answered: answered.length,
+      correct,
+      now: args.submittedAt,
+    }),
+
+    // 5. The status flip. LAST, and the only statement whose `changes` matters.
+    sql(
+      `UPDATE ${T.attempts}
+          SET status = 'submitted', submitted_at = ?3, elapsed_ms = ?4
+        WHERE id = ?1 AND user_id = ?2 AND status = 'in_progress'`,
+      args.attemptId,
+      args.userId,
+      args.submittedAt,
+      args.elapsedMs,
+    ),
+  ];
+
+  const results = await db.batch(statements);
+  const flip = results[results.length - 1];
+  return { applied: (flip?.meta.changes ?? 0) === 1 };
+}
+
+/**
+ * NQ-24 attempt-answers-load. The answers already recorded. 1 query.
+ *
+ * `selected_option_id` is the VIRTUAL generated column -- zero bytes on disk,
+ * and the reason this read does not have to re-concatenate an id the database
+ * can express itself.
+ */
+export async function loadRecordedAnswers(
+  db: Db,
+  publicId: string,
+  userId: string,
+): Promise<Map<string, { optionId: string | null; isCorrect: boolean }>> {
+  const rows = await db.all<{
+    question_id: string;
+    selected_option_id: string | null;
+    is_correct: number;
+  }>(
+    `SELECT aa.question_id, aa.selected_option_id, aa.is_correct
+       FROM ${T.attemptAnswers} aa
+       JOIN ${T.attempts} a ON a.id = aa.attempt_id
+      WHERE a.public_id = ?1 AND a.user_id = ?2`,
+    publicId,
+    userId,
+  );
+
+  const out = new Map<string, { optionId: string | null; isCorrect: boolean }>();
+  for (const row of rows) {
+    out.set(row.question_id, {
+      optionId: row.selected_option_id,
+      isCorrect: row.is_correct === 1,
+    });
+  }
+  return out;
+}
+
+/** NQ-20 resume-attempt. The caller's most recent live attempt. 1 query. */
+export async function findResumableAttempt(
+  db: Db,
+  userId: string,
+  now: number,
+): Promise<AttemptRow | null> {
+  return await db.first<AttemptRow>(
+    `SELECT ${ATTEMPT_SELECT}
+       FROM ${T.attempts} a
+      WHERE a.user_id = ?1 AND a.status = 'in_progress'
+        AND (a.deadline_at IS NULL OR a.deadline_at > ?2)
+      ORDER BY a.started_at DESC LIMIT 1`,
+    userId,
+    now,
+  );
+}
+
+/**
+ * NQ-22 attempt-history. 1 query, newest first, cursor-paged.
+ *
+ * ONE table, so no UNION ALL -- which is the clearest single payoff of
+ * unifying mock and practice attempts. `correct_count` is the
+ * trigger-maintained score, so this read works unchanged after archival has
+ * deleted the raw answers the score was computed from.
+ */
+export async function readAttemptHistory(
+  db: Db,
+  args: { userId: string; limit: number; beforeStartedAt: number | null },
+): Promise<
+  Array<{
+    kind: 'mock' | 'practice';
+    id: string;
+    label: string;
+    score: number;
+    total: number;
+    at: number;
+    status: string;
+  }>
+> {
+  const rows = await db.all<{
+    mode: string;
+    public_id: string;
+    label: string;
+    score: number;
+    total: number;
+    at: number;
+    status: string;
+  }>(
+    `SELECT a.mode, a.public_id,
+            COALESCE(t.name, a.mode) AS label,
+            a.correct_count AS score, a.question_count AS total,
+            a.started_at AS at, a.status
+       FROM ${T.attempts} a
+       LEFT JOIN ${T.mockTestTemplates} t ON t.id = a.template_id
+      WHERE a.user_id = ?1 AND a.started_at < ?2
+      ORDER BY a.started_at DESC
+      LIMIT ?3`,
+    args.userId,
+    args.beforeStartedAt ?? Number.MAX_SAFE_INTEGER,
+    args.limit,
+  );
+
+  return rows.map((r) => ({
+    kind: r.mode === 'mock' ? 'mock' : 'practice',
+    id: r.public_id,
+    label: r.label,
+    score: r.score,
+    total: r.total,
+    at: r.at,
+    status: r.status,
+  }));
+}
+
+/**
+ * Commits one practice answer. 4 statements, ONE batch, ONE round trip.
+ *
+ * Returns `applied: false` if the question was already answered in this
+ * attempt, in which case nothing was written. That makes the endpoint
+ * idempotent on `(attemptId, questionId)` WITHOUT an idempotency key, which is
+ * exactly what the offline outbox wants: replaying a queued answer converges
+ * instead of inflating the user's stats.
+ *
+ * The answer INSERT runs LAST and its `changes` is the decision, for the same
+ * ordering reason as `submitAttempt` -- and because the trigger on that INSERT
+ * is what moves `attempts.answered_count` and `user_question_stats`, so the
+ * counters the handler reads back afterwards are already correct.
+ *
+ * A SKIP (`selectedOptionId === null`) is recorded as a row with a NULL
+ * `selected_opt_key`, which is an exposure but not an attempt: it must not
+ * count toward accuracy, must not feed the revision schedule, and must not
+ * touch the streak. Doing a paper by pressing skip fifty times is not a day's
+ * study.
+ */
+export async function commitPracticeAnswer(
+  db: Db,
+  args: {
+    attemptId: number;
+    userId: string;
+    questionId: string;
+    chapterId: string;
+    selectedOptionId: string | null;
+    isCorrect: boolean;
+    deliveredPosition: number | null;
+    now: number;
+    /** Telemetry. Influences the revision schedule only, never the score. */
+    latencyMs?: number;
+    flaggedGuess?: boolean;
+  },
+): Promise<{ applied: boolean }> {
+  const guard = unansweredGuard(args.attemptId, args.questionId);
+  const answered = args.selectedOptionId !== null;
+
+  const rollup: RollupAnswer[] = [
+    {
+      questionId: args.questionId,
+      chapterId: args.chapterId,
+      isCorrect: args.isCorrect,
+      answered,
+    },
+  ];
+
+  const statements: PendingStatement[] = [];
+
+  if (answered) {
+    statements.push(
+      upsertSrsFromAnswersStatement({
+        userId: args.userId,
+        answers: rollup,
+        now: args.now,
+        guard,
+      }),
+      touchStreakStatement({ userId: args.userId, now: args.now, guard }),
+      bumpStudySessionStatement({
+        userId: args.userId,
+        attemptId: args.attemptId,
+        isCorrect: args.isCorrect,
+        guard,
+      }),
+    );
+  }
+
+  statements.push(
+    sql(
+      `INSERT INTO ${T.attemptAnswers}
+         (attempt_id, question_id, selected_opt_key, is_correct,
+          delivered_position, time_ms, revised, answered_at)
+       SELECT ?1, ?2, ?3, ?4, ?5, ?6, ?9, ?7
+        WHERE EXISTS (SELECT 1 FROM ${T.attempts}
+                       WHERE id = ?1 AND user_id = ?8 AND status = 'in_progress')
+       ON CONFLICT (attempt_id, question_id) DO NOTHING`,
+      args.attemptId,
+      args.questionId,
+      args.selectedOptionId === null ? null : optKeyOf(args.selectedOptionId),
+      args.isCorrect ? 1 : 0,
+      args.deliveredPosition,
+      args.latencyMs ?? null,
+      args.now,
+      args.userId,
+      // `revised` is the "changed their mind" flag. A first answer has not.
+      // The flagged-guess telemetry rides here rather than in a column of its
+      // own, because this table may not grow one: it is the only unbounded
+      // table on the platform and a flag is a bit, not a row.
+      args.flaggedGuess === true ? 1 : 0,
+    ),
+  );
+
+  const results = await db.batch(statements);
+  const insert = results[results.length - 1];
+  return { applied: (insert?.meta.changes ?? 0) === 1 };
+}
+
+/**
+ * Finishes an untimed attempt. 2 statements, ONE batch.
+ *
+ * Idempotent: finishing a finished attempt changes nothing and reports false.
+ */
+export async function finishAttempt(
+  db: Db,
+  args: { attemptId: number; userId: string; answered: number; correct: number; now: number },
+): Promise<boolean> {
+  const results = await db.batch([
+    sql(
+      `UPDATE ${T.attempts}
+          SET status = 'submitted', submitted_at = ?3,
+              elapsed_ms = ?3 - started_at
+        WHERE id = ?1 AND user_id = ?2 AND status = 'in_progress'`,
+      args.attemptId,
+      args.userId,
+      args.now,
+    ),
+    closeStudySessionStatement({
+      userId: args.userId,
+      attemptId: args.attemptId,
+      answered: args.answered,
+      correct: args.correct,
+      now: args.now,
+    }),
+  ]);
+  return (results[0]?.meta.changes ?? 0) === 1;
+}
diff --git a/worker/src/data/auth.ts b/worker/src/data/auth.ts
new file mode 100644
index 0000000..72eaeea
--- /dev/null
+++ b/worker/src/data/auth.ts
@@ -0,0 +1,591 @@
+/**
+ * Identity: users, profiles, sessions, OAuth links.
+ *
+ * Self-hosted because D1 has no managed auth. Three identity shapes share one
+ * `users` row:
+ *
+ *   anonymous guest   is_anonymous = 1, email NULL,     password_hash NULL
+ *   email + password  is_anonymous = 0, email set,      password_hash set
+ *   Google            is_anonymous = 0, email set,      password_hash may be NULL
+ *
+ * An upgrade mutates the row in place, so the user id NEVER changes and every
+ * attempt, bookmark and SRS card written while the user was a guest stays
+ * attached. That is the whole reason guests get a real row instead of a
+ * client-side identity.
+ *
+ * TWO TABLES PER USER, not one. `users` holds the credential; `user_profiles`
+ * holds `display_name` and everything else another user may see. D1 has no
+ * column-level grants, so "don't leak password_hash" cannot be a database rule
+ * -- it can only be a property of the query, and splitting the table makes the
+ * safe query the short one. The cost is that creating a user is two statements
+ * in one batch; the second is guarded by `WHERE EXISTS (the user)` so a
+ * rejected signup leaves no orphan profile.
+ *
+ * SESSIONS ARE STORED HASHED. `sessions.id` is the SHA-256 hex of the cookie
+ * value, never the cookie value itself, so a dump of this table does not let
+ * anyone sign in. Lookup is still a primary-key hit because the Worker hashes
+ * before it queries. Two clocks: `expires_at` is the idle window the Worker
+ * slides forward, `absolute_expires_at` is the ceiling sliding cannot pass, so
+ * a stolen cookie cannot be renewed indefinitely.
+ */
+
+import { Db, sql } from './d1.ts';
+import type { PendingStatement } from './d1.ts';
+import { T } from './tables.ts';
+import { newId, newSecretId } from '../lib/ids.ts';
+import { sha256Hex } from '../lib/password.ts';
+import { DAY, MINUTE } from '../lib/time.ts';
+import type { SessionUser, UserRole } from '../shared/types.ts';
+
+/** Idle window. Slid forward on use, never past the absolute ceiling. */
+export const SESSION_IDLE_TTL_MS = 14 * DAY;
+/** Hard ceiling. A session older than this must be re-established. */
+export const SESSION_ABSOLUTE_TTL_MS = 90 * DAY;
+export const OAUTH_STATE_TTL_MS = 10 * MINUTE;
+/** A session is only re-stamped once an hour, to avoid a write per request. */
+export const SESSION_TOUCH_INTERVAL_MS = 60 * MINUTE;
+
+export const PASSWORD_ALGO = 'pbkdf2-sha256';
+
+/** `users` joined to the display half of `user_profiles`. */
+export interface UserRow {
+  id: string;
+  email: string | null;
+  email_verified_at: number | null;
+  password_hash: string | null;
+  role: string;
+  status: string;
+  is_anonymous: number;
+  created_at: number;
+  updated_at: number;
+  display_name: string | null;
+}
+
+const USER_SELECT = `u.id, u.email, u.email_verified_at, u.password_hash, u.role,
+                     u.status, u.is_anonymous, u.created_at, u.updated_at,
+                     p.display_name`;
+
+/**
+ * Fails closed on an unrecognised role. An unexpected value must read as the
+ * LEAST privileged, never as admin, so a typo in a migration or a hand-edited
+ * row cannot grant the admin surface.
+ */
+export function toUserRole(raw: string): UserRole {
+  switch (raw) {
+    case 'admin':
+    case 'moderator':
+    case 'contributor':
+      return raw;
+    default:
+      return 'student';
+  }
+}
+
+export function toSessionUser(row: UserRow): SessionUser {
+  return {
+    id: row.id,
+    email: row.email,
+    displayName: row.display_name,
+    role: toUserRole(row.role),
+    isAnonymous: row.is_anonymous === 1,
+    hasPassword: row.password_hash !== null,
+    createdAt: row.created_at,
+  };
+}
+
+// --- Users ------------------------------------------------------------------
+
+/**
+ * 1 query. Matches on the GENERATED `email_normalized` column, not on `email`,
+ * so a login with different casing or stray whitespace resolves to the one
+ * account rather than to nothing.
+ */
+export async function findUserByEmail(db: Db, email: string): Promise<UserRow | null> {
+  return await db.first<UserRow>(
+    `SELECT ${USER_SELECT}
+       FROM ${T.users} u
+       LEFT JOIN ${T.userProfiles} p ON p.user_id = u.id
+      WHERE u.email_normalized = lower(trim(?1)) AND u.status = 'active'`,
+    email,
+  );
+}
+
+/** 1 query. */
+export async function getUserById(db: Db, userId: string): Promise<UserRow | null> {
+  return await db.first<UserRow>(
+    `SELECT ${USER_SELECT}
+       FROM ${T.users} u
+       LEFT JOIN ${T.userProfiles} p ON p.user_id = u.id
+      WHERE u.id = ?1`,
+    userId,
+  );
+}
+
+export interface CreateUserArgs {
+  email: string | null;
+  passwordHash: string | null;
+  displayName: string | null;
+  isAnonymous: boolean;
+  emailVerified?: boolean;
+  now: number;
+}
+
+/** What a guest's profile is called until they say otherwise. */
+export const GUEST_DISPLAY_NAME = 'Guest';
+
+/**
+ * Creates a user and its profile. 2 statements, ONE batch.
+ *
+ * Returns `null` when the email is already claimed, which is detected by the
+ * partial unique index rather than by a preceding SELECT: a read-then-write
+ * would race two concurrent signups for the same address into two rows.
+ *
+ * The profile insert carries `WHERE EXISTS (the user)` rather than relying on
+ * the batch being atomic, because a foreign-key violation would throw and the
+ * caller could not then distinguish "email taken" from "something broke".
+ */
+export async function createUser(db: Db, args: CreateUserArgs): Promise<UserRow | null> {
+  const id = newId('usr');
+  const displayName = args.displayName ?? (args.isAnonymous ? GUEST_DISPLAY_NAME : null);
+  // `user_profiles.display_name` is NOT NULL, and a nameless signup is a real
+  // case (email + password with no display name). The local part of the address
+  // is a better placeholder than an empty string.
+  const profileName =
+    displayName ?? (args.email !== null ? args.email.split('@')[0] : GUEST_DISPLAY_NAME);
+
+  const results = await db.batch([
+    // The conflict target repeats the index predicate on purpose. The unique
+    // index on `email_normalized` is PARTIAL -- anonymous guests all carry a
+    // NULL email -- and SQLite only matches a partial index when the upsert
+    // restates its WHERE clause. A bare `ON CONFLICT (email_normalized)`
+    // raises "does not match any PRIMARY KEY or UNIQUE constraint" at runtime,
+    // on every signup.
+    //
+    // The target is named rather than left bare so that an id collision, which
+    // would be a genuine bug, still throws instead of being quietly reported
+    // to the caller as a taken email address.
+    sql(
+      `INSERT INTO ${T.users}
+         (id, email, email_verified_at, password_hash, password_algo, role,
+          is_anonymous, status, created_at, updated_at)
+       VALUES (?1, ?2, ?3, ?4, ?5, 'student', ?6, 'active', ?7, ?7)
+       ON CONFLICT (email_normalized) WHERE email_normalized IS NOT NULL DO NOTHING`,
+      id,
+      args.email,
+      args.emailVerified ? args.now : null,
+      args.passwordHash,
+      args.passwordHash === null ? null : PASSWORD_ALGO,
+      args.isAnonymous ? 1 : 0,
+      args.now,
+    ),
+    sql(
+      `INSERT INTO ${T.userProfiles} (user_id, display_name, created_at, updated_at)
+       SELECT ?1, ?2, ?3, ?3
+        WHERE EXISTS (SELECT 1 FROM ${T.users} WHERE id = ?1)
+       ON CONFLICT (user_id) DO NOTHING`,
+      id,
+      profileName,
+      args.now,
+    ),
+  ]);
+
+  if ((results[0]?.meta.changes ?? 0) !== 1) return null;
+
+  return {
+    id,
+    email: args.email,
+    email_verified_at: args.emailVerified ? args.now : null,
+    password_hash: args.passwordHash,
+    role: 'student',
+    status: 'active',
+    is_anonymous: args.isAnonymous ? 1 : 0,
+    created_at: args.now,
+    updated_at: args.now,
+    display_name: displayName ?? profileName,
+  };
+}
+
+export type UpgradeOutcome = 'upgraded' | 'email_taken' | 'not_anonymous';
+
+/**
+ * Turns the current anonymous user into a real account, in place. 3 queries.
+ *
+ * The `is_anonymous = 1` predicate is in the WHERE clause, not in a preceding
+ * read, so a replayed upgrade cannot overwrite an already-claimed account's
+ * email and password - the second call matches zero rows and the caller reports
+ * `not_anonymous`. Combined with the unique email index, this is the entire
+ * safety argument for the endpoint.
+ */
+export async function upgradeAnonymousUser(
+  db: Db,
+  args: {
+    userId: string;
+    email: string;
+    passwordHash: string;
+    displayName: string | null;
+    now: number;
+  },
+): Promise<UpgradeOutcome> {
+  // The email check has to come first, because SQLite surfaces a unique-index
+  // violation as a thrown error rather than as zero changes, and the thrown
+  // error cannot be distinguished from a genuine failure.
+  const taken = await db.first<{ id: string }>(
+    `SELECT id FROM ${T.users}
+      WHERE email_normalized = lower(trim(?1)) AND id <> ?2`,
+    args.email,
+    args.userId,
+  );
+  if (taken) return 'email_taken';
+
+  // Both halves of the identity move in ONE statement, which is what the
+  // `is_anonymous = 0 OR email IS NULL` CHECK requires: setting the flag and
+  // the address in two statements would leave an invalid row in between.
+  const results = await db.batch([
+    sql(
+      `UPDATE ${T.users}
+          SET email = ?2, password_hash = ?3, password_algo = ?4,
+              is_anonymous = 0, updated_at = ?5
+        WHERE id = ?1 AND is_anonymous = 1`,
+      args.userId,
+      args.email,
+      args.passwordHash,
+      PASSWORD_ALGO,
+      args.now,
+    ),
+    sql(
+      `UPDATE ${T.userProfiles}
+          SET display_name = COALESCE(?2, display_name), updated_at = ?3
+        WHERE user_id = ?1`,
+      args.userId,
+      args.displayName,
+      args.now,
+    ),
+  ]);
+
+  return (results[0]?.meta.changes ?? 0) === 1 ? 'upgraded' : 'not_anonymous';
+}
+
+/** Transparent iteration-count upgrade after a successful login. */
+export function rehashStatement(args: {
+  userId: string;
+  passwordHash: string;
+  now: number;
+}): PendingStatement {
+  return sql(
+    `UPDATE ${T.users}
+        SET password_hash = ?2, password_algo = ?3, updated_at = ?4
+      WHERE id = ?1`,
+    args.userId,
+    args.passwordHash,
+    PASSWORD_ALGO,
+    args.now,
+  );
+}
+
+// --- Sessions ---------------------------------------------------------------
+
+export interface SessionRow {
+  /** sha256 hex of the cookie value. NEVER the cookie value. */
+  id: string;
+  user_id: string;
+  created_at: number;
+  last_used_at: number;
+  expires_at: number;
+  absolute_expires_at: number;
+}
+
+/** The stored id for a cookie value. The only way to turn one into the other. */
+export async function hashSessionCookie(cookieValue: string): Promise<string> {
+  return await sha256Hex(cookieValue);
+}
+
+/**
+ * 1 query. Returns the opaque value that goes into the cookie AND the id that
+ * went into the database, which are deliberately different.
+ */
+export async function createSession(
+  db: Db,
+  args: {
+    userId: string;
+    now: number;
+    userAgent: string | null;
+    ipHash: string | null;
+    idleTtlMs?: number;
+    absoluteTtlMs?: number;
+  },
+): Promise<{ cookieValue: string; id: string; expiresAt: number }> {
+  const cookieValue = newSecretId('ses');
+  const id = await hashSessionCookie(cookieValue);
+  const absoluteExpiresAt = args.now + (args.absoluteTtlMs ?? SESSION_ABSOLUTE_TTL_MS);
+  const expiresAt = Math.min(args.now + (args.idleTtlMs ?? SESSION_IDLE_TTL_MS), absoluteExpiresAt);
+
+  await db.run(
+    `INSERT INTO ${T.sessions}
+       (id, user_id, created_at, last_used_at, expires_at, absolute_expires_at,
+        revoked_at, revoked_reason, ip_hash, user_agent)
+     VALUES (?1, ?2, ?3, ?3, ?4, ?5, NULL, NULL, ?6, ?7)`,
+    id,
+    args.userId,
+    args.now,
+    expiresAt,
+    absoluteExpiresAt,
+    args.ipHash,
+    args.userAgent === null ? null : args.userAgent.slice(0, 256),
+  );
+  return { cookieValue, id, expiresAt };
+}
+
+/**
+ * Resolves a STORED session id to a live session and its user. 1 query.
+ *
+ * Expiry, revocation and account status are all in the WHERE clause, so an
+ * expired, revoked or suspended session is indistinguishable from a nonexistent
+ * one and there is no code path where a stale row is loaded and then checked.
+ * `u.status = 'active'` is the part that is easy to forget: without it a
+ * suspended user keeps every session they had when they were suspended.
+ */
+export async function loadSessionById(
+  db: Db,
+  sessionId: string,
+  now: number,
+): Promise<{ session: SessionRow; user: UserRow } | null> {
+  const raw = await db.first<Record<string, unknown>>(
+    `SELECT s.id AS session_id, s.user_id, s.created_at AS session_created_at,
+            s.last_used_at, s.expires_at, s.absolute_expires_at,
+            ${USER_SELECT}
+       FROM ${T.sessions} s
+       JOIN ${T.users} u ON u.id = s.user_id
+       LEFT JOIN ${T.userProfiles} p ON p.user_id = u.id
+      WHERE s.id = ?1
+        AND s.revoked_at IS NULL
+        AND s.expires_at > ?2
+        AND s.absolute_expires_at > ?2
+        AND u.status = 'active'`,
+    sessionId,
+    now,
+  );
+  if (!raw) return null;
+
+  return {
+    session: {
+      id: raw.session_id as string,
+      user_id: raw.user_id as string,
+      created_at: raw.session_created_at as number,
+      last_used_at: raw.last_used_at as number,
+      expires_at: raw.expires_at as number,
+      absolute_expires_at: raw.absolute_expires_at as number,
+    },
+    user: {
+      id: raw.id as string,
+      email: (raw.email as string | null) ?? null,
+      email_verified_at: (raw.email_verified_at as number | null) ?? null,
+      password_hash: (raw.password_hash as string | null) ?? null,
+      role: raw.role as string,
+      status: raw.status as string,
+      is_anonymous: raw.is_anonymous as number,
+      created_at: raw.created_at as number,
+      updated_at: raw.updated_at as number,
+      display_name: (raw.display_name as string | null) ?? null,
+    },
+  };
+}
+
+/** Resolves a raw COOKIE value. Hashes first, so the cookie is never a key. */
+export async function loadSessionByCookie(
+  db: Db,
+  cookieValue: string,
+  now: number,
+): Promise<{ session: SessionRow; user: UserRow } | null> {
+  return await loadSessionById(db, await hashSessionCookie(cookieValue), now);
+}
+
+/**
+ * Slides the idle window forward, at most once an hour.
+ *
+ * Returned as a statement, and only when it is actually due, because a write on
+ * every authenticated request would spend a meaningful slice of the 100k
+ * rows/day budget on nothing but liveness tracking. `min(..., absolute)` is the
+ * clamp that makes the second clock mean something: without it, sliding would
+ * renew a stolen cookie forever.
+ */
+export function touchSessionStatement(
+  session: SessionRow,
+  now: number,
+  idleTtlMs = SESSION_IDLE_TTL_MS,
+): PendingStatement | null {
+  if (now - session.last_used_at < SESSION_TOUCH_INTERVAL_MS) return null;
+  return sql(
+    `UPDATE ${T.sessions}
+        SET last_used_at = ?2,
+            expires_at = MIN(?3, absolute_expires_at)
+      WHERE id = ?1 AND revoked_at IS NULL`,
+    session.id,
+    now,
+    now + idleTtlMs,
+  );
+}
+
+export type RevokeReason =
+  | 'logout'
+  | 'logout_all'
+  | 'password_change'
+  | 'admin'
+  | 'rotated'
+  | 'suspicious';
+
+/** 1 query. Idempotent: revoking a revoked session is a no-op. */
+export async function revokeSession(
+  db: Db,
+  sessionId: string,
+  now: number,
+  reason: RevokeReason = 'logout',
+): Promise<void> {
+  await db.run(
+    `UPDATE ${T.sessions}
+        SET revoked_at = ?2, revoked_reason = ?3
+      WHERE id = ?1 AND revoked_at IS NULL`,
+    sessionId,
+    now,
+    reason,
+  );
+}
+
+/** Used when a password changes, so other devices are logged out. */
+export async function revokeAllSessionsForUser(
+  db: Db,
+  userId: string,
+  now: number,
+  exceptSessionId?: string,
+  reason: RevokeReason = 'logout_all',
+): Promise<void> {
+  await db.run(
+    `UPDATE ${T.sessions}
+        SET revoked_at = ?2, revoked_reason = ?4
+      WHERE user_id = ?1 AND revoked_at IS NULL AND id <> COALESCE(?3, '')`,
+    userId,
+    now,
+    exceptSessionId ?? null,
+    reason,
+  );
+}
+
+// --- OAuth ------------------------------------------------------------------
+
+/** 1 query. */
+export async function createOAuthState(
+  db: Db,
+  args: { codeVerifier: string; redirectTo: string | null; now: number },
+): Promise<string> {
+  const state = newSecretId('oas');
+  await db.run(
+    `INSERT INTO ${T.oauthStates} (state, code_verifier, redirect_to, created_at, expires_at)
+     VALUES (?1, ?2, ?3, ?4, ?5)`,
+    state,
+    args.codeVerifier,
+    // The column has a `GLOB '/*'` CHECK, so a non-path slips through as NULL
+    // rather than failing the request: the redirect is a convenience, and an
+    // absolute URL here would be an open-redirect primitive.
+    args.redirectTo !== null && args.redirectTo.startsWith('/') ? args.redirectTo : null,
+    args.now,
+    args.now + OAUTH_STATE_TTL_MS,
+  );
+  return state;
+}
+
+/**
+ * Single-use state consumption. 1 query.
+ *
+ * `DELETE ... RETURNING` makes it atomic: a replayed callback finds nothing and
+ * is rejected, which is what stops an intercepted `?code=` from being redeemed
+ * twice.
+ */
+export async function consumeOAuthState(
+  db: Db,
+  state: string,
+  now: number,
+): Promise<{ codeVerifier: string; redirectTo: string | null } | null> {
+  const row = await db.first<{ code_verifier: string; redirect_to: string | null }>(
+    `DELETE FROM ${T.oauthStates}
+      WHERE state = ?1 AND expires_at > ?2
+      RETURNING code_verifier, redirect_to`,
+    state,
+    now,
+  );
+  return row ? { codeVerifier: row.code_verifier, redirectTo: row.redirect_to } : null;
+}
+
+/** 1 query. */
+export async function findUserByOAuthAccount(
+  db: Db,
+  provider: string,
+  providerAccountId: string,
+): Promise<UserRow | null> {
+  return await db.first<UserRow>(
+    `SELECT ${USER_SELECT}
+       FROM ${T.oauthAccounts} oa
+       JOIN ${T.users} u ON u.id = oa.user_id
+       LEFT JOIN ${T.userProfiles} p ON p.user_id = u.id
+      WHERE oa.provider = ?1 AND oa.provider_account_id = ?2 AND u.status = 'active'`,
+    provider,
+    providerAccountId,
+  );
+}
+
+/** 1 query. Idempotent, so a repeat sign-in does not create a second link. */
+export async function linkOAuthAccount(
+  db: Db,
+  args: {
+    userId: string;
+    provider: string;
+    providerAccountId: string;
+    now: number;
+  },
+): Promise<void> {
+  await db.run(
+    `INSERT INTO ${T.oauthAccounts}
+       (id, user_id, provider, provider_account_id, created_at)
+     VALUES (?1, ?2, ?3, ?4, ?5)
+     ON CONFLICT (provider, provider_account_id) DO NOTHING`,
+    newId('oac'),
+    args.userId,
+    args.provider,
+    args.providerAccountId,
+    args.now,
+  );
+}
+
+/**
+ * Claims an anonymous user for a Google identity, in place. 2 statements.
+ *
+ * Same shape as the password upgrade, and for the same reason: a guest who has
+ * already done three mock tests and then signs in with Google must keep them.
+ */
+export async function claimAnonymousForOAuth(
+  db: Db,
+  args: { userId: string; email: string; displayName: string | null; now: number },
+): Promise<boolean> {
+  const results = await db.batch([
+    sql(
+      `UPDATE ${T.users}
+          SET email = ?2, email_verified_at = ?3,
+              is_anonymous = 0, updated_at = ?3
+        WHERE id = ?1 AND is_anonymous = 1
+          AND NOT EXISTS (
+            SELECT 1 FROM ${T.users}
+             WHERE email_normalized = lower(trim(?2)) AND id <> ?1)`,
+      args.userId,
+      args.email,
+      args.now,
+    ),
+    sql(
+      `UPDATE ${T.userProfiles}
+          SET display_name = COALESCE(?2, display_name), updated_at = ?3
+        WHERE user_id = ?1 AND EXISTS (
+          SELECT 1 FROM ${T.users} WHERE id = ?1 AND is_anonymous = 0)`,
+      args.userId,
+      args.displayName,
+      args.now,
+    ),
+  ]);
+  return (results[0]?.meta.changes ?? 0) === 1;
+}
diff --git a/worker/src/data/content.ts b/worker/src/data/content.ts
new file mode 100644
index 0000000..ae0109e
--- /dev/null
+++ b/worker/src/data/content.ts
@@ -0,0 +1,580 @@
+/**
+ * Content reads: chapters, questions, options, templates, search.
+ *
+ * THE STRUCTURAL RULE OF THIS FILE. There are two functions that can reach an
+ * answer, and they read DIFFERENT TABLES:
+ *
+ *   loadOptionsForQuestions()  SELECTs from `question_options`
+ *   loadAnswerKey()            SELECTs from `question_answer_keys`
+ *
+ * `question_options` has no `is_correct` column -- the key is a separate table
+ * with one row per question -- so a query over the option rows is physically
+ * incapable of returning the key. Getting it into a response is not a matter of
+ * forgetting to delete a field, nor of leaving a column out of a SELECT list:
+ * it requires naming a third table in a FROM clause. That is a greppable,
+ * reviewable, testable event, and `loadAnswerKey` is the only place in this
+ * codebase that does it.
+ *
+ * ON `v_question_delivery`, WHICH THIS FILE DOES NOT USE. The schema offers it
+ * as the shortest correct thing to write for a delivery payload, and it cannot
+ * reference the key table, so `SELECT *` over it is safe by construction. The
+ * reads here are narrower and go straight at the tables, for one reason: the
+ * view is one row per (question, option), so loading 100 questions through it
+ * would return 400 rows with every stem repeated four times -- against a 1 MB
+ * D1 response limit and on a mobile connection. `loadQuestionStems` and
+ * `loadOptionsForQuestions` are the same query split in two, and neither can
+ * reach the key either, for the same structural reason the view cannot.
+ *
+ * Every `IN (...)` list is passed as ONE json parameter and expanded with
+ * `json_each`, because D1 refuses more than 100 bound parameters per statement
+ * and a 100-question paper would otherwise have to be chunked.
+ */
+
+import { Db } from './d1.ts';
+import { T } from './tables.ts';
+import type {
+  ChapterIcon,
+  ChapterSummary,
+  MockTemplateSummary,
+  QuestionDifficulty,
+} from '../shared/types.ts';
+import type { OptionRow } from '../lib/permute.ts';
+import type { BlueprintRule, ChapterPool, SubchapterPool } from '../domain/blueprint.ts';
+import type { KeyEntry } from '../domain/scoring.ts';
+
+const VALID_ICONS: ReadonlySet<string> = new Set<ChapterIcon>([
+  'cpu', 'code', 'network', 'database', 'brain',
+  'chip', 'settings', 'book', 'calculator', 'monitor',
+]);
+
+export function toDifficulty(raw: string | null): QuestionDifficulty | null {
+  return raw === 'easy' || raw === 'medium' || raw === 'hard' ? raw : null;
+}
+
+interface ChapterRowShape {
+  id: string;
+  slug: string;
+  name: string;
+  short_name: string;
+  description: string;
+  icon: string;
+  color: string;
+  order_index: number;
+  question_count: number;
+}
+
+/**
+ * 1 query.
+ *
+ * `question_count` is a correlated COUNT rather than a stored column, because
+ * the schema does not keep one and a denormalised counter here would need a
+ * trigger on every question status change to stay honest. The subquery is
+ * served by `idx_questions_published_chapter`, which is partial on
+ * `status = 'published'` and covering for `(chapter_id, id)`, so it is ten
+ * index-only range scans and never touches the questions table.
+ *
+ * `name` is `chapters.display_name` -- the short string the practice cards
+ * already show. `chapters.title` is the official NEC syllabus title and is a
+ * genuinely different string; it is not on this payload because nothing renders
+ * it yet.
+ */
+export async function listChapters(db: Db): Promise<ChapterSummary[]> {
+  const rows = await db.all<ChapterRowShape>(
+    `SELECT c.id, c.slug, c.display_name AS name, c.short_name,
+            COALESCE(c.description, '') AS description, c.icon, c.color,
+            c.ordinal AS order_index,
+            (SELECT COUNT(*) FROM ${T.questions} q
+              WHERE q.chapter_id = c.id AND q.status = 'published') AS question_count
+       FROM ${T.chapters} c
+      WHERE c.status = 'published'
+      ORDER BY c.ordinal, c.slug`,
+  );
+  return rows.map((r) => ({
+    id: r.id,
+    slug: r.slug,
+    name: r.name,
+    shortName: r.short_name,
+    description: r.description,
+    questionCount: r.question_count,
+    icon: (VALID_ICONS.has(r.icon) ? r.icon : 'book') as ChapterIcon,
+    color: r.color,
+    orderIndex: r.order_index,
+  }));
+}
+
+/** One rule out of a stored blueprint, as `json_each` yields it. */
+interface BlueprintRuleRow {
+  chapter_id: string;
+  subchapter_code: string | null;
+  want: number;
+}
+
+function toRules(rows: readonly BlueprintRuleRow[]): BlueprintRule[] {
+  return rows.map((r) => ({
+    chapterId: r.chapter_id,
+    subchapterCode: r.subchapter_code,
+    questionCount: r.want,
+  }));
+}
+
+/**
+ * Templates with their composition. 1 query (NQ-19a + NQ-19b in one).
+ *
+ * The 60 sub-chapter rules are expanded with `json_each` and folded in as two
+ * JSON aggregates -- the per-chapter totals the UI shows in a line, and the
+ * real per-code composition -- rather than a second round trip, because this
+ * runs inside `/api/bootstrap` where every query competes with the rest of the
+ * app shell for the 50-query budget.
+ */
+export async function listMockTemplates(db: Db): Promise<MockTemplateSummary[]> {
+  const rows = await db.all<{
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    duration_minutes: number;
+    total_questions: number;
+    chapter_json: string;
+    subchapter_json: string;
+  }>(
+    `SELECT t.id, t.slug, t.name, COALESCE(t.description, '') AS description,
+            t.duration_minutes, t.total_questions,
+            COALESCE((
+              SELECT json_group_array(
+                       json_object('chapterId', chapter_id, 'questionCount', n))
+                FROM (
+                  SELECT json_extract(r.value, '$.chapter_id') AS chapter_id,
+                         SUM(json_extract(r.value, '$.count'))  AS n
+                    FROM json_each(t.blueprint, '$.rules') r
+                   GROUP BY chapter_id
+                   ORDER BY MIN(r.key)
+                )
+            ), '[]') AS chapter_json,
+            COALESCE((
+              SELECT json_group_array(
+                       json_object('chapterId', chapter_id,
+                                   'subchapterCode', subchapter_code,
+                                   'questionCount', n))
+                FROM (
+                  SELECT json_extract(r.value, '$.chapter_id')      AS chapter_id,
+                         json_extract(r.value, '$.subchapter_code') AS subchapter_code,
+                         json_extract(r.value, '$.count')           AS n
+                    FROM json_each(t.blueprint, '$.rules') r
+                   ORDER BY r.key
+                )
+            ), '[]') AS subchapter_json
+       FROM ${T.mockTestTemplates} t
+      WHERE t.status = 'published'
+      ORDER BY t.ordinal, t.slug`,
+  );
+
+  return rows.map((r) => ({
+    id: r.id,
+    slug: r.slug,
+    name: r.name,
+    description: r.description,
+    durationMinutes: r.duration_minutes,
+    totalQuestions: r.total_questions,
+    blueprint: parseJsonArray<{ chapterId: string; questionCount: number }>(r.chapter_json),
+    subchapterBlueprint: parseJsonArray<{
+      chapterId: string;
+      subchapterCode: string;
+      questionCount: number;
+    }>(r.subchapter_json),
+  }));
+}
+
+function parseJsonArray<T>(raw: string): T[] {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return Array.isArray(parsed) ? (parsed as T[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+export interface MockTemplateRow {
+  id: string;
+  name: string;
+  duration_minutes: number;
+  total_questions: number;
+  strict_subchapter: number;
+}
+
+/** NQ-19 template-by-id. 1 query. `null` for an unknown or retired template. */
+export async function getActiveMockTemplate(
+  db: Db,
+  templateId: string,
+): Promise<MockTemplateRow | null> {
+  return await db.first<MockTemplateRow>(
+    `SELECT id, name, duration_minutes, total_questions,
+            CASE WHEN json_extract(blueprint, '$.strict_subchapter') IN (1, 'true')
+                 THEN 1 ELSE 0 END AS strict_subchapter
+       FROM ${T.mockTestTemplates}
+      WHERE id = ?1 AND status = 'published'`,
+    templateId,
+  );
+}
+
+/** NQ-19b blueprint-expand. 1 query, all 60 rules. */
+export async function getBlueprint(db: Db, templateId: string): Promise<BlueprintRule[]> {
+  const rows = await db.all<BlueprintRuleRow>(
+    `SELECT json_extract(r.value, '$.chapter_id')      AS chapter_id,
+            json_extract(r.value, '$.subchapter_code') AS subchapter_code,
+            json_extract(r.value, '$.count')           AS want
+       FROM ${T.mockTestTemplates} t, json_each(t.blueprint, '$.rules') r
+      WHERE t.id = ?1`,
+    templateId,
+  );
+  return toRules(rows);
+}
+
+/**
+ * NQ-19c blueprint-draw. The whole paper's candidate pools in ONE query.
+ *
+ * Two arms, UNION ALL'd:
+ *
+ *   'subchapter'  up to `count` published questions actually TAGGED with each
+ *                 rule's syllabus code. Empty today -- no imported question
+ *                 carries `subchapter_id` -- and that is why the second arm
+ *                 exists rather than being a fallback bolted on later.
+ *   'chapter'     each chapter's whole quota, shuffled by SQLite, for the
+ *                 top-up. The window function does the random selection inside
+ *                 the database, so the Worker never materialises 2,290
+ *                 questions to pick 100.
+ *
+ * The two arms can overlap -- a tagged question is also in its chapter's pool
+ * -- and `selectPaper` de-duplicates. Bounded at 2 x total_questions rows.
+ */
+export async function drawBlueprintPools(
+  db: Db,
+  templateId: string,
+): Promise<{ subchapterPools: SubchapterPool[]; chapterPools: ChapterPool[] }> {
+  const rows = await db.all<{
+    src: string;
+    id: string;
+    chapter_id: string;
+    subchapter_code: string | null;
+  }>(
+    `WITH rules AS (
+       SELECT json_extract(r.value, '$.chapter_id')      AS chapter_id,
+              json_extract(r.value, '$.subchapter_code') AS subchapter_code,
+              json_extract(r.value, '$.count')           AS want
+         FROM ${T.mockTestTemplates} t, json_each(t.blueprint, '$.rules') r
+        WHERE t.id = ?1
+     ),
+     chapter_want AS (
+       SELECT chapter_id, SUM(want) AS want FROM rules GROUP BY chapter_id
+     ),
+     tagged AS (
+       SELECT q.id, q.chapter_id, s.code AS subchapter_code, r.want,
+              ROW_NUMBER() OVER (PARTITION BY s.code ORDER BY RANDOM()) AS rn
+         FROM rules r
+         JOIN ${T.subchapters} s ON s.code = r.subchapter_code
+         JOIN ${T.questions} q
+           ON q.subchapter_id = s.id AND q.status = 'published'
+     ),
+     pool AS (
+       SELECT q.id, q.chapter_id, cw.want,
+              ROW_NUMBER() OVER (PARTITION BY q.chapter_id ORDER BY RANDOM()) AS rn
+         FROM chapter_want cw
+         JOIN ${T.questions} q
+           ON q.chapter_id = cw.chapter_id AND q.status = 'published'
+     )
+     SELECT 'subchapter' AS src, id, chapter_id, subchapter_code
+       FROM tagged WHERE rn <= want
+     UNION ALL
+     SELECT 'chapter' AS src, id, chapter_id, NULL AS subchapter_code
+       FROM pool WHERE rn <= want`,
+    templateId,
+  );
+
+  const byCode = new Map<string, string[]>();
+  const byChapter = new Map<string, string[]>();
+  for (const row of rows) {
+    if (row.src === 'subchapter' && row.subchapter_code !== null) {
+      const list = byCode.get(row.subchapter_code);
+      if (list) list.push(row.id);
+      else byCode.set(row.subchapter_code, [row.id]);
+    } else {
+      const list = byChapter.get(row.chapter_id);
+      if (list) list.push(row.id);
+      else byChapter.set(row.chapter_id, [row.id]);
+    }
+  }
+
+  return {
+    subchapterPools: [...byCode.entries()].map(([subchapterCode, questionIds]) => ({
+      subchapterCode,
+      questionIds,
+    })),
+    chapterPools: [...byChapter.entries()].map(([chapterId, questionIds]) => ({
+      chapterId,
+      questionIds,
+    })),
+  };
+}
+
+/** Random published questions from a set of chapters, for practice. 1 query. */
+export async function drawPracticeQuestions(
+  db: Db,
+  args: { chapterIds: readonly string[] | null; limit: number },
+): Promise<Array<{ questionId: string; chapterId: string }>> {
+  const rows = args.chapterIds
+    ? await db.all<{ id: string; chapter_id: string }>(
+        `SELECT q.id, q.chapter_id
+           FROM ${T.questions} q
+          WHERE q.status = 'published'
+            AND q.chapter_id IN (SELECT value FROM json_each(?1))
+          ORDER BY RANDOM()
+          LIMIT ?2`,
+        JSON.stringify(args.chapterIds),
+        args.limit,
+      )
+    : await db.all<{ id: string; chapter_id: string }>(
+        `SELECT q.id, q.chapter_id
+           FROM ${T.questions} q
+          WHERE q.status = 'published'
+          ORDER BY RANDOM()
+          LIMIT ?1`,
+        args.limit,
+      );
+  return rows.map((r) => ({ questionId: r.id, chapterId: r.chapter_id }));
+}
+
+export interface QuestionStem {
+  id: string;
+  chapter_id: string;
+  stem: string;
+  explanation: string | null;
+  difficulty: string | null;
+}
+
+/**
+ * The published explanation for a question, as a correlated subquery.
+ *
+ * `explanations` is a separate table because an explanation is long, edited on
+ * a different cadence, has its own author and review state, and must never be
+ * shipped with the question before the student has answered. Only a PUBLISHED
+ * one is readable here, and `uq_explanations_primary` guarantees at most one
+ * primary per question, so the `ORDER BY` has nothing to choose between.
+ *
+ * It returns NULL for every question today: the table is modelled and indexed
+ * but unpopulated, and the editor flow that fills it is a later phase.
+ */
+const EXPLANATION_SUBQUERY = `(SELECT e.body FROM ${T.explanations} e
+                                WHERE e.question_id = q.id AND e.status = 'published'
+                                ORDER BY e.is_primary DESC, e.id
+                                LIMIT 1)`;
+
+/** 1 query. Stems only - no options, no key. */
+export async function loadQuestionStems(
+  db: Db,
+  questionIds: readonly string[],
+): Promise<QuestionStem[]> {
+  if (questionIds.length === 0) return [];
+  return await db.all<QuestionStem>(
+    `SELECT q.id, q.chapter_id, q.stem, q.difficulty,
+            ${EXPLANATION_SUBQUERY} AS explanation
+       FROM ${T.questions} q
+      WHERE q.id IN (SELECT value FROM json_each(?1))`,
+    JSON.stringify(questionIds),
+  );
+}
+
+/**
+ * NQ-09 deliver-options. Option bodies for a set of questions, keyed by
+ * question. 1 query.
+ *
+ * READS `question_options`, WHICH HAS NO ANSWER COLUMN. This is the function
+ * every pre-answer payload uses, and it is physically incapable of returning
+ * the key: the key is a row in `question_answer_keys`, a table this statement
+ * does not name.
+ *
+ * `is_pinned` comes back because the permuter needs it: 'All of the above' and
+ * friends must stay last, and the schema's flag is better than re-deriving it
+ * from the text on every request.
+ */
+export async function loadOptionsForQuestions(
+  db: Db,
+  questionIds: readonly string[],
+): Promise<Map<string, OptionRow[]>> {
+  const out = new Map<string, OptionRow[]>();
+  if (questionIds.length === 0) return out;
+
+  const rows = await db.all<{
+    id: string;
+    question_id: string;
+    body: string;
+    position: number;
+    is_pinned: number;
+  }>(
+    `SELECT id, question_id, text AS body, ordinal AS position, is_pinned
+       FROM ${T.questionOptions}
+      WHERE question_id IN (SELECT value FROM json_each(?1))
+        AND retired_at IS NULL
+      ORDER BY question_id, ordinal`,
+    JSON.stringify(questionIds),
+  );
+
+  for (const row of rows) {
+    const list = out.get(row.question_id);
+    const option: OptionRow = {
+      id: row.id,
+      body: row.body,
+      position: row.position,
+      isPinned: row.is_pinned === 1,
+    };
+    if (list) list.push(option);
+    else out.set(row.question_id, [option]);
+  }
+  return out;
+}
+
+/**
+ * *** THE ANSWER KEY. NQ-10b grade-batch. 1 query. ***
+ *
+ * The ONLY function in this codebase that names `question_answer_keys`. Three
+ * callers: mock scoring, mock review assembly (which reuses the scoring result)
+ * and the practice per-question reveal. Each runs strictly AFTER the answer has
+ * been committed. Grep for this function name before adding a fourth, and read
+ * the block above the table in migrations/0002_content.sql first.
+ *
+ * One statement for a whole paper, because D1 allows 50 queries per Worker
+ * invocation and a 100-question mock graded one question at a time would need
+ * 100.
+ */
+export async function loadAnswerKey(
+  db: Db,
+  questionIds: readonly string[],
+): Promise<KeyEntry[]> {
+  if (questionIds.length === 0) return [];
+  const rows = await db.all<{ question_id: string; correct_option_id: string }>(
+    `SELECT question_id, correct_option_id
+       FROM ${T.questionAnswerKeys}
+      WHERE question_id IN (SELECT value FROM json_each(?1))`,
+    JSON.stringify(questionIds),
+  );
+  return rows.map((r) => ({ questionId: r.question_id, correctOptionId: r.correct_option_id }));
+}
+
+/** 1 query. */
+export async function countChapterQuestions(db: Db, chapterId: string): Promise<number> {
+  const row = await db.first<{ n: number }>(
+    `SELECT COUNT(*) AS n FROM ${T.questions}
+      WHERE chapter_id = ?1 AND status = 'published'`,
+    chapterId,
+  );
+  return row?.n ?? 0;
+}
+
+/** 1 query. Stable ordering, so paging does not repeat or skip. */
+export async function pageChapterQuestions(
+  db: Db,
+  args: { chapterId: string; offset: number; limit: number },
+): Promise<QuestionStem[]> {
+  return await db.all<QuestionStem>(
+    `SELECT q.id, q.chapter_id, q.stem, q.difficulty,
+            ${EXPLANATION_SUBQUERY} AS explanation
+       FROM ${T.questions} q
+      WHERE q.chapter_id = ?1 AND q.status = 'published'
+      ORDER BY q.id
+      LIMIT ?2 OFFSET ?3`,
+    args.chapterId,
+    args.limit,
+    args.offset,
+  );
+}
+
+/**
+ * Turns a user's search box into an FTS5 MATCH expression.
+ *
+ * FTS5's query language is not a safe place to put untrusted text: a bare `"`,
+ * a trailing `AND`, a `*` or a `-` is a syntax error that throws at
+ * `prepare()`, and `NEAR`/`OR` would let a caller write queries the UI never
+ * offered. So the input is reduced to alphanumeric tokens and each is quoted as
+ * a literal phrase, which is both injection-proof and what a student means by
+ * typing two words. The last token gets a `*` so search-as-you-type finds
+ * 'thevenin' from 'theven'.
+ *
+ * Returns `null` when nothing survives tokenising, which the caller turns into
+ * an empty result rather than a 500.
+ */
+export function toFtsQuery(raw: string): string | null {
+  const tokens = raw.toLowerCase().match(/[a-z0-9]+/g);
+  if (!tokens || tokens.length === 0) return null;
+  const capped = tokens.slice(0, 8);
+  return capped
+    .map((token, i) => (i === capped.length - 1 ? `"${token}"*` : `"${token}"`))
+    .join(' ');
+}
+
+/**
+ * NQ-11 question-search. 1 query, over the FTS5 index.
+ *
+ * This replaced a `LIKE '%...%'` scan. The scan was correct and fast enough at
+ * 2,290 rows, and it needed no second structure to keep in sync -- but D1 is
+ * single-threaded per database, so a scan on a request path is a platform-wide
+ * cost, and the bank is expected to reach 10k-50k questions. The FTS index is
+ * maintained by the six triggers in 0003, which run inside the statement that
+ * edits a question and therefore cost nothing against the query budget, so the
+ * "an out-of-date index silently returns wrong results" objection is answered
+ * by the triggers rather than by a cron.
+ *
+ * The bm25 weights are positional over the table's five columns: the three
+ * UNINDEXED ones get 0, a stem hit is weighted 10 and an option hit 3. A
+ * student searching 'Thevenin' wants the question about Thevenin's theorem
+ * ahead of one that merely lists it as a wrong answer.
+ */
+export async function searchQuestions(
+  db: Db,
+  args: { query: string; chapterId: string | null; limit: number },
+): Promise<Array<{ questionId: string; chapterId: string; stem: string }>> {
+  const match = toFtsQuery(args.query);
+  if (match === null) return [];
+
+  const rows = args.chapterId
+    ? await db.all<{ question_id: string; chapter_id: string; stem: string }>(
+        `SELECT question_id, chapter_id, stem
+           FROM ${T.questionsFts}
+          WHERE ${T.questionsFts} MATCH ?1
+            AND status = 'published'
+            AND chapter_id = ?2
+          ORDER BY bm25(${T.questionsFts}, 0.0, 0.0, 0.0, 10.0, 3.0)
+          LIMIT ?3`,
+        match,
+        args.chapterId,
+        args.limit,
+      )
+    : await db.all<{ question_id: string; chapter_id: string; stem: string }>(
+        `SELECT question_id, chapter_id, stem
+           FROM ${T.questionsFts}
+          WHERE ${T.questionsFts} MATCH ?1
+            AND status = 'published'
+          ORDER BY bm25(${T.questionsFts}, 0.0, 0.0, 0.0, 10.0, 3.0)
+          LIMIT ?2`,
+        match,
+        args.limit,
+      );
+
+  return rows.map((r) => ({
+    questionId: r.question_id,
+    chapterId: r.chapter_id,
+    stem: r.stem,
+  }));
+}
+
+/**
+ * A cheap cache-busting token for the content endpoints. 1 query.
+ *
+ * Derived from the newest `questions.updated_at`, so publishing or retiring a
+ * question changes it and the client knows to refetch, without a separate
+ * version table to keep in step.
+ */
+export async function contentVersion(db: Db): Promise<string> {
+  const row = await db.first<{ v: number | null; n: number }>(
+    `SELECT MAX(updated_at) AS v, COUNT(*) AS n
+       FROM ${T.questions} WHERE status = 'published'`,
+  );
+  return `${row?.v ?? 0}-${row?.n ?? 0}`;
+}
diff --git a/worker/src/data/d1.ts b/worker/src/data/d1.ts
new file mode 100644
index 0000000..9f9a53b
--- /dev/null
+++ b/worker/src/data/d1.ts
@@ -0,0 +1,176 @@
+/**
+ * ADAPTER BOUNDARY - the only place that knows what a D1 handle looks like.
+ *
+ * `@cloudflare/workers-types` is not a dependency of this directory (the Worker
+ * package manifest is owned elsewhere), so the slice of the D1 API this codebase
+ * actually uses is declared here. It is structurally compatible with the real
+ * `D1Database`, so a Worker can pass `env.DB` straight in, and the test harness
+ * can pass a `node:sqlite` shim that implements the same four methods.
+ *
+ * Everything above this file talks to `Db`, never to `D1Database` directly.
+ */
+
+export type SqlValue = string | number | null | ArrayBuffer;
+
+export interface D1Meta {
+  changes: number;
+  last_row_id: number;
+  rows_read?: number;
+  rows_written?: number;
+}
+
+export interface D1Result<T = Record<string, unknown>> {
+  results: T[];
+  success: boolean;
+  meta: D1Meta;
+}
+
+export interface D1PreparedStatement {
+  bind(...values: SqlValue[]): D1PreparedStatement;
+  first<T = Record<string, unknown>>(): Promise<T | null>;
+  all<T = Record<string, unknown>>(): Promise<D1Result<T>>;
+  run<T = Record<string, unknown>>(): Promise<D1Result<T>>;
+}
+
+export interface D1Database {
+  prepare(query: string): D1PreparedStatement;
+  batch<T = Record<string, unknown>>(
+    statements: D1PreparedStatement[],
+  ): Promise<D1Result<T>[]>;
+}
+
+/** A statement queued for a `batch()`. */
+export interface PendingStatement {
+  sql: string;
+  binds: SqlValue[];
+}
+
+export function sql(query: string, ...binds: SqlValue[]): PendingStatement {
+  return { sql: query, binds };
+}
+
+/**
+ * Raised when a single Worker invocation tries to spend more D1 queries than
+ * the plan allows.
+ *
+ * D1 Free permits 50 queries per invocation (1,000 on the $5/mo plan) and the
+ * budget is enforced here rather than discovered in production: an accidental
+ * N+1 inside a handler fails the request - and the test suite - instead of
+ * quietly working on a ten-question paper and blowing up on a hundred-question
+ * one.
+ */
+export class QueryBudgetExceeded extends Error {
+  // Written out rather than declared as constructor parameter properties:
+  // those are not erasable syntax, so neither Node's type stripping nor the
+  // frontend's `erasableSyntaxOnly` tsconfig will accept them.
+  readonly spent: number;
+  readonly budget: number;
+  readonly lastSql: string;
+
+  constructor(spent: number, budget: number, lastSql: string) {
+    super(
+      `D1 query budget exceeded: ${spent} > ${budget}. ` +
+        `Last statement: ${lastSql.slice(0, 160)}`,
+    );
+    this.name = 'QueryBudgetExceeded';
+    this.spent = spent;
+    this.budget = budget;
+    this.lastSql = lastSql;
+  }
+}
+
+/** D1 refuses more than 100 bound parameters in one statement. */
+export const D1_MAX_BOUND_PARAMS = 100;
+
+export class TooManyBoundParams extends Error {
+  constructor(count: number, query: string) {
+    super(
+      `Statement binds ${count} parameters, D1 allows ` +
+        `${D1_MAX_BOUND_PARAMS}. Pass the payload as a single JSON parameter ` +
+        `and expand it with json_each(). Statement: ${query.slice(0, 160)}`,
+    );
+    this.name = 'TooManyBoundParams';
+  }
+}
+
+export interface DbOptions {
+  /** Queries allowed for this invocation. Default 45, under the free cap of 50. */
+  budget?: number;
+}
+
+/**
+ * Query-counting facade over a D1 handle.
+ *
+ * Every data-access function in `worker/src/data/` takes one of these, so the
+ * cost of a request is a measured number rather than an estimate. Handlers
+ * report it on the `X-D1-Queries` response header and the tests assert that the
+ * expensive endpoints are O(1) in the size of the paper.
+ */
+export class Db {
+  #inner: D1Database;
+  #spent = 0;
+  #budget: number;
+
+  constructor(inner: D1Database, options: DbOptions = {}) {
+    this.#inner = inner;
+    this.#budget = options.budget ?? 45;
+  }
+
+  /** Statements executed so far in this invocation. */
+  get queryCount(): number {
+    return this.#spent;
+  }
+
+  get budget(): number {
+    return this.#budget;
+  }
+
+  #spend(n: number, query: string): void {
+    this.#spent += n;
+    if (this.#spent > this.#budget) {
+      throw new QueryBudgetExceeded(this.#spent, this.#budget, query);
+    }
+  }
+
+  #prepare(query: string, binds: SqlValue[]): D1PreparedStatement {
+    if (binds.length > D1_MAX_BOUND_PARAMS) {
+      throw new TooManyBoundParams(binds.length, query);
+    }
+    const stmt = this.#inner.prepare(query);
+    return binds.length > 0 ? stmt.bind(...binds) : stmt;
+  }
+
+  async first<T>(query: string, ...binds: SqlValue[]): Promise<T | null> {
+    this.#spend(1, query);
+    return await this.#prepare(query, binds).first<T>();
+  }
+
+  async all<T>(query: string, ...binds: SqlValue[]): Promise<T[]> {
+    this.#spend(1, query);
+    const res = await this.#prepare(query, binds).all<T>();
+    return res.results;
+  }
+
+  async run(query: string, ...binds: SqlValue[]): Promise<D1Meta> {
+    this.#spend(1, query);
+    const res = await this.#prepare(query, binds).run();
+    return res.meta;
+  }
+
+  /**
+   * One round trip, N statements, implicitly transactional in D1.
+   *
+   * D1 is single-threaded per database and has no interactive transactions, so
+   * this is the only atomic write primitive available. Every multi-row write in
+   * this codebase goes through here.
+   */
+  async batch<T = Record<string, unknown>>(
+    statements: PendingStatement[],
+  ): Promise<D1Result<T>[]> {
+    if (statements.length === 0) return [];
+    this.#spend(statements.length, statements[0].sql);
+    return await this.#inner.batch<T>(
+      statements.map((s) => this.#prepare(s.sql, s.binds)),
+    );
+  }
+}
diff --git a/worker/src/data/infra.ts b/worker/src/data/infra.ts
new file mode 100644
index 0000000..c9ab0cc
--- /dev/null
+++ b/worker/src/data/infra.ts
@@ -0,0 +1,219 @@
+/**
+ * Idempotency and rate limiting - the two cross-cutting pieces of D1 state.
+ */
+
+import { Db, sql } from './d1.ts';
+import type { PendingStatement } from './d1.ts';
+import { T } from './tables.ts';
+import { HOUR, MINUTE } from '../lib/time.ts';
+
+// --- Idempotency ------------------------------------------------------------
+
+export type IdempotencyCheck =
+  | { kind: 'proceed' }
+  | { kind: 'replay'; statusCode: number; body: unknown }
+  /** Same key, different body. The client has a bug; do not guess. */
+  | { kind: 'reused' }
+  /** Key reserved but not yet finalised: a concurrent duplicate is in flight. */
+  | { kind: 'in_flight' };
+
+/**
+ * Reserves an idempotency key, or reports what happened last time.
+ *
+ * Costs 1 D1 query on the common first-attempt path and 2 when a key is being
+ * replayed. The reservation is a real row with a NULL `response_json`, so two
+ * concurrent copies of the same request cannot both proceed: the second gets
+ * `in_flight` and retries, rather than both of them scoring the same attempt.
+ *
+ * Keyed by `(user_id, key)`. One user's key can neither collide with nor read
+ * another's, which matters because clients mint these keys themselves.
+ */
+export async function reserveIdempotency(
+  db: Db,
+  args: {
+    userId: string;
+    key: string;
+    endpoint: string;
+    requestHash: string;
+    now: number;
+  },
+): Promise<IdempotencyCheck> {
+  const inserted = await db.run(
+    `INSERT INTO ${T.idempotencyKeys}
+       (user_id, key, endpoint, request_hash, status_code, response_json, created_at)
+     VALUES (?1, ?2, ?3, ?4, NULL, NULL, ?5)
+     ON CONFLICT (user_id, key) DO NOTHING`,
+    args.userId,
+    args.key,
+    args.endpoint,
+    args.requestHash,
+    args.now,
+  );
+
+  if (inserted.changes === 1) return { kind: 'proceed' };
+
+  const existing = await db.first<{
+    endpoint: string;
+    request_hash: string;
+    status_code: number | null;
+    response_json: string | null;
+  }>(
+    `SELECT endpoint, request_hash, status_code, response_json
+       FROM ${T.idempotencyKeys}
+      WHERE user_id = ?1 AND key = ?2`,
+    args.userId,
+    args.key,
+  );
+
+  // Lost the row between the two statements (a concurrent sweep). Safest
+  // reading is that nothing has been recorded, so let the caller proceed.
+  if (!existing) return { kind: 'proceed' };
+
+  if (existing.request_hash !== args.requestHash || existing.endpoint !== args.endpoint) {
+    return { kind: 'reused' };
+  }
+
+  if (existing.response_json === null || existing.status_code === null) {
+    return { kind: 'in_flight' };
+  }
+
+  try {
+    return {
+      kind: 'replay',
+      statusCode: existing.status_code,
+      body: JSON.parse(existing.response_json) as unknown,
+    };
+  } catch {
+    // A corrupt stored response must not become a permanent 500 for this key.
+    return { kind: 'proceed' };
+  }
+}
+
+/**
+ * The statement that records the response.
+ *
+ * Returned rather than executed so it joins the handler's own write batch: the
+ * result and its idempotency record commit together, and it costs no extra
+ * round trip. A crash between the two would otherwise leave a key reserved
+ * forever with the work already done.
+ */
+export function finalizeIdempotencyStatement(args: {
+  userId: string;
+  key: string;
+  statusCode: number;
+  body: unknown;
+}): PendingStatement {
+  return sql(
+    `UPDATE ${T.idempotencyKeys}
+        SET status_code = ?3, response_json = ?4
+      WHERE user_id = ?1 AND key = ?2`,
+    args.userId,
+    args.key,
+    args.statusCode,
+    JSON.stringify(args.body),
+  );
+}
+
+/**
+ * Releases a reservation whose handler failed, so a retry is not stuck on
+ * `in_flight` until the sweep runs. Best-effort: a failure here is swallowed by
+ * the caller, because the original error is the one worth reporting.
+ */
+export async function releaseIdempotency(
+  db: Db,
+  args: { userId: string; key: string },
+): Promise<void> {
+  await db.run(
+    `DELETE FROM ${T.idempotencyKeys}
+      WHERE user_id = ?1 AND key = ?2 AND response_json IS NULL`,
+    args.userId,
+    args.key,
+  );
+}
+
+/** Retention for replay records. Longer than any plausible offline window. */
+export const IDEMPOTENCY_TTL_MS = 7 * 24 * HOUR;
+
+/** For a scheduled sweep. Not called on the request path. */
+export function sweepIdempotencyStatement(now: number): PendingStatement {
+  return sql(
+    `DELETE FROM ${T.idempotencyKeys} WHERE created_at < ?1`,
+    now - IDEMPOTENCY_TTL_MS,
+  );
+}
+
+// --- Rate limiting ----------------------------------------------------------
+
+export interface RateLimitRule {
+  /** Namespace, e.g. `auth:login`. */
+  name: string;
+  limit: number;
+  windowMs: number;
+}
+
+export const RATE_LIMITS = {
+  login: { name: 'auth:login', limit: 10, windowMs: 10 * MINUTE },
+  signup: { name: 'auth:signup', limit: 5, windowMs: HOUR },
+  anonymous: { name: 'auth:anonymous', limit: 10, windowMs: HOUR },
+  upgrade: { name: 'auth:upgrade', limit: 5, windowMs: HOUR },
+  mockStart: { name: 'mock:start', limit: 20, windowMs: HOUR },
+  mockSubmit: { name: 'mock:submit', limit: 40, windowMs: HOUR },
+  mockSync: { name: 'mock:sync', limit: 240, windowMs: HOUR },
+  practiceAnswer: { name: 'practice:answer', limit: 600, windowMs: HOUR },
+  report: { name: 'report:submit', limit: 30, windowMs: HOUR },
+  search: { name: 'content:search', limit: 120, windowMs: HOUR },
+} as const satisfies Record<string, RateLimitRule>;
+
+export interface RateLimitResult {
+  allowed: boolean;
+  count: number;
+  limit: number;
+  retryAfterMs: number;
+}
+
+/**
+ * Fixed-window counter, one D1 query.
+ *
+ * BEST-EFFORT BY CONSTRUCTION, and the honest reason is worth writing down: D1
+ * replicates asynchronously, so two requests served by different Cloudflare
+ * locations can both read a stale counter and both be allowed. The effective
+ * limit is therefore "roughly `limit` per window per region". That is adequate
+ * for what this defends against - credential stuffing, mock-submit hammering
+ * and search abuse - and it is not a substitute for a Durable Object or for
+ * Cloudflare's own WAF rate limiting, neither of which is on the free plan.
+ *
+ * The whole operation is one upsert with RETURNING so there is no read-then-
+ * write race within a single region.
+ */
+export async function consumeRateLimit(
+  db: Db,
+  rule: RateLimitRule,
+  subject: string,
+  now: number,
+): Promise<RateLimitResult> {
+  const windowStart = Math.floor(now / rule.windowMs) * rule.windowMs;
+  const bucket = `${rule.name}:${subject}`;
+
+  const row = await db.first<{ count: number; window_start: number }>(
+    `INSERT INTO ${T.rateLimits} (bucket, window_start, count)
+     VALUES (?1, ?2, 1)
+     ON CONFLICT (bucket) DO UPDATE SET
+       count = CASE WHEN ${T.rateLimits}.window_start < ?2 THEN 1
+                    ELSE ${T.rateLimits}.count + 1 END,
+       window_start = CASE WHEN ${T.rateLimits}.window_start < ?2 THEN ?2
+                          ELSE ${T.rateLimits}.window_start END
+     RETURNING count, window_start`,
+    bucket,
+    windowStart,
+  );
+
+  const count = row?.count ?? 1;
+  const start = row?.window_start ?? windowStart;
+
+  return {
+    allowed: count <= rule.limit,
+    count,
+    limit: rule.limit,
+    retryAfterMs: Math.max(0, start + rule.windowMs - now),
+  };
+}
diff --git a/worker/src/data/moderation.ts b/worker/src/data/moderation.ts
new file mode 100644
index 0000000..d4b928a
--- /dev/null
+++ b/worker/src/data/moderation.ts
@@ -0,0 +1,398 @@
+/**
+ * Errata reports, admin triage, question publishing and the audit log.
+ *
+ * The bank is known to contain wrong keys - the importer's own validator files
+ * 106 of them as `question_reports` rows with `source = 'validator'` on every
+ * seed - so user-submitted errata is a content pipeline, not a nice-to-have.
+ * Every admin mutation writes an audit row in the same batch as the mutation
+ * itself, so there is no path that changes published content without leaving a
+ * trace.
+ *
+ * TWO IDS AGAIN. `question_reports.id` is an INTEGER rowid; `public_id` is the
+ * ULID in URLs and the only one this API emits. `admin_audit_log.id` is a rowid
+ * with no public form at all, and the API stringifies it: the audit log is
+ * admin-only and append-only, so there is nothing an enumerable id there
+ * exposes that the reader cannot already list.
+ *
+ * ONE TABLE FOR BOTH KINDS OF FINDING. A user's report and the importer's
+ * validator finding are the same object -- a claim that a question is
+ * defective, awaiting adjudication -- so they share a table and a queue, with
+ * `source` distinguishing them. `reporter_user_id` is NULL for a machine
+ * finding, which is what keeps the triage inbox honest about which rows a
+ * person is waiting on an answer for.
+ */
+
+import { Db, sql } from './d1.ts';
+import type { PendingStatement } from './d1.ts';
+import { T } from './tables.ts';
+import { newId } from '../lib/ids.ts';
+import type {
+  AdminReportItem,
+  AuditLogItem,
+  QuestionPublishState,
+  ReportItem,
+  ReportReason,
+  ReportStatus,
+  UserRole,
+} from '../shared/types.ts';
+
+/**
+ * `question_reports.category` is wider than the wire `ReportReason`: it also
+ * carries 'bad_option', which only the importer's validator files. An
+ * unrecognised value reads as 'other' rather than throwing, because a report
+ * row is evidence and a display mapping must never be the reason a moderator
+ * cannot see it.
+ */
+function toReason(raw: string): ReportReason {
+  switch (raw) {
+    case 'wrong_answer':
+    case 'ambiguous':
+    case 'typo':
+    case 'duplicate':
+    case 'out_of_syllabus':
+      return raw;
+    default:
+      return 'other';
+  }
+}
+
+function toStatus(raw: string): ReportStatus {
+  switch (raw) {
+    case 'triaged':
+    case 'accepted':
+    case 'rejected':
+    case 'duplicate':
+      return raw;
+    default:
+      return 'open';
+  }
+}
+
+/** Statuses that resolve a report, matching the CHECK on `resolved_at`. */
+const RESOLVING: ReadonlySet<ReportStatus> = new Set<ReportStatus>([
+  'accepted',
+  'rejected',
+  'duplicate',
+]);
+
+// --- User-facing ------------------------------------------------------------
+
+/**
+ * Files an errata report. 1 query.
+ *
+ * The PARTIAL unique index on `(question_id, reporter_user_id) WHERE status =
+ * 'open' AND reporter_user_id IS NOT NULL` makes this idempotent on its own: a
+ * user re-reporting the same question updates their existing open report rather
+ * than filling the triage queue with duplicates, and a replayed offline
+ * mutation converges. That is why the endpoint's idempotency key is optional.
+ *
+ * The conflict target restates the index predicate, which is not optional:
+ * SQLite matches a conflict target to a partial unique index only if the
+ * predicate is repeated, and omitting it fails at `prepare()` time with "ON
+ * CONFLICT clause does not match any PRIMARY KEY or UNIQUE constraint" -- at
+ * runtime, on the first report anyone files.
+ *
+ * `SELECT ... FROM questions` rather than `VALUES`, so a nonexistent question
+ * id writes nothing and returns nothing instead of creating an orphan report.
+ */
+export async function submitReport(
+  db: Db,
+  args: {
+    userId: string;
+    questionId: string;
+    reason: ReportReason;
+    detail: string | null;
+    now: number;
+  },
+): Promise<{ id: string; created: boolean } | null> {
+  const publicId = newId('rep');
+  const row = await db.first<{ public_id: string }>(
+    `INSERT INTO ${T.questionReports}
+       (public_id, question_id, reporter_user_id, source, category, code, detail,
+        suggested_option_id, attempt_id, status, resolution, resolved_by,
+        resolved_at, created_at, updated_at)
+     SELECT ?1, q.id, ?2, 'user', ?3, NULL, ?4, NULL, NULL, 'open', NULL, NULL,
+            NULL, ?5, ?5
+       FROM ${T.questions} q
+      WHERE q.id = ?6
+     ON CONFLICT (question_id, reporter_user_id)
+       WHERE status = 'open' AND reporter_user_id IS NOT NULL
+       DO UPDATE SET
+         category   = excluded.category,
+         detail     = excluded.detail,
+         updated_at = excluded.updated_at
+     RETURNING public_id`,
+    publicId,
+    args.userId,
+    args.reason,
+    args.detail,
+    args.now,
+    args.questionId,
+  );
+
+  if (!row) return null;
+  return { id: row.public_id, created: row.public_id === publicId };
+}
+
+const REPORT_SELECT = `r.public_id AS id, r.question_id, q.chapter_id, r.category,
+                       r.detail, r.status, r.created_at, r.resolution`;
+
+interface ReportRowShape {
+  id: string;
+  question_id: string;
+  chapter_id: string;
+  category: string;
+  detail: string | null;
+  status: string;
+  created_at: number;
+  resolution: string | null;
+}
+
+function toReportItem(r: ReportRowShape): ReportItem {
+  return {
+    id: r.id,
+    questionId: r.question_id,
+    chapterId: r.chapter_id,
+    reason: toReason(r.category),
+    detail: r.detail,
+    status: toStatus(r.status),
+    createdAt: r.created_at,
+    resolutionNote: r.resolution,
+  };
+}
+
+/**
+ * NQ-16 reports-for-user. 1 query. Scoped to the caller.
+ *
+ * `chapter_id` comes from the join rather than from a column on the report,
+ * because a question can be moved between chapters and a denormalised copy here
+ * would then name the wrong one in a moderator's queue.
+ */
+export async function listOwnReports(db: Db, userId: string): Promise<ReportItem[]> {
+  const rows = await db.all<ReportRowShape>(
+    `SELECT ${REPORT_SELECT}
+       FROM ${T.questionReports} r
+       JOIN ${T.questions} q ON q.id = r.question_id
+      WHERE r.reporter_user_id = ?1
+      ORDER BY r.created_at DESC
+      LIMIT 200`,
+    userId,
+  );
+  return rows.map(toReportItem);
+}
+
+// --- Admin ------------------------------------------------------------------
+
+/**
+ * NQ-15 report-triage-queue. 1 query.
+ *
+ * Carries `reportCountForQuestion` from a correlated subquery so a question
+ * five people have flagged sorts to the top, instead of needing a second pass
+ * over the queue to work that out.
+ */
+export async function readReportQueue(
+  db: Db,
+  args: { status: ReportStatus; limit: number; beforeCreatedAt: number | null },
+): Promise<AdminReportItem[]> {
+  const rows = await db.all<
+    ReportRowShape & {
+      reporter_user_id: string | null;
+      stem: string;
+      report_count: number;
+    }
+  >(
+    `SELECT ${REPORT_SELECT}, r.reporter_user_id, q.stem,
+            (SELECT COUNT(*) FROM ${T.questionReports} r2
+              WHERE r2.question_id = r.question_id
+                AND r2.status IN ('open', 'triaged')) AS report_count
+       FROM ${T.questionReports} r
+       JOIN ${T.questions} q ON q.id = r.question_id
+      WHERE r.status = ?1 AND r.created_at < ?2
+      ORDER BY report_count DESC, r.created_at DESC
+      LIMIT ?3`,
+    args.status,
+    args.beforeCreatedAt ?? Number.MAX_SAFE_INTEGER,
+    args.limit,
+  );
+
+  return rows.map((r) => ({
+    ...toReportItem(r),
+    // '' for a validator or import finding: there is no human behind it, and
+    // inventing one would make the queue lie about who is waiting.
+    reporterUserId: r.reporter_user_id ?? '',
+    stem: r.stem,
+    reportCountForQuestion: r.report_count,
+  }));
+}
+
+/**
+ * One audit row. `actor_role` and `entity_type` are NOT NULL in the schema, and
+ * both are load-bearing: the role is what the action was permitted BY (a
+ * moderator who is later promoted does not retroactively change what they were
+ * allowed to do at the time), and the entity type is what makes NQ-37b -- "who
+ * touched this question" -- an index hit rather than a scan.
+ *
+ * `after_json` must be valid JSON (a CHECK), so the detail is stringified here
+ * and never passed through as free text.
+ */
+export function auditStatement(args: {
+  actorUserId: string | null;
+  actorRole: UserRole | 'system';
+  action: string;
+  entityType: string;
+  entityId: string | null;
+  detail: unknown;
+  reason?: string | null;
+  now: number;
+}): PendingStatement {
+  return sql(
+    `INSERT INTO ${T.adminAuditLog}
+       (actor_user_id, actor_role, action, entity_type, entity_id,
+        before_json, after_json, reason, ip_hash, user_agent, created_at)
+     VALUES (?1, ?2, ?3, ?4, ?5, NULL, ?6, ?7, NULL, NULL, ?8)`,
+    args.actorUserId,
+    args.actorRole,
+    args.action,
+    args.entityType,
+    args.entityId,
+    args.detail === undefined || args.detail === null
+      ? null
+      : JSON.stringify(args.detail).slice(0, 4000),
+    args.reason ?? null,
+    args.now,
+  );
+}
+
+/**
+ * Bulk triage. 2 statements, ONE batch.
+ *
+ * The id list travels as one JSON parameter, so triaging 100 reports is still a
+ * single statement under D1's 100-bound-parameter ceiling.
+ *
+ * `resolved_at`/`resolved_by` are set only for a resolving status and NULLed
+ * otherwise, because the schema has a CHECK that says so -- moving a report
+ * back to 'triaged' without clearing them would be rejected, which is the
+ * constraint doing its job.
+ */
+export async function triageReports(
+  db: Db,
+  args: {
+    actorUserId: string;
+    actorRole: UserRole;
+    reportIds: readonly string[];
+    status: ReportStatus;
+    resolutionNote: string | null;
+    now: number;
+  },
+): Promise<number> {
+  const resolved = RESOLVING.has(args.status);
+
+  const results = await db.batch([
+    sql(
+      `UPDATE ${T.questionReports}
+          SET status = ?2,
+              resolution = COALESCE(?3, resolution),
+              resolved_at = CASE WHEN ?4 = 1 THEN ?5 ELSE NULL END,
+              resolved_by = CASE WHEN ?4 = 1 THEN ?6 ELSE NULL END,
+              updated_at = ?5
+        WHERE public_id IN (SELECT value FROM json_each(?1))`,
+      JSON.stringify(args.reportIds),
+      args.status,
+      args.resolutionNote,
+      resolved ? 1 : 0,
+      args.now,
+      args.actorUserId,
+    ),
+    auditStatement({
+      actorUserId: args.actorUserId,
+      actorRole: args.actorRole,
+      action: 'report.triage',
+      entityType: 'question_report',
+      entityId: null,
+      detail: { reportIds: args.reportIds, status: args.status },
+      now: args.now,
+    }),
+  ]);
+
+  return results[0]?.meta.changes ?? 0;
+}
+
+/**
+ * Publishes, drafts or retires questions in bulk. 2 statements, ONE batch.
+ *
+ * Retiring a question is the lever that takes a known-bad item out of every
+ * future paper without deleting the history of attempts against it, which is
+ * what the quarantine list in the current frontend is doing by hand. A DELETE
+ * would be refused by a foreign key anyway, which is the schema making the same
+ * point.
+ *
+ * `status_changed_at` moves with the status, because NQ-38 (the moderation
+ * queue) orders by it: a question that has been sitting in draft for a month
+ * should surface above one drafted this morning.
+ */
+export async function setQuestionState(
+  db: Db,
+  args: {
+    actorUserId: string;
+    actorRole: UserRole;
+    questionIds: readonly string[];
+    state: QuestionPublishState;
+    now: number;
+  },
+): Promise<number> {
+  const results = await db.batch([
+    sql(
+      `UPDATE ${T.questions}
+          SET status = ?2, status_changed_at = ?3, updated_at = ?3
+        WHERE id IN (SELECT value FROM json_each(?1))`,
+      JSON.stringify(args.questionIds),
+      args.state,
+      args.now,
+    ),
+    auditStatement({
+      actorUserId: args.actorUserId,
+      actorRole: args.actorRole,
+      action: 'question.set_state',
+      entityType: 'question',
+      entityId: null,
+      detail: { questionIds: args.questionIds, state: args.state },
+      now: args.now,
+    }),
+  ]);
+
+  return results[0]?.meta.changes ?? 0;
+}
+
+/** NQ-37c audit-recent. 1 query. */
+export async function readAuditLog(
+  db: Db,
+  args: { limit: number; beforeCreatedAt: number | null },
+): Promise<AuditLogItem[]> {
+  const rows = await db.all<{
+    id: number;
+    actor_user_id: string | null;
+    action: string;
+    entity_type: string;
+    entity_id: string | null;
+    after_json: string | null;
+    created_at: number;
+  }>(
+    `SELECT id, actor_user_id, action, entity_type, entity_id, after_json, created_at
+       FROM ${T.adminAuditLog}
+      WHERE created_at < ?1
+      ORDER BY created_at DESC, id DESC
+      LIMIT ?2`,
+    args.beforeCreatedAt ?? Number.MAX_SAFE_INTEGER,
+    args.limit,
+  );
+
+  return rows.map((r) => ({
+    id: String(r.id),
+    actorUserId: r.actor_user_id,
+    action: r.action,
+    entityType: r.entity_type,
+    entityId: r.entity_id,
+    detail: r.after_json,
+    createdAt: r.created_at,
+  }));
+}
diff --git a/worker/src/data/progress.ts b/worker/src/data/progress.ts
new file mode 100644
index 0000000..f2919e1
--- /dev/null
+++ b/worker/src/data/progress.ts
@@ -0,0 +1,802 @@
+/**
+ * Progress, streaks, bookmarks and spaced repetition.
+ *
+ * ===========================================================================
+ * THE ROLLUPS ARE MAINTAINED BY TRIGGERS, NOT BY THIS FILE
+ * ===========================================================================
+ *
+ * `user_question_stats` and `attempts.answered_count`/`correct_count` are
+ * maintained by the triggers in `migrations/0005_learning.sql`, which fire on
+ * `attempt_answers`. This file used to hand-write three upsert statements for
+ * the same job. The triggers are better for a reason specific to this platform:
+ * D1 allows 50 queries per Worker invocation, and work done inside a trigger
+ * belongs to the statement that fired it and does NOT count against that
+ * budget. Three statements per submission became zero, and -- more
+ * importantly -- the rollup can no longer drift from the answer log, because
+ * there is no code path that writes one without the other.
+ *
+ * WHAT IS LEFT HERE is the state a trigger cannot maintain, and in each case
+ * the reason is the same: it needs something SQLite does not know.
+ *
+ *   `streaks`         needs the user's LOCAL calendar day. Nepal is UTC+05:45,
+ *                     so a UTC-keyed day boundary breaks the streak of anyone
+ *                     studying after 18:15 local -- which is most of them.
+ *                     SQLite's date functions know UTC and fixed offsets, not
+ *                     timezones, so the API resolves the day and passes it in.
+ *   `study_sessions`  same reason, plus a session is wall-clock engagement and
+ *                     spans several attempts or none.
+ *   `srs_state`       needs the scheduler, and FSRS needs `pow`/`exp`, which
+ *                     are a compile-time option SQLite and D1 do not guarantee.
+ *
+ * THERE IS NO DELETE TRIGGER ON `attempt_answers` AND THERE MUST NEVER BE.
+ * Archival deletes millions of answer rows; a delete trigger that decremented
+ * these counters would erase every student's entire progress history the first
+ * night the retention job ran. `db/smoke.mjs` asserts the trigger's absence.
+ *
+ * Every statement builder here takes `userId` and puts it in the row. D1 has no
+ * row-level security, so there is no safety net below this line.
+ */
+
+import { Db, sql } from './d1.ts';
+import type { PendingStatement } from './d1.ts';
+import { T } from './tables.ts';
+import { dayKey, DAY } from '../lib/time.ts';
+import { newId } from '../lib/ids.ts';
+import { newCard, review as reviewCard, RATING_BY_GRADE, STATE_CODE, stateFromCode } from '../domain/srs.ts';
+import type { CardState } from '../domain/srs.ts';
+import type {
+  BookmarkItem,
+  ChapterProgress,
+  ProgressStats,
+  SrsCardState,
+  SrsGrade,
+} from '../shared/types.ts';
+import type { ActivityDay } from '../domain/streaks.ts';
+
+/** One scored answer, as fed to the rollup statements. */
+export interface RollupAnswer {
+  questionId: string;
+  chapterId: string;
+  isCorrect: boolean;
+  /** `false` for a skipped question; skips do not count as attempts. */
+  answered: boolean;
+}
+
+function rollupPayload(answers: readonly RollupAnswer[]): string {
+  return JSON.stringify(
+    answers
+      .filter((a) => a.answered)
+      .map((a) => ({
+        q: a.questionId,
+        c: a.chapterId,
+        k: a.isCorrect ? 1 : 0,
+      })),
+  );
+}
+
+// --- Submission guard -------------------------------------------------------
+
+/**
+ * A SQL predicate that is true only while a given attempt is still in progress
+ * (or, for practice, only while a question is still unanswered).
+ *
+ * Every conditional statement in a write batch carries it, and the statement
+ * whose `changes` is the decision runs LAST. A duplicate submission that
+ * arrives after the first one committed therefore finds the predicate false,
+ * writes nothing, and reports zero changes -- which the handler turns into a
+ * replay of the stored result rather than a second score.
+ *
+ * This is the whole concurrency story for submit, and it needs no transaction,
+ * which matters because D1 has none.
+ *
+ * `fragment(startIndex)` renders the predicate with explicitly numbered
+ * placeholders starting at `startIndex`, because D1 binds `?n` positionally and
+ * a hardcoded high number like `?90` would demand ninety bound values.
+ */
+export interface SubmissionGuard {
+  fragment(startIndex: number): string;
+  binds: readonly (string | number)[];
+}
+
+/** True while this attempt is in progress and owned by this user. */
+export function attemptGuard(attemptId: number, userId: string): SubmissionGuard {
+  return {
+    fragment: (start) =>
+      `EXISTS (SELECT 1 FROM ${T.attempts} a
+                WHERE a.id = ?${start}
+                  AND a.user_id = ?${start + 1}
+                  AND a.status = 'in_progress')`,
+    binds: [attemptId, userId],
+  };
+}
+
+/** True while this question has no answer recorded in this attempt. */
+export function unansweredGuard(attemptId: number, questionId: string): SubmissionGuard {
+  return {
+    fragment: (start) =>
+      `NOT EXISTS (SELECT 1 FROM ${T.attemptAnswers}
+                    WHERE attempt_id = ?${start} AND question_id = ?${start + 1})`,
+    binds: [attemptId, questionId],
+  };
+}
+
+/** No guard, for call sites where the caller has already serialised the write. */
+export const UNGUARDED: SubmissionGuard = { fragment: () => '1 = 1', binds: [] };
+
+// --- Streaks ----------------------------------------------------------------
+
+/**
+ * NQ-32a streak-touch. ONE statement, idempotent per local day.
+ *
+ * Called on every answer, so it must move the streak AT MOST ONCE per calendar
+ * day or a double-submit would inflate it. `localDate` is 'YYYY-MM-DD' in the
+ * candidate's timezone, resolved by the API -- see the note at the top of this
+ * file for why SQLite cannot do it.
+ *
+ * `longest_length` is deliberately NOT set here. The obvious hand-written
+ * version is wrong: inside an UPDATE, `longest_length = max(longest_length,
+ * current_length)` reads the OLD `current_length` and so lags a day behind the
+ * streak it is supposed to record. The `streaks_longest_ratchet` trigger owns
+ * it instead.
+ *
+ * The trailing `WHERE last_active_date IS NULL OR last_active_date <= ?2` stops
+ * a stale request -- a drained offline outbox entry from yesterday -- from
+ * moving the streak backwards.
+ */
+export function touchStreakStatement(args: {
+  userId: string;
+  now: number;
+  guard: SubmissionGuard;
+}): PendingStatement {
+  return sql(
+    `INSERT INTO ${T.streaks} (user_id, current_length, last_active_date,
+                               total_active_days, updated_at)
+     SELECT ?1, 1, ?2, 1, ?3
+      WHERE ${args.guard.fragment(4)}
+     ON CONFLICT (user_id) DO UPDATE SET
+       current_length = CASE
+         WHEN last_active_date = ?2                     THEN current_length
+         WHEN last_active_date = date(?2, '-1 day')     THEN current_length + 1
+         WHEN freezes_available > 0
+              AND last_active_date = date(?2, '-2 day') THEN current_length + 1
+         ELSE 1 END,
+       freezes_available = CASE
+         WHEN last_active_date = date(?2, '-2 day') AND freezes_available > 0
+              THEN freezes_available - 1 ELSE freezes_available END,
+       total_active_days = total_active_days
+         + CASE WHEN last_active_date IS NULL OR last_active_date <> ?2
+                THEN 1 ELSE 0 END,
+       last_active_date  = ?2,
+       updated_at        = ?3
+      WHERE last_active_date IS NULL OR last_active_date <= ?2`,
+    args.userId,
+    dayKey(args.now),
+    args.now,
+    ...args.guard.binds,
+  );
+}
+
+export interface StreakRow {
+  current_length: number;
+  longest_length: number;
+  last_active_date: string | null;
+  total_active_days: number;
+}
+
+/** 1 query. `null` for a user who has never answered anything. */
+export async function readStreak(db: Db, userId: string): Promise<StreakRow | null> {
+  return await db.first<StreakRow>(
+    `SELECT current_length, longest_length, last_active_date, total_active_days
+       FROM ${T.streaks} WHERE user_id = ?1`,
+    userId,
+  );
+}
+
+// --- Study sessions ---------------------------------------------------------
+
+/**
+ * Attempt mode -> `study_sessions.kind`. The two enums are not the same shape
+ * and should not be: an attempt has five modes, a session has five kinds, and
+ * 'bookmark_review' and 'weak_areas' are both 'review' as far as wall-clock
+ * engagement is concerned.
+ */
+export function studyKindForMode(mode: string): string {
+  switch (mode) {
+    case 'mock':
+      return 'mock';
+    case 'srs':
+      return 'srs';
+    case 'practice':
+      return 'practice';
+    default:
+      return 'review';
+  }
+}
+
+/**
+ * Opens the wall-clock session for an attempt. One statement, in the attempt's
+ * own start batch.
+ *
+ * `local_date` is the calendar day in the candidate's timezone and is what the
+ * activity heatmap groups by (NQ-31b, a covering index-only scan). It is
+ * written here rather than generated because a generated column would have to
+ * assume UTC and would misattribute every late-night session in Kathmandu to
+ * the wrong day -- which is exactly the bug that breaks a streak.
+ */
+export function createStudySessionStatement(args: {
+  userId: string;
+  /** The attempt's ULID. The numeric id does not exist until it is inserted. */
+  attemptPublicId: string;
+  mode: string;
+  chapterId: string | null;
+  now: number;
+}): PendingStatement {
+  return sql(
+    // `SELECT ... FROM attempts` rather than `VALUES`, so this can ride in the
+    // same batch as the attempt's own INSERT: the numeric rowid is not known
+    // until that statement runs, and resolving it here keeps the whole start
+    // path to one round trip. The `user_id` predicate is not decoration -- it
+    // is what stops a public_id collision from attaching a session to someone
+    // else's attempt.
+    `INSERT INTO ${T.studySessions}
+       (public_id, user_id, kind, chapter_id, subchapter_id, attempt_id,
+        started_at, ended_at, questions_seen, questions_correct, local_date)
+     SELECT ?1, ?2, ?3, ?4, NULL, a.id, ?5, NULL, 0, 0, ?6
+       FROM ${T.attempts} a
+      WHERE a.public_id = ?7 AND a.user_id = ?2`,
+    newId('stu'),
+    args.userId,
+    studyKindForMode(args.mode),
+    args.chapterId,
+    args.now,
+    dayKey(args.now),
+    args.attemptPublicId,
+  );
+}
+
+/**
+ * Credits one answered question to the open session. Guarded, so a replayed
+ * answer does not inflate the heatmap.
+ *
+ * Scoped by `user_id` as well as `attempt_id` -- `study_sessions` has no index
+ * on `attempt_id` on purpose (it is written in bulk and read by user and day),
+ * so this is a short range scan over one user's sessions rather than a table
+ * scan. One user accumulates a few hundred a year, which is bounded by human
+ * stamina rather than by anything unbounded.
+ */
+export function bumpStudySessionStatement(args: {
+  userId: string;
+  attemptId: number;
+  isCorrect: boolean;
+  guard: SubmissionGuard;
+}): PendingStatement {
+  return sql(
+    `UPDATE ${T.studySessions}
+        SET questions_seen = questions_seen + 1,
+            questions_correct = questions_correct + ?3
+      WHERE attempt_id = ?1 AND user_id = ?2 AND ended_at IS NULL
+        AND ${args.guard.fragment(4)}`,
+    args.attemptId,
+    args.userId,
+    args.isCorrect ? 1 : 0,
+    ...args.guard.binds,
+  );
+}
+
+/** Closes the session, stamping the totals the attempt actually reached. */
+export function closeStudySessionStatement(args: {
+  userId: string;
+  attemptId: number;
+  answered: number;
+  correct: number;
+  now: number;
+}): PendingStatement {
+  return sql(
+    `UPDATE ${T.studySessions}
+        SET ended_at = ?3,
+            questions_seen = MAX(questions_seen, ?4),
+            questions_correct = MAX(questions_correct, ?5)
+      WHERE attempt_id = ?1 AND user_id = ?2 AND ended_at IS NULL`,
+    args.attemptId,
+    args.userId,
+    args.now,
+    args.answered,
+    args.correct,
+  );
+}
+
+// --- Spaced repetition, from answers ---------------------------------------
+
+/**
+ * Feeds the schedule from the answers themselves. ONE statement for the whole
+ * paper.
+ *
+ * The arithmetic is deliberately cruder than `domain/srs.ts`, which runs on an
+ * explicitly graded review: doing it properly for 100 questions at once would
+ * mean reading 100 cards first to get each card's difficulty, and the query
+ * budget does not allow a hundred reads. Correct doubles the interval (capped
+ * at a year) and nudges difficulty down; wrong resets it to tomorrow, counts a
+ * lapse and nudges difficulty up.
+ *
+ * `excluded.lapses` carries the correctness bit into the conflict branch -- 0
+ * for a correct answer, 1 for a wrong one -- which is the only way to branch on
+ * the new row's values inside an upsert. `stability` tracks `scheduled_days`
+ * because an SM-2 interval IS its stability estimate; a real FSRS fit would
+ * separate them and that is a change to this statement and `domain/srs.ts`,
+ * not to the schema.
+ *
+ * Every CHECK on `srs_state` is respected by construction: `reps` starts at 1
+ * with `last_review` set (so `reps = 0 OR last_review IS NOT NULL` holds),
+ * `lapses` rises by at most 1 per review alongside `reps` (so
+ * `lapses <= reps` holds), and `difficulty` is clamped to 1..10 in SQL.
+ */
+export function upsertSrsFromAnswersStatement(args: {
+  userId: string;
+  answers: readonly RollupAnswer[];
+  now: number;
+  guard: SubmissionGuard;
+}): PendingStatement {
+  const nextScheduled =
+    `CASE WHEN excluded.lapses = 0
+          THEN MIN(MAX(${T.srsState}.scheduled_days, 1.0) * 2.0, 365.0)
+          ELSE 1.0 END`;
+
+  return sql(
+    `INSERT INTO ${T.srsState}
+       (user_id, question_id, stability, difficulty, elapsed_days, scheduled_days,
+        reps, lapses, state, due, last_review, last_rating, created_at, updated_at)
+     SELECT ?2,
+            json_extract(j.value, '$.q'),
+            CASE WHEN json_extract(j.value, '$.k') = 1 THEN 3.0 ELSE 1.0 END,
+            CASE WHEN json_extract(j.value, '$.k') = 1 THEN 4.8 ELSE 5.8 END,
+            0.0,
+            CASE WHEN json_extract(j.value, '$.k') = 1 THEN 3.0 ELSE 1.0 END,
+            1,
+            CASE WHEN json_extract(j.value, '$.k') = 1 THEN 0 ELSE 1 END,
+            CASE WHEN json_extract(j.value, '$.k') = 1 THEN 2 ELSE 3 END,
+            ?3 + (CASE WHEN json_extract(j.value, '$.k') = 1 THEN 3 ELSE 1 END) * ?4,
+            ?3,
+            CASE WHEN json_extract(j.value, '$.k') = 1 THEN 3 ELSE 1 END,
+            ?3, ?3
+       FROM json_each(?1) j
+      WHERE ${args.guard.fragment(5)}
+     ON CONFLICT (user_id, question_id) DO UPDATE SET
+       scheduled_days = ${nextScheduled},
+       stability      = ${nextScheduled},
+       elapsed_days   = MAX(0.0, (?3 - COALESCE(${T.srsState}.last_review, ?3)) / 86400000.0),
+       difficulty     = MIN(10.0, MAX(1.0,
+                          ${T.srsState}.difficulty
+                          + CASE WHEN excluded.lapses = 0 THEN -0.2 ELSE 0.8 END)),
+       due            = ?3 + (${nextScheduled}) * ?4,
+       lapses         = ${T.srsState}.lapses + excluded.lapses,
+       reps           = ${T.srsState}.reps + 1,
+       state          = CASE WHEN excluded.lapses = 0 THEN 2 ELSE 3 END,
+       last_review    = ?3,
+       last_rating    = CASE WHEN excluded.lapses = 0 THEN 3 ELSE 1 END,
+       updated_at     = ?3`,
+    rollupPayload(args.answers),
+    args.userId,
+    args.now,
+    DAY,
+    ...args.guard.binds,
+  );
+}
+
+// --- Reads ------------------------------------------------------------------
+
+/**
+ * NQ-27 progress-page. 1 query.
+ *
+ * ONE index range scan over `user_question_stats`, grouped by its DENORMALISED
+ * `chapter_id` -- which the rollup trigger stamps precisely so this read needs
+ * no join to `questions`. The alternative, aggregating a user's rows in
+ * `attempt_answers`, grows without bound and stops working entirely once
+ * archival deletes those rows.
+ *
+ * The chapter list is the outer side so a chapter with no activity still
+ * reports its question count, and `question_count` is the same correlated
+ * COUNT as `listChapters` for the same reason.
+ */
+export async function readProgressStats(db: Db, userId: string): Promise<ProgressStats> {
+  const rows = await db.all<{
+    chapter_id: string;
+    question_count: number;
+    attempted: number;
+    correct: number;
+  }>(
+    `SELECT c.id AS chapter_id,
+            (SELECT COUNT(*) FROM ${T.questions} q
+              WHERE q.chapter_id = c.id AND q.status = 'published') AS question_count,
+            COALESCE(s.attempted, 0) AS attempted,
+            COALESCE(s.correct, 0) AS correct
+       FROM ${T.chapters} c
+       LEFT JOIN (
+         SELECT chapter_id,
+                SUM(answer_count)  AS attempted,
+                SUM(correct_count) AS correct
+           FROM ${T.userQuestionStats}
+          WHERE user_id = ?1
+          GROUP BY chapter_id
+       ) s ON s.chapter_id = c.id
+      WHERE c.status = 'published'
+      ORDER BY c.ordinal, c.slug`,
+    userId,
+  );
+
+  const chapters: ChapterProgress[] = rows.map((r) => ({
+    chapterId: r.chapter_id,
+    attempted: r.attempted,
+    correct: r.correct,
+    accuracyPct: r.attempted === 0 ? 0 : Math.round((r.correct / r.attempted) * 100),
+    questionCount: r.question_count,
+  }));
+
+  const totalAnswered = chapters.reduce((sum, c) => sum + c.attempted, 0);
+  const totalCorrect = chapters.reduce((sum, c) => sum + c.correct, 0);
+
+  return {
+    totalAnswered,
+    totalCorrect,
+    accuracyPct: totalAnswered === 0 ? 0 : Math.round((totalCorrect / totalAnswered) * 100),
+    totalAvailable: chapters.reduce((sum, c) => sum + c.questionCount, 0),
+    chapters,
+  };
+}
+
+/**
+ * NQ-31b activity-heatmap. 1 query, newest first, which is what
+ * `computeStreaks` expects.
+ *
+ * Reads `study_sessions.local_date` -- the candidate's own calendar day -- and
+ * is covering, so a year of squares is an index-only scan.
+ */
+export async function readActivityDays(
+  db: Db,
+  userId: string,
+  limit = 400,
+): Promise<ActivityDay[]> {
+  const rows = await db.all<{ day: string; answered: number }>(
+    `SELECT local_date AS day, SUM(questions_seen) AS answered
+       FROM ${T.studySessions}
+      WHERE user_id = ?1
+      GROUP BY local_date
+      ORDER BY local_date DESC
+      LIMIT ?2`,
+    userId,
+    limit,
+  );
+  return rows.map((r) => ({ day: r.day, answered: r.answered }));
+}
+
+/**
+ * NQ-28 weak-areas. 1 query.
+ *
+ * Questions this user got wrong most recently. `last_is_correct` is the
+ * trigger-maintained "how did it go the last time they saw it", which is the
+ * right signal for a revision queue -- a question answered wrong once and then
+ * right four times is not a weak area.
+ */
+export async function readWeakQuestionIds(
+  db: Db,
+  userId: string,
+  limit: number,
+): Promise<Array<{ questionId: string; chapterId: string }>> {
+  const rows = await db.all<{ question_id: string; chapter_id: string }>(
+    `SELECT s.question_id, s.chapter_id
+       FROM ${T.userQuestionStats} s
+       JOIN ${T.questions} q ON q.id = s.question_id AND q.status = 'published'
+      WHERE s.user_id = ?1 AND s.last_is_correct = 0
+      ORDER BY s.last_answered_at DESC LIMIT ?2`,
+    userId,
+    limit,
+  );
+  return rows.map((r) => ({ questionId: r.question_id, chapterId: r.chapter_id }));
+}
+
+// --- Bookmarks --------------------------------------------------------------
+
+/** NQ-30 bookmarks-list. 1 query. */
+export async function listBookmarks(db: Db, userId: string): Promise<BookmarkItem[]> {
+  const rows = await db.all<{
+    question_id: string;
+    chapter_id: string;
+    stem: string;
+    created_at: number;
+  }>(
+    `SELECT b.question_id, q.chapter_id, q.stem, b.created_at
+       FROM ${T.bookmarks} b
+       JOIN ${T.questions} q ON q.id = b.question_id
+      WHERE b.user_id = ?1
+      ORDER BY b.created_at DESC
+      LIMIT 500`,
+    userId,
+  );
+  return rows.map((r) => ({
+    questionId: r.question_id,
+    chapterId: r.chapter_id,
+    stem: r.stem,
+    createdAt: r.created_at,
+  }));
+}
+
+/**
+ * Sets a bookmark to a desired state. 1 query.
+ *
+ * Expressed as a desired end state rather than a toggle, which is what makes
+ * offline replay safe: `ON CONFLICT DO NOTHING` and a `DELETE` of a missing row
+ * both converge, so replaying the same queued mutation any number of times
+ * lands in the same place.
+ */
+export async function setBookmark(
+  db: Db,
+  args: { userId: string; questionId: string; desired: boolean; now: number },
+): Promise<void> {
+  if (args.desired) {
+    await db.run(
+      `INSERT INTO ${T.bookmarks} (user_id, question_id, created_at)
+       SELECT ?1, ?2, ?3
+        WHERE EXISTS (SELECT 1 FROM ${T.questions}
+                       WHERE id = ?2 AND status = 'published')
+       ON CONFLICT (user_id, question_id) DO NOTHING`,
+      args.userId,
+      args.questionId,
+      args.now,
+    );
+  } else {
+    await db.run(
+      `DELETE FROM ${T.bookmarks} WHERE user_id = ?1 AND question_id = ?2`,
+      args.userId,
+      args.questionId,
+    );
+  }
+}
+
+/** 1 query. */
+export async function countBookmarks(db: Db, userId: string): Promise<number> {
+  const row = await db.first<{ n: number }>(
+    `SELECT COUNT(*) AS n FROM ${T.bookmarks} WHERE user_id = ?1`,
+    userId,
+  );
+  return row?.n ?? 0;
+}
+
+/** 1 query. */
+export async function isBookmarked(
+  db: Db,
+  userId: string,
+  questionId: string,
+): Promise<boolean> {
+  const row = await db.first<{ n: number }>(
+    `SELECT 1 AS n FROM ${T.bookmarks} WHERE user_id = ?1 AND question_id = ?2`,
+    userId,
+    questionId,
+  );
+  return row !== null;
+}
+
+/** 1 query. */
+export async function readBookmarkedQuestionIds(
+  db: Db,
+  userId: string,
+  limit: number,
+): Promise<Array<{ questionId: string; chapterId: string }>> {
+  const rows = await db.all<{ question_id: string; chapter_id: string }>(
+    `SELECT b.question_id, q.chapter_id
+       FROM ${T.bookmarks} b
+       JOIN ${T.questions} q ON q.id = b.question_id
+      WHERE b.user_id = ?1 AND q.status = 'published'
+      ORDER BY RANDOM() LIMIT ?2`,
+    userId,
+    limit,
+  );
+  return rows.map((r) => ({ questionId: r.question_id, chapterId: r.chapter_id }));
+}
+
+// --- SRS reads and the graded review ---------------------------------------
+
+interface SrsRow {
+  question_id: string;
+  due: number;
+  stability: number;
+  difficulty: number;
+  scheduled_days: number;
+  elapsed_days: number;
+  reps: number;
+  lapses: number;
+  state: number;
+  last_review: number | null;
+}
+
+const SRS_SELECT = `c.question_id, c.due, c.stability, c.difficulty, c.scheduled_days,
+                    c.elapsed_days, c.reps, c.lapses, c.state, c.last_review`;
+
+function toCardState(row: SrsRow): SrsCardState {
+  return {
+    questionId: row.question_id,
+    dueAt: row.due,
+    stability: row.stability,
+    difficulty: row.difficulty,
+    scheduledDays: row.scheduled_days,
+    reps: row.reps,
+    lapses: row.lapses,
+    state: stateFromCode(row.state),
+    // `reps` IS the revision. One column, one meaning, no second counter to
+    // keep in step with it.
+    revision: row.reps,
+  };
+}
+
+/**
+ * NQ-29 srs-due-queue. 1 query. Cards due now, oldest first.
+ *
+ * `suspended_at IS NULL` is in the partial index, so suspended cards are not
+ * merely filtered out -- they are absent from the structure being scanned.
+ */
+export async function readDueCards(
+  db: Db,
+  args: { userId: string; now: number; limit: number },
+): Promise<SrsCardState[]> {
+  const rows = await db.all<SrsRow>(
+    `SELECT ${SRS_SELECT}
+       FROM ${T.srsState} c
+       JOIN ${T.questions} q ON q.id = c.question_id AND q.status = 'published'
+      WHERE c.user_id = ?1 AND c.due <= ?2 AND c.suspended_at IS NULL
+      ORDER BY c.due
+      LIMIT ?3`,
+    args.userId,
+    args.now,
+    args.limit,
+  );
+  return rows.map(toCardState);
+}
+
+/**
+ * Due cards as `(questionId, chapterId)` pairs. 1 query.
+ *
+ * Separate from `readDueCards` because the attempt writer needs the chapter id
+ * to attribute the rollups, and `srs_state` deliberately does not carry one --
+ * it would be a second copy of `questions.chapter_id` that an admin moving a
+ * question between chapters would have to re-stamp.
+ */
+export async function readDueQuestionIds(
+  db: Db,
+  args: { userId: string; now: number; limit: number },
+): Promise<Array<{ questionId: string; chapterId: string }>> {
+  const rows = await db.all<{ question_id: string; chapter_id: string }>(
+    `SELECT c.question_id, q.chapter_id
+       FROM ${T.srsState} c
+       JOIN ${T.questions} q ON q.id = c.question_id AND q.status = 'published'
+      WHERE c.user_id = ?1 AND c.due <= ?2 AND c.suspended_at IS NULL
+      ORDER BY c.due
+      LIMIT ?3`,
+    args.userId,
+    args.now,
+    args.limit,
+  );
+  return rows.map((r) => ({ questionId: r.question_id, chapterId: r.chapter_id }));
+}
+
+/** 1 query. */
+export async function readCard(
+  db: Db,
+  userId: string,
+  questionId: string,
+): Promise<SrsCardState | null> {
+  const row = await db.first<SrsRow>(
+    `SELECT ${SRS_SELECT} FROM ${T.srsState} c
+      WHERE c.user_id = ?1 AND c.question_id = ?2`,
+    userId,
+    questionId,
+  );
+  return row ? toCardState(row) : null;
+}
+
+export interface SrsReviewOutcome {
+  card: SrsCardState;
+  applied: boolean;
+}
+
+/**
+ * Applies one graded review. 2 queries (read the card, write it).
+ *
+ * The write carries `AND reps = ?expected`, so a replayed outbox entry whose
+ * revision the server has already moved past changes nothing and is reported as
+ * `applied: false` with the current card. That is what makes the endpoint safe
+ * to replay without an idempotency key -- and strictly better than a key here,
+ * because it also makes a stale review from a second device a no-op instead of
+ * a conflict.
+ */
+export async function applySrsReview(
+  db: Db,
+  args: {
+    userId: string;
+    questionId: string;
+    grade: SrsGrade;
+    expectedRevision: number;
+    now: number;
+  },
+): Promise<SrsReviewOutcome | null> {
+  const existingRow = await db.first<SrsRow>(
+    `SELECT ${SRS_SELECT} FROM ${T.srsState} c
+      WHERE c.user_id = ?1 AND c.question_id = ?2`,
+    args.userId,
+    args.questionId,
+  );
+  const existing = existingRow ? toCardState(existingRow) : null;
+
+  if (existing && existing.revision !== args.expectedRevision) {
+    return { card: existing, applied: false };
+  }
+
+  const current: CardState = existingRow
+    ? {
+        dueAt: existingRow.due,
+        stability: existingRow.stability,
+        difficulty: existingRow.difficulty,
+        scheduledDays: existingRow.scheduled_days,
+        elapsedDays: existingRow.elapsed_days,
+        reps: existingRow.reps,
+        lapses: existingRow.lapses,
+        state: stateFromCode(existingRow.state),
+        revision: existingRow.reps,
+        lastReviewAt: existingRow.last_review,
+      }
+    : newCard(args.now);
+
+  const next = reviewCard(current, args.grade, args.now);
+
+  const meta = await db.run(
+    `INSERT INTO ${T.srsState}
+       (user_id, question_id, stability, difficulty, elapsed_days, scheduled_days,
+        reps, lapses, state, due, last_review, last_rating, created_at, updated_at)
+     SELECT ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?11, ?11
+      WHERE EXISTS (SELECT 1 FROM ${T.questions}
+                     WHERE id = ?2 AND status = 'published')
+     ON CONFLICT (user_id, question_id) DO UPDATE SET
+       stability      = excluded.stability,
+       difficulty     = excluded.difficulty,
+       elapsed_days   = excluded.elapsed_days,
+       scheduled_days = excluded.scheduled_days,
+       reps           = excluded.reps,
+       lapses         = excluded.lapses,
+       state          = excluded.state,
+       due            = excluded.due,
+       last_review    = excluded.last_review,
+       last_rating    = excluded.last_rating,
+       updated_at     = excluded.updated_at
+      WHERE ${T.srsState}.reps = ?13`,
+    args.userId,
+    args.questionId,
+    next.stability,
+    next.difficulty,
+    next.elapsedDays,
+    next.scheduledDays,
+    next.reps,
+    next.lapses,
+    STATE_CODE[next.state],
+    next.dueAt,
+    args.now,
+    RATING_BY_GRADE[args.grade],
+    args.expectedRevision,
+  );
+
+  if (meta.changes !== 1) {
+    const fresh = await readCard(db, args.userId, args.questionId);
+    return fresh ? { card: fresh, applied: false } : null;
+  }
+
+  return {
+    card: {
+      questionId: args.questionId,
+      dueAt: next.dueAt,
+      stability: next.stability,
+      difficulty: next.difficulty,
+      scheduledDays: next.scheduledDays,
+      reps: next.reps,
+      lapses: next.lapses,
+      state: next.state,
+      revision: next.revision,
+    },
+    applied: true,
+  };
+}
diff --git a/worker/src/data/tables.ts b/worker/src/data/tables.ts
new file mode 100644
index 0000000..03e7736
--- /dev/null
+++ b/worker/src/data/tables.ts
@@ -0,0 +1,207 @@
+/**
+ * THE TABLE NAMES THIS API READS AND WRITES.
+ *
+ * ===========================================================================
+ * THIS FILE USED TO DECLARE AN ASSUMED SCHEMA. IT NO LONGER DOES.
+ * ===========================================================================
+ *
+ * `worker/src/**` and `worker/migrations/**` were written concurrently against
+ * different assumptions. This file held `ASSUMED_SCHEMA_DDL` -- a parallel
+ * description of the database that the test harness applied, so the suite
+ * proved the API against its own assumptions rather than against the schema it
+ * would actually run on. That was the right call while the two halves were
+ * being built; it is the wrong one now that they have to be one system, because
+ * two descriptions of one database is exactly how a 45-minute deadline comes to
+ * expire in 45 milliseconds.
+ *
+ * So the DDL is gone. `src/__tests__/harness.ts` now applies
+ * `worker/migrations/*.sql` verbatim, and the only thing left here is the map
+ * of names. Anything the API gets wrong about the schema is now a test failure
+ * against the real DDL rather than a passing suite against a fiction.
+ *
+ * The constants below are the CANONICAL names from the migrations. Where the
+ * API's earlier shape differed, the migrations won on names and the adapters in
+ * this directory changed -- see the reconciliation record at the foot of this
+ * file for what moved, what did not, and why.
+ */
+
+export const T = {
+  // 0001_identity
+  users: 'users',
+  userProfiles: 'user_profiles',
+  sessions: 'sessions',
+  oauthAccounts: 'oauth_accounts',
+  oauthStates: 'oauth_states',
+  adminAuditLog: 'admin_audit_log',
+
+  // 0002_content
+  subjects: 'subjects',
+  chapters: 'chapters',
+  subchapters: 'subchapters',
+  questions: 'questions',
+  questionOptions: 'question_options',
+  /**
+   * *** SERVER-ONLY. *** Must not appear in any query whose result can reach a
+   * client before that client's attempt is submitted. The three permitted
+   * queries are written out in migrations/0002_content.sql (NQ-10, NQ-10b,
+   * NQ-10c). In this codebase exactly one function names it:
+   * `data/content.ts#loadAnswerKey`.
+   */
+  questionAnswerKeys: 'question_answer_keys',
+  /** The delivery projection. It cannot join the key table, by construction. */
+  questionDelivery: 'v_question_delivery',
+  explanations: 'explanations',
+  questionReports: 'question_reports',
+
+  // 0003_search
+  questionsFts: 'questions_fts',
+
+  // 0004_assessment
+  mockTestTemplates: 'mock_test_templates',
+  /** ONE table for every sitting: mock, practice, SRS, bookmark and weak-area. */
+  attempts: 'attempts',
+  attemptQuestions: 'attempt_questions',
+  attemptAnswers: 'attempt_answers',
+
+  // 0005_learning
+  bookmarks: 'bookmarks',
+  srsState: 'srs_state',
+  studySessions: 'study_sessions',
+  streaks: 'streaks',
+  userQuestionStats: 'user_question_stats',
+
+  // 0006_engagement. Written only by the scheduled jobs in src/jobs/ and read
+  // by the leaderboard and notification endpoints; never computed on a
+  // request path.
+  leaderboardSnapshots: 'leaderboard_snapshots',
+  leaderboardEntries: 'leaderboard_entries',
+  notifications: 'notifications',
+
+  // 0008_api_infrastructure
+  idempotencyKeys: 'idempotency_keys',
+  rateLimits: 'rate_limits',
+} as const;
+
+/**
+ * RECONCILIATION RECORD -- what changed, and which side moved.
+ *
+ * Kept because the next reader will find two sets of names in the git history
+ * and deserve to know which one won and why, rather than inferring it.
+ *
+ * TIMESTAMPS: MILLISECONDS, and the SQL moved. The migrations defaulted every
+ * timestamp to `unixepoch()` (whole seconds) while this Worker was milliseconds
+ * end to end. This was the highest-risk delta precisely because it is silent:
+ * a 45-minute deadline stored as seconds and compared against `Date.now()` is
+ * 45,000 times too small, so every candidate would be handed an expired paper
+ * and nothing would throw. Milliseconds won because every consumer is
+ * JavaScript -- `Date.now()`, the `EpochMs` wire type, and the client's own
+ * response log, quiz drafts and mock `endsAt` are all already milliseconds --
+ * so converting at the boundary would have added a conversion to every read
+ * and write for no benefit. The default is now
+ * `CAST(unixepoch('subsec') * 1000 AS INTEGER)` and `db/smoke.mjs` asserts
+ * that a round-tripped 45-minute deadline is still in the future.
+ *
+ * ANSWER KEY: `question_answer_keys`, and this API moved. It assumed
+ * `question_options.is_correct`. The separate table is stronger and the
+ * isolation is the whole point of the backend: `questions` has no answer
+ * column and `question_options` has none either, so
+ * `SELECT * FROM questions JOIN question_options` CANNOT leak the key -- it
+ * takes naming a third table in a FROM clause, which is a greppable,
+ * reviewable, testable event. `loadAnswerKey` is the one function that does.
+ *
+ * OPTION IDS: no longer ordinal-bearing, and the SQL moved. Both authors found
+ * the same hole independently: ids were `question_id || '#' || ordinal`, and
+ * `frontend/public/data/books/*.json` publishes `correct_option_index` and is
+ * in git history forever, so any option id reaching a client recovered the
+ * whole key with no database access -- and per-attempt permutation was no
+ * defence, because the ordinal travelled inside the id rather than as a
+ * position. `opt_key` is now 12 CSPRNG base32 characters. The keyed
+ * `browseOptionRef` and the per-attempt refs stay as defence in depth; they
+ * were never the problem, they were the patch over it.
+ *
+ * ATTEMPTS: one table, and this API moved. It had `mock_attempts` +
+ * `practice_sessions` with parallel question and answer tables either side.
+ * The unified `attempts` with a `mode` column is better and
+ * `readAttemptHistory` stops being a UNION ALL. `attempts.id` is an INTEGER
+ * rowid and `public_id` is the ULID in URLs; `data/attempts.ts` resolves
+ * `public_id` -> `id` once per request and never emits the integer, which is
+ * enumerable. The two columns the API needed for a pre-deadline snapshot --
+ * `synced_answers`, `last_sync_at` -- were added to `attempts`, with a CHECK
+ * that the snapshot cannot be stamped past the deadline.
+ *
+ * ROLLUPS: the triggers do it, and this API moved. `user_question_stats` and
+ * `attempts.answered_count`/`correct_count` are maintained by the triggers in
+ * 0005, which run inside the statement that writes the answer and so cost
+ * nothing against D1's 50-queries-per-invocation budget. Three hand-written
+ * upsert statements went away with them. `user_chapter_stats` is gone: NQ-27
+ * groups `user_question_stats` by its denormalised `chapter_id` in one covering
+ * index scan. `user_daily_activity` is gone: `streaks` (NQ-32a, idempotent per
+ * local day) plus `study_sessions.local_date` do the same job in the user's own
+ * timezone, which UTC-keyed day buckets could not.
+ *
+ * NAMES: `srs_state` not `srs_cards`, `admin_audit_log` not `audit_log`,
+ * `mock_test_templates` not `mock_templates`, `question_options.text` not
+ * `.body`, `question_options.ordinal` not `.position`. `subjects` and
+ * `subchapters` had no equivalent here and are kept.
+ *
+ * BLUEPRINT: sub-chapter level, and the SQL moved. The API's
+ * `mock_template_blueprint` was chapter-level rows; the schema's `blueprint`
+ * JSON was chapter-level rules. `frontend/src/data/examBlueprint.ts` is right:
+ * the official syllabus is 10 chapters x 6 sub-chapters and the frontend models
+ * 60 quotas by largest remainder. The blueprint is now version 2 with 60 rules,
+ * `domain/blueprint.ts` allocates them with the same documented fallback, and
+ * `generate-reference-sql.mjs` derives 0007 from the same rule so the two
+ * cannot drift.
+ *
+ * SRS: FSRS's vocabulary, and this API moved. `srs_state` already carried
+ * `stability`, `difficulty`, `elapsed_days` and `scheduled_days` -- the
+ * columns `frontend/src/services/scheduler.ts` wants -- so `domain/srs.ts`
+ * speaks them instead of SM-2's `ease` and `interval_days`. `revision` is
+ * `reps`, which every applied review increments.
+ *
+ * SESSIONS: `sessions.id` is the SHA-256 hex of the cookie value, and this API
+ * moved. It stored the cookie value itself, so a database dump yielded usable
+ * session cookies. The schema also splits idle `expires_at` from
+ * `absolute_expires_at`, so a stolen cookie cannot be renewed indefinitely;
+ * `touchSessionStatement` slides the former and clamps it to the latter.
+ *
+ * IDENTITY: `users.email` is nullable with `is_anonymous`, and the SQL moved.
+ * `NOT NULL` left nowhere to put an anonymous guest, and guests are not a
+ * nice-to-have on this product -- the entire current UX is "type a name and
+ * start practising", and a server-scored mock with a server-authored deadline
+ * is only possible if the sitting belongs to a real row. `display_name` lives
+ * on `user_profiles`, which is the half of a user with no credential in it, so
+ * `createUser` writes both rows in one batch.
+ *
+ * FOUR TABLES ADDED for this API: `oauth_accounts` and `oauth_states` in 0001
+ * (they are identity), `idempotency_keys` and `rate_limits` in a new
+ * `0008_api_infrastructure.sql` (they are HTTP-layer state). The DDL proposed
+ * here was reviewed rather than taken as-is; what changed is in the file.
+ *
+ * STILL OPEN, and deliberately not papered over:
+ *
+ *   * `questions.subchapter_id` is now populated for about two thirds of the
+ *     bank by the deterministic classifier (migration 0009), which is enough
+ *     for every rule of all three shipped templates to be satisfied without
+ *     fallback. It stays OPEN because those labels are heuristic, recorded as
+ *     `subchapter_source = 'heuristic'`: `strict_subchapter` should not be
+ *     turned on against machine labels, and the contributor workflow that
+ *     confirms or corrects them (NQ-38b) is still unbuilt.
+ *   * The outbox in `frontend/src/services/api.ts` uses localStorage where
+ *     `responseLog.ts` already has an IndexedDB store whose `rid` is
+ *     documented as a cross-device merge key -- i.e. an idempotency key. That
+ *     is a frontend change and is out of this change's scope.
+ *   * `ResponseRecord.chosenIndex` in `responseLog.ts` is an INDEX into the
+ *     presented options. Against this API it has to become a ref, or a stored
+ *     record cannot be replayed.
+ *   * Practice-mode vocabulary still differs between `shared/types.ts`
+ *     (`chapter|bookmarks|srs|wrong|custom`), `attempts.mode`
+ *     (`practice|mock|srs|bookmark_review|weak_areas`) and the client's
+ *     `responseLog.PRACTICE_MODES`. `attempts.mode` has the CHECK, so it wins;
+ *     `data/attempts.ts#modeForPractice` is the one place that maps.
+ *   * `lib/permute.ts` still duplicates
+ *     `frontend/src/services/optionOrdering.ts`. The server copy is now
+ *     authoritative and uses `question_options.is_pinned` rather than the
+ *     regex; the client copy should become presentation-only.
+ */
+export const SCHEMA_RECONCILED_VERSION = '2026-10-20.2';
diff --git a/worker/src/domain/blueprint.ts b/worker/src/domain/blueprint.ts
new file mode 100644
index 0000000..77e7760
--- /dev/null
+++ b/worker/src/domain/blueprint.ts
@@ -0,0 +1,219 @@
+/**
+ * Paper selection. Pure, so the picking policy is testable without a database.
+ *
+ * The blueprint is SERVER data: the client names a template id and nothing
+ * else. It cannot ask for a shorter paper, for questions from one easy chapter,
+ * or for a specific question it has already seen the answer to.
+ *
+ * ===========================================================================
+ * THE BLUEPRINT IS SUB-CHAPTER LEVEL
+ * ===========================================================================
+ *
+ * The official NEC syllabus for Computer Engineering publishes 10 chapters of
+ * exactly 6 sub-chapters each -- 60 codes -- and
+ * `frontend/src/data/examBlueprint.ts` already models a 100-question paper at
+ * that granularity under a documented rule
+ * (`equal-chapter-weight-largest-remainder`: 10 per chapter, split 2/2/2/2/1/1
+ * across its six codes). This module used to allocate per CHAPTER, which
+ * matched neither the syllabus nor the client. It now takes the 60 rules the
+ * template stores and spends them, with the SAME two-pass fallback the frontend
+ * planner uses:
+ *
+ *   pass 1  satisfy each rule from questions actually TAGGED with its
+ *           sub-chapter, in full, before any fallback -- so the result does not
+ *           depend on rule iteration order;
+ *   pass 2  top up each rule's deficit from its chapter's pool, and record the
+ *           rule as APPROXIMATED.
+ *
+ * Pass 1 draws for real as of migration 0009. The source JSON has no syllabus
+ * field, so `questions.subchapter_id` was NULL for all 2,290 imported
+ * questions and every rule was approximated -- the paper was chapter-level in
+ * all but name. The importer now classifies each question with the
+ * deterministic term-matching classifier the app uses, which labels about two
+ * thirds of the bank and declines the rest, and all 60 sub-chapters are
+ * populated well enough that every rule of all three shipped templates is
+ * satisfied from pass 1 alone.
+ *
+ * Two things follow, and neither is a detail:
+ *
+ *   * Those labels are HEURISTIC. `questions.subchapter_source` says so, and a
+ *     paper built from them is only as well-balanced as the classifier is
+ *     accurate. This planner does not read `subchapter_source` -- requiring
+ *     human labels would empty pass 1 again -- so if that policy is ever
+ *     wanted, it belongs in `drawBlueprintPools`, not here.
+ *   * The decline rate is not a shortfall. A declined question keeps its
+ *     chapter, so it stays available to pass 2 exactly as before.
+ *
+ * `approximatedSubchapterCodes` still reports whatever pass 2 has to cover, so
+ * a term-list regression that empties a sub-chapter shows up as approximation
+ * rather than as a silently worse paper.
+ *
+ * A chapter that cannot fill its quota contributes what it has and is recorded
+ * in `shortfalls`. This matches what the app does today
+ * (`loadQuestionsSlice` takes `min(count, available)`): chapters 5, 6, 7 and 9
+ * hold only 64-71 questions each, so a hard failure here would take every mock
+ * test offline for a content gap in one chapter. The caller refuses only a
+ * completely empty paper, and the attempt records the ACTUAL question count so
+ * scoring is never out of a number the paper did not contain.
+ */
+
+export interface BlueprintRule {
+  chapterId: string;
+  /** Official NEC syllabus code, e.g. '1.1'. `null` for a chapter-wide rule. */
+  subchapterCode: string | null;
+  questionCount: number;
+}
+
+/** Published questions carrying a given sub-chapter tag. Empty today. */
+export interface SubchapterPool {
+  subchapterCode: string;
+  questionIds: readonly string[];
+}
+
+/** Published questions in a chapter, for the fallback top-up. */
+export interface ChapterPool {
+  chapterId: string;
+  /** Ids of published questions in this chapter, in any order. */
+  questionIds: readonly string[];
+}
+
+export interface PaperPick {
+  questionId: string;
+  chapterId: string;
+  /** The rule this pick was drawn for, or `null` for a chapter-wide rule. */
+  subchapterCode: string | null;
+  /** `true` when it came from the chapter pool rather than a tagged question. */
+  approximated: boolean;
+  /** 1-based position on the assembled paper. */
+  position: number;
+}
+
+export interface PaperShortfall {
+  chapterId: string;
+  subchapterCode: string | null;
+  requested: number;
+  /** Tagged questions available for this rule. */
+  availableTagged: number;
+  /** What the rule actually raised, tagged plus fallback. */
+  planned: number;
+}
+
+export interface SelectedPaper {
+  picks: PaperPick[];
+  shortfalls: PaperShortfall[];
+  requestedTotal: number;
+  /** Rules whose quota was partly or wholly satisfied at chapter level. */
+  approximatedSubchapterCodes: string[];
+}
+
+/**
+ * Draws each rule's quota, then shuffles the whole paper so chapters and
+ * sub-chapters are interleaved.
+ *
+ * `shuffle` is injected so the tests can make selection deterministic; in
+ * production it is `cryptoShuffle`.
+ *
+ * `strictSubchapter` disables the chapter-level fallback entirely, which turns
+ * an untagged bank into 60 shortfalls. It exists so the flag in the stored
+ * blueprint means something; it must stay false until tagging coverage is real.
+ */
+export function selectPaper(args: {
+  blueprint: readonly BlueprintRule[];
+  subchapterPools: readonly SubchapterPool[];
+  chapterPools: readonly ChapterPool[];
+  shuffle: <T>(xs: readonly T[]) => T[];
+  strictSubchapter?: boolean;
+}): SelectedPaper {
+  const strict = args.strictSubchapter ?? false;
+
+  const taggedByCode = new Map<string, readonly string[]>();
+  for (const pool of args.subchapterPools) {
+    taggedByCode.set(pool.subchapterCode, pool.questionIds);
+  }
+
+  // Shuffled once per chapter, then consumed with a cursor, so two rules for
+  // the same chapter cannot be handed the same question.
+  const chapterQueue = new Map<string, string[]>();
+  for (const pool of args.chapterPools) {
+    chapterQueue.set(pool.chapterId, args.shuffle(pool.questionIds));
+  }
+
+  /** Every question already on the paper, so the two pools cannot overlap. */
+  const taken = new Set<string>();
+
+  const drawn: Array<Omit<PaperPick, 'position'>> = [];
+  const shortfalls: PaperShortfall[] = [];
+  const approximatedSubchapterCodes: string[] = [];
+  let requestedTotal = 0;
+
+  // ---- pass 1: tagged questions, in full, for every rule ------------------
+  const fromTagged: number[] = [];
+  args.blueprint.forEach((rule, ruleIndex) => {
+    fromTagged[ruleIndex] = 0;
+    if (rule.questionCount <= 0 || rule.subchapterCode === null) return;
+    const pool = taggedByCode.get(rule.subchapterCode) ?? [];
+    for (const questionId of args.shuffle(pool)) {
+      if (fromTagged[ruleIndex] >= rule.questionCount) break;
+      if (taken.has(questionId)) continue;
+      taken.add(questionId);
+      drawn.push({
+        questionId,
+        chapterId: rule.chapterId,
+        subchapterCode: rule.subchapterCode,
+        approximated: false,
+      });
+      fromTagged[ruleIndex]++;
+    }
+  });
+
+  // ---- pass 2: top up each deficit from the chapter pool ------------------
+  args.blueprint.forEach((rule, ruleIndex) => {
+    if (rule.questionCount <= 0) return;
+    requestedTotal += rule.questionCount;
+
+    const tagged = fromTagged[ruleIndex] ?? 0;
+    const availableTagged =
+      rule.subchapterCode === null ? 0 : (taggedByCode.get(rule.subchapterCode) ?? []).length;
+    let deficit = rule.questionCount - tagged;
+    let fallback = 0;
+
+    if (deficit > 0 && !strict) {
+      const queue = chapterQueue.get(rule.chapterId) ?? [];
+      while (deficit > 0 && queue.length > 0) {
+        const questionId = queue.pop() as string;
+        if (taken.has(questionId)) continue;
+        taken.add(questionId);
+        drawn.push({
+          questionId,
+          chapterId: rule.chapterId,
+          subchapterCode: rule.subchapterCode,
+          approximated: true,
+        });
+        fallback++;
+        deficit--;
+      }
+    }
+
+    if (fallback > 0 && rule.subchapterCode !== null) {
+      approximatedSubchapterCodes.push(rule.subchapterCode);
+    }
+
+    const planned = tagged + fallback;
+    if (planned < rule.questionCount) {
+      shortfalls.push({
+        chapterId: rule.chapterId,
+        subchapterCode: rule.subchapterCode,
+        requested: rule.questionCount,
+        availableTagged,
+        planned,
+      });
+    }
+  });
+
+  const picks = args.shuffle(drawn).map((pick, index) => ({
+    ...pick,
+    position: index + 1,
+  }));
+
+  return { picks, shortfalls, requestedTotal, approximatedSubchapterCodes };
+}
diff --git a/worker/src/domain/expiry.ts b/worker/src/domain/expiry.ts
new file mode 100644
index 0000000..920ef9b
--- /dev/null
+++ b/worker/src/domain/expiry.ts
@@ -0,0 +1,128 @@
+/**
+ * The expiry clamp. Pure, so it is unit-testable against a wound-forward clock
+ * rather than a sleep.
+ *
+ * THE ATTACK IT DEFEATS. In the implementation this replaces, the timer was a
+ * client `setInterval` and the deadline lived in localStorage, so pausing the
+ * tab, editing the stored `endsAt`, or simply breaking in the debugger bought
+ * unlimited time. Moving the countdown display to the server's `expiresAt` is
+ * NOT a fix on its own: the display is cosmetic, and a client can always hold
+ * its submission back and keep working.
+ *
+ * THE RULE. A mock answer counts only if the SERVER received it before the
+ * deadline. That is the only claim the server can actually verify, so it is the
+ * only one the scoring trusts.
+ *
+ * - While the attempt is live, the client pushes its answer map to
+ *   `POST /api/mock/sync`. The UPDATE carries `AND ?now <= expires_at`, so the
+ *   stored snapshot is by construction a pre-deadline state.
+ * - On `POST /api/mock/submit` inside the grace window, the submitted payload
+ *   is scored - the normal path.
+ * - On a submission after the grace window, the payload is DISCARDED and the
+ *   last stored snapshot is scored instead. Stalling therefore cannot gain a
+ *   single mark; it can only lose the answers that were never synced.
+ *
+ * No client timestamp appears anywhere in this file. There is deliberately no
+ * `answeredAt` field on the wire, because a client-asserted answer time is
+ * exactly the thing a cheater would forge, and accepting one would reintroduce
+ * the hole through a different door.
+ */
+
+/**
+ * Slack for network latency and client clock skew on an honest submission sent
+ * right on the buzzer. Ten seconds is worth roughly two questions of guessing
+ * on a 45-minute paper, which is within the noise of the paper itself, and it
+ * is short enough that it cannot be used as extra working time.
+ */
+export const SUBMIT_GRACE_MS = 10_000;
+
+export type SubmissionTiming = 'on_time' | 'expired';
+
+export interface AnswerMap {
+  readonly [questionId: string]: string;
+}
+
+export interface ClampInput {
+  /** Server clock. Never a client-supplied value. */
+  now: number;
+  startedAt: number;
+  /** Server-authored at start and immutable thereafter. */
+  expiresAt: number;
+  /** The answers in the submit payload. */
+  submitted: AnswerMap;
+  /** The last snapshot the server accepted strictly before `expiresAt`. */
+  syncedSnapshot: AnswerMap | null;
+  graceMs?: number;
+}
+
+export interface ClampResult {
+  timing: SubmissionTiming;
+  /** The answers that will actually be scored. */
+  answers: AnswerMap;
+  /** `min(now, expiresAt)` - the instant the paper was frozen. */
+  scoredAt: number;
+  /** Entries in `submitted` that the clamp refused to honour. */
+  droppedLateAnswers: number;
+  /** Whether the payload was scored (false means the snapshot was). */
+  usedPayload: boolean;
+  remainingMs: number;
+}
+
+export function clampSubmission(input: ClampInput): ClampResult {
+  const grace = input.graceMs ?? SUBMIT_GRACE_MS;
+  const scoredAt = Math.min(input.now, input.expiresAt);
+  const remainingMs = Math.max(0, input.expiresAt - input.now);
+  const onTime = input.now <= input.expiresAt + grace;
+
+  if (onTime) {
+    return {
+      timing: 'on_time',
+      answers: input.submitted,
+      scoredAt,
+      droppedLateAnswers: 0,
+      usedPayload: true,
+      remainingMs,
+    };
+  }
+
+  const snapshot = input.syncedSnapshot ?? {};
+
+  // Count what the clamp cost the candidate, so the result screen can say so
+  // rather than silently showing a lower score than they expected. An entry is
+  // "dropped" when the payload carries a selection the pre-deadline snapshot
+  // does not already agree with.
+  let dropped = 0;
+  for (const questionId of Object.keys(input.submitted)) {
+    if (snapshot[questionId] !== input.submitted[questionId]) dropped++;
+  }
+
+  return {
+    timing: 'expired',
+    answers: snapshot,
+    scoredAt,
+    droppedLateAnswers: dropped,
+    usedPayload: false,
+    remainingMs: 0,
+  };
+}
+
+/**
+ * Whether a sync may be stored. The same predicate is ALSO expressed as a WHERE
+ * clause on the UPDATE (see `data/mock.ts`), so a race between this check and
+ * the write cannot let a post-deadline snapshot through. This copy exists to
+ * give the endpoint an honest `reason` to report.
+ */
+export function syncDecision(args: {
+  now: number;
+  expiresAt: number;
+  status: string;
+}): { accepted: boolean; reason?: 'past_deadline' | 'not_in_progress' } {
+  if (args.status !== 'in_progress') return { accepted: false, reason: 'not_in_progress' };
+  if (args.now > args.expiresAt) return { accepted: false, reason: 'past_deadline' };
+  return { accepted: true };
+}
+
+/** The deadline for an attempt started now. Server-side only. */
+export function deadlineFor(startedAt: number, durationSeconds: number): number {
+  return startedAt + durationSeconds * 1000;
+}
diff --git a/worker/src/domain/scoring.ts b/worker/src/domain/scoring.ts
new file mode 100644
index 0000000..462cce3
--- /dev/null
+++ b/worker/src/domain/scoring.ts
@@ -0,0 +1,186 @@
+/**
+ * Scoring. Pure: paper in, key in, answers in, result out.
+ *
+ * The answer key reaches this function from a D1 join on
+ * `question_options.is_correct` and leaves it only inside the review payload the
+ * caller builds afterwards. No part of the key is ever present in a request, so
+ * there is nothing for a client to tamper with: a submission consists of
+ * question ids and opaque option refs, and both are checked against the paper
+ * that the server itself wrote at start.
+ */
+
+import type { AnswerMap } from './expiry.ts';
+
+export interface PaperQuestion {
+  questionId: string;
+  chapterId: string;
+  /** 1-based position on this paper. */
+  position: number;
+  /** `question_options.id`, in the per-attempt permuted order. */
+  optionOrder: readonly string[];
+  /** Opaque per-attempt tokens, parallel to `optionOrder`. */
+  optionRefs: readonly string[];
+}
+
+/** One row of the key, as joined from `question_options`. */
+export interface KeyEntry {
+  questionId: string;
+  correctOptionId: string;
+}
+
+export interface ScoredQuestion {
+  questionId: string;
+  chapterId: string;
+  position: number;
+  selectedOptionId: string | null;
+  selectedRef: string | null;
+  correctOptionId: string;
+  correctRef: string;
+  isCorrect: boolean;
+  answered: boolean;
+}
+
+export interface ScoreResult {
+  /** One entry per scorable question on the paper, in paper order. */
+  questions: ScoredQuestion[];
+  total: number;
+  correct: number;
+  incorrect: number;
+  skipped: number;
+  accuracyPct: number;
+  /** Submitted ids that are not on this paper. */
+  rejectedQuestionIds: string[];
+  /** Submitted refs that do not belong to the named question on this paper. */
+  unknownRefQuestionIds: string[];
+  /**
+   * Questions dropped because the bank's key does not point at any option on
+   * the paper. The authored bank genuinely contains these - see
+   * `frontend/src/data/quarantine.json` - and they are excluded from `total`
+   * rather than silently marked wrong, which would punish the candidate for a
+   * content bug.
+   */
+  unscorableQuestionIds: string[];
+}
+
+export interface ScoreOptions {
+  /**
+   * `true` for a live submission: an off-paper question id or an unresolvable
+   * option ref is a hard error for the caller to turn into a 422.
+   *
+   * `false` for the stored pre-deadline snapshot on the expired path: that data
+   * was already validated when it was synced, and refusing to score a paper
+   * because one stale entry no longer resolves would penalise a candidate who
+   * merely ran out of time.
+   */
+  strict: boolean;
+}
+
+/** Resolves one opaque ref to a `question_options.id` on this paper. */
+export function resolveOptionRef(
+  question: PaperQuestion,
+  ref: string,
+): string | null {
+  const index = question.optionRefs.indexOf(ref);
+  if (index < 0) return null;
+  return question.optionOrder[index] ?? null;
+}
+
+/** The ref a client would have seen for a given option on this paper. */
+export function refForOption(
+  question: PaperQuestion,
+  optionId: string,
+): string | null {
+  const index = question.optionOrder.indexOf(optionId);
+  if (index < 0) return null;
+  return question.optionRefs[index] ?? null;
+}
+
+export function scorePaper(args: {
+  paper: readonly PaperQuestion[];
+  key: readonly KeyEntry[];
+  answers: AnswerMap;
+  options: ScoreOptions;
+}): ScoreResult {
+  const { paper, key, answers } = args;
+
+  const keyByQuestion = new Map<string, string>();
+  for (const entry of key) keyByQuestion.set(entry.questionId, entry.correctOptionId);
+
+  const paperById = new Map<string, PaperQuestion>();
+  for (const q of paper) paperById.set(q.questionId, q);
+
+  const rejectedQuestionIds: string[] = [];
+  for (const questionId of Object.keys(answers)) {
+    if (!paperById.has(questionId)) rejectedQuestionIds.push(questionId);
+  }
+
+  const unknownRefQuestionIds: string[] = [];
+  const unscorableQuestionIds: string[] = [];
+  const questions: ScoredQuestion[] = [];
+
+  let correct = 0;
+  let answered = 0;
+
+  for (const q of paper) {
+    const correctOptionId = keyByQuestion.get(q.questionId);
+    const correctRef =
+      correctOptionId === undefined ? null : refForOption(q, correctOptionId);
+
+    // The key is missing, or points at an option that is not on this paper.
+    if (correctOptionId === undefined || correctRef === null) {
+      unscorableQuestionIds.push(q.questionId);
+      continue;
+    }
+
+    const submittedRef = Object.prototype.hasOwnProperty.call(answers, q.questionId)
+      ? answers[q.questionId]
+      : undefined;
+
+    let selectedOptionId: string | null = null;
+    let selectedRef: string | null = null;
+
+    if (submittedRef !== undefined) {
+      const resolved = resolveOptionRef(q, submittedRef);
+      if (resolved === null) {
+        // A ref that does not belong to this question on this attempt. Either a
+        // stale client, or someone replaying a ref harvested from a different
+        // attempt. Neither is scorable.
+        unknownRefQuestionIds.push(q.questionId);
+      } else {
+        selectedOptionId = resolved;
+        selectedRef = submittedRef;
+        answered++;
+      }
+    }
+
+    const isCorrect = selectedOptionId !== null && selectedOptionId === correctOptionId;
+    if (isCorrect) correct++;
+
+    questions.push({
+      questionId: q.questionId,
+      chapterId: q.chapterId,
+      position: q.position,
+      selectedOptionId,
+      selectedRef,
+      correctOptionId,
+      correctRef,
+      isCorrect,
+      answered: selectedOptionId !== null,
+    });
+  }
+
+  const total = questions.length;
+  const skipped = total - answered;
+
+  return {
+    questions,
+    total,
+    correct,
+    incorrect: answered - correct,
+    skipped,
+    accuracyPct: total === 0 ? 0 : Math.round((correct / total) * 100),
+    rejectedQuestionIds,
+    unknownRefQuestionIds,
+    unscorableQuestionIds,
+  };
+}
diff --git a/worker/src/domain/srs.ts b/worker/src/domain/srs.ts
new file mode 100644
index 0000000..fb523d0
--- /dev/null
+++ b/worker/src/domain/srs.ts
@@ -0,0 +1,213 @@
+/**
+ * Spaced repetition scheduling.
+ *
+ * Pure, and the server is the only place it runs: the due queue and the next
+ * interval are server state, so a client cannot bring a card forward to farm an
+ * easy session, and the schedule survives a cleared browser.
+ *
+ * ===========================================================================
+ * FSRS'S VOCABULARY, SM-2'S ARITHMETIC
+ * ===========================================================================
+ *
+ * The columns are FSRS's -- `stability`, `difficulty`, `elapsed_days`,
+ * `scheduled_days`, `reps`, `lapses`, `state`, `due`, `last_review` -- because
+ * that is what `srs_state` stores (migrations/0005_learning.sql) and what
+ * `frontend/src/services/scheduler.ts` already carries on its own `Card`. This
+ * module used to speak SM-2's `ease` and `interval_days` instead, and the
+ * mapping between the two was the problem: `ease` is a multiplier in
+ * [1.3, 2.8] where `difficulty` is a 1..10 scale with the OPPOSITE sense, so
+ * every read and write would have had to apply an affine transform, and
+ * `applySrsReview` reads a card and writes it straight back -- so the rounding
+ * would compound on every single review.
+ *
+ * What is NOT claimed: this is not FSRS. The update rules below are a trimmed
+ * SM-2 re-expressed over `difficulty`, because FSRS needs `pow` and `exp` and
+ * D1 does not guarantee SQLite's math functions, and because a real FSRS
+ * implementation with fitted parameters is a separate piece of work. The point
+ * of speaking FSRS's field names now is that dropping the real scheduler in
+ * later is a change to THIS file and nothing else -- no migration, no wire
+ * change, no translation layer.
+ *
+ * `difficulty` is 1..10 and HIGHER IS HARDER, which is the opposite sense to
+ * SM-2's ease. Getting that backwards would make every lapse lengthen the
+ * interval, so the CHECK in the migration bounds it and the tests pin the
+ * direction.
+ */
+
+import { DAY } from '../lib/time.ts';
+import type { SrsGrade, SrsState } from '../shared/types.ts';
+
+export interface CardState {
+  dueAt: number;
+  /** Days until recall probability decays to 90%. */
+  stability: number;
+  /** 1..10, HIGHER IS HARDER. */
+  difficulty: number;
+  /** The interval the scheduler last asked for, in days. */
+  scheduledDays: number;
+  /** Real days between `lastReview` and the review being applied. */
+  elapsedDays: number;
+  reps: number;
+  lapses: number;
+  state: SrsState;
+  /** `srs_state.reps` at the time this card was read. The CAS token. */
+  revision: number;
+  /** `null` until the first review. `reps = 0` implies this is null. */
+  lastReviewAt: number | null;
+}
+
+/** The neutral starting difficulty, matching the column default. */
+export const NEW_CARD_DIFFICULTY = 5;
+const MIN_DIFFICULTY = 1;
+const MAX_DIFFICULTY = 10;
+/** Ten years. Keeps `dueAt` inside a sane integer range. */
+const MAX_SCHEDULED_DAYS = 3650;
+/** A lapse comes back in ten minutes, not tomorrow. */
+const RELEARN_DELAY_MS = 10 * 60 * 1000;
+
+/** A card for a question the user has never been scheduled on. */
+export function newCard(now: number): CardState {
+  return {
+    dueAt: now,
+    stability: 0,
+    difficulty: NEW_CARD_DIFFICULTY,
+    scheduledDays: 0,
+    elapsedDays: 0,
+    reps: 0,
+    lapses: 0,
+    state: 'new',
+    revision: 0,
+    lastReviewAt: null,
+  };
+}
+
+/**
+ * How each grade moves `difficulty`. Signs are the point: a failed review
+ * makes the item HARDER for this user, which SHORTENS the next interval.
+ */
+const DIFFICULTY_DELTA: Record<SrsGrade, number> = {
+  again: 1.2,
+  hard: 0.6,
+  good: 0,
+  easy: -0.6,
+};
+
+/** 1..4, as `srs_state.last_rating` stores it. */
+export const RATING_BY_GRADE: Record<SrsGrade, number> = {
+  again: 1,
+  hard: 2,
+  good: 3,
+  easy: 4,
+};
+
+export const STATE_CODE: Record<SrsState, number> = {
+  new: 0,
+  learning: 1,
+  review: 2,
+  relearning: 3,
+};
+
+export function stateFromCode(code: number): SrsState {
+  switch (code) {
+    case 1:
+      return 'learning';
+    case 2:
+      return 'review';
+    case 3:
+      return 'relearning';
+    default:
+      // Fail closed on an unrecognised value: 'new' is the state that costs a
+      // user the least if it is wrong.
+      return 'new';
+  }
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+/**
+ * The interval multiplier for a card in `review`.
+ *
+ * Derived from `difficulty` so there is one scale and not two: an easy item
+ * (difficulty 1) multiplies by 2.5, a neutral one (5) by about 1.7, a
+ * maximally hard one (10) by 1.2. Never below 1, because an interval that
+ * shrinks on a CORRECT answer is a scheduler bug, not a conservative choice.
+ */
+function reviewMultiplier(difficulty: number, grade: SrsGrade): number {
+  const base = 1.2 + ((MAX_DIFFICULTY - difficulty) / (MAX_DIFFICULTY - MIN_DIFFICULTY)) * 1.3;
+  const byGrade = grade === 'hard' ? 0.8 : grade === 'easy' ? 1.3 : 1;
+  return Math.max(1, base * byGrade);
+}
+
+/**
+ * Applies one review.
+ *
+ * `again` sends the card to relearning with a ten-minute step rather than
+ * resetting everything: a lapse on a question answered correctly ten times
+ * should cost the interval, not the history. `stability` halves rather than
+ * zeroing, for the same reason.
+ */
+export function review(card: CardState, grade: SrsGrade, now: number): CardState {
+  const difficulty = clamp(
+    card.difficulty + DIFFICULTY_DELTA[grade],
+    MIN_DIFFICULTY,
+    MAX_DIFFICULTY,
+  );
+  const elapsedDays =
+    card.lastReviewAt === null ? 0 : Math.max(0, (now - card.lastReviewAt) / DAY);
+
+  let scheduledDays: number;
+  let state: SrsState;
+  let lapses = card.lapses;
+  let stability: number;
+
+  if (grade === 'again') {
+    lapses += 1;
+    state = 'relearning';
+    scheduledDays = 0;
+    stability = card.stability / 2;
+  } else if (card.state === 'new' || card.reps === 0) {
+    state = 'learning';
+    scheduledDays = grade === 'easy' ? 3 : 1;
+    stability = scheduledDays;
+  } else if (card.state === 'learning' || card.state === 'relearning') {
+    state = 'review';
+    scheduledDays = grade === 'hard' ? 2 : grade === 'good' ? 3 : 5;
+    stability = scheduledDays;
+  } else {
+    state = 'review';
+    const previous = Math.max(1, card.scheduledDays);
+    scheduledDays = Math.round(previous * reviewMultiplier(difficulty, grade));
+    stability = scheduledDays;
+  }
+
+  scheduledDays = clamp(Math.round(scheduledDays), 0, MAX_SCHEDULED_DAYS);
+  stability = clamp(stability, 0, MAX_SCHEDULED_DAYS);
+
+  const dueAt = grade === 'again' ? now + RELEARN_DELAY_MS : now + scheduledDays * DAY;
+  const reps = card.reps + 1;
+
+  return {
+    dueAt,
+    stability,
+    difficulty,
+    scheduledDays,
+    elapsedDays,
+    reps,
+    lapses,
+    state,
+    // `reps` IS the revision: every applied review increments it, so a client
+    // holding a stale value names a card that has already moved on.
+    revision: reps,
+    lastReviewAt: now,
+  };
+}
+
+/**
+ * The grade implied by answering a question in practice or in a mock, so
+ * answering a question anywhere feeds the schedule without a second request.
+ */
+export function gradeFromCorrectness(isCorrect: boolean): SrsGrade {
+  return isCorrect ? 'good' : 'again';
+}
diff --git a/worker/src/domain/streaks.ts b/worker/src/domain/streaks.ts
new file mode 100644
index 0000000..5f3e7cc
--- /dev/null
+++ b/worker/src/domain/streaks.ts
@@ -0,0 +1,73 @@
+/**
+ * Streaks, derived from `study_sessions.local_date`.
+ *
+ * Pure, and day-keyed rather than timestamp-keyed, because a streak is a
+ * calendar fact in the candidate's timezone (UTC+05:45 here) and not a
+ * difference between two instants. See `lib/time.ts#dayKey`.
+ *
+ * WHAT THIS IS AND IS NOT THE SOURCE OF. `streaks.current_length` and
+ * `.longest_length` are the authority: they are maintained by the idempotent
+ * NQ-32a upsert on every answer and ratcheted by a trigger, so they account for
+ * the one-day freeze token that a "count consecutive active days" derivation
+ * cannot see. This function supplies `activeDays` (the heatmap) and
+ * `todayAnswered`, and its streak numbers stand in only when a user has no
+ * `streaks` row yet. `handlers/progress.ts` does that merge.
+ *
+ * It used to read a `user_daily_activity` table that the reconciled schema
+ * does not have, for a good reason: a UTC-keyed day bucket misattributes every
+ * late-night session in Kathmandu to the wrong day, which is precisely the bug
+ * that breaks a streak. `study_sessions.local_date` is written by the API,
+ * which knows the user's timezone.
+ */
+
+import { dayKeyDiff } from '../lib/time.ts';
+import type { DayKey, StreakInfo } from '../shared/types.ts';
+
+export interface ActivityDay {
+  day: DayKey;
+  answered: number;
+}
+
+/**
+ * `days` must be newest-first, which is the order the query returns.
+ *
+ * A streak survives "nothing done yet today": if the most recent active day is
+ * yesterday, the current streak still counts, because the day is not over. It
+ * breaks only once a full day has been skipped.
+ */
+export function computeStreaks(days: readonly ActivityDay[], today: DayKey): StreakInfo {
+  const activeDays = days.map((d) => d.day);
+  const todayAnswered = days.find((d) => d.day === today)?.answered ?? 0;
+
+  let currentStreak = 0;
+  if (days.length > 0) {
+    const gapToNewest = dayKeyDiff(today, days[0].day);
+    if (gapToNewest !== null && gapToNewest <= 1) {
+      currentStreak = 1;
+      for (let i = 1; i < days.length; i++) {
+        const gap = dayKeyDiff(days[i - 1].day, days[i].day);
+        if (gap !== 1) break;
+        currentStreak++;
+      }
+    }
+  }
+
+  let longestStreak = 0;
+  let run = 0;
+  for (let i = 0; i < days.length; i++) {
+    if (i === 0) {
+      run = 1;
+    } else {
+      const gap = dayKeyDiff(days[i - 1].day, days[i].day);
+      run = gap === 1 ? run + 1 : 1;
+    }
+    if (run > longestStreak) longestStreak = run;
+  }
+
+  return {
+    currentStreak,
+    longestStreak: Math.max(longestStreak, currentStreak),
+    todayAnswered,
+    activeDays,
+  };
+}
diff --git a/worker/src/env.ts b/worker/src/env.ts
new file mode 100644
index 0000000..2bceb33
--- /dev/null
+++ b/worker/src/env.ts
@@ -0,0 +1,144 @@
+/**
+ * Worker bindings and configuration.
+ *
+ * Configuration FAILS CLOSED. A missing secret throws at request time with the
+ * name of the variable, rather than falling back to a development default that
+ * would silently ship a predictable permutation secret or an open CORS policy.
+ * The cost is that a misconfigured deployment 500s on every request, which is
+ * the correct failure mode.
+ */
+
+import type { D1Database } from './data/d1.ts';
+import { ApiException } from './shared/errors.ts';
+
+export interface Env {
+  /** The D1 binding. Declared in wrangler.toml by whoever owns that file. */
+  DB: D1Database;
+
+  /** Origin the browser app is served from. Drives CORS and OAuth redirects. */
+  APP_ORIGIN: string;
+
+  /**
+   * Seeds the stable option permutation used by the content-browsing
+   * endpoints. Rotating it reshuffles every browse order, which is harmless.
+   * It must not be guessable: with it, the permutation applied to a given
+   * (user, question) can be reproduced offline and joined against the public
+   * chapter JSON in git history.
+   */
+  CONTENT_PERMUTATION_SECRET: string;
+
+  GOOGLE_CLIENT_ID?: string;
+  GOOGLE_CLIENT_SECRET?: string;
+  /** Must exactly match the authorised redirect URI in Google Cloud console. */
+  GOOGLE_REDIRECT_URI?: string;
+
+  ENVIRONMENT?: string;
+  /** Default 100000. Raise to 600000 on the paid plan. See lib/password.ts. */
+  PASSWORD_HASH_ITERATIONS?: string;
+  /** Default 45. Raise to ~900 on the paid plan (1,000 queries/invocation). */
+  D1_QUERY_BUDGET?: string;
+  /**
+   * Raw-answer retention window in days, read by the retention cron. Default
+   * 90 on the free plan; 180 once on Workers Paid. See the archival note in
+   * migrations/0004_assessment.sql and `src/jobs/index.ts#retentionDays`.
+   */
+  ANSWER_RETENTION_DAYS?: string;
+}
+
+export interface GoogleOAuthConfig {
+  clientId: string;
+  clientSecret: string;
+  redirectUri: string;
+}
+
+export interface Config {
+  appOrigin: string;
+  permutationSecret: string;
+  passwordIterations: number;
+  queryBudget: number;
+  isProduction: boolean;
+  /** `null` when Google OAuth is not configured; those routes then 404. */
+  google: GoogleOAuthConfig | null;
+  /**
+   * Set when SOME but not all of the three Google values were supplied.
+   *
+   * Distinct from `google === null` with no error, which means "deliberately
+   * not configured". A half-configured OAuth app is a mistake someone is
+   * actively making, and the Google routes say so rather than reporting the
+   * feature as absent.
+   */
+  googleConfigError: string | null;
+}
+
+function required(env: Env, key: 'APP_ORIGIN' | 'CONTENT_PERMUTATION_SECRET'): string {
+  const value = env[key];
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new ApiException('INTERNAL', 'Server is not configured.', {
+      internal: `Missing required environment variable ${key}.`,
+    });
+  }
+  return value.trim();
+}
+
+function intOr(raw: string | undefined, fallback: number, min: number, max: number): number {
+  if (raw === undefined) return fallback;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isInteger(n) || n < min || n > max) {
+    throw new ApiException('INTERNAL', 'Server is not configured.', {
+      internal: `Invalid numeric configuration value ${raw}; expected ${min}..${max}.`,
+    });
+  }
+  return n;
+}
+
+export function loadConfig(env: Env): Config {
+  const appOrigin = required(env, 'APP_ORIGIN');
+  const permutationSecret = required(env, 'CONTENT_PERMUTATION_SECRET');
+
+  if (permutationSecret.length < 32) {
+    throw new ApiException('INTERNAL', 'Server is not configured.', {
+      internal: 'CONTENT_PERMUTATION_SECRET must be at least 32 characters.',
+    });
+  }
+
+  // All three Google values or none. A half-configured OAuth app produces a
+  // redirect_uri_mismatch at Google, which is a confusing place to debug it.
+  //
+  // This used to THROW, and that was wrong in a way only a real deployment
+  // showed: `loadConfig` runs in the `/api/*` middleware, so one missing
+  // Google value 500'd every endpoint on the platform — chapters, guest
+  // sign-in, submitting a paper — each reporting "Google OAuth needs...",
+  // which is a baffling thing to read when you asked for a chapter list.
+  //
+  // An optional feature must not be able to take down a required one. The
+  // misconfiguration is recorded instead, and the three Google handlers (which
+  // already guard on `google === null`) are the only place it surfaces.
+  const googleParts = [
+    env.GOOGLE_CLIENT_ID,
+    env.GOOGLE_CLIENT_SECRET,
+    env.GOOGLE_REDIRECT_URI,
+  ];
+  const googleSet = googleParts.filter((p) => typeof p === 'string' && p.trim().length > 0).length;
+  const googleConfigError =
+    googleSet === 0 || googleSet === 3
+      ? null
+      : `Google OAuth needs GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET and ` +
+        `GOOGLE_REDIRECT_URI together, or none of them; ${String(googleSet)} of 3 are set.`;
+
+  return {
+    appOrigin,
+    permutationSecret,
+    passwordIterations: intOr(env.PASSWORD_HASH_ITERATIONS, 100_000, 10_000, 1_000_000),
+    queryBudget: intOr(env.D1_QUERY_BUDGET, 45, 5, 990),
+    isProduction: env.ENVIRONMENT !== 'development',
+    google:
+      googleSet === 3
+        ? {
+            clientId: (env.GOOGLE_CLIENT_ID as string).trim(),
+            clientSecret: (env.GOOGLE_CLIENT_SECRET as string).trim(),
+            redirectUri: (env.GOOGLE_REDIRECT_URI as string).trim(),
+          }
+        : null,
+    googleConfigError,
+  };
+}
diff --git a/worker/src/handlers/auth.ts b/worker/src/handlers/auth.ts
new file mode 100644
index 0000000..eddba02
--- /dev/null
+++ b/worker/src/handlers/auth.ts
@@ -0,0 +1,632 @@
+/**
+ * Authentication handlers.
+ *
+ * Self-hosted, because D1 has no managed auth. Four ways in - anonymous guest,
+ * email + password, Google, and an in-place upgrade from guest to either of the
+ * other two - and all four land on the same `users` row shape and the same
+ * opaque session cookie.
+ *
+ * THE DESIGN DECISION THAT MATTERS MOST is the anonymous guest. A new visitor
+ * gets a real `users` row immediately, so their first mock attempt is written
+ * server-side with a server-side deadline from the very first question. Without
+ * it, the only way to let someone try the product without signing up is to let
+ * the browser own the attempt - which is exactly the hole this whole API exists
+ * to close.
+ */
+
+import { fail } from '../shared/errors.ts';
+import {
+  claimAnonymousForOAuth,
+  createOAuthState,
+  createSession,
+  consumeOAuthState,
+  createUser,
+  findUserByEmail,
+  findUserByOAuthAccount,
+  getUserById,
+  linkOAuthAccount,
+  loadSessionByCookie,
+  loadSessionById,
+  rehashStatement,
+  revokeAllSessionsForUser,
+  revokeSession,
+  SESSION_IDLE_TTL_MS,
+  toSessionUser,
+  touchSessionStatement,
+  upgradeAnonymousUser,
+} from '../data/auth.ts';
+import { consumeRateLimit, RATE_LIMITS } from '../data/infra.ts';
+import { burnPasswordTime, hashPassword, sha256Hex, verifyPassword } from '../lib/password.ts';
+import { randomToken } from '../lib/ids.ts';
+import { clearSessionCookie, serializeSessionCookie } from '../lib/cookies.ts';
+import { ok, requireUser } from './context.ts';
+import type { HandlerContext, HandlerResult } from './context.ts';
+import type { GoogleOAuthConfig } from '../env.ts';
+import type { SessionResponse, SessionUser } from '../shared/types.ts';
+import type {
+  GoogleCallbackInput,
+  LoginInput,
+  SignupInput,
+  UpgradeAnonymousInput,
+} from '../validation/schemas.ts';
+
+const GOOGLE_AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
+const GOOGLE_TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const GOOGLE_USERINFO_URL = 'https://openidconnect.googleapis.com/v1/userinfo';
+
+/**
+ * Canonical email form.
+ *
+ * The request schemas already lowercase and trim, but normalising again here is
+ * defence in depth that matters: this value becomes a UNIQUE key and the lookup
+ * key for every future login. If a caller ever reaches a handler without going
+ * through the schema, a stray capital letter would create a second account for
+ * the same person and make their first one unreachable.
+ */
+function normalizeEmail(raw: string): string {
+  return raw.trim().toLowerCase();
+}
+
+function emitSessionCookie(ctx: HandlerContext, sessionId: string, maxAgeSeconds: number): void {
+  ctx.cookies.push(
+    serializeSessionCookie(sessionId, {
+      maxAgeSeconds,
+      secure: ctx.config.isProduction,
+      sameSite: 'Lax',
+    }),
+  );
+}
+
+async function establishSession(
+  ctx: HandlerContext,
+  userId: string,
+): Promise<{ sessionId: string; expiresAt: number }> {
+  const now = ctx.clock.now();
+  const session = await createSession(ctx.db, {
+    userId,
+    now,
+    userAgent: ctx.meta.userAgent,
+    ipHash: ctx.meta.ipHash,
+  });
+  // THE COOKIE CARRIES `cookieValue`; THE DATABASE HOLDS ITS SHA-256. They are
+  // deliberately different strings, so a dump of `sessions` yields nothing
+  // anyone can sign in with. `ctx.auth.sessionId` is the STORED id, because
+  // that is what revocation and the touch statement address.
+  emitSessionCookie(ctx, session.cookieValue, Math.floor(SESSION_IDLE_TTL_MS / 1000));
+  return { sessionId: session.id, expiresAt: session.expiresAt };
+}
+
+function sessionBody(
+  ctx: HandlerContext,
+  user: SessionUser | null,
+  expiresAt: number | null,
+): SessionResponse {
+  return { user, sessionExpiresAt: expiresAt, serverNow: ctx.clock.now() };
+}
+
+/**
+ * Rate-limit subject for an unauthenticated endpoint.
+ *
+ * Hashed, so the `rate_limits` table never stores a raw IP - it is a bucket
+ * key, not a log, and there is no reason for it to be reversible.
+ */
+function ipSubject(ctx: HandlerContext): string {
+  return ctx.meta.ipHash ?? 'unknown';
+}
+
+/**
+ * GET /api/auth/session - 0 or 1 D1 queries.
+ *
+ * Zero when there is no cookie, since the session middleware does the lookup.
+ * This is the cheapest endpoint in the API on purpose: the client calls it on
+ * every cold start.
+ */
+export async function readSession(
+  ctx: HandlerContext,
+): Promise<HandlerResult<SessionResponse>> {
+  if (!ctx.auth) return ok(sessionBody(ctx, null, null));
+  const session = await loadSessionById(ctx.db, ctx.auth.sessionId, ctx.clock.now());
+  return ok(
+    session
+      ? sessionBody(ctx, toSessionUser(session.user), session.session.expires_at)
+      : sessionBody(ctx, null, null),
+  );
+}
+
+/**
+ * POST /api/auth/anonymous - 3 D1 queries.
+ *
+ * Idempotent in the way that matters: if the caller already has a live session,
+ * it is returned untouched rather than minting a second guest and orphaning the
+ * first one's progress. That makes the endpoint safe to call on every cold
+ * start, which is how the client uses it.
+ */
+export async function startAnonymousSession(
+  ctx: HandlerContext,
+): Promise<HandlerResult<SessionResponse>> {
+  if (ctx.auth) {
+    return ok(sessionBody(ctx, ctx.auth.user, null));
+  }
+
+  const limit = await consumeRateLimit(
+    ctx.db,
+    RATE_LIMITS.anonymous,
+    ipSubject(ctx),
+    ctx.clock.now(),
+  );
+  if (!limit.allowed) {
+    fail('RATE_LIMITED', 'Too many new sessions from this address.', {
+      retryAfterMs: limit.retryAfterMs,
+    });
+  }
+
+  const now = ctx.clock.now();
+  const user = await createUser(ctx.db, {
+    email: null,
+    passwordHash: null,
+    displayName: null,
+    isAnonymous: true,
+    now,
+  });
+  if (!user) fail('INTERNAL', 'Could not create a guest session.');
+
+  const session = await establishSession(ctx, user.id);
+  return ok(sessionBody(ctx, toSessionUser(user), session.expiresAt));
+}
+
+/**
+ * POST /api/auth/signup - 4 D1 queries.
+ *
+ * The email uniqueness check is the partial unique index, not a preceding
+ * SELECT, so two simultaneous signups for the same address cannot both win.
+ */
+export async function signup(
+  ctx: HandlerContext,
+  input: SignupInput,
+): Promise<HandlerResult<SessionResponse>> {
+  const limit = await consumeRateLimit(
+    ctx.db,
+    RATE_LIMITS.signup,
+    ipSubject(ctx),
+    ctx.clock.now(),
+  );
+  if (!limit.allowed) {
+    fail('RATE_LIMITED', 'Too many sign-up attempts. Try again later.', {
+      retryAfterMs: limit.retryAfterMs,
+    });
+  }
+
+  const now = ctx.clock.now();
+  const email = normalizeEmail(input.email);
+  const passwordHash = await hashPassword(input.password, ctx.config.passwordIterations);
+
+  const user = await createUser(ctx.db, {
+    email,
+    passwordHash,
+    displayName: input.displayName ?? null,
+    isAnonymous: false,
+    now,
+  });
+
+  if (!user) fail('EMAIL_IN_USE', 'An account with that email already exists.');
+
+  const session = await establishSession(ctx, user.id);
+  return { status: 201, body: sessionBody(ctx, toSessionUser(user), session.expiresAt) };
+}
+
+/**
+ * POST /api/auth/login - 3 to 5 D1 queries.
+ *
+ * A wrong email runs `burnPasswordTime` before answering. Without that, "no
+ * such user" returns in a fraction of the time a real PBKDF2 verification
+ * takes, and the response latency becomes a user-enumeration oracle - the error
+ * message being deliberately vague would not help.
+ */
+export async function login(
+  ctx: HandlerContext,
+  input: LoginInput,
+): Promise<HandlerResult<SessionResponse>> {
+  const now = ctx.clock.now();
+  const email = normalizeEmail(input.email);
+
+  // Limited per address AND per account, so one attacker cannot lock every
+  // user out by hammering a single IP, and one account cannot be hammered from
+  // a thousand addresses.
+  for (const subject of [ipSubject(ctx), `email:${email}`]) {
+    const limit = await consumeRateLimit(ctx.db, RATE_LIMITS.login, subject, now);
+    if (!limit.allowed) {
+      fail('RATE_LIMITED', 'Too many sign-in attempts. Try again later.', {
+        retryAfterMs: limit.retryAfterMs,
+      });
+    }
+  }
+
+  const user = await findUserByEmail(ctx.db, email);
+
+  if (!user || user.is_anonymous === 1) {
+    await burnPasswordTime(ctx.config.passwordIterations);
+    fail('INVALID_CREDENTIALS', 'That email or password is incorrect.');
+  }
+
+  const check = await verifyPassword(
+    input.password,
+    user.password_hash,
+    ctx.config.passwordIterations,
+  );
+  if (!check.valid) {
+    fail('INVALID_CREDENTIALS', 'That email or password is incorrect.');
+  }
+
+  if (check.needsRehash) {
+    const rehashed = await hashPassword(input.password, ctx.config.passwordIterations);
+    await ctx.db.batch([
+      rehashStatement({ userId: user.id, passwordHash: rehashed, now }),
+    ]);
+  }
+
+  const session = await establishSession(ctx, user.id);
+  return ok(sessionBody(ctx, toSessionUser(user), session.expiresAt));
+}
+
+/** POST /api/auth/logout - 1 D1 query. Idempotent. */
+export async function logout(ctx: HandlerContext): Promise<HandlerResult<{ ok: true }>> {
+  if (ctx.auth) {
+    await revokeSession(ctx.db, ctx.auth.sessionId, ctx.clock.now());
+  }
+  ctx.cookies.push(
+    clearSessionCookie({ secure: ctx.config.isProduction, sameSite: 'Lax' }),
+  );
+  return ok({ ok: true as const });
+}
+
+/**
+ * POST /api/auth/upgrade - 6 D1 queries.
+ *
+ * Turns the CURRENT anonymous session's user into a real account WITHOUT
+ * changing the user id, so every attempt, bookmark, streak and SRS card the
+ * guest accumulated stays attached. That is the whole point of the endpoint:
+ * the alternative - create a new user and migrate - means a multi-table copy
+ * with no transaction to protect it, on a database that has none.
+ *
+ * Idempotent through the `is_anonymous = 1` predicate on the UPDATE: a replay
+ * matches zero rows and gets `NOT_ANONYMOUS` rather than overwriting the
+ * password of an account that has since been claimed.
+ */
+export async function upgradeAnonymous(
+  ctx: HandlerContext,
+  input: UpgradeAnonymousInput,
+): Promise<HandlerResult<SessionResponse>> {
+  const auth = requireUser(ctx);
+  const now = ctx.clock.now();
+
+  const limit = await consumeRateLimit(ctx.db, RATE_LIMITS.upgrade, auth.user.id, now);
+  if (!limit.allowed) {
+    fail('RATE_LIMITED', 'Too many attempts. Try again later.', {
+      retryAfterMs: limit.retryAfterMs,
+    });
+  }
+
+  if (!auth.user.isAnonymous) {
+    fail('NOT_ANONYMOUS', 'This account is already registered.');
+  }
+
+  const passwordHash = await hashPassword(input.password, ctx.config.passwordIterations);
+  const outcome = await upgradeAnonymousUser(ctx.db, {
+    userId: auth.user.id,
+    email: normalizeEmail(input.email),
+    passwordHash,
+    displayName: input.displayName ?? null,
+    now,
+  });
+
+  if (outcome === 'email_taken') {
+    fail('EMAIL_IN_USE', 'An account with that email already exists.');
+  }
+  if (outcome === 'not_anonymous') {
+    fail('NOT_ANONYMOUS', 'This account is already registered.');
+  }
+
+  // Other devices that were sharing the guest session are logged out, because
+  // the identity has changed under them. The current session survives.
+  await revokeAllSessionsForUser(
+    ctx.db,
+    auth.user.id,
+    now,
+    auth.sessionId,
+    'password_change',
+  );
+
+  const user = await getUserById(ctx.db, auth.user.id);
+  if (!user) fail('INTERNAL', 'Account vanished mid-upgrade.');
+
+  return ok(sessionBody(ctx, toSessionUser(user), null));
+}
+
+// --- Google OAuth -----------------------------------------------------------
+
+function base64Url(bytes: Uint8Array): string {
+  let s = '';
+  for (const b of bytes) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+async function pkceChallenge(verifier: string): Promise<string> {
+  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifier));
+  return base64Url(new Uint8Array(digest));
+}
+
+/**
+ * GET /api/auth/google/start - 1 D1 query. Returns a 302.
+ *
+ * Uses PKCE even though this is a confidential client with a secret. The
+ * verifier is stored server-side against the single-use `state`, so an attacker
+ * who intercepts the redirect still cannot redeem the code.
+ */
+/**
+ * The Google config, or the right failure.
+ *
+ * Two different "no": deliberately not configured, and configured wrongly.
+ * Reporting a half-set OAuth app as NOT_FOUND would tell an operator who just
+ * typed two of three secrets that the feature does not exist, which is the
+ * least useful true statement available.
+ */
+function requireGoogle(ctx: HandlerContext): GoogleOAuthConfig {
+  const google = ctx.config.google;
+  if (google) return google;
+  if (ctx.config.googleConfigError) {
+    fail('INTERNAL', 'Google sign-in is misconfigured.', {
+      internal: ctx.config.googleConfigError,
+    });
+  }
+  fail('NOT_FOUND', 'Google sign-in is not configured.');
+}
+
+export async function googleStart(
+  ctx: HandlerContext,
+  redirectTo: string | null,
+): Promise<HandlerResult<{ location: string }>> {
+  const google = requireGoogle(ctx);
+
+  const verifier = randomToken(64);
+  const state = await createOAuthState(ctx.db, {
+    codeVerifier: verifier,
+    // Only a path on our own origin is ever accepted back, so the state cannot
+    // be used to bounce a signed-in user to an attacker's site.
+    redirectTo: redirectTo && redirectTo.startsWith('/') ? redirectTo : null,
+    now: ctx.clock.now(),
+  });
+
+  const params = new URLSearchParams({
+    client_id: google.clientId,
+    redirect_uri: google.redirectUri,
+    response_type: 'code',
+    scope: 'openid email profile',
+    state,
+    code_challenge: await pkceChallenge(verifier),
+    code_challenge_method: 'S256',
+    access_type: 'online',
+    prompt: 'select_account',
+  });
+
+  return { status: 302, body: { location: `${GOOGLE_AUTH_URL}?${params.toString()}` } };
+}
+
+export interface GoogleIdentity {
+  sub: string;
+  email: string;
+  emailVerified: boolean;
+  name: string | null;
+}
+
+export type FetchLike = (
+  input: string,
+  init?: { method?: string; headers?: Record<string, string>; body?: string },
+) => Promise<{ ok: boolean; status: number; json: () => Promise<unknown> }>;
+
+/**
+ * Exchanges the authorisation code for an identity.
+ *
+ * Injectable `fetchImpl` so the callback handler can be tested without
+ * reaching Google. Two subrequests, zero D1 queries.
+ */
+export async function exchangeGoogleCode(
+  ctx: HandlerContext,
+  args: { code: string; codeVerifier: string },
+  fetchImpl: FetchLike,
+): Promise<GoogleIdentity> {
+  const google = requireGoogle(ctx);
+
+  const tokenRes = await fetchImpl(GOOGLE_TOKEN_URL, {
+    method: 'POST',
+    headers: { 'content-type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      code: args.code,
+      client_id: google.clientId,
+      client_secret: google.clientSecret,
+      redirect_uri: google.redirectUri,
+      grant_type: 'authorization_code',
+      code_verifier: args.codeVerifier,
+    }).toString(),
+  });
+
+  if (!tokenRes.ok) {
+    fail('OAUTH_EXCHANGE_FAILED', 'Google sign-in failed. Please try again.', {
+      internal: `Google token endpoint returned ${tokenRes.status}.`,
+    });
+  }
+
+  const token = (await tokenRes.json()) as { access_token?: unknown };
+  if (typeof token.access_token !== 'string') {
+    fail('OAUTH_EXCHANGE_FAILED', 'Google sign-in failed. Please try again.', {
+      internal: 'Google token response had no access_token.',
+    });
+  }
+
+  const userRes = await fetchImpl(GOOGLE_USERINFO_URL, {
+    headers: { authorization: `Bearer ${token.access_token}` },
+  });
+  if (!userRes.ok) {
+    fail('OAUTH_EXCHANGE_FAILED', 'Google sign-in failed. Please try again.', {
+      internal: `Google userinfo endpoint returned ${userRes.status}.`,
+    });
+  }
+
+  const profile = (await userRes.json()) as {
+    sub?: unknown;
+    email?: unknown;
+    email_verified?: unknown;
+    name?: unknown;
+  };
+
+  if (typeof profile.sub !== 'string' || typeof profile.email !== 'string') {
+    fail('OAUTH_EXCHANGE_FAILED', 'Google did not return an email address.');
+  }
+
+  // An unverified Google address must not be allowed to claim an account: it
+  // would be an account-takeover path for any email a user has not verified.
+  if (profile.email_verified !== true) {
+    fail('OAUTH_EXCHANGE_FAILED', 'Your Google email address is not verified.');
+  }
+
+  return {
+    sub: profile.sub,
+    email: profile.email.toLowerCase(),
+    emailVerified: true,
+    name: typeof profile.name === 'string' ? profile.name : null,
+  };
+}
+
+/**
+ * GET /api/auth/google/callback - 4 to 7 D1 queries. Returns a 302.
+ *
+ * Resolution order, and each step exists for a reason:
+ *
+ * 1. An existing `oauth_accounts` link wins. This is the only stable
+ *    identifier Google gives us; an email can be reassigned.
+ * 2. Otherwise an existing user with that VERIFIED email gets the link added,
+ *    so signing up with a password and later using Google does not create a
+ *    second account.
+ * 3. Otherwise, if the caller is currently an anonymous guest, that guest is
+ *    claimed in place and keeps all its progress.
+ * 4. Otherwise a new user is created.
+ */
+export async function googleCallback(
+  ctx: HandlerContext,
+  input: GoogleCallbackInput,
+  fetchImpl: FetchLike,
+): Promise<HandlerResult<{ location: string }>> {
+  // Guard only: this handler reads the config through `exchangeGoogleCode`
+  // below, but it must refuse before touching the OAuth state table.
+  requireGoogle(ctx);
+
+  const now = ctx.clock.now();
+
+  const stored = await consumeOAuthState(ctx.db, input.state, now);
+  if (!stored) {
+    fail('OAUTH_STATE_INVALID', 'That sign-in link has expired. Please try again.');
+  }
+
+  const identity = await exchangeGoogleCode(
+    ctx,
+    { code: input.code, codeVerifier: stored.codeVerifier },
+    fetchImpl,
+  );
+
+  let userId: string | null = null;
+
+  const linked = await findUserByOAuthAccount(ctx.db, 'google', identity.sub);
+  if (linked) {
+    userId = linked.id;
+  } else {
+    const byEmail = await findUserByEmail(ctx.db, identity.email);
+    if (byEmail) {
+      userId = byEmail.id;
+      await linkOAuthAccount(ctx.db, {
+        userId,
+        provider: 'google',
+        providerAccountId: identity.sub,
+        now,
+      });
+    } else if (ctx.auth?.user.isAnonymous) {
+      const claimed = await claimAnonymousForOAuth(ctx.db, {
+        userId: ctx.auth.user.id,
+        email: identity.email,
+        displayName: identity.name,
+        now,
+      });
+      if (claimed) {
+        userId = ctx.auth.user.id;
+        await linkOAuthAccount(ctx.db, {
+          userId,
+          provider: 'google',
+          providerAccountId: identity.sub,
+          now,
+        });
+      }
+    }
+
+    if (!userId) {
+      const created = await createUser(ctx.db, {
+        email: identity.email,
+        passwordHash: null,
+        displayName: identity.name,
+        isAnonymous: false,
+        emailVerified: true,
+        now,
+      });
+      if (!created) fail('EMAIL_IN_USE', 'An account with that email already exists.');
+      userId = created.id;
+      await linkOAuthAccount(ctx.db, {
+        userId,
+        provider: 'google',
+        providerAccountId: identity.sub,
+        now,
+      });
+    }
+  }
+
+  await establishSession(ctx, userId);
+
+  const path = stored.redirectTo ?? '/app';
+  return { status: 302, body: { location: `${ctx.config.appOrigin}${path}` } };
+}
+
+// --- Session middleware support ---------------------------------------------
+
+export interface ResolvedSession {
+  auth: { user: SessionUser; sessionId: string } | null;
+  /** A `last_seen_at` refresh, if one is due. Applied by the middleware. */
+  touch: ReturnType<typeof touchSessionStatement>;
+}
+
+/**
+ * Resolves a cookie into an auth context. 1 D1 query, or 0 without a cookie.
+ *
+ * Called once per request by the middleware. The cookie is HASHED before it is
+ * used as a key, so the stored id and the cookie are never the same string. The
+ * role on the returned user comes from the `users` row, never from the cookie,
+ * so there is nothing a client can edit to escalate -- and `users.status` is in
+ * the lookup's WHERE clause, so a suspended account's existing sessions stop
+ * resolving the moment it is suspended.
+ */
+export async function resolveSession(
+  ctx: Pick<HandlerContext, 'db' | 'clock'>,
+  cookieValue: string | null,
+): Promise<ResolvedSession> {
+  if (!cookieValue) return { auth: null, touch: null };
+
+  const now = ctx.clock.now();
+  const found = await loadSessionByCookie(ctx.db, cookieValue, now);
+  if (!found) return { auth: null, touch: null };
+
+  return {
+    auth: { user: toSessionUser(found.user), sessionId: found.session.id },
+    touch: touchSessionStatement(found.session, now),
+  };
+}
+
+/** Hashes a client IP for use as a rate-limit bucket key. */
+export async function hashIp(ip: string | null, salt: string): Promise<string | null> {
+  if (!ip) return null;
+  return (await sha256Hex(`${salt}:${ip}`)).slice(0, 32);
+}
diff --git a/worker/src/handlers/content.ts b/worker/src/handlers/content.ts
new file mode 100644
index 0000000..505223e
--- /dev/null
+++ b/worker/src/handlers/content.ts
@@ -0,0 +1,178 @@
+/**
+ * Content handlers - chapters, questions, templates, search.
+ *
+ * None of these endpoints can return an answer key, and the reason is
+ * structural: they build option lists from `loadOptionsForQuestions`, which
+ * reads `question_options` -- a table with NO answer column. The key is a row
+ * in `question_answer_keys`, and nothing on this path names that table.
+ *
+ * They do still permute. A content endpoint that returned options in the
+ * authored order would let anyone join position-to-position against
+ * `frontend/public/data/books/*.json`, which ships `correct_option_index` and
+ * will be in this repository's git history forever. The permutation here is
+ * seeded from a server-only secret plus the viewer's user id, so it is stable
+ * across reloads - selections are stored by ref, and a reshuffle between loads
+ * would re-point them - but not reproducible by anyone without the secret.
+ */
+
+import { fail } from '../shared/errors.ts';
+import { browseOptionRef, browsePermutation } from '../lib/permute.ts';
+import {
+  contentVersion,
+  countChapterQuestions,
+  listChapters,
+  listMockTemplates,
+  loadOptionsForQuestions,
+  pageChapterQuestions,
+  searchQuestions,
+  toDifficulty,
+} from '../data/content.ts';
+import { consumeRateLimit, RATE_LIMITS } from '../data/infra.ts';
+import { ok } from './context.ts';
+import type { HandlerContext, HandlerResult } from './context.ts';
+import { readSession } from './auth.ts';
+import type {
+  BootstrapResponse,
+  ChapterQuestionsResponse,
+  ChapterSummary,
+  MockTemplateSummary,
+  PublicQuestion,
+  SearchResponse,
+} from '../shared/types.ts';
+import type { ChapterQuestionsInput, SearchInput } from '../validation/schemas.ts';
+
+/**
+ * GET /api/bootstrap - 4 or 5 D1 queries.
+ *
+ * ONE call for the whole app shell: session, chapters, mock templates and a
+ * content version. Workers Free allows 100k requests a day, so a client that
+ * made four separate calls on every cold start would burn through that four
+ * times faster for no benefit. Everything here is small and changes rarely.
+ */
+export async function bootstrap(
+  ctx: HandlerContext,
+): Promise<HandlerResult<BootstrapResponse>> {
+  const session = await readSession(ctx);
+  const chapters = await listChapters(ctx.db);
+  const mockTemplates = await listMockTemplates(ctx.db);
+  const version = await contentVersion(ctx.db);
+
+  return ok<BootstrapResponse>({
+    session: session.body,
+    chapters,
+    mockTemplates,
+    contentVersion: version,
+  });
+}
+
+/** GET /api/content/chapters - 1 D1 query. */
+export async function getChapters(
+  ctx: HandlerContext,
+): Promise<HandlerResult<{ chapters: ChapterSummary[] }>> {
+  return ok({ chapters: await listChapters(ctx.db) });
+}
+
+/** GET /api/content/mock-templates - 1 D1 query. */
+export async function getMockTemplates(
+  ctx: HandlerContext,
+): Promise<HandlerResult<{ mockTemplates: MockTemplateSummary[] }>> {
+  return ok({ mockTemplates: await listMockTemplates(ctx.db) });
+}
+
+/**
+ * GET /api/content/chapters/:chapterId/questions - 3 D1 queries.
+ *
+ * Questions WITHOUT keys, for browsing and study. Paged, because a chapter can
+ * hold 746 questions and sending all of them in one response would be a
+ * multi-megabyte payload on a mobile connection in Nepal.
+ *
+ * Works for anonymous callers too; the permutation then falls back to a
+ * per-chapter seed, which still breaks the positional join against the public
+ * JSON but is shared between guests.
+ */
+export async function getChapterQuestions(
+  ctx: HandlerContext,
+  input: ChapterQuestionsInput,
+): Promise<HandlerResult<ChapterQuestionsResponse>> {
+  const total = await countChapterQuestions(ctx.db, input.chapterId);
+  if (total === 0) fail('NOT_FOUND', 'That chapter has no published questions.');
+
+  const rows = await pageChapterQuestions(ctx.db, {
+    chapterId: input.chapterId,
+    offset: input.offset,
+    limit: input.limit,
+  });
+
+  const optionsByQuestion = await loadOptionsForQuestions(
+    ctx.db,
+    rows.map((r) => r.id),
+  );
+
+  const seedUser = ctx.auth?.user.id ?? `guest:${input.chapterId}`;
+
+  const questions: PublicQuestion[] = rows.map((row) => {
+    const options = optionsByQuestion.get(row.id) ?? [];
+    const permuted = browsePermutation(
+      options,
+      ctx.config.permutationSecret,
+      seedUser,
+      row.id,
+    );
+    return {
+      id: row.id,
+      chapterId: row.chapter_id,
+      stem: row.stem,
+      difficulty: toDifficulty(row.difficulty),
+      // An OPAQUE keyed digest, not the option id.
+      //
+      // This used to be load-bearing on its own: option ids were
+      // `question_id || '#' || ordinal`, so handing one over handed over the
+      // authored ordinal, and the public chapter JSON in git history publishes
+      // `correct_option_index` -- which made that ordinal the answer. The
+      // permutation did not help, because the ordinal travelled INSIDE the id.
+      // `migrations/0002_content.sql` now mints ids with a CSPRNG `opt_key`,
+      // so the leak is closed at the root. The digest stays because a stable
+      // per-viewer handle is still better than a globally stable one: two
+      // accounts comparing payloads learn nothing from each other.
+      options: permuted.map((o) => ({
+        ref: browseOptionRef(ctx.config.permutationSecret, seedUser, row.id, o.id),
+        body: o.body,
+      })),
+    };
+  });
+
+  return ok<ChapterQuestionsResponse>({
+    chapterId: input.chapterId,
+    total,
+    offset: input.offset,
+    limit: input.limit,
+    questions,
+  });
+}
+
+/**
+ * GET /api/content/search - 2 D1 queries.
+ *
+ * Stems only. Returning options here would be a way to enumerate the bank in
+ * bulk, and the UI does not need them: a result is a link to the question.
+ */
+export async function search(
+  ctx: HandlerContext,
+  input: SearchInput,
+): Promise<HandlerResult<SearchResponse>> {
+  const subject = ctx.auth?.user.id ?? (ctx.meta.ipHash ?? 'unknown');
+  const limit = await consumeRateLimit(ctx.db, RATE_LIMITS.search, subject, ctx.clock.now());
+  if (!limit.allowed) {
+    fail('RATE_LIMITED', 'Too many searches. Please slow down.', {
+      retryAfterMs: limit.retryAfterMs,
+    });
+  }
+
+  const results = await searchQuestions(ctx.db, {
+    query: input.q,
+    chapterId: input.chapterId ?? null,
+    limit: input.limit,
+  });
+
+  return ok<SearchResponse>({ query: input.q, results });
+}
diff --git a/worker/src/handlers/context.ts b/worker/src/handlers/context.ts
new file mode 100644
index 0000000..b47533b
--- /dev/null
+++ b/worker/src/handlers/context.ts
@@ -0,0 +1,176 @@
+/**
+ * The handler context, and the two gates every protected endpoint goes through.
+ *
+ * WHY HANDLERS ARE NOT HONO HANDLERS. Everything in `handlers/` is a plain
+ * async function from `(ctx, input)` to `{ status, body }`. The Hono layer in
+ * `routes/` does nothing but parse, validate, call one of these, and serialise
+ * the result. That keeps the entire real logic path - ownership checks, the
+ * expiry clamp, scoring, idempotency, the actual SQL - executable under
+ * `node --test` against a local SQLite database, with no framework and no
+ * network. The tests exercise production code, not a re-implementation of it.
+ */
+
+import type { Db } from '../data/d1.ts';
+import type { Clock } from '../lib/time.ts';
+import type { Config } from '../env.ts';
+import { fail } from '../shared/errors.ts';
+import { reserveIdempotency, releaseIdempotency, finalizeIdempotencyStatement } from '../data/infra.ts';
+import { canonicalJson } from '../lib/canonical.ts';
+import { sha256Hex } from '../lib/password.ts';
+import type { SessionUser } from '../shared/types.ts';
+
+export interface AuthContext {
+  user: SessionUser;
+  sessionId: string;
+}
+
+export interface RequestMeta {
+  /** `CF-Connecting-IP`, already hashed by the middleware. */
+  ipHash: string | null;
+  userAgent: string | null;
+}
+
+export interface HandlerContext {
+  db: Db;
+  clock: Clock;
+  config: Config;
+  /** `null` when the request carried no live session. */
+  auth: AuthContext | null;
+  meta: RequestMeta;
+  /** Set-Cookie values the route layer must attach to the response. */
+  cookies: string[];
+}
+
+export interface HandlerResult<T> {
+  status: number;
+  body: T;
+  replayed?: boolean;
+}
+
+export function ok<T>(body: T): HandlerResult<T> {
+  return { status: 200, body };
+}
+
+export function created<T>(body: T): HandlerResult<T> {
+  return { status: 201, body };
+}
+
+/**
+ * The single authentication gate.
+ *
+ * D1 has no row-level security, so this function plus "every data-access
+ * function takes a userId" is the entire authorisation story. There is no
+ * fallback, no "if no user, use a default", and no handler that reads
+ * `ctx.auth` directly without going through here.
+ */
+export function requireUser(ctx: HandlerContext): AuthContext {
+  if (!ctx.auth) {
+    fail('UNAUTHENTICATED', 'Sign in to continue.');
+  }
+  return ctx.auth;
+}
+
+/**
+ * The role gate for the admin surface.
+ *
+ * The role comes from the `users` row loaded through the session, never from
+ * the cookie or from a request field, so there is nothing a client can edit to
+ * reach these endpoints.
+ */
+export function requireAdmin(ctx: HandlerContext): AuthContext {
+  const auth = requireUser(ctx);
+  if (auth.user.role !== 'admin' && auth.user.role !== 'moderator') {
+    // A deliberate 403 rather than a 404: the caller is authenticated, and
+    // pretending the route does not exist makes a legitimate permissions
+    // problem undebuggable.
+    fail('FORBIDDEN', 'This action requires a moderator role.');
+  }
+  return auth;
+}
+
+/** Anonymous users may do most things, but not everything. */
+export function requireRealAccount(ctx: HandlerContext): AuthContext {
+  const auth = requireUser(ctx);
+  if (auth.user.isAnonymous) {
+    fail('FORBIDDEN', 'Create an account to use this feature.');
+  }
+  return auth;
+}
+
+/**
+ * Wraps a mutation so it is safe to replay.
+ *
+ * Costs 2 D1 queries on the first attempt (reserve, finalise) and 2 on a replay
+ * (reserve-conflict, read). The stored response is returned verbatim, so a
+ * client whose connection dropped after the server committed gets the SAME
+ * result rather than a 409 or a second write.
+ *
+ * Three failure modes, all of them explicit:
+ *
+ * - same key, same body, finished   -> replay the stored response
+ * - same key, same body, in flight  -> 409 REQUEST_IN_FLIGHT, retry later
+ * - same key, DIFFERENT body        -> 409 IDEMPOTENCY_KEY_REUSED, never guess
+ *
+ * If `work` throws, the reservation is released so an immediate retry is not
+ * stuck behind a key that will never be finalised.
+ */
+export async function withIdempotency<T>(
+  ctx: HandlerContext,
+  args: {
+    userId: string;
+    key: string;
+    endpoint: string;
+    body: unknown;
+  },
+  work: () => Promise<HandlerResult<T>>,
+): Promise<HandlerResult<T>> {
+  const now = ctx.clock.now();
+  const requestHash = await sha256Hex(`${args.endpoint}\n${canonicalJson(args.body)}`);
+
+  const check = await reserveIdempotency(ctx.db, {
+    userId: args.userId,
+    key: args.key,
+    endpoint: args.endpoint,
+    requestHash,
+    now,
+  });
+
+  if (check.kind === 'replay') {
+    return { status: check.statusCode, body: check.body as T, replayed: true };
+  }
+  if (check.kind === 'reused') {
+    fail(
+      'IDEMPOTENCY_KEY_REUSED',
+      'This idempotency key was already used for a different request.',
+    );
+  }
+  if (check.kind === 'in_flight') {
+    fail('REQUEST_IN_FLIGHT', 'An identical request is still being processed.', {
+      retryAfterMs: 1000,
+    });
+  }
+
+  let result: HandlerResult<T>;
+  try {
+    result = await work();
+  } catch (err) {
+    try {
+      await releaseIdempotency(ctx.db, { userId: args.userId, key: args.key });
+    } catch {
+      // The original error is the one worth reporting; a failed release only
+      // means the retry waits for the sweep.
+    }
+    throw err;
+  }
+
+  await ctx.db.batch([
+    finalizeIdempotencyStatement({
+      userId: args.userId,
+      key: args.key,
+      statusCode: result.status,
+      body: result.body,
+    }),
+  ]);
+
+  return result;
+}
diff --git a/worker/src/handlers/mock.ts b/worker/src/handlers/mock.ts
new file mode 100644
index 0000000..4a72b3d
--- /dev/null
+++ b/worker/src/handlers/mock.ts
@@ -0,0 +1,539 @@
+/**
+ * Mock test handlers - the centre of the anti-cheat work.
+ *
+ * WHAT THIS REPLACES. `frontend/src/pages/app/MockTestQuiz.tsx` fetches
+ * the chapter JSON including `correct_option_index`, scores in the browser
+ * against `q.correctIndex`, and runs the clock as a `setInterval`. Opening
+ * devtools reveals the whole key; stopping the interval or editing the
+ * localStorage draft grants unlimited time.
+ *
+ * WHAT MAKES THAT IMPOSSIBLE HERE, structurally rather than by politeness:
+ *
+ * 1. The key is a SEPARATE TABLE (`question_answer_keys`, one row per
+ *    question). `questions` has no answer column and `question_options` has
+ *    none either, so no amount of forgetting to narrow a SELECT list can leak
+ *    it -- it takes naming a third table in a FROM clause, which `loadAnswerKey`
+ *    is the only function in the codebase to do, and which is called once,
+ *    during scoring, after the submission has arrived.
+ * 2. Option identity on the wire is a per-attempt ref derived from the server's
+ *    secret and the attempt's `option_seed`. The client submits a ref, so there
+ *    is no index and no id to correlate with the public JSON, and a ref
+ *    harvested from a finished attempt is meaningless in a new one.
+ * 3. The paper is permuted per attempt, so even position-to-position
+ *    correlation against the authored order fails.
+ * 4. `deadline_at` is written by the server at start and never accepted from a
+ *    client. Scoring uses the server clock, and the "what was submitted in
+ *    time" question is answered by what the server actually received before the
+ *    deadline - see `domain/expiry.ts` and `attempts.synced_answers`.
+ * 5. Scoring happens here. The request body has no field in which to assert a
+ *    score, a correctness bit, or a timestamp.
+ */
+
+import { fail } from '../shared/errors.ts';
+import { newId } from '../lib/ids.ts';
+import { cryptoShuffle } from '../lib/permute.ts';
+import { clampSubmission, deadlineFor, syncDecision } from '../domain/expiry.ts';
+import { scorePaper } from '../domain/scoring.ts';
+import { selectPaper } from '../domain/blueprint.ts';
+import {
+  drawBlueprintPools,
+  getActiveMockTemplate,
+  getBlueprint,
+  loadAnswerKey,
+  loadOptionsForQuestions,
+} from '../data/content.ts';
+import {
+  attemptDurationSeconds,
+  attemptScoredAt,
+  attemptStatus,
+  attemptTiming,
+  createAttemptBatch,
+  loadAttempt,
+  loadPaper,
+  loadRecordedAnswers,
+  parseSyncedAnswers,
+  submitAttempt,
+  syncAnswers,
+} from '../data/attempts.ts';
+import type { AttemptRow, SubmissionAnswer } from '../data/attempts.ts';
+import { consumeRateLimit, RATE_LIMITS } from '../data/infra.ts';
+import { attachRefs, bodyIndex, buildAttemptPaper, publicOptionsFor, toAttemptQuestions } from './paper.ts';
+import type { DeliverablePaperRow, RefContext } from './paper.ts';
+import { ok, requireUser, withIdempotency } from './context.ts';
+import type { HandlerContext, HandlerResult } from './context.ts';
+import type {
+  MockAttemptPaper,
+  MockReviewQuestion,
+  MockSubmitResponse,
+  MockSyncResponse,
+} from '../shared/types.ts';
+import type { MockStartInput, MockSubmitInput, MockSyncInput } from '../validation/schemas.ts';
+
+/** Shared by every rate-limited handler here. */
+async function enforceLimit(
+  ctx: HandlerContext,
+  rule: { name: string; limit: number; windowMs: number },
+  subject: string,
+): Promise<void> {
+  const result = await consumeRateLimit(ctx.db, rule, subject, ctx.clock.now());
+  if (!result.allowed) {
+    fail('RATE_LIMITED', 'Too many requests. Please slow down.', {
+      retryAfterMs: result.retryAfterMs,
+    });
+  }
+}
+
+function refContextFor(ctx: HandlerContext, attempt: AttemptRow): RefContext {
+  return {
+    secret: ctx.config.permutationSecret,
+    optionSeed: attempt.option_seed,
+    attemptPublicId: attempt.public_id,
+  };
+}
+
+/** A CSPRNG seed for the per-attempt option permutation. */
+function newOptionSeed(): number {
+  const buf = new Uint32Array(1);
+  crypto.getRandomValues(buf);
+  // Kept inside 2^31 so it is a plain positive INTEGER in SQLite and in JSON.
+  return buf[0] & 0x7fffffff;
+}
+
+/**
+ * POST /api/mock/start - 12 D1 queries, CONSTANT in paper size.
+ *
+ * rate limit 1, idempotency reserve 1, template 1, blueprint 1, pool draw 1,
+ * option bodies 1, attempt + paper + study session 3 (ONE batch), attempt
+ * read-back 1, paper read-back 1, idempotency finalise 1.
+ */
+export async function startMock(
+  ctx: HandlerContext,
+  input: MockStartInput,
+): Promise<HandlerResult<MockAttemptPaper>> {
+  const auth = requireUser(ctx);
+  await enforceLimit(ctx, RATE_LIMITS.mockStart, auth.user.id);
+
+  return await withIdempotency(
+    ctx,
+    {
+      userId: auth.user.id,
+      key: input.idempotencyKey,
+      endpoint: 'POST /api/mock/start',
+      body: input,
+    },
+    async () => {
+      const template = await getActiveMockTemplate(ctx.db, input.templateId);
+      if (!template) fail('NOT_FOUND', 'That mock test does not exist.');
+
+      const blueprint = await getBlueprint(ctx.db, input.templateId);
+      if (blueprint.length === 0) {
+        fail('INSUFFICIENT_CONTENT', 'That mock test has no questions configured.');
+      }
+
+      // The composition comes from the blueprint, which is server data. The
+      // request named a template and nothing else: it cannot ask for a shorter
+      // paper, an easier chapter, or a specific question.
+      const pools = await drawBlueprintPools(ctx.db, input.templateId);
+      const selection = selectPaper({
+        blueprint,
+        subchapterPools: pools.subchapterPools,
+        chapterPools: pools.chapterPools,
+        shuffle: cryptoShuffle,
+        strictSubchapter: template.strict_subchapter === 1,
+      });
+
+      if (selection.picks.length === 0) {
+        fail('INSUFFICIENT_CONTENT', 'No published questions are available yet.');
+      }
+
+      const questionIds = selection.picks.map((p) => p.questionId);
+      const optionsByQuestion = await loadOptionsForQuestions(ctx.db, questionIds);
+      const paper = buildAttemptPaper(selection.picks, optionsByQuestion);
+
+      if (paper.length === 0) {
+        fail('INSUFFICIENT_CONTENT', 'No answerable questions are available yet.');
+      }
+
+      const startedAt = ctx.clock.now();
+      const durationSeconds = template.duration_minutes * 60;
+      const publicId = newId('mat');
+
+      await ctx.db.batch(
+        createAttemptBatch({
+          publicId,
+          userId: auth.user.id,
+          mode: 'mock',
+          templateId: template.id,
+          // NULL: a mock spans all ten chapters, and `attempts.chapter_id` is
+          // for a single-chapter practice set.
+          chapterId: null,
+          optionSeed: newOptionSeed(),
+          startedAt,
+          deadlineAt: deadlineFor(startedAt, durationSeconds),
+          paper,
+        }),
+      );
+
+      // Read the attempt and the paper back rather than assembling the response
+      // from the in-memory pick. It costs two queries and it means the client
+      // is shown exactly the permutation that was persisted - if the insert had
+      // dropped a row, the response would say so instead of promising a
+      // question the scorer will never see. The read-back is also where the
+      // attempt's `option_seed` comes from, which the refs are derived under.
+      const attempt = await loadAttempt(ctx.db, publicId, auth.user.id);
+      if (!attempt) fail('INTERNAL', 'The attempt could not be created.');
+
+      const rows = attachRefs(
+        await loadPaper(ctx.db, publicId, auth.user.id),
+        refContextFor(ctx, attempt),
+      );
+
+      return ok<MockAttemptPaper>({
+        attemptId: attempt.public_id,
+        templateId: template.id,
+        status: 'in_progress',
+        startedAt: attempt.started_at,
+        expiresAt: attempt.deadline_at ?? startedAt,
+        serverNow: startedAt,
+        durationSeconds,
+        questionCount: attempt.question_count,
+        questions: toAttemptQuestions(rows, optionsByQuestion),
+        savedAnswers: {},
+      });
+    },
+  );
+}
+
+/**
+ * GET /api/mock/attempts/:attemptId - 3 D1 queries.
+ *
+ * The resume path. Returns the paper and the answers the server has already
+ * accepted, so a reload does not depend on localStorage surviving - and cannot
+ * be influenced by editing it.
+ */
+export async function getMockAttempt(
+  ctx: HandlerContext,
+  attemptId: string,
+): Promise<HandlerResult<MockAttemptPaper>> {
+  const auth = requireUser(ctx);
+
+  const attempt = await loadAttempt(ctx.db, attemptId, auth.user.id);
+  if (!attempt) fail('NOT_FOUND', 'That attempt does not exist.');
+
+  const rows = attachRefs(
+    await loadPaper(ctx.db, attemptId, auth.user.id),
+    refContextFor(ctx, attempt),
+  );
+  const optionsByQuestion = await loadOptionsForQuestions(
+    ctx.db,
+    rows.map((r) => r.questionId),
+  );
+
+  const now = ctx.clock.now();
+
+  return ok<MockAttemptPaper>({
+    attemptId: attempt.public_id,
+    templateId: attempt.template_id ?? '',
+    status: attemptStatus(attempt),
+    startedAt: attempt.started_at,
+    expiresAt: attempt.deadline_at ?? attempt.started_at,
+    serverNow: now,
+    durationSeconds: attemptDurationSeconds(attempt),
+    questionCount: attempt.question_count,
+    questions: toAttemptQuestions(rows, optionsByQuestion),
+    savedAnswers: parseSyncedAnswers(attempt) ?? {},
+  });
+}
+
+/**
+ * POST /api/mock/sync - 3 D1 queries.
+ *
+ * The coarse autosave, and the mechanism that gives the expiry clamp something
+ * true to score. The client calls it every 10-15 seconds and on every page
+ * change, NOT on every keystroke: Workers Free allows 100k requests a day.
+ *
+ * Naturally idempotent - the map replaces the stored snapshot - so the offline
+ * outbox needs no key for it.
+ */
+export async function syncMock(
+  ctx: HandlerContext,
+  input: MockSyncInput,
+): Promise<HandlerResult<MockSyncResponse>> {
+  const auth = requireUser(ctx);
+  await enforceLimit(ctx, RATE_LIMITS.mockSync, auth.user.id);
+
+  const attempt = await loadAttempt(ctx.db, input.attemptId, auth.user.id);
+  if (!attempt) fail('NOT_FOUND', 'That attempt does not exist.');
+
+  const now = ctx.clock.now();
+  const expiresAt = attempt.deadline_at ?? attempt.started_at;
+  const decision = syncDecision({
+    now,
+    expiresAt,
+    status: attempt.status,
+  });
+
+  // The same predicate is also the UPDATE's WHERE clause - and a CHECK on the
+  // table - so a race between this decision and the write cannot let a
+  // post-deadline snapshot through. This copy exists only to give the client an
+  // honest reason.
+  const accepted = decision.accepted
+    ? await syncAnswers(ctx.db, {
+        publicId: input.attemptId,
+        userId: auth.user.id,
+        answers: input.answers,
+        now,
+      })
+    : false;
+
+  return ok<MockSyncResponse>({
+    accepted,
+    serverNow: now,
+    expiresAt,
+    remainingMs: Math.max(0, expiresAt - now),
+    ...(accepted ? {} : { reason: decision.reason ?? 'past_deadline' }),
+  });
+}
+
+/**
+ * POST /api/mock/submit - 13 D1 queries, CONSTANT in the size of the paper.
+ *
+ * rate limit 1, idempotency 2, attempt 1, paper 1, key 1, option bodies 1,
+ * commit batch 5 (one round trip), attempt re-read 1.
+ *
+ * A hundred answers are written by ONE statement: the rows travel as a single
+ * JSON bound parameter and are expanded with `json_each`, because D1 allows 50
+ * queries per invocation and 100 bound parameters per statement, so neither a
+ * loop of inserts nor a multi-row VALUES list would fit. The rollups that used
+ * to be three more statements are now triggers on that INSERT.
+ */
+export async function submitMock(
+  ctx: HandlerContext,
+  input: MockSubmitInput,
+): Promise<HandlerResult<MockSubmitResponse>> {
+  const auth = requireUser(ctx);
+  await enforceLimit(ctx, RATE_LIMITS.mockSubmit, auth.user.id);
+
+  return await withIdempotency(
+    ctx,
+    {
+      userId: auth.user.id,
+      key: input.idempotencyKey,
+      endpoint: 'POST /api/mock/submit',
+      body: input,
+    },
+    async () => {
+      const attempt = await loadAttempt(ctx.db, input.attemptId, auth.user.id);
+      if (!attempt) fail('NOT_FOUND', 'That attempt does not exist.');
+
+      if (attempt.status !== 'in_progress') {
+        // Deliberately a 409 and not a re-score. A finished attempt is read
+        // back through GET /api/mock/attempts/:id/review, which is a read and
+        // cannot change a stored result.
+        fail('ATTEMPT_NOT_IN_PROGRESS', 'This attempt has already been submitted.');
+      }
+
+      const stored = await loadPaper(ctx.db, input.attemptId, auth.user.id);
+      if (stored.length === 0) fail('INTERNAL', 'This attempt has no paper.');
+      const paper = attachRefs(stored, refContextFor(ctx, attempt));
+
+      const now = ctx.clock.now();
+      const expiresAt = attempt.deadline_at ?? attempt.started_at;
+
+      // THE CLAMP. Nothing from the request influences it: `now` is the
+      // server's clock, `deadline_at` was written by the server at start, and
+      // the fallback snapshot is whatever the server itself accepted before the
+      // deadline.
+      const clamp = clampSubmission({
+        now,
+        startedAt: attempt.started_at,
+        expiresAt,
+        submitted: input.answers,
+        syncedSnapshot: parseSyncedAnswers(attempt),
+      });
+
+      const questionIds = paper.map((p) => p.questionId);
+      const key = await loadAnswerKey(ctx.db, questionIds);
+
+      const scored = scorePaper({
+        paper,
+        key,
+        answers: clamp.answers,
+        // Strict for a live payload: an off-paper question id or an
+        // unresolvable ref is a client bug or a probe, and either way the
+        // request is refused. Lenient for the stored snapshot, which was
+        // already accepted once and must not cost a candidate their paper
+        // because one stale entry no longer resolves.
+        options: { strict: clamp.usedPayload },
+      });
+
+      if (clamp.usedPayload && scored.rejectedQuestionIds.length > 0) {
+        fail('QUESTION_NOT_ON_PAPER', 'Some answers are not for questions on this paper.', {
+          fields: { answers: scored.rejectedQuestionIds.slice(0, 10).join(', ') },
+        });
+      }
+      if (clamp.usedPayload && scored.unknownRefQuestionIds.length > 0) {
+        fail('UNKNOWN_OPTION_REF', 'Some answers reference an unknown option.', {
+          fields: { answers: scored.unknownRefQuestionIds.slice(0, 10).join(', ') },
+        });
+      }
+
+      const paperById = new Map(paper.map((p) => [p.questionId, p]));
+
+      const answers: SubmissionAnswer[] = scored.questions.map((q) => {
+        const row = paperById.get(q.questionId);
+        const index =
+          row && q.selectedOptionId !== null ? row.optionOrder.indexOf(q.selectedOptionId) : -1;
+        return {
+          questionId: q.questionId,
+          chapterId: q.chapterId,
+          isCorrect: q.isCorrect,
+          answered: q.answered,
+          selectedOptionId: q.selectedOptionId,
+          // 1-based screen position under this attempt's permutation.
+          // Analytics only -- it is what measures position bias -- and never
+          // an input to grading.
+          deliveredPosition: index >= 0 ? index + 1 : null,
+        };
+      });
+
+      const optionsByQuestion = await loadOptionsForQuestions(ctx.db, questionIds);
+      const bodies = bodyIndex(optionsByQuestion);
+
+      const { applied } = await submitAttempt(ctx.db, {
+        attemptId: attempt.id,
+        publicId: attempt.public_id,
+        userId: auth.user.id,
+        answers,
+        submittedAt: now,
+        scoredAt: clamp.scoredAt,
+        elapsedMs: Math.max(0, clamp.scoredAt - attempt.started_at),
+      });
+
+      if (!applied) {
+        // Lost the race with a concurrent submission that used a different
+        // idempotency key. Nothing was written by this call.
+        fail('ATTEMPT_NOT_IN_PROGRESS', 'This attempt has already been submitted.');
+      }
+
+      // THE ONLY KEY DISCLOSURE for a mock attempt, and it happens after the
+      // status has already been flipped to `submitted` - so the paper cannot be
+      // re-answered with the key in hand.
+      const review: MockReviewQuestion[] = scored.questions.map((q) =>
+        reviewItem(q, paperById.get(q.questionId), bodies),
+      );
+
+      return ok<MockSubmitResponse>({
+        attemptId: attempt.public_id,
+        status: 'submitted',
+        score: scored.correct,
+        total: scored.total,
+        correct: scored.correct,
+        incorrect: scored.incorrect,
+        skipped: scored.skipped,
+        accuracyPct: scored.accuracyPct,
+        timing: clamp.timing,
+        startedAt: attempt.started_at,
+        expiresAt,
+        submittedAt: now,
+        scoredAt: clamp.scoredAt,
+        droppedLateAnswers: clamp.droppedLateAnswers,
+        rejectedQuestionIds: scored.rejectedQuestionIds,
+        review,
+      });
+    },
+  );
+}
+
+function reviewItem(
+  q: {
+    questionId: string;
+    chapterId: string;
+    position: number;
+    selectedRef: string | null;
+    correctRef: string;
+    isCorrect: boolean;
+  },
+  row: DeliverablePaperRow | undefined,
+  bodies: ReadonlyMap<string, string>,
+): MockReviewQuestion {
+  return {
+    questionId: q.questionId,
+    chapterId: q.chapterId,
+    position: q.position,
+    stem: row?.stem ?? '',
+    options: row ? publicOptionsFor(row, bodies) : [],
+    selectedRef: q.selectedRef,
+    correctRef: q.correctRef,
+    isCorrect: q.isCorrect,
+    explanation: row?.explanation ?? null,
+  };
+}
+
+/**
+ * GET /api/mock/attempts/:attemptId/review - 5 D1 queries.
+ *
+ * Re-reads a submitted attempt's review from what was recorded, so a lost
+ * response or a cleared browser does not lose the paper. A read, so it cannot
+ * change a stored score, and it refuses an attempt that is still in progress -
+ * which is what stops it from being a mid-exam key oracle.
+ *
+ * `score`, `timing` and `scoredAt` come from the attempt row rather than from
+ * re-scoring: `correct_count` is trigger-maintained and therefore survives
+ * archival deleting the raw answers, and `timing`/`scoredAt` are derived from
+ * `submitted_at` and `deadline_at` rather than stored as a third copy.
+ */
+export async function getMockReview(
+  ctx: HandlerContext,
+  attemptId: string,
+): Promise<HandlerResult<MockSubmitResponse>> {
+  const auth = requireUser(ctx);
+
+  const attempt = await loadAttempt(ctx.db, attemptId, auth.user.id);
+  if (!attempt) fail('NOT_FOUND', 'That attempt does not exist.');
+
+  if (attempt.status === 'in_progress') {
+    fail('ATTEMPT_NOT_IN_PROGRESS', 'This attempt has not been submitted yet.');
+  }
+
+  const paper = attachRefs(
+    await loadPaper(ctx.db, attemptId, auth.user.id),
+    refContextFor(ctx, attempt),
+  );
+  const questionIds = paper.map((p) => p.questionId);
+  const key = await loadAnswerKey(ctx.db, questionIds);
+  const recorded = await loadRecordedAnswers(ctx.db, attemptId, auth.user.id);
+  const optionsByQuestion = await loadOptionsForQuestions(ctx.db, questionIds);
+  const bodies = bodyIndex(optionsByQuestion);
+
+  const answers: Record<string, string> = {};
+  for (const row of paper) {
+    const recordedAnswer = recorded.get(row.questionId);
+    if (!recordedAnswer?.optionId) continue;
+    const index = row.optionOrder.indexOf(recordedAnswer.optionId);
+    if (index >= 0 && row.optionRefs[index]) answers[row.questionId] = row.optionRefs[index];
+  }
+
+  const scored = scorePaper({ paper, key, answers, options: { strict: false } });
+  const paperById = new Map(paper.map((p) => [p.questionId, p]));
+  const expiresAt = attempt.deadline_at ?? attempt.started_at;
+
+  return ok<MockSubmitResponse>({
+    attemptId: attempt.public_id,
+    status: 'submitted',
+    score: attempt.correct_count,
+    total: scored.total,
+    correct: scored.correct,
+    incorrect: scored.incorrect,
+    skipped: scored.skipped,
+    accuracyPct: scored.accuracyPct,
+    timing: attemptTiming(attempt),
+    startedAt: attempt.started_at,
+    expiresAt,
+    submittedAt: attempt.submitted_at ?? expiresAt,
+    scoredAt: attemptScoredAt(attempt),
+    droppedLateAnswers: 0,
+    rejectedQuestionIds: [],
+    review: scored.questions.map((q) => reviewItem(q, paperById.get(q.questionId), bodies)),
+  });
+}
diff --git a/worker/src/handlers/moderation.ts b/worker/src/handlers/moderation.ts
new file mode 100644
index 0000000..feef151
--- /dev/null
+++ b/worker/src/handlers/moderation.ts
@@ -0,0 +1,211 @@
+/**
+ * Errata reports (user-facing) and the admin surface behind a role check.
+ *
+ * The bank is known to contain wrong keys - the importer's own validator files
+ * 106 of them on every seed, and the frontend currently filters a hardcoded
+ * list out at read time. Reports plus
+ * `POST /api/admin/questions/publish` replace that hardcoded list with a
+ * workflow, and every admin mutation writes an audit row in the SAME batch as
+ * the mutation, so there is no path that changes published content silently.
+ */
+
+import { fail } from '../shared/errors.ts';
+import {
+  listOwnReports,
+  readAuditLog,
+  readReportQueue,
+  setQuestionState,
+  submitReport,
+  triageReports,
+} from '../data/moderation.ts';
+import { consumeRateLimit, RATE_LIMITS } from '../data/infra.ts';
+import { ok, requireAdmin, requireUser, withIdempotency } from './context.ts';
+import type { HandlerContext, HandlerResult } from './context.ts';
+import type {
+  AdminPublishResponse,
+  AdminReportQueueResponse,
+  AdminTriageResponse,
+  AuditLogResponse,
+  ReportListResponse,
+} from '../shared/types.ts';
+import type {
+  AdminPublishInput,
+  AdminQueueInput,
+  AdminTriageInput,
+  AuditInput,
+  ReportSubmitInput,
+} from '../validation/schemas.ts';
+
+/**
+ * POST /api/reports - 3 D1 queries.
+ *
+ * Idempotent WITHOUT a key, through the PARTIAL unique index on
+ * `(question_id, reporter_user_id) WHERE status = 'open'`: re-reporting the
+ * same question updates the existing open report instead of filling the triage
+ * queue with duplicates, so a replayed offline mutation converges. The optional
+ * key is accepted for uniformity.
+ */
+export async function submitErrataReport(
+  ctx: HandlerContext,
+  input: ReportSubmitInput,
+): Promise<HandlerResult<{ reportId: string; created: boolean }>> {
+  const auth = requireUser(ctx);
+  const now = ctx.clock.now();
+
+  const limit = await consumeRateLimit(ctx.db, RATE_LIMITS.report, auth.user.id, now);
+  if (!limit.allowed) {
+    fail('RATE_LIMITED', 'Too many reports. Try again later.', {
+      retryAfterMs: limit.retryAfterMs,
+    });
+  }
+
+  const result = await submitReport(ctx.db, {
+    userId: auth.user.id,
+    questionId: input.questionId,
+    reason: input.reason,
+    detail: input.detail ?? null,
+    now,
+  });
+
+  // The INSERT selects from `questions`, so a nonexistent question id writes
+  // nothing and returns nothing rather than creating an orphan report.
+  if (!result) fail('NOT_FOUND', 'That question does not exist.');
+
+  return ok({ reportId: result.id, created: result.created });
+}
+
+/** GET /api/reports - 1 D1 query. Scoped to the caller. */
+export async function listMyReports(
+  ctx: HandlerContext,
+): Promise<HandlerResult<ReportListResponse>> {
+  const auth = requireUser(ctx);
+  return ok<ReportListResponse>({ items: await listOwnReports(ctx.db, auth.user.id) });
+}
+
+// --- Admin ------------------------------------------------------------------
+
+/** GET /api/admin/reports - 1 D1 query. Moderator or admin. */
+export async function getReportQueue(
+  ctx: HandlerContext,
+  input: AdminQueueInput,
+): Promise<HandlerResult<AdminReportQueueResponse>> {
+  requireAdmin(ctx);
+
+  const before = parseCursor(input.cursor);
+  const items = await readReportQueue(ctx.db, {
+    status: input.status,
+    limit: input.limit,
+    beforeCreatedAt: before,
+  });
+
+  return ok<AdminReportQueueResponse>({
+    items,
+    nextCursor:
+      items.length === input.limit ? String(items[items.length - 1].createdAt) : null,
+  });
+}
+
+function parseCursor(cursor: string | undefined): number | null {
+  if (cursor === undefined) return null;
+  const parsed = Number.parseInt(cursor, 10);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    fail('BAD_REQUEST', 'Invalid cursor.', { fields: { cursor: 'Malformed.' } });
+  }
+  return parsed;
+}
+
+/**
+ * POST /api/admin/reports/triage - 4 D1 queries for any batch size.
+ *
+ * idempotency 2, update + audit 2 (one batch). Up to 100 report ids travel as
+ * one JSON parameter, so bulk triage does not scale with the number of rows.
+ */
+export async function triage(
+  ctx: HandlerContext,
+  input: AdminTriageInput,
+): Promise<HandlerResult<AdminTriageResponse>> {
+  const auth = requireAdmin(ctx);
+
+  return await withIdempotency(
+    ctx,
+    {
+      userId: auth.user.id,
+      key: input.idempotencyKey,
+      endpoint: 'POST /api/admin/reports/triage',
+      body: input,
+    },
+    async () => {
+      const updated = await triageReports(ctx.db, {
+        actorUserId: auth.user.id,
+        // The role the action was permitted BY, recorded at the time. A
+        // moderator later promoted to admin does not retroactively change what
+        // they were allowed to do when they did it.
+        actorRole: auth.user.role,
+        reportIds: input.reportIds,
+        status: input.status,
+        resolutionNote: input.resolutionNote ?? null,
+        now: ctx.clock.now(),
+      });
+      return ok<AdminTriageResponse>({ updated, status: input.status });
+    },
+  );
+}
+
+/**
+ * POST /api/admin/questions/publish - 4 D1 queries for any batch size.
+ *
+ * Publishing, drafting or retiring in bulk. Retiring is the lever that takes a
+ * known-bad question out of every future paper WITHOUT deleting the attempts
+ * already recorded against it - which is why `questions.status` is a state and
+ * not a DELETE.
+ *
+ * Admin only, not moderator: this changes what candidates sit.
+ */
+export async function publishQuestions(
+  ctx: HandlerContext,
+  input: AdminPublishInput,
+): Promise<HandlerResult<AdminPublishResponse>> {
+  const auth = requireAdmin(ctx);
+  if (auth.user.role !== 'admin') {
+    fail('FORBIDDEN', 'Publishing requires an admin role.');
+  }
+
+  return await withIdempotency(
+    ctx,
+    {
+      userId: auth.user.id,
+      key: input.idempotencyKey,
+      endpoint: 'POST /api/admin/questions/publish',
+      body: input,
+    },
+    async () => {
+      const updated = await setQuestionState(ctx.db, {
+        actorUserId: auth.user.id,
+        actorRole: auth.user.role,
+        questionIds: input.questionIds,
+        state: input.state,
+        now: ctx.clock.now(),
+      });
+      return ok<AdminPublishResponse>({ updated, state: input.state });
+    },
+  );
+}
+
+/** GET /api/admin/audit - 1 D1 query. */
+export async function getAuditLog(
+  ctx: HandlerContext,
+  input: AuditInput,
+): Promise<HandlerResult<AuditLogResponse>> {
+  requireAdmin(ctx);
+
+  const items = await readAuditLog(ctx.db, {
+    limit: input.limit,
+    beforeCreatedAt: parseCursor(input.cursor),
+  });
+
+  return ok<AuditLogResponse>({
+    items,
+    nextCursor:
+      items.length === input.limit ? String(items[items.length - 1].createdAt) : null,
+  });
+}
diff --git a/worker/src/handlers/paper.ts b/worker/src/handlers/paper.ts
new file mode 100644
index 0000000..51ebe57
--- /dev/null
+++ b/worker/src/handlers/paper.ts
@@ -0,0 +1,155 @@
+/**
+ * Turning a stored paper into a client payload.
+ *
+ * The one place that assembles option lists for an attempt, and the reason the
+ * assembly is centralised: it reads `optionOrder` (real option ids, server-side
+ * only) and emits ONLY a derived ref per option. An option id never reaches a
+ * client.
+ *
+ * That matters less than it used to, and the reason is worth knowing. Option
+ * ids used to be `question_id || '#' || ordinal`, so an id in a payload WAS the
+ * answer key for any question in the public JSON bank -- and this layer was the
+ * only thing standing between the two. `migrations/0002_content.sql` now mints
+ * ids with a CSPRNG `opt_key`, so the leak is closed at the root. The refs stay
+ * because they still buy something real: a ref is per attempt, so one captured
+ * paper teaches nothing about another, and a ref carries no stable handle a
+ * client could accumulate across sessions.
+ */
+
+import { attemptOptionRef, cryptoShuffle, permuteOptions } from '../lib/permute.ts';
+import type { OptionRow } from '../lib/permute.ts';
+import type { PaperRowInput, StoredPaperRow } from '../data/attempts.ts';
+import type { PaperQuestion } from '../domain/scoring.ts';
+import type { AttemptQuestion, PublicOption } from '../shared/types.ts';
+
+/** A stored paper row with this attempt's refs attached. */
+export interface DeliverablePaperRow extends PaperQuestion {
+  stem: string;
+  explanation: string | null;
+}
+
+/**
+ * Builds the per-attempt option permutation for each pick.
+ *
+ * The permutation is a CSPRNG shuffle and it is PERSISTED, so a reload reads it
+ * back rather than recomputing it -- which is what lets the refs be derived
+ * from the stored order rather than stored alongside it.
+ *
+ * Options flagged `question_options.is_pinned` ('All of the above' and friends,
+ * 450 of them in the bank, every one authored in slot 4) are held at the end.
+ * Shuffling one into the middle makes the question nonsense, and the flag is
+ * the schema's rather than a regex over the text, so a mis-detected option is a
+ * data fix and not a deploy.
+ */
+export function buildAttemptPaper(
+  picks: ReadonlyArray<{ questionId: string; position: number }>,
+  optionsByQuestion: ReadonlyMap<string, OptionRow[]>,
+): PaperRowInput[] {
+  const out: PaperRowInput[] = [];
+
+  for (const pick of picks) {
+    const options = optionsByQuestion.get(pick.questionId);
+    // A question with fewer than two options cannot be answered. Dropping it
+    // here keeps it off the paper rather than letting it be auto-wrong.
+    if (!options || options.length < 2) continue;
+
+    const permuted = permuteOptions(options, cryptoShuffle);
+    out.push({
+      questionId: pick.questionId,
+      position: out.length + 1,
+      optionOrder: permuted.map((o) => o.id),
+    });
+  }
+
+  return out;
+}
+
+export interface RefContext {
+  /** `CONTENT_PERMUTATION_SECRET`. Server-only, and the key of the digest. */
+  secret: string;
+  /** `attempts.option_seed`. CSPRNG per attempt. */
+  optionSeed: number;
+  /** `attempts.public_id`. */
+  attemptPublicId: string;
+}
+
+/**
+ * Derives this attempt's refs for a stored paper. No database access, no
+ * storage: see `lib/permute.ts#attemptOptionRef` for why they are computed
+ * rather than kept.
+ */
+export function attachRefs(
+  rows: readonly StoredPaperRow[],
+  ctx: RefContext,
+): DeliverablePaperRow[] {
+  return rows.map((row) => ({
+    questionId: row.questionId,
+    chapterId: row.chapterId,
+    position: row.position,
+    optionOrder: row.optionOrder,
+    optionRefs: row.optionOrder.map((optionId) =>
+      attemptOptionRef(ctx.secret, ctx.optionSeed, ctx.attemptPublicId, optionId),
+    ),
+    stem: row.stem,
+    explanation: row.explanation,
+  }));
+}
+
+/** The same derivation for a single stored question. */
+export function attachRefsToOne<T extends { optionOrder: string[] }>(
+  row: T,
+  ctx: RefContext,
+): T & { optionRefs: string[] } {
+  return {
+    ...row,
+    optionRefs: row.optionOrder.map((optionId) =>
+      attemptOptionRef(ctx.secret, ctx.optionSeed, ctx.attemptPublicId, optionId),
+    ),
+  };
+}
+
+/** Option bodies in the stored permuted order, labelled only by ref. */
+export function publicOptionsFor(
+  paper: PaperQuestion,
+  bodies: ReadonlyMap<string, string>,
+): PublicOption[] {
+  const out: PublicOption[] = [];
+  for (let i = 0; i < paper.optionOrder.length; i++) {
+    const body = bodies.get(paper.optionOrder[i]);
+    const ref = paper.optionRefs[i];
+    // Skip an option whose row has gone, rather than emitting a blank choice.
+    if (body === undefined || ref === undefined) continue;
+    out.push({ ref, body });
+  }
+  return out;
+}
+
+/**
+ * `optionId -> body` across several questions.
+ *
+ * Built from `loadOptionsForQuestions`, which reads a table with no answer
+ * column, so this map cannot carry a key even in principle.
+ */
+export function bodyIndex(
+  optionsByQuestion: ReadonlyMap<string, OptionRow[]>,
+): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const options of optionsByQuestion.values()) {
+    for (const option of options) out.set(option.id, option.body);
+  }
+  return out;
+}
+
+export function toAttemptQuestions(
+  paper: readonly DeliverablePaperRow[],
+  optionsByQuestion: ReadonlyMap<string, OptionRow[]>,
+): AttemptQuestion[] {
+  const bodies = bodyIndex(optionsByQuestion);
+  return paper.map((row) => ({
+    questionId: row.questionId,
+    chapterId: row.chapterId,
+    position: row.position,
+    stem: row.stem,
+    options: publicOptionsFor(row, bodies),
+  }));
+}
diff --git a/worker/src/handlers/practice.ts b/worker/src/handlers/practice.ts
new file mode 100644
index 0000000..897fa94
--- /dev/null
+++ b/worker/src/handlers/practice.ts
@@ -0,0 +1,430 @@
+/**
+ * Practice handlers - untimed, with the key revealed one question at a time
+ * AFTER the answer is committed.
+ *
+ * This is the one place the API discloses an answer key during a session, and
+ * it is a deliberate, bounded concession to what practice is actually for.
+ * The ordering is what makes it safe:
+ *
+ *   1. resolve the submitted ref against the paper stored for this attempt
+ *   2. join the key, compute correctness
+ *   3. WRITE the answer and the rollups - guarded so a replay cannot re-write
+ *   4. only then put `correctRef` and the explanation in the response
+ *
+ * So the key for question 7 becomes visible only once question 7 has been
+ * answered on the record. There is no endpoint that reveals question 8's key,
+ * and nothing in the paper payload hints at it.
+ *
+ * A practice session IS an attempt (`attempts.mode` in
+ * 'practice'|'srs'|'bookmark_review'|'weak_areas'). It used to be a separate
+ * `practice_sessions` table with its own questions and answers alongside the
+ * mock ones; one table means the rollup triggers, the history query and the
+ * archival job exist once instead of twice.
+ */
+
+import { fail } from '../shared/errors.ts';
+import { newId } from '../lib/ids.ts';
+import { resolveOptionRef } from '../domain/scoring.ts';
+import {
+  drawPracticeQuestions,
+  loadAnswerKey,
+  loadOptionsForQuestions,
+} from '../data/content.ts';
+import {
+  readBookmarkedQuestionIds,
+  readDueQuestionIds,
+  readWeakQuestionIds,
+} from '../data/progress.ts';
+import {
+  attemptStatus,
+  commitPracticeAnswer,
+  createAttemptBatch,
+  finishAttempt,
+  loadAttempt,
+  loadPaper,
+  loadPaperQuestionWithKey,
+  loadRecordedAnswers,
+  modeForPractice,
+  practiceModeFor,
+} from '../data/attempts.ts';
+import type { AttemptRow } from '../data/attempts.ts';
+import { consumeRateLimit, RATE_LIMITS } from '../data/infra.ts';
+import { attachRefs, attachRefsToOne, buildAttemptPaper, toAttemptQuestions } from './paper.ts';
+import type { RefContext } from './paper.ts';
+import { ok, requireUser, withIdempotency } from './context.ts';
+import type { HandlerContext, HandlerResult } from './context.ts';
+import type {
+  PracticeAnswerResponse,
+  PracticeAnswerResult,
+  PracticeFinishResponse,
+  PracticeSessionPaper,
+} from '../shared/types.ts';
+import type {
+  PracticeAnswerInput,
+  PracticeFinishInput,
+  PracticeStartInput,
+} from '../validation/schemas.ts';
+
+function refContextFor(ctx: HandlerContext, attempt: AttemptRow): RefContext {
+  return {
+    secret: ctx.config.permutationSecret,
+    optionSeed: attempt.option_seed,
+    attemptPublicId: attempt.public_id,
+  };
+}
+
+function newOptionSeed(): number {
+  const buf = new Uint32Array(1);
+  crypto.getRandomValues(buf);
+  return buf[0] & 0x7fffffff;
+}
+
+/**
+ * Chooses the question set for a practice mode. 1 D1 query in every case.
+ *
+ * The SOURCE of the questions is server-decided. A client asking for `wrong`
+ * mode gets the questions the server's own stats say it got wrong; it cannot
+ * hand over a list of question ids, which would otherwise be a way to farm the
+ * per-question reveal for a chosen set.
+ */
+async function pickPracticeQuestions(
+  ctx: HandlerContext,
+  userId: string,
+  input: PracticeStartInput,
+): Promise<Array<{ questionId: string; chapterId: string }>> {
+  switch (input.mode) {
+    case 'bookmarks':
+      return await readBookmarkedQuestionIds(ctx.db, userId, input.questionCount);
+    case 'wrong':
+      return await readWeakQuestionIds(ctx.db, userId, input.questionCount);
+    case 'srs':
+      return await readDueQuestionIds(ctx.db, {
+        userId,
+        now: ctx.clock.now(),
+        limit: input.questionCount,
+      });
+    case 'chapter':
+    case 'custom':
+    default:
+      return await drawPracticeQuestions(ctx.db, {
+        chapterIds: input.chapterIds ?? null,
+        limit: input.questionCount,
+      });
+  }
+}
+
+/**
+ * POST /api/practice/start - 8 D1 queries, constant in session size.
+ *
+ * idempotency 2, question pick 1, option bodies 1, attempt + paper + study
+ * session 3 (ONE batch), attempt read-back 1, paper read-back 1 -- the last
+ * two share the budget with the idempotency finalise.
+ */
+export async function startPractice(
+  ctx: HandlerContext,
+  input: PracticeStartInput,
+): Promise<HandlerResult<PracticeSessionPaper>> {
+  const auth = requireUser(ctx);
+
+  return await withIdempotency(
+    ctx,
+    {
+      userId: auth.user.id,
+      key: input.idempotencyKey,
+      endpoint: 'POST /api/practice/start',
+      body: input,
+    },
+    async () => {
+      if (input.mode === 'chapter' && (input.chapterIds?.length ?? 0) === 0) {
+        fail('BAD_REQUEST', 'Chapter practice needs at least one chapter.', {
+          fields: { chapterIds: 'Pick at least one chapter.' },
+        });
+      }
+
+      const picked = await pickPracticeQuestions(ctx, auth.user.id, input);
+      if (picked.length === 0) {
+        fail('INSUFFICIENT_CONTENT', 'No questions are available for that selection.');
+      }
+
+      const questionIds = picked.map((p) => p.questionId);
+      const optionsByQuestion = await loadOptionsForQuestions(ctx.db, questionIds);
+      const paper = buildAttemptPaper(
+        picked.map((p, index) => ({ ...p, position: index + 1 })),
+        optionsByQuestion,
+      );
+
+      if (paper.length === 0) {
+        fail('INSUFFICIENT_CONTENT', 'No answerable questions are available.');
+      }
+
+      const publicId = newId('pse');
+      const startedAt = ctx.clock.now();
+
+      // `attempts.chapter_id` is set only for a genuinely single-chapter set.
+      // A multi-chapter custom session leaves it NULL rather than naming one of
+      // them, because a column that sometimes means "all of these" and
+      // sometimes "this one" is worse than a NULL.
+      const chapterId =
+        input.chapterIds !== undefined && input.chapterIds.length === 1
+          ? input.chapterIds[0]
+          : null;
+
+      await ctx.db.batch(
+        createAttemptBatch({
+          publicId,
+          userId: auth.user.id,
+          mode: modeForPractice(input.mode),
+          templateId: null,
+          chapterId,
+          optionSeed: newOptionSeed(),
+          startedAt,
+          // Untimed, deliberately: practice is not an exam, and a NULL
+          // deadline is what makes `syncAnswers` refuse to clamp one.
+          deadlineAt: null,
+          paper,
+        }),
+      );
+
+      const attempt = await loadAttempt(ctx.db, publicId, auth.user.id);
+      if (!attempt) fail('INTERNAL', 'The practice session could not be created.');
+
+      const rows = attachRefs(
+        await loadPaper(ctx.db, publicId, auth.user.id),
+        refContextFor(ctx, attempt),
+      );
+
+      return ok<PracticeSessionPaper>({
+        sessionId: attempt.public_id,
+        mode: input.mode,
+        status: 'in_progress',
+        startedAt: attempt.started_at,
+        serverNow: startedAt,
+        questionCount: attempt.question_count,
+        questions: toAttemptQuestions(rows, optionsByQuestion),
+        answered: {},
+      });
+    },
+  );
+}
+
+/**
+ * GET /api/practice/sessions/:sessionId - 5 D1 queries.
+ *
+ * Resume. Replays the keys for questions already answered, and nothing else -
+ * so reloading mid-session restores exactly the knowledge the user had earned.
+ */
+export async function getPracticeSession(
+  ctx: HandlerContext,
+  sessionId: string,
+): Promise<HandlerResult<PracticeSessionPaper>> {
+  const auth = requireUser(ctx);
+
+  const attempt = await loadAttempt(ctx.db, sessionId, auth.user.id);
+  if (!attempt) fail('NOT_FOUND', 'That practice session does not exist.');
+
+  const rows = attachRefs(
+    await loadPaper(ctx.db, sessionId, auth.user.id),
+    refContextFor(ctx, attempt),
+  );
+  const optionsByQuestion = await loadOptionsForQuestions(
+    ctx.db,
+    rows.map((r) => r.questionId),
+  );
+  const committed = await loadRecordedAnswers(ctx.db, sessionId, auth.user.id);
+
+  // The key is loaded for the ALREADY ANSWERED questions and for no others.
+  // An unanswered question contributes nothing to this map, so resuming a
+  // session discloses exactly what the user had already earned - it is not a
+  // way to read the whole paper's key by starting a session and reloading.
+  const answeredIds = rows
+    .map((row) => row.questionId)
+    .filter((questionId) => committed.has(questionId));
+  const key = await loadAnswerKey(ctx.db, answeredIds);
+  const correctByQuestion = new Map(key.map((k) => [k.questionId, k.correctOptionId]));
+
+  const answered: Record<string, PracticeAnswerResult> = {};
+  for (const row of rows) {
+    const record = committed.get(row.questionId);
+    if (!record) continue;
+
+    const selectedIndex =
+      record.optionId === null ? -1 : row.optionOrder.indexOf(record.optionId);
+    const correctOptionId = correctByQuestion.get(row.questionId);
+    const correctIndex =
+      correctOptionId === undefined ? -1 : row.optionOrder.indexOf(correctOptionId);
+
+    answered[row.questionId] = {
+      questionId: row.questionId,
+      selectedRef: selectedIndex >= 0 ? (row.optionRefs[selectedIndex] ?? null) : null,
+      correctRef: correctIndex >= 0 ? (row.optionRefs[correctIndex] ?? '') : '',
+      isCorrect: record.isCorrect,
+      explanation: row.explanation,
+    };
+  }
+
+  return ok<PracticeSessionPaper>({
+    sessionId: attempt.public_id,
+    mode: practiceModeFor(attempt.mode),
+    status: attemptStatus(attempt),
+    startedAt: attempt.started_at,
+    serverNow: ctx.clock.now(),
+    questionCount: attempt.question_count,
+    questions: toAttemptQuestions(rows, optionsByQuestion),
+    answered,
+  });
+}
+
+/**
+ * POST /api/practice/answer - 7 D1 queries.
+ *
+ * rate limit 1, question + key 1, commit batch 4 (counted as 4 statements but
+ * one round trip), attempt counters read 1.
+ *
+ * IDEMPOTENT WITHOUT A KEY, on `(attemptId, questionId)`. The commit batch
+ * guards every conditional statement with `NOT EXISTS (an answer for this
+ * pair)` and the answer INSERT runs last, so replaying a queued offline answer
+ * converges instead of inflating the user's stats. An idempotency key is
+ * accepted anyway, for uniformity with the rest of the outbox.
+ */
+export async function answerPractice(
+  ctx: HandlerContext,
+  input: PracticeAnswerInput,
+): Promise<HandlerResult<PracticeAnswerResponse>> {
+  const auth = requireUser(ctx);
+
+  const limit = await consumeRateLimit(
+    ctx.db,
+    RATE_LIMITS.practiceAnswer,
+    auth.user.id,
+    ctx.clock.now(),
+  );
+  if (!limit.allowed) {
+    fail('RATE_LIMITED', 'Too many answers too quickly.', {
+      retryAfterMs: limit.retryAfterMs,
+    });
+  }
+
+  // Ownership is in the query: the join requires `attempts.user_id` to match,
+  // so another user's session id resolves to nothing.
+  const found = await loadPaperQuestionWithKey(ctx.db, {
+    publicId: input.sessionId,
+    userId: auth.user.id,
+    questionId: input.questionId,
+  });
+  if (!found) fail('QUESTION_NOT_ON_PAPER', 'That question is not in this session.');
+
+  if (found.row.attemptStatus !== 'in_progress') {
+    fail('ATTEMPT_NOT_IN_PROGRESS', 'This practice session is already finished.');
+  }
+  if (found.correctOptionId === null) {
+    fail('INTERNAL', 'That question has no answer key and cannot be scored.');
+  }
+
+  const question = attachRefsToOne(found.row, {
+    secret: ctx.config.permutationSecret,
+    optionSeed: found.row.optionSeed,
+    attemptPublicId: input.sessionId,
+  });
+
+  let selectedOptionId: string | null = null;
+  if (input.optionRef !== null) {
+    selectedOptionId = resolveOptionRef(question, input.optionRef);
+    if (selectedOptionId === null) {
+      fail('UNKNOWN_OPTION_REF', 'That option does not belong to this question.');
+    }
+  }
+
+  const isCorrect = selectedOptionId !== null && selectedOptionId === found.correctOptionId;
+  const now = ctx.clock.now();
+  const selectedIndex =
+    selectedOptionId === null ? -1 : question.optionOrder.indexOf(selectedOptionId);
+
+  await commitPracticeAnswer(ctx.db, {
+    attemptId: found.row.attemptId,
+    userId: auth.user.id,
+    questionId: input.questionId,
+    chapterId: found.row.chapterId,
+    selectedOptionId,
+    isCorrect,
+    deliveredPosition: selectedIndex >= 0 ? selectedIndex + 1 : null,
+    now,
+    // Recorded, never trusted for scoring. The schema has already bounded
+    // these; they exist so the revision schedule can be computed server-side
+    // the way `frontend/src/services/scheduler.ts` does it today.
+    latencyMs: input.latencyMs,
+    flaggedGuess: input.flaggedGuess,
+  });
+
+  // Read back rather than counting in memory: `answered_count` and
+  // `correct_count` are maintained by the trigger on the INSERT above, so the
+  // attempt row is the authority and a replayed answer reports the same totals.
+  const attempt = await loadAttempt(ctx.db, input.sessionId, auth.user.id);
+
+  const correctIndex = question.optionOrder.indexOf(found.correctOptionId);
+  const correctRef = correctIndex >= 0 ? (question.optionRefs[correctIndex] ?? '') : '';
+
+  // The reveal. Strictly after the write above, and only for this question.
+  return ok<PracticeAnswerResponse>({
+    questionId: input.questionId,
+    selectedRef: input.optionRef,
+    correctRef,
+    isCorrect,
+    explanation: found.row.explanation,
+    answeredCount: attempt?.answered_count ?? 0,
+    correctCount: attempt?.correct_count ?? 0,
+  });
+}
+
+/**
+ * POST /api/practice/finish - 5 D1 queries.
+ *
+ * Idempotent twice over: through the idempotency key, and through the
+ * `status = 'in_progress'` predicate on the UPDATE, so a replay returns the
+ * same totals rather than a 409.
+ */
+export async function finishPractice(
+  ctx: HandlerContext,
+  input: PracticeFinishInput,
+): Promise<HandlerResult<PracticeFinishResponse>> {
+  const auth = requireUser(ctx);
+
+  return await withIdempotency(
+    ctx,
+    {
+      userId: auth.user.id,
+      key: input.idempotencyKey,
+      endpoint: 'POST /api/practice/finish',
+      body: input,
+    },
+    async () => {
+      const now = ctx.clock.now();
+
+      const before = await loadAttempt(ctx.db, input.sessionId, auth.user.id);
+      if (!before) fail('NOT_FOUND', 'That practice session does not exist.');
+
+      await finishAttempt(ctx.db, {
+        attemptId: before.id,
+        userId: auth.user.id,
+        answered: before.answered_count,
+        correct: before.correct_count,
+        now,
+      });
+
+      const session = await loadAttempt(ctx.db, input.sessionId, auth.user.id);
+      if (!session) fail('NOT_FOUND', 'That practice session does not exist.');
+
+      const answered = session.answered_count;
+      const correct = session.correct_count;
+
+      return ok<PracticeFinishResponse>({
+        sessionId: session.public_id,
+        total: session.question_count,
+        correct,
+        incorrect: Math.max(0, answered - correct),
+        skipped: Math.max(0, session.question_count - answered),
+        accuracyPct: answered === 0 ? 0 : Math.round((correct / answered) * 100),
+        finishedAt: session.submitted_at ?? now,
+      });
+    },
+  );
+}
diff --git a/worker/src/handlers/progress.ts b/worker/src/handlers/progress.ts
new file mode 100644
index 0000000..73cefe1
--- /dev/null
+++ b/worker/src/handlers/progress.ts
@@ -0,0 +1,305 @@
+/**
+ * Progress, bookmarks and spaced repetition.
+ *
+ * All read-scoped by `userId` in the SQL, never filtered in TypeScript after
+ * the fact. D1 has no row-level security; a `WHERE user_id = ?` that is missing
+ * is a data breach, not a bug, so the data layer takes the id as a required
+ * argument and there is no overload that omits it.
+ */
+
+import { fail } from '../shared/errors.ts';
+import { dayKey } from '../lib/time.ts';
+import { computeStreaks } from '../domain/streaks.ts';
+import { loadOptionsForQuestions, loadQuestionStems } from '../data/content.ts';
+import { readAttemptHistory } from '../data/attempts.ts';
+import {
+  applySrsReview,
+  countBookmarks,
+  isBookmarked,
+  listBookmarks,
+  readActivityDays,
+  readDueCards,
+  readProgressStats,
+  readStreak,
+  setBookmark,
+} from '../data/progress.ts';
+import { browseOptionRef, browsePermutation } from '../lib/permute.ts';
+import { ok, requireUser } from './context.ts';
+import type { HandlerContext, HandlerResult } from './context.ts';
+import type {
+  AttemptHistoryItem,
+  AttemptHistoryResponse,
+  AttemptStatus,
+  BookmarkListResponse,
+  BookmarkSetResponse,
+  ProgressOverview,
+  SrsDueResponse,
+  SrsReviewResponse,
+} from '../shared/types.ts';
+import type {
+  BookmarkSetInput,
+  HistoryInput,
+  SrsDueInput,
+  SrsReviewInput,
+} from '../validation/schemas.ts';
+
+function toAttemptStatus(raw: string): AttemptStatus {
+  switch (raw) {
+    case 'in_progress':
+    case 'submitted':
+    case 'expired':
+    case 'abandoned':
+      return raw;
+    default:
+      return 'abandoned';
+  }
+}
+
+/**
+ * GET /api/progress/overview - 4 D1 queries.
+ *
+ * ONE call for the whole dashboard: chapter stats, streaks and recent attempts.
+ * The previous client computed all of this by reading every chapter's JSON and
+ * walking localStorage; this is four indexed queries over rollup tables.
+ *
+ * STREAKS COME FROM `streaks`, NOT FROM COUNTING DAYS. `current_length` and
+ * `longest_length` are maintained by the idempotent NQ-32a upsert on every
+ * answer and ratcheted by a trigger, so they already account for the
+ * freeze-token grace that a naive "count consecutive active days" derivation
+ * cannot see. `computeStreaks` over `study_sessions.local_date` still runs, for
+ * the heatmap and for today's count -- and as a cross-check: if the two
+ * disagree the stored row wins, because it is the one that saw every answer as
+ * it happened rather than reconstructing them from a 400-day window.
+ */
+export async function getProgressOverview(
+  ctx: HandlerContext,
+): Promise<HandlerResult<ProgressOverview>> {
+  const auth = requireUser(ctx);
+  const now = ctx.clock.now();
+
+  const stats = await readProgressStats(ctx.db, auth.user.id);
+  const days = await readActivityDays(ctx.db, auth.user.id);
+  const stored = await readStreak(ctx.db, auth.user.id);
+  const history = await readAttemptHistory(ctx.db, {
+    userId: auth.user.id,
+    limit: 10,
+    beforeStartedAt: null,
+  });
+
+  const recent: AttemptHistoryItem[] = history.map((row) => ({
+    kind: row.kind,
+    id: row.id,
+    label: row.label,
+    score: row.score,
+    total: row.total,
+    accuracyPct: row.total === 0 ? 0 : Math.round((row.score / row.total) * 100),
+    at: row.at,
+    status: toAttemptStatus(row.status),
+  }));
+
+  const derived = computeStreaks(days, dayKey(now));
+
+  return ok<ProgressOverview>({
+    stats,
+    streak: {
+      ...derived,
+      currentStreak: stored?.current_length ?? derived.currentStreak,
+      longestStreak: stored?.longest_length ?? derived.longestStreak,
+    },
+    recent,
+  });
+}
+
+/** GET /api/progress/history - 1 D1 query. Cursor-paged. */
+export async function getAttemptHistory(
+  ctx: HandlerContext,
+  input: HistoryInput,
+): Promise<HandlerResult<AttemptHistoryResponse>> {
+  const auth = requireUser(ctx);
+
+  // The cursor is the `started_at` of the last row seen. Opaque to the client
+  // by convention, and validated as a token, so a malformed cursor is a 400
+  // rather than a NaN that silently pages from the beginning.
+  let before: number | null = null;
+  if (input.cursor !== undefined) {
+    const parsed = Number.parseInt(input.cursor, 10);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+      fail('BAD_REQUEST', 'Invalid cursor.', { fields: { cursor: 'Malformed.' } });
+    }
+    before = parsed;
+  }
+
+  const rows = await readAttemptHistory(ctx.db, {
+    userId: auth.user.id,
+    limit: input.limit,
+    beforeStartedAt: before,
+  });
+
+  const items: AttemptHistoryItem[] = rows.map((row) => ({
+    kind: row.kind,
+    id: row.id,
+    label: row.label,
+    score: row.score,
+    total: row.total,
+    accuracyPct: row.total === 0 ? 0 : Math.round((row.score / row.total) * 100),
+    at: row.at,
+    status: toAttemptStatus(row.status),
+  }));
+
+  return ok<AttemptHistoryResponse>({
+    items,
+    nextCursor:
+      items.length === input.limit ? String(items[items.length - 1].at) : null,
+  });
+}
+
+// --- Bookmarks --------------------------------------------------------------
+
+/** GET /api/bookmarks - 1 D1 query. */
+export async function getBookmarks(
+  ctx: HandlerContext,
+): Promise<HandlerResult<BookmarkListResponse>> {
+  const auth = requireUser(ctx);
+  return ok<BookmarkListResponse>({ items: await listBookmarks(ctx.db, auth.user.id) });
+}
+
+/**
+ * PUT /api/bookmarks - 3 D1 queries.
+ *
+ * Expressed as a desired end state (`desired: true | false`) rather than as
+ * add/remove verbs, which is what makes it replay-safe: `INSERT ... ON CONFLICT
+ * DO NOTHING` and a `DELETE` of a missing row both converge, so the offline
+ * outbox can replay the same entry any number of times. An idempotency key is
+ * accepted but not required, and the handler ignores it when absent rather than
+ * refusing the request.
+ */
+export async function putBookmark(
+  ctx: HandlerContext,
+  input: BookmarkSetInput,
+): Promise<HandlerResult<BookmarkSetResponse>> {
+  const auth = requireUser(ctx);
+  const now = ctx.clock.now();
+
+  await setBookmark(ctx.db, {
+    userId: auth.user.id,
+    questionId: input.questionId,
+    desired: input.desired,
+    now,
+  });
+
+  // Read back rather than trusting the request: adding a bookmark for an
+  // unpublished question is a silent no-op in the SQL, and the client must be
+  // told the truth about the resulting state.
+  const bookmarked = await isBookmarked(ctx.db, auth.user.id, input.questionId);
+  const total = await countBookmarks(ctx.db, auth.user.id);
+
+  return ok<BookmarkSetResponse>({
+    questionId: input.questionId,
+    bookmarked,
+    total,
+  });
+}
+
+// --- Spaced repetition ------------------------------------------------------
+
+/**
+ * GET /api/srs/due - 3 D1 queries.
+ *
+ * The due queue with question payloads, so starting a review session is one
+ * round trip. Options are permuted with the stable browse permutation and
+ * carry no key.
+ */
+export async function getSrsDue(
+  ctx: HandlerContext,
+  input: SrsDueInput,
+): Promise<HandlerResult<SrsDueResponse>> {
+  const auth = requireUser(ctx);
+  const now = ctx.clock.now();
+
+  const cards = await readDueCards(ctx.db, {
+    userId: auth.user.id,
+    now,
+    limit: input.limit,
+  });
+
+  if (cards.length === 0) {
+    return ok<SrsDueResponse>({ serverNow: now, dueCount: 0, questions: [], cards: {} });
+  }
+
+  const questionIds = cards.map((c) => c.questionId);
+  const stems = await loadQuestionStems(ctx.db, questionIds);
+  const optionsByQuestion = await loadOptionsForQuestions(ctx.db, questionIds);
+
+  const stemById = new Map(stems.map((s) => [s.id, s]));
+  const cardMap: Record<string, (typeof cards)[number]> = {};
+  for (const card of cards) cardMap[card.questionId] = card;
+
+  return ok<SrsDueResponse>({
+    serverNow: now,
+    dueCount: cards.length,
+    questions: cards
+      .map((card, index) => {
+        const stem = stemById.get(card.questionId);
+        if (!stem) return null;
+        const permuted = browsePermutation(
+          optionsByQuestion.get(card.questionId) ?? [],
+          ctx.config.permutationSecret,
+          auth.user.id,
+          card.questionId,
+        );
+        return {
+          questionId: card.questionId,
+          chapterId: stem.chapter_id,
+          position: index + 1,
+          stem: stem.stem,
+          // Opaque, for the same reason as the chapter-browsing payload: an
+          // option id carries its authored ordinal, and the published JSON
+          // turns that ordinal into the key.
+          options: permuted.map((o) => ({
+            ref: browseOptionRef(
+              ctx.config.permutationSecret,
+              auth.user.id,
+              card.questionId,
+              o.id,
+            ),
+            body: o.body,
+          })),
+        };
+      })
+      .filter((q): q is NonNullable<typeof q> => q !== null),
+    cards: cardMap,
+  });
+}
+
+/**
+ * POST /api/srs/review - 3 or 4 D1 queries.
+ *
+ * Idempotent through the `revision` field rather than through a key: the write
+ * carries `AND revision = ?expected`, so a replayed outbox entry whose revision
+ * the server has already moved past changes nothing and comes back with
+ * `applied: false` and the current card. That is strictly better than a key
+ * here, because it also makes a stale review from a second device a no-op
+ * instead of a conflict.
+ */
+export async function reviewSrsCard(
+  ctx: HandlerContext,
+  input: SrsReviewInput,
+): Promise<HandlerResult<SrsReviewResponse>> {
+  const auth = requireUser(ctx);
+  const now = ctx.clock.now();
+
+  const stems = await loadQuestionStems(ctx.db, [input.questionId]);
+  if (stems.length === 0) fail('NOT_FOUND', 'That question does not exist.');
+
+  const outcome = await applySrsReview(ctx.db, {
+    userId: auth.user.id,
+    questionId: input.questionId,
+    grade: input.grade,
+    expectedRevision: input.revision,
+    now,
+  });
+
+  if (!outcome) fail('CONFLICT', 'That card could not be reviewed.');
+
+  return ok<SrsReviewResponse>({ card: outcome.card, applied: outcome.applied });
+}
diff --git a/worker/src/index.ts b/worker/src/index.ts
new file mode 100644
index 0000000..d302419
--- /dev/null
+++ b/worker/src/index.ts
@@ -0,0 +1,412 @@
+/**
+ * The Worker entry point: Hono wiring and nothing else.
+ *
+ * Every route in this file does exactly four things - validate, build a
+ * context, call ONE handler from `handlers/`, serialise the result. No route
+ * contains a branch on business state, no route writes SQL, and no route reads
+ * `question_options`. That is deliberate: it is what lets the entire real logic
+ * path be tested under `node --test` against a local SQLite database without
+ * Hono, a Worker runtime, or a network.
+ *
+ * NOTE ON DEPENDENCIES. `hono` is imported here and in nowhere else. It is not
+ * yet in a package manifest - `worker/package.json` and `worker/wrangler.toml`
+ * are owned outside this change - so this single file will not type-check or
+ * bundle until `npm i hono` has been run in `worker/`. Everything the tests
+ * cover is reachable without it.
+ */
+
+import { Hono } from 'hono';
+
+import { Db } from './data/d1.ts';
+import { loadConfig } from './env.ts';
+import type { Env } from './env.ts';
+import { systemClock } from './lib/time.ts';
+import { handleScheduled, type ScheduledEventLike } from './jobs/index.ts';
+import { readCookie, SESSION_COOKIE } from './lib/cookies.ts';
+import { toErrorResponse } from './shared/errors.ts';
+import type { HandlerContext, HandlerResult } from './handlers/context.ts';
+import { hashIp, resolveSession } from './handlers/auth.ts';
+import * as auth from './handlers/auth.ts';
+import * as content from './handlers/content.ts';
+import * as mock from './handlers/mock.ts';
+import * as practice from './handlers/practice.ts';
+import * as progress from './handlers/progress.ts';
+import * as moderation from './handlers/moderation.ts';
+import { pathId, queryObject, readJsonBody, validate } from './middleware/validate.ts';
+import {
+  adminPublishSchema,
+  adminQueueQuerySchema,
+  adminTriageSchema,
+  auditQuerySchema,
+  bookmarkSetSchema,
+  chapterQuestionsQuerySchema,
+  googleCallbackSchema,
+  historyQuerySchema,
+  loginSchema,
+  mockStartSchema,
+  mockSubmitSchema,
+  mockSyncSchema,
+  practiceAnswerSchema,
+  practiceFinishSchema,
+  practiceStartSchema,
+  reportSubmitSchema,
+  searchQuerySchema,
+  signupSchema,
+  srsDueQuerySchema,
+  srsReviewSchema,
+  upgradeAnonymousSchema,
+} from './validation/schemas.ts';
+
+type Vars = { ctx: HandlerContext };
+
+const app = new Hono<{ Bindings: Env; Variables: Vars }>();
+
+/**
+ * Builds the handler context, once per request.
+ *
+ * Costs 1 D1 query when a session cookie is present and 0 when it is not. The
+ * session touch is applied here, and only when it is actually due, so a
+ * `last_seen_at` write does not land on every authenticated request - at 100k
+ * row writes a day, that would be a meaningful slice of the budget spent on
+ * liveness alone.
+ */
+app.use('/api/*', async (c, next) => {
+  const config = loadConfig(c.env);
+  const db = new Db(c.env.DB, { budget: config.queryBudget });
+
+  const ipHash = await hashIp(
+    c.req.header('cf-connecting-ip') ?? null,
+    config.permutationSecret,
+  );
+
+  const sessionId = readCookie(c.req.header('cookie') ?? null, SESSION_COOKIE);
+  const resolved = await resolveSession({ db, clock: systemClock }, sessionId);
+
+  if (resolved.touch) {
+    await db.batch([resolved.touch]);
+  }
+
+  const ctx: HandlerContext = {
+    db,
+    clock: systemClock,
+    config,
+    auth: resolved.auth,
+    meta: { ipHash, userAgent: c.req.header('user-agent') ?? null },
+    cookies: [],
+  };
+
+  c.set('ctx', ctx);
+  await next();
+});
+
+/** CORS for the configured app origin only. No wildcard, ever. */
+app.use('/api/*', async (c, next) => {
+  const config = loadConfig(c.env);
+  const origin = c.req.header('origin');
+
+  if (c.req.method === 'OPTIONS') {
+    return new Response(null, {
+      status: 204,
+      headers: corsHeaders(origin, config.appOrigin),
+    });
+  }
+
+  await next();
+
+  for (const [name, value] of Object.entries(corsHeaders(origin, config.appOrigin))) {
+    c.res.headers.set(name, value);
+  }
+});
+
+function corsHeaders(origin: string | undefined, appOrigin: string): Record<string, string> {
+  // Credentials are cookies, so `Access-Control-Allow-Origin` cannot be `*`.
+  // An unrecognised origin gets no CORS headers at all, which the browser turns
+  // into a blocked request - the correct outcome.
+  if (origin !== appOrigin) return { vary: 'Origin' };
+  return {
+    'access-control-allow-origin': appOrigin,
+    'access-control-allow-credentials': 'true',
+    'access-control-allow-methods': 'GET,POST,PUT,DELETE,OPTIONS',
+    'access-control-allow-headers': 'content-type',
+    'access-control-max-age': '86400',
+    vary: 'Origin',
+  };
+}
+
+/**
+ * Serialises a handler result, attaching cookies, the replay marker, and the
+ * measured D1 cost.
+ *
+ * `X-D1-Queries` is on every response on purpose: the per-invocation query
+ * limit is the tightest constraint this platform has, and a number in a
+ * response header is the difference between knowing the cost and guessing it.
+ */
+function send<T>(ctx: HandlerContext, result: HandlerResult<T>): Response {
+  const headers = new Headers({ 'content-type': 'application/json; charset=utf-8' });
+  for (const cookie of ctx.cookies) headers.append('set-cookie', cookie);
+  headers.set('x-d1-queries', String(ctx.db.queryCount));
+  if (result.replayed) headers.set('idempotent-replay', 'true');
+
+  // A 302 from `googleStart` / `googleCallback` carries its target in the body.
+  if (result.status === 302 && typeof result.body === 'object' && result.body !== null) {
+    const location = (result.body as { location?: unknown }).location;
+    if (typeof location === 'string') {
+      headers.set('location', location);
+      return new Response(null, { status: 302, headers });
+    }
+  }
+
+  return new Response(JSON.stringify(result.body), { status: result.status, headers });
+}
+
+/** The single error boundary. Nothing below it leaks a D1 message. */
+app.onError((err, c) => {
+  const { status, body, logMessage } = toErrorResponse(err);
+  console.error(`[api] ${c.req.method} ${c.req.path} -> ${status}: ${logMessage}`);
+
+  const headers = new Headers({ 'content-type': 'application/json; charset=utf-8' });
+  const ctx = c.get('ctx') as HandlerContext | undefined;
+  if (ctx) {
+    for (const cookie of ctx.cookies) headers.append('set-cookie', cookie);
+    headers.set('x-d1-queries', String(ctx.db.queryCount));
+  }
+  if (body.error.retryAfterMs !== undefined) {
+    headers.set('retry-after', String(Math.ceil(body.error.retryAfterMs / 1000)));
+  }
+
+  return new Response(JSON.stringify(body), { status, headers });
+});
+
+app.notFound(
+  () =>
+    new Response(JSON.stringify({ error: { code: 'NOT_FOUND', message: 'No such endpoint.' } }), {
+      status: 404,
+      headers: { 'content-type': 'application/json; charset=utf-8' },
+    }),
+);
+
+// --- Bootstrap & content ----------------------------------------------------
+
+app.get('/api/bootstrap', async (c) => {
+  const ctx = c.get('ctx');
+  return send(ctx, await content.bootstrap(ctx));
+});
+
+app.get('/api/content/chapters', async (c) => {
+  const ctx = c.get('ctx');
+  return send(ctx, await content.getChapters(ctx));
+});
+
+app.get('/api/content/mock-templates', async (c) => {
+  const ctx = c.get('ctx');
+  return send(ctx, await content.getMockTemplates(ctx));
+});
+
+app.get('/api/content/chapters/:chapterId/questions', async (c) => {
+  const ctx = c.get('ctx');
+  const input = validate(chapterQuestionsQuerySchema, {
+    ...queryObject(new URL(c.req.url), ['offset', 'limit']),
+    chapterId: pathId(c.req.param('chapterId'), 'chapterId'),
+  });
+  return send(ctx, await content.getChapterQuestions(ctx, input));
+});
+
+app.get('/api/content/search', async (c) => {
+  const ctx = c.get('ctx');
+  const input = validate(searchQuerySchema, queryObject(new URL(c.req.url), ['limit']));
+  return send(ctx, await content.search(ctx, input));
+});
+
+// --- Auth -------------------------------------------------------------------
+
+app.get('/api/auth/session', async (c) => {
+  const ctx = c.get('ctx');
+  return send(ctx, await auth.readSession(ctx));
+});
+
+app.post('/api/auth/anonymous', async (c) => {
+  const ctx = c.get('ctx');
+  return send(ctx, await auth.startAnonymousSession(ctx));
+});
+
+app.post('/api/auth/signup', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, signupSchema);
+  return send(ctx, await auth.signup(ctx, input));
+});
+
+app.post('/api/auth/login', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, loginSchema);
+  return send(ctx, await auth.login(ctx, input));
+});
+
+app.post('/api/auth/logout', async (c) => {
+  const ctx = c.get('ctx');
+  return send(ctx, await auth.logout(ctx));
+});
+
+app.post('/api/auth/upgrade', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, upgradeAnonymousSchema);
+  return send(ctx, await auth.upgradeAnonymous(ctx, input));
+});
+
+app.get('/api/auth/google/start', async (c) => {
+  const ctx = c.get('ctx');
+  const redirectTo = new URL(c.req.url).searchParams.get('redirect_to');
+  return send(ctx, await auth.googleStart(ctx, redirectTo));
+});
+
+app.get('/api/auth/google/callback', async (c) => {
+  const ctx = c.get('ctx');
+  const input = validate(googleCallbackSchema, queryObject(new URL(c.req.url)));
+  return send(ctx, await auth.googleCallback(ctx, input, globalThis.fetch as never));
+});
+
+// --- Mock -------------------------------------------------------------------
+
+app.post('/api/mock/start', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, mockStartSchema);
+  return send(ctx, await mock.startMock(ctx, input));
+});
+
+app.get('/api/mock/attempts/:attemptId', async (c) => {
+  const ctx = c.get('ctx');
+  const attemptId = pathId(c.req.param('attemptId'), 'attemptId');
+  return send(ctx, await mock.getMockAttempt(ctx, attemptId));
+});
+
+app.get('/api/mock/attempts/:attemptId/review', async (c) => {
+  const ctx = c.get('ctx');
+  const attemptId = pathId(c.req.param('attemptId'), 'attemptId');
+  return send(ctx, await mock.getMockReview(ctx, attemptId));
+});
+
+app.post('/api/mock/sync', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, mockSyncSchema);
+  return send(ctx, await mock.syncMock(ctx, input));
+});
+
+app.post('/api/mock/submit', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, mockSubmitSchema);
+  return send(ctx, await mock.submitMock(ctx, input));
+});
+
+// --- Practice ---------------------------------------------------------------
+
+app.post('/api/practice/start', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, practiceStartSchema);
+  return send(ctx, await practice.startPractice(ctx, input));
+});
+
+app.get('/api/practice/sessions/:sessionId', async (c) => {
+  const ctx = c.get('ctx');
+  const sessionId = pathId(c.req.param('sessionId'), 'sessionId');
+  return send(ctx, await practice.getPracticeSession(ctx, sessionId));
+});
+
+app.post('/api/practice/answer', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, practiceAnswerSchema);
+  return send(ctx, await practice.answerPractice(ctx, input));
+});
+
+app.post('/api/practice/finish', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, practiceFinishSchema);
+  return send(ctx, await practice.finishPractice(ctx, input));
+});
+
+// --- Progress, bookmarks, SRS ----------------------------------------------
+
+app.get('/api/progress/overview', async (c) => {
+  const ctx = c.get('ctx');
+  return send(ctx, await progress.getProgressOverview(ctx));
+});
+
+app.get('/api/progress/history', async (c) => {
+  const ctx = c.get('ctx');
+  const input = validate(historyQuerySchema, queryObject(new URL(c.req.url), ['limit']));
+  return send(ctx, await progress.getAttemptHistory(ctx, input));
+});
+
+app.get('/api/bookmarks', async (c) => {
+  const ctx = c.get('ctx');
+  return send(ctx, await progress.getBookmarks(ctx));
+});
+
+app.put('/api/bookmarks', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, bookmarkSetSchema);
+  return send(ctx, await progress.putBookmark(ctx, input));
+});
+
+app.get('/api/srs/due', async (c) => {
+  const ctx = c.get('ctx');
+  const input = validate(srsDueQuerySchema, queryObject(new URL(c.req.url), ['limit']));
+  return send(ctx, await progress.getSrsDue(ctx, input));
+});
+
+app.post('/api/srs/review', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, srsReviewSchema);
+  return send(ctx, await progress.reviewSrsCard(ctx, input));
+});
+
+// --- Reports ----------------------------------------------------------------
+
+app.post('/api/reports', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, reportSubmitSchema);
+  return send(ctx, await moderation.submitErrataReport(ctx, input));
+});
+
+app.get('/api/reports', async (c) => {
+  const ctx = c.get('ctx');
+  return send(ctx, await moderation.listMyReports(ctx));
+});
+
+// --- Admin ------------------------------------------------------------------
+
+app.get('/api/admin/reports', async (c) => {
+  const ctx = c.get('ctx');
+  const input = validate(adminQueueQuerySchema, queryObject(new URL(c.req.url), ['limit']));
+  return send(ctx, await moderation.getReportQueue(ctx, input));
+});
+
+app.post('/api/admin/reports/triage', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, adminTriageSchema);
+  return send(ctx, await moderation.triage(ctx, input));
+});
+
+app.post('/api/admin/questions/publish', async (c) => {
+  const ctx = c.get('ctx');
+  const input = await readJsonBody(c.req.raw, adminPublishSchema);
+  return send(ctx, await moderation.publishQuestions(ctx, input));
+});
+
+app.get('/api/admin/audit', async (c) => {
+  const ctx = c.get('ctx');
+  const input = validate(auditQuerySchema, queryObject(new URL(c.req.url), ['limit']));
+  return send(ctx, await moderation.getAuditLog(ctx, input));
+});
+
+/**
+ * The Worker's two entry points.
+ *
+ * Exporting the Hono app directly gave Cloudflare a `fetch` handler and no
+ * `scheduled` handler, so all three declared crons fired into nothing. They
+ * are routed by cron expression in `src/jobs/`.
+ */
+export default {
+  fetch: app.fetch,
+  scheduled: async (event: ScheduledEventLike, env: Env): Promise<void> => {
+    await handleScheduled(event, env);
+  },
+};
diff --git a/worker/src/jobs/index.ts b/worker/src/jobs/index.ts
new file mode 100644
index 0000000..926e372
--- /dev/null
+++ b/worker/src/jobs/index.ts
@@ -0,0 +1,184 @@
+/**
+ * The scheduled-job router.
+ *
+ * `wrangler.toml` declared three crons and nothing implemented them: the
+ * Worker exported a Hono app, which gives Cloudflare a `fetch` handler and no
+ * `scheduled` handler at all. Cloudflare fires the trigger, finds nothing to
+ * call, and the job silently never runs. The visible consequence was
+ * `attempt_answers` growing without bound toward D1's 500 MB wall, with the
+ * first symptom being every write failing.
+ *
+ * DISPATCH IS BY CRON STRING
+ * --------------------------
+ * `ScheduledController.cron` carries the exact expression from
+ * `wrangler.toml`, which is the only thing distinguishing one trigger from
+ * another. The mapping is therefore a literal table, and an unrecognised
+ * expression THROWS rather than defaulting to a job: editing a schedule in
+ * `wrangler.toml` without editing this table is a mistake that should surface
+ * on the first firing, not silently run the wrong work at the wrong hour.
+ *
+ * EVERY JOB GETS ITS OWN QUERY BUDGET
+ * -----------------------------------
+ * The request-path budget (45 queries, or whatever `D1_QUERY_BUDGET` says)
+ * exists to keep page loads inside D1's 50-queries-per-invocation limit on the
+ * free plan. A cron invocation is not a page load: it is allowed to use the
+ * whole limit, and the batching inside each job is what keeps it there. Using
+ * the request budget would make the retention job give up after nine delete
+ * batches for no reason.
+ *
+ * FAILURES ARE LOGGED AND RETHROWN
+ * --------------------------------
+ * Cloudflare records a failed scheduled invocation, and that record is the
+ * only alarm this platform has. Swallowing the error would turn a broken
+ * nightly job into silence, which is the failure mode that produced this file.
+ */
+
+import { Db } from '../data/d1.ts';
+import type { Env } from '../env.ts';
+import { systemClock, type Clock } from '../lib/time.ts';
+import { runAnswerRetention } from './retention.ts';
+import { runNightlySweep } from './sweep.ts';
+import { runLeaderboardSnapshot } from './leaderboard.ts';
+
+/** Must match `[triggers] crons` in wrangler.toml, expression for expression. */
+export const CRON_RETENTION = '10 2 * * *';
+export const CRON_SWEEP = '40 2 * * *';
+export const CRON_LEADERBOARD = '5 * * * *';
+
+/**
+ * Queries one cron invocation may spend.
+ *
+ * D1's free plan allows 50 per Worker invocation; this sits just under it so
+ * that exceeding it raises `QueryBudgetExceeded` with the offending statement
+ * rather than a bare D1 error.
+ */
+export const JOB_QUERY_BUDGET = 48;
+
+/**
+ * Row writes the retention job may spend per run.
+ *
+ * A quarter of the free plan's 100,000 daily allowance. The job stops cleanly
+ * when it is spent and resumes the next night, because a retention pass that
+ * exhausts the day's writes takes the whole platform read-only — far worse
+ * than a backlog that drains over a few nights.
+ */
+export const RETENTION_ROW_WRITE_BUDGET = 25_000;
+
+const DEFAULT_RETENTION_DAYS = 90;
+
+export interface ScheduledDeps {
+  readonly clock?: Clock;
+  readonly budget?: number;
+}
+
+/**
+ * Minimal shape of Cloudflare's `ScheduledController`.
+ *
+ * Declared locally for the same reason `data/d1.ts` declares `D1Database`:
+ * this codebase depends on the contract, not on `@cloudflare/workers-types`.
+ */
+export interface ScheduledEventLike {
+  readonly cron: string;
+  readonly scheduledTime?: number;
+}
+
+export type JobOutcome = Record<string, unknown>;
+
+export async function handleScheduled(
+  event: ScheduledEventLike,
+  env: Env,
+  deps: ScheduledDeps = {},
+): Promise<JobOutcome> {
+  const clock = deps.clock ?? systemClock;
+  const db = new Db(env.DB, { budget: deps.budget ?? JOB_QUERY_BUDGET });
+  // Prefer the scheduled time over the clock: a retried or delayed invocation
+  // should compute the window it was scheduled for, not the one it happens to
+  // be running in.
+  const now = event.scheduledTime ?? clock.now();
+  const started = Date.now();
+
+  try {
+    const result = await dispatch(event.cron, db, env, now);
+    const outcome: JobOutcome = {
+      cron: event.cron,
+      ok: true,
+      ms: Date.now() - started,
+      queries: db.queryCount,
+      ...result,
+    };
+    console.log(JSON.stringify(outcome));
+    return outcome;
+  } catch (err) {
+    console.error(
+      JSON.stringify({
+        cron: event.cron,
+        ok: false,
+        ms: Date.now() - started,
+        queries: db.queryCount,
+        error: err instanceof Error ? err.message : String(err),
+      }),
+    );
+    // Rethrow: a failed invocation is the only alarm there is.
+    throw err;
+  }
+}
+
+async function dispatch(
+  cron: string,
+  db: Db,
+  env: Env,
+  now: number,
+): Promise<JobOutcome> {
+  switch (cron) {
+    case CRON_RETENTION: {
+      const days = retentionDays(env);
+      const result = await runAnswerRetention(db, {
+        submittedRetentionDays: days,
+        rowWriteBudget: RETENTION_ROW_WRITE_BUDGET,
+        now,
+      });
+      return { job: 'answer-retention', retentionDays: days, ...result };
+    }
+
+    case CRON_SWEEP: {
+      const result = await runNightlySweep(db, { now });
+      return { job: 'nightly-sweep', ...result };
+    }
+
+    case CRON_LEADERBOARD: {
+      const result = await runLeaderboardSnapshot(db, { now });
+      return { job: 'leaderboard-snapshot', ...result };
+    }
+
+    default:
+      throw new Error(
+        `No scheduled job is registered for cron "${cron}". ` +
+          'Add it to src/jobs/index.ts or remove it from wrangler.toml.',
+      );
+  }
+}
+
+/**
+ * `ANSWER_RETENTION_DAYS` from the environment.
+ *
+ * Bounded at 7 days minimum because the submit path needs the raw answers to
+ * render a review, and at 400 maximum because beyond a year the free plan's
+ * 500 MB ceiling is the binding constraint rather than the policy. An
+ * unparseable value throws: silently falling back to a default would be the
+ * difference between a 7-day and a 180-day window, decided by a typo.
+ */
+export function retentionDays(env: Env): number {
+  const raw = env.ANSWER_RETENTION_DAYS;
+  if (raw === undefined || raw.trim().length === 0) return DEFAULT_RETENTION_DAYS;
+  // Digits only. `Number.parseInt` alone stops at the first non-digit, so
+  // "90 days" would parse as 90 and a value that was never a number would
+  // silently become policy.
+  const trimmed = raw.trim();
+  const n = /^\d+$/.test(trimmed) ? Number.parseInt(trimmed, 10) : Number.NaN;
+  if (!Number.isInteger(n) || n < 7 || n > 400) {
+    throw new Error(
+      `Invalid ANSWER_RETENTION_DAYS "${raw}"; expected an integer between 7 and 400.`,
+    );
+  }
+  return n;
+}
diff --git a/worker/src/jobs/leaderboard.ts b/worker/src/jobs/leaderboard.ts
new file mode 100644
index 0000000..f3a2fab
--- /dev/null
+++ b/worker/src/jobs/leaderboard.ts
@@ -0,0 +1,360 @@
+/**
+ * Leaderboard snapshots.
+ *
+ * The board is NEVER computed on a request path. `migrations/0006_engagement`
+ * is explicit about why: ranking means aggregating every submitted attempt in
+ * a period, which is the one scan this platform tolerates, and tolerating it
+ * once an hour is different from tolerating it per page view. The read path
+ * (NQ-35) fetches the latest snapshot row and renders `top_json` without a
+ * single join.
+ *
+ * WHAT IS RANKED
+ * --------------
+ * Global board only, metric `correct_answers`, over four periods: today, this
+ * week, this month, and all time. Chapter- and template-scoped boards are
+ * expressible in the schema and deliberately not computed — each additional
+ * scope multiplies this job's cost, and nothing in the app reads them yet.
+ *
+ * Periods are bucketed in Nepal Standard Time (`lib/time.ts`), not UTC. A 9pm
+ * study session in Kathmandu belongs to that day, which is the same reason
+ * streaks are bucketed that way.
+ *
+ * OPT-IN IS ENFORCED HERE
+ * -----------------------
+ * `user_profiles.leaderboard_opt_in` defaults to 0, and this job filters on
+ * it. That is the only place it can be enforced: once a name is baked into
+ * `top_json`, no read-path filter can take it back out. A user who opts out is
+ * gone at the next snapshot rather than leaving a gap in a join — which is
+ * exactly why 0006 denormalises the display fields.
+ *
+ * Soft-deleted users are excluded for the same reason: their rows survive so
+ * that attempt history stays intact, but they must not appear on a board.
+ */
+
+import { Db } from '../data/d1.ts';
+import { T } from '../data/tables.ts';
+import { sql, type PendingStatement } from '../data/d1.ts';
+import { ACTIVITY_TZ_OFFSET_MINUTES, MINUTE, dayKey } from '../lib/time.ts';
+
+/** How many ranked users each snapshot stores. */
+export const TOP_N = 50;
+
+/** Snapshots older than this are pruned, except `all_time`. */
+export const SNAPSHOT_RETENTION_DAYS = 14;
+
+/** Children deleted per prune batch. 0006 names 50 for exactly this reason. */
+export const PRUNE_BATCH = 50;
+
+export type Period = 'daily' | 'weekly' | 'monthly' | 'all_time';
+
+/** `all_time` has no real start; 0006 fixes it at this sentinel. */
+export const ALL_TIME_PERIOD_START = '0001-01-01';
+
+export interface LeaderboardConfig {
+  readonly now: number;
+  readonly topN?: number;
+}
+
+export interface BoardResult {
+  readonly period: Period;
+  readonly periodStart: string;
+  readonly snapshotId: number;
+  readonly entrants: number;
+  readonly ranked: number;
+  readonly computeMs: number;
+}
+
+export interface LeaderboardResult {
+  readonly boards: readonly BoardResult[];
+  readonly snapshotsPruned: number;
+  readonly entriesPruned: number;
+}
+
+interface AggregateRow {
+  user_id: string;
+  display_name: string;
+  avatar_url: string | null;
+  score: number;
+  answered: number;
+}
+
+/**
+ * Inclusive start of a period, as epoch ms, in the activity timezone.
+ *
+ * `all_time` returns 0 rather than a date, so one code path covers all four
+ * periods and the aggregate query never needs a special case.
+ */
+export function periodWindow(
+  period: Period,
+  now: number,
+): { startMs: number; periodStart: string } {
+  if (period === 'all_time') {
+    return { startMs: 0, periodStart: ALL_TIME_PERIOD_START };
+  }
+
+  const offset = ACTIVITY_TZ_OFFSET_MINUTES * MINUTE;
+  // Work in a shifted clock so that "midnight" means midnight in Kathmandu,
+  // then shift back to get a real UTC instant to compare `submitted_at` to.
+  const shifted = new Date(now + offset);
+  const y = shifted.getUTCFullYear();
+  const m = shifted.getUTCMonth();
+  const d = shifted.getUTCDate();
+
+  let startShifted: number;
+  if (period === 'daily') {
+    startShifted = Date.UTC(y, m, d);
+  } else if (period === 'weekly') {
+    // Week starts Sunday, matching how the streak display groups days.
+    startShifted = Date.UTC(y, m, d - shifted.getUTCDay());
+  } else {
+    startShifted = Date.UTC(y, m, 1);
+  }
+
+  const startMs = startShifted - offset;
+  return { startMs, periodStart: dayKey(startMs) };
+}
+
+/**
+ * Aggregate one period into a ranked list.
+ *
+ * Reads `attempts`, not `attempt_answers`: `correct_count` and
+ * `answered_count` are trigger-maintained summaries, so this survives the
+ * retention job deleting the raw rows underneath it. That is the property
+ * 0004 called out when it said leaderboards are "precomputed".
+ */
+async function aggregate(
+  db: Db,
+  startMs: number,
+  topN: number,
+): Promise<{ rows: AggregateRow[]; entrants: number }> {
+  // One grouped read, bounded by LIMIT. Served by idx_attempts_submitted_at.
+  const rows = await db.all<AggregateRow>(
+    `SELECT a.user_id                AS user_id,
+            p.display_name           AS display_name,
+            p.avatar_url             AS avatar_url,
+            SUM(a.correct_count)     AS score,
+            SUM(a.answered_count)    AS answered
+       FROM ${T.attempts} a
+       JOIN ${T.userProfiles} p ON p.user_id = a.user_id
+       JOIN ${T.users} u        ON u.id = a.user_id
+      WHERE a.status = 'submitted'
+        AND a.submitted_at >= ?1
+        AND p.leaderboard_opt_in = 1
+        AND u.deleted_at IS NULL
+      GROUP BY a.user_id
+      HAVING SUM(a.answered_count) > 0
+      ORDER BY score DESC, answered ASC, a.user_id ASC
+      LIMIT ?2`,
+    startMs,
+    topN,
+  );
+
+  // Entrant count is the size of the eligible field, not of the top N — a
+  // board that says "you are 212th of 3,400" needs the denominator, and
+  // counting it here costs one query instead of a second scan at read time.
+  const count = await db.first<{ n: number }>(
+    `SELECT COUNT(*) AS n FROM (
+       SELECT a.user_id
+         FROM ${T.attempts} a
+         JOIN ${T.userProfiles} p ON p.user_id = a.user_id
+         JOIN ${T.users} u        ON u.id = a.user_id
+        WHERE a.status = 'submitted'
+          AND a.submitted_at >= ?1
+          AND p.leaderboard_opt_in = 1
+          AND u.deleted_at IS NULL
+        GROUP BY a.user_id
+       HAVING SUM(a.answered_count) > 0
+     )`,
+    startMs,
+  );
+
+  return { rows, entrants: count?.n ?? 0 };
+}
+
+/**
+ * Writes one board: the snapshot row, then its entries, carrying prev_rank.
+ *
+ * ONE ROW PER (scope, scope_ref, period, period_start)
+ * ----------------------------------------------------
+ * 0006 puts a UNIQUE index on exactly that tuple, which settles a question
+ * this job would otherwise have got wrong: an hourly cron REPLACES the current
+ * period's snapshot in place, it does not append a new one. A naive insert
+ * worked on the first run of each day and then failed on the unique index for
+ * the other twenty-three, which is the kind of bug that only shows up in
+ * production on day two.
+ *
+ * Updating in place is also the better shape: the read path (NQ-35) wants
+ * "today's board", not "the 14th snapshot of today's board", and the retention
+ * window stays bounded by period rather than by run count.
+ *
+ * `prev_rank` then means "rank the last time this board was computed", which
+ * is the previous hour within a day and the previous day at a boundary. One
+ * query finds either: the most recently computed snapshot of this board,
+ * whichever period_start it belongs to.
+ */
+async function writeBoard(
+  db: Db,
+  period: Period,
+  periodStart: string,
+  agg: { rows: AggregateRow[]; entrants: number },
+  now: number,
+  computeMs: number,
+): Promise<BoardResult> {
+  // The most recent computation of this board, for the movement arrows. Read
+  // BEFORE the write, because when the current period already has a row this
+  // is that row, and it is about to be overwritten.
+  const prev = await db.first<{ id: number }>(
+    `SELECT id FROM ${T.leaderboardSnapshots}
+      WHERE scope = 'global' AND scope_ref = '' AND period = ?1
+      ORDER BY computed_at DESC LIMIT 1`,
+    period,
+  );
+
+  const prevRanks = new Map<string, number>();
+  if (prev) {
+    const prevRows = await db.all<{ user_id: string; rank: number }>(
+      `SELECT user_id, rank FROM ${T.leaderboardEntries} WHERE snapshot_id = ?1`,
+      prev.id,
+    );
+    for (const row of prevRows) prevRanks.set(row.user_id, row.rank);
+  }
+
+  const top = agg.rows.map((row, i) => ({
+    rank: i + 1,
+    user_id: row.user_id,
+    display_name: row.display_name,
+    avatar_url: row.avatar_url,
+    score: row.score,
+    accuracy_bp: accuracyBp(row.score, row.answered),
+  }));
+
+  // Upsert on the board key, not on the id: the id is an autoincrementing
+  // rowid and the board key is what identifies the thing being recomputed.
+  const written = await db.first<{ id: number }>(
+    `INSERT INTO ${T.leaderboardSnapshots}
+       (scope, scope_ref, period, period_start, metric, top_json, entrant_count,
+        computed_at, compute_ms)
+     VALUES ('global', '', ?1, ?2, 'correct_answers', ?3, ?4, ?5, ?6)
+     ON CONFLICT (scope, scope_ref, period, period_start) DO UPDATE SET
+       top_json      = excluded.top_json,
+       entrant_count = excluded.entrant_count,
+       computed_at   = excluded.computed_at,
+       compute_ms    = excluded.compute_ms
+     RETURNING id`,
+    period,
+    periodStart,
+    JSON.stringify(top),
+    agg.entrants,
+    now,
+    computeMs,
+  );
+  if (!written) {
+    throw new Error(`leaderboard: snapshot upsert for ${period} returned no id`);
+  }
+
+  // Entries are replaced wholesale. A partial update would leave stale ranks
+  // behind for anyone who dropped out of the top N, and
+  // `uq_leaderboard_entries_snapshot_user` would reject the re-insert anyway.
+  const statements: PendingStatement[] = [
+    sql(`DELETE FROM ${T.leaderboardEntries} WHERE snapshot_id = ?1`, written.id),
+    ...top.map((entry) =>
+      sql(
+        `INSERT INTO ${T.leaderboardEntries}
+           (snapshot_id, rank, user_id, score, accuracy_bp, prev_rank)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6)`,
+        written.id,
+        entry.rank,
+        entry.user_id,
+        entry.score,
+        entry.accuracy_bp,
+        prevRanks.get(entry.user_id) ?? null,
+      ),
+    ),
+  ];
+  await db.batch(statements);
+
+  return {
+    period,
+    periodStart,
+    snapshotId: written.id,
+    entrants: agg.entrants,
+    ranked: top.length,
+    computeMs,
+  };
+}
+
+function accuracyBp(correct: number, answered: number): number | null {
+  if (answered <= 0) return null;
+  return Math.round((correct / answered) * 10_000);
+}
+
+/**
+ * Prune old snapshots, children first.
+ *
+ * `leaderboard_entries.snapshot_id` is deliberately not a foreign key, so
+ * there is no cascade to lean on: deleting the parents first would orphan the
+ * children silently. 0006 spells out this order (NQ-35d before NQ-35c) and
+ * why — a cascading delete here is the shape that blows D1's per-query time
+ * limit.
+ *
+ * `all_time` is never pruned; it is one row per run of history.
+ */
+async function prune(db: Db, now: number): Promise<{ snapshots: number; entries: number }> {
+  const cutoff = now - SNAPSHOT_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+
+  const entries = await db.run(
+    `DELETE FROM ${T.leaderboardEntries}
+      WHERE snapshot_id IN (
+        SELECT id FROM ${T.leaderboardSnapshots}
+         WHERE computed_at < ?1 AND period <> 'all_time'
+         ORDER BY id
+         LIMIT ?2
+      )`,
+    cutoff,
+    PRUNE_BATCH,
+  );
+
+  const snapshots = await db.run(
+    `DELETE FROM ${T.leaderboardSnapshots}
+      WHERE id IN (
+        SELECT id FROM ${T.leaderboardSnapshots}
+         WHERE computed_at < ?1 AND period <> 'all_time'
+         ORDER BY id
+         LIMIT ?2
+      )`,
+    cutoff,
+    PRUNE_BATCH,
+  );
+
+  return { snapshots: snapshots.changes ?? 0, entries: entries.changes ?? 0 };
+}
+
+const PERIODS: readonly Period[] = ['daily', 'weekly', 'monthly', 'all_time'];
+
+export async function runLeaderboardSnapshot(
+  db: Db,
+  config: LeaderboardConfig,
+): Promise<LeaderboardResult> {
+  const topN = config.topN ?? TOP_N;
+  const boards: BoardResult[] = [];
+
+  for (const period of PERIODS) {
+    const { startMs, periodStart } = periodWindow(period, config.now);
+    // `compute_ms` is recorded because 0006 says this job is the one thing
+    // allowed to scan a large table, and the day it gets slow is the day the
+    // ceiling arithmetic needs revisiting. Measuring it is how that day is
+    // noticed.
+    const started = Date.now();
+    const agg = await aggregate(db, startMs, topN);
+    const computeMs = Date.now() - started;
+    boards.push(await writeBoard(db, period, periodStart, agg, config.now, computeMs));
+  }
+
+  const pruned = await prune(db, config.now);
+
+  return {
+    boards,
+    snapshotsPruned: pruned.snapshots,
+    entriesPruned: pruned.entries,
+  };
+}
diff --git a/worker/src/jobs/retention.ts b/worker/src/jobs/retention.ts
new file mode 100644
index 0000000..578f335
--- /dev/null
+++ b/worker/src/jobs/retention.ts
@@ -0,0 +1,153 @@
+/**
+ * Raw-answer retention.
+ *
+ * Without this job `attempt_answers` grows forever and the first symptom is
+ * every write failing at D1's 500 MB per-database wall. The schema spells the
+ * reasoning out in `migrations/0004_assessment.sql`; the policy it states is
+ * what this file implements, nothing more:
+ *
+ *   * answers of a SUBMITTED attempt   -- `ANSWER_RETENTION_DAYS` (90 free)
+ *   * answers of an ABANDONED/EXPIRED attempt -- 7 days
+ *   * the `attempts` summary row itself -- kept forever, one row per sitting
+ *
+ * Deleting a raw answer loses the question-by-question review of an old
+ * attempt and nothing else. Score, counts, per-question history and SRS state
+ * are all trigger-maintained on other tables, and `db/smoke.mjs` asserts that
+ * they survive an archival pass.
+ *
+ * WHY THIS DELETES RATHER THAN ARCHIVES
+ * -------------------------------------
+ * `attempt_answers_archive` exists in 0004 with an `r2_object_key` column, and
+ * its own comment is explicit: a NULL key means "this row is still only in D1
+ * and deleting it would lose data". There is no R2 bucket bound in
+ * `wrangler.toml`, so copying rows into that table would move them from a
+ * 4-index table to a 1-index table in the same database — paying write
+ * amplification to bound nothing. Deletion is what actually reclaims pages for
+ * reuse.
+ *
+ * Turning archival on is therefore a two-part change, not a flag: bind an R2
+ * bucket, then write the drain (NQ-26d). Until then this job implements the
+ * documented trade rather than pretending to preserve what it cannot.
+ *
+ * WHY IT IS BATCHED AND BUDGETED
+ * ------------------------------
+ * D1's free plan allows 100,000 row writes per day and counts INDEX rows as
+ * writes. `attempt_answers` carries three secondary indexes plus the unique
+ * one, so a single deleted answer costs about five row writes. The job
+ * therefore works to an explicit row-write budget and stops cleanly when it is
+ * spent, leaving the rest for tomorrow: a retention job that exhausts the
+ * day's write allowance takes the whole platform read-only, which is a far
+ * worse outcome than a backlog draining over several nights.
+ */
+
+import { Db } from '../data/d1.ts';
+import { T } from '../data/tables.ts';
+
+/** Row writes charged per deleted answer: the row, plus its four indexes. */
+export const WRITE_COST_PER_ANSWER = 5;
+
+/** Answers of an attempt that was never submitted are worth very little. */
+export const ABANDONED_RETENTION_DAYS = 7;
+
+/**
+ * How many answers to delete in one statement.
+ *
+ * Deliberately well under D1's bound-parameter ceiling, and small enough that
+ * one batch is a short-lived write lock on a single-threaded database.
+ */
+export const DELETE_BATCH_SIZE = 500;
+
+export interface RetentionConfig {
+  /** Retention for answers of submitted attempts, in days. */
+  readonly submittedRetentionDays: number;
+  /**
+   * Row-write ceiling for the whole run. Defaults to a quarter of the free
+   * plan's daily allowance, so the job can never be the reason a student
+   * cannot record an answer.
+   */
+  readonly rowWriteBudget: number;
+  /** Injected so tests do not depend on the wall clock. */
+  readonly now: number;
+}
+
+export interface RetentionResult {
+  readonly answersDeleted: number;
+  readonly rowWritesSpent: number;
+  readonly batches: number;
+  /** True when the budget ran out before the backlog did. */
+  readonly budgetExhausted: boolean;
+  /** Oldest answer still present after the run, epoch ms, or null if none. */
+  readonly oldestRemainingAt: number | null;
+}
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Delete expired raw answers, oldest first, within a row-write budget.
+ *
+ * Oldest-first matters: it means an interrupted run always makes progress on
+ * the rows closest to being a problem, and a backlog drains deterministically
+ * instead of leaving an arbitrary residue.
+ */
+export async function runAnswerRetention(
+  db: Db,
+  config: RetentionConfig,
+): Promise<RetentionResult> {
+  const submittedCutoff = config.now - config.submittedRetentionDays * DAY_MS;
+  const abandonedCutoff = config.now - ABANDONED_RETENTION_DAYS * DAY_MS;
+
+  let answersDeleted = 0;
+  let batches = 0;
+  let budgetExhausted = false;
+
+  for (;;) {
+    const remainingWrites = config.rowWriteBudget - answersDeleted * WRITE_COST_PER_ANSWER;
+    const affordable = Math.floor(remainingWrites / WRITE_COST_PER_ANSWER);
+    if (affordable <= 0) {
+      budgetExhausted = true;
+      break;
+    }
+    const limit = Math.min(DELETE_BATCH_SIZE, affordable);
+
+    // The cutoff depends on the PARENT attempt's status, so the predicate has
+    // to join. `answered_at` drives the ordering and is indexed
+    // (idx_attempt_answers_answered_at), and the attempt lookup is by primary
+    // key, so this stays a bounded scan of the oldest rows rather than a table
+    // sort.
+    const meta = await db.run(
+      `DELETE FROM ${T.attemptAnswers}
+        WHERE id IN (
+          SELECT aa.id
+            FROM ${T.attemptAnswers} aa
+            JOIN ${T.attempts} a ON a.id = aa.attempt_id
+           WHERE (a.status = 'submitted' AND aa.answered_at < ?1)
+              OR (a.status IN ('abandoned', 'expired') AND aa.answered_at < ?2)
+           ORDER BY aa.answered_at
+           LIMIT ?3
+        )`,
+      submittedCutoff,
+      abandonedCutoff,
+      limit,
+    );
+
+    const deleted = meta.changes ?? 0;
+    answersDeleted += deleted;
+    batches += 1;
+
+    // Fewer than asked for means the backlog is drained, not that the budget
+    // ran out. Distinguishing the two is the whole point of the result shape.
+    if (deleted < limit) break;
+  }
+
+  const oldest = await db.first<{ answered_at: number }>(
+    `SELECT answered_at FROM ${T.attemptAnswers} ORDER BY answered_at LIMIT 1`,
+  );
+
+  return {
+    answersDeleted,
+    rowWritesSpent: answersDeleted * WRITE_COST_PER_ANSWER,
+    batches,
+    budgetExhausted,
+    oldestRemainingAt: oldest?.answered_at ?? null,
+  };
+}
diff --git a/worker/src/jobs/sweep.ts b/worker/src/jobs/sweep.ts
new file mode 100644
index 0000000..7212e61
--- /dev/null
+++ b/worker/src/jobs/sweep.ts
@@ -0,0 +1,128 @@
+/**
+ * Nightly sweep: expire stale attempts, retire dead sessions, prune
+ * notifications and idempotency keys.
+ *
+ * Each of these has a reason rooted in a limit or an invariant, not in
+ * tidiness:
+ *
+ *  1. ATTEMPTS past their deadline. `attempts.status` stays 'in_progress'
+ *     until something ends it. The submit path clamps a late submission
+ *     (`domain/expiry.ts`), but a student who closes the tab and never returns
+ *     leaves a row that claims to be in progress forever. That row is not
+ *     harmless: the mock-start path refuses to begin a second attempt while
+ *     one is open, so a single abandoned paper locks a student out of that
+ *     template permanently.
+ *
+ *  2. SESSIONS past their absolute expiry. Already unusable — the session
+ *     lookup checks both clocks — so this is purely about not carrying dead
+ *     rows and their index entries forever.
+ *
+ *  3. NOTIFICATIONS past `expires_at`, which is what that column is for.
+ *
+ *  4. IDEMPOTENCY KEYS past their TTL, using the statement `data/infra.ts`
+ *     already defines. Reusing it rather than writing a second DELETE keeps
+ *     one definition of what "expired key" means.
+ *
+ * Everything here is bounded by LIMIT and reports what it did, for the same
+ * reason the retention job is: an unbounded nightly DELETE on a
+ * single-threaded database is a self-inflicted outage.
+ */
+
+import { Db } from '../data/d1.ts';
+import { T } from '../data/tables.ts';
+import { IDEMPOTENCY_TTL_MS, sweepIdempotencyStatement } from '../data/infra.ts';
+
+/** Per-category ceiling for one run. */
+export const SWEEP_BATCH_SIZE = 1000;
+
+export interface SweepConfig {
+  readonly now: number;
+  readonly batchSize?: number;
+}
+
+export interface SweepResult {
+  readonly attemptsExpired: number;
+  readonly sessionsDeleted: number;
+  readonly notificationsDeleted: number;
+  readonly idempotencyKeysDeleted: number;
+}
+
+export async function runNightlySweep(db: Db, config: SweepConfig): Promise<SweepResult> {
+  const limit = config.batchSize ?? SWEEP_BATCH_SIZE;
+  const now = config.now;
+
+  // 1. Expire attempts whose deadline has passed.
+  //
+  // `elapsed_ms` is set from the deadline rather than from `now`, because the
+  // student stopped working at some unknown point before it — crediting them
+  // with the time between abandonment and this cron run would be a lie, and
+  // the deadline is the only defensible upper bound available.
+  //
+  // Only timed attempts are touched: `deadline_at IS NULL` is an untimed
+  // practice session, which has no deadline to be past.
+  //
+  // `attempts` has no `updated_at` — one row per sitting whose lifecycle is
+  // already described by `started_at`/`submitted_at`/`deadline_at` — so there
+  // is nothing to stamp here beyond the status itself. Leaving `submitted_at`
+  // NULL is required: the table's CHECK ties it to `status = 'submitted'`, and
+  // an expired paper was never submitted.
+  const expired = await db.run(
+    `UPDATE ${T.attempts}
+        SET status = 'expired',
+            elapsed_ms = COALESCE(elapsed_ms, deadline_at - started_at)
+      WHERE id IN (
+        SELECT id FROM ${T.attempts}
+         WHERE status = 'in_progress'
+           AND deadline_at IS NOT NULL
+           AND deadline_at < ?1
+         ORDER BY deadline_at
+         LIMIT ?2
+      )`,
+    now,
+    limit,
+  );
+
+  // 2. Sessions past their hard ceiling. The idle clock slides, the absolute
+  // one does not, so `absolute_expires_at` is the only safe deletion key: a
+  // session can sit far past `expires_at` and still be legitimately revivable
+  // in another tab's race, but nothing survives the absolute ceiling.
+  const sessions = await db.run(
+    `DELETE FROM ${T.sessions}
+      WHERE id IN (
+        SELECT id FROM ${T.sessions}
+         WHERE absolute_expires_at < ?1
+         ORDER BY absolute_expires_at
+         LIMIT ?2
+      )`,
+    now,
+    limit,
+  );
+
+  // 3. Expired notifications. NULL `expires_at` means "keep until read", which
+  // is a different policy and not this job's business.
+  const notifications = await db.run(
+    `DELETE FROM ${T.notifications}
+      WHERE id IN (
+        SELECT id FROM ${T.notifications}
+         WHERE expires_at IS NOT NULL
+           AND expires_at < ?1
+         ORDER BY expires_at
+         LIMIT ?2
+      )`,
+    now,
+    limit,
+  );
+
+  // 4. Idempotency keys, via the one statement that defines their TTL.
+  const idem = sweepIdempotencyStatement(now);
+  const [idemResult] = await db.batch([idem]);
+
+  return {
+    attemptsExpired: expired.changes ?? 0,
+    sessionsDeleted: sessions.changes ?? 0,
+    notificationsDeleted: notifications.changes ?? 0,
+    idempotencyKeysDeleted: idemResult?.meta?.changes ?? 0,
+  };
+}
+
+export { IDEMPOTENCY_TTL_MS };
diff --git a/worker/src/lib/canonical.ts b/worker/src/lib/canonical.ts
new file mode 100644
index 0000000..72db8ad
--- /dev/null
+++ b/worker/src/lib/canonical.ts
@@ -0,0 +1,36 @@
+/**
+ * Canonical JSON, for idempotency request fingerprints.
+ *
+ * Two replays of the same logical mutation must produce the same fingerprint
+ * even if the client serialised its object keys in a different order (JS object
+ * key order is insertion order, and an offline queue rehydrated from storage
+ * can easily differ). Two DIFFERENT mutations sent under the same idempotency
+ * key must produce different fingerprints, so the server can reject the reuse
+ * instead of silently replaying the wrong response.
+ *
+ * The idempotency key itself is excluded from the fingerprint - it is the
+ * lookup key, not part of the request's identity.
+ */
+
+const IGNORED_KEYS = new Set(['idempotencyKey']);
+
+function canonicalize(value: unknown): unknown {
+  if (value === null || typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.map(canonicalize);
+
+  const source = value as Record<string, unknown>;
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(source).sort()) {
+    if (IGNORED_KEYS.has(key)) continue;
+    // `undefined` and a missing key must fingerprint identically, since
+    // JSON.stringify drops both.
+    if (source[key] === undefined) continue;
+    out[key] = canonicalize(source[key]);
+  }
+  return out;
+}
+
+/** Stable string form of a request body. */
+export function canonicalJson(value: unknown): string {
+  return JSON.stringify(canonicalize(value));
+}
diff --git a/worker/src/lib/cookies.ts b/worker/src/lib/cookies.ts
new file mode 100644
index 0000000..8de60e6
--- /dev/null
+++ b/worker/src/lib/cookies.ts
@@ -0,0 +1,57 @@
+/**
+ * Session cookie handling.
+ *
+ * The cookie carries nothing but an opaque session id. There is no signed
+ * payload, no user id and no role in it, so a forged or tampered cookie simply
+ * fails to match a `sessions` row. That costs one indexed lookup per request
+ * and removes a whole class of "I edited my JWT claims to admin" bugs - which
+ * matters more than usual here, because D1 has no row-level security and the
+ * role in the cookie would otherwise be the only thing standing between a user
+ * and the admin endpoints.
+ */
+
+export const SESSION_COOKIE = 'necprep_session';
+
+export interface CookieOptions {
+  maxAgeSeconds: number;
+  secure: boolean;
+  /** Set for a deployment where the API and the app are on different hosts. */
+  sameSite?: 'Strict' | 'Lax' | 'None';
+  domain?: string;
+}
+
+export function serializeSessionCookie(
+  sessionId: string,
+  options: CookieOptions,
+): string {
+  const parts = [
+    `${SESSION_COOKIE}=${sessionId}`,
+    'Path=/',
+    'HttpOnly',
+    `Max-Age=${Math.max(0, Math.floor(options.maxAgeSeconds))}`,
+    `SameSite=${options.sameSite ?? 'Lax'}`,
+  ];
+  // SameSite=None is only honoured together with Secure, and a cross-site
+  // deployment that forgets Secure silently loses its session on every
+  // browser, so tie them together here rather than in each caller.
+  if (options.secure || options.sameSite === 'None') parts.push('Secure');
+  if (options.domain) parts.push(`Domain=${options.domain}`);
+  return parts.join('; ');
+}
+
+export function clearSessionCookie(options: Pick<CookieOptions, 'secure' | 'sameSite' | 'domain'>): string {
+  return serializeSessionCookie('', { ...options, maxAgeSeconds: 0 });
+}
+
+/** Reads one cookie out of a raw `Cookie:` header. */
+export function readCookie(header: string | null, name: string): string | null {
+  if (!header) return null;
+  for (const pair of header.split(';')) {
+    const eq = pair.indexOf('=');
+    if (eq < 0) continue;
+    if (pair.slice(0, eq).trim() !== name) continue;
+    const value = pair.slice(eq + 1).trim();
+    return value.length > 0 ? value : null;
+  }
+  return null;
+}
diff --git a/worker/src/lib/ids.ts b/worker/src/lib/ids.ts
new file mode 100644
index 0000000..1e59acd
--- /dev/null
+++ b/worker/src/lib/ids.ts
@@ -0,0 +1,41 @@
+/**
+ * Id and opaque-token generation.
+ *
+ * Uses the WebCrypto global, which exists in both the Workers runtime and in
+ * Node 18+, so the same code runs in production and under `node --test`.
+ */
+
+/** Crockford-style base32 without the ambiguous letters I, L, O and U. */
+const B32 = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+/**
+ * `len` random base32 characters, i.e. 5 * len bits of entropy from the CSPRNG.
+ *
+ * Rejection-free: 256 is not a multiple of 32 but it is a multiple of 32, so
+ * masking the low 5 bits of each byte is uniform.
+ */
+export function randomToken(len: number): string {
+  const bytes = new Uint8Array(len);
+  crypto.getRandomValues(bytes);
+  let out = '';
+  for (let i = 0; i < len; i++) out += B32[bytes[i] & 31];
+  return out;
+}
+
+/** A prefixed, sortable-enough, opaque id. `usr_01H...`. */
+export function newId(prefix: string): string {
+  return `${prefix}_${randomToken(22)}`;
+}
+
+/** 128 bits, for session cookies and OAuth state. */
+export function newSecretId(prefix: string): string {
+  return `${prefix}_${randomToken(26)}`;
+}
+
+/** Constant-time string compare, for session ids and tokens. */
+export function timingSafeEqual(a: string, b: string): boolean {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
diff --git a/worker/src/lib/password.ts b/worker/src/lib/password.ts
new file mode 100644
index 0000000..ce8699e
--- /dev/null
+++ b/worker/src/lib/password.ts
@@ -0,0 +1,127 @@
+/**
+ * Password hashing with PBKDF2-HMAC-SHA256 via WebCrypto.
+ *
+ * Workers has no native argon2/bcrypt and cannot load a WASM one on the free
+ * plan's CPU budget, so PBKDF2 through `crypto.subtle` is the only credible
+ * option. The iteration count is a deliberate, documented compromise: OWASP
+ * asks for 600,000 for PBKDF2-SHA256, but Workers Free allows ~10ms of CPU per
+ * invocation and 600k iterations will not fit. The default is therefore
+ * 100,000, overridable with `PASSWORD_HASH_ITERATIONS`, and the deployment note
+ * in docs/api.md says to raise it to 600,000 on the paid plan where the CPU
+ * limit is 30s.
+ *
+ * Stored format - self-describing, so the iteration count can be raised later
+ * and old hashes still verify and get rehashed on next login:
+ *
+ *     pbkdf2$sha256$<iterations>$<salt-b64url>$<derived-b64url>
+ */
+
+export const DEFAULT_PBKDF2_ITERATIONS = 100_000;
+const SALT_BYTES = 16;
+const DERIVED_BITS = 256;
+
+function toBase64Url(bytes: Uint8Array): string {
+  let s = '';
+  for (const b of bytes) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+function fromBase64Url(text: string): Uint8Array {
+  const padded = text.replace(/-/g, '+').replace(/_/g, '/');
+  const raw = atob(padded + '='.repeat((4 - (padded.length % 4)) % 4));
+  const out = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i);
+  return out;
+}
+
+async function derive(
+  password: string,
+  salt: Uint8Array,
+  iterations: number,
+): Promise<Uint8Array> {
+  const key = await crypto.subtle.importKey(
+    'raw',
+    new TextEncoder().encode(password),
+    'PBKDF2',
+    false,
+    ['deriveBits'],
+  );
+  const bits = await crypto.subtle.deriveBits(
+    { name: 'PBKDF2', hash: 'SHA-256', salt: salt as unknown as BufferSource, iterations },
+    key,
+    DERIVED_BITS,
+  );
+  return new Uint8Array(bits);
+}
+
+export async function hashPassword(
+  password: string,
+  iterations = DEFAULT_PBKDF2_ITERATIONS,
+): Promise<string> {
+  const salt = new Uint8Array(SALT_BYTES);
+  crypto.getRandomValues(salt);
+  const derived = await derive(password, salt, iterations);
+  return `pbkdf2$sha256$${iterations}$${toBase64Url(salt)}$${toBase64Url(derived)}`;
+}
+
+/**
+ * Verifies a password against a stored hash.
+ *
+ * Returns `needsRehash` when the stored hash used fewer iterations than the
+ * current setting, so callers can transparently upgrade on a successful login.
+ * Never throws on a malformed stored hash - a corrupt row must read as "wrong
+ * password", not as a 500 that tells an attacker the account exists.
+ */
+export async function verifyPassword(
+  password: string,
+  stored: string | null,
+  currentIterations = DEFAULT_PBKDF2_ITERATIONS,
+): Promise<{ valid: boolean; needsRehash: boolean }> {
+  if (!stored) return { valid: false, needsRehash: false };
+
+  const parts = stored.split('$');
+  if (parts.length !== 5 || parts[0] !== 'pbkdf2' || parts[1] !== 'sha256') {
+    return { valid: false, needsRehash: false };
+  }
+
+  const iterations = Number.parseInt(parts[2], 10);
+  if (!Number.isInteger(iterations) || iterations < 1 || iterations > 2_000_000) {
+    return { valid: false, needsRehash: false };
+  }
+
+  let salt: Uint8Array;
+  let expected: Uint8Array;
+  try {
+    salt = fromBase64Url(parts[3]);
+    expected = fromBase64Url(parts[4]);
+  } catch {
+    return { valid: false, needsRehash: false };
+  }
+
+  const actual = await derive(password, salt, iterations);
+  if (actual.length !== expected.length) return { valid: false, needsRehash: false };
+
+  let diff = 0;
+  for (let i = 0; i < actual.length; i++) diff |= actual[i] ^ expected[i];
+
+  return { valid: diff === 0, needsRehash: diff === 0 && iterations < currentIterations };
+}
+
+/**
+ * A dummy verification, run on a login for an address with no account.
+ *
+ * Without it, "no such user" returns in a fraction of the time a real password
+ * check takes and the response latency becomes a user-enumeration oracle.
+ */
+export async function burnPasswordTime(
+  iterations = DEFAULT_PBKDF2_ITERATIONS,
+): Promise<void> {
+  const salt = new Uint8Array(SALT_BYTES);
+  await derive('timing-equalisation', salt, iterations);
+}
+
+/** SHA-256 hex, used for request fingerprints and IP hashing. */
+export async function sha256Hex(input: string): Promise<string> {
+  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('');
+}
diff --git a/worker/src/lib/permute.ts b/worker/src/lib/permute.ts
new file mode 100644
index 0000000..b9d5500
--- /dev/null
+++ b/worker/src/lib/permute.ts
@@ -0,0 +1,259 @@
+/**
+ * Option ordering.
+ *
+ * Two problems are solved here, and they are not the same problem.
+ *
+ * 1. ANSWER-POSITION BIAS IN THE BANK. As documented in
+ *    `frontend/src/services/localData.ts`, option 2 is correct in 32% of the
+ *    2,801 authored questions and in 64.8% of chapter 9. Serving the authored
+ *    order teaches the tell instead of the material.
+ *
+ * 2. THE PUBLIC ANSWER KEY IN GIT HISTORY. `frontend/public/data/books/*.json`
+ *    ships `correct_option_index` and will stay in the repository's history
+ *    forever. Any endpoint that returns options in the authored order lets an
+ *    attacker join position-to-position and recover the key without ever
+ *    looking at the database.
+ *
+ * So EVERY option list that leaves this Worker is permuted. Mock and practice
+ * papers use a CSPRNG permutation stored per attempt; content browsing uses a
+ * permutation seeded from a server-only secret plus the viewer's user id, which
+ * is stable (so the UI does not reshuffle on reload) but unjoinable against the
+ * public JSON.
+ */
+
+export interface OptionRow {
+  id: string;
+  body: string;
+  /** `question_options.ordinal`, the authored slot. SERVER-ONLY. */
+  position: number;
+  /**
+   * `question_options.is_pinned`. The schema computes it at import time and an
+   * editor can override it, which is strictly better than re-deriving it from
+   * the text on every request: a pinned option that the regex happens not to
+   * match is a data fix, not a deploy.
+   */
+  isPinned: boolean;
+}
+
+/**
+ * Options whose meaning depends on being last. 450 of these exist in the bank
+ * and every one was authored in slot 4, so they are pinned rather than
+ * shuffled - moving one into the middle of the list makes the question
+ * nonsense.
+ *
+ * SUPERSEDED as the server's source of truth by
+ * `question_options.is_pinned`, which the importer computes with this same
+ * pattern and an editor can correct. Kept and exported because it is the
+ * pattern `frontend/src/services/localData.ts` still uses on the offline path,
+ * and the two must agree about what is shufflable; `pinnedByText` is the one
+ * fallback left, for a row that reaches the permuter without the flag.
+ */
+export const POSITIONAL_OPTION_RE =
+  /^\s*(all|none|both)\s+(of\s+)?(the\s+)?(above|these|mentioned)/i;
+
+/** Last-resort pin test for an option row with no `is_pinned` flag. */
+export function pinnedByText(body: string): boolean {
+  return POSITIONAL_OPTION_RE.test(body);
+}
+
+/** FNV-1a: a stable 32-bit seed from a string. */
+export function hashSeed(input: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+/** mulberry32 - small, fast, seedable PRNG. Not for secrets. */
+export function seededRandom(seed: number): () => number {
+  let a = seed;
+  return () => {
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/**
+ * Unbiased integer in [0, max) from the CSPRNG.
+ *
+ * `getRandomValues` then modulo would skew toward the low end; rejecting the
+ * tail above the largest multiple of `max` removes that.
+ */
+function cryptoRandomBelow(max: number): number {
+  if (max <= 1) return 0;
+  const limit = Math.floor(0x100000000 / max) * max;
+  const buf = new Uint32Array(1);
+  for (;;) {
+    crypto.getRandomValues(buf);
+    if (buf[0] < limit) return buf[0] % max;
+  }
+}
+
+/** Fisher-Yates over a copy. */
+function fisherYates<T>(arr: readonly T[], below: (max: number) => number): T[] {
+  const a = [...arr];
+  for (let i = a.length - 1; i > 0; i--) {
+    const j = below(i + 1);
+    [a[i], a[j]] = [a[j], a[i]];
+  }
+  return a;
+}
+
+/** CSPRNG shuffle. Used for picking questions and permuting attempt options. */
+export function cryptoShuffle<T>(arr: readonly T[]): T[] {
+  return fisherYates(arr, cryptoRandomBelow);
+}
+
+/** Deterministic shuffle from a string seed. */
+export function seededShuffle<T>(arr: readonly T[], seedKey: string): T[] {
+  const rand = seededRandom(hashSeed(seedKey));
+  return fisherYates(arr, (max) => Math.floor(rand() * max));
+}
+
+/**
+ * Reorders one question's options, keeping positional options ("All of the
+ * above") pinned to the end in their original relative order.
+ *
+ * `shuffle` decides the policy: pass `cryptoShuffle` for a per-attempt paper,
+ * or `(xs) => seededShuffle(xs, key)` for a stable per-viewer order.
+ */
+export function permuteOptions(
+  options: readonly OptionRow[],
+  shuffle: <T>(xs: readonly T[]) => T[],
+): OptionRow[] {
+  if (options.length < 2) return [...options];
+
+  const pinned: OptionRow[] = [];
+  const free: OptionRow[] = [];
+  for (const o of options) {
+    (o.isPinned ? pinned : free).push(o);
+  }
+
+  // Nothing is gained by shuffling fewer than two free options, and shuffling
+  // one free option around pinned ones would be a no-op anyway.
+  if (free.length < 2) return [...options];
+
+  return [...shuffle(free), ...pinned];
+}
+
+/**
+ * The stable per-viewer order used by the content-browsing endpoints.
+ *
+ * Seeded from a server-only secret so the mapping cannot be reproduced offline,
+ * and from the user id so two accounts comparing notes see different orders.
+ * Stable across requests because the client stores selections by option ref and
+ * a reshuffle between loads would re-point them.
+ */
+export function browsePermutation(
+  options: readonly OptionRow[],
+  secret: string,
+  userId: string,
+  questionId: string,
+): OptionRow[] {
+  const key = `${secret}:${userId}:${questionId}`;
+  return permuteOptions(options, (xs) => seededShuffle(xs, key));
+}
+
+/** Crockford-style base32, matching `lib/ids.ts`. */
+const B32 = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+/**
+ * An opaque, deterministic ref for ONE option on a content-browsing payload.
+ *
+ * WHY THIS EXISTS. A content endpoint cannot return the raw
+ * `question_options.id`, because the id is not opaque in practice: the schema
+ * mints it as `question_id || '#' || ordinal`, so the AUTHORED ORDINAL is
+ * recoverable from the id by reading it. Since
+ * `frontend/public/data/books/*.json` ships `correct_option_index` and is in
+ * git history forever, an id of `q_abc#3` plus a published key of 3 is the
+ * whole answer - no database access required, and the per-viewer permutation
+ * does not help because the ordinal travels inside the id rather than as a
+ * position.
+ *
+ * This digest is DELIBERATELY NOT REVERSIBLE, and it does not need to be: the
+ * browsing endpoints are read-only. A client never submits a browse ref back -
+ * answering goes through a practice session, which mints its own per-attempt
+ * refs and stores the mapping. So there is nothing to look up and no table to
+ * keep.
+ *
+ * Keyed on the server-only secret, so an attacker who somehow learns an option
+ * id still cannot compute which ref corresponds to it. Deterministic in
+ * (secret, user, question, option), so it is stable across reloads for one
+ * viewer and differs between viewers.
+ *
+ * 64 bits across two independent FNV-1a rounds, which is ample: the only thing
+ * a collision would do is make two options on one question share a display
+ * token, and the probability across four options is on the order of 1e-19.
+ */
+export function browseOptionRef(
+  secret: string,
+  userId: string,
+  questionId: string,
+  optionId: string,
+): string {
+  return keyedRef(`${secret}:${userId}:${questionId}:${optionId}`, 13);
+}
+
+/**
+ * The opaque per-attempt ref for ONE option on a delivered paper.
+ *
+ * DERIVED, NOT STORED, and that is the change from the first version of this
+ * API. It used to mint a CSPRNG token per (attempt, option) and store a
+ * parallel `option_refs` JSON array next to `attempt_questions.option_order`.
+ * The refs were fine; the storage was not. `attempt_questions` is the second
+ * table to watch at scale -- one row per delivered question, roughly 3 million
+ * rows a year at 1,000 MAU -- and four stored 12-character tokens per row is
+ * ~60 bytes each for information the server can recompute from two columns it
+ * already has. `migrations/0004_assessment.sql` names this exact alternative
+ * ("or an HMAC of the option id under `option_seed`").
+ *
+ * The security properties are the ones that matter and they are unchanged:
+ *
+ *   * PER ATTEMPT. `option_seed` is CSPRNG per attempt, so the same option in
+ *     two attempts gets two unrelated refs and a ref harvested from a finished
+ *     paper resolves to nothing in a new one.
+ *   * CARRIES NOTHING. It is a digest, so it reveals neither the option id nor
+ *     the authored slot nor the delivered position.
+ *   * NOT REPRODUCIBLE OFFLINE. Keyed on the server-only permutation secret as
+ *     well as the seed, so knowing an option id is not enough to compute its
+ *     ref, and knowing a ref is not enough to search for the seed.
+ *
+ * Resolution is a loop over `option_order` comparing refs, which is four
+ * comparisons per question and no database access -- see
+ * `domain/scoring.ts#resolveOptionRef`.
+ */
+export function attemptOptionRef(
+  secret: string,
+  optionSeed: number,
+  attemptPublicId: string,
+  optionId: string,
+): string {
+  return keyedRef(`${secret}:${optionSeed}:${attemptPublicId}:${optionId}`, 12);
+}
+
+/**
+ * `len` base32 characters from two independent FNV-1a rounds over a keyed
+ * string. 64 bits of entropy across 13 characters, which is ample: the only
+ * thing a collision does is make two options on one question share a display
+ * token, and across four options that is on the order of 1e-19.
+ */
+function keyedRef(base: string, len: number): string {
+  let a = hashSeed(base);
+  let b = hashSeed(`${base}:${a.toString(36)}`);
+
+  let out = '';
+  for (let i = 0; i < len; i++) {
+    if (i % 2 === 0) {
+      out += B32[a & 31];
+      a = (a >>> 5) | ((a & 31) << 27);
+    } else {
+      out += B32[b & 31];
+      b = (b >>> 5) | ((b & 31) << 27);
+    }
+  }
+  return out;
+}
diff --git a/worker/src/lib/time.ts b/worker/src/lib/time.ts
new file mode 100644
index 0000000..c769b8c
--- /dev/null
+++ b/worker/src/lib/time.ts
@@ -0,0 +1,59 @@
+/**
+ * Server time.
+ *
+ * Every timestamp this API stores or compares comes from a `Clock`. Nothing
+ * reads `Date.now()` directly outside this module, which is what lets the
+ * expiry tests drive the deadline deterministically instead of sleeping.
+ */
+
+export interface Clock {
+  /** Epoch milliseconds. */
+  now(): number;
+}
+
+export const systemClock: Clock = {
+  now: () => Date.now(),
+};
+
+/** A clock the tests can wind forward by hand. */
+export function fixedClock(start: number): Clock & { set(t: number): void; advance(ms: number): void } {
+  let t = start;
+  return {
+    now: () => t,
+    set: (next: number) => {
+      t = next;
+    },
+    advance: (ms: number) => {
+      t += ms;
+    },
+  };
+}
+
+export const SECOND = 1000;
+export const MINUTE = 60 * SECOND;
+export const HOUR = 60 * MINUTE;
+export const DAY = 24 * HOUR;
+
+/**
+ * Nepal Standard Time, UTC+05:45. Streaks and the daily activity rollup are
+ * bucketed in the candidate's local day, not UTC, or a 9pm study session in
+ * Kathmandu would land on the next UTC day and break the streak.
+ */
+export const ACTIVITY_TZ_OFFSET_MINUTES = 345;
+
+/** `YYYY-MM-DD` in the activity timezone. */
+export function dayKey(epochMs: number, offsetMinutes = ACTIVITY_TZ_OFFSET_MINUTES): string {
+  const shifted = new Date(epochMs + offsetMinutes * MINUTE);
+  const y = shifted.getUTCFullYear();
+  const m = String(shifted.getUTCMonth() + 1).padStart(2, '0');
+  const d = String(shifted.getUTCDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+/** Whole days between two `YYYY-MM-DD` keys. `null` if either is malformed. */
+export function dayKeyDiff(later: string, earlier: string): number | null {
+  const a = Date.parse(`${later}T00:00:00Z`);
+  const b = Date.parse(`${earlier}T00:00:00Z`);
+  if (Number.isNaN(a) || Number.isNaN(b)) return null;
+  return Math.round((a - b) / DAY);
+}
diff --git a/worker/src/middleware/validate.ts b/worker/src/middleware/validate.ts
new file mode 100644
index 0000000..67719ed
--- /dev/null
+++ b/worker/src/middleware/validate.ts
@@ -0,0 +1,104 @@
+/**
+ * Request parsing. Fails closed at every step.
+ *
+ * Three things go wrong with request handling in practice, and all three are
+ * handled here rather than in each route:
+ *
+ * - A body that is not JSON, or is JSON but not an object. Both are a 400 with
+ *   a clear message, never a crash inside a handler.
+ * - A body that is too large. Checked against `Content-Length` BEFORE reading,
+ *   so a hostile client cannot make the Worker buffer megabytes.
+ * - Query strings, which are always strings. Numeric parameters are coerced
+ *   explicitly, by name, and a value that is not a number is a 400 - not a
+ *   silent `NaN` that pages from the start of a table.
+ */
+
+import { ApiException } from '../shared/errors.ts';
+import { safeParse } from '../validation/parse.ts';
+import type { Schema } from '../validation/parse.ts';
+import { MAX_BODY_BYTES } from '../validation/schemas.ts';
+
+function badRequest(issues: Record<string, string>): never {
+  throw new ApiException('BAD_REQUEST', 'The request body is invalid.', {
+    fields: issues,
+  });
+}
+
+/** Validates an already-parsed value against a schema. */
+export function validate<T>(schema: Schema<T>, raw: unknown): T {
+  const result = safeParse(schema, raw);
+  if (!result.success) badRequest(result.error.issues);
+  return result.data;
+}
+
+export interface BodyRequest {
+  headers: { get(name: string): string | null };
+  json(): Promise<unknown>;
+}
+
+/** Reads and validates a JSON body. */
+export async function readJsonBody<T>(
+  request: BodyRequest,
+  schema: Schema<T>,
+): Promise<T> {
+  const declaredLength = request.headers.get('content-length');
+  if (declaredLength !== null) {
+    const length = Number.parseInt(declaredLength, 10);
+    if (Number.isInteger(length) && length > MAX_BODY_BYTES) {
+      throw new ApiException('PAYLOAD_TOO_LARGE', 'That request is too large.');
+    }
+  }
+
+  const contentType = request.headers.get('content-type') ?? '';
+  if (!contentType.toLowerCase().includes('application/json')) {
+    badRequest({ '': 'Expected a JSON body.' });
+  }
+
+  let raw: unknown;
+  try {
+    raw = await request.json();
+  } catch {
+    badRequest({ '': 'Malformed JSON.' });
+  }
+
+  return validate(schema, raw);
+}
+
+/**
+ * Builds a plain object from a query string, coercing the named keys to
+ * numbers.
+ *
+ * A number-shaped parameter that is not a number is left as the original
+ * string, so the schema reports `Expected a finite number` against the right
+ * field instead of this function inventing a default.
+ */
+export function queryObject(
+  url: URL,
+  numericKeys: readonly string[] = [],
+): Record<string, unknown> {
+  const numeric = new Set(numericKeys);
+  const out: Record<string, unknown> = {};
+
+  for (const [key, value] of url.searchParams) {
+    if (!numeric.has(key)) {
+      out[key] = value;
+      continue;
+    }
+    if (value === '') continue;
+    const parsed = Number(value);
+    out[key] = Number.isFinite(parsed) ? parsed : value;
+  }
+
+  return out;
+}
+
+/** Validates a path parameter as an opaque entity id. */
+export function pathId(value: string | undefined, name: string): string {
+  if (typeof value !== 'string' || value.length === 0 || value.length > 64) {
+    badRequest({ [name]: 'Missing or malformed.' });
+  }
+  if (!/^[A-Za-z0-9_.:-]+$/.test(value)) {
+    badRequest({ [name]: 'Malformed identifier.' });
+  }
+  return value;
+}
diff --git a/worker/src/shared/errors.ts b/worker/src/shared/errors.ts
new file mode 100644
index 0000000..c99a1a2
--- /dev/null
+++ b/worker/src/shared/errors.ts
@@ -0,0 +1,107 @@
+/**
+ * The one way this API fails.
+ *
+ * Handlers throw `ApiException`; the Hono error middleware and the test harness
+ * both turn it into the same `{ error: { code, message } }` body with the same
+ * status. Nothing else is ever surfaced to a client: an unexpected throw becomes
+ * a bare `INTERNAL`, because a D1 error message can contain SQL and column
+ * names and sometimes row values.
+ */
+
+import type { ApiError, ApiErrorBody, ApiErrorCode } from './types.ts';
+
+const STATUS_BY_CODE: Record<ApiErrorCode, number> = {
+  BAD_REQUEST: 400,
+  UNAUTHENTICATED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  RATE_LIMITED: 429,
+  IDEMPOTENCY_KEY_REUSED: 409,
+  REQUEST_IN_FLIGHT: 409,
+  ATTEMPT_NOT_IN_PROGRESS: 409,
+  QUESTION_NOT_ON_PAPER: 422,
+  UNKNOWN_OPTION_REF: 422,
+  EMAIL_IN_USE: 409,
+  INVALID_CREDENTIALS: 401,
+  NOT_ANONYMOUS: 409,
+  OAUTH_STATE_INVALID: 400,
+  OAUTH_EXCHANGE_FAILED: 502,
+  INSUFFICIENT_CONTENT: 409,
+  PAYLOAD_TOO_LARGE: 413,
+  INTERNAL: 500,
+  // Client-synthesised; the Worker never returns these. Mapped anyway so the
+  // record stays exhaustive and adding a code cannot silently skip a status.
+  BACKEND_NOT_CONFIGURED: 501,
+  NETWORK_UNAVAILABLE: 503,
+};
+
+export interface ApiExceptionInit {
+  fields?: Record<string, string>;
+  retryAfterMs?: number;
+  /** Logged, never returned. For the genuine cause behind a generic code. */
+  internal?: string;
+}
+
+export class ApiException extends Error {
+  readonly code: ApiErrorCode;
+  readonly status: number;
+  readonly fields?: Record<string, string>;
+  readonly retryAfterMs?: number;
+  readonly internal?: string;
+
+  constructor(code: ApiErrorCode, message: string, init: ApiExceptionInit = {}) {
+    super(message);
+    this.name = 'ApiException';
+    this.code = code;
+    this.status = STATUS_BY_CODE[code];
+    this.fields = init.fields;
+    this.retryAfterMs = init.retryAfterMs;
+    this.internal = init.internal;
+  }
+
+  toBody(): ApiErrorBody {
+    const error: ApiError = { code: this.code, message: this.message };
+    if (this.fields) error.fields = this.fields;
+    if (this.retryAfterMs !== undefined) error.retryAfterMs = this.retryAfterMs;
+    return { error };
+  }
+}
+
+export function fail(
+  code: ApiErrorCode,
+  message: string,
+  init?: ApiExceptionInit,
+): never {
+  throw new ApiException(code, message, init);
+}
+
+export function statusForCode(code: ApiErrorCode): number {
+  return STATUS_BY_CODE[code];
+}
+
+/**
+ * Turns anything thrown inside a handler into a client-safe response pair.
+ *
+ * Fails closed: an unrecognised throw is a 500 `INTERNAL` with a fixed message,
+ * and the real text is handed back separately for the log.
+ */
+export function toErrorResponse(err: unknown): {
+  status: number;
+  body: ApiErrorBody;
+  logMessage: string;
+} {
+  if (err instanceof ApiException) {
+    return {
+      status: err.status,
+      body: err.toBody(),
+      logMessage: err.internal ?? err.message,
+    };
+  }
+  const logMessage = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+  return {
+    status: 500,
+    body: { error: { code: 'INTERNAL', message: 'Something went wrong.' } },
+    logMessage,
+  };
+}
diff --git a/worker/src/shared/types.ts b/worker/src/shared/types.ts
new file mode 100644
index 0000000..d916820
--- /dev/null
+++ b/worker/src/shared/types.ts
@@ -0,0 +1,659 @@
+/**
+ * The wire contract between the Worker and the browser.
+ *
+ * This file is TYPE-ONLY on purpose. `frontend/src/services/api.ts` imports it
+ * with `import type`, which `verbatimModuleSyntax` erases completely, so Vite
+ * never has to resolve a path outside its root and no Worker runtime code can
+ * leak into the client bundle. Keep it free of enums, namespaces, classes and
+ * runtime `const` values: the frontend type-checks this file under
+ * `erasableSyntaxOnly`, which rejects all of those.
+ *
+ * Shapes are defined here ONCE. The Worker handlers return them and the client
+ * consumes them; neither side re-declares a response body.
+ */
+
+/** Milliseconds since the Unix epoch, always produced by the SERVER clock. */
+export type EpochMs = number;
+
+/** `YYYY-MM-DD` in the activity timezone (see `ACTIVITY_TZ_OFFSET_MINUTES`). */
+export type DayKey = string;
+
+// --- Errors -----------------------------------------------------------------
+
+export type ApiErrorCode =
+  | 'BAD_REQUEST'
+  | 'UNAUTHENTICATED'
+  | 'FORBIDDEN'
+  | 'NOT_FOUND'
+  | 'CONFLICT'
+  | 'RATE_LIMITED'
+  | 'IDEMPOTENCY_KEY_REUSED'
+  | 'REQUEST_IN_FLIGHT'
+  | 'ATTEMPT_NOT_IN_PROGRESS'
+  | 'QUESTION_NOT_ON_PAPER'
+  | 'UNKNOWN_OPTION_REF'
+  | 'EMAIL_IN_USE'
+  | 'INVALID_CREDENTIALS'
+  | 'NOT_ANONYMOUS'
+  | 'OAUTH_STATE_INVALID'
+  | 'OAUTH_EXCHANGE_FAILED'
+  | 'INSUFFICIENT_CONTENT'
+  | 'PAYLOAD_TOO_LARGE'
+  | 'INTERNAL'
+  // Synthesised by the typed client, never sent by the Worker. They live in the
+  // same union so a caller can switch over one exhaustive set of codes instead
+  // of handling transport failures through a separate channel.
+  | 'BACKEND_NOT_CONFIGURED'
+  | 'NETWORK_UNAVAILABLE';
+
+export interface ApiError {
+  code: ApiErrorCode;
+  message: string;
+  /** Per-field validation messages, keyed by dotted path. */
+  fields?: Record<string, string>;
+  /** Present on RATE_LIMITED. */
+  retryAfterMs?: number;
+}
+
+export interface ApiErrorBody {
+  error: ApiError;
+}
+
+/** What the typed client hands back. It never throws for expected failures. */
+export type ApiResult<T> =
+  | { ok: true; data: T; replayed: boolean }
+  | { ok: false; error: ApiError };
+
+// --- Identity ---------------------------------------------------------------
+
+/**
+ * Four roles, matching the CHECK on `users.role` in
+ * `worker/migrations/0001_identity.sql`. `contributor` authors content without
+ * publishing it; `moderator` works the errata triage queue; `admin` publishes
+ * and retires questions, which changes what candidates sit. The API genuinely
+ * needs the triage role to be distinct from the publish role, so this is four
+ * values and not three.
+ */
+export type UserRole = 'student' | 'contributor' | 'moderator' | 'admin';
+
+export interface SessionUser {
+  id: string;
+  email: string | null;
+  displayName: string | null;
+  role: UserRole;
+  /** True for a guest identity that can still be upgraded in place. */
+  isAnonymous: boolean;
+  hasPassword: boolean;
+  createdAt: EpochMs;
+}
+
+export interface SessionResponse {
+  user: SessionUser | null;
+  sessionExpiresAt: EpochMs | null;
+  serverNow: EpochMs;
+}
+
+export interface SignupRequest {
+  email: string;
+  password: string;
+  displayName?: string;
+}
+
+export interface LoginRequest {
+  email: string;
+  password: string;
+}
+
+/** Upgrades the CURRENT anonymous session's user in place. The id is kept. */
+export interface UpgradeAnonymousRequest {
+  email: string;
+  password: string;
+  displayName?: string;
+}
+
+// --- Content ----------------------------------------------------------------
+
+export type ChapterIcon =
+  | 'cpu' | 'code' | 'network' | 'database' | 'brain'
+  | 'chip' | 'settings' | 'book' | 'calculator' | 'monitor';
+
+export interface ChapterSummary {
+  id: string;
+  slug: string;
+  name: string;
+  shortName: string;
+  description: string;
+  questionCount: number;
+  icon: ChapterIcon;
+  color: string;
+  orderIndex: number;
+}
+
+/**
+ * One selectable option as the client sees it.
+ *
+ * `ref` is an OPAQUE token. It is never an index, never a position and never a
+ * `question_options.id`:
+ *
+ *   * browsing a chapter or an SRS queue -> a keyed digest of
+ *     (server secret, viewer, question, option). Stable for one viewer, so a
+ *     selection stored by ref does not re-point on reload; different for
+ *     another viewer, so two accounts comparing payloads learn nothing.
+ *   * inside a mock or practice attempt -> a keyed digest that also mixes in
+ *     the attempt's `option_seed`, so a ref harvested from one attempt is
+ *     meaningless in another.
+ *
+ * Neither form is reversible and neither is reproducible without the server's
+ * secret, so there is nothing here to join against the option ordering in the
+ * public chapter JSON that still sits in git history.
+ *
+ * There is deliberately no `isCorrect` field anywhere on this type.
+ */
+export interface PublicOption {
+  ref: string;
+  body: string;
+}
+
+/**
+ * Editorial difficulty, as stored. `questions.p_value_bp` is the OBSERVED
+ * difficulty and is deliberately not on the wire: it is a per-question
+ * success rate, and publishing it tells a candidate which questions other
+ * candidates get wrong.
+ */
+export type QuestionDifficulty = 'easy' | 'medium' | 'hard';
+
+/** A question with no answer key. Returned by every pre-answer endpoint. */
+export interface PublicQuestion {
+  id: string;
+  chapterId: string;
+  stem: string;
+  options: PublicOption[];
+  difficulty: QuestionDifficulty | null;
+}
+
+export interface ChapterQuestionsResponse {
+  chapterId: string;
+  total: number;
+  offset: number;
+  limit: number;
+  questions: PublicQuestion[];
+}
+
+export interface SearchResultItem {
+  questionId: string;
+  chapterId: string;
+  stem: string;
+}
+
+export interface SearchResponse {
+  query: string;
+  results: SearchResultItem[];
+}
+
+export interface MockTemplateSummary {
+  id: string;
+  slug: string;
+  name: string;
+  description: string;
+  durationMinutes: number;
+  totalQuestions: number;
+  /**
+   * Per-chapter totals, so the UI can describe the paper in one line. Derived
+   * by summing the stored blueprint's sub-chapter rules, NOT a second copy of
+   * the composition: the blueprint is sub-chapter level (60 rules for a full
+   * mock) and this is the aggregate a chapter list wants.
+   */
+  blueprint: Array<{ chapterId: string; questionCount: number }>;
+  /** The real composition, one entry per official NEC syllabus code. */
+  subchapterBlueprint: Array<{
+    chapterId: string;
+    subchapterCode: string;
+    questionCount: number;
+  }>;
+}
+
+/**
+ * One coarse call that boots the whole app shell: chapters, mock templates and
+ * the caller's session. Workers Free allows 100k requests/day, so the client
+ * must not spend three round trips on this.
+ */
+export interface BootstrapResponse {
+  session: SessionResponse;
+  chapters: ChapterSummary[];
+  mockTemplates: MockTemplateSummary[];
+  contentVersion: string;
+}
+
+// --- Attempts (one shape for mock + practice) -------------------------------
+
+export type AttemptStatus = 'in_progress' | 'submitted' | 'expired' | 'abandoned';
+
+export interface AttemptQuestion {
+  questionId: string;
+  chapterId: string;
+  /** 1-based position on THIS paper. Says nothing about the bank. */
+  position: number;
+  stem: string;
+  options: PublicOption[];
+}
+
+// --- Mock tests -------------------------------------------------------------
+
+export interface MockStartRequest {
+  templateId: string;
+  idempotencyKey: string;
+}
+
+export interface MockAttemptPaper {
+  attemptId: string;
+  templateId: string;
+  status: AttemptStatus;
+  startedAt: EpochMs;
+  /** Server-authored deadline. The client renders its timer against this. */
+  expiresAt: EpochMs;
+  serverNow: EpochMs;
+  durationSeconds: number;
+  questionCount: number;
+  questions: AttemptQuestion[];
+  /**
+   * Answers the server has already accepted for this attempt, from the last
+   * pre-deadline sync. Lets a reload resume without trusting localStorage.
+   */
+  savedAnswers: Record<string, string>;
+}
+
+/**
+ * Coarse autosave. The map is questionId -> optionRef and REPLACES the stored
+ * snapshot wholesale, which makes it naturally idempotent and replay-safe.
+ * The server stamps it with its own clock and refuses it past `expiresAt`.
+ */
+export interface MockSyncRequest {
+  attemptId: string;
+  answers: Record<string, string>;
+}
+
+export interface MockSyncResponse {
+  accepted: boolean;
+  serverNow: EpochMs;
+  expiresAt: EpochMs;
+  remainingMs: number;
+  reason?: 'past_deadline' | 'not_in_progress';
+}
+
+export interface MockSubmitRequest {
+  attemptId: string;
+  idempotencyKey: string;
+  answers: Record<string, string>;
+}
+
+/** The ONLY place a mock answer key is ever disclosed. */
+export interface MockReviewQuestion {
+  questionId: string;
+  chapterId: string;
+  position: number;
+  stem: string;
+  options: PublicOption[];
+  selectedRef: string | null;
+  correctRef: string;
+  isCorrect: boolean;
+  explanation: string | null;
+}
+
+export interface MockSubmitResponse {
+  attemptId: string;
+  status: 'submitted';
+  score: number;
+  total: number;
+  correct: number;
+  incorrect: number;
+  skipped: number;
+  accuracyPct: number;
+  /**
+   * `on_time` - submitted inside the grace window, so the payload was scored.
+   * `expired` - submitted after the deadline, so the payload was discarded and
+   *             the last snapshot the server accepted BEFORE `expiresAt` was
+   *             scored instead.
+   */
+  timing: 'on_time' | 'expired';
+  startedAt: EpochMs;
+  expiresAt: EpochMs;
+  submittedAt: EpochMs;
+  /** `min(submittedAt, expiresAt)` - the instant the paper was frozen. */
+  scoredAt: EpochMs;
+  /** Answers discarded because the submission arrived past the deadline. */
+  droppedLateAnswers: number;
+  /** Submitted questionIds that were not on this attempt's paper. */
+  rejectedQuestionIds: string[];
+  review: MockReviewQuestion[];
+}
+
+// --- Practice ---------------------------------------------------------------
+
+export type PracticeMode = 'chapter' | 'bookmarks' | 'srs' | 'wrong' | 'custom';
+
+export interface PracticeStartRequest {
+  mode: PracticeMode;
+  chapterIds?: string[];
+  questionCount: number;
+  idempotencyKey: string;
+}
+
+export interface PracticeAnswerResult {
+  questionId: string;
+  selectedRef: string | null;
+  /** Disclosed only after the answer is committed, for this question alone. */
+  correctRef: string;
+  isCorrect: boolean;
+  explanation: string | null;
+}
+
+export interface PracticeSessionPaper {
+  sessionId: string;
+  mode: PracticeMode;
+  status: AttemptStatus;
+  startedAt: EpochMs;
+  serverNow: EpochMs;
+  questionCount: number;
+  questions: AttemptQuestion[];
+  /** Already-committed answers, so a reload keeps the revealed keys visible. */
+  answered: Record<string, PracticeAnswerResult>;
+}
+
+export interface PracticeAnswerRequest {
+  sessionId: string;
+  questionId: string;
+  /** `null` records a deliberate skip, which still reveals the key. */
+  optionRef: string | null;
+  /** Optional: this endpoint is already idempotent per (session, question). */
+  idempotencyKey?: string;
+  /**
+   * Learner telemetry, all optional and all UNTRUSTED.
+   *
+   * These are inputs to the spaced-repetition grade, not to the score: see
+   * `ratingFromOutcome` in `frontend/src/services/scheduler.ts`, which turns
+   * time-on-question and a guess flag into a Rating. They are safe to accept
+   * from the client precisely because the only thing they can influence is how
+   * soon the learner sees the question again - lying makes your own revision
+   * schedule worse. Correctness is still computed server-side from the key.
+   *
+   * `latencyMs` is clamped server-side; a mock answer accepts none of this.
+   */
+  latencyMs?: number;
+  flaggedGuess?: boolean;
+  confidence?: 1 | 2 | 3;
+}
+
+export interface PracticeAnswerResponse extends PracticeAnswerResult {
+  answeredCount: number;
+  correctCount: number;
+}
+
+export interface PracticeFinishRequest {
+  sessionId: string;
+  idempotencyKey: string;
+}
+
+export interface PracticeFinishResponse {
+  sessionId: string;
+  total: number;
+  correct: number;
+  incorrect: number;
+  skipped: number;
+  accuracyPct: number;
+  finishedAt: EpochMs;
+}
+
+// --- Progress ---------------------------------------------------------------
+
+export interface ChapterProgress {
+  chapterId: string;
+  attempted: number;
+  correct: number;
+  accuracyPct: number;
+  questionCount: number;
+}
+
+export interface ProgressStats {
+  totalAnswered: number;
+  totalCorrect: number;
+  accuracyPct: number;
+  totalAvailable: number;
+  chapters: ChapterProgress[];
+}
+
+export interface StreakInfo {
+  currentStreak: number;
+  longestStreak: number;
+  todayAnswered: number;
+  /** Most recent active days, newest first. */
+  activeDays: DayKey[];
+}
+
+export interface AttemptHistoryItem {
+  kind: 'mock' | 'practice';
+  id: string;
+  label: string;
+  score: number;
+  total: number;
+  accuracyPct: number;
+  at: EpochMs;
+  status: AttemptStatus;
+}
+
+/** One coarse call for the whole dashboard. */
+export interface ProgressOverview {
+  stats: ProgressStats;
+  streak: StreakInfo;
+  recent: AttemptHistoryItem[];
+}
+
+export interface AttemptHistoryResponse {
+  items: AttemptHistoryItem[];
+  nextCursor: string | null;
+}
+
+// --- Bookmarks --------------------------------------------------------------
+
+export interface BookmarkItem {
+  questionId: string;
+  chapterId: string;
+  stem: string;
+  createdAt: EpochMs;
+}
+
+export interface BookmarkListResponse {
+  items: BookmarkItem[];
+}
+
+/**
+ * `desired: true` adds, `false` removes. Expressing it as a desired end state
+ * rather than as add/remove verbs is what makes offline replay safe: replaying
+ * the same mutation twice converges instead of toggling.
+ */
+export interface BookmarkSetRequest {
+  questionId: string;
+  desired: boolean;
+  idempotencyKey?: string;
+}
+
+export interface BookmarkSetResponse {
+  questionId: string;
+  bookmarked: boolean;
+  total: number;
+}
+
+// --- Spaced repetition ------------------------------------------------------
+
+export type SrsGrade = 'again' | 'hard' | 'good' | 'easy';
+
+export type SrsState = 'new' | 'learning' | 'review' | 'relearning';
+
+/**
+ * One scheduling card, in FSRS's vocabulary.
+ *
+ * The field names and units are FSRS's deliberately, because `srs_state` in
+ * `worker/migrations/0005_learning.sql` stores them that way and
+ * `frontend/src/services/scheduler.ts` already carries `stability` and
+ * `difficulty` on its own `Card`. A translation layer between three spellings
+ * of the same card is how a scheduler drifts out of agreement with its store.
+ */
+export interface SrsCardState {
+  questionId: string;
+  dueAt: EpochMs;
+  /** Days until recall probability decays to 90%. */
+  stability: number;
+  /** 1..10, intrinsic to the item for this user. HIGHER IS HARDER. */
+  difficulty: number;
+  /** The interval the scheduler last asked for, in days. */
+  scheduledDays: number;
+  reps: number;
+  lapses: number;
+  state: SrsState;
+  /**
+   * Optimistic-concurrency token: `srs_state.reps`, which every applied review
+   * increments. A review carrying a stale value is a no-op rather than a
+   * conflict, which is what makes a second device's queued review safe.
+   */
+  revision: number;
+}
+
+export interface SrsDueResponse {
+  serverNow: EpochMs;
+  dueCount: number;
+  questions: AttemptQuestion[];
+  /** Keyed by questionId, parallel to `questions`. */
+  cards: Record<string, SrsCardState>;
+}
+
+export interface SrsReviewRequest {
+  questionId: string;
+  grade: SrsGrade;
+  /**
+   * The `revision` the client last saw for this card. The server applies the
+   * review only if it still matches, so a replayed outbox entry is a no-op.
+   */
+  revision: number;
+  idempotencyKey?: string;
+}
+
+export interface SrsReviewResponse {
+  card: SrsCardState;
+  applied: boolean;
+}
+
+// --- Errata reports ---------------------------------------------------------
+
+export type ReportReason =
+  | 'wrong_answer' | 'ambiguous' | 'typo' | 'duplicate' | 'out_of_syllabus' | 'other';
+
+/**
+ * Matches the CHECK on `question_reports.status`. `duplicate` replaces the
+ * earlier `fixed`: an accepted report whose fix landed is `accepted`, and the
+ * state the triage queue actually needed was "this is the same claim as an
+ * existing report".
+ */
+export type ReportStatus = 'open' | 'triaged' | 'accepted' | 'rejected' | 'duplicate';
+
+export interface ReportSubmitRequest {
+  questionId: string;
+  reason: ReportReason;
+  detail?: string;
+  idempotencyKey?: string;
+}
+
+export interface ReportItem {
+  id: string;
+  questionId: string;
+  chapterId: string;
+  reason: ReportReason;
+  detail: string | null;
+  status: ReportStatus;
+  createdAt: EpochMs;
+  resolutionNote: string | null;
+}
+
+export interface ReportListResponse {
+  items: ReportItem[];
+}
+
+// --- Admin ------------------------------------------------------------------
+
+export interface AdminReportItem extends ReportItem {
+  reporterUserId: string;
+  stem: string;
+  /** Open reports against this question, so triage can prioritise. */
+  reportCountForQuestion: number;
+}
+
+export interface AdminReportQueueResponse {
+  items: AdminReportItem[];
+  nextCursor: string | null;
+}
+
+export interface AdminTriageRequest {
+  reportIds: string[];
+  status: ReportStatus;
+  resolutionNote?: string;
+  idempotencyKey: string;
+}
+
+export interface AdminTriageResponse {
+  updated: number;
+  status: ReportStatus;
+}
+
+export type QuestionPublishState = 'draft' | 'published' | 'retired';
+
+export interface AdminPublishRequest {
+  questionIds: string[];
+  state: QuestionPublishState;
+  idempotencyKey: string;
+}
+
+export interface AdminPublishResponse {
+  updated: number;
+  state: QuestionPublishState;
+}
+
+export interface AuditLogItem {
+  id: string;
+  actorUserId: string | null;
+  action: string;
+  entityType: string | null;
+  entityId: string | null;
+  detail: string | null;
+  createdAt: EpochMs;
+}
+
+export interface AuditLogResponse {
+  items: AuditLogItem[];
+  nextCursor: string | null;
+}
+
+// --- Offline outbox ---------------------------------------------------------
+
+/**
+ * Every mutating endpoint the offline outbox may replay, with the body it
+ * replays. Discriminated so the queue can be persisted as JSON and drained
+ * without `any`.
+ *
+ * See `docs/api.md` for the replay contract. The rule: an outbox entry carries
+ * an idempotency key minted ONCE at enqueue time, never regenerated on retry.
+ */
+export type OutboxEntry =
+  | { kind: 'mock.sync'; body: MockSyncRequest }
+  | { kind: 'mock.submit'; body: MockSubmitRequest }
+  | { kind: 'practice.answer'; body: PracticeAnswerRequest }
+  | { kind: 'practice.finish'; body: PracticeFinishRequest }
+  | { kind: 'bookmark.set'; body: BookmarkSetRequest }
+  | { kind: 'srs.review'; body: SrsReviewRequest }
+  | { kind: 'report.submit'; body: ReportSubmitRequest };
+
+export interface QueuedMutation {
+  /** Local queue id. Never sent to the server. */
+  localId: string;
+  entry: OutboxEntry;
+  enqueuedAt: EpochMs;
+  attempts: number;
+  lastError: string | null;
+}
diff --git a/worker/src/validation/parse.ts b/worker/src/validation/parse.ts
new file mode 100644
index 0000000..dae5599
--- /dev/null
+++ b/worker/src/validation/parse.ts
@@ -0,0 +1,101 @@
+/**
+ * The bridge between Zod and this API's error shape.
+ *
+ * ===========================================================================
+ * THIS REPLACED A HAND-WRITTEN VALIDATOR
+ * ===========================================================================
+ *
+ * `validation/v.ts` was a deliberately Zod-shaped subset written because
+ * `worker/package.json` was outside the scope of the change that needed it.
+ * Zod is now a real dependency and the hand-written one is gone. What survives
+ * is this file, because the two behaviours that mattered about it are NOT Zod
+ * defaults and are worth keeping explicit:
+ *
+ * 1. IT FAILS CLOSED ON UNKNOWN KEYS. Every schema is `z.strictObject`, never
+ *    `z.object`: Zod's default is to STRIP an unrecognised key, and stripping
+ *    is the worst of the three options at this boundary. Validated bodies are
+ *    passed straight into the data layer, so a silently-dropped `attemptID`
+ *    typo reads as a missing required field, while a silently-KEPT extra field
+ *    would be a way to append columns to a write. A client that sends
+ *    `{ score: 100 }` to `POST /api/mock/submit` gets a 400 naming the field.
+ *
+ * 2. EVERY ISSUE IS REPORTED AT ONCE, keyed by dotted path, so the 400 tells
+ *    the client which fields to fix in one round trip. Zod's `ZodError.issues`
+ *    is an ARRAY of objects with structured paths; `ApiError.fields` is a flat
+ *    `Record<path, message>` that the frontend renders next to inputs. This
+ *    file is the only place that translation lives.
+ *
+ * It also normalises two things Zod spells differently from the rest of this
+ * codebase: an `unrecognized_keys` issue arrives with an EMPTY path and a list
+ * of offending keys, so it is fanned out to one entry per key; and array
+ * indices become `field[0]` rather than `field.0`, which is what a client's
+ * form bindings expect.
+ */
+
+import { z } from 'zod';
+
+/** Any Zod schema, as this codebase passes them around. */
+export type Schema<T> = z.ZodType<T>;
+
+export type ParseResult<T> =
+  | { success: true; data: T }
+  | { success: false; error: { issues: Record<string, string> } };
+
+/** `['answers', '__proto__']` -> `answers.__proto__`; `['ids', 0]` -> `ids[0]`. */
+function dotted(path: readonly PropertyKey[]): string {
+  let out = '';
+  for (const segment of path) {
+    if (typeof segment === 'number') {
+      out += `[${segment}]`;
+    } else {
+      out += out.length === 0 ? String(segment) : `.${String(segment)}`;
+    }
+  }
+  return out;
+}
+
+/**
+ * Flattens a `ZodError` into `Record<dottedPath, message>`.
+ *
+ * First issue per path wins, which is the most specific one: Zod runs the base
+ * type check before any refinement, so a field that is both the wrong type and
+ * out of range reports the type error -- the one the client has to fix first.
+ */
+export function flattenIssues(error: z.ZodError): Record<string, string> {
+  const issues: Record<string, string> = {};
+  const record = (path: readonly PropertyKey[], message: string): void => {
+    const key = dotted(path);
+    if (!(key in issues)) issues[key] = message;
+  };
+
+  for (const issue of error.issues) {
+    if (issue.code === 'unrecognized_keys') {
+      // Reported once for the object, with the offending keys in a list. Fanned
+      // out so the client gets one message per field, at that field's own path.
+      for (const key of issue.keys) {
+        record([...issue.path, key], 'Unexpected field.');
+      }
+      continue;
+    }
+    record(issue.path, issue.message);
+  }
+
+  // Guarantee at least one issue, so a 400 is never an empty object.
+  if (Object.keys(issues).length === 0) issues[''] = 'Invalid request body.';
+  return issues;
+}
+
+/**
+ * `safeParse(schema, input)`, with the argument order this codebase uses.
+ *
+ * Deliberately a free function rather than `schema.safeParse(input)`: the
+ * schema is the thing that varies at a call site and the input is the thing
+ * being checked, so reading it as a predicate over the input is the right way
+ * round -- and it keeps every caller one import away from the flattening above
+ * instead of remembering to apply it.
+ */
+export function safeParse<T>(schema: Schema<T>, input: unknown): ParseResult<T> {
+  const result = schema.safeParse(input);
+  if (result.success) return { success: true, data: result.data };
+  return { success: false, error: { issues: flattenIssues(result.error) } };
+}
diff --git a/worker/src/validation/schemas.ts b/worker/src/validation/schemas.ts
new file mode 100644
index 0000000..b65733f
--- /dev/null
+++ b/worker/src/validation/schemas.ts
@@ -0,0 +1,357 @@
+/**
+ * Request schemas, in Zod. Every endpoint that accepts a body or a query string
+ * has one here, and the middleware refuses the request if it does not parse.
+ *
+ * EVERY OBJECT IS `z.strictObject`. Zod's `z.object` STRIPS an unrecognised
+ * key, which is the worst of the three options at this boundary -- see the
+ * header of `validation/parse.ts` for the argument. A bare `z.object` anywhere
+ * in this file is a bug.
+ *
+ * The limits are not decoration. `MAX_MOCK_ANSWERS` bounds the JSON blob that
+ * gets expanded by `json_each` in the submit batch, and `MAX_SEARCH_LEN` bounds
+ * what reaches the FTS5 tokeniser. An unbounded answers map is a cheap way to
+ * make one D1 statement do unbounded work on a single-threaded database.
+ */
+
+import { z } from 'zod';
+
+/** The largest paper the API will accept a submission for. */
+export const MAX_MOCK_ANSWERS = 250;
+export const MAX_PRACTICE_QUESTIONS = 100;
+export const MAX_SEARCH_LEN = 120;
+export const MAX_REPORT_DETAIL = 2000;
+export const MAX_ADMIN_BATCH = 100;
+
+/** Request bodies larger than this are refused before they are parsed. */
+export const MAX_BODY_BYTES = 128 * 1024;
+
+/**
+ * No string coercion anywhere, and the message says so.
+ *
+ * `"12"` in a JSON body is a client bug; coercing it hides the bug until a
+ * value like `"12abc"` arrives. Zod rejects `NaN` by default and -- verified,
+ * not assumed -- also rejects `Infinity`, so a hostile numeric value cannot
+ * reach an INTEGER column or skew an aggregate.
+ */
+const number = () => z.number({ error: 'Expected a finite number.' });
+const integer = () => number().int('Expected an integer.');
+
+/**
+ * A server-minted entity id, or any opaque token on the wire.
+ *
+ * Charset-restricted because these reach a primary key and are echoed in logs,
+ * and bounded because `question_reports.public_id`, `attempts.public_id` and an
+ * idempotency key all become half of a unique index.
+ */
+const TOKEN_RE = /^[A-Za-z0-9_.:-]+$/;
+const token = (maxLen = 64) =>
+  z
+    .string({ error: 'Expected a string.' })
+    .min(1, 'Must be a valid identifier.')
+    .max(maxLen, 'Must be a valid identifier.')
+    .regex(TOKEN_RE, 'Must be a valid identifier.');
+
+const entityId = () => token(64);
+const optionRef = () => token(32);
+const questionId = () => entityId();
+
+/**
+ * The idempotency key, as a field. Client-supplied, so it is bounded and
+ * charset-restricted: it becomes half of a primary key and is echoed in logs.
+ * The 8-character floor is so it cannot be trivially guessed by another
+ * session -- the key is scoped per user, but a guessable one would still let a
+ * second tab collide with the first.
+ */
+const idempotencyKey = () =>
+  token(80).min(8, 'Must be at least 8 characters.');
+
+/**
+ * Deliberately boring. A full RFC 5322 matcher is a liability; this rejects
+ * everything that cannot be a deliverable address and nothing that can. The
+ * transforms run before the checks, so a stored address is already the
+ * canonical form `users.email_normalized` will generate from it.
+ */
+const EMAIL_RE = /^[^\s@]{1,64}@[^\s@.]+(\.[^\s@.]+)+$/;
+const email = () =>
+  z
+    .string({ error: 'Expected a string.' })
+    .trim()
+    .toLowerCase()
+    .max(254, 'Must be a valid email address.')
+    .regex(EMAIL_RE, 'Must be a valid email address.');
+
+/** Keys that must never arrive from a client, whatever the schema says. */
+const RESERVED_KEYS: ReadonlySet<string> = new Set([
+  '__proto__',
+  'constructor',
+  'prototype',
+]);
+
+/**
+ * Rejects a prototype-polluting key BEFORE the inner schema sees the object.
+ *
+ * This guard is not optional and it is not paranoia about Zod. Zod's
+ * `z.record` builds its output with plain assignment onto a fresh object, so a
+ * JSON body of `{"__proto__": "x"}` has the key SILENTLY DROPPED -- the parse
+ * succeeds and the field vanishes. That is the stripping failure mode this
+ * whole file exists to avoid: the client believes it submitted an answer for a
+ * question whose id happens to be a reserved word, and the server believes it
+ * submitted nothing. A refinement cannot see it either, because refinements run
+ * on the OUTPUT. So the check has to happen on the raw value, which is what
+ * `z.unknown().superRefine(...).pipe(inner)` does: the pipe's second half never
+ * runs if the first half raised an issue.
+ */
+function noReservedKeys<T extends z.ZodType>(inner: T): z.ZodType<z.output<T>> {
+  return z
+    .unknown()
+    .superRefine((value, ctx) => {
+      if (typeof value !== 'object' || value === null || Array.isArray(value)) return;
+      for (const key of Object.keys(value)) {
+        if (RESERVED_KEYS.has(key)) {
+          ctx.addIssue({ code: 'custom', message: 'Reserved key.', path: [key] });
+        }
+      }
+    })
+    .pipe(inner) as unknown as z.ZodType<z.output<T>>;
+}
+
+// --- Auth -------------------------------------------------------------------
+
+/**
+ * 8 characters is the floor, 200 the ceiling. The ceiling exists because the
+ * password is fed to PBKDF2 and an unbounded input is a cheap CPU-exhaustion
+ * vector on a Worker with a 10ms budget.
+ */
+const password = () =>
+  z.string({ error: 'Expected a string.' }).min(8, 'Must be at least 8 characters.').max(200);
+
+const displayName = () =>
+  z.string({ error: 'Expected a string.' }).trim().min(1).max(60);
+
+export const signupSchema = z.strictObject({
+  email: email(),
+  password: password(),
+  displayName: displayName().optional(),
+});
+
+export const loginSchema = z.strictObject({
+  email: email(),
+  // No minimum, deliberately. Rejecting a short password at the schema would
+  // tell an attacker their guess was too short to be anyone's password.
+  password: z.string({ error: 'Expected a string.' }).min(1).max(200),
+});
+
+export const upgradeAnonymousSchema = z.strictObject({
+  email: email(),
+  password: password(),
+  displayName: displayName().optional(),
+});
+
+export const googleCallbackSchema = z.strictObject({
+  code: z.string({ error: 'Expected a string.' }).min(1).max(2048),
+  state: token(64),
+});
+
+// --- Content ----------------------------------------------------------------
+
+export const chapterQuestionsQuerySchema = z.strictObject({
+  chapterId: entityId(),
+  offset: integer().min(0).max(100_000).default(0),
+  // An unbounded page size is a bulk-extraction vector against the bank.
+  limit: integer().min(1).max(100).default(50),
+});
+
+export const searchQuerySchema = z.strictObject({
+  q: z.string({ error: 'Expected a string.' }).trim().min(2).max(MAX_SEARCH_LEN),
+  chapterId: entityId().optional(),
+  limit: integer().min(1).max(50).default(20),
+});
+
+// --- Mock -------------------------------------------------------------------
+
+export const mockStartSchema = z.strictObject({
+  templateId: entityId(),
+  idempotencyKey: idempotencyKey(),
+});
+
+/**
+ * The answers map is questionId -> optionRef.
+ *
+ * Note what is NOT in here: no score, no `isCorrect`, no timestamps and no
+ * deadline. The client has no field with which to assert anything about
+ * correctness or about time, and because the object is strict, inventing one
+ * is a 400 rather than a silently ignored field.
+ */
+const answersMap = () =>
+  noReservedKeys(
+    z
+      .record(questionId(), optionRef())
+      .refine(
+        (map) => Object.keys(map).length <= MAX_MOCK_ANSWERS,
+        `Allows at most ${MAX_MOCK_ANSWERS} entries.`,
+      ),
+  );
+
+export const mockSyncSchema = z.strictObject({
+  attemptId: entityId(),
+  answers: answersMap(),
+});
+
+export const mockSubmitSchema = z.strictObject({
+  attemptId: entityId(),
+  idempotencyKey: idempotencyKey(),
+  answers: answersMap(),
+});
+
+export const attemptIdSchema = z.strictObject({
+  attemptId: entityId(),
+});
+
+// --- Practice ---------------------------------------------------------------
+
+export const practiceStartSchema = z.strictObject({
+  mode: z.enum(['chapter', 'bookmarks', 'srs', 'wrong', 'custom']),
+  chapterIds: z
+    .array(entityId())
+    .min(1)
+    .max(20)
+    .refine((xs) => new Set(xs).size === xs.length, 'Items must be unique.')
+    .optional(),
+  questionCount: integer().min(1).max(MAX_PRACTICE_QUESTIONS),
+  idempotencyKey: idempotencyKey(),
+});
+
+/** An hour. Anything longer is a tab left open, not time on the question. */
+export const MAX_LATENCY_MS = 60 * 60 * 1000;
+
+export const practiceAnswerSchema = z.strictObject({
+  sessionId: entityId(),
+  questionId: questionId(),
+  /** `null` records a deliberate skip, which still reveals the key. */
+  optionRef: optionRef().nullable(),
+  idempotencyKey: idempotencyKey().optional(),
+  // Telemetry for the spaced-repetition grade only. Bounded so a hostile value
+  // cannot overflow an INTEGER column or skew an aggregate.
+  latencyMs: integer().min(0).max(MAX_LATENCY_MS).optional(),
+  flaggedGuess: z.boolean({ error: 'Expected true or false.' }).optional(),
+  confidence: integer().min(1).max(3).optional(),
+});
+
+export const practiceFinishSchema = z.strictObject({
+  sessionId: entityId(),
+  idempotencyKey: idempotencyKey(),
+});
+
+// --- Progress ---------------------------------------------------------------
+
+export const historyQuerySchema = z.strictObject({
+  limit: integer().min(1).max(50).default(20),
+  cursor: token(64).optional(),
+});
+
+// --- Bookmarks --------------------------------------------------------------
+
+export const bookmarkSetSchema = z.strictObject({
+  questionId: questionId(),
+  // Not coerced: `'true'` and `1` are both client bugs, and accepting either
+  // would make "remove this bookmark" indistinguishable from "add it".
+  desired: z.boolean({ error: 'Expected true or false.' }),
+  idempotencyKey: idempotencyKey().optional(),
+});
+
+// --- SRS --------------------------------------------------------------------
+
+export const srsDueQuerySchema = z.strictObject({
+  limit: integer().min(1).max(50).default(20),
+});
+
+export const srsReviewSchema = z.strictObject({
+  questionId: questionId(),
+  grade: z.enum(['again', 'hard', 'good', 'easy']),
+  /** The `revision` (`srs_state.reps`) the client last saw for this card. */
+  revision: integer().min(0).max(1_000_000),
+  idempotencyKey: idempotencyKey().optional(),
+});
+
+// --- Reports ----------------------------------------------------------------
+
+export const reportSubmitSchema = z.strictObject({
+  questionId: questionId(),
+  reason: z.enum([
+    'wrong_answer',
+    'ambiguous',
+    'typo',
+    'duplicate',
+    'out_of_syllabus',
+    'other',
+  ]),
+  detail: z.string({ error: 'Expected a string.' }).trim().max(MAX_REPORT_DETAIL).optional(),
+  idempotencyKey: idempotencyKey().optional(),
+});
+
+// --- Admin ------------------------------------------------------------------
+
+/** Matches the CHECK on `question_reports.status`. */
+const reportStatus = () => z.enum(['open', 'triaged', 'accepted', 'rejected', 'duplicate']);
+
+export const adminQueueQuerySchema = z.strictObject({
+  status: reportStatus().default('open'),
+  limit: integer().min(1).max(50).default(25),
+  cursor: token(64).optional(),
+});
+
+/** A duplicated id in a batch is a client bug worth surfacing, not deduplicating. */
+const uniqueIds = (inner: z.ZodType<string>) =>
+  z
+    .array(inner)
+    .min(1)
+    .max(MAX_ADMIN_BATCH)
+    .refine((xs) => new Set(xs).size === xs.length, 'Items must be unique.');
+
+export const adminTriageSchema = z.strictObject({
+  reportIds: uniqueIds(entityId()),
+  status: reportStatus(),
+  resolutionNote: z.string({ error: 'Expected a string.' }).trim().max(1000).optional(),
+  idempotencyKey: idempotencyKey(),
+});
+
+export const adminPublishSchema = z.strictObject({
+  questionIds: uniqueIds(questionId()),
+  state: z.enum(['draft', 'published', 'retired']),
+  idempotencyKey: idempotencyKey(),
+});
+
+export const auditQuerySchema = z.strictObject({
+  limit: integer().min(1).max(100).default(50),
+  cursor: token(64).optional(),
+});
+
+// --- Inferred input types ---------------------------------------------------
+//
+// These are the server-side view of each body AFTER validation (defaults
+// applied, strings trimmed). The client-side request types live in
+// `shared/types.ts`; these are intentionally separate because a validated body
+// is not the same type as a request body - `limit` is optional on the wire and
+// required here.
+
+export type SignupInput = z.infer<typeof signupSchema>;
+export type LoginInput = z.infer<typeof loginSchema>;
+export type UpgradeAnonymousInput = z.infer<typeof upgradeAnonymousSchema>;
+export type GoogleCallbackInput = z.infer<typeof googleCallbackSchema>;
+export type ChapterQuestionsInput = z.infer<typeof chapterQuestionsQuerySchema>;
+export type SearchInput = z.infer<typeof searchQuerySchema>;
+export type MockStartInput = z.infer<typeof mockStartSchema>;
+export type MockSyncInput = z.infer<typeof mockSyncSchema>;
+export type MockSubmitInput = z.infer<typeof mockSubmitSchema>;
+export type PracticeStartInput = z.infer<typeof practiceStartSchema>;
+export type PracticeAnswerInput = z.infer<typeof practiceAnswerSchema>;
+export type PracticeFinishInput = z.infer<typeof practiceFinishSchema>;
+export type HistoryInput = z.infer<typeof historyQuerySchema>;
+export type BookmarkSetInput = z.infer<typeof bookmarkSetSchema>;
+export type SrsDueInput = z.infer<typeof srsDueQuerySchema>;
+export type SrsReviewInput = z.infer<typeof srsReviewSchema>;
+export type ReportSubmitInput = z.infer<typeof reportSubmitSchema>;
+export type AdminQueueInput = z.infer<typeof adminQueueQuerySchema>;
+export type AdminTriageInput = z.infer<typeof adminTriageSchema>;
+export type AdminPublishInput = z.infer<typeof adminPublishSchema>;
+export type AuditInput = z.infer<typeof auditQuerySchema>;
diff --git a/worker/tsconfig.json b/worker/tsconfig.json
new file mode 100644
index 0000000..b3249a1
--- /dev/null
+++ b/worker/tsconfig.json
@@ -0,0 +1,33 @@
+{
+  "//": [
+    "Typechecking for worker/src. There was no tsconfig here before: the only",
+    "typecheck script was `db:typecheck`, which compiled db/schema.ts with a",
+    "long flag list, and worker/src was never type-checked at all -- it was",
+    "exercised only by `node --test`, which strips types rather than reading",
+    "them. `npm run typecheck` now covers both halves.",
+    "",
+    "`allowImportingTsExtensions` because every import in this directory is",
+    "written with a `.ts` suffix, which is what lets Node run the sources",
+    "directly (type stripping, Node 22+) with no build step. `noEmit` is",
+    "therefore mandatory, and bundling is wrangler/esbuild's job."
+  ],
+  "compilerOptions": {
+    "target": "es2022",
+    "lib": ["es2023"],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "types": ["node", "@cloudflare/workers-types"],
+    "strict": true,
+    "noUncheckedIndexedAccess": false,
+    "exactOptionalPropertyTypes": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts", "db/schema.ts"]
+}
diff --git a/worker/wrangler.toml b/worker/wrangler.toml
new file mode 100644
index 0000000..485cb5a
--- /dev/null
+++ b/worker/wrangler.toml
@@ -0,0 +1,97 @@
+# Cloudflare Worker + D1 configuration for the NECPrep API.
+#
+# Why D1 and not Supabase: docs/adr/0001-cloudflare-d1-over-supabase.md.
+#
+# `main` is owned by the API handlers (worker/src/**). This file, the
+# migrations and worker/db/** are owned by the schema. Keep that boundary:
+# a binding added here is a contract the handlers may rely on, and a binding
+# removed here breaks them at deploy time rather than at review time.
+
+name = "necprep-api"
+main = "src/index.ts"
+compatibility_date = "2026-10-01"
+# nodejs_compat is needed for node:crypto in the password-hashing and
+# session-token paths. It is NOT needed by anything in worker/db/**.
+compatibility_flags = ["nodejs_compat"]
+
+# D1 is single-threaded per database and serialises writes, so there is no
+# connection pool to size and no Hyperdrive in front of it.
+[[d1_databases]]
+binding = "DB"
+database_name = "necprep"
+# Filled in by `wrangler d1 create necprep`. Left as a placeholder on purpose:
+# a wrong-but-plausible id here would deploy against someone else's database,
+# so this must fail loudly until a human pastes the real one.
+database_id = "9c8e53db-9492-4006-bb29-90424c46ba24"
+migrations_dir = "migrations"
+
+[observability]
+enabled = true
+
+[observability.logs]
+enabled = true
+
+[vars]
+ENVIRONMENT = "development"
+# Origin the browser app is served from. Drives CORS and the OAuth redirect,
+# and `loadConfig` REQUIRES it -- every request 500s until it is right, which
+# is the correct failure mode for a value that decides who may call this API.
+# Replace with the deployed frontend origin, no trailing slash.
+APP_ORIGIN = "http://localhost:5173"
+# Raw-answer retention for the retention cron. 90 on the free plan (the 500 MB
+# per-database limit holds roughly 4 million answer rows); 180 once on Workers
+# Paid. See the archival note in migrations/0004_assessment.sql and
+# src/jobs/retention.ts. Validated on read: a non-numeric value throws rather
+# than silently becoming the default.
+ANSWER_RETENTION_DAYS = "90"
+
+# Session lifetimes are NOT here. They were, as SESSION_IDLE_TTL_SECONDS and
+# SESSION_ABSOLUTE_TTL_SECONDS, and nothing read them: the real values are
+# `SESSION_IDLE_TTL_MS` and `SESSION_ABSOLUTE_TTL_MS` in src/data/auth.ts, and
+# every session-creating call already takes a per-call override. Config that
+# looks adjustable and is not is worse than no config, so the dead vars are
+# gone rather than left as a trap for whoever next tries to shorten a session.
+
+# NO SECRETS IN THIS FILE. `CONTENT_PERMUTATION_SECRET` and the Google OAuth
+# client secret go in via `wrangler secret put <NAME>` and arrive on `env`. A
+# missing secret must throw at startup, not fall back to a default.
+
+[[migrations]]
+# Placeholder so `wrangler deploy` does not warn on a project with no Durable
+# Object migrations. Durable Objects are a candidate home for attempt_answers
+# if the platform outgrows a single D1 database (see 0004); nothing uses them
+# today.
+tag = "v1"
+new_classes = []
+
+# ---------------------------------------------------------------------------
+# Scheduled jobs. Every one of these exists because of a limit documented in
+# the migrations, not because a cron looked tidy.
+# ---------------------------------------------------------------------------
+[triggers]
+crons = [
+  # 02:10 UTC -- answer retention. Batched: D1 counts index rows as writes, and
+  # the free plan allows 100,000 row writes per day.
+  "10 2 * * *",
+  # 02:40 UTC -- expire in-progress attempts past their deadline, sweep dead
+  # sessions, prune expired notifications.
+  "40 2 * * *",
+  # Hourly -- leaderboard snapshots. Never computed on a request path.
+  "5 * * * *",
+]
+
+[env.production]
+name = "necprep-api"
+
+[env.production.vars]
+ENVIRONMENT = "production"
+# Must be the real deployed frontend origin. Leaving localhost here would set
+# a CORS policy that blocks the actual app.
+APP_ORIGIN = "https://necprep.pages.dev"
+ANSWER_RETENTION_DAYS = "90"
+
+[[env.production.d1_databases]]
+binding = "DB"
+database_name = "necprep"
+database_id = "9c8e53db-9492-4006-bb29-90424c46ba24"
+migrations_dir = "migrations"