feat(work): implement largestRectangleArea solution and fix formatting

.claude/skills/problem-approach/SKILL.md

@@ -1,18 +1,17 @@
 ---
 name: problem-approach
-description: Write the `## Approach` section — a Mermaid flowchart that traces the submitted solution — for every docs solution page under apps/docs/content/ that lacks one, using the repo's exact placement and node conventions. Use when asked to add/implement/fill in missing approaches, draw the approach diagram for a problem page, or when `/problem-approach` is run.
+description: Write the `## Approach` section — a Mermaid flowchart that traces the submitted solution — for every docs solution page under docs/ that lacks one, using the repo's exact placement and node conventions. Use when asked to add/implement/fill in missing approaches, draw the approach diagram for a problem page, or when `/problem-approach` is run.
 ---
 
 # Problem approach diagrams
 
-Every solution page (`apps/docs/content/(<category>)/<num>-<slug>.mdx`) has three
-hand-owned sections around the script-owned one:
+Every solution page (`docs/(<phase>)/<topic>/(problems)/<num>_<slug>.mdx`) has a
+hand-owned section before the script-owned one:
 
 ```
-frontmatter → <Badge> → ::::warning (maybe) → ### Example N / ### Constraints
+frontmatter → ::::warning (maybe) → ### Example N / ### Constraints
 ## Approach        ← this skill (Mermaid flowchart of the code below)
 ## Solution        ← bun run sync owns this; never edit inside it
-## Explanation     ← bun run videos --write (NeetCode embed); not this skill
 ```
 
 `sync.ts` regenerates only `## Solution`, so an `## Approach` placed **before** it
@@ -24,7 +23,7 @@ next `work/` push.
 1. **Find the pages** (numbered pages with no `## Approach` heading):
 
    ```sh
-   grep -L '^## Approach' apps/docs/content/*/*.mdx
+   grep -rL '^## Approach' docs --include='[0-9]*_*.mdx'
    ```
 
 2. **For each page**, read `## Solution` and write the diagram from *that code* — the
@@ -48,11 +47,13 @@ next `work/` push.
    ````
 
 4. **Check** each diagram by hand against the syntax rules below (the docs build does
-   not parse Mermaid — a broken diagram fails only in the browser), then run the
-   docs build once at the end and review the pages in `bun run dev`:
+   not parse Mermaid — a broken diagram fails only in the browser). The site is built
+   from prdlk/cs, which reads `docs/` over HTTP, so preview unpushed pages there
+   against this checkout (its `README` names the local-content switch), then build
+   once at the end:
 
    ```sh
-   cd apps/docs && bunx blume build --isolated && rm -rf .blume-verify
+   cd ../cs && bunx blume build --isolated && rm -rf .blume-verify
    ```
 
 Pages with two languages (`<CodeGroup>`) get **one** diagram, traced from the
@@ -60,7 +61,7 @@ Python version. Pages with only JavaScript trace the JavaScript.
 
 ## Diagram conventions
 
-Reference page: `apps/docs/content/(array)/15-3sum.mdx`. Every existing diagram
+Reference page: `docs/(01-linear-structures)/two-pointers/(problems)/15_3sum.mdx`. Every existing diagram
 follows this shape:
 
 ```mermaid
@@ -101,7 +102,7 @@ flowchart TD
   The base case is the first decision after entry.
 - **Classes** (design problems) use one `subgraph name["method(args)"]` per public
   method, plus a `state["…"]` subgraph describing the fields, with `state --> method`
-  edges — see `(hash-table)/146-lru-cache.mdx`. Private helpers are named inside the
+  edges — see `hybrid-structures/(problems)/146_lru-cache.mdx`. Private helpers are named inside the
   method nodes (`"_remove_node then _add_node — move it beside the tail"`), not drawn.
 - **Annotate the why with an em dash** inside the node, sparingly (one clause, a few
   per diagram): `"nums.sort() — duplicates become adjacent"`, `"map = {0: 1} — the
@@ -123,7 +124,7 @@ flowchart TD
 ### Code that does not run
 
 Trace it anyway — the diagram documents what was submitted — and put a `::::warning`
-callout **before** the fence naming exactly why it fails (`(array)/121-best-time-to-buy-and-sell-stock.mdx`):
+callout **before** the fence naming exactly why it fails (`sliding-window/(problems)/121_best-time-to-buy-and-sell-stock.mdx`):
 
 ````md
 ## Approach
@@ -144,7 +145,7 @@ there (then `bun run sync`).
 
 - Do not write prose approaches, complexity tables or alternative algorithms — the
   section is one flowchart (plus the warning callout when the code is broken).
-- Do not touch `## Solution` or anything after it; `## Explanation` is filled by
-  `bun run videos --write`.
+- Do not touch `## Solution` or anything after it, nor the frontmatter `topics:` /
+  `video:` keys (`bun run sync` / `bun run videos --write` own them).
 - Do not add an approach to `reference/` pages or `index.mdx` — only numbered
   solution pages (`title: 'NN. …'`) carry one.

.githooks/pre-commit

@@ -1,35 +0,0 @@
-#!/bin/sh
-# Pre-commit: the docs pages under apps/docs/content are generated from work/1
-# by `bun run sync`, and deploy.yml publishes whatever main holds. Regenerate
-# them now and stage what sync changed, so a solution and its page land in the
-# same commit and a stale `## Solution` never reaches main.
-#
-# Sync reads the working tree, not the index, so the pages it writes only
-# match this commit when work/1 has nothing unstaged: an untracked or
-# half-staged solution would ship a page whose source is not in the commit.
-# In that case refuse and say what to stage.
-#
-# Only paths that became dirty during sync are staged. Anything already dirty
-# beforehand (hand-written `## Approach` prose in progress, a new index.mdx)
-# stays where the author left it.
-#
-# Bypass for a deliberate partial commit: git commit --no-verify
-set -eu
-
-cd "$(git rev-parse --show-toplevel)"
-
-unstaged=$(git status --porcelain -- work/1 | grep -v '^[MADR] ' || true)
-if [ -n "$unstaged" ]; then
-  printf 'pre-commit: work/1 has unstaged changes; stage or stash them so the generated pages match this commit:\n%s\n' "$unstaged" >&2
-  exit 1
-fi
-
-before=$(mktemp)
-trap 'rm -f "$before"' EXIT
-git status --porcelain -- apps/docs/content | sort > "$before"
-report=$(bun run --silent sync)
-generated=$(git status --porcelain -- apps/docs/content | sort | comm -13 "$before" - | cut -c4-)
-if [ -n "$generated" ]; then
-  printf '%s\n' "$report" | grep -v 'skipped (in sync)' >&2
-  printf '%s\n' "$generated" | xargs git add --
-fi

.github/workflows/close-solved.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
     inputs:
       dry_run:
-        description: Report matches without closing anything
+        description: Report matches and would-be releases without closing or releasing anything
         type: boolean
         default: false
 
@@ -61,3 +61,43 @@ jobs:
             exit 0
           fi
           bun apps/cli/sync-project-fields.ts
+
+  # One timever release per finished topic (every core sub-issue closed) and
+  # per finished `Review <N> — <Phase>` issue (every sub-issue closed), tagged
+  # at the instant the last required problem closed. It reads the same rules
+  # close-topics uses (apps/cli/topics.ts) straight off the sub-issues, so the
+  # push that finishes a topic or review releases it in this run — no waiting
+  # for Close Topics, which chains after this workflow. A problem re-parented
+  # into a Review issue still belongs to its topic (apps/api/src/reviews.ts),
+  # so moving it never rewrites a topic's release. Reconciling: a run releases
+  # everything finished and still missing a release, so a manual dispatch
+  # backfills and a problem closed by hand in the UI is picked up by the next
+  # run. The docs changelog (deploy.yml) tags each release Topic or Review.
+  release:
+    needs: close
+    # Like close-topics: a partially failed close still closed some issues,
+    # and the script only reads state, so run unless the run was cancelled.
+    if: ${{ !cancelled() }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # push tags, create releases
+      issues: read
+    steps:
+      # Full history: each tag targets the last main commit before its topic
+      # finished, and backfilled tags reach far behind HEAD.
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: oven-sh/setup-bun@v2
+
+      # The tagger of the annotated, backdated tags.
+      - run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+      # No install step: the script only uses Bun builtins + fetch.
+      - run: bun apps/cli/release-topics.ts
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          DRY_RUN: ${{ inputs.dry_run }}

.github/workflows/close-topics.yml

@@ -1,9 +1,14 @@
 name: Close Topics
 
-# No D1 push here, unlike Close Solved: D1 stores no topic completion column.
-# Phase progress, the gate pools and the charts all derive from the problem
-# rows, which close-solved already logs — a topic is finished exactly when its
-# core problems are, so there is nothing left to reconcile.
+# Closes finished topics AND finished `Review <N> — <Phase>` issues (every
+# sub-issue closed). Problems moved from a topic into a Review issue still
+# count toward that topic (apps/cli/topics.ts).
+#
+# No D1 push here, unlike Close Solved: D1 stores no topic or review
+# completion column. Phase progress, the gate pools and the charts all derive
+# from the problem rows, which close-solved already logs — a topic or review
+# is finished exactly when its problems are, so there is nothing left to
+# reconcile.
 
 on:
   # Close Solved closes problem issues with GITHUB_TOKEN, and token-driven
@@ -19,7 +24,7 @@ on:
   workflow_dispatch:
     inputs:
       dry_run:
-        description: Report finished topics without closing anything
+        description: Report finished topics and reviews without closing anything
         type: boolean
         default: false
 
@@ -34,7 +39,7 @@ concurrency:
 jobs:
   close:
     # The `issues` trigger fires for every issue in the repo; only closing a
-    # problem sub-issue can ever complete a topic's core set.
+    # problem sub-issue can ever complete a topic's core set or a review.
     if: github.event_name != 'issues' || contains(github.event.issue.labels.*.name, 'problem')
     runs-on: ubuntu-latest
     steps:

.github/workflows/deploy.yml

@@ -5,51 +5,24 @@ on:
     branches: [main]
   workflow_dispatch:
 
+# The Worker only. The docs site is built and published from prdlk/cs, which
+# reads docs/ from this repo over HTTP (Blume's mdxRemote()), so this repo has
+# no Pages build.
 permissions:
   contents: read
-  pages: write
-  id-token: write
 
 # The Worker deploy is idempotent (wrangler uploads the whole bundle), so on a
-# burst of pushes only the last one matters: cancel-in-progress is correct for
-# both the Pages build and the Worker job.
+# burst of pushes only the last one matters: cancel-in-progress is correct.
 concurrency:
   group: deploy
   cancel-in-progress: true
 
 jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22 # Blume requires 22.12+
-
-      - uses: oven-sh/setup-bun@v2 # skip if you use npm/pnpm
-
-      - run: bun install --frozen-lockfile
-      - run: bun run build
-
-      - uses: actions/upload-pages-artifact@v3
-        with:
-          path: apps/docs/dist
-
-  deploy:
-    needs: build
-    runs-on: ubuntu-latest
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    steps:
-      - id: deployment
-        uses: actions/deploy-pages@v4
-
   # Deploys on every main push (not path-filtered): apps/api/data/schedule.json
   # is bundled at deploy time, and re-deploying an unchanged Worker is a no-op.
-  # Needs repo secrets CLOUDFLARE_API_TOKEN (Workers Scripts: Edit) and
-  # CLOUDFLARE_ACCOUNT_ID.
+  # Needs repo secrets CLOUDFLARE_API_TOKEN (Workers Scripts: Edit),
+  # CLOUDFLARE_ACCOUNT_ID, and OPENROUTER_API_KEY (the docs assistant's
+  # POST /ask; the Actions secret is the one copy, mirrored into the Worker).
   deploy-api:
     runs-on: ubuntu-latest
     steps:
@@ -62,6 +35,13 @@ jobs:
       # DST cron guards must hold before the Worker ships.
       - run: bun run api:test
 
+      - run: printf %s "$OPENROUTER_API_KEY" | bunx wrangler secret put OPENROUTER_API_KEY
+        working-directory: apps/api
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+
       - run: bun run api:deploy
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.gitignore

@@ -1,5 +1,6 @@
 # dependencies (bun install)
 node_modules
+.openlogs
 tmp/
 *.log
 .crush
@@ -36,9 +37,6 @@ report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
 # Finder (MacOS) folder config
 .DS_Store
 /CLAUDE.md
-.blume/
-/apps/docs/docs/.wrangler/state/v3
-.blume-verify/
 
 # api worker
 apps/api/.dev.vars

AGENTS.md

@@ -2,7 +2,7 @@
 
 ## Project Overview
 
-LeetCode interview-prep campaign (8 weeks, 2026-08-17 → Oct 11) run as a repo: solution files under `work/`, a Blume docs site under `apps/docs/`, GitHub Actions that reconcile issues and publish docs, and a Cloudflare Worker (`apps/api/`) that runs the spaced-repetition system (SRS) — daily digest email, one-tap logging, weekly review issues, live charts. Issues model the curriculum: ~24 `topic` issues (`Topic NN — Name`) own ~161 `problem` sub-issues titled `LC <num> · <Name>`, with difficulty and set carried **only** by labels (`set:core|optional|deferred`, `diff:*`) — never by the title; milestones are phases; a user-level GitHub Project ("Interview Prep", #2) mirrors review state.
+LeetCode interview-prep campaign (2026-08-17 → Nov 3: eight weeks of topics, then the Review-issue phase; the end is the last date in `apps/api/data/schedule.json` — `CAMPAIGN_END`/`CAMPAIGN_DAYS` in `apps/api/src/srs.ts` are derived from it, never declared) run as a repo: solution files under `work/`, the docs content under `docs/` (MDX only — the Blume site that publishes it lives in [prdlk/cs](https://github.com/prdlk/cs) and reads `docs/` over HTTP), GitHub Actions that reconcile issues, and a Cloudflare Worker (`apps/api/`) that runs the spaced-repetition system (SRS) — daily digest email, one-tap logging, weekly review issues, live charts. Issues model the curriculum: ~24 `topic` issues (`Topic NN — Name`) own ~161 `problem` sub-issues titled `LC <num> · <Name>`, with difficulty and set carried **only** by labels (`set:core|optional|deferred`, `diff:*`) — never by the title; milestones are phases; a user-level GitHub Project ("Interview Prep", #2) mirrors review state.
 
 ## Architecture & Data Flow
 
@@ -10,10 +10,12 @@ Three owners, one direction of truth:
 
 ```mermaid
 flowchart LR
-  work[work/ solutions] -->|bun run sync| docs[apps/docs/content/*.mdx]
+  work[work/ solutions] -->|bun run sync| docs[docs/*.mdx + docs/site.json]
+  docs -->|mdxRemote + site.json fetch| Site[prdlk/cs docs site]
   work -->|close-solved.yml| PI[problem issues]
   work -->|close-solved.yml POST /admin/solved| D1[(D1 = SRS state)]
-  PI -->|close-topics.yml| TI[topic issues]
+  PI -->|close-topics.yml| TI[topic + Review N issues]
+  PI -->|close-solved.yml release job| Rel[timever release per finished topic / Review N]
   GH[GitHub issues = catalog] -->|nightly reconcile| D1
   D1 -->|8 AM ET cron| Mail[digest email + one-tap links]
   Mail -->|GET /log| D1
@@ -37,6 +39,9 @@ flowchart LR
 - **Determinism = idempotency.** Drill/gate sampling uses a seeded PRNG (`rng()` in `apps/api/src/srs.ts`, FNV-1a → mulberry32, seed = date / ISO week); the digest is keyed by ET date in `email_log`; one-tap links are unique on (problem, date, kind).
 - **DST-proof crons:** each event has two UTC crons; code fires only on the computed ET hour (`etHour`), unit-checked in `apps/api/src/srs.test.ts`.
 - **Chained workflows:** `GITHUB_TOKEN`-driven issue closes fire no `issues` events, so `close-topics.yml` chains off `workflow_run` of Close Solved instead. The Worker's webhook uses its own `GH_PAT`, so its events flow normally.
+- **One "finished topic" rule, two consumers.** `apps/cli/topics.ts` (`coreSet()`: every `set:core` sub-issue closed, zero core = never) is read by `close-topics.ts` (closes the topic issue) and `release-topics.ts` (the `release` job of `close-solved.yml`). The release reads the sub-issues, not the topic issue, so the push that finishes a topic releases it in the same run instead of waiting for Close Topics to chain after it. Version = [timever](https://gist.github.com/twolfson/de1b004dd22536b8e668) (`YYYYMMDD.HHMMSS.NNNNNNNNN`, UTC) of the instant the last core problem closed; the tag is annotated and backdated to that instant, on the last first-parent main commit before it; the body is a changelog snapshot at that instant (a one-sentence summary first, then the problems closed on the finish day / earlier, with solution links at the tag — problems still open at the finish are left out). A release is found by its `<!-- release-topics: #N -->` body marker, never by tag name, so re-closing a core problem never mints a second one; an existing release keeps its tag and has its name (the topic title) and body rewritten whenever the render changes. The docs site's `/changelog` (prdlk/cs `pages/changelog.astro` + `lib/releases.ts`) fetches this repo's releases at its build, dates each by its timever tag, not `published_at` (which the API cannot backdate), tags it `Topic` or `Review` from the release name, and lists the rows of its `### Closed …` tables — so the tag format and that table shape are its cross-repo contract with `render()`.
+- **Review issues re-parent problems; topics still own them.** The transfer phase's 20 `Review <N> — <Phase>` issues (label `review`, milestone `Review — Transfer & Mocks`; not the Worker's `Review — Week N` gate issues) hold open optional/deferred problems as sub-issues in solve order, moved there with `replace_parent`. `apps/api/src/reviews.ts` is the ONE recovery of ownership — `readReviews()` (one GraphQL request per 50 `review` issues, cheap enough for the Worker's cron subrequest budget) reads each moved problem's topic off its last `parent_issue_removed` event naming a topic, `movedFromTopics()` groups them — shared by the Worker's catalog reconcile (a moved problem's D1 row keeps syncing its labels and `topic_issue`) and `apps/cli/topics.ts` (`readProblems()` returns a topic's sub-issues plus its moved problems, so the finished rule and existing release bodies do not change when a problem moves). A Review issue finishes by `completion()` in `topics.ts` — every sub-issue closed, any set — which `close-topics.ts` closes it on and `release-topics.ts` releases it on, exactly like a topic: timever of the last close, same `<!-- release-topics: #N -->` marker (issue numbers never collide), body fields from the review's `**Scheduled:**`/`**Phase:**`/`**Load:**` lines.
+- **Review days are plan days.** `schedule.json` books each Review issue on its own date — Mon/Tue/Thu/Fri only, Oct 1 → Nov 3 — as `review: { issue, title, problems }` (solve order). The digest renders it as a linked "Today's review" section with the issue's day rules (`REVIEW_RULES` in `email.tsx`, one sentence for HTML and text), its problems join `RESERVED` so drills and sampled gates never draw them early, and `gate: []` skips a Saturday's checkpoint (Oct 3). The issue's sub-issues stay the truth: the catalog reconcile compares every booked review's title and problem list with GitHub and returns any mismatch as `reviewDrift` (also logged), so a re-arranged Review issue shows up the next sync instead of silently disagreeing with the email. Move a review by editing its `schedule.json` date AND the issue's `**Scheduled:**` line (the release body reads it).
 
 ## Key Directories
 
@@ -44,10 +49,10 @@ flowchart LR
 |---|---|
 | `work/<1\|3\|7>/<Difficulty>/<Category>/<num>.<slug>.{js,py}` | Solutions, e.g. `work/1/Easy/Array/1.two-sum.py`. The top directory is the spaced-repetition bucket: `1` = first solve, `3`/`7` = the blind re-solves of that problem 3 and 7 days later. Machine-parsed header comment (title / `Difficulty:` / URL / `─` rule / statement) — preserve its exact shape |
 | `apps/cli/` | Flat Bun TS workspace: automation entries (shebang + top-level await) and libraries (no shebang, side-effect-free on import). Root `bun run` scripts delegate here |
-| `apps/docs/` | Blume site (`blume.config.ts`, `content/`, `components/` + `components.ts`, `islands/`, `public/`). `content/<topic>/<num>-<slug>.mdx` plus one `meta.ts` per topic folder, all generated by sync: the folder is the README campaign topic slug (`tree-dfs/`, `heap-priority-queue/`) and a real route segment (`/tree-dfs/invert-binary-tree`), the `meta.ts` carries the exact label and topic number so the sidebar reads in curriculum order, and the page badge is the `work/` data-structure category. A hand-written `<topic>/index.mdx` (`hidden: true`) is that topic's landing page: Blume ≥ 1.7.3 links the sidebar group row to it (`sliding-window/index.mdx` → `/sliding-window`) and the hidden flag drops the duplicate row. Two kinds of custom MDX component, both import-free on every page: `islands/<Name>.tsx` is hydrated React (auto-discovered; `ProgressDashboard`, `DependencySpine` — the README topic map as data, zoom/pan, nodes link to whatever route Blume's `/api/docs/navigation.json` reports for the topic folder, inert until a topic has pages), `components/<Name>.astro` registered in `components.ts` is static markup plus a custom element for behaviour, the way Blume's own `Frame` is built (`Carousel`/`CarouselImage`: `src` takes a URL, `/file.png`, or the page-relative `../../public/file.png`) |
-| `apps/api/` | Cloudflare Worker workspace: `src/` modules, `data/schedule.json` (the plan: `date → { topics | problems | gate | sweep }`, human-edited, bundled at deploy), `migrations/` (append-only; `0002` is the +3/+7 ladder rebuild) |
-| `.github/workflows/` | deploy (docs → Pages, Worker → Cloudflare, on every main push), close-solved (issues + `/admin/solved` + Project `Set`/`Difficulty`, needs `SRS_ADMIN_KEY` and `PROJECT_PAT`), close-topics, sync-d1 (issue edits → `/admin/reconcile`), spaced-repetition (daily 06:00 ET cron → today's review issue; `GITHUB_TOKEN` only, no secrets) |
-| `.githooks/` | Tracked git hooks; `bun install` points `core.hooksPath` here (root `prepare` script, no husky). `pre-commit` runs `bun run sync` and stages only the pages sync changed, so a solution and its page land in one commit; it refuses to run while `work/1` has anything unstaged (sync reads the tree, so the page would not match the commit), and leaves pre-existing dirt under `apps/docs/content` (in-progress `## Approach` prose) unstaged. `git commit --no-verify` for a deliberate partial commit |
+| `docs/` | The docs content, and nothing of the site: no `blume.config.ts`, no `meta.ts`, no components. prdlk/cs publishes it with Blume's `mdxRemote()` source, which fetches `.md`/`.mdx` files only. `docs/(0N-<phase>)/<topic>/(problems)/<num>_<slug>.mdx` is generated by sync; `(0N-<phase>)/<topic>/index.mdx` (`hidden: true`) is a topic's hand-written landing page, and `index.mdx`/`keywords.mdx`/`progress.mdx` sit at the root. The phase folder is a `(group)` (sidebar section, no route segment), the topic folder is the README campaign topic slug (`tree-dfs/`, `heap-priority-queue/`) and a real route segment, and `(problems)` is a second `(group)` inside it, so `tree-dfs/(problems)/226_invert-binary-tree.mdx` routes to `/tree-dfs/invert-binary-tree` (Blume sorts by the `<num>_` prefix and strips it from the route). `docs/site.json` is sync's generated manifest and the site's ONE other input: `folders` (path under `docs/` → `{ title, order, icon?, display? }`, exactly what a `meta.ts` in that folder would say — every topic `display: "page"`, so it is one sidebar row whose panel holds its landing page and a "Problems" section) and `redirects` (the `/<num>` short links). Images are root-absolute (`![](/topo_intro_1.png)`, `<CarouselImage src='/binary_search.001.png' />`) and served from the site's `public/` — a page-relative path cannot resolve once the MDX is fetched over HTTP. Frontmatter keys beyond Blume's (`topics:`, `video:`, `issue:`) and the MDX components pages use (`<CodeGroup>`, `<Carousel>`/`<CarouselImage>`, the islands) are the site's to declare — add a new one there before a page uses it |
+| `apps/api/` | Cloudflare Worker workspace: `src/` modules, `data/schedule.json` (the plan: `date → { topics | problems | review | gate | sweep }`, human-edited, bundled at deploy), `migrations/` (append-only; `0002` is the +3/+7 ladder rebuild) |
+| `.github/workflows/` | deploy (Worker → Cloudflare with the `OPENROUTER_API_KEY` Actions secret put into it first, on every main push; the docs site deploys from prdlk/cs), close-solved (issues + `/admin/solved` + Project `Set`/`Difficulty`, needs `SRS_ADMIN_KEY` and `PROJECT_PAT`; then the `release` job: timever tag + release per finished topic, `contents: write`), close-topics, sync-d1 (issue edits → `/admin/reconcile`), spaced-repetition (daily 06:00 ET cron → today's review issue; `GITHUB_TOKEN` only, no secrets) |
+| `.githooks/` | `bun install` points `core.hooksPath` here (root `prepare` script, no husky). Its `pre-commit` hook (run `bun run sync`, stage only what sync changed — pages and `docs/site.json`) was removed in `e63d517`, so nothing runs on commit today: run `bun run sync` yourself before committing a solution, or its page and short link ship a commit later |
 
 ## Development Commands
 
@@ -67,13 +72,14 @@ bun run test            # run ONE solution against LeetCode's judge (not a test
                         # most recently tested first, stamped in the db on exit 0)
 bun run submit          # submit ONE solution to LeetCode (newest scaffold first, nothing
                         # hidden; last_submitted stamped in the db on exit 0)
-bun run sync            # work/1 → apps/docs/content/ pages (re-solves are never published)
-bun run videos          # docs pages with no <YouTube> embed → NeetCode video per page
-                        # (channel search scraped, no API key; --write appends the
-                        # `## Explanation` embed; "no NeetCode match" pages stay untouched)
-bun run dev|build       # Blume docs site (runs in apps/docs/)
+bun run sync            # work/1 → docs/ pages + docs/site.json (folder meta + /<num> short
+                        # links; re-solves are never published)
+bun run videos          # docs pages with no `video:` frontmatter → NeetCode video per page
+                        # (channel search scraped, no API key; --write adds the
+                        # `video:` key; "no NeetCode match" pages stay untouched)
 bun run close-solved -- --dry-run    # issue reconcilers (also DRY_RUN=1)
 bun run close-topics -- --dry-run
+bun run release-topics -- --dry-run # prints every would-be topic release body
 # close-solved also pushes the solved set to the Worker; point it at a local
 # one and nothing production is touched:
 SRS_API=http://localhost:8787 SRS_ADMIN_KEY=$LINK_KEY bun run close-solved -- --dry-run
@@ -103,24 +109,24 @@ curl -X POST -H "Authorization: Bearer $LINK_KEY" \
 ## Important Files
 
 - `apps/api/src/srs.ts` — SRS domain: the ladder (`new → +3 → +7 → retired`; fail resets to `+3`; first-ever log enters at `+3`), `WINDOWS`/`STAGES`/`TEMPERATURES`/`DIFFICULTIES`/`SETS` (the one vocabulary shared by the charts, the `work/<n>` buckets, the review issues and the stats dashboard), ET date math, `workingDay()` (no scheduled date is ever a Sunday), `temperatureOf()` (days since a concept was last exercised → `hot`/`fresh`/`fading`/`cold`, bands derived from `WINDOWS` so they cannot drift; read-side only, nothing is scheduled off it), seeded sampling, `logAttempt()` (the ONE write path — email taps, webhook, gate scoring all converge here), and overload leveling: at most `REVIEW_CAP` (3) reviews surface per day — `levelReviews()` (run by `sendDigest` on real sends only, never dry) gives everything past the cap a concrete future WORKING day, ≤ 3 per day, oldest first, instead of letting the due pile grow.
-- `apps/api/src/index.ts` — router + cron dispatch; `apps/api/wrangler.jsonc` — bindings (`DB`, `EMAIL`), crons, vars; secrets `GH_PAT`/`WEBHOOK_SECRET`/`LINK_KEY` via `wrangler secret put`.
-- `apps/api/src/digest.ts` / `apps/api/src/email.tsx` — the daily digest, split data/presentation. `digest.ts` reads D1 into a `DigestData`; `email.tsx` owns every colour and every sentence, and renders both the HTML and (via its own `plainDigest`, not React Email's `plainText` mode, which flattens the tables) the text alternative. The retrieval rules hold by construction: `DigestRow` has no title and no issue field, so a review or drill line *cannot* leak the topic or a solution link. Subject is `(Day N/56) LeetCode Daily Digest`.
+- `apps/api/src/index.ts` — router + cron dispatch; `apps/api/wrangler.jsonc` — bindings (`DB`, `EMAIL`), crons, vars; secrets `GH_PAT`/`WEBHOOK_SECRET`/`LINK_KEY` via `wrangler secret put`, and `OPENROUTER_API_KEY`, whose one copy is the repo's Actions secret (deploy.yml puts it before every deploy — rotate it there).
+- `apps/api/src/ask.ts` — `POST /ask`, the docs assistant's backend. Blume's own assistant route is server-rendered and cannot ship in the static Pages build (`BLUME_SERVER_FEATURE_REQUIRED`), so `blume.config.ts` sets `ai.assistant.endpoint` to this route instead of a `provider`. It speaks the Blume island's wire contract (`{ messages, page: { path } }` in, a plain-text stream out, a 503 "The assistant is not configured…" when the key is missing), validates like Blume's generated route (1–40 user/assistant messages, 24 000 chars, 64 KB — no caller system prompt), grounds on the published `llms-full.txt` (current page first, then keyword-ranked excerpts in Blume's 6 × 2 000 / 10 000-char budget, cached 5 min), and streams OpenRouter's chat completions over plain `fetch` — no AI SDK — for the `ASK_MODEL` var. `:free` models share an upstream pool and often answer 429, which the island shows as its rate-limit notice.
+- `apps/api/src/digest.ts` / `apps/api/src/email.tsx` — the daily digest, split data/presentation. `digest.ts` reads D1 into a `DigestData`; `email.tsx` owns every colour and every sentence, and renders both the HTML and (via its own `plainDigest`, not React Email's `plainText` mode, which flattens the tables) the text alternative. The retrieval rules hold by construction: `DigestRow` has no title and no issue field, so a review or drill line *cannot* leak the topic or a solution link. Subject is `(Day N/<CAMPAIGN_DAYS>) LeetCode Daily Digest` — 79 with the plan ending Nov 3; booking a later day in `schedule.json` lengthens it, and the heatmaps and `/api/stats` `heat` with it.
 - `apps/api/src/png.ts` — hand-rolled PNG encoder (RGB8, one IDAT, zlib via `CompressionStream("deflate")`, CRC32, 5×7 bitmap font). It exists because every major email client refuses remote SVG, so `/chart/heatmap.png` rasters the heatmap for the digest while `/chart/heatmap.svg` keeps serving the README byte-for-byte. Both come from one `heatmapCells()` so the two pictures cannot drift.
-- `apps/cli/sync.ts` — work→docs contract: on existing pages only the `<Badge>` line and the `## Solution` section are script-owned, the latter bounded by `solutionEnd()` at the next unfenced top-level heading; human prose before it and any sections after it are never touched. Never hand-write solution pages or edit inside `## Solution`. Two classifications, two homes: the sidebar group is the README topic (`readmeTopics()`, first listing wins for a problem under two topics; a warm-up outside the plan groups under its category at `order: 0`, ahead of topic 1) and the badge is the `work/1/<Difficulty>/<Category>/` category — topic folders and their `meta.ts` are rewritten every run, a page is `rename`d when its topic changes, and a folder every page has left is deleted unless it still holds a hand-written `index.mdx` (sync never writes, moves, or deletes one). Never use `(group)` folders here: they add no route segment, so a topic `index.mdx` inside one collides with the root `/`. The two hand-owned sections around the solution have their own owners: `## Approach` (a Mermaid flowchart tracing the page's code, placed *before* `## Solution` so a re-sync keeps it) is written per the `problem-approach` skill (`/problem-approach` fills every page missing one); `## Explanation` (the NeetCode `<YouTube>` embed, after `## Solution`) is appended by `bun run videos --write` (`apps/cli/videos.ts`).
+- `apps/cli/sync.ts` — work→docs contract: on existing pages only the frontmatter `icon:` and the `## Solution` section are regenerated, and `topics:` (LeetCode's `topicTags` as `{ name, slug }`, fetched by GraphQL) and `issue:` (the URL of the problem's `problem`-labelled GitHub issue, `LC <num> · …`, listed via `github()` — rendered as the neutral `Issue #N` badge after `Explanation`) are filled once — on create, or on any run that finds them missing — never refreshed (delete a key to refetch; offline or without `gh` auth, the page is written without it and the next sync retries; a sync with nothing missing makes no request). Only a problem the README plan lists gets `issue:` — an unplanned warm-up has no catalog issue, so it is never looked up. `## Solution` is the latter bounded by `solutionEnd()` at the next unfenced top-level heading; human prose before it and any sections after it are never touched. Never hand-write solution pages or edit inside `## Solution`. Two classifications, two homes: the sidebar group is the README topic (`readmeTopics()`, first listing wins for a problem under two topics; a warm-up outside the plan groups under its category at `order: 0`, ahead of topic 1) and the `work/1/<Difficulty>/<Category>/` category, which only places an unplanned problem — the page's topic badges are LeetCode's tags, not either classification. Topics nest under their README phase (`## Phase N — Name` headings, shortened via `PHASE_ALIASES`): `docs/(0N-<phase>)/<topic>/`, with every problem page in the topic's `(problems)/` group as `<num>_<slug>.mdx` (a page is found by its frontmatter title, wherever it sits, so a layout change is one sync of `rename`s). `docs/site.json` is wholly script-owned and rewritten whenever it differs, because `mdxRemote()` reads no `meta.ts`: its `folders` are what a `meta.ts` per phase and topic folder would carry — a phase `N. Name` at `order: N`, a topic its exact label, curriculum order, `TOPIC_ICONS` icon and `display: "page"` — all derived from the README, so a rename there is a rename on the site; its `redirects` are the `/<num>` → `/<topic>/<slug>` short links. Which tags the site teaches as topics (`topic-landings.ts`) and its Appendix glossary (`appendix.ts`) are the site's, in prdlk/cs: sync no longer checks them. The phase folder is a Blume `(group)` — no route segment, so `/tree-dfs` is unchanged and a landing page there is one level deep, never at `/` — and the topic folder is the real segment; never put a topic `index.mdx` directly inside a `(group)`. A page is `rename`d when its topic or phase changes; a folder every page has left is deleted (climbing through an emptied `(problems)` and topic into an emptied phase folder) unless it still holds a hand-written `index.mdx` (sync never writes, moves, or deletes one). Slugs come from `slugify()`, which glues a leading number to the next token (`1d-dynamic-programming`) because Blume strips `<digits>-` prefixes from routes. The hand-owned parts have their own owners: `## Approach` (a Mermaid flowchart tracing the page's code, placed *before* `## Solution` so a re-sync keeps it) is written per the `problem-approach` skill (`/problem-approach` fills every page missing one); the frontmatter `video:` (the NeetCode walkthrough, rendered as the red `Explanation` badge) is added by `bun run videos --write` (`apps/cli/videos.ts`).
 - `apps/cli/work.ts` — the `work/` layout: bucket paths, `isSolution()`/`solvedInBucket()` (the stub test, shared with `close-solved.ts`), `firstSolved()` (one `git log`, ET dates, keyed by LC number so past layout moves don't matter), and `reviewQueues()` (what each window still owes). Everything that needs to know where a solution file lives, or when it was solved, goes through here.
-- `apps/api/src/stats.ts` / `apps/cli/stats.ts` / `apps/cli/tui.ts` / `apps/cli/api.ts` — the read side. `buildStats()` is the ONE aggregation: phases, ladder, difficulty, per-topic temperature, gates, the 14-day due queue, and `heat` (every campaign day, zeros and future days included — the docs page windows the tail off it rather than asking a second question). Two readers consume it, the docs island and `bun run stats`, so its shape is both their contract: change all three together. `tui.ts` is hand-rolled ANSI (bars, sparklines, heat cells, alternate screen) on charts.ts's palette, and every chart differs by GLYPH as well as by colour so a piped or `NO_COLOR` dashboard still reads. The TUI recomputes nothing: the only local fact it shows is the `work/` solution count, which is inventory, not schedule.
-- `README.md` live charts are Worker endpoints (`/chart/*.svg`, `/badge/gate.svg`, 5-min Camo cache); the docs `/progress` page fetches `/api/stats` client-side (`apps/docs/islands/ProgressDashboard.tsx`).
-- `apps/docs/blume.config.ts` — site base `/leetcode`; `README.md` campaign table doubles as topic-map input to `sync.ts` (`readmeTopics()`, `TOPIC_ALIASES`).
+- `apps/api/src/stats.ts` / `apps/cli/stats.ts` / `apps/cli/tui.ts` / `apps/cli/api.ts` — the read side. `buildStats()` is the ONE aggregation: phases, ladder, difficulty, `attempting` (open misses, via `MISS_WHERE` in `srs.ts` — the sweep day's definition), per-topic temperature, gates, the 14-day due queue, `heat` (every campaign day, zeros and future days included — the TUI windows its tail rather than asking a second question), `recent` (the ten problems most recently solved, dated by each one's first pass) and `year` (the 365 days ending today — always the calendar year to date — each split by difficulty into attempts and first solves; the docs cards window and bucket it themselves). Two readers consume it, the docs site's `/progress` islands (prdlk/cs `lib/stats.ts`) and `bun run stats`, so its shape is a cross-repo contract: change the Worker and both readers together (additive fields a reader ignores are safe). `tui.ts` is hand-rolled ANSI (bars, sparklines, heat cells, alternate screen) on charts.ts's palette, and every chart differs by GLYPH as well as by colour so a piped or `NO_COLOR` dashboard still reads. The TUI recomputes nothing: the only local fact it shows is the `work/` solution count, which is inventory, not schedule.
+- `README.md` live charts are Worker endpoints (`/chart/*.svg`, `/badge/gate.svg`, 5-min Camo cache); the campaign table doubles as topic-map input to `sync.ts` (`readmeTopics()`, `TOPIC_ALIASES`, `PHASE_ALIASES`). `/api/stats` and `/ask` reflect a requesting origin only when it is in the `DOCS_ORIGIN` var (`apps/api/wrangler.jsonc`, comma-separated: `https://lc.prd.lk,https://prdlk.github.io`) — a new host for the docs site must be added there.
 - Old `.github/srs/` JSON state, its `srs-*` Actions, and the one-shot `import-srs.ts` importer are RETIRED and deleted — do not resurrect; git history is the record.
 
 ## Runtime/Tooling Preferences
 
-- **Bun only**: run scripts with `bun apps/cli/<name>.ts` (or the root `bun run` aliases), install with `bun install --frozen-lockfile`. One workspace (`apps/*`), one root `bun.lock`. Node 22 appears only in `deploy.yml` because Blume requires it.
-- **Near-zero runtime npm dependencies** — SVG, PNG, terminal ANSI, HMAC (WebCrypto), GraphQL are hand-rolled; Actions scripts use Bun builtins + `fetch` only. The **one** exception is the digest email: `apps/api/src/email.tsx` renders React Email (`react`, `react-dom`, `@react-email/components`, `@react-email/render`) inside the Worker, because hand-rolling table-based email HTML that survives Gmail *and* Outlook is not worth owning. It costs ~235 KB gzipped of a 3 MB budget, needs no `nodejs_compat` (it resolves to `renderToReadableStream`), and requires `"jsx": "react-jsx"` in `apps/api/tsconfig.json`. Do not extend this exception to any other module.
+- **Bun only**: run scripts with `bun apps/cli/<name>.ts` (or the root `bun run` aliases), install with `bun install --frozen-lockfile`. One workspace (`apps/*`), one root `bun.lock`.
+- **Near-zero runtime npm dependencies** — SVG, PNG, terminal ANSI, HMAC (WebCrypto), GraphQL are hand-rolled; Actions scripts use Bun builtins + `fetch` only. One exception, confined to one surface: the digest email, `apps/api/src/email.tsx`, renders React Email (`react`, `react-dom`, `@react-email/components`, `@react-email/render`) inside the Worker, because hand-rolling table-based email HTML that survives Gmail *and* Outlook is not worth owning. It costs ~235 KB gzipped of a 3 MB budget, needs no `nodejs_compat` (it resolves to `renderToReadableStream`), and requires `"jsx": "react-jsx"` in `apps/api/tsconfig.json`. Do not extend it to any other module. (The docs site's own dependencies are prdlk/cs's.)
 - Local GitHub auth falls back to `gh auth token`; scripts run fine outside Actions.
 
 ## Testing & QA
 
 - Repo-wide: no test framework — `bun run test` submits one solution to LeetCode's judge. Exception: `apps/api/src/srs.test.ts` (`bun:test`) proves the DST cron guards with fixed dates; run via `bun run api:test`.
 - QA is dry-runs + local state: Worker logic against `wrangler dev` + local D1 with `?dry=1&date=`; reconcilers with `--dry-run`; idempotency check = run twice, `cmp` output.
-- Docs changes: `bunx blume build --isolated` (from `apps/docs/`) must pass with no new warnings (then `rm -rf apps/docs/.blume-verify`); after sync, review only *created* pages (prose transforms are heuristic).
+- Docs changes: the site builds in prdlk/cs, which must pass `bunx blume build --isolated` with no new warnings against this repo's `docs/`; after sync, review only *created* pages (prose transforms are heuristic) and `docs/site.json`'s diff.

README.md

@@ -5,11 +5,11 @@
 <p align="center">
   <a href="https://x.com/basedprad"><img alt="follow" src="https://shieldcn.dev/x/follow/basedprad.svg" /></a>
   <a href="https://leetcode.com/progress"><img alt="Custom badge" src="https://shieldcn.dev/badge/view-@prdlk.svg?logo=leetcode" /></a>
-  <a href="https://prdlk.github.io/leetcode"><img alt="badge" src="https://shieldcn.dev/badge/Read-Documentation.svg?logo=lu%3ABook" /></a>
+  <a href="https://lc.prd.lk"><img alt="badge" src="https://shieldcn.dev/badge/Read-Documentation.svg?logo=lu%3ABook" /></a>
 </p>
 
 <p align="center">
-  <sub>8-week interview-prep fight camp. Each phase is a milestone; each topic an issue; each problem a sub-issue.<br>
+  <sub>Interview-prep fight camp: eight weeks of topics, then a review phase to Nov 3. Each phase is a milestone; each topic an issue; each problem a sub-issue.<br>
   New topic Mon–Fri, gate on Saturday, Sunday off — every solve comes back at <strong>+3</strong> and <strong>+7</strong> days,
   the two windows that keep the rest day clear (a Thursday solve's +3 slides to Monday).<br>
   Charts are live from the SRS Worker, never committed: pushing a solution or tapping the daily digest moves them within ~5 min.</sub>

apps/api/.dev.vars.example

@@ -1,3 +1,4 @@
 GH_PAT=github_pat_or_gho_token_with_issues_and_projects_rw
 WEBHOOK_SECRET=random_hex_matching_the_repo_webhook
 LINK_KEY=random_hex_signing_one_tap_links
+OPENROUTER_API_KEY=sk-or-v1_key_for_the_docs_assistant

apps/api/README.md

@@ -17,9 +17,12 @@ Live at `https://srs-api.prdlk.workers.dev`.
 - **The repo owns the plan** — `data/schedule.json`, human-edited,
   bundled at deploy. Git history is its audit log. Each date is a
   `ScheduledDay`: `topics` (one or more topic issues), `problems` (a set day,
-  fixed numbers), `gate` (Saturday's blind set, verbatim), or `sweep` (redo
-  every miss, nothing new). Numbers a `gate` or `problems` entry names are
-  `RESERVED`: the drill and gate samplers never draw them.
+  fixed numbers), `review` (a `Review <N> — <Phase>` issue with its problems
+  in solve order; Mon/Tue/Thu/Fri only), `gate` (Saturday's blind set,
+  verbatim; `[]` skips that week's checkpoint), or `sweep` (redo every miss,
+  nothing new). Numbers a `gate`, `problems` or `review` entry names are
+  `RESERVED`: the drill and gate samplers never draw them. The catalog
+  reconcile reports any drift between a `review` entry and its issue.
 - The GitHub Project mirror writes `Target Date` and nothing else: it is
   best-effort, so failures log warnings and never block a D1 write, and topic
   rows are never written. SRS stage and first-attempt result stay in D1 only —

apps/api/data/schedule.json

@@ -22,7 +22,25 @@
   "2026-09-28": { "topics": [24] },
   "2026-09-29": { "topics": [25] },
   "2026-09-30": { "topics": [26] },
-  "2026-10-01": { "problems": [399, 261, 909, 77, 52] },
-  "2026-10-02": { "sweep": true },
-  "2026-10-03": { "gate": [347, 1254, 1971, 131, 494, 986] }
+  "2026-10-01": { "review": { "issue": 225, "title": "Review 1 — Linear Structures", "problems": [205, 974, 209, 34, 42] } },
+  "2026-10-02": { "review": { "issue": 226, "title": "Review 2 — Linear Structures", "problems": [290, 525, 189, 1004, 84] }, "sweep": true },
+  "2026-10-03": { "gate": [] },
+  "2026-10-05": { "review": { "issue": 227, "title": "Review 3 — Linear Structures", "problems": [643, 128, 162, 71, 4] } },
+  "2026-10-06": { "review": { "issue": 228, "title": "Review 4 — Linear Structures", "problems": [496, 80, 901, 76, 224] } },
+  "2026-10-08": { "review": { "issue": 229, "title": "Review 5 — Nodal & Grid", "problems": [876, 19, 36] } },
+  "2026-10-09": { "review": { "issue": 230, "title": "Review 6 — Nodal & Grid", "problems": [92, 82, 380] } },
+  "2026-10-12": { "review": { "issue": 231, "title": "Review 7 — Nodal & Grid", "problems": [143, 86, 289] } },
+  "2026-10-13": { "review": { "issue": 232, "title": "Review 8 — Nodal & Grid", "problems": [61, 138] } },
+  "2026-10-15": { "review": { "issue": 233, "title": "Review 9 — Hierarchical", "problems": [100, 112, 530, 1046, 103, 124] } },
+  "2026-10-16": { "review": { "issue": 234, "title": "Review 10 — Hierarchical", "problems": [572, 543, 703, 105, 295] } },
+  "2026-10-19": { "review": { "issue": 235, "title": "Review 11 — Hierarchical", "problems": [101, 637, 173, 621, 502] } },
+  "2026-10-20": { "review": { "issue": 236, "title": "Review 12 — Hierarchical", "problems": [108, 129, 373, 648, 212] } },
+  "2026-10-22": { "review": { "issue": 237, "title": "Review 13 — Relational", "problems": [1971, 695, 547, 433] } },
+  "2026-10-23": { "review": { "issue": 238, "title": "Review 14 — Relational", "problems": [130, 261, 909, 1462] } },
+  "2026-10-26": { "review": { "issue": 239, "title": "Review 15 — Relational", "problems": [286, 1254, 721, 399] } },
+  "2026-10-27": { "review": { "issue": 240, "title": "Review 16 — Relational", "problems": [1091, 802, 269] } },
+  "2026-10-29": { "review": { "issue": 241, "title": "Review 17 — Decision Space", "problems": [746, 228, 17, 77, 213, 63, 122] } },
+  "2026-10-30": { "review": { "issue": 242, "title": "Review 18 — Decision Space", "problems": [22, 90, 139, 120, 45, 253, 72] } },
+  "2026-11-02": { "review": { "issue": 243, "title": "Review 19 — Decision Space", "problems": [79, 131, 91, 494, 763, 986, 920] } },
+  "2026-11-03": { "review": { "issue": 244, "title": "Review 20 — Decision Space", "problems": [300, 647, 97, 221, 918, 452, 52] } }
 }

apps/api/src/ask.ts

@@ -0,0 +1,289 @@
+/**
+ * POST /ask — the docs assistant's backend.
+ *
+ * The docs are a static GitHub Pages site, and Blume's own assistant route is
+ * server-rendered (it reads the provider key per request), so the site points
+ * `ai.assistant.endpoint` here instead. This speaks the Blume island's wire
+ * contract (`blume/components/islands/hooks.ts`):
+ *
+ * - request: `{ messages: [{ role, content }], page: { path } }` as JSON,
+ *   `path` the base-stripped route the reader is on;
+ * - response: the answer as a plain UTF-8 text stream; any non-2xx shows the
+ *   island's error notice, and a 503 whose body starts "The assistant is not
+ *   configured" shows that body verbatim.
+ *
+ * Validation matches Blume's generated route: 1–40 user/assistant messages of
+ * string content, ≤ 24 000 chars serialized, a 64 KB body, and only role and
+ * content ever reach the model, so the endpoint cannot be repurposed as an
+ * open LLM proxy with a caller's own system prompt.
+ *
+ * Grounding reads what the site already publishes: `llms-full.txt`, every
+ * page's Markdown under `# Title` / `Source: <url>`. The page the reader is on
+ * goes in first, then the best keyword matches, within Blume's default budget
+ * (6 pages, 2 000 chars each, 10 000 total), under Blume's grounded system
+ * prompt — answer only from the excerpts, cite pages as `[Title](/route)`.
+ *
+ * The model call is OpenRouter's OpenAI-compatible chat endpoint over plain
+ * `fetch` (no SDK — see the repo's near-zero-dependency rule), streamed, with
+ * `reasoning.effort: "none"`, for the model the `ASK_MODEL` var names (a
+ * wrangler.jsonc change swaps it); its SSE deltas are re-emitted as bare text. The
+ * reader closing the panel aborts the request, which aborts the model call.
+ */
+
+const BODY_LIMIT = 64 * 1024;
+const MAX_MESSAGES = 40;
+const MAX_CHARS = 24_000;
+
+const MAX_RESULTS = 6;
+const EXCERPT_CHARS = 2000;
+const CONTEXT_BUDGET = 10_000;
+/** Lead-in kept before the matched region of a long page. */
+const EXCERPT_LEAD = 160;
+/** How long one isolate reuses the parsed corpus (the edge caches the fetch as long). */
+const CORPUS_TTL_MS = 5 * 60_000;
+
+const SYSTEM_PROMPT =
+  "You are a helpful documentation assistant for this project, a LeetCode interview-prep campaign: solved problems grouped by topic, with guides to the techniques behind them. Answer the user's question using ONLY the documentation excerpts below. Each excerpt is headed by its page as `## Page Title (/route)`. If the answer is not covered by the excerpts, say you don't know and suggest where in the docs to look — do not invent details. Always cite the pages you drew from, and write every citation as a Markdown link to that page using its route, e.g. [Page Title](/route).";
+
+/** Words that match everything and rank nothing. */
+const STOPWORDS = new Set(
+  "a an and are as at be but by can do does for from how i if in is it its me my of on or so that the this to was what when where which who why with you your".split(
+    " ",
+  ),
+);
+
+interface AskMessage {
+  role: "user" | "assistant";
+  content: string;
+}
+
+interface Section {
+  title: string;
+  route: string;
+  body: string;
+  /** Lower-cased title + body, searched per query term. */
+  text: string;
+  titleText: string;
+}
+
+// ── corpus ───────────────────────────────────────────────────────
+
+let corpus: { at: number; sections: Section[] } | undefined;
+
+/** `llms-full.txt` split into pages, cached per isolate for `CORPUS_TTL_MS`. */
+async function sections(docsUrl: string): Promise<Section[]> {
+  if (corpus && Date.now() - corpus.at < CORPUS_TTL_MS) return corpus.sections;
+  const res = await fetch(`${docsUrl}/llms-full.txt`, {
+    cf: { cacheTtl: CORPUS_TTL_MS / 1000, cacheEverything: true },
+  });
+  if (!res.ok) throw new Error(`GET llms-full.txt -> ${res.status}`);
+  const full = await res.text();
+  const heads = [...full.matchAll(/^# (.+)\nSource: (\S+)$/gm)];
+  const out = heads.map((head, i): Section => {
+    const start = head.index + head[0].length;
+    const end = heads[i + 1]?.index ?? full.length;
+    const body = full.slice(start, end).replace(/\n-{3,}\s*$/, "").trim();
+    const title = head[1]!.trim();
+    return {
+      title,
+      route: new URL(head[2]!).pathname.replace(/(.)\/+$/, "$1"),
+      body,
+      text: `${title}\n${body}`.toLowerCase(),
+      titleText: title.toLowerCase(),
+    };
+  });
+  corpus = { at: Date.now(), sections: out };
+  return out;
+}
+
+// ── retrieval ────────────────────────────────────────────────────
+
+function terms(text: string): string[] {
+  return [...new Set(text.toLowerCase().match(/[a-z0-9][a-z0-9+#-]*/g) ?? [])].filter(
+    (t) => !STOPWORDS.has(t) && (t.length > 1 || /\d/.test(t)),
+  );
+}
+
+function occurrences(haystack: string, needle: string): number {
+  let count = 0;
+  for (let at = haystack.indexOf(needle); at !== -1; at = haystack.indexOf(needle, at + needle.length)) count++;
+  return count;
+}
+
+/**
+ * The pages to inject, best first: term frequency damped by log and weighted
+ * by rarity across pages (idf), a title hit counting triple — so "217" or
+ * "sliding window" lands on the page named that rather than every page that
+ * mentions it in passing.
+ */
+function rank(all: Section[], query: string[]): Section[] {
+  const idf = new Map(
+    query.map((t) => [t, Math.log(1 + all.length / (1 + all.filter((s) => s.text.includes(t)).length))]),
+  );
+  return all
+    .map((section) => {
+      let score = 0;
+      for (const t of query) {
+        const tf = occurrences(section.text, t);
+        if (tf) score += idf.get(t)! * (Math.log(1 + tf) + (section.titleText.includes(t) ? 3 : 0));
+      }
+      return { section, score };
+    })
+    .filter((r) => r.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, MAX_RESULTS)
+    .map((r) => r.section);
+}
+
+/** A page whole when it fits, else `chars` from just before its first query hit. */
+function excerpt(section: Section, query: string[], chars: number): string {
+  if (section.body.length <= chars) return section.body;
+  const lower = section.body.toLowerCase();
+  const hits = query.map((t) => lower.indexOf(t)).filter((i) => i !== -1);
+  const start = hits.length ? Math.max(0, Math.min(...hits) - EXCERPT_LEAD) : 0;
+  return `${start > 0 ? "…" : ""}${section.body.slice(start, start + chars)}…`;
+}
+
+/** The system prompt: the current page, then the ranked pages, within the budget. */
+async function instructions(env: Env, messages: AskMessage[], path: string | undefined): Promise<string> {
+  const all = await sections(env.DOCS_URL);
+  // A follow-up ("and in Python?") leans on the question before it.
+  const asked = messages.filter((m) => m.role === "user").slice(-2).map((m) => m.content);
+  const query = terms(asked.join(" "));
+  const current = path ? all.find((s) => s.route === path) : undefined;
+  const picked = [...(current ? [current] : []), ...rank(all, query).filter((s) => s !== current)];
+  const parts: string[] = [];
+  let budget = CONTEXT_BUDGET;
+  for (const section of picked) {
+    if (budget < 200) break;
+    const text = excerpt(section, query, Math.min(EXCERPT_CHARS, budget));
+    parts.push(`## ${section.title} (${section.route})\n\n${text}`);
+    budget -= text.length;
+  }
+  return parts.length ? `${SYSTEM_PROMPT}\n\n# Documentation excerpts\n\n${parts.join("\n\n")}` : SYSTEM_PROMPT;
+}
+
+// ── request handling ─────────────────────────────────────────────
+
+/** The validated conversation, or a reason it was turned away. */
+function readMessages(body: unknown): AskMessage[] | undefined {
+  if (!body || typeof body !== "object" || !("messages" in body) || !Array.isArray(body.messages)) return;
+  const raw: unknown[] = body.messages;
+  if (raw.length === 0 || raw.length > MAX_MESSAGES || JSON.stringify(raw).length > MAX_CHARS) return;
+  const messages: AskMessage[] = [];
+  for (const m of raw) {
+    if (!m || typeof m !== "object" || !("role" in m) || !("content" in m)) return;
+    if ((m.role !== "user" && m.role !== "assistant") || typeof m.content !== "string") return;
+    messages.push({ role: m.role, content: m.content });
+  }
+  return messages;
+}
+
+function readPath(body: unknown): string | undefined {
+  if (!body || typeof body !== "object" || !("page" in body)) return;
+  const page = body.page;
+  if (!page || typeof page !== "object" || !("path" in page) || typeof page.path !== "string") return;
+  return page.path.replace(/(.)\/+$/, "$1");
+}
+
+/** OpenRouter's SSE (`data: {…choices[0].delta.content…}`) → the answer's bare text. */
+function textStream(sse: ReadableStream<Uint8Array>): ReadableStream<Uint8Array> {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffer = "";
+  return sse.pipeThrough(
+    new TransformStream<Uint8Array, Uint8Array>({
+      transform(chunk, controller) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue; // `: OPENROUTER PROCESSING` keep-alives
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") continue;
+          let event: unknown;
+          try {
+            event = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          if (event && typeof event === "object" && "error" in event) {
+            // After the 200: the stream just ends, and the island shows its
+            // error notice for an empty answer.
+            console.error(`ask: provider error mid-stream: ${JSON.stringify(event.error)}`);
+            continue;
+          }
+          if (!event || typeof event !== "object" || !("choices" in event) || !Array.isArray(event.choices)) continue;
+          const choice: unknown = event.choices[0];
+          if (!choice || typeof choice !== "object" || !("delta" in choice)) continue;
+          const delta = choice.delta;
+          if (!delta || typeof delta !== "object" || !("content" in delta)) continue;
+          const content = delta.content;
+          if (typeof content === "string" && content) controller.enqueue(encoder.encode(content));
+        }
+      },
+    }),
+  );
+}
+
+export async function handleAsk(request: Request, env: Env): Promise<Response> {
+  // The docs serve from the custom domain and the Pages origin; reflect the
+  // requesting origin only when it is on the allowlist (as /api/stats does).
+  const allowed = env.DOCS_ORIGIN.split(",").map((o) => o.trim());
+  const origin = request.headers.get("origin");
+  const cors = {
+    "access-control-allow-origin": origin && allowed.includes(origin) ? origin : allowed[0]!,
+    "access-control-allow-methods": "POST",
+    "access-control-allow-headers": "content-type",
+    "access-control-max-age": "86400",
+    vary: "Origin",
+  };
+  const text = (body: string, status: number) =>
+    new Response(body, { status, headers: { ...cors, "content-type": "text/plain; charset=utf-8" } });
+
+  if (request.method === "OPTIONS") return new Response(null, { status: 204, headers: cors });
+  if (request.method !== "POST") return text("POST only.", 405);
+
+  const raw = await request.arrayBuffer();
+  if (raw.byteLength > BODY_LIMIT) return text("Request too large: the body must be at most 64 KB.", 413);
+  let body: unknown;
+  try {
+    body = JSON.parse(new TextDecoder().decode(raw));
+  } catch {
+    body = undefined;
+  }
+  const messages = readMessages(body);
+  if (!messages) return text("Invalid request: send 1-40 user/assistant messages with string content.", 400);
+  if (!env.OPENROUTER_API_KEY) return text("The assistant is not configured: set OPENROUTER_API_KEY.", 503);
+
+  let system: string;
+  try {
+    system = await instructions(env, messages, readPath(body));
+  } catch (err) {
+    // Ungrounded beats unanswered: the prompt still forbids inventing details.
+    console.warn(`ask: grounding unavailable: ${err}`);
+    system = SYSTEM_PROMPT;
+  }
+
+  const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${env.OPENROUTER_API_KEY}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      model: env.ASK_MODEL,
+      stream: true,
+      reasoning: { effort: "none" },
+      messages: [{ role: "system", content: system }, ...messages],
+    }),
+    signal: request.signal,
+  });
+  if (!res.ok || !res.body) {
+    console.error(`ask: POST /chat/completions -> ${res.status} ${await res.text().catch(() => "")}`);
+    return text("Failed to generate a response.", res.status === 429 ? 429 : 502);
+  }
+  return new Response(textStream(res.body), {
+    headers: { ...cors, "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" },
+  });
+}

apps/api/src/catalog.ts

@@ -9,9 +9,16 @@
  * issue title — the title carries only the LC number and the problem's name,
  * so relabelling a problem is enough to move it and titles stay readable.
  * The `problem` label is what marks a sub-issue as curriculum.
+ *
+ * A topic's problems are its sub-issues PLUS those re-parented into a
+ * `Review <N> — <Phase>` issue (reviews.ts recovers which topic each came
+ * from). Walking topic sub-issues alone would silently freeze a moved
+ * problem's row: upserts only, so nothing breaks — its labels just stop
+ * syncing.
  */
-import { DIFFICULTIES, SETS, workingDay } from "./srs.ts";
+import { DIFFICULTIES, SCHEDULE, SETS, workingDay } from "./srs.ts";
 import type { GitHub } from "./github.ts";
+import { movedFromTopics, readReviews, type Review } from "./reviews.ts";
 
 const TITLE_RE = /^LC (\d+) · (.+)$/;
 
@@ -21,6 +28,37 @@ const DEFER_FROM = "2026-09-28";
 export interface ReconcileReport {
   topics: number;
   problems: number;
+  /** Where schedule.json's review days disagree with the Review issues; empty when in step. */
+  reviewDrift: string[];
+}
+
+/**
+ * schedule.json copies each review day's issue, title and problems so the
+ * digest and RESERVED need no GitHub call; the issues stay the truth. Compared
+ * here because this is the one place that already holds both.
+ */
+function reviewDrift(reviews: Review[]): string[] {
+  const drift: string[] = [];
+  const booked = new Map<number, string>();
+  for (const [date, day] of Object.entries(SCHEDULE)) {
+    if (!day.review) continue;
+    const { issue, title, problems } = day.review;
+    booked.set(issue, date);
+    const review = reviews.find((r) => r.number === issue);
+    if (!review) {
+      drift.push(`${date}: #${issue} is not a "Review <N> — <Phase>" issue`);
+      continue;
+    }
+    if (review.title !== title) drift.push(`${date}: #${issue} is titled "${review.title}", schedule says "${title}"`);
+    const actual = review.problems.map((p) => Number(p.title.match(TITLE_RE)?.[1]));
+    if (actual.join(",") !== problems.join(",")) {
+      drift.push(`${date}: #${issue} holds LC ${actual.join(", ")}, schedule says LC ${problems.join(", ")}`);
+    }
+  }
+  for (const review of reviews) {
+    if (!booked.has(review.number)) drift.push(`#${review.number} "${review.title}" has no day in schedule.json`);
+  }
+  return drift;
 }
 
 /** Label names on one issue payload, narrowed with guards rather than cast. */
@@ -72,24 +110,32 @@ export async function reconcileCatalog(db: D1Database, gh: GitHub): Promise<Reco
     );
   }
 
+  const reviews = await readReviews(gh);
+  const drift = reviewDrift(reviews);
+  for (const line of drift) console.warn(`catalog: review drift — ${line}`);
+  const moved = movedFromTopics(reviews);
   let problems = 0;
   let deferredSeen = 0;
   for (const t of topics) {
+    const members: { number: number; title: string; labels: string[] }[] = [];
     for await (const raw of gh.list(`/repos/${gh.repo}/issues/${t.number}/sub_issues`)) {
       if (!raw || typeof raw !== "object") continue;
       if (!("number" in raw) || typeof raw.number !== "number") continue;
       if (!("title" in raw) || typeof raw.title !== "string") continue;
-      const labels = labelNames(raw);
+      members.push({ number: raw.number, title: raw.title, labels: labelNames(raw) });
+    }
+    members.push(...(moved.get(t.number) ?? []));
+    for (const { number, title, labels } of members) {
       if (!labels.includes("problem")) continue; // non-curriculum sub-issue
-      const m = raw.title.match(TITLE_RE);
+      const m = title.match(TITLE_RE);
       if (!m) {
-        console.warn(`catalog: #${raw.number} is a problem but not titled "LC <n> · <name>"`);
+        console.warn(`catalog: #${number} is a problem but not titled "LC <n> · <name>"`);
         continue;
       }
       const difficulty = DIFFICULTIES.find((d) => labels.includes(`diff:${d}`));
       const set = SETS.find((s) => labels.includes(`set:${s}`));
       if (!difficulty || !set) {
-        console.warn(`catalog: #${raw.number} is missing a diff:/set: label — skipped`);
+        console.warn(`catalog: #${number} is missing a diff:/set: label — skipped`);
         continue;
       }
       const lc = Number(m[1]);
@@ -106,7 +152,7 @@ export async function reconcileCatalog(db: D1Database, gh: GitHub): Promise<Reco
              ON CONFLICT(lc_number) DO UPDATE SET
                issue = ?2, topic_issue = ?3, title = ?4, difficulty = ?5, set_label = ?6`,
           )
-          .bind(lc, raw.number, t.number, m[2]!, difficulty, set, defer),
+          .bind(lc, number, t.number, m[2]!, difficulty, set, defer),
       );
       problems++;
     }
@@ -116,5 +162,5 @@ export async function reconcileCatalog(db: D1Database, gh: GitHub): Promise<Reco
   for (let i = 0; i < statements.length; i += 50) {
     await db.batch(statements.slice(i, i + 50));
   }
-  return { topics: topics.length, problems };
+  return { topics: topics.length, problems, reviewDrift: drift };
 }

apps/api/src/digest.ts

@@ -8,8 +8,9 @@
  * Retrieval rules: review, drill and sweep rows carry number + difficulty
  * only — never the topic, never a solution link. `DigestRow` has no field for
  * either, so the rule holds by construction. The plan's own sections — a
- * learning day's topics (core, then the optional "if time" list) and a set
- * day's problems — are the only labeled, linked ones. At most REVIEW_CAP (3)
+ * learning day's topics (core, then the optional "if time" list), a set
+ * day's problems, and a review day's `Review <N>` issue — are the only
+ * labeled, linked ones. At most REVIEW_CAP (3)
  * reviews per day; drills fill toward DAILY_CAP (6) only when the due queue
  * is light, and never on a sweep day, which assigns every open miss and
  * nothing new. Overflow is levelled, not stacked: sendDigest gives every
@@ -23,6 +24,7 @@
  */
 import {
   CAMPAIGN_DAYS,
+  MISS_WHERE,
   type ProblemRow,
   RESERVED,
   REVIEW_CAP,
@@ -84,8 +86,7 @@ async function openMisses(db: D1Database): Promise<ProblemRow[]> {
     .prepare(
       `SELECT p.* FROM problems p
        JOIN attempts a ON a.lc_number = p.lc_number
-       WHERE a.id = (SELECT MAX(id) FROM attempts WHERE lc_number = p.lc_number)
-         AND a.result = 'fail' AND p.stage != 'retired'
+       WHERE ${MISS_WHERE}
        ORDER BY a.date, p.lc_number`,
     )
     .all<ProblemRow>();
@@ -150,6 +151,18 @@ export async function collectDigest(env: Env, date: string): Promise<DigestData>
     data.assigned = rows.map((p) => topicRow(env, p));
   }
 
+  // A review day: the `Review <N> — <Phase>` issue's problems, in its solve
+  // order, linked like a set day's and headed by the issue itself.
+  if (plan.review) {
+    const { rows, missing } = await lookupProblems(db, plan.review.problems);
+    if (missing.length) console.warn(`digest ${date}: review problems not in the catalog: ${missing.join(", ")}`);
+    data.review = {
+      title: plan.review.title,
+      url: `https://github.com/${env.REPO}/issues/${plan.review.issue}`,
+      rows: rows.map((p) => topicRow(env, p)),
+    };
+  }
+
   // A sweep day works the miss log: every problem still standing on a
   // failure, minus the ones today's review list already carries.
   if (plan.sweep) {

apps/api/src/email.tsx

@@ -71,6 +71,13 @@ const LAST_SEEN: Record<string, string> = {
   retired: "retired",
 };
 
+// A review day's rules, the same ones its GitHub issue carries — one sentence
+// here so the HTML and the plain-text alternative cannot word them apart.
+const REVIEW_RULES =
+  "90 minutes, top to bottom — easy to hard; skip what is already solved. " +
+  "Before each submit, say the time and space complexity out loud and trace one edge case. " +
+  "Whatever is unfinished stays open.";
+
 // ── data model ───────────────────────────────────────────────────
 
 /** A review or drill line: number + difficulty + one-tap links, nothing else. */
@@ -101,7 +108,7 @@ export interface TopicSection {
 export interface DigestData {
   /** "Tuesday, August 25" */
   day: string;
-  /** "Day 9 of 56 · Week 2" */
+  /** "Day 9 of 79 · Week 2" — the length is CAMPAIGN_DAYS, derived from the plan. */
   progress: string;
   streak: number;
   rest: boolean;
@@ -109,6 +116,8 @@ export interface DigestData {
   topics: TopicSection[];
   /** A set day's problems, assigned by number rather than by topic. */
   assigned?: TopicRow[];
+  /** A review day: the `Review <N> — <Phase>` issue and its problems in solve order. */
+  review?: { title: string; url: string; rows: TopicRow[] };
   reviews: DigestRow[];
   /** Reviews past the daily cap; levelled onto the coming days. */
   carried: number;
@@ -293,11 +302,13 @@ function DigestEmail({ data }: { data: DigestData }) {
   const load = data.reviews.length + data.drills.length + (data.sweep?.length ?? 0);
   const lead = data.topics[0]
     ? `, starting with ${data.topics[0].name}`
-    : data.assigned
-      ? ", starting with today's set"
-      : data.sweep
-        ? " — sweep day, nothing new"
-        : "";
+    : data.review
+      ? `, starting with ${data.review.title}`
+      : data.assigned
+        ? ", starting with today's set"
+        : data.sweep
+          ? " — sweep day, nothing new"
+          : "";
   const preview = data.rest ? "Rest day — nothing to do but rest." : `${load} to work through today${lead}.`;
 
   const passed = data.yesterday.total - data.yesterday.failed.length;
@@ -350,6 +361,19 @@ function DigestEmail({ data }: { data: DigestData }) {
                   </Section>
                 ))}
 
+                {data.review ? (
+                  <Section style={{ marginTop: "28px" }}>
+                    <Text style={label}>Today's review</Text>
+                    <Text style={{ fontSize: "16px", fontWeight: 600, margin: "0 0 8px" }}>
+                      <Link href={data.review.url} style={{ color: INK, textDecoration: "underline" }}>
+                        {data.review.title}
+                      </Link>
+                    </Text>
+                    <Text style={hint}>{REVIEW_RULES}</Text>
+                    <TopicTable rows={data.review.rows} />
+                  </Section>
+                ) : null}
+
                 {data.assigned ? (
                   <Section style={{ marginTop: "28px" }}>
                     <Text style={label}>Today's set</Text>
@@ -407,14 +431,14 @@ function DigestEmail({ data }: { data: DigestData }) {
               </>
             )}
 
-            {/* Eight weeks at a glance — the one thing here that is pure
+            {/* The whole campaign at a glance — the one thing here that is pure
                 encouragement rather than instruction. */}
             <Section style={{ marginTop: "28px" }}>
               <Text style={label}>Every day you showed up</Text>
               <Link href={data.progressUrl}>
                 <Img
                   src={data.heatmapUrl}
-                  alt="Attempt heatmap across the eight-week campaign"
+                  alt="Attempt heatmap across the whole campaign"
                   width="552"
                   style={{ border: `1px solid ${BORDER}`, borderRadius: "8px", display: "block", width: "100%" }}
                 />
@@ -473,6 +497,15 @@ function plainDigest(data: DigestData): string {
         out.push("  If time — only once the core is done inside the clock:", ...topic.ifTime.map(linked));
       }
     }
+    if (data.review) {
+      out.push(
+        "",
+        `TODAY'S REVIEW — ${data.review.title}`,
+        `  ${data.review.url}`,
+        REVIEW_RULES,
+        ...data.review.rows.map(linked),
+      );
+    }
     if (data.assigned) {
       out.push(
         "",

apps/api/src/gate.ts

@@ -5,7 +5,8 @@
  * The gate half is a topic-blind quiz. When the plan fixes the set
  * (`gate` in data/schedule.json) that list IS the gate, verbatim — every
  * number must be a catalog problem, or the issue is not created, because a
- * `/done` on an uncatalogued number can never be logged. Otherwise the set
+ * `/done` on an uncatalogued number can never be logged; an empty list skips
+ * the week's checkpoint outright. Otherwise the set
  * is sampled: one unsolved optional problem per topic scheduled this week
  * (which is why daily drills only draw from earlier weeks), never one the
  * plan has reserved. The recap half is generated data, deliberately NOT a
@@ -77,6 +78,7 @@ export async function createReviewIssue(env: Env, gh: GitHub, date: string): Pro
   // week without topics, across every topic that still has an unsolved pool.
   const picks: { p: ProblemRow; fallback: boolean }[] = [];
   const planned = SCHEDULE[date]?.gate;
+  if (planned?.length === 0) return { created: false, reason: `the plan skips the week ${week} checkpoint` };
   if (planned) {
     const { rows, missing } = await lookupProblems(db, planned);
     if (missing.length) {

apps/api/src/index.ts

@@ -9,6 +9,7 @@
  * Writes are owner-only (webhook author check, HMAC one-tap links, bearer
  * admin routes); everything else is read-only public.
  */
+import { handleAsk } from "./ask.ts";
 import { reconcileCatalog } from "./catalog.ts";
 import { gateBadge, heatmapChart, heatmapPng, ladderChart, progressChart } from "./charts.ts";
 import { sendDigest } from "./digest.ts";
@@ -17,6 +18,7 @@ import { type GitHub, github } from "./github.ts";
 import { timingSafeEqual, verifyLink, verifyWebhook } from "./links.ts";
 import { type Mirror, projectMirror } from "./mirror.ts";
 import {
+  CAMPAIGN_DAYS,
   CAMPAIGN_START,
   type LogOutcome,
   type Stage,
@@ -322,6 +324,8 @@ export default {
       if (path.startsWith("/admin/") && request.method === "POST") {
         return await handleAdmin(request, env, path);
       }
+      // The docs assistant (the static Pages site's `ai.assistant.endpoint`).
+      if (path === "/ask") return await handleAsk(request, env);
 
       if (path === "/chart/progress.svg") {
         return new Response(await progressChart(env.DB), { headers: SVG_HEADERS });
@@ -330,10 +334,10 @@ export default {
         return new Response(await ladderChart(env.DB), { headers: SVG_HEADERS });
       }
       if (path === "/chart/heatmap.svg") {
-        return new Response(await heatmapChart(env.DB, CAMPAIGN_START, 56), { headers: SVG_HEADERS });
+        return new Response(await heatmapChart(env.DB, CAMPAIGN_START, CAMPAIGN_DAYS), { headers: SVG_HEADERS });
       }
       if (path === "/chart/heatmap.png") {
-        return new Response(await heatmapPng(env.DB, CAMPAIGN_START, 56), { headers: PNG_HEADERS });
+        return new Response(await heatmapPng(env.DB, CAMPAIGN_START, CAMPAIGN_DAYS), { headers: PNG_HEADERS });
       }
       if (path === "/badge/gate.svg") {
         return new Response(await gateBadge(env.DB), { headers: SVG_HEADERS });

apps/api/src/reviews.ts

@@ -0,0 +1,140 @@
+/**
+ * `Review <N> — <Phase>` issues: the transfer phase's day blocks. Problems were
+ * re-parented into them from their topics (`replace_parent` — a GitHub issue
+ * has exactly one parent), so a topic's sub-issue list no longer names every
+ * problem it owns. This module is the ONE recovery of that ownership: each
+ * moved problem's topic is its last `parent_issue_removed` event naming a
+ * topic, which GitHub records and no human edits.
+ *
+ * Two consumers must agree on it: the Worker's catalog reconcile
+ * (catalog.ts — else a moved problem's D1 row stops syncing its labels) and
+ * the CLI's topic rules (apps/cli/topics.ts — else close-topics and the
+ * release bodies change when a problem moves). Hence it lives here, the lower
+ * layer, the way apps/cli already imports srs.ts.
+ *
+ * Library: side-effect-free on import; the caller passes its GitHub client —
+ * the Worker's or the CLI's, which share the two members used here.
+ */
+import type { GitHub } from "./github.ts";
+
+/** `Review 7 — Nodal & Grid`, never the Worker's weekly `Review — Week N` gate. */
+const REVIEW_TITLE = /^Review \d+ — /;
+const TOPIC_TITLE = /^Topic \d+ — /;
+
+/** One problem issue as a topic or review lists it. */
+export interface Problem {
+  number: number;
+  /** `LC <num> · <Name>`. */
+  title: string;
+  /** ISO instant the issue closed; null while it is open. */
+  closedAt: string | null;
+  labels: string[];
+}
+
+export interface Review {
+  number: number;
+  title: string;
+  open: boolean;
+  /** Markdown body: `**Scheduled:**` / `**Phase:**` / `**Load:**` lines the release reads. */
+  body: string;
+  /** Sub-issues in the order GitHub lists them (the solve order). */
+  problems: (Problem & { fromTopic: number | null })[];
+}
+
+/**
+ * Every `Review <N> — <Phase>` issue, open and closed, with its sub-issues.
+ * One GraphQL request per 50 `review`-labelled issues (the Worker's weekly
+ * gate issues share the label and are dropped by title): the sub-issues and
+ * the timeline filter ride along, so recovering each problem's source topic
+ * costs no extra request. That matters in the Worker, whose nightly cron
+ * spends its subrequest budget on the catalog walk and the digest.
+ */
+export async function readReviews(gh: Pick<GitHub, "repo" | "graphql">): Promise<Review[]> {
+  const [owner, name] = gh.repo.split("/");
+  const reviews: Review[] = [];
+  for (let after: string | null = null; ; ) {
+    // Shape fixed by the query below; GraphQL errors throw in gh.graphql().
+    const data = (await gh.graphql(
+      `query($owner: String!, $name: String!, $after: String) {
+        repository(owner: $owner, name: $name) {
+          issues(labels: ["review"], first: 50, after: $after, orderBy: { field: CREATED_AT, direction: ASC }) {
+            pageInfo { hasNextPage endCursor }
+            nodes {
+              number title state body
+              subIssues(first: 50) {
+                pageInfo { hasNextPage }
+                nodes {
+                  number title state closedAt
+                  labels(first: 20) { nodes { name } }
+                  timelineItems(itemTypes: [PARENT_ISSUE_REMOVED_EVENT], last: 10) {
+                    nodes { ... on ParentIssueRemovedEvent { parent { number title } } }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }`,
+      { owner, name, after },
+    )) as {
+      repository: {
+        issues: {
+          pageInfo: { hasNextPage: boolean; endCursor: string | null };
+          nodes: {
+            number: number;
+            title: string;
+            state: "OPEN" | "CLOSED";
+            body: string;
+            subIssues: {
+              pageInfo: { hasNextPage: boolean };
+              nodes: {
+                number: number;
+                title: string;
+                state: "OPEN" | "CLOSED";
+                closedAt: string | null;
+                labels: { nodes: { name: string }[] };
+                timelineItems: { nodes: { parent: { number: number; title: string } | null }[] };
+              }[];
+            };
+          }[];
+        };
+      };
+    };
+    const page = data.repository.issues;
+    for (const issue of page.nodes) {
+      if (!REVIEW_TITLE.test(issue.title)) continue;
+      // A review is one day's handful; more than a page means a mis-linked issue.
+      if (issue.subIssues.pageInfo.hasNextPage) throw new Error(`review #${issue.number} has over 50 sub-issues`);
+      reviews.push({
+        number: issue.number,
+        title: issue.title,
+        open: issue.state === "OPEN",
+        body: issue.body,
+        problems: issue.subIssues.nodes.map((p) => ({
+          number: p.number,
+          title: p.title,
+          closedAt: p.state === "CLOSED" ? p.closedAt : null,
+          labels: p.labels.nodes.map((l) => l.name),
+          // Oldest first, so the last topic it left is its owner; a later
+          // review-to-review move names a review and is skipped.
+          fromTopic:
+            p.timelineItems.nodes.findLast((e) => e.parent && TOPIC_TITLE.test(e.parent.title))?.parent?.number ?? null,
+        })),
+      });
+    }
+    if (!page.pageInfo.hasNextPage) break;
+    after = page.pageInfo.endCursor;
+  }
+  return reviews.sort((a, b) => a.number - b.number);
+}
+
+/** Topic -> the problems moved out of it into Review issues, in review order. */
+export function movedFromTopics(reviews: Review[]): Map<number, Problem[]> {
+  const moved = new Map<number, Problem[]>();
+  for (const review of reviews) {
+    for (const { fromTopic, ...problem } of review.problems) {
+      if (fromTopic !== null) moved.set(fromTopic, [...(moved.get(fromTopic) ?? []), problem]);
+    }
+  }
+  return moved;
+}

apps/api/src/srs.test.ts

@@ -134,6 +134,8 @@ describe("the plan", () => {
       expect(isRestDay(date)).toBe(false);
       if (day.gate) expect(weekdayOf(date)).toBe(6);
       if (day.topics) expect(weekdayOf(date)).toBeLessThan(6);
+      // Reviews run Mon/Tue and Thu/Fri; Wednesday and the weekend stay free.
+      if (day.review) expect([1, 2, 4, 5]).toContain(weekdayOf(date));
     }
   });
 
@@ -150,6 +152,20 @@ describe("the plan", () => {
     expect(topicDate(999)).toBeUndefined();
   });
 
+  test("a review is booked once, and no problem sits in two reviews", () => {
+    const issues = new Set<number>();
+    const problems = new Set<number>();
+    for (const day of Object.values(SCHEDULE)) {
+      if (!day.review) continue;
+      expect(issues.has(day.review.issue)).toBe(false);
+      issues.add(day.review.issue);
+      for (const lc of day.review.problems) {
+        expect(problems.has(lc)).toBe(false);
+        problems.add(lc);
+      }
+    }
+  });
+
   test("every gate and set problem is reserved from the samplers", () => {
     for (const day of Object.values(SCHEDULE)) {
       for (const lc of [...(day.gate ?? []), ...(day.problems ?? [])]) {

apps/api/src/srs.ts

@@ -22,8 +22,8 @@ import scheduleJson from "../data/schedule.json";
 
 // ── dates (America/New_York) ─────────────────────────────────────
 
+/** Day 1. The last day is not a constant: see CAMPAIGN_END below the schedule. */
 export const CAMPAIGN_START = "2026-08-17";
-export const CAMPAIGN_DAYS = 56;
 
 const ET_DATE = new Intl.DateTimeFormat("en-CA", {
   timeZone: "America/New_York",
@@ -130,15 +130,26 @@ export function prettyDate(date: string): string {
  * One calendar day of the plan. Most days teach topics (one, or two when the
  * plan doubles up); the rest are named by what they assign instead: a fixed
  * gate set for Saturday's review issue, a fixed problem set (a "B-set" day),
- * or a sweep — redo every miss, nothing new. Absent dates are unplanned:
- * the ladder still runs, the digest just has nothing new to say.
+ * a transfer-phase review day, or a sweep — redo every miss, nothing new.
+ * Absent dates are unplanned: the ladder still runs, the digest just has
+ * nothing new to say.
  */
 export interface ScheduledDay {
   /** Topic issues taught that day, in the order the digest presents them. */
   topics?: number[];
   /** Problems assigned by number instead of by topic. */
   problems?: number[];
-  /** Saturday: the blind set, fixed by the plan rather than sampled. */
+  /**
+   * A `Review <N> — <Phase>` day (Mon/Tue/Thu/Fri only): the issue, its title
+   * and its problems in solve order. The issue's sub-issues are the truth; this
+   * copy is what the digest and RESERVED read without calling GitHub, and the
+   * catalog reconcile reports any drift between the two.
+   */
+  review?: { issue: number; title: string; problems: number[] };
+  /**
+   * Saturday: the blind set, fixed by the plan rather than sampled. An empty
+   * list skips that week's checkpoint — no issue is created.
+   */
   gate?: number[];
   /** Miss-log sweep: every problem whose last attempt failed, and no new ones. */
   sweep?: boolean;
@@ -146,6 +157,15 @@ export interface ScheduledDay {
 
 export const SCHEDULE: Record<string, ScheduledDay> = scheduleJson;
 
+/**
+ * The last day the plan books anything — the campaign ends there. Derived,
+ * not declared: booking a later day (the review phase ran the plan past its
+ * original eight weeks) moves the digest's "Day N/M", the stats' `heat` and
+ * the heatmap charts with it, and nothing can disagree about when it ends.
+ */
+export const CAMPAIGN_END = Object.keys(SCHEDULE).sort().at(-1)!;
+export const CAMPAIGN_DAYS = daysBetween(CAMPAIGN_START, CAMPAIGN_END) + 1;
+
 /** Date the schedule teaches a topic on, if it teaches it at all. */
 export function topicDate(topic: number): string | undefined {
   for (const [date, day] of Object.entries(SCHEDULE)) {
@@ -161,13 +181,17 @@ export function topicWeek(topic: number): number | undefined {
 }
 
 /**
- * Every problem the plan names outright — a gate's blind set or a set day's
- * list. The plan owns these: the samplers (daily drills, a sampled gate)
- * never draw them, so a gate problem stays unseen until its Saturday and a
- * set day's problems wait for their day.
+ * Every problem the plan names outright — a gate's blind set, a set day's
+ * list, or a review day's. The plan owns these: the samplers (daily drills,
+ * a sampled gate) never draw them, so a gate problem stays unseen until its
+ * Saturday and a set or review day's problems wait for their day.
  */
 export const RESERVED: ReadonlySet<number> = new Set(
-  Object.values(SCHEDULE).flatMap((day) => [...(day.gate ?? []), ...(day.problems ?? [])]),
+  Object.values(SCHEDULE).flatMap((day) => [
+    ...(day.gate ?? []),
+    ...(day.problems ?? []),
+    ...(day.review?.problems ?? []),
+  ]),
 );
 
 // ── deterministic sampling ───────────────────────────────────────
@@ -310,6 +334,15 @@ export async function lookupProblems(
 export const DUE_WHERE = `stage != 'retired' AND next_review IS NOT NULL AND next_review <= ?1
     AND (defer_until IS NULL OR defer_until <= ?1)`;
 
+/**
+ * What an open miss means, in one place: a problem `p` whose most recent
+ * attempt (highest id) failed and that has not retired. The sweep day works
+ * these and the stats' "attempting" count is how many there are, so the two
+ * cannot disagree. Expects `problems p` joined to `attempts a` on lc_number.
+ */
+export const MISS_WHERE = `a.id = (SELECT MAX(id) FROM attempts WHERE lc_number = p.lc_number)
+    AND a.result = 'fail' AND p.stage != 'retired'`;
+
 /** Reviews due on/before `date`, oldest first — the overflow carry order. */
 export async function dueReviews(db: D1Database, date: string): Promise<ProblemRow[]> {
   const { results } = await db

apps/api/src/stats.ts

@@ -8,12 +8,17 @@
  * srs.ts turns a topic's days-since-last-attempt into a band, so "which
  * concepts have gone cold" has exactly one definition and the dashboard is
  * free to colour it however it likes.
+ *
+ * `recent`, `attempting` and `year` feed the docs page's LeetCode-style cards
+ * (recently solved, the solved ring, the heatmap and the submissions chart).
+ * They are additive: the terminal dashboard ignores them.
  */
 import {
   CAMPAIGN_DAYS,
   CAMPAIGN_START,
   DIFFICULTIES,
   DUE_WHERE,
+  MISS_WHERE,
   addDays,
   campaignDay,
   campaignWeek,
@@ -54,6 +59,12 @@ interface TopicStat {
   temperature: Temperature;
 }
 
+/** Days in `year`: the 365 ending today, which always covers the current calendar year to date. */
+const YEAR_DAYS = 365;
+
+/** How many problems `recent` lists. */
+const RECENT_LIMIT = 10;
+
 async function buildTopics(db: D1Database, today: string): Promise<TopicStat[]> {
   // Three shapes, three statements: batch() carries one row type, and casting
   // its results apart would cost more than the round trips it saves.
@@ -195,9 +206,9 @@ export async function buildStats(db: D1Database, today: string): Promise<object>
   );
   const queue = dates.map((date, i) => ({ date, due: queueRows[i]?.results[0]?.n ?? 0 }));
 
-  // Attempts per campaign day, every day present. This is the heatmap's data
-  // model — the docs page reads the tail of it for "last 7 days" rather than
-  // asking a second question that could answer differently.
+  // Attempts per campaign day, every day present. This is the README heatmap's
+  // data model — the terminal dashboard lays it out by campaign week and reads
+  // its tail for "last 14 days" rather than asking a second question.
   const end = addDays(CAMPAIGN_START, CAMPAIGN_DAYS - 1);
   const { results: heatRows } = await db
     .prepare(
@@ -215,16 +226,92 @@ export async function buildStats(db: D1Database, today: string): Promise<object>
     return { date, attempts: row?.attempts ?? 0, passes: row?.passes ?? 0 };
   });
 
+  // The ten problems most recently solved, dated by each one's FIRST passing
+  // attempt — when it was completed, not when it was last re-solved (LeetCode's
+  // "Recent AC"). Same-day ties fall back to log order.
+  const { results: recentRows } = await db
+    .prepare(
+      `SELECT p.lc_number AS lc, p.title AS title, p.difficulty AS difficulty,
+              MIN(a.date) AS date, MIN(a.id) AS seq
+       FROM attempts a JOIN problems p ON p.lc_number = a.lc_number
+       WHERE a.result = 'pass'
+       GROUP BY p.lc_number
+       ORDER BY date DESC, seq DESC
+       LIMIT ?1`,
+    )
+    .bind(RECENT_LIMIT)
+    .all<{ lc: number; title: string; difficulty: string; date: string; seq: number }>();
+  const recent = recentRows.map(({ lc, title, difficulty, date }) => ({ lc, title, difficulty, date }));
+
+  // Problems still standing on a failure — the sweep day's miss log, counted.
+  const missRow = await db
+    .prepare(
+      `SELECT COUNT(*) AS n FROM problems p
+       JOIN attempts a ON a.lc_number = p.lc_number
+       WHERE ${MISS_WHERE}`,
+    )
+    .first<{ n: number }>();
+
+  // The past year, one entry per day (zeros included), split by difficulty two
+  // ways: every logged attempt, and every first solve — the same first-pass
+  // date `recent` uses. `heat` stays campaign-scoped (the terminal dashboard
+  // lays it out by campaign week); this is the calendar-scoped view the docs
+  // heatmap and submissions chart window and bucket for themselves.
+  const yearStart = addDays(today, -(YEAR_DAYS - 1));
+  const { results: attemptRows } = await db
+    .prepare(
+      `SELECT a.date AS date, p.difficulty AS difficulty,
+              COUNT(*) AS n,
+              SUM(CASE WHEN a.result = 'pass' THEN 1 ELSE 0 END) AS passes
+       FROM attempts a JOIN problems p ON p.lc_number = a.lc_number
+       WHERE a.date BETWEEN ?1 AND ?2
+       GROUP BY a.date, p.difficulty`,
+    )
+    .bind(yearStart, today)
+    .all<{ date: string; difficulty: string; n: number; passes: number | null }>();
+  const { results: solvedRows } = await db
+    .prepare(
+      `SELECT date, difficulty, COUNT(*) AS n
+       FROM (SELECT MIN(a.date) AS date, p.difficulty AS difficulty
+             FROM attempts a JOIN problems p ON p.lc_number = a.lc_number
+             WHERE a.result = 'pass'
+             GROUP BY p.lc_number)
+       WHERE date BETWEEN ?1 AND ?2
+       GROUP BY date, difficulty`,
+    )
+    .bind(yearStart, today)
+    .all<{ date: string; difficulty: string; n: number }>();
+  const year = Array.from({ length: YEAR_DAYS }, (_, i) => ({
+    date: addDays(yearStart, i),
+    passes: 0,
+    attempts: Object.fromEntries(DIFFICULTIES.map((d) => [d, 0])),
+    solved: Object.fromEntries(DIFFICULTIES.map((d) => [d, 0])),
+  }));
+  const yearIndex = new Map(year.map((d, i) => [d.date, i]));
+  for (const row of attemptRows) {
+    const day = year[yearIndex.get(row.date) ?? -1];
+    if (!day || !(row.difficulty in day.attempts)) continue;
+    day.attempts[row.difficulty] = row.n;
+    day.passes += row.passes ?? 0;
+  }
+  for (const row of solvedRows) {
+    const day = year[yearIndex.get(row.date) ?? -1];
+    if (day && row.difficulty in day.solved) day.solved[row.difficulty] = row.n;
+  }
+
   return {
     generated: new Date().toISOString(),
     campaign: { day: campaignDay(today), week: campaignWeek(today), start: CAMPAIGN_START, days: CAMPAIGN_DAYS },
     phases: [...phases.values()],
     ladder,
     difficulty,
+    attempting: missRow?.n ?? 0,
     topics: await buildTopics(db, today),
     gates,
     streak: await streak(db, today),
     queue,
     heat,
+    recent,
+    year,
   };
 }

apps/api/wrangler.jsonc

@@ -32,10 +32,15 @@
     "REPO": "prdlk/leetcode",
     "FROM_EMAIL": "srs@prdlk.com",
     "TO_EMAIL": "prnk28@gmail.com",
-    "DOCS_URL": "https://prdlk.github.io/leetcode",
-    "DOCS_ORIGIN": "https://prdlk.github.io,https://lc.prad.nu",
-    "PUBLIC_URL": "https://srs-api.prdlk.workers.dev"
+    "DOCS_URL": "https://lc.prd.lk",
+    "DOCS_ORIGIN": "https://lc.prd.lk,https://prdlk.github.io",
+    "PUBLIC_URL": "https://srs-api.prdlk.workers.dev",
+    // The docs assistant's OpenRouter model (POST /ask). `:free` variants share
+    // an upstream pool and answer 429 when it is saturated.
+    "ASK_MODEL": "qwen/qwen3.8-27b:free"
   }
 
   // Secrets (wrangler secret put): GH_PAT, WEBHOOK_SECRET, LINK_KEY.
+  // OPENROUTER_API_KEY (the docs assistant, POST /ask) is the repo's Actions
+  // secret of that name, put by deploy.yml before every deploy.
 }

apps/cli/close-topics.ts

@@ -1,24 +1,34 @@
 #!/usr/bin/env bun
 /**
- * Close the GitHub issue for every topic whose required (core) problems are done.
+ * Close the GitHub issue for every topic whose required (core) problems are
+ * done, and for every `Review <N> — <Phase>` issue whose problems all are.
  *
  * Each `topic`-labelled issue owns its problems as GitHub sub-issues, and each
  * problem carries exactly one `set:` label — `set:core` is required, while
  * `set:optional` and `set:deferred` are extra credit. A topic is finished when
  * every one of its core sub-issues is closed; optional/deferred state is
  * ignored, matching the day rule in each topic body ("Core problems first").
+ * Problems re-parented into Review issues still count for their topic. The
+ * rules live in topics.ts, shared with release-topics.ts.
+ *
+ * A Review issue is a fixed day's assignment, so it closes when every one of
+ * its sub-issues is closed, whatever their set. Closing it fires the Worker's
+ * `review`-label webhook, which scores only issues with a gate record — these
+ * have none, so that is a no-op.
  *
  * Like close-solved.ts this reconciles state instead of reacting to an event
  * payload: re-runs are no-ops, backfilling needs no special casing, and only
- * open topics are touched, so reopening a problem never reopens its topic.
+ * open topics/reviews are touched, so reopening a problem never reopens either.
  *
- *   bun apps/cli/close-topics.ts            # close finished topics
+ *   bun apps/cli/close-topics.ts            # close finished topics and reviews
  *   bun apps/cli/close-topics.ts --dry-run  # report only, touch nothing
  *
  * Auth: GH_TOKEN / GITHUB_TOKEN, else falls back to `gh auth token`.
  */
+import { movedFromTopics, readReviews } from "../api/src/reviews.ts";
 import { github } from "./github.ts";
 import { markdownTable, printTable, writeStepSummary } from "./report.ts";
+import { completion, coreSet, readProblems } from "./topics.ts";
 
 const DRY =
   process.argv.includes("--dry-run") ||
@@ -53,44 +63,8 @@ for await (const raw of gh.list(`/repos/${gh.repo}/issues?labels=topic&state=ope
 }
 topics.sort((a, b) => a.number - b.number);
 
-// ── core sub-issue state per topic ───────────────────────────────
-
-interface Core {
-  /** Core sub-issues, closed and open alike, lowest number first. */
-  all: number[];
-  /** The core sub-issues still open — non-empty means the topic stays open. */
-  pending: number[];
-}
-
-/**
- * Read a topic's core sub-issue state. The sub_issues payload carries the full
- * issue objects (state + labels), so no per-problem follow-up request is needed.
- */
-async function readCore(topic: number): Promise<Core> {
-  const all: number[] = [];
-  const pending: number[] = [];
-  for await (const raw of gh.list(`/repos/${gh.repo}/issues/${topic}/sub_issues`)) {
-    if (!raw || typeof raw !== "object") continue;
-    if (!("number" in raw) || typeof raw.number !== "number") continue;
-    if (!("state" in raw) || typeof raw.state !== "string") continue;
-    if (!("labels" in raw) || !Array.isArray(raw.labels)) continue;
-
-    const core = raw.labels.some(
-      (label) =>
-        label &&
-        typeof label === "object" &&
-        "name" in label &&
-        label.name === "set:core",
-    );
-    if (!core) continue;
-
-    all.push(raw.number);
-    if (raw.state === "open") pending.push(raw.number);
-  }
-  all.sort((a, b) => a - b);
-  pending.sort((a, b) => a - b);
-  return { all, pending };
-}
+const reviews = await readReviews(gh);
+const moved = movedFromTopics(reviews);
 
 // ── reconcile ────────────────────────────────────────────────────
 
@@ -98,7 +72,7 @@ const report: string[][] = [];
 let closed = 0;
 
 for (const topic of topics) {
-  const core = await readCore(topic.number);
+  const core = coreSet(await readProblems(gh, topic.number, moved));
   const progress = `${core.all.length - core.pending.length}/${core.all.length}`;
 
   // A topic with no core sub-issues has nothing to complete: never close it,
@@ -132,19 +106,58 @@ for (const topic of topics) {
   closed++;
 }
 
+// ── reviews ──────────────────────────────────────────────────────
+
+const reviewReport: string[][] = [];
+let reviewsClosed = 0;
+
+for (const review of reviews.filter((r) => r.open)) {
+  const set = completion(review.problems);
+  const progress = `${set.all.length - set.pending.length}/${set.all.length}`;
+  // An empty review would read as done; leave it for a human, like a topic
+  // with no core set.
+  if (set.all.length === 0) {
+    reviewReport.push([`#${review.number}`, review.title, progress, "no sub-issues"]);
+    continue;
+  }
+  if (set.pending.length > 0) {
+    reviewReport.push([`#${review.number}`, review.title, progress, `open: ${set.pending.map((n) => `#${n}`).join(" ")}`]);
+    continue;
+  }
+  if (DRY) {
+    reviewReport.push([`#${review.number}`, review.title, progress, "would close"]);
+    continue;
+  }
+  await gh.closeIssue(
+    review.number,
+    `Review complete — all ${set.all.length} problems closed ` +
+      `(${set.all.map((n) => `#${n}`).join(", ")}).\n\n` +
+      "Closed automatically by `close-topics`.",
+  );
+  reviewReport.push([`#${review.number}`, review.title, progress, "closed"]);
+  reviewsClosed++;
+}
+
 // ── report ───────────────────────────────────────────────────────
 
 const rows = [["topic", "title", "core", "status"], ...report];
 printTable(rows);
+const reviewRows = [["review", "title", "closed", "status"], ...reviewReport];
+console.log();
+printTable(reviewRows);
 
-const finished = report.filter((r) => r[3] === "closed" || r[3] === "would close");
+const finished = new Set(["closed", "would close"]);
+const topicsDone = report.filter((r) => finished.has(r[3]!)).length;
+const reviewsDone = reviewReport.filter((r) => finished.has(r[3]!)).length;
 console.log(
-  `\n${topics.length} open topics · ` +
-    `${DRY ? `would close ${finished.length}` : `closed ${closed}`}`,
+  `\n${topics.length} open topics · ${DRY ? `would close ${topicsDone}` : `closed ${closed}`}` +
+    `\n${reviewReport.length} open reviews · ${DRY ? `would close ${reviewsDone}` : `closed ${reviewsClosed}`}`,
 );
 
 await writeStepSummary(
   `### close-topics${DRY ? " (dry run)" : ""}\n\n` +
-    `${topics.length} open topic issues, ${finished.length} with a complete core set.\n\n` +
-    (report.length ? `${markdownTable(rows)}\n` : "No open topics.\n"),
+    `${topics.length} open topic issues, ${topicsDone} with a complete core set.\n\n` +
+    (report.length ? `${markdownTable(rows)}\n` : "No open topics.\n") +
+    `\n${reviewReport.length} open review issues, ${reviewsDone} with every problem closed.\n\n` +
+    (reviewReport.length ? `${markdownTable(reviewRows)}\n` : "No open reviews.\n"),
 );

apps/cli/package.json

@@ -10,7 +10,8 @@
     "sync": "bun ./sync.ts",
     "videos": "bun ./videos.ts",
     "close-solved": "bun ./close-solved.ts",
-    "close-topics": "bun ./close-topics.ts"
+    "close-topics": "bun ./close-topics.ts",
+    "release-topics": "bun ./release-topics.ts"
   },
   "devDependencies": {
     "@clack/prompts": "^1.7.0",

apps/cli/release-topics.ts

@@ -0,0 +1,377 @@
+#!/usr/bin/env bun
+/**
+ * Publish one GitHub release per finished topic and per finished
+ * `Review <N> — <Phase>` issue, versioned by timever
+ * (`YYYYMMDD.HHMMSS.NNNNNNNNN`, UTC — https://gist.github.com/twolfson/de1b004dd22536b8e668).
+ *
+ * "Finished" is topics.ts's rule — a topic when every core problem is closed,
+ * a review when every one of its sub-issues is — the same one close-topics.ts
+ * closes the issue on, and the version is the instant the LAST required
+ * problem closed. Keying off the sub-issues rather than the topic/review issue
+ * lets this run as the tail of Close Solved: the push that closes the final
+ * required problem releases it in the same run, without waiting for
+ * close-topics to chain after it. The issue itself closes seconds later, on
+ * the same day.
+ *
+ * Each release is a changelog snapshot at that instant: the issue's problems
+ * that had closed by then (a topic's sub-issues plus those since re-parented
+ * into Review issues, or a review's sub-issues in solve order — see
+ * topics.ts), grouped as closed on the finish day (ET) and closed earlier,
+ * each with its set, difficulty, and the solution files as they stood in the
+ * tagged commit — the last main commit before the finish. Problems still open
+ * at the finish are left out: the release records what finished, and an open
+ * optional problem is tracked by its issue (or its Review day), not here.
+ * The docs site (prdlk/cs `lib/releases.ts`) reads these `### Closed …`
+ * tables back for its `/changelog` timeline, so their row shape is its contract.
+ *
+ * The tag is annotated and backdated (tagger date = finish), so
+ * `git tag --sort=taggerdate` reads as the campaign's history even for tags
+ * minted by a backfill. The release's own published date cannot be backdated
+ * (the API has no field for it), so the docs changelog dates each entry from
+ * this timever tag instead (prdlk/cs `lib/releases.ts`)
+ * — the tag format is that contract.
+ *
+ * Reconciles instead of reacting: every finished topic or review without a
+ * release gets one, so a first run backfills the whole campaign; an existing
+ * release keeps its tag and commit and only has its body rewritten when
+ * render() would say something else. Re-runs with nothing new are no-ops.
+ * A release is found by the marker comment in its body, never by tag name, so
+ * reopening and re-closing a core problem can never mint a second release.
+ * A tag that exists without its release (a run that died between the two) is
+ * reused, not re-created.
+ *
+ *   bun apps/cli/release-topics.ts            # tag, push, release, fix bodies
+ *   bun apps/cli/release-topics.ts --dry-run  # print the would-be releases
+ *
+ * Auth: GH_TOKEN / GITHUB_TOKEN, else `gh auth token` (needs contents: write).
+ * Git:  a clone with full history, an `origin` it may push tags to, and a
+ *       committer identity (the tagger).
+ */
+import { etDate } from "../api/src/srs.ts";
+import { movedFromTopics, readReviews, type Problem } from "../api/src/reviews.ts";
+import { github } from "./github.ts";
+import { markdownTable, printTable, writeStepSummary } from "./report.ts";
+import { completion, coreSet, labelValue, readProblems } from "./topics.ts";
+import { ROOT, parseWorkPath } from "./work.ts";
+
+const DRY =
+  process.argv.includes("--dry-run") ||
+  process.env.DRY_RUN === "1" ||
+  process.env.DRY_RUN === "true";
+
+/** The docs site (prdlk/cs `blume.config.ts` `deployment.site`); it publishes sync's `/<num>` short links. */
+const DOCS_SITE = "https://lc.prd.lk";
+const TIMEVER = "https://gist.github.com/twolfson/de1b004dd22536b8e668";
+
+const gh = await github();
+
+function git(...args: string[]): string {
+  const run = Bun.spawnSync(["git", ...args], { cwd: ROOT });
+  if (run.exitCode !== 0) throw new Error(`git ${args.join(" ")}: ${run.stderr.toString().trim()}`);
+  return run.stdout.toString().trim();
+}
+
+// ── finished topics and reviews ──────────────────────────────────
+
+/** A topic or Review issue, as far as its release reads it. */
+interface Issue {
+  number: number;
+  title: string;
+  milestone: string | null;
+  body: string;
+}
+
+/** Narrow one /issues element; the `topic` label filter cannot exclude PRs. */
+function readTopic(value: unknown): Issue | undefined {
+  if (!value || typeof value !== "object") return;
+  if ("pull_request" in value) return;
+  if (!("number" in value) || typeof value.number !== "number") return;
+  if (!("title" in value) || typeof value.title !== "string") return;
+  const milestone =
+    "milestone" in value &&
+    value.milestone &&
+    typeof value.milestone === "object" &&
+    "title" in value.milestone &&
+    typeof value.milestone.title === "string"
+      ? value.milestone.title
+      : null;
+  const body = "body" in value && typeof value.body === "string" ? value.body : "";
+  return { number: value.number, title: value.title, milestone, body };
+}
+
+interface Finished {
+  kind: "topic" | "review";
+  issue: Issue;
+  /** Topic: every problem it owns, by number. Review: its sub-issues, in solve order. */
+  problems: Problem[];
+  /** The set whose last close finished it: a topic's core, a review's every problem. */
+  required: number[];
+  finishedAt: string;
+}
+
+// Closed and open issues alike: the rules read the sub-issues, so a topic or
+// review finished moments ago (close-topics not yet run) releases now.
+const finished: Finished[] = [];
+const reviews = await readReviews(gh);
+const moved = movedFromTopics(reviews);
+for await (const raw of gh.list(`/repos/${gh.repo}/issues?labels=topic&state=all`)) {
+  const issue = readTopic(raw);
+  if (!issue) continue;
+  const problems = await readProblems(gh, issue.number, moved);
+  const core = coreSet(problems);
+  if (core.finishedAt) finished.push({ kind: "topic", issue, problems, required: core.all, finishedAt: core.finishedAt });
+}
+for (const review of reviews) {
+  const set = completion(review.problems);
+  if (!set.finishedAt) continue;
+  finished.push({
+    kind: "review",
+    // The review's phase is its body's `**Phase:**` line; its milestone is the
+    // shared "Review — Transfer & Mocks" and says nothing per issue.
+    issue: { number: review.number, title: review.title, milestone: null, body: review.body },
+    problems: review.problems,
+    required: set.all,
+    finishedAt: set.finishedAt,
+  });
+}
+// Oldest first, so a backfill creates releases in campaign order.
+finished.sort((a, b) => a.finishedAt.localeCompare(b.finishedAt) || a.issue.number - b.issue.number);
+
+// ── existing releases ────────────────────────────────────────────
+
+/** Topic or review issue -> its release. Name and body are kept in sync with the render on every run. */
+const released = new Map<number, { id: number; tag: string; name: string; body: string }>();
+for await (const raw of gh.list(`/repos/${gh.repo}/releases`)) {
+  if (!raw || typeof raw !== "object") continue;
+  if (!("id" in raw) || typeof raw.id !== "number") continue;
+  if (!("tag_name" in raw) || typeof raw.tag_name !== "string") continue;
+  if (!("body" in raw) || typeof raw.body !== "string") continue;
+  const name = "name" in raw && typeof raw.name === "string" ? raw.name : "";
+  const m = raw.body.match(/<!-- release-topics: #(\d+) -->/);
+  if (m) released.set(Number(m[1]), { id: raw.id, tag: raw.tag_name, name, body: raw.body });
+}
+
+// ── timever ──────────────────────────────────────────────────────
+
+/**
+ * Timever of an instant. The API reports whole seconds, so SUBTIME is the
+ * tiebreak: two topics or reviews finishing in the same second (one push
+ * closing both last problems) get consecutive nanoseconds, in (instant,
+ * issue) order.
+ */
+const tags = new Map<number, string>(); // issue -> tag
+{
+  let prev = "";
+  let ns = 0;
+  for (const f of finished) {
+    const iso = new Date(f.finishedAt).toISOString(); // 2026-09-24T18:36:38.000Z
+    const base = `${iso.slice(0, 10).replaceAll("-", "")}.${iso.slice(11, 19).replaceAll(":", "")}`;
+    ns = base === prev ? ns + 1 : Number(iso.slice(20, 23)) * 1_000_000;
+    prev = base;
+    tags.set(f.issue.number, `${base}.${String(ns).padStart(9, "0")}`);
+  }
+}
+
+// ── release body ─────────────────────────────────────────────────
+
+const ET_WHEN = new Intl.DateTimeFormat("en-US", {
+  timeZone: "America/New_York",
+  weekday: "short",
+  month: "short",
+  day: "numeric",
+  year: "numeric",
+  hour: "numeric",
+  minute: "2-digit",
+});
+const ET_DAY = new Intl.DateTimeFormat("en-US", {
+  timeZone: "America/New_York",
+  month: "short",
+  day: "numeric",
+});
+
+/** Topic body sections worth carrying into the changelog (skipped while still `TODO`). */
+const NOTES = ["Trigger", "Invariant", "Trap"] as const;
+
+function bodyField(body: string, field: string): string | undefined {
+  return body.match(new RegExp(`^\\*\\*${field}:\\*\\*\\s*(.+)$`, "m"))?.[1]?.trim();
+}
+
+function bodySection(body: string, heading: string): string | undefined {
+  const m = body.match(new RegExp(`^### ${heading}\\n([\\s\\S]*?)(?=^### |(?![\\s\\S]))`, "m"));
+  const text = m?.[1]?.trim();
+  return text && text !== "TODO" ? text : undefined;
+}
+
+function render(f: Finished, tag: string, sha: string, files: Map<number, string[]>): string {
+  const { issue, problems } = f;
+  const finishDay = etDate(new Date(f.finishedAt));
+  // Snapshot at the finish instant: a problem closed later was open then, and
+  // open problems are not part of the release.
+  const closedBy = (p: Problem) => p.closedAt !== null && p.closedAt <= f.finishedAt;
+  const onDay = problems.filter((p) => closedBy(p) && etDate(new Date(p.closedAt!)) === finishDay);
+  const earlier = problems.filter((p) => closedBy(p) && etDate(new Date(p.closedAt!)) !== finishDay);
+
+  const row = (p: Problem): string[] => {
+    const lc = Number(p.title.match(/^LC (\d+)/)?.[1]);
+    const code = closedBy(p)
+      ? (files.get(lc) ?? []).map(
+          (path) => `[${path.slice(path.lastIndexOf(".") + 1)}](https://github.com/${gh.repo}/blob/${tag}/${encodeURI(path)})`,
+        )
+      : [];
+    return [
+      `#${p.number}`,
+      p.title,
+      labelValue(p, "set:") ?? "—",
+      labelValue(p, "diff:") ?? "—",
+      closedBy(p) ? ET_DAY.format(new Date(p.closedAt!)) : "—",
+      code.length ? [...code, `[docs](${DOCS_SITE}/${lc})`].join(" · ") : "—",
+    ];
+  };
+  const table = (list: Problem[]) =>
+    markdownTable([["Issue", "Problem", "Set", "Difficulty", "Closed (ET)", "Solution"], ...list.map(row)]);
+
+  // Blume's changelog derives each page's meta description from the opening
+  // prose, stripping markdown and line breaks without adding a space — so lead
+  // with one self-contained sentence and keep the fields on one `·` line.
+  const when = ET_WHEN.format(new Date(f.finishedAt));
+  const summary =
+    `Finished ${when} ET: all ${f.required.length} ${f.kind === "topic" ? "core " : ""}problems closed, ` +
+    `${onDay.length} ${onDay.length === 1 ? "problem" : "problems"} closed that day.`;
+  const fields: string[] = [];
+  const scheduled = bodyField(issue.body, "Scheduled");
+  if (scheduled) fields.push(`**Scheduled:** ${scheduled}`);
+  const phase = f.kind === "topic" ? issue.milestone : bodyField(issue.body, "Phase");
+  if (phase) fields.push(`**Phase:** ${phase}`);
+  fields.push(`**${f.kind === "topic" ? "Topic" : "Review"}:** #${issue.number}`);
+  const buildsOn = bodyField(issue.body, "Builds on");
+  if (buildsOn) fields.push(`**Builds on:** ${buildsOn}`);
+  const load = bodyField(issue.body, "Load");
+  if (load) fields.push(`**Load:** ${load}`);
+  // The marker is how a later run finds this release; see the file header.
+  // One marker for both kinds: issue numbers never collide.
+  const sections = [`<!-- release-topics: #${issue.number} -->\n${summary}`, fields.join(" · ")];
+  sections.push(`### Closed ${ET_DAY.format(new Date(f.finishedAt))} — the day the ${f.kind} finished\n\n${table(onDay)}`);
+  if (earlier.length) sections.push(`### Closed earlier\n\n${table(earlier)}`);
+  const notes = NOTES.flatMap((h) => {
+    const text = bodySection(issue.body, h);
+    return text ? [`**${h}.** ${text}`] : [];
+  });
+  if (notes.length) sections.push(`### Notes\n\n${notes.join("\n\n")}`);
+  sections.push(
+    `---\n\n\`${tag}\` is [timever](${TIMEVER}) for the UTC instant the ` +
+      `${f.kind === "topic" ? "core set completed" : "last problem closed"}; ` +
+      `it tags ${sha.slice(0, 7)}, the last main commit before it.`,
+  );
+  return `${sections.join("\n\n")}\n`;
+}
+
+// ── reconcile ────────────────────────────────────────────────────
+
+const latest = finished.at(-1)?.issue.number;
+const report: string[][] = [];
+const previews: string[] = [];
+let created = 0;
+let updated = 0;
+
+for (const f of finished) {
+  const { issue } = f;
+  const finishedEt = etDate(new Date(f.finishedAt));
+  const existing = released.get(issue.number);
+  // An existing release keeps its tag and commit; only its name and body are
+  // reconciled. Its tag may postdate this clone (released by another run), so
+  // fetch it when missing — read-only, so a dry run does it too.
+  const tag = existing?.tag ?? tags.get(issue.number)!;
+  if (existing && Bun.spawnSync(["git", "rev-parse", "-q", "--verify", `refs/tags/${tag}`], { cwd: ROOT }).exitCode !== 0) {
+    git("fetch", "-q", "origin", `refs/tags/${tag}:refs/tags/${tag}`);
+  }
+  const sha = existing
+    ? git("rev-parse", `${tag}^{commit}`)
+    : git("rev-list", "-1", "--first-parent", `--before=${f.finishedAt}`, "HEAD");
+  if (!sha) {
+    report.push([`#${issue.number}`, issue.title, finishedEt, tag, "ERROR: no commit before finish"]);
+    continue;
+  }
+  // LC number -> its first-solve files in the tagged tree. Keyed by file name,
+  // like firstSolved(): tags before the bucket split see `work/<Difficulty>/…`,
+  // and the work/3 + work/7 re-solves are not the solve that closed the issue.
+  const files = new Map<number, string[]>();
+  for (const path of git("ls-tree", "-r", "--name-only", sha, "--", "work").split("\n")) {
+    const bucket = parseWorkPath(path.slice("work/".length))?.bucket;
+    const lc = path.match(/\/(\d+)\.[^/]+\.(?:js|py)$/)?.[1];
+    if (!lc || (bucket && bucket !== 1)) continue;
+    files.set(Number(lc), [...(files.get(Number(lc)) ?? []), path]);
+  }
+  const body = render(f, tag, sha, files);
+  const name = issue.title;
+
+  if (existing) {
+    if (existing.body === body && existing.name === name) {
+      report.push([`#${issue.number}`, issue.title, finishedEt, tag, "released"]);
+    } else if (DRY) {
+      previews.push(`## ${name} (${tag})\n\n${body}`);
+      report.push([`#${issue.number}`, issue.title, finishedEt, tag, "would update"]);
+    } else {
+      await gh.api(`/repos/${gh.repo}/releases/${existing.id}`, {
+        method: "PATCH",
+        body: JSON.stringify({ name, body }),
+      });
+      report.push([`#${issue.number}`, issue.title, finishedEt, tag, "updated"]);
+      updated++;
+    }
+    continue;
+  }
+
+  if (DRY) {
+    previews.push(`## ${name} (${tag})\n\n${body}`);
+    report.push([`#${issue.number}`, issue.title, finishedEt, tag, "would release"]);
+    continue;
+  }
+
+  const remote = git("ls-remote", "--tags", "origin", `refs/tags/${tag}`);
+  if (!remote) {
+    const local = Bun.spawnSync(["git", "rev-parse", "-q", "--verify", `refs/tags/${tag}`], { cwd: ROOT });
+    if (local.exitCode !== 0) {
+      const tagged = Bun.spawnSync(
+        [
+          "git", "tag", "-a", tag, sha, "-m",
+          `${issue.title} (#${issue.number})\n\n` +
+            `${f.kind === "topic" ? "Core set complete" : "All problems closed"}: ${f.required.map((n) => `#${n}`).join(", ")}`,
+        ],
+        { cwd: ROOT, env: { ...process.env, GIT_COMMITTER_DATE: f.finishedAt } },
+      );
+      if (tagged.exitCode !== 0) throw new Error(`git tag ${tag}: ${tagged.stderr.toString().trim()}`);
+    }
+    git("push", "origin", `refs/tags/${tag}`);
+  }
+  await gh.api(`/repos/${gh.repo}/releases`, {
+    method: "POST",
+    body: JSON.stringify({
+      tag_name: tag,
+      name,
+      body,
+      make_latest: issue.number === latest ? "true" : "false",
+    }),
+  });
+  report.push([`#${issue.number}`, issue.title, finishedEt, tag, "released now"]);
+  created++;
+}
+
+// ── report ───────────────────────────────────────────────────────
+
+if (previews.length) console.log(`${previews.join("\n")}\n`);
+const rows = [["issue", "title", "finished (ET)", "tag", "status"], ...report];
+printTable(rows);
+const would = (status: string) => report.filter((r) => r[4] === status).length;
+console.log(
+  `\n${finished.length} finished topics and reviews · ` +
+    (DRY
+      ? `would release ${would("would release")}, update ${would("would update")}`
+      : `released ${created}, updated ${updated}`),
+);
+
+await writeStepSummary(
+  `### release-topics${DRY ? " (dry run)" : ""}\n\n` +
+    `${finished.length} finished topics and reviews, ${released.size} already released.\n\n` +
+    (report.length ? `${markdownTable(rows)}\n` : "Nothing finished.\n") +
+    (previews.length ? `\n${previews.join("\n")}` : ""),
+);

apps/cli/sync.ts

@@ -1,38 +1,81 @@
 #!/usr/bin/env bun
 /**
- * Sync work/1 leetcode solutions into apps/docs/content/ pages.
+ * Sync work/1 leetcode solutions into docs/ pages, plus docs/site.json.
  *
- * - New problems get a full page (frontmatter, badge, warning, examples,
+ * docs/ is content only — MDX pages and one generated JSON manifest, no Blume
+ * config. The docs site itself (config, components, islands, the Appendix)
+ * lives in prdlk/cs and reads docs/ over HTTP with Blume's `mdxRemote()`
+ * source, which fetches `.md`/`.mdx` and nothing else: no `meta.ts`. So the
+ * sidebar meta a folder `meta.ts` used to carry, and the `/<num>` short links,
+ * travel in `docs/site.json` instead, which the site fetches at the same ref.
+ *
+ * - New problems get a full page (frontmatter, warning, examples,
  *   constraints, solution) in the gold-standard format.
  * - Already-ported pages only get their script-owned parts regenerated — the
- *   `<Badge>` line and the `## Solution` section — so hand-curated prose is
- *   never touched.
+ *   frontmatter `icon:` (`PAGE_ICON`) and the `## Solution` section — so
+ *   hand-curated prose is never touched.
  * - When a problem is solved in both JavaScript and Python the solution
  *   renders as a <CodeGroup> (Python first); single-language solutions
  *   render as a plain fence.
+ * - Every page carries LeetCode's own topic tags as frontmatter `topics:`
+ *   (`{ name, slug }` per tag, LeetCode's order), fetched from the GraphQL
+ *   `topicTags` once — when the page is created, or on any later run that
+ *   finds the key missing — and never refreshed after, so a sync with nothing
+ *   new makes no request. Delete the key to refetch it. The page itself
+ *   renders no badges: the site's MDX `wrapper` (prdlk/cs
+ *   `components/ProblemBadges.astro`) turns `topics:` and the `video:` key
+ *   `videos.ts` writes into the badge row under the description.
+ * - Every planned page (a problem the README plan lists) carries its GitHub
+ *   problem issue as frontmatter `issue:` (the URL of the `problem`-labelled
+ *   issue titled `LC <num> · …`), rendered by the same wrapper as a GitHub
+ *   badge after the others; an unplanned warm-up has no catalog issue and no
+ *   key. Like `topics:` it is filled once — on create, or on any run that
+ *   finds it missing — and the issue list is fetched only on such a run
+ *   (never on a sync with nothing new); offline, or with no `gh` auth, the
+ *   page is written without it and the next sync retries. Delete the key to
+ *   refetch it.
  *
- * Two classifications, two homes. The sidebar group is the campaign TOPIC
- * from the README table (`tree-dfs/`, ordered by topic number via a
- * script-owned `meta.ts`); the page badge is the data-structure CATEGORY the
- * file sits under in `work/1/<Difficulty>/<Category>/`. A problem outside the
- * plan (warm-ups) has no topic, so it groups under its category instead.
+ * The sidebar group is the campaign TOPIC from the README table (`tree-dfs/`).
+ * A problem outside the plan (warm-ups) has no topic, so it groups under the
+ * data-structure CATEGORY its file sits under in
+ * `work/1/<Difficulty>/<Category>/` instead.
  *
- * Topic folders are real route segments (`/tree-dfs/invert-binary-tree`), not
- * `(group)` folders, so a hand-written `index.mdx` in one is the topic's
- * landing page at `/tree-dfs` and Blume links the sidebar group row to it.
- * Sync never writes or moves an `index.mdx`, and never removes a folder that
- * still holds one.
+ * Topics nest under their README PHASE: `(01-linear-structures)/tree-dfs/`.
+ * The phase folder is a Blume `(group)` — a sidebar section adding no route
+ * segment — while the topic folder is a real segment
+ * (`/tree-dfs/invert-binary-tree`), so a hand-written `index.mdx` in it is the
+ * topic's landing page at `/tree-dfs` and Blume links the sidebar group row to
+ * it. The topic's problem pages sit one level down in a `(problems)` group,
+ * `tree-dfs/(problems)/226_invert-binary-tree.mdx`: no route segment either,
+ * and Blume strips the `<num>_` prefix from the route while sorting by it, so
+ * the URL is still `/tree-dfs/invert-binary-tree`. Sync never writes or moves
+ * an `index.mdx`, and never removes a folder that still holds one. An
+ * unplanned category group has no phase and sits at the docs/ root.
+ *
+ * `docs/site.json` is wholly script-owned and rewritten whenever it differs:
+ * - `folders`: Blume folder meta keyed by folder path under docs/ — exactly
+ *   the key a `meta.ts` in that folder would have. A phase is `N. Name` in
+ *   phase order; a topic is its exact name (the folder slug loses `/` and
+ *   case), curriculum order, `TOPIC_ICONS` icon and `display: "page"`, so it
+ *   is one sidebar row drilling into its own panel. `(problems)` has none:
+ *   Blume's humanized "Problems" is the label.
+ * - `redirects`: one `{ from: "/<num>", to: "/<topic>/<slug>" }` per page, in
+ *   number order — exact root-relative paths; Blume prepends the deployment
+ *   base itself.
  *
  * Only the first-solve bucket is read: work/3 and work/7 hold blind re-solves
  * of problems whose page already exists (see work.ts), and a fresh scaffold
  * there would otherwise wipe the page's `## Solution`.
  */
-import { mkdir, readdir, rename, rmdir, unlink } from "node:fs/promises";
+import { mkdir, readdir, rename, rmdir } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 
+import { github } from "./github.ts";
+
 const ROOT = join(import.meta.dir, "..", "..");
 const WORK = join(ROOT, "work", "1");
-const DOCS = join(ROOT, "apps", "docs", "content");
+const DOCS = join(ROOT, "docs");
+const MANIFEST = join(DOCS, "site.json");
 
 type Lang = "js" | "py";
 
@@ -171,24 +214,86 @@ function parseHeader(header: string): Header {
 
 // ── README topic map ─────────────────────────────────────────────
 
+/** A campaign phase: `## Phase N — Name · Weeks …` in the README. */
+interface Phase {
+  order: number;
+  name: string;
+}
+
 /** A campaign topic: `<strong>NN. Name</strong>` in the README table. */
 interface Topic {
   order?: number; // README topic number; absent for an unplanned problem's category group
   name: string;
+  phase?: Phase; // absent for an unplanned category group
 }
 
+/** README phase names → the short labels the overview page uses. */
+const PHASE_ALIASES: Record<string, string> = {
+  "Nodal & Grid Structures": "Nodal & Grid",
+  "Hierarchical Structures": "Hierarchical",
+  "Relational Structures": "Relational",
+  "Decision-Space Exploration": "Decision Space",
+};
+
+const ROMAN = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X"];
+
 const TOPIC_ALIASES: Record<string, string> = {
   "Hash-Based Lookup": "Hash Table",
 };
 
+/**
+ * Sidebar icon per group, keyed by the (post-alias) topic name — the same key an
+ * unplanned problem's category group uses, so `Stack` the category and `Stack`
+ * the topic share one row. Lucide names; Blume resolves them at build time and
+ * reports a diagnostic for a typo, but an unmapped group is caught here first.
+ */
+const TOPIC_ICONS: Record<string, string> = {
+  // README topics, in curriculum order
+  "Hash Table": "hash",
+  "Prefix Sum": "sigma",
+  "Two Pointers": "arrow-left-right",
+  "Sliding Window": "app-window",
+  "Binary Search": "search",
+  Stack: "layers",
+  "Monotonic Stack": "trending-up",
+  "Linked List": "link",
+  "Hybrid Structures": "combine",
+  "Matrix Index Math": "grid-3x3",
+  "Tree DFS": "folder-tree",
+  "Tree BFS": "network",
+  "Binary Search Tree": "git-fork",
+  "Heap / Priority Queue": "triangle",
+  Trie: "spell-check",
+  "Graph DFS": "waypoints",
+  "Graph BFS": "radar",
+  "Topological Sort": "workflow",
+  "Union-Find": "merge",
+  Backtracking: "undo-2",
+  "1-D Dynamic Programming": "columns-3",
+  "Multi-D / Grid DP": "table",
+  Greedy: "coins",
+  Intervals: "calendar-range",
+  // work/1 categories that can surface as an unplanned group
+  Array: "brackets",
+  String: "type",
+  Tree: "network",
+  "Depth-First Search": "folder-tree",
+};
+
 /** LC number -> topic. A problem listed under two topics keeps the first. */
 async function readmeTopics(): Promise<Map<number, Topic>> {
   const md = await Bun.file(join(ROOT, "README.md")).text();
   const map = new Map<number, Topic>();
+  let phase: Phase | undefined;
   let topic: Topic | null = null;
   for (const line of md.split("\n")) {
+    const p = line.match(/^## Phase ([IVX]+) — (.+?) · /);
+    if (p) {
+      const name = p[2]!.replaceAll("&amp;", "&");
+      phase = { order: ROMAN.indexOf(p[1]!) + 1, name: PHASE_ALIASES[name] ?? name };
+    }
     const t = line.match(/<strong>(\d+)\.\s*([^<]+)<\/strong>/);
-    if (t) topic = { order: Number(t[1]), name: TOPIC_ALIASES[t[2]!.trim()] ?? t[2]!.trim() };
+    if (t) topic = { order: Number(t[1]), name: TOPIC_ALIASES[t[2]!.trim()] ?? t[2]!.trim(), phase };
     if (!topic) continue;
     const n = line.match(/<td align="center">(\d+)<\/td>/);
     if (n && !map.has(Number(n[1]))) map.set(Number(n[1]), topic);
@@ -197,12 +302,150 @@ async function readmeTopics(): Promise<Map<number, Topic>> {
 }
 
 /**
- * Blume folder meta: exact topic label (the folder slug loses `/` and case) and
- * curriculum order. An unplanned category group (warm-ups) has no README
- * number and sorts at 0, ahead of topic 1, so the sidebar opens on the basics.
+ * Folder slug for a topic or phase name. Blume reads a leading `<digits>-` on a
+ * folder as a sidebar-order prefix and strips it from the route (`1-d-…` →
+ * `/d-…`), so a slug that would start that way keeps the digits glued to the
+ * next token (`1d-dynamic-programming`).
  */
-function groupMeta(topic: Topic): string {
-  return `import { defineMeta } from "blume";\n\nexport default defineMeta({ title: ${JSON.stringify(topic.name)}, order: ${topic.order ?? 0} });\n`;
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .replace(/^(\d+)-/, "$1");
+}
+
+/**
+ * Content folder for a topic, relative to `DOCS`: `(0N-<phase>)/<topic>` for a
+ * planned topic (the phase is a `(group)`, so the route is still `/<topic>`),
+ * bare `<topic>` for an unplanned category group.
+ */
+function topicDir(topic: Topic): string {
+  const slug = slugify(topic.name);
+  return topic.phase ? `${phaseDir(topic.phase)}/${slug}` : slug;
+}
+
+function phaseDir(phase: Phase): string {
+  return `(${String(phase.order).padStart(2, "0")}-${slugify(phase.name)})`;
+}
+
+/** A sidebar group's Blume folder meta, as `docs/site.json` carries it. */
+interface FolderMeta {
+  title: string;
+  order: number;
+  icon?: string;
+  display?: "page";
+}
+
+/**
+ * Folder meta for a phase `(group)`: the overview page's heading, `N. Name`,
+ * in phase order. Derived like everything in the manifest, so a README rename
+ * renames the heading — and lands in a new folder (`phaseDir`) anyway.
+ */
+function phaseMeta(phase: Phase): FolderMeta {
+  return { title: `${phase.order}. ${phase.name}`, order: phase.order };
+}
+
+/**
+ * Folder meta for a topic: exact label, curriculum order, the sidebar icon,
+ * and `display: "page"` so the topic is one row under its phase heading that
+ * drills into its own panel (the landing page, then its `(problems)` list).
+ * An unplanned category group (warm-ups) has no README number and sorts at 0,
+ * ahead of phase 1, so the sidebar opens on the basics.
+ */
+function groupMeta(topic: Topic): FolderMeta {
+  const icon = TOPIC_ICONS[topic.name];
+  if (!icon) console.warn(`no icon for group ${JSON.stringify(topic.name)}: add it to TOPIC_ICONS`);
+  return { title: topic.name, order: topic.order ?? 0, ...(icon ? { icon } : {}), display: "page" };
+}
+
+// ── LeetCode topic tags ──────────────────────────────────────────
+
+/** One of LeetCode's topic tags. `slug` is not derivable from `name` (`Graph Theory` → `graph`). */
+interface TopicTag {
+  name: string;
+  slug: string;
+}
+
+/**
+ * The problem's topic tags, in LeetCode's order — or undefined, warned, when
+ * LeetCode cannot answer (offline commit, unknown slug): the page is written
+ * without `topics:` and the next sync fills it in.
+ */
+async function fetchTopicTags(sol: Solution): Promise<TopicTag[] | undefined> {
+  try {
+    const res = await fetch("https://leetcode.com/graphql", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "user-agent": "Mozilla/5.0",
+        referer: `https://leetcode.com/problems/${sol.slug}/`,
+      },
+      body: JSON.stringify({
+        query: "query topicTags($titleSlug: String!) { question(titleSlug: $titleSlug) { topicTags { name slug } } }",
+        variables: { titleSlug: sol.slug },
+      }),
+    });
+    if (!res.ok) throw new Error(`POST /graphql -> ${res.status} ${res.statusText}`);
+    const data = (await res.json()) as { data?: { question?: { topicTags?: TopicTag[] } | null } };
+    const tags = data.data?.question?.topicTags;
+    if (!Array.isArray(tags)) throw new Error("POST /graphql -> no such question");
+    return tags.map(({ name, slug }) => ({ name, slug }));
+  } catch (err) {
+    console.warn(`no topics for ${sol.num}.${sol.slug}: ${err instanceof Error ? err.message : err}`);
+    return undefined;
+  }
+}
+
+/** The frontmatter `topics:` block, one flow mapping per tag (JSON strings are valid YAML). */
+function topicsYaml(tags: TopicTag[]): string {
+  if (tags.length === 0) return "topics: []";
+  return ["topics:", ...tags.map((t) => `  - { name: ${JSON.stringify(t.name)}, slug: ${JSON.stringify(t.slug)} }`)].join("\n");
+}
+
+// ── GitHub problem issues ────────────────────────────────────────
+
+let issueUrls: Promise<Map<number, string> | undefined> | undefined;
+
+/**
+ * LC number → the URL of its `problem` issue (`LC <num> · <Name>`, open or
+ * closed), listed once per run and only when a page first needs it — or
+ * undefined, warned, when GitHub cannot answer (offline commit, no `gh`
+ * auth): pages go without `issue:` and the next sync fills it in.
+ */
+function problemIssues(): Promise<Map<number, string> | undefined> {
+  issueUrls ??= (async () => {
+    try {
+      const gh = await github();
+      const urls = new Map<number, string>();
+      for await (const raw of gh.list(`/repos/${gh.repo}/issues?labels=problem&state=all`)) {
+        if (!raw || typeof raw !== "object" || "pull_request" in raw) continue;
+        if (!("title" in raw) || typeof raw.title !== "string") continue;
+        if (!("html_url" in raw) || typeof raw.html_url !== "string") continue;
+        const lc = raw.title.match(/^LC (\d+) · /)?.[1];
+        if (lc && !urls.has(Number(lc))) urls.set(Number(lc), raw.html_url);
+      }
+      return urls;
+    } catch (err) {
+      console.warn(`no problem issues: ${err instanceof Error ? err.message : err}`);
+      return undefined;
+    }
+  })();
+  return issueUrls;
+}
+
+/**
+ * The problem's issue URL, or undefined (warned when GitHub answered but has
+ * no such issue). Only a problem the README plan lists has a catalog issue;
+ * an unplanned warm-up never will, so it is not looked up — otherwise its
+ * missing key would re-list the issues and re-warn on every sync.
+ */
+async function issueUrl(sol: Solution): Promise<string | undefined> {
+  if (!topics.has(sol.num)) return undefined;
+  const urls = await problemIssues();
+  const url = urls?.get(sol.num);
+  if (urls && !url) console.warn(`no problem issue titled "LC ${sol.num} · …" for ${sol.num}.${sol.slug}`);
+  return url;
 }
 
 // ── inline-code formatting heuristics ────────────────────────────
@@ -306,11 +549,10 @@ function warningText(h: Header): string {
   );
 }
 
-function badgeLine(sol: Solution): string {
-  return `<Badge variant="accent">${sol.category}</Badge>`;
-}
+/** Sidebar/page icon for every problem page (Lucide, resolved by Blume). */
+const PAGE_ICON = "dot";
 
-function renderPage(sol: Solution): string {
+function renderPage(sol: Solution, tags: TopicTag[] | undefined, issue: string | undefined): string {
   const h = sol.header;
   const ids = identifiers(sol);
   const description = h.statement[0]?.replace(/\.\s*$/, "") ?? "";
@@ -320,13 +562,14 @@ function renderPage(sol: Solution): string {
     "---",
     `title: '${h.num}. ${h.title.replaceAll("'", "''")}'`,
     /[:#]/.test(description) ? `description: '${description.replaceAll("'", "''")}'` : `description: ${description}`,
+    `icon: ${PAGE_ICON}`,
+    ...(tags ? [topicsYaml(tags)] : []),
+    ...(issue ? [`issue: ${JSON.stringify(issue)}`] : []),
     "sidebar:",
     `  label: '${h.title.replaceAll("'", "''")}'`,
     `  badge: '${h.difficulty}'`,
     "---",
     "",
-    badgeLine(sol),
-    "",
   );
 
   const warning = warningText(h);
@@ -383,6 +626,11 @@ for await (const rel of new Bun.Glob("**/*.{js,py}").scan(WORK)) {
 }
 
 const topics = await readmeTopics();
+// An unplanned problem whose work/ category is also a README topic name (a
+// `Hash Table` warm-up) files under that topic, in its phase, not a second
+// root-level `hash-table/`.
+const topicByName = new Map<string, Topic>();
+for (const topic of topics.values()) topicByName.set(topic.name, topic);
 
 /** Insert a number-free `sidebar.label` into existing frontmatter when missing. */
 function ensureLabel(page: string, h: Header): string {
@@ -392,10 +640,39 @@ function ensureLabel(page: string, h: Header): string {
   return page.replace(/^sidebar:$/m, `sidebar:\n${label}`);
 }
 
+/** Set the frontmatter's top-level `icon:` to `PAGE_ICON`, inserting it before `sidebar:`. */
+function ensureIcon(page: string): string {
+  const fm = page.match(/^---\n[\s\S]*?\n---/);
+  if (!fm) return page;
+  const line = `icon: ${PAGE_ICON}`;
+  const next = /^icon: .*$/m.test(fm[0])
+    ? fm[0].replace(/^icon: .*$/m, line)
+    : fm[0].replace(/^sidebar:$/m, `${line}\nsidebar:`);
+  return next + page.slice(fm[0].length);
+}
+
+/** Insert `topics:` before `sidebar:` when the frontmatter lacks it; an existing list is kept as is. */
+async function ensureTopics(page: string, sol: Solution): Promise<string> {
+  const fm = page.match(/^---\n[\s\S]*?\n---/);
+  if (!fm || /^topics:/m.test(fm[0])) return page;
+  const tags = await fetchTopicTags(sol);
+  if (!tags) return page;
+  return fm[0].replace(/^sidebar:$/m, `${topicsYaml(tags)}\nsidebar:`) + page.slice(fm[0].length);
+}
+
+/** Insert `issue:` before `sidebar:` when the frontmatter lacks it; an existing URL is kept as is. */
+async function ensureIssue(page: string, sol: Solution): Promise<string> {
+  const fm = page.match(/^---\n[\s\S]*?\n---/);
+  if (!fm || /^issue:/m.test(fm[0])) return page;
+  const url = await issueUrl(sol);
+  if (!url) return page;
+  return fm[0].replace(/^sidebar:$/m, `issue: ${JSON.stringify(url)}\nsidebar:`) + page.slice(fm[0].length);
+}
+
 /**
  * Offset just past the script-owned `## Solution` section: the next top-level
  * heading that is not inside a code fence, or end of file. Sections a human
- * appends after the solution (`## Explanation`, …) survive regeneration.
+ * appends after the solution survive regeneration.
  */
 function solutionEnd(page: string, from: number): number {
   const lines = page.slice(from).split("\n");
@@ -420,22 +697,23 @@ for (const rel of (await Array.fromAsync(new Bun.Glob("**/*.mdx").scan(DOCS))).s
 
 const report: [string, string, string][] = [];
 const ordered = [...solutions.values()].sort((a, b) => a.num - b.num);
-const groups = new Map<string, Topic>(); // folder -> topic, for meta.ts
+const folders = new Map<string, FolderMeta>(); // folder under docs/ -> its sidebar meta, for site.json
 const vacated = new Set<string>(); // folders a page moved out of; removed below if empty
+const redirects: { from: string; to: string }[] = []; // one per page, numeric order
 
 for (const sol of ordered) {
   const langs = Object.keys(sol.code).sort().join("+");
   const workRef = `${sol.num}.${sol.slug} (${langs})`;
-  // <topic>/ folder (a real route segment, so its index.mdx is the topic landing
-  // page) + leetcode-number prefix: numeric sidebar order, prefix stripped from the URL.
-  // An unplanned problem's category may share a folder with a numbered topic
-  // (`Hash Table` warm-ups under topic 1); the numbered one owns the meta.
-  const topic = topics.get(sol.num) ?? { name: sol.category };
-  const group = topic.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  if (groups.get(group)?.order === undefined) groups.set(group, topic);
-  const name = `${group}/${sol.num}-${sol.slug}.mdx`;
+  // (0N-<phase>)/<topic>/(problems)/ folder (the topic is a real route segment,
+  // so its index.mdx is the landing page; `(problems)` adds none) +
+  // leetcode-number prefix: numeric sidebar order, prefix stripped from the URL.
+  const topic = topics.get(sol.num) ?? topicByName.get(sol.category) ?? { name: sol.category };
+  const dir = topicDir(topic);
+  if (!folders.has(dir)) folders.set(dir, groupMeta(topic));
+  if (topic.phase) folders.set(phaseDir(topic.phase), phaseMeta(topic.phase));
+  const name = `${dir}/(problems)/${sol.num}_${sol.slug}.mdx`;
   const existing = pages.get(sol.num);
-  await mkdir(join(DOCS, group), { recursive: true });
+  await mkdir(join(DOCS, dirname(name)), { recursive: true });
 
   if (existing) {
     const page = await Bun.file(join(DOCS, existing)).text();
@@ -446,7 +724,7 @@ for (const sol of ordered) {
     }
     const tail = page.slice(solutionEnd(page, at));
     const body = page.slice(0, at) + solutionSection(sol) + (tail ? `\n${tail}` : "");
-    const next = ensureLabel(body, sol.header).replace(/^<Badge variant="accent">.*<\/Badge>$/m, badgeLine(sol));
+    const next = await ensureIssue(await ensureTopics(ensureIcon(ensureLabel(body, sol.header)), sol), sol);
     const actions: string[] = [];
     if (existing !== name) {
       await rename(join(DOCS, existing), join(DOCS, name));
@@ -459,28 +737,43 @@ for (const sol of ordered) {
     }
     report.push([workRef, name, actions.join(" + ") || "skipped (in sync)"]);
   } else {
-    await Bun.write(join(DOCS, name), renderPage(sol));
+    await Bun.write(join(DOCS, name), renderPage(sol, await fetchTopicTags(sol), await issueUrl(sol)));
     report.push([workRef, name, "created"]);
   }
+  // The route drops the phase `(group)`, `(problems)` and the number prefix.
+  redirects.push({ from: `/${sol.num}`, to: `/${slugify(topic.name)}/${sol.slug}` });
+}
+
+// The site's one generated input besides the pages; script-owned, rewritten
+// only when it differs. Folders sorted by path so a diff reads by location.
+{
+  const manifest = `${JSON.stringify(
+    { folders: Object.fromEntries([...folders].sort(([a], [b]) => (a < b ? -1 : 1))), redirects },
+    null,
+    2,
+  )}\n`;
+  if (!(await Bun.file(MANIFEST).exists()) || (await Bun.file(MANIFEST).text()) !== manifest) {
+    await Bun.write(MANIFEST, manifest);
+    report.push([`${folders.size} folders, ${redirects.length} redirects`, "docs/site.json", "written"]);
+  }
 }
 
-// Script-owned folder meta: one per live group, rewritten only when it differs.
-for (const [group, topic] of groups) {
-  const path = join(DOCS, group, "meta.ts");
-  const meta = groupMeta(topic);
-  if ((await Bun.file(path).exists()) && (await Bun.file(path).text()) === meta) continue;
-  await Bun.write(path, meta);
-  report.push([`topic ${topic.order ?? "-"}`, `${group}/meta.ts`, "written"]);
-}
-
-// A group every page left behind is dead: drop its meta and the folder itself.
-for (const dir of vacated) {
-  if (groups.has(dir)) continue;
-  const left = await readdir(join(DOCS, dir));
-  if (left.some((f) => f !== "meta.ts")) continue;
-  if (left.length) await unlink(join(DOCS, dir, "meta.ts"));
-  await rmdir(join(DOCS, dir));
-  report.push(["", dir, "removed (empty)"]);
+// A folder every page left behind is dead: drop it, then the folders above it
+// that emptied too (`(problems)`, its topic, the phase). A folder that still
+// holds anything (a hand-written index.mdx, another topic) stops the climb.
+for (const start of vacated) {
+  for (let dir = start; dir !== "."; dir = dirname(dir)) {
+    if (folders.has(dir)) break;
+    let left: string[];
+    try {
+      left = await readdir(join(DOCS, dir));
+    } catch {
+      break; // already removed via a sibling's climb
+    }
+    if (left.length) break;
+    await rmdir(join(DOCS, dir));
+    report.push(["", dir, "removed (empty)"]);
+  }
 }
 
 const w0 = Math.max(...report.map((r) => r[0].length), 9);

apps/cli/topics.ts

@@ -0,0 +1,89 @@
+/**
+ * Topic issues and their problem sub-issues: the ONE reading of "is this topic
+ * finished", shared by close-topics.ts (closes the topic issue) and
+ * release-topics.ts (publishes the topic's timever release) so the two can
+ * never disagree about when a topic was done. Also the one reading of "is this
+ * Review issue finished", which close-topics.ts closes on.
+ *
+ * Rule: a topic is finished when it has a core set (`set:core` sub-issues) and
+ * every one of them is closed. Optional and deferred problems are extra credit
+ * and never hold a topic open. A topic with no core sub-issues is never
+ * finished — that would be indistinguishable from a mis-labelled problem set.
+ *
+ * Review issues (`Review <N> — <Phase>`, label `review`) are day blocks for
+ * the transfer phase: problems were re-parented into them from their topics
+ * (a GitHub issue has one parent). A topic still OWNS such a problem —
+ * readProblems() returns it alongside the topic's direct sub-issues, with the
+ * ownership recovered by apps/api/src/reviews.ts (shared with the Worker's
+ * catalog reconcile) — so the finished rule and the release snapshots do not
+ * change when a problem moves. A Review issue is finished when every one of
+ * its sub-issues is closed: it is a fixed assignment, so the set labels do
+ * not matter there.
+ *
+ * Library: side-effect-free on import; every call takes the caller's github().
+ */
+import type { Problem } from "../api/src/reviews.ts";
+import type { GitHub } from "./github.ts";
+
+/** Completion of a required set: a topic's core problems, or every problem of a review. */
+export interface Core {
+  /** The required problems, closed and open alike, in the order given. */
+  all: number[];
+  /** The required problems still open — non-empty means the issue stays open. */
+  pending: number[];
+  /** When the last required problem closed; null until the set is finished (never, if empty). */
+  finishedAt: string | null;
+}
+
+/**
+ * Every problem a topic owns: its sub-issues plus the ones moved from it into
+ * a Review issue (`moved`, from movedFromTopics()). The sub_issues payload
+ * carries the full issue objects (state + labels), so no per-problem
+ * follow-up request is needed.
+ */
+export async function readProblems(
+  gh: GitHub,
+  topic: number,
+  moved: Map<number, Problem[]>,
+): Promise<Problem[]> {
+  const problems = [...(moved.get(topic) ?? [])];
+  for await (const raw of gh.list(`/repos/${gh.repo}/issues/${topic}/sub_issues`)) {
+    if (!raw || typeof raw !== "object") continue;
+    if (!("number" in raw) || typeof raw.number !== "number") continue;
+    if (!("title" in raw) || typeof raw.title !== "string") continue;
+    if (!("state" in raw) || typeof raw.state !== "string") continue;
+    if (!("labels" in raw) || !Array.isArray(raw.labels)) continue;
+    const closedAt =
+      raw.state === "closed" && "closed_at" in raw && typeof raw.closed_at === "string"
+        ? raw.closed_at
+        : null;
+    const labels = raw.labels.flatMap((label: unknown) =>
+      label && typeof label === "object" && "name" in label && typeof label.name === "string"
+        ? [label.name]
+        : [],
+    );
+    problems.push({ number: raw.number, title: raw.title, closedAt, labels });
+  }
+  return problems.sort((a, b) => a.number - b.number);
+}
+
+/** The value of a `prefix:value` label (`set:` → `core`), if the problem has one. */
+export function labelValue(problem: Problem, prefix: string): string | undefined {
+  return problem.labels.find((l) => l.startsWith(prefix))?.slice(prefix.length);
+}
+
+/** A topic's rule: its `set:core` problems are the required set. */
+export function coreSet(problems: Problem[]): Core {
+  return completion(problems.filter((p) => labelValue(p, "set:") === "core"));
+}
+
+/** The shared rule: finished when non-empty and every required problem is closed. */
+export function completion(required: Problem[]): Core {
+  const pending = required.filter((p) => !p.closedAt).map((p) => p.number);
+  // ISO instants from the API share one format, so string order is time order.
+  const finishedAt =
+    required.length && !pending.length
+      ? required.map((p) => p.closedAt!).reduce((a, b) => (a > b ? a : b))
+      : null;
+  return { all: required.map((p) => p.number), pending, finishedAt };
+}

apps/cli/videos.ts

@@ -2,31 +2,30 @@
 /**
  * Find the NeetCode explanation video for every docs page that has none.
  *
- * A finished solution page ends with `## Explanation` holding one
- * `<YouTube id="…" title="…" />` — NeetCode's walkthrough of the problem.
- * `sync.ts` never writes that section (it owns only `## Solution`), so pages
- * accumulate without one. This script lists every numbered page lacking a
- * `<YouTube` embed and looks each up on NeetCode's two channels, main channel
- * first, accepting only a title that names the page's exact LC number
- * (`… - Leetcode 226 - …`) and is not a #short. No YouTube API key: the
- * channel search page embeds its results as `ytInitialData` JSON, which is
- * all we parse. Ranking is the channel's own — the first exact-number match
- * wins.
+ * A finished solution page carries frontmatter `video: <YouTube id>` —
+ * NeetCode's walkthrough of the problem — which the site's MDX `wrapper`
+ * (prdlk/cs `components/ProblemBadges.astro`) renders as the red
+ * "Explanation" badge beside the topic badges. `sync.ts` never writes that key
+ * (it owns `icon:`, `topics:` and `## Solution`), so pages accumulate without
+ * one. This script lists every numbered page lacking `video:` and looks each
+ * up on NeetCode's two channels, main channel first, accepting only a title
+ * that names the page's exact LC number (`… - Leetcode 226 - …`) and is not a
+ * #short. No YouTube API key: the channel search page embeds its results as
+ * `ytInitialData` JSON, which is all we parse. Ranking is the channel's own —
+ * the first exact-number match wins.
  *
  *   bun apps/cli/videos.ts           # report: page → video (or "no match")
- *   bun apps/cli/videos.ts --write   # also append `## Explanation` + embed
+ *   bun apps/cli/videos.ts --write   # also add `video:` to the frontmatter
  *
- * --write appends at end of file (below `## Solution`, where sync.ts leaves
- * human sections alone) and adds the `## Explanation` heading only when the
- * page lacks it. A page with no match is left untouched, so re-runs are
- * no-ops once every page has its embed.
+ * --write inserts the key before `sidebar:`. A page with no match is left
+ * untouched, so re-runs are no-ops once every page has its video.
  */
 import { join } from "node:path";
 
 import { printTable } from "./report.ts";
 import { ROOT } from "./work.ts";
 
-const DOCS = join(ROOT, "apps", "docs", "content");
+const DOCS = join(ROOT, "docs");
 const WRITE = process.argv.includes("--write");
 
 /** Channel handles searched in order; the first exact match wins. */
@@ -126,23 +125,21 @@ interface Page {
   text: string;
 }
 
-/** Numbered solution pages without a `<YouTube` embed, by LC number. */
+/** The page's frontmatter block, `---` to `---`. */
+const FRONTMATTER = /^---\n[\s\S]*?\n---/;
+
+/** Numbered solution pages without a `video:` key, by LC number. */
 async function pagesMissingVideo(): Promise<Page[]> {
   const pages: Page[] = [];
   for (const rel of await Array.fromAsync(new Bun.Glob("**/*.mdx").scan(DOCS))) {
     const text = await Bun.file(join(DOCS, rel)).text();
     const t = text.match(/^title: '(\d+)\./m);
-    if (t && !text.includes("<YouTube")) pages.push({ num: Number(t[1]), rel, text });
+    const fm = text.match(FRONTMATTER)?.[0] ?? "";
+    if (t && !/^video:/m.test(fm)) pages.push({ num: Number(t[1]), rel, text });
   }
   return pages.sort((a, b) => a.num - b.num);
 }
 
-function withEmbed(page: Page, video: Video): string {
-  const embed = `<YouTube id="${video.id}" title="${video.title.replaceAll('"', "'")}" />`;
-  const heading = /^## Explanation\s*$/m.test(page.text) ? "" : "## Explanation\n\n";
-  return `${page.text.replace(/\s*$/, "\n")}\n${heading}${embed}\n`;
-}
-
 // ── main ─────────────────────────────────────────────────────────
 
 const missing = await pagesMissingVideo();
@@ -162,7 +159,8 @@ for (const page of missing) {
   found++;
   let status = "";
   if (WRITE) {
-    await Bun.write(join(DOCS, page.rel), withEmbed(page, video));
+    const next = page.text.replace(FRONTMATTER, (fm) => fm.replace(/^sidebar:$/m, `video: ${JSON.stringify(video.id)}\nsidebar:`));
+    await Bun.write(join(DOCS, page.rel), next);
     status = "written";
   }
   rows.push([page.rel, `https://youtu.be/${video.id}`, `${video.title} (${video.channel})`, status]);

apps/docs/.gitignore

@@ -1 +0,0 @@
-.blume-verify/

apps/docs/blume.config.ts

@@ -1,13 +0,0 @@
-import { defineConfig } from "blume";
-
-export default defineConfig({
-  title: "Leetcode",
-  description: "Documentation for LeetCode solutions",
-  deployment: {
-    site: "https://prdlk.github.io",
-    base: "/leetcode",
-  },
-  content: {
-    root: "content",
-  },
-});

apps/docs/components.ts

@@ -1,13 +0,0 @@
-/**
- * Project MDX components, available on every page with no import. Static
- * `.astro` files ship no framework JS (a custom element carries any
- * behaviour); interactive React lives in `islands/` instead.
- */
-import { defineComponents } from "blume";
-
-export default defineComponents({
-  mdx: {
-    Carousel: "./components/Carousel.astro",
-    CarouselImage: "./components/CarouselImage.astro",
-  },
-});

apps/docs/components/Carousel.astro

@@ -1,170 +0,0 @@
----
-/**
- * A horizontal carousel of <CarouselImage> slides, built the way Blume's own
- * content components are: static markup, a custom element for the behaviour,
- * no framework. The track is a CSS scroll-snap strip (so it also swipes on
- * touch and the browser does the animation); prev/next sit outside it and
- * the play toggle sits below with a "n / N" counter.
- *
- * `time` is seconds per slide while playing (default 1.25); `autoplay` starts
- * playing on load. Play wraps around, pauses whenever the tab is hidden, and
- * never starts on its own for a reader who prefers reduced motion — the
- * button still works for them. Manual navigation (buttons, arrow keys, swipe)
- * does not stop playback; it only restarts the interval so a step is never
- * doubled.
- */
-import Icon from "blume/components/Icon.astro";
-
-interface Props {
-  /** Seconds each slide stays while playing. */
-  time?: number;
-  autoplay?: boolean;
-}
-
-const { time = 1.25, autoplay = false } = Astro.props;
-
-const buttonClass =
-  "inline-flex size-9 shrink-0 cursor-pointer items-center justify-center rounded-full border border-border bg-background text-muted-foreground transition-colors hover:border-foreground hover:text-foreground disabled:cursor-default disabled:opacity-40";
----
-
-<blume-carousel
-  class="not-prose my-6 block"
-  data-time={String(time)}
-  data-autoplay={autoplay ? "" : undefined}
-  role="region"
-  aria-roledescription="carousel"
->
-  <div class="flex items-center gap-3">
-    <button class={buttonClass} data-prev type="button" aria-label="Previous slide">
-      <Icon class="rtl:-scale-x-100" name="chevron-left" size={18} />
-    </button>
-    <div
-      class="flex min-w-0 flex-1 snap-x snap-mandatory overflow-x-auto scroll-smooth rounded-blume [scrollbar-width:none] [&::-webkit-scrollbar]:hidden"
-      data-track
-      tabindex="0"
-      aria-live="polite"
-    >
-      <slot />
-    </div>
-    <button class={buttonClass} data-next type="button" aria-label="Next slide">
-      <Icon class="rtl:-scale-x-100" name="chevron-right" size={18} />
-    </button>
-  </div>
-  <div class="mt-3 flex items-center justify-center gap-3">
-    <button class={buttonClass} data-play type="button" aria-label="Play" aria-pressed="false">
-      <Icon class="[[aria-pressed=true]_&]:hidden" name="play" size={16} />
-      <Icon class="[[aria-pressed=false]_&]:hidden" name="pause" size={16} />
-    </button>
-    <span class="text-muted-foreground text-xs tabular-nums leading-5" data-count></span>
-  </div>
-</blume-carousel>
-
-<script>
-  class BlumeCarousel extends HTMLElement {
-    #track!: HTMLElement;
-    #play!: HTMLButtonElement;
-    #count!: HTMLElement;
-    #timer: number | null = null;
-    #index = 0;
-
-    connectedCallback() {
-      this.#track = this.querySelector("[data-track]")!;
-      this.#play = this.querySelector("[data-play]")!;
-      this.#count = this.querySelector("[data-count]")!;
-      const prev = this.querySelector<HTMLButtonElement>("[data-prev]")!;
-      const next = this.querySelector<HTMLButtonElement>("[data-next]")!;
-
-      const slides = this.#slides().length;
-      if (slides < 2) {
-        for (const b of [prev, next, this.#play]) b.disabled = true;
-      }
-      this.#render();
-
-      prev.addEventListener("click", () => this.#step(-1));
-      next.addEventListener("click", () => this.#step(1));
-      this.#play.addEventListener("click", () => (this.#timer === null ? this.#start() : this.#stop()));
-      this.addEventListener("keydown", (event) => {
-        if (event.key === "ArrowLeft") this.#step(-1);
-        else if (event.key === "ArrowRight") this.#step(1);
-        else return;
-        event.preventDefault();
-      });
-      // Swipes and trackpad scrolls move the track without #step; follow them
-      // once the scroll settles. Settle-only, not per event: a long smooth
-      // scroll from #step passes over intermediate slides and must not be
-      // read back as the reader's position mid-flight.
-      let settle: number | undefined;
-      this.#track.addEventListener(
-        "scroll",
-        () => {
-          window.clearTimeout(settle);
-          settle = window.setTimeout(() => this.#syncFromScroll(), 150);
-        },
-        { passive: true }
-      );
-      document.addEventListener("visibilitychange", this.#onVisibility);
-
-      const reduced = matchMedia("(prefers-reduced-motion: reduce)").matches;
-      if (this.hasAttribute("data-autoplay") && slides > 1 && !reduced) this.#start();
-    }
-
-    disconnectedCallback() {
-      this.#stop();
-      document.removeEventListener("visibilitychange", this.#onVisibility);
-    }
-
-    #slides(): HTMLElement[] {
-      return [...this.#track.querySelectorAll<HTMLElement>(":scope > blume-carousel-image")];
-    }
-
-    #step(delta: number) {
-      const slides = this.#slides();
-      this.#index = (this.#index + delta + slides.length) % slides.length;
-      slides[this.#index]!.scrollIntoView({ block: "nearest", inline: "start", behavior: "smooth" });
-      this.#render();
-      if (this.#timer !== null) this.#start(); // restart the interval from this slide
-    }
-
-    #syncFromScroll() {
-      const at = Math.round(this.#track.scrollLeft / this.#track.clientWidth);
-      if (at !== this.#index && Number.isFinite(at)) {
-        this.#index = Math.min(Math.max(at, 0), this.#slides().length - 1);
-        this.#render();
-      }
-    }
-
-    #start() {
-      this.#stop();
-      const ms = Number(this.dataset.time) * 1000;
-      this.#timer = window.setInterval(() => this.#step(1), ms > 0 ? ms : 1250);
-      this.#play.setAttribute("aria-pressed", "true");
-      this.#play.setAttribute("aria-label", "Pause");
-    }
-
-    #stop() {
-      if (this.#timer !== null) window.clearInterval(this.#timer);
-      this.#timer = null;
-      this.#play.setAttribute("aria-pressed", "false");
-      this.#play.setAttribute("aria-label", "Play");
-    }
-
-    // A background tab keeps its timers but not its layout; resume on return.
-    #wasPlaying = false;
-    #onVisibility = () => {
-      if (document.hidden) {
-        this.#wasPlaying = this.#timer !== null;
-        this.#stop();
-      } else if (this.#wasPlaying) this.#start();
-    };
-
-    #render() {
-      const slides = this.#slides();
-      this.#count.textContent = `${this.#index + 1} / ${slides.length}`;
-      slides.forEach((s, i) => s.setAttribute("aria-hidden", i === this.#index ? "false" : "true"));
-    }
-  }
-
-  if (!customElements.get("blume-carousel")) {
-    customElements.define("blume-carousel", BlumeCarousel);
-  }
-</script>

apps/docs/components/CarouselImage.astro

@@ -1,45 +0,0 @@
----
-/**
- * One slide of a <Carousel>: Blume's own <Frame> around an <img>, so a slide
- * is pixel-identical to a framed image elsewhere on the site — `alt` doubles
- * as the frame's hint line and `caption` is Markdown, exactly as in Frame.
- *
- * `src` accepts what MDX authors already write for images: a URL, a
- * root-relative `/file.png` (served from public/, prefixed with the deploy
- * base), or the page-relative `../../public/file.png` form. A relative path
- * that does not pass through public/ has nothing to serve it, so it is a
- * build error rather than a silent 404.
- */
-import Frame from "blume/components/content/Frame.astro";
-import { withBase } from "blume/components/islands/base-path.ts";
-
-interface Props {
-  src: string;
-  alt?: string;
-  caption?: string;
-}
-
-const { src, alt, caption } = Astro.props;
-
-const resolveSrc = (value: string): string => {
-  if (URL.canParse(value)) return value;
-  if (value.startsWith("/")) return withBase(value);
-  const at = value.indexOf("public/");
-  if (at === -1) {
-    throw new Error(
-      `<CarouselImage src="${value}">: a relative src must point into public/ (or use /file.png)`
-    );
-  }
-  return withBase(`/${value.slice(at + "public/".length)}`);
-};
----
-
-<blume-carousel-image
-  class="block w-full shrink-0 snap-center [&_blume-frame]:my-0"
-  role="group"
-  aria-roledescription="slide"
->
-  <Frame caption={caption} hint={alt}>
-    <img alt={alt ?? ""} src={resolveSrc(src)} loading="lazy" draggable="false" />
-  </Frame>
-</blume-carousel-image>

apps/docs/content/array/1365-how-many-numbers-are-smaller-than-the-current-number.mdx

@@ -1,77 +0,0 @@
----
-title: '1365. How Many Numbers Are Smaller Than the Current Number'
-description: Given the array nums, for each nums[i] find out how many numbers in the array are smaller than it. That is, for each nums[i] you have to count the number of valid j's such that j != i and nums[j] < nums[i]
-sidebar:
-  label: 'How Many Numbers Are Smaller Than the Current Number'
-  badge: 'Easy'
----
-
-<Badge variant="accent">Array</Badge>
-
-### Example 1:
-- Input: `nums = [8,1,2,2,3]`
-- Output: `[4,0,1,1,3]`
-- Explanation: For `nums[0]=8` there exist four smaller numbers than it (`1`, `2`, `2` and `3`). For `nums[1]=1` does not exist any smaller number than it. For `nums[2]=2` there exist one smaller number than it (`1`). For `nums[3]=2` there exist one smaller number than it (`1`). For `nums[4]=3` there exist three smaller numbers than it (`1`, `2` and `2`).
-
-### Example 2:
-- Input: `nums = [6,5,4,8]`
-- Output: `[2,1,0,3]`
-
-### Example 3:
-- Input: `nums = [7,7,7,7]`
-- Output: `[0,0,0,0]`
-
-### Constraints:
-
-- `2 <= nums.length <= 500`
-- `0 <= nums[i] <= 100`
-
-## Approach
-
-```mermaid
-flowchart TD
-  S(["smallerNumbersThanCurrent(nums)"]) --> F["freq: count every value in nums"]
-  F --> O["sorted = keys of freq, ascending"]
-  O --> I["count = 0, smaller = {}"]
-  I --> L{"more num in sorted?"}
-  L -- yes --> A["smaller[num] = count — everything already passed is smaller"]
-  A --> B["count += freq[num]"]
-  B --> L
-  L -- no --> M(["return nums.map(n => smaller[n])"])
-```
-
-## Solution
-
-```js
-/**
- * @param {number[]} nums
- * @return {number[]}
- */
-
-var smallerNumbersThanCurrent = function (nums) {
-  // Step 1: Begin by initializing a [Frequency Map]()
-  const freq = {};
-  for (let n of nums) freq[n] = (freq[n] || 0) + 1;
-
-  // Step 2: Sort the numbers by ascending order
-  const sorted = Object.keys(freq).sort((a, b) => a - b);
-
-  // Step 3: Init a count of numbers smaller than the active number
-  let count = 0;
-
-  // Step 4: Init a map to track number of values smaller for each number
-  const smaller = {};
-
-  // Step 5: Iterate over the sorted list
-  for (let num of sorted) {
-    // Set count for active number
-    smaller[num] = count;
-
-    // Update the count by frequency
-    count += freq[num];
-  }
-
-  // Step 6: Use original list and find number of smaller values than it
-  return nums.map((n) => smaller[n]);
-};
-```

apps/docs/content/array/1413-minimum-value-to-get-positive-step-by-step-sum.mdx

@@ -1,69 +0,0 @@
----
-title: '1413. Minimum Value to Get Positive Step by Step Sum'
-description: Given an array of integers nums, you start with an initial positive value startValue
-sidebar:
-  label: 'Minimum Value to Get Positive Step by Step Sum'
-  badge: 'Easy'
----
-
-<Badge variant="accent">Array</Badge>
-
-### Example 1:
-- Input: `nums = [-3,2,-3,4,2]`
-- Output: `5`
-- Explanation: If you choose `startValue = 4`, in the third iteration your step by step sum is less than `1`.
-
-```
-step by step sum
-startValue = 4 | startValue = 5 | nums
-  (4 -3 ) = 1  | (5 -3 ) = 2    |  -3
-  (1 +2 ) = 3  | (2 +2 ) = 4    |   2
-  (3 -3 ) = 0  | (4 -3 ) = 1    |  -3
-  (0 +4 ) = 4  | (1 +4 ) = 5    |   4
-  (4 +2 ) = 6  | (5 +2 ) = 7    |   2
-```
-
-### Example 2:
-- Input: `nums = [1,2]`
-- Output: `1`
-- Explanation: Minimum start value should be positive.
-
-### Example 3:
-- Input: `nums = [1,-2,-3]`
-- Output: `5`
-
-### Constraints:
-
-- `1 <= nums.length <= 100`
-- `-100 <= nums[i] <= 100`
-
-## Approach
-
-```mermaid
-flowchart TD
-  S(["minStartValue(nums)"]) --> I["prefix = [nums[0]]"]
-  I --> L{"more i in 1..n-1?"}
-  L -- yes --> P["prefix.push(prefix[i-1] + nums[i])"]
-  P --> L
-  L -- no --> M["min = smallest running total"]
-  M --> R(["return max(1, 1 - min) — lift the dip to 1"])
-```
-
-## Solution
-
-```js
-/**
- * @param {number[]} nums
- * @return {number}
- */
-var minStartValue = function(nums) {
-  let prefix = [nums[0]];
-  // Make prefix sum start at 1 after initializing seed value
-  for (let i = 1; i < nums.length; i++){
-    prefix.push(prefix[i - 1] + nums[i]);
-  }
-
-  let min = Math.min(...prefix);
-  return Math.max(1, 1 - min);
-};
-```

apps/docs/content/array/1426-counting-elements.mdx

@@ -1,58 +0,0 @@
----
-title: '1426. Counting Elements'
-description: Given an integer array arr, count how many elements x there are, such that x + 1 is also in arr. If there are duplicates in arr, count them separately
-sidebar:
-  label: 'Counting Elements'
-  badge: 'Easy'
----
-
-<Badge variant="accent">Array</Badge>
-
-### Example 1:
-- Input: `arr = [1,2,3]`
-- Output: `2`
-- Explanation: `1` and `2` are counted cause `2` and `3` are in `arr`.
-
-### Example 2:
-- Input: `arr = [1,1,3,3,5,5,7,7]`
-- Output: `0`
-- Explanation: No numbers are counted, cause there is no `2`, `4`, `6`, or `8` in `arr`.
-
-### Constraints:
-
-- `1 <= arr.length <= 1000`
-- `0 <= arr[i] <= 1000`
-
-## Approach
-
-```mermaid
-flowchart TD
-  S(["countElements(arr)"]) --> I["arrSet = Set(arr), count = 0"]
-  I --> L{"more n in arr?"}
-  L -- no --> E(["return count"])
-  L -- yes --> H{"arrSet has n + 1?"}
-  H -- yes --> C["count++"]
-  C --> L
-  H -- no --> L
-```
-
-## Solution
-
-```js
-/**
- * @param {number[]} arr
- * @return {number}
- */
-var countElements = function(arr) {
-  let arrSet = new Set(arr);
-  let count = 0; 
-
-  for (let n of arr) {
-    let sum = n + 1;
-    if (arrSet.has(sum)) {
-      count++;
-    }
-  }
-  return count;
-};
-```

apps/docs/content/array/1480-running-sum-of-1d-array.mdx

@@ -1,55 +0,0 @@
----
-title: '1480. Running Sum of 1d Array'
-description: Given an array nums. We define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i])
-sidebar:
-  label: 'Running Sum of 1d Array'
-  badge: 'Easy'
----
-
-<Badge variant="accent">Array</Badge>
-
-### Example 1:
-- Input: `nums = [1,2,3,4]`
-- Output: `[1,3,6,10]`
-- Explanation: Running sum is obtained as follows: `[1, 1+2, 1+2+3, 1+2+3+4]`.
-
-### Example 2:
-- Input: `nums = [1,1,1,1,1]`
-- Output: `[1,2,3,4,5]`
-- Explanation: Running sum is obtained as follows: `[1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1]`.
-
-### Example 3:
-- Input: `nums = [3,1,2,10,1]`
-- Output: `[3,4,6,16,17]`
-
-### Constraints:
-
-- `1 <= nums.length <= 1000`
-- `-10^6 <= nums[i] <= 10^6`
-
-## Approach
-
-```mermaid
-flowchart TD
-  S(["runningSum(nums)"]) --> I["prefix = [nums[0]]"]
-  I --> L{"more i in 1..n-1?"}
-  L -- yes --> P["prefix.push(prefix[i-1] + nums[i])"]
-  P --> L
-  L -- no --> E(["return prefix"])
-```
-
-## Solution
-
-```js
-/**
- * @param {number[]} nums
- * @return {number[]}
- */
-var runningSum = function(nums) {
-  let prefix = [nums[0]];
-  for (let i = 1; i < nums.length; i++){
-    prefix.push(prefix[i - 1] + nums[i]);
-  }
-  return prefix;
-};
-```

apps/docs/content/array/1636-sort-array-by-increasing-frequency.mdx

@@ -1,58 +0,0 @@
----
-title: '1636. Sort Array by Increasing Frequency'
-description: Given an array of integers nums, sort the array in increasing order based on the frequency of the values. If multiple values have the same frequency, sort them in decreasing order
-sidebar:
-  label: 'Sort Array by Increasing Frequency'
-  badge: 'Easy'
----
-
-<Badge variant="accent">Array</Badge>
-
-### Example 1:
-- Input: `nums = [1,1,2,2,2,3]`
-- Output: `[3,1,1,2,2,2]`
-- Explanation: `'3'` has a frequency of `1`, `'1'` has a frequency of `2`, and `'2'` has a frequency of `3`.
-
-### Example 2:
-- Input: `nums = [2,3,1,3,2]`
-- Output: `[1,3,3,2,2]`
-- Explanation: `'2'` and `'3'` both have a frequency of `2`, so they are sorted in decreasing order.
-
-### Example 3:
-- Input: `nums = [-1,1,-6,4,5,-6,1,4,1]`
-- Output: `[5,-1,4,4,-6,-6,1,1,1]`
-
-### Constraints:
-
-- `1 <= nums.length <= 100`
-- `-100 <= nums[i] <= 100`
-
-## Approach
-
-```mermaid
-flowchart TD
-  S(["frequencySort(nums)"]) --> F["freq: count every value in nums"]
-  F --> C["sort nums with a two-key comparator"]
-  C --> K1["primary: freq[a] - freq[b] — rarer first"]
-  C --> K2["tie-break: b - a — larger value first"]
-  K1 --> R(["return nums"])
-  K2 --> R
-```
-
-## Solution
-
-```js
-/**
- * @param {number[]} nums
- * @return {number[]}
- */
-var frequencySort = function (nums) {
-  const freq = {};
-  for (let n of nums) freq[n] = (freq[n] || 0) + 1;
-  return nums.sort((a, b) => freq[a] - freq[b] || b - a);
-};
-```
-
-## Explanation
-
-<YouTube id="Evq1SfUbhBg" title="Sort Array by Increasing Frequency - Leetcode 1636 - Python" />

apps/docs/content/array/268-missing-number.mdx

@@ -1,71 +0,0 @@
----
-title: '268. Missing Number'
-description: Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array
-sidebar:
-  label: 'Missing Number'
-  badge: 'Easy'
----
-
-<Badge variant="accent">Array</Badge>
-
-::::warning
-Could you implement a solution using only O(1) extra space complexity and O(n) runtime complexity?
-::::
-
-### Example 1:
-- Input: `nums = [3,0,1]`
-- Output: `2`
-- Explanation: `n = 3` since there are `3` numbers, so all numbers are in the range `[0,3]`. `2` is the missing number in the range since it does not appear in `nums`.
-
-### Example 2:
-- Input: `nums = [0,1]`
-- Output: `2`
-- Explanation: `n = 2` since there are `2` numbers, so all numbers are in the range `[0,2]`. `2` is the missing number in the range since it does not appear in `nums`.
-
-### Example 3:
-- Input: `nums = [9,6,4,2,3,5,7,0,1]`
-- Output: `8`
-- Explanation: `n = 9` since there are `9` numbers, so all numbers are in the range `[0,9]`. `8` is the missing number in the range since it does not appear in `nums`.
-
-### Constraints:
-
-- `n == nums.length`
-- `1 <= n <= 10^4`
-- `0 <= nums[i] <= n`
-- All the numbers of `nums` are unique.
-
-## Approach
-
-```mermaid
-flowchart TD
-  S(["missingNumber(nums)"]) --> I["numSet = Set(nums), expectedCount = n + 1"]
-  I --> L{"more i in 0..expectedCount-1?"}
-  L -- yes --> Q{"numSet has i?"}
-  Q -- no --> R(["return i"])
-  Q -- yes --> L
-  L -- no --> E(["return -1"])
-```
-
-## Solution
-
-```js
-/**
- * @param {number[]} nums
- * @return {number}
- */
-var missingNumber = function(nums) {
-  const numSet = new Set(nums);
-  const expectedCount = nums.length + 1;
-
-  for (let i = 0; i < expectedCount; i++){
-    if(!numSet.has(i)){
-      return i;
-    }
-  }
-  return -1;
-};
-```
-
-## Explanation
-
-<YouTube id="WnPLSRLSANE" title="Missing Number - Blind 75 - Leetcode 268 - Python" />

apps/docs/content/array/271-encode-and-decode-strings.mdx

@@ -1,73 +0,0 @@
----
-title: '271. Encode and Decode Strings'
-description: Design an algorithm to encode a list of strings to a string. The encoded string is then sent over the network and is decoded back to the original list of strings
-sidebar:
-  label: 'Encode and Decode Strings'
-  badge: 'Medium'
----
-
-<Badge variant="accent">Array</Badge>
-
-::::warning
-Could you write a generalized algorithm to work on any possible set of characters?
-::::
-
-### Example 1:
-- Input: `dummy_input = ["Hello","World"]`
-- Output: `["Hello","World"]`
-- Explanation: Machine `1`: Codec encoder = new Codec(); String msg = encoder.encode(strs); Machine `1` ---msg---> Machine `2` Machine `2`: Codec decoder = new Codec(); `String[] strs` = decoder.decode(msg);
-
-### Example 2:
-- Input: `dummy_input = [""]`
-- Output: `[""]`
-
-### Constraints:
-
-- `1 <= strs.length <= 200`
-- `0 <= strs[i].length <= 200`
-- `strs[i]` contains any possible characters out of 256 valid ASCII characters.
-
-## Approach
-
-::::warning
-The diagram traces the code below literally. That code does not solve the problem: both `encode` and `decode` have only a docstring for a body, so each returns `None` and `codec.decode(codec.encode(strs))` yields `None` instead of `strs`.
-::::
-
-```mermaid
-flowchart TD
-  subgraph state["state — Codec holds no fields"]
-    X["Codec() — nothing is stored between encode and decode"]
-  end
-  subgraph encode["encode(strs)"]
-    E1["docstring only — no statement runs"] --> E2(["return None"])
-  end
-  subgraph decode["decode(s)"]
-    D1["docstring only — no statement runs"] --> D2(["return None"])
-  end
-  state --> encode
-  state --> decode
-```
-
-## Solution
-
-```py
-class Codec:
-    def encode(self, strs: List[str]) -> str:
-        """Encodes a list of strings to a single string.
-        """
-        
-
-    def decode(self, s: str) -> List[str]:
-        """Decodes a single string to a list of strings.
-        """
-        
-
-
-# Your Codec object will be instantiated and called as such:
-# codec = Codec()
-# codec.decode(codec.encode(strs))
-```
-
-## Explanation
-
-<YouTube id="B1k_sxOSgv8" title="Encode and Decode Strings - Leetcode 271 - Python" />

apps/docs/content/array/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Array", order: 0 });

apps/docs/content/binary-search-tree/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Binary Search Tree", order: 13 });

apps/docs/content/binary-search/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Binary Search", order: 5 });

apps/docs/content/graph-bfs/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Graph BFS", order: 17 });

apps/docs/content/graph-dfs/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Graph DFS", order: 16 });

apps/docs/content/hash-table/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Hash Table", order: 1 });

apps/docs/content/heap-priority-queue/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Heap / Priority Queue", order: 14 });

apps/docs/content/hybrid-structures/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Hybrid Structures", order: 9 });

apps/docs/content/index.mdx

@@ -1,11 +0,0 @@
----
-title: Overview
-description: Live SRS campaign dashboard — phases, ladder, review queue, gates, and recent attempts, fetched from the SRS Worker.
----
-
-<DependencySpine />
-
-Live view of the 56-day campaign. Everything below is fetched client-side
-from the SRS Worker, so it is always current — no rebuild required.
-
-<ProgressDashboard />

apps/docs/content/linked-list/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Linked List", order: 8 });

apps/docs/content/matrix-index-math/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Matrix Index Math", order: 10 });

apps/docs/content/monotonic-stack/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Monotonic Stack", order: 7 });

apps/docs/content/prefix-sum/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Prefix Sum", order: 2 });

apps/docs/content/sliding-window/index.mdx

@@ -1,104 +0,0 @@
----
-title: Sliding Window
-description: 'Sliding window is a specialized two-pointer family where the pointers define a contiguous interval and you maintain information about that entire interval as it moves.'
-hidden: true
----
-
-:::warning
-This is the family where invariants matter the most
-:::
-
-## What Makes Sliding Window Different?
-
-Many problems have two moving boundaries. That alone does not make them sliding window problems.
-
-A problem belongs to this family when:
-
-- the answer depends on the subarray or substring between left and right
-- you can update the window state incrementally as elements enter or leave
-- you maintain a condition that tells you whether the window is valid
-
-## What is an Invariant?
-
-
-An invariant is a statement that stays true before and after every iteration.
-
-For sliding window, the invariant often looks like one of these:
-
-- "the current window is valid"
-- "the current window contains no duplicates"
-- "the current window sum is at most the target"
-- "the frequency map matches the characters currently inside the window"
-
-The invariant gives the loop its structure:
-
-- expand the window by moving right
-- update the window state
-- if the invariant breaks, shrink from the left until it holds again
-- update the answer only when you know the invariant is satisfied
-
-
-## Why Invariants Matter
-
-Without an invariant, shrinking the window becomes arbitrary. You no longer know:
-
-- when the window is valid
-- when to update the answer
-- why the left pointer should stop moving
-- The invariant is the reason the algorithm is correct.
-
-## The Main Subtypes
-
-### 1. Fixed-size windows
-
-:::tip
-The window size never changes. The main task is updating the window state efficiently when one element enters and one leaves.
-:::
-
-![Sliding Window Fixed Size](../../public/sliding-window-fixed-size.svg)
-
-### 2. Flexible-size windows with a validity rule
-
-:::tip
-Here the window expands until invalid, then shrinks until valid again.
-:::
-
-![Flexible-size windows](../../public/sliding-window-flexible.svg)
-
-
-### 3. Frequency-tracking windows
-
-:::tip
-The difficulty comes from keeping the bookkeeping correct as characters enter and leave.
-:::
-
-![Frequency-tracking windows](../../public/sliding-window-frequency.svg)
-
-## How Sliding Window Differs From Other Two-Pointer Families
-
-Compare it with Container With Most Water:
-
-- In sliding window, the interval itself has meaning.
-- In container, the interval is just the remaining search space.
-
-Compare it with Remove Duplicates:
-
-- In sliding window, both pointers describe a live window.
-- In compaction, the left part of the array is already the answer prefix.
-
-## A Practical Template
-
-A common variable-size sliding window has this shape:
-
-1. Add the new rightmost element.
-2. Update the window state.
-3. While the invariant is broken, remove elements from the left.
-4. Once the invariant is restored, update the answer.
-
-The exact data structure changes from problem to problem, but the logic stays the same.
-
-As you work through this section, keep asking:
-
-:::warning
-What invariant does my window maintain, and at what moment is it safe to update the answer?
-:::

apps/docs/content/sliding-window/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Sliding Window", order: 4 });

apps/docs/content/stack/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Stack", order: 6 });

apps/docs/content/todo.md

@@ -1,181 +0,0 @@
----
-hidden: true
----
-
-# todo — draining the review backlog
-
-every solution in `work/1` owes a blind re-solve at `work/3` and a second one at `work/7`. both buckets are empty, so 36 problems owe 72 re-solves and not one has been started. snapshot: `reviewqueues("2026-08-31")` from `apps/cli/work.ts` — what `bun run pick` shows — cross-checked against `/api/stats`.
-
-at 10 problems a day *including* the campaign's own load, 72 re-solves do not fit in one week: this week absorbs 38, the `+3` rung finishes **sat sep 5** (campaign day 20), the last `+7` clears **fri sep 18** (day 33), and normal srs resumes **sat sep 19** — see [when standard srs resumes](#when-standard-srs-resumes). saturday gates are deliberately left out of the count.
-
-## rules this plan follows
-
-- **≤ 10 problems a day, everything counted.** each day's new core set and the on-time reviews it earns are booked first; the backlog takes what is left — 7 slots on a light day, 2 on a heavy one.
-- **coverage before depth.** all 36 `+3` re-solves come first — one blind pass over everything — before any problem gets its `+7`.
-- **oldest first.** lc 387 and lc 1365 have been sitting 50 days.
-- **≥ 3 days between a problem's own `+3` and `+7`.** two re-solves in one day test nothing.
-- **sunday is not a slot.** `workingday()` never mints one; neither does this list.
-- **re-solve blind, then push.** `bun run pick` (tab cycles to the 3-day and 7-day sections) scaffolds straight into `work/3`/`work/7`. do not open `work/1` first. pushing the file is the log: `close-solved.yml` posts the bucket to `/admin/solved` and d1 moves the problem up the ladder.
-
-## this week
-
-### mon aug 31 — 3 new + 7 backlog = 10/10
-
-*topic 08 — linked list ([#10](https://github.com/prdlk/leetcode/issues/10), closed today)*
-
-| bucket | problem | difficulty | where | why |
-| --- | --- | --- | --- | --- |
-| `work/1` | [lc 21 · merge two sorted lists](https://github.com/prdlk/leetcode/issues/78) | easy | linked list | done today |
-| `work/1` | [lc 206 · reverse linked list](https://github.com/prdlk/leetcode/issues/77) | easy | linked list | done today |
-| `work/1` | [lc 141 · linked list cycle](https://github.com/prdlk/leetcode/issues/79) | easy | hash table | done today |
-| `work/3` | lc 387 · first unique character in a string | easy | hash table | 50d stale — first solved 2026-07-12 |
-| `work/3` | lc 1365 · how many numbers are smaller than the current number | easy | array | 50d stale — first solved 2026-07-12 |
-| `work/3` | lc 268 · missing number | easy | array | 14d stale — first solved 2026-08-17 |
-| `work/3` | lc 344 · reverse string | easy | two pointers | 14d stale — first solved 2026-08-17 |
-| `work/3` | lc 1426 · counting elements | easy | array | 14d stale — first solved 2026-08-17 |
-| `work/3` | lc 1832 · check if the sentence is pangram | easy | hash table | 14d stale — first solved 2026-08-17 |
-| `work/3` | [lc 15 · 3sum](https://github.com/prdlk/leetcode/issues/43) | medium | array | 13d stale — first solved 2026-08-18 |
-
-### tue sep 1 — 2 new + 8 backlog = 10/10
-
-*topic 09 — hybrid structures ([#11](https://github.com/prdlk/leetcode/issues/11))*
-
-| bucket | problem | difficulty | where | why |
-| --- | --- | --- | --- | --- |
-| `work/1` | [lc 146 · lru cache](https://github.com/prdlk/leetcode/issues/87) | medium | topic 09 — hybrid structures | new core problem |
-| `work/1` | [lc 2 · add two numbers](https://github.com/prdlk/leetcode/issues/88) | medium | topic 09 — hybrid structures | new core problem |
-| `work/3` | [lc 49 · group anagrams](https://github.com/prdlk/leetcode/issues/30) | medium | array | 13d stale — first solved 2026-08-18 |
-| `work/3` | [lc 125 · valid palindrome](https://github.com/prdlk/leetcode/issues/41) | easy | two pointers | 13d stale — first solved 2026-08-18 |
-| `work/3` | [lc 167 · two sum ii - input array is sorted](https://github.com/prdlk/leetcode/issues/42) | medium | array | 13d stale — first solved 2026-08-18 |
-| `work/3` | [lc 217 · contains duplicate](https://github.com/prdlk/leetcode/issues/27) | easy | array | 13d stale — first solved 2026-08-18 |
-| `work/3` | [lc 238 · product of array except self](https://github.com/prdlk/leetcode/issues/37) | medium | array | 13d stale — first solved 2026-08-18 |
-| `work/3` | [lc 242 · valid anagram](https://github.com/prdlk/leetcode/issues/28) | easy | hash table | 13d stale — first solved 2026-08-18 |
-| `work/3` | [lc 303 · range sum query - immutable](https://github.com/prdlk/leetcode/issues/36) | easy | array | 13d stale — first solved 2026-08-18 |
-| `work/3` | [lc 560 · subarray sum equals k](https://github.com/prdlk/leetcode/issues/38) | medium | array | 13d stale — first solved 2026-08-18 |
-
-### wed sep 2 — 3 new + 7 backlog = 10/10
-
-*topic 10 — matrix index math ([#12](https://github.com/prdlk/leetcode/issues/12))*
-
-| bucket | problem | difficulty | where | why |
-| --- | --- | --- | --- | --- |
-| `work/1` | [lc 48 · rotate image](https://github.com/prdlk/leetcode/issues/91) | medium | topic 10 — matrix index math | new core problem |
-| `work/1` | [lc 54 · spiral matrix](https://github.com/prdlk/leetcode/issues/92) | medium | topic 10 — matrix index math | new core problem |
-| `work/1` | [lc 73 · set matrix zeroes](https://github.com/prdlk/leetcode/issues/93) | medium | topic 10 — matrix index math | new core problem |
-| `work/3` | lc 1413 · minimum value to get positive step by step sum | easy | array | 13d stale — first solved 2026-08-18 |
-| `work/3` | lc 1480 · running sum of 1d array | easy | array | 13d stale — first solved 2026-08-18 |
-| `work/3` | [lc 33 · search in rotated sorted array](https://github.com/prdlk/leetcode/issues/60) | medium | array | 12d stale — first solved 2026-08-19 |
-| `work/3` | [lc 704 · binary search](https://github.com/prdlk/leetcode/issues/58) | easy | array | 12d stale — first solved 2026-08-19 |
-| `work/3` | [lc 875 · koko eating bananas](https://github.com/prdlk/leetcode/issues/59) | medium | array | 12d stale — first solved 2026-08-19 |
-| `work/3` | [lc 977 · squares of a sorted array](https://github.com/prdlk/leetcode/issues/46) | easy | array | 12d stale — first solved 2026-08-19 |
-| `work/3` | [lc 121 · best time to buy and sell stock](https://github.com/prdlk/leetcode/issues/50) | easy | array | 11d stale — first solved 2026-08-20 |
-
-### thu sep 3 — 3 new + 3 on-time reviews + 4 backlog = 10/10
-
-*topic 11 — tree dfs ([#13](https://github.com/prdlk/leetcode/issues/13))*
-
-| bucket | problem | difficulty | where | why |
-| --- | --- | --- | --- | --- |
-| `work/1` | [lc 226 · invert binary tree](https://github.com/prdlk/leetcode/issues/96) | easy | topic 11 — tree dfs | new core problem |
-| `work/1` | [lc 104 · maximum depth of binary tree](https://github.com/prdlk/leetcode/issues/97) | easy | topic 11 — tree dfs | new core problem |
-| `work/1` | [lc 236 · lowest common ancestor of a binary tree](https://github.com/prdlk/leetcode/issues/98) | medium | topic 11 — tree dfs | new core problem |
-| `work/3` | [lc 21 · merge two sorted lists](https://github.com/prdlk/leetcode/issues/78) | easy | linked list | on time — solved mon aug 31 |
-| `work/3` | [lc 206 · reverse linked list](https://github.com/prdlk/leetcode/issues/77) | easy | linked list | on time — solved mon aug 31 |
-| `work/3` | [lc 141 · linked list cycle](https://github.com/prdlk/leetcode/issues/79) | easy | hash table | on time — solved mon aug 31 |
-| `work/3` | [lc 1 · two sum](https://github.com/prdlk/leetcode/issues/29) | easy | array | 7d stale — first solved 2026-08-24 |
-| `work/3` | [lc 11 · container with most water](https://github.com/prdlk/leetcode/issues/44) | medium | array | 7d stale — first solved 2026-08-24 |
-| `work/3` | [lc 392 · is subsequence](https://github.com/prdlk/leetcode/issues/45) | easy | two pointers | 7d stale — first solved 2026-08-24 |
-| `work/3` | [lc 3 · longest substring without repeating characters](https://github.com/prdlk/leetcode/issues/51) | medium | hash table | 6d stale — first solved 2026-08-25 |
-
-### fri sep 4 — 3 new + 2 on-time reviews + 5 backlog = 10/10
-
-*topic 12 — tree bfs ([#14](https://github.com/prdlk/leetcode/issues/14))*
-
-| bucket | problem | difficulty | where | why |
-| --- | --- | --- | --- | --- |
-| `work/1` | [lc 102 · binary tree level order traversal](https://github.com/prdlk/leetcode/issues/106) | medium | topic 12 — tree bfs | new core problem |
-| `work/1` | [lc 199 · binary tree right side view](https://github.com/prdlk/leetcode/issues/107) | medium | topic 12 — tree bfs | new core problem |
-| `work/1` | [lc 1448 · count good nodes in binary tree](https://github.com/prdlk/leetcode/issues/108) | medium | topic 12 — tree bfs | new core problem |
-| `work/3` | [lc 146 · lru cache](https://github.com/prdlk/leetcode/issues/87) | medium | topic 09 — hybrid structures | on time — solved tue sep 1 |
-| `work/3` | [lc 2 · add two numbers](https://github.com/prdlk/leetcode/issues/88) | medium | topic 09 — hybrid structures | on time — solved tue sep 1 |
-| `work/3` | [lc 424 · longest repeating character replacement](https://github.com/prdlk/leetcode/issues/52) | medium | hash table | 6d stale — first solved 2026-08-25 |
-| `work/3` | [lc 567 · permutation in string](https://github.com/prdlk/leetcode/issues/53) | medium | hash table | 6d stale — first solved 2026-08-25 |
-| `work/3` | [lc 35 · search insert position](https://github.com/prdlk/leetcode/issues/63) | easy | array | 5d stale — first solved 2026-08-26 |
-| `work/3` | [lc 74 · search a 2d matrix](https://github.com/prdlk/leetcode/issues/61) | medium | array | 5d stale — first solved 2026-08-26 |
-| `work/3` | [lc 153 · find minimum in rotated sorted array](https://github.com/prdlk/leetcode/issues/62) | medium | array | 5d stale — first solved 2026-08-26 |
-
-### sat sep 5 — 3 on-time reviews + 7 backlog = 10/10
-
-*no new topic — saturday.*
-
-| bucket | problem | difficulty | where | why |
-| --- | --- | --- | --- | --- |
-| `work/3` | [lc 48 · rotate image](https://github.com/prdlk/leetcode/issues/91) | medium | topic 10 — matrix index math | on time — solved wed sep 2 |
-| `work/3` | [lc 54 · spiral matrix](https://github.com/prdlk/leetcode/issues/92) | medium | topic 10 — matrix index math | on time — solved wed sep 2 |
-| `work/3` | [lc 73 · set matrix zeroes](https://github.com/prdlk/leetcode/issues/93) | medium | topic 10 — matrix index math | on time — solved wed sep 2 |
-| `work/3` | [lc 20 · valid parentheses](https://github.com/prdlk/leetcode/issues/67) | easy | string | 4d stale — first solved 2026-08-27 |
-| `work/3` | [lc 150 · evaluate reverse polish notation](https://github.com/prdlk/leetcode/issues/69) | medium | array | 4d stale — first solved 2026-08-27 |
-| `work/3` | [lc 155 · min stack](https://github.com/prdlk/leetcode/issues/68) | medium | stack | 4d stale — first solved 2026-08-27 |
-| `work/3` | [lc 739 · daily temperatures](https://github.com/prdlk/leetcode/issues/72) | medium | array | 3d stale — first solved 2026-08-28 |
-| `work/3` | [lc 853 · car fleet](https://github.com/prdlk/leetcode/issues/73) | medium | array | 3d stale — first solved 2026-08-28 |
-| `work/7` | lc 387 · first unique character in a string | easy | hash table | `+3` was mon aug 31 |
-| `work/7` | lc 1365 · how many numbers are smaller than the current number | easy | array | `+3` was mon aug 31 |
-
-### sun sep 6 — rest day
-
-nothing. by design.
-
-## carry-over
-
-the 34 re-solves that do not fit this week, at the same cap and the same rules. booked = that day's new core set plus the on-time reviews it owes.
-
-| day | topic | booked | backlog re-solves | load |
-| --- | --- | --- | --- | --- |
-| **mon sep 7** | topic 13 — binary search tree | 10 | *none — the day is already full* | 10/10 |
-| **tue sep 8** | topic 14 — heap / priority queue | 7 | `work/7` — lc 268, lc 344, lc 1426 | 10/10 |
-| **wed sep 9** | topic 15 — trie | 5 | `work/7` — lc 1832, lc 15, lc 49, lc 125, lc 167 | 10/10 |
-| **thu sep 10** | topic 16 — graph dfs | 9 | `work/7` — lc 217 | 10/10 |
-| **fri sep 11** | topic 17 — graph bfs | 8 | `work/7` — lc 238, lc 242 | 10/10 |
-| **sat sep 12** | *none — saturday* | 2 | `work/7` — lc 303, lc 560, lc 1413, lc 1480, lc 33, lc 704, lc 875, lc 977 | 10/10 |
-| **mon sep 14** | topic 18 — topological sort | 10 | *none — the day is already full* | 10/10 |
-| **tue sep 15** | topic 19 — union-find | 5 | `work/7` — lc 121, lc 1, lc 11, lc 392, lc 3 | 10/10 |
-| **wed sep 16** | topic 20 — backtracking | 5 | `work/7` — lc 424, lc 567, lc 35, lc 74, lc 153 | 10/10 |
-| **thu sep 17** | topic 21 — 1-d dynamic programming | 8 | `work/7` — lc 20, lc 150 | 10/10 |
-| **fri sep 18** | topic 22 — multi-d / grid dp | 7 | `work/7` — lc 155, lc 739, lc 853 | 10/10 |
-
-## when standard srs resumes
-
-- **sat sep 5** (campaign day 20) — the `+3` rung is empty. every one of the 36 has been recalled blind once; nothing is unretrieved any more.
-- **fri sep 18** (campaign day 33) — the last backlog `+7` lands. `work/3` and `work/7` hold a file for all 36, so `reviewqueues()` owes nothing; the 28 that have a d1 row are `retired` on the ladder, and the 8 listed at the bottom of this file never had one.
-- **sat sep 19 onward — standard srs.** the only reviews left are the ones the campaign itself minted: solve a problem, its `+3` and `+7` come back on `workingday(solve + 3)` and `workingday(solve + 7)`, the digest asks for ≤ `review_cap` (3) a day, `levelreviews()` pushes any excess forward, and `bun run pick`'s 3-day and 7-day sections show only what is due. no dated plan needed after this — the digest *is* the plan.
-
-campaign-native load per working day once the backlog is gone, all of it inside the cap:
-
-| day | topic | new | `work/3` | `work/7` | load |
-| --- | --- | --- | --- | --- | --- |
-| **sat sep 19** | *review-only* | 0 | 3 | 0 | 3/10 |
-| **mon sep 21** | topic 23 — greedy | 3 | 5 | 2 | 10/10 |
-| **tue sep 22** | topic 24 — intervals | 3 | 1 | 2 | 6/10 |
-| **wed sep 23** | *review-only* | 0 | 0 | 3 | 3/10 |
-| **thu sep 24** | *review-only* | 0 | 3 | 3 | 6/10 |
-| **fri sep 25** | *review-only* | 0 | 3 | 3 | 6/10 |
-| **sat sep 26** | *review-only* | 0 | 0 | 0 | 0/10 |
-| **mon sep 28** | *review-only* | 0 | 0 | 3 | 3/10 |
-| **tue sep 29** | *review-only* | 0 | 0 | 3 | 3/10 |
-
-two things to watch there. **mon sep 21 is 10/10 on campaign load alone** — topic 23's core set, two `+7`s, and five of the six `+3`s that land there (thursday's three slide off sunday onto monday, friday's three land natively, and the sixth is pushed to tuesday exactly as `levelreviews()` would) — so one slipped day re-opens a backlog. and from **wed sep 30** the ladder runs dry: `apps/api/data/schedule.json` books its last topic tue sep 22, so the review-only weeks that close the campaign are drills, optional sets and the weekly gates, none of which this file counts.
-
-## not reviews
-
-three july scaffolds in `work/1` are still empty, so they owe no re-solve — they are unsolved problems, and `bun run pick` still lists them in its new-problem section:
-
-| problem | difficulty |
-| --- | --- |
-| [lc 347 · top k frequent elements](https://github.com/prdlk/leetcode/issues/31) | medium |
-| lc 451 · sort characters by frequency | medium |
-| lc 1636 · sort array by increasing frequency | easy |
-
-## what this plan exposes
-
-- **8 of the 36 have no problem issue** (387, 1365, 268, 344, 1426, 1832, 1413, 1480) — pre-campaign solves. the catalog reconcile never invents rows, so d1 does not know them and no digest can ever surface them. `bun run pick` is the only thing that will ask for these reviews.
-- **`/api/stats` reports a stage that does not exist**: `ladder: { new: 128, "+3": 3, "+7": 0, retired: 0, "+2": 30 }`. `+2` is not in `stages` (`apps/api/src/srs.ts`), so 30 rows sit on a pre-`0002` rung — which is why the digest queue plateaus at 32 due instead of tracking the tables above. that wants a migration, not a re-solve.

apps/docs/content/topological-sort/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Topological Sort", order: 18 });

apps/docs/content/tree-bfs/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Tree BFS", order: 12 });

apps/docs/content/tree-dfs/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Tree DFS", order: 11 });

apps/docs/content/trie/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Trie", order: 15 });

apps/docs/content/two-pointers/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Two Pointers", order: 3 });

apps/docs/content/union-find/meta.ts

@@ -1,3 +0,0 @@
-import { defineMeta } from "blume";
-
-export default defineMeta({ title: "Union-Find", order: 19 });

apps/docs/islands/DependencySpine.tsx

@@ -1,377 +0,0 @@
-/**
- * Dependency spine island — the "how the 24 topics build on each other" map
- * from the README, redrawn as data (nodes on a 7×6 grid, edges as SVG path
- * strings) so it is themed, zoomable, and clickable.
- *
- * - Wheel over the figure zooms about the cursor (trackpad pinch arrives as a
- *   ctrl+wheel and behaves the same); dragging pans; the toolbar and +/-/0
- *   keys do the same. Zooming OUT at the minimum scale is deliberately left
- *   to the page, so a reader scrolling past the map is never trapped in it.
- * - A node is a link to its topic. Routes come from Blume's own navigation
- *   endpoint at mount: the topic's landing page when the folder has an
- *   `index.mdx`, else its first solution page. A topic with no pages yet is
- *   drawn inert rather than linked to a 404, so the map stays honest as the
- *   campaign fills in without a rebuild of this file.
- *
- * Invariants: the first frame is the figure at HOME_ZOOM, centred, with no
- * links (server and client render identically); the geometry is the README
- * SVG's, to the pixel, so `viewBox` maths below is in that 1472×648 space.
- */
-import { useEffect, useRef, useState, type CSSProperties, type PointerEvent } from "react";
-import { withBase } from "blume/components/islands/base-path.ts";
-
-export const client = "visible";
-
-// ── figure data (README dependency-spine geometry) ───────────────
-
-const W = 1472;
-const H = 648;
-const MAX_ZOOM = 6;
-const NODE_W = 144;
-const NODE_H = 48;
-const COL_X = [56, 248, 472, 664, 888, 1080, 1272] as const;
-const ROW_Y = [72, 144, 216, 288, 416, 488] as const;
-
-type Kind = "entry" | "topic" | "focal";
-
-interface Topic {
-  n: number;
-  name: string;
-  sub?: string;
-  /** Sync's group slug for the README topic name — the docs folder. */
-  slug: string;
-  kind: Kind;
-  col: number;
-  row: number;
-}
-
-const TOPICS: Topic[] = [
-  { n: 5, name: "Binary Search", slug: "binary-search", kind: "entry", col: 0, row: 0 },
-  { n: 3, name: "Two Pointers", slug: "two-pointers", kind: "entry", col: 0, row: 1 },
-  { n: 4, name: "Sliding Window", slug: "sliding-window", kind: "topic", col: 1, row: 1 },
-  { n: 6, name: "Stack", slug: "stack", kind: "entry", col: 0, row: 2 },
-  { n: 7, name: "Monotonic Stack", slug: "monotonic-stack", kind: "topic", col: 1, row: 2 },
-  { n: 1, name: "Hash Lookup", slug: "hash-table", kind: "entry", col: 0, row: 3 },
-  { n: 2, name: "Prefix Sum", slug: "prefix-sum", kind: "topic", col: 1, row: 3 },
-  { n: 11, name: "Tree DFS", slug: "tree-dfs", kind: "focal", col: 2, row: 0 },
-  { n: 13, name: "Binary Search Tree", slug: "binary-search-tree", kind: "topic", col: 2, row: 1 },
-  { n: 14, name: "Heap", sub: "priority queue", slug: "heap-priority-queue", kind: "topic", col: 3, row: 1 },
-  { n: 15, name: "Trie", slug: "trie", kind: "topic", col: 3, row: 2 },
-  { n: 12, name: "Tree BFS", slug: "tree-bfs", kind: "entry", col: 2, row: 3 },
-  { n: 8, name: "Linked List", slug: "linked-list", kind: "entry", col: 2, row: 4 },
-  { n: 9, name: "Hybrid Structures", slug: "hybrid-structures", kind: "topic", col: 3, row: 4 },
-  { n: 10, name: "Matrix Index Math", slug: "matrix-index-math", kind: "topic", col: 2, row: 5 },
-  { n: 16, name: "Graph DFS", slug: "graph-dfs", kind: "topic", col: 4, row: 0 },
-  { n: 18, name: "Topological Sort", slug: "topological-sort", kind: "topic", col: 5, row: 0 },
-  { n: 19, name: "Union-Find", slug: "union-find", kind: "topic", col: 4, row: 1 },
-  { n: 20, name: "Backtracking", slug: "backtracking", kind: "topic", col: 5, row: 1 },
-  { n: 21, name: "1-D DP", sub: "dynamic programming", slug: "1-d-dynamic-programming", kind: "focal", col: 5, row: 2 },
-  { n: 22, name: "Multi-D / Grid DP", slug: "multi-d-grid-dp", kind: "topic", col: 6, row: 2 },
-  { n: 17, name: "Graph BFS", slug: "graph-bfs", kind: "topic", col: 4, row: 3 },
-  { n: 23, name: "Greedy", slug: "greedy", kind: "topic", col: 5, row: 3 },
-  { n: 24, name: "Intervals", slug: "intervals", kind: "topic", col: 6, row: 3 },
-];
-
-/** "builds on" arrows, source → target, in the figure's coordinate space. */
-const EDGES: [string, string][] = [
-  ["3 → 4", "M200,168 H248"],
-  ["6 → 7", "M200,240 H248"],
-  ["1 → 2", "M200,312 H248"],
-  ["8 → 9", "M616,440 H664"],
-  ["16 → 18", "M1032,96 H1080"],
-  ["21 → 22", "M1224,240 H1272"],
-  ["23 → 24", "M1224,312 H1272"],
-  ["11 → 16", "M616,84 H888"],
-  ["12 → 17", "M616,312 H888"],
-  ["11 → 13", "M544,120 V144"],
-  ["16 → 19", "M960,120 V144"],
-  ["18 → 20", "M1152,120 V144"],
-  ["20 → 21", "M1152,192 V216"],
-  ["21 → 23", "M1152,264 V288"],
-  ["5 → 13", "M200,96 H416 Q424,96 424,104 V160 Q424,168 432,168 H472"],
-  ["11 → 14", "M616,96 H640 Q648,96 648,104 V160 Q648,168 656,168 H664"],
-  ["11 → 15", "M616,108 H624 Q632,108 632,116 V232 Q632,240 640,240 H664"],
-  ["4 → 10", "M392,184 H432 Q440,184 440,192 V504 Q440,512 448,512 H472"],
-  ["1 → 9", "M128,336 V560 Q128,568 136,568 H728 Q736,568 736,560 V464"],
-];
-
-const ZONES: [string, number, number, number, number, number][] = [
-  // label, x, y, w, h, label plate width
-  ["PHASE I — LINEAR STRUCTURES", 40, 40, 368, 312, 168],
-  ["PHASE III — HIERARCHICAL", 456, 40, 368, 312, 152],
-  ["PHASE II — NODAL & GRID", 456, 384, 368, 168, 144],
-  ["PHASES IV–V — RELATIONAL & DECISION-SPACE", 872, 40, 560, 312, 264],
-];
-
-// ── theme ────────────────────────────────────────────────────────
-// Everything is a Blume token so the map follows the site's light/dark
-// scheme instead of the README's fixed black; tints go through color-mix.
-
-const fg = "var(--blume-foreground)";
-const muted = "var(--blume-muted-foreground)";
-const accent = "var(--blume-accent)";
-const tint = (color: string, pct: number) => `color-mix(in oklab, ${color} ${pct}%, transparent)`;
-
-const NODE_STYLE: Record<Kind, { fill: string; stroke: string; strokeWidth: number; tag: string }> = {
-  entry: { fill: tint(muted, 10), stroke: tint(muted, 70), strokeWidth: 1, tag: muted },
-  topic: { fill: tint(fg, 4), stroke: fg, strokeWidth: 1, tag: muted },
-  focal: { fill: tint(accent, 12), stroke: accent, strokeWidth: 1.2, tag: accent },
-};
-
-const mono: CSSProperties = { fontFamily: "var(--blume-font-mono, ui-monospace, monospace)" };
-const sans: CSSProperties = { fontFamily: "var(--blume-font-sans, system-ui, sans-serif)" };
-
-const toolButton: CSSProperties = {
-  width: "1.75rem",
-  height: "1.75rem",
-  border: "1px solid var(--blume-border)",
-  borderRadius: "9999px",
-  background: "var(--blume-background)",
-  color: muted,
-  font: "inherit",
-  lineHeight: 1,
-  cursor: "pointer",
-};
-
-// ── navigation lookup ────────────────────────────────────────────
-
-interface NavGroup {
-  kind: "group";
-  path: string;
-  route?: string | null;
-  children: unknown[];
-}
-
-const isGroup = (v: unknown): v is NavGroup =>
-  typeof v === "object" && v !== null && (v as NavGroup).kind === "group" &&
-  typeof (v as NavGroup).path === "string" && Array.isArray((v as NavGroup).children);
-
-/** The first page route under a sidebar entry, depth-first. */
-const firstRoute = (items: unknown[]): string | null => {
-  for (const item of items) {
-    if (typeof item !== "object" || item === null) continue;
-    const v = item as { route?: unknown; children?: unknown };
-    if (typeof v.route === "string") return v.route;
-    if (Array.isArray(v.children)) {
-      const inner = firstRoute(v.children);
-      if (inner) return inner;
-    }
-  }
-  return null;
-};
-
-/** folder path (`/tree-dfs`) → the route a node should open. */
-const topicRoutes = (nav: unknown): Record<string, string> => {
-  const out: Record<string, string> = {};
-  const sidebar = (nav as { sidebar?: unknown })?.sidebar;
-  if (!Array.isArray(sidebar)) return out;
-  for (const entry of sidebar) {
-    if (!isGroup(entry)) continue;
-    const route = entry.route ?? firstRoute(entry.children);
-    if (route) out[entry.path] = route;
-  }
-  return out;
-};
-
-// ── component ────────────────────────────────────────────────────
-
-interface ViewBox { x: number; y: number; w: number; h: number }
-/** The resting view — 1.6× on the centre so node labels read at the content width; 1× stays reachable by zooming out. */
-const HOME_ZOOM = 1.6;
-const HOME: ViewBox = { x: (W - W / HOME_ZOOM) / 2, y: (H - H / HOME_ZOOM) / 2, w: W / HOME_ZOOM, h: H / HOME_ZOOM };
-const clamp = (v: number, lo: number, hi: number) => Math.min(Math.max(v, lo), hi);
-
-export default function DependencySpine() {
-  const svgRef = useRef<SVGSVGElement>(null);
-  const [vb, setVbState] = useState<ViewBox>(HOME);
-  // The native wheel listener and back-to-back events read the latest view
-  // from the ref, which is written synchronously — state alone lags a render.
-  const vbRef = useRef(vb);
-  const setVb = (next: ViewBox) => {
-    vbRef.current = next;
-    setVbState(next);
-  };
-  const [routes, setRoutes] = useState<Record<string, string> | null>(null);
-  const drag = useRef<{ x: number; y: number; moved: boolean } | null>(null);
-
-  useEffect(() => {
-    let live = true;
-    fetch(withBase("/api/docs/navigation.json"))
-      .then((r) => (r.ok ? r.json() : Promise.reject(new Error(String(r.status)))))
-      .then((nav) => live && setRoutes(topicRoutes(nav)))
-      .catch(() => live && setRoutes({}));
-    return () => { live = false; };
-  }, []);
-
-  /** Zoom by `factor` (>1 in) about a client-space point; omitted = centre. */
-  const zoomAt = (factor: number, clientX?: number, clientY?: number) => {
-    const rect = svgRef.current?.getBoundingClientRect();
-    const cur = vbRef.current;
-    if (!rect) return;
-    const px = clientX === undefined ? cur.x + cur.w / 2 : cur.x + ((clientX - rect.left) / rect.width) * cur.w;
-    const py = clientY === undefined ? cur.y + cur.h / 2 : cur.y + ((clientY - rect.top) / rect.height) * cur.h;
-    const w = clamp(cur.w / factor, W / MAX_ZOOM, W);
-    const f = cur.w / w;
-    const h = H * (w / W);
-    setVb({ x: clamp(px - (px - cur.x) / f, 0, W - w), y: clamp(py - (py - cur.y) / f, 0, H - h), w, h });
-  };
-
-  // React registers `wheel` as passive, so preventDefault has to go native.
-  useEffect(() => {
-    const svg = svgRef.current;
-    if (!svg) return;
-    const onWheel = (e: WheelEvent) => {
-      if (e.deltaY > 0 && vbRef.current.w >= W) return; // fully zoomed out: let the page scroll
-      e.preventDefault();
-      zoomAt(Math.exp(-e.deltaY * 0.0015), e.clientX, e.clientY);
-    };
-    svg.addEventListener("wheel", onWheel, { passive: false });
-    return () => svg.removeEventListener("wheel", onWheel);
-  }, []);
-
-  const onPointerDown = (e: PointerEvent<SVGSVGElement>) => {
-    if (e.button !== 0) return;
-    drag.current = { x: e.clientX, y: e.clientY, moved: false };
-  };
-  const onPointerMove = (e: PointerEvent<SVGSVGElement>) => {
-    const d = drag.current;
-    const rect = svgRef.current?.getBoundingClientRect();
-    if (!d || !rect) return;
-    const dx = e.clientX - d.x;
-    const dy = e.clientY - d.y;
-    if (!d.moved && Math.hypot(dx, dy) < 4) return; // a click, not a drag
-    if (!d.moved) {
-      // Capture only once it is a drag: capturing on pointerdown would retarget
-      // pointerup (and so the click) to the <svg>, and a node's link would never fire.
-      d.moved = true;
-      e.currentTarget.setPointerCapture(e.pointerId);
-    }
-    d.x = e.clientX;
-    d.y = e.clientY;
-    const cur = vbRef.current;
-    const scale = cur.w / rect.width;
-    setVb({ ...cur, x: clamp(cur.x - dx * scale, 0, W - cur.w), y: clamp(cur.y - dy * scale, 0, H - cur.h) });
-  };
-  const onPointerUp = (e: PointerEvent<SVGSVGElement>) => {
-    if (e.currentTarget.hasPointerCapture(e.pointerId)) e.currentTarget.releasePointerCapture(e.pointerId);
-    // Cleared on the next tick so a node's click handler can still see `moved`.
-    setTimeout(() => { drag.current = null; }, 0);
-  };
-
-  const zoom = W / vb.w;
-  const atHome = vb.x === HOME.x && vb.y === HOME.y && vb.w === HOME.w;
-
-  return (
-    <figure
-      className="not-prose"
-      style={{ margin: "1.5rem 0", border: "1px solid var(--blume-border)", borderRadius: "var(--blume-radius)", background: tint("var(--blume-muted)", 30), overflow: "hidden" }}
-      aria-label="Dependency spine: how the 24 topics build on each other"
-      onKeyDown={(e) => {
-        if (e.key === "+" || e.key === "=") zoomAt(1.25);
-        else if (e.key === "-") zoomAt(0.8);
-        else if (e.key === "0") setVb(HOME);
-        else return;
-        e.preventDefault();
-      }}
-      tabIndex={0}
-    >
-      <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between", gap: "0.75rem", padding: "0.5rem 0.75rem", borderBottom: "1px solid var(--blume-border)" }}>
-        <span style={{ ...mono, fontSize: "0.7rem", letterSpacing: "0.12em", textTransform: "uppercase", color: muted, whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" }}>
-          scroll to zoom · drag to pan · click a topic
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: "0.35rem", flexShrink: 0 }}>
-          <span style={{ ...mono, fontSize: "0.7rem", color: muted, minWidth: "4ch", textAlign: "right", whiteSpace: "nowrap" }}>{zoom.toFixed(1)}×</span>
-          <button type="button" style={toolButton} aria-label="Zoom out" onClick={() => zoomAt(0.8)} disabled={zoom <= 1.001}>−</button>
-          <button type="button" style={toolButton} aria-label="Zoom in" onClick={() => zoomAt(1.25)} disabled={zoom >= MAX_ZOOM - 0.001}>+</button>
-          <button type="button" style={toolButton} aria-label="Reset zoom" onClick={() => setVb(HOME)} disabled={atHome}>⟲</button>
-        </span>
-      </div>
-
-      <svg
-        ref={svgRef}
-        viewBox={`${vb.x} ${vb.y} ${vb.w} ${vb.h}`}
-        xmlns="http://www.w3.org/2000/svg"
-        role="img"
-        aria-labelledby="dependency-spine-title dependency-spine-desc"
-        style={{ display: "block", width: "100%", height: "auto", touchAction: "none", cursor: drag.current?.moved ? "grabbing" : zoom > 1.001 ? "grab" : "default", userSelect: "none" }}
-        onPointerDown={onPointerDown}
-        onPointerMove={onPointerMove}
-        onPointerUp={onPointerUp}
-        onPointerCancel={onPointerUp}
-        onDoubleClick={() => setVb(HOME)}
-      >
-        <title id="dependency-spine-title">LeetCode topic dependency spine</title>
-        <desc id="dependency-spine-desc">
-          Dependency graph of 24 LeetCode study topics across five phases, showing which topics build on which, with Tree DFS and 1-D dynamic programming as the two central hubs.
-        </desc>
-        <defs>
-          <marker id="spine-arrow" markerWidth="8" markerHeight="6" refX="7" refY="3" orient="auto">
-            <polygon points="0 0, 8 3, 0 6" style={{ fill: muted }} />
-          </marker>
-        </defs>
-
-        {ZONES.map(([label, x, y, w, h, plate]) => (
-          <g key={label}>
-            <rect x={x} y={y} width={w} height={h} rx={8} style={{ fill: tint(fg, 2), stroke: tint(fg, 10), strokeWidth: 0.8 }} />
-            <rect x={x + 16} y={y + 4} width={plate} height={12} rx={2} style={{ fill: "var(--blume-background)" }} />
-            <text x={x + 20} y={y + 13} fontSize={7} letterSpacing="0.14em" style={{ ...mono, fill: tint(fg, 40) }}>{label}</text>
-          </g>
-        ))}
-
-        {EDGES.map(([id, d]) => (
-          <path key={id} d={d} fill="none" strokeWidth={1} markerEnd="url(#spine-arrow)" style={{ stroke: muted }}>
-            <title>{id}</title>
-          </path>
-        ))}
-
-        {TOPICS.map((t) => {
-          const x = COL_X[t.col]!;
-          const y = ROW_Y[t.row]!;
-          const s = NODE_STYLE[t.kind];
-          const route = routes?.[`/${t.slug}`];
-          const tag = String(t.n).padStart(2, "0");
-          const body = (
-            <>
-              <title>{route ? `${tag} · ${t.name} — open topic` : `${tag} · ${t.name} — no pages yet`}</title>
-              <rect x={x} y={y} width={NODE_W} height={NODE_H} rx={6} style={{ fill: "var(--blume-background)" }} />
-              <rect x={x} y={y} width={NODE_W} height={NODE_H} rx={6} style={{ fill: s.fill, stroke: s.stroke, strokeWidth: s.strokeWidth }} />
-              <rect x={x + 8} y={y + 6} width={24} height={12} rx={2} fill="transparent" style={{ stroke: tint(s.tag, 50), strokeWidth: 0.8 }} />
-              <text x={x + 20} y={y + 15} fontSize={7} textAnchor="middle" letterSpacing="0.08em" style={{ ...mono, fill: s.tag }}>{tag}</text>
-              <text x={x + NODE_W / 2} y={y + (t.sub ? 26 : 32)} fontSize={12} fontWeight={600} textAnchor="middle" style={{ ...sans, fill: fg }}>{t.name}</text>
-              {t.sub && <text x={x + NODE_W / 2} y={y + 40} fontSize={9} textAnchor="middle" style={{ ...mono, fill: muted }}>{t.sub}</text>}
-            </>
-          );
-          return route ? (
-            <a
-              key={t.n}
-              href={withBase(route)}
-              className="spine-node"
-              style={{ cursor: "pointer", textDecoration: "none" }}
-              onClick={(e) => { if (drag.current?.moved) e.preventDefault(); }}
-            >
-              {body}
-            </a>
-          ) : (
-            <g key={t.n} style={{ opacity: routes ? 0.55 : 1 }} aria-disabled="true">{body}</g>
-          );
-        })}
-
-        <line x1={40} y1={600} x2={1432} y2={600} strokeWidth={0.8} style={{ stroke: tint(fg, 10) }} />
-        <text x={40} y={620} fontSize={8} letterSpacing="0.14em" style={{ ...mono, fill: muted }}>LEGEND</text>
-        <rect x={160} y={608} width={20} height={12} rx={2} style={{ fill: NODE_STYLE.entry.fill, stroke: NODE_STYLE.entry.stroke, strokeWidth: 1 }} />
-        <text x={188} y={618} fontSize={8} letterSpacing="0.06em" style={{ ...mono, fill: muted }}>ENTRY — NO PREREQS</text>
-        <rect x={360} y={608} width={20} height={12} rx={2} style={{ fill: NODE_STYLE.topic.fill, stroke: NODE_STYLE.topic.stroke, strokeWidth: 1 }} />
-        <text x={388} y={618} fontSize={8} letterSpacing="0.06em" style={{ ...mono, fill: muted }}>TOPIC</text>
-        <rect x={480} y={608} width={20} height={12} rx={2} style={{ fill: NODE_STYLE.focal.fill, stroke: NODE_STYLE.focal.stroke, strokeWidth: 1.2 }} />
-        <text x={508} y={618} fontSize={8} letterSpacing="0.06em" style={{ ...mono, fill: muted }}>FOCAL HUB</text>
-        <line x1={624} y1={614} x2={656} y2={614} strokeWidth={1} markerEnd="url(#spine-arrow)" style={{ stroke: muted }} />
-        <text x={668} y={618} fontSize={8} letterSpacing="0.06em" style={{ ...mono, fill: muted }}>BUILDS ON</text>
-        <rect x={792} y={608} width={20} height={12} rx={2} style={{ fill: tint(fg, 2), stroke: tint(fg, 10), strokeWidth: 0.8 }} />
-        <text x={820} y={618} fontSize={8} letterSpacing="0.06em" style={{ ...mono, fill: muted }}>PHASE ZONE</text>
-        <rect x={1000} y={608} width={20} height={12} rx={2} style={{ fill: NODE_STYLE.topic.fill, stroke: NODE_STYLE.topic.stroke, strokeWidth: 1, opacity: 0.55 }} />
-        <text x={1028} y={618} fontSize={8} letterSpacing="0.06em" style={{ ...mono, fill: muted }}>NO PAGES YET</text>
-      </svg>
-      <style>{`.spine-node:hover rect:nth-of-type(2), .spine-node:focus-visible rect:nth-of-type(2) { stroke: ${accent}; stroke-width: 1.6; } .spine-node:focus { outline: none; }`}</style>
-    </figure>
-  );
-}

apps/docs/islands/ProgressDashboard.tsx

@@ -1,428 +0,0 @@
-/**
- * Progress dashboard island — the expanded, always-current version of the
- * daily email footer. Rendered on /progress; fetches campaign state from the
- * SRS Worker at page load, entirely client-side, so `blume build` never
- * depends on the API being up. API_BASE is a placeholder stamped in after the
- * Worker deploys — do not inline it anywhere else.
- *
- * Invariants: the component never throws on malformed API data (a shape guard
- * downgrades to the error state), and the first frame is always the loading
- * state so server and client render identically.
- */
-import { useEffect, useState, type CSSProperties } from "react";
-
-export const client = "load";
-
-const API_BASE = "https://srs-api.prdlk.workers.dev";
-
-// ── /api/stats response shape ────────────────────────────────────
-
-// Mirrors STAGES in apps/api/src/srs.ts — the ladder rungs, in order. The
-// Worker ships every rung in `ladder`, zeros included.
-const STAGES = ["new", "+3", "+7", "retired"] as const;
-
-type Stage = (typeof STAGES)[number];
-
-interface Stats {
-  generated: string;
-  campaign: { day: number; week: number; start: string; days: number };
-  phases: {
-    milestone: number;
-    name: string;
-    core_done: number;
-    core_total: number;
-    optional_done: number;
-    optional_total: number;
-    deferred_done: number;
-    deferred_total: number;
-  }[];
-  ladder: Record<Stage, number>;
-  /** week is the 1-based campaign week — the Worker converts from ISO. */
-  gates: {
-    week: number;
-    issue: number | null;
-    pass_rate: number | null;
-    closed_on: string | null;
-  }[];
-  streak: number;
-  queue: { date: string; due: number }[];
-  /** Every campaign day, zeros included; this page reads only the tail. */
-  heat: { date: string; attempts: number; passes: number }[];
-}
-
-function isStats(value: unknown): value is Stats {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value as Record<string, unknown>;
-  return (
-    typeof v.campaign === "object" &&
-    v.campaign !== null &&
-    typeof v.ladder === "object" &&
-    v.ladder !== null &&
-    Array.isArray(v.phases) &&
-    Array.isArray(v.gates) &&
-    Array.isArray(v.queue) &&
-    Array.isArray(v.heat) &&
-    typeof v.streak === "number"
-  );
-}
-
-// ── formatting ───────────────────────────────────────────────────
-
-/** Legacy gates stored integer percent; the Worker may emit a 0–1 fraction. */
-function percent(rate: number): string {
-  return `${Math.round(rate <= 1 ? rate * 100 : rate)}%`;
-}
-
-/** "2026-08-24" → "Mon 24" without timezone drift. */
-function dayLabel(iso: string): string {
-  const d = new Date(`${iso}T00:00:00`);
-  const weekday = d.toLocaleDateString("en-US", { weekday: "short" });
-  return `${weekday} ${iso.slice(8)}`;
-}
-
-// ── shared styles ────────────────────────────────────────────────
-// Theme tokens only, with two deliberate exceptions: the phase-bar sets get
-// fixed hues (accent-blue core, yellow optional, red deferred — they must be
-// distinguishable, not shades of one colour), and the last-7-days heatmap
-// reuses the GREENS ramp from apps/api/src/charts.ts so the page matches the
-// README/email heatmaps (level 0 stays a theme token so light mode works).
-
-const card: CSSProperties = {
-  border: "1px solid var(--blume-border)",
-  borderRadius: "var(--blume-radius)",
-  padding: "0.75rem 1rem",
-  marginBottom: "1rem",
-};
-
-const muted: CSSProperties = {
-  color: "var(--blume-muted-foreground)",
-  fontSize: "0.85em",
-};
-
-const heading: CSSProperties = {
-  fontWeight: 600,
-  marginBottom: "0.5rem",
-};
-
-function Bar({ done, total }: { done: number; total: number }) {
-  const ratio = total > 0 ? Math.min(done / total, 1) : 0;
-  return (
-    <span
-      style={{
-        display: "inline-block",
-        width: "10rem",
-        maxWidth: "40vw",
-        height: "0.5rem",
-        borderRadius: "var(--blume-radius)",
-        background: "var(--blume-muted)",
-        verticalAlign: "middle",
-        overflow: "hidden",
-      }}
-    >
-      <span
-        style={{
-          display: "block",
-          width: `${ratio * 100}%`,
-          height: "100%",
-          background: "var(--blume-accent)",
-        }}
-      />
-    </span>
-  );
-}
-
-// ── sections ─────────────────────────────────────────────────────
-
-function Header({ stats }: { stats: Stats }) {
-  const { campaign, streak } = stats;
-  return (
-    <div style={{ ...card, display: "flex", gap: "1.5rem", flexWrap: "wrap" }}>
-      <span>
-        <strong>
-          Day {campaign.day}/{campaign.days}
-        </strong>
-      </span>
-      <span>Week {campaign.week}</span>
-      <span>
-        Streak: <strong>{streak}</strong> day{streak === 1 ? "" : "s"}
-      </span>
-      <span style={muted}>started {campaign.start}</span>
-    </div>
-  );
-}
-
-// One stacked bar per phase: solved core / optional / deferred segments over
-// a muted track sized by the phase's total problem count, so both phase size
-// and progress read at a glance.
-const SETS = [
-  ["core", "var(--blume-accent)"],
-  ["optional", "#d29922"],
-  ["deferred", "#e5534b"],
-] as const;
-
-function Phases({ stats }: { stats: Stats }) {
-  const maxTotal = Math.max(
-    1,
-    ...stats.phases.map((p) => p.core_total + p.optional_total + p.deferred_total),
-  );
-  return (
-    <div style={card}>
-      <div style={heading}>Phases</div>
-      <div style={{ display: "flex", gap: "1rem", flexWrap: "wrap", marginBottom: "0.6rem" }}>
-        {SETS.map(([set, color]) => (
-          <span key={set} style={muted}>
-            <span
-              style={{
-                display: "inline-block",
-                width: "0.65rem",
-                height: "0.65rem",
-                borderRadius: "2px",
-                background: color,
-                marginRight: "0.35rem",
-              }}
-            />
-            {set}
-          </span>
-        ))}
-      </div>
-      {stats.phases.map((p) => {
-        const total = p.core_total + p.optional_total + p.deferred_total;
-        const done = p.core_done + p.optional_done + p.deferred_done;
-        return (
-          <div
-            key={p.milestone}
-            title={`core ${p.core_done}/${p.core_total} · optional ${p.optional_done}/${p.optional_total} · deferred ${p.deferred_done}/${p.deferred_total}`}
-            style={{ display: "flex", alignItems: "center", gap: "0.75rem", padding: "0.25rem 0" }}
-          >
-            <span style={{ width: "9.5rem", flexShrink: 0 }}>{p.name}</span>
-            <span style={{ flex: 1 }}>
-              <span
-                style={{
-                  display: "flex",
-                  width: `${(total / maxTotal) * 100}%`,
-                  height: "0.65rem",
-                  borderRadius: "var(--blume-radius)",
-                  background: "var(--blume-muted)",
-                  overflow: "hidden",
-                }}
-              >
-                {SETS.map(([set, color]) => {
-                  const solved = p[`${set}_done`];
-                  return solved > 0 ? (
-                    <span
-                      key={set}
-                      style={{ width: `${(solved / total) * 100}%`, background: color }}
-                    />
-                  ) : null;
-                })}
-              </span>
-            </span>
-            <span style={{ ...muted, width: "3.5rem", textAlign: "right", flexShrink: 0 }}>
-              {done}/{total}
-            </span>
-          </div>
-        );
-      })}
-    </div>
-  );
-}
-
-function Ladder({ stats }: { stats: Stats }) {
-  return (
-    <div style={card}>
-      <div style={heading}>SRS ladder</div>
-      <div style={{ display: "flex", gap: "0.5rem", flexWrap: "wrap" }}>
-        {STAGES.map((stage) => (
-          <span
-            key={stage}
-            style={{
-              background: "var(--blume-muted)",
-              borderRadius: "var(--blume-radius)",
-              padding: "0.35rem 0.75rem",
-            }}
-          >
-            <span style={muted}>{stage}</span>{" "}
-            <strong>{stats.ladder[stage] ?? 0}</strong>
-          </span>
-        ))}
-      </div>
-    </div>
-  );
-}
-
-function Queue({ stats }: { stats: Stats }) {
-  const max = Math.max(1, ...stats.queue.map((q) => q.due));
-  return (
-    <div style={card}>
-      <div style={heading}>Review queue — next 14 days</div>
-      <table style={{ borderCollapse: "collapse" }}>
-        <tbody>
-          {stats.queue.map((q) => (
-            <tr key={q.date}>
-              <td style={{ ...muted, padding: "0.1rem 1rem 0.1rem 0" }}>
-                {dayLabel(q.date)}
-              </td>
-              <td style={{ padding: "0.1rem 0.75rem 0.1rem 0" }}>
-                <Bar done={q.due} total={max} />
-              </td>
-              <td>{q.due}</td>
-            </tr>
-          ))}
-        </tbody>
-      </table>
-    </div>
-  );
-}
-
-function Gates({ stats }: { stats: Stats }) {
-  return (
-    <div style={card}>
-      <div style={heading}>Gate log</div>
-      {stats.gates.length === 0 ? (
-        <span style={muted}>No gates yet — the first weekly review opens Saturday night.</span>
-      ) : (
-        stats.gates.map((g) => (
-          <div
-            key={g.week}
-            style={{
-              display: "flex",
-              gap: "0.75rem",
-              alignItems: "baseline",
-              flexWrap: "wrap",
-              padding: "0.15rem 0",
-            }}
-          >
-            <span style={{ width: "4.5rem", flexShrink: 0 }}>Week {g.week}</span>
-            {g.issue === null ? (
-              <span style={muted}>no review issue</span>
-            ) : (
-              <a
-                href={`https://github.com/prdlk/leetcode/issues/${g.issue}`}
-                target="_blank"
-                rel="noreferrer"
-              >
-                #{g.issue}
-              </a>
-            )}
-            {g.pass_rate === null ? (
-              <span style={muted}>in progress</span>
-            ) : (
-              <span>
-                {percent(g.pass_rate)} passed
-                {g.closed_on && <span style={muted}> · closed {g.closed_on}</span>}
-              </span>
-            )}
-          </div>
-        ))
-      )}
-      <div style={{ ...muted, marginTop: "0.4rem" }}>
-        One gate per campaign week — scored when its review issue closes.
-      </div>
-    </div>
-  );
-}
-
-// GREENS ramp from apps/api/src/charts.ts; level 0 swapped for the theme's
-// muted token so an empty day looks right in both colour schemes.
-const GREENS = [
-  "var(--blume-muted)",
-  "#0e4429",
-  "#006d32",
-  "#26a641",
-  "#39d353",
-];
-
-function Recent({ stats }: { stats: Stats }) {
-  // heat spans the whole campaign, future days and all. The window wanted here
-  // is the seven days ending today, and campaign.day is that day, 1-based.
-  const week = stats.heat.slice(Math.max(0, stats.campaign.day - 7), stats.campaign.day);
-  return (
-    <div style={card}>
-      <div style={heading}>Last 7 days</div>
-      <div style={{ display: "flex", gap: "0.4rem", flexWrap: "wrap" }}>
-        {week.map((r) => (
-          <span
-            key={r.date}
-            title={`${r.date}: ${r.passes}/${r.attempts} passed`}
-            style={{ textAlign: "center" }}
-          >
-            <span
-              style={{
-                display: "block",
-                width: "2.6rem",
-                height: "2rem",
-                borderRadius: "var(--blume-radius)",
-                background: GREENS[Math.min(r.attempts, 4)],
-              }}
-            />
-            <span style={{ ...muted, display: "block", marginTop: "0.25rem", fontSize: "0.75em" }}>
-              {dayLabel(r.date)}
-            </span>
-          </span>
-        ))}
-      </div>
-      <div style={{ ...muted, marginTop: "0.5rem", display: "flex", alignItems: "center", gap: "0.25rem" }}>
-        <span>Less</span>
-        {GREENS.map((color) => (
-          <span
-            key={color}
-            style={{ display: "inline-block", width: "0.65rem", height: "0.65rem", borderRadius: "2px", background: color }}
-          />
-        ))}
-        <span>More · colour = attempts, hover for passes</span>
-      </div>
-    </div>
-  );
-}
-
-// ── dashboard ────────────────────────────────────────────────────
-
-type Load =
-  | { phase: "loading" }
-  | { phase: "error" }
-  | { phase: "ready"; stats: Stats };
-
-export default function ProgressDashboard() {
-  const [load, setLoad] = useState<Load>({ phase: "loading" });
-
-  useEffect(() => {
-    const controller = new AbortController();
-    fetch(`${API_BASE}/api/stats`, { signal: controller.signal })
-      .then((res) => {
-        if (!res.ok) throw new Error(`HTTP ${res.status}`);
-        return res.json();
-      })
-      .then((body: unknown) => {
-        setLoad(isStats(body) ? { phase: "ready", stats: body } : { phase: "error" });
-      })
-      .catch(() => {
-        if (!controller.signal.aborted) setLoad({ phase: "error" });
-      });
-    return () => controller.abort();
-  }, []);
-
-  if (load.phase === "loading") {
-    return <p style={muted}>Loading progress…</p>;
-  }
-  if (load.phase === "error") {
-    return (
-      <p style={muted}>
-        API unreachable — stats are served live from the SRS Worker and it did
-        not respond.
-      </p>
-    );
-  }
-
-  const { stats } = load;
-  return (
-    <div>
-      <Header stats={stats} />
-      <Phases stats={stats} />
-      <Ladder stats={stats} />
-      <Queue stats={stats} />
-      <Gates stats={stats} />
-      <Recent stats={stats} />
-      <p style={muted}>Generated {stats.generated}</p>
-    </div>
-  );
-}

apps/docs/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "docs",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "dev": "blume dev",
-    "build": "blume build",
-    "doctor": "blume doctor"
-  },
-  "dependencies": {
-    "blume": "^1.7.3",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8"
-  }
-}

apps/docs/public/sliding-window-fixed-size.svg

@@ -1,66 +0,0 @@
-<svg viewBox="0 0 800 450" xmlns="http://www.w3.org/2000/svg">
-  <!-- Background (REQUIRED) -->
-  <rect width="800" height="450" fill="#f8f9fa" rx="10"/>
-
-  <!-- Title and Subtitle -->
-  <text x="400" y="45" font-family="Arial, sans-serif" font-size="26" font-weight="bold" fill="#2c3e50" text-anchor="middle">Sliding Window: Fixed Size</text>
-  <text x="400" y="75" font-family="Arial, sans-serif" font-size="16" fill="#7f8c8d" text-anchor="middle">Window of size K=3 moving through the array.</text>
-
-  <!-- Step 1: Initial window -->
-  <g transform="translate(150, 130)">
-    <text x="0" y="-20" font-family="Arial, sans-serif" font-size="18" font-weight="bold" fill="#2c3e50">1. Current window (Sum = 10)</text>
-    
-    <!-- Array -->
-    <g transform="translate(0, 20)">
-      <rect x="0" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="30" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#1b5e20">2</text>
-      
-      <rect x="70" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="100" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#1b5e20">3</text>
-      
-      <rect x="140" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="170" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#1b5e20">5</text>
-
-      <rect x="210" y="0" width="60" height="50" fill="#ffffff" stroke="#dee2e6" stroke-width="2" rx="3"/>
-      <text x="240" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">1</text>
-
-      <rect x="280" y="0" width="60" height="50" fill="#ffffff" stroke="#dee2e6" stroke-width="2" rx="3"/>
-      <text x="310" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">8</text>
-
-      <!-- Bracket -->
-      <path d="M 0,60 L 0,70 L 200,70 L 200,60" fill="none" stroke="#10b981" stroke-width="2"/>
-    </g>
-  </g>
-
-  <!-- Transition -->
-  <g transform="translate(400, 260)">
-    <path d="M 0,0 L 0,30" stroke="#dee2e6" stroke-width="2" fill="none"/>
-    <text x="10" y="20" font-family="Arial, sans-serif" font-size="14" font-style="italic" fill="#7f8c8d">Slide window: -2, +1</text>
-  </g>
-
-  <!-- Step 2: Slid window -->
-  <g transform="translate(150, 340)">
-    <text x="0" y="-20" font-family="Arial, sans-serif" font-size="18" font-weight="bold" fill="#2c3e50">2. Next window (Sum = 9)</text>
-    
-    <!-- Array -->
-    <g transform="translate(0, 20)">
-      <rect x="0" y="0" width="60" height="50" fill="#e5e7eb" stroke="#94a3b8" stroke-width="2" rx="3"/>
-      <text x="30" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#94a3b8">2</text>
-      
-      <rect x="70" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="100" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#1b5e20">3</text>
-      
-      <rect x="140" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="170" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#1b5e20">5</text>
-
-      <rect x="210" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="240" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#1b5e20">1</text>
-
-      <rect x="280" y="0" width="60" height="50" fill="#ffffff" stroke="#dee2e6" stroke-width="2" rx="3"/>
-      <text x="310" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">8</text>
-
-      <!-- Bracket -->
-      <path d="M 70,60 L 70,70 L 270,70 L 270,60" fill="none" stroke="#10b981" stroke-width="2"/>
-    </g>
-  </g>
-</svg>

apps/docs/public/sliding-window-flexible.svg

@@ -1,66 +0,0 @@
-<svg viewBox="0 0 800 450" xmlns="http://www.w3.org/2000/svg">
-  <!-- Background (REQUIRED) -->
-  <rect width="800" height="450" fill="#f8f9fa" rx="10"/>
-
-  <!-- Title and Subtitle -->
-  <text x="400" y="45" font-family="Arial, sans-serif" font-size="26" font-weight="bold" fill="#2c3e50" text-anchor="middle">Sliding Window: Flexible Size</text>
-  <text x="400" y="75" font-family="Arial, sans-serif" font-size="16" fill="#7f8c8d" text-anchor="middle">Window expands until invalid, then shrinks until valid again.</text>
-
-  <!-- Step 1: Invalid state -->
-  <g transform="translate(150, 130)">
-    <text x="0" y="-20" font-family="Arial, sans-serif" font-size="18" font-weight="bold" fill="#2c3e50">1. Expansion breaks invariant</text>
-    
-    <!-- Array -->
-    <g transform="translate(0, 20)">
-      <rect x="0" y="0" width="60" height="50" fill="#fee2e2" stroke="#ef4444" stroke-width="3" rx="3"/>
-      <text x="30" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">a</text>
-      <polygon points="30,60 25,70 35,70" fill="#27ae60"/>
-      <text x="30" y="85" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#27ae60" text-anchor="middle">L</text>
-
-      <rect x="70" y="0" width="60" height="50" fill="#fee2e2" stroke="#ef4444" stroke-width="3" rx="3"/>
-      <text x="100" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">b</text>
-      
-      <rect x="140" y="0" width="60" height="50" fill="#fee2e2" stroke="#ef4444" stroke-width="3" rx="3"/>
-      <text x="170" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">c</text>
-
-      <rect x="210" y="0" width="60" height="50" fill="#fee2e2" stroke="#ef4444" stroke-width="4" rx="3"/>
-      <text x="240" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">a</text>
-      <polygon points="240,60 235,70 245,70" fill="#3498db"/>
-      <text x="240" y="85" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#3498db" text-anchor="middle">R</text>
-
-      <text x="300" y="32" font-family="Arial, sans-serif" font-size="14" fill="#ef4444" font-weight="bold">Duplicate 'a'!</text>
-    </g>
-  </g>
-
-  <!-- Transition -->
-  <g transform="translate(400, 260)">
-    <path d="M 0,0 L 0,30" stroke="#dee2e6" stroke-width="2" fill="none"/>
-    <text x="10" y="20" font-family="Arial, sans-serif" font-size="14" font-style="italic" fill="#7f8c8d">Shrink from left</text>
-  </g>
-
-  <!-- Step 2: Valid again -->
-  <g transform="translate(150, 340)">
-    <text x="0" y="-20" font-family="Arial, sans-serif" font-size="18" font-weight="bold" fill="#2c3e50">2. Invariant restored</text>
-    
-    <!-- Array -->
-    <g transform="translate(0, 20)">
-      <rect x="0" y="0" width="60" height="50" fill="#e5e7eb" stroke="#94a3b8" stroke-width="2" rx="3"/>
-      <text x="30" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#94a3b8">a</text>
-      
-      <rect x="70" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="100" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">b</text>
-      <polygon points="100,60 95,70 105,70" fill="#27ae60"/>
-      <text x="100" y="85" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#27ae60" text-anchor="middle">L</text>
-      
-      <rect x="140" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="170" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">c</text>
-
-      <rect x="210" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="240" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">a</text>
-      <polygon points="240,60 235,70 245,70" fill="#3498db"/>
-      <text x="240" y="85" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#3498db" text-anchor="middle">R</text>
-
-      <text x="300" y="32" font-family="Arial, sans-serif" font-size="14" fill="#10b981" font-weight="bold">Valid again!</text>
-    </g>
-  </g>
-</svg>

apps/docs/public/sliding-window-frequency.svg

@@ -1,54 +0,0 @@
-<svg viewBox="0 0 800 450" xmlns="http://www.w3.org/2000/svg">
-  <!-- Background (REQUIRED) -->
-  <rect width="800" height="450" fill="#f8f9fa" rx="10"/>
-
-  <!-- Title and Subtitle -->
-  <text x="400" y="45" font-family="Arial, sans-serif" font-size="26" font-weight="bold" fill="#2c3e50" text-anchor="middle">Sliding Window: Frequency Tracking</text>
-  <text x="400" y="75" font-family="Arial, sans-serif" font-size="16" fill="#7f8c8d" text-anchor="middle">Maintaining a character frequency map for the current window.</text>
-
-  <!-- Left: Window -->
-  <g transform="translate(100, 150)">
-    <text x="0" y="-30" font-family="Arial, sans-serif" font-size="18" font-weight="bold" fill="#2c3e50">Current Window</text>
-    
-    <!-- Array -->
-    <g transform="translate(0, 20)">
-      <rect x="0" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="30" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">a</text>
-      <polygon points="30,60 25,70 35,70" fill="#27ae60"/>
-      <text x="30" y="85" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#27ae60" text-anchor="middle">L</text>
-
-      <rect x="70" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="100" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">b</text>
-      
-      <rect x="140" y="0" width="60" height="50" fill="#d1fae5" stroke="#10b981" stroke-width="3" rx="3"/>
-      <text x="170" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">a</text>
-      <polygon points="170,60 165,70 175,70" fill="#3498db"/>
-      <text x="170" y="85" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#3498db" text-anchor="middle">R</text>
-
-      <rect x="210" y="0" width="60" height="50" fill="#ffffff" stroke="#dee2e6" stroke-width="2" rx="3"/>
-      <text x="240" y="32" font-family="monospace" font-size="22" text-anchor="middle" fill="#2c3e50">c</text>
-    </g>
-  </g>
-
-  <!-- Right: Frequency Map -->
-  <g transform="translate(500, 150)">
-    <text x="0" y="-30" font-family="Arial, sans-serif" font-size="18" font-weight="bold" fill="#2c3e50">Frequency Map</text>
-    
-    <!-- Map Container -->
-    <rect x="0" y="0" width="150" height="120" fill="#ffffff" stroke="#dee2e6" stroke-width="2" rx="8"/>
-    
-    <!-- Entries -->
-    <g transform="translate(25, 35)">
-      <text x="0" y="0" font-family="monospace" font-size="18" fill="#2c3e50">'a' : 2</text>
-      <text x="0" y="30" font-family="monospace" font-size="18" fill="#2c3e50">'b' : 1</text>
-      <text x="0" y="60" font-family="monospace" font-size="18" fill="#7f8c8d">'c' : 0</text>
-    </g>
-
-    <!-- Invariant label -->
-    <rect x="-20" y="140" width="190" height="40" fill="#e3f2fd" stroke="#3498db" stroke-width="1" rx="5"/>
-    <text x="75" y="165" font-family="Arial, sans-serif" font-size="12" font-weight="bold" fill="#1565c0" text-anchor="middle">INVARIANT: SYNCED STATE</text>
-  </g>
-
-  <!-- Connector -->
-  <path d="M 380,195 L 480,195" stroke="#dee2e6" stroke-width="2" stroke-dasharray="5,5" fill="none"/>
-</svg>

docs/(01-linear-structures)/binary-search/(problems)/153_find-minimum-in-rotated-sorted-array.mdx

@@ -1,13 +1,17 @@
 ---
 title: '153. Find Minimum in Rotated Sorted Array'
 description: 'Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:'
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "nIVW4P8b1VA"
+issue: "https://github.com/prdlk/leetcode/issues/62"
 sidebar:
   label: 'Find Minimum in Rotated Sorted Array'
   badge: 'Medium'
 ---
 
-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
 ::::
@@ -68,7 +72,3 @@ class Solution:
 
         return nums[lowest_index]
 ```
-
-## Explanation
-
-<YouTube id="nIVW4P8b1VA" title="Find Minimum in Rotated Sorted Array - Binary Search - Leetcode 153 - Python" />

docs/(01-linear-structures)/binary-search/(problems)/162_find-peak-element.mdx

@@ -0,0 +1,48 @@
+---
+title: '162. Find Peak Element'
+description: A peak element is an element that is strictly greater than its neighbors
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+issue: "https://github.com/prdlk/leetcode/issues/64"
+sidebar:
+  label: 'Find Peak Element'
+  badge: 'Medium'
+---
+
+::::warning
+You must write an algorithm that runs in O(log n) time.
+::::
+
+### Example 1:
+- Input: `nums = [1,2,3,1]`
+- Output: `2`
+- Explanation: `3` is a peak element and your function should return the index number `2`.
+
+### Example 2:
+- Input: `nums = [1,2,1,3,5,6,4]`
+- Output: `5`
+- Explanation: Your function can return either index number `1` where the peak element is `2`, or index number `5` where the peak element is `6`.
+
+### Constraints:
+
+- `1 <= nums.length <= 1000`
+- `-2^31 <= nums[i] <= 2^31 - 1`
+- `nums[i] != nums[i + 1] for all valid i.`
+
+## Solution
+
+```py
+class Solution:
+    def findPeakElement(self, nums: list[int]) -> int:
+        left, right = 0, len(nums) - 1
+        while left < right:
+            mid = (left + right) // 2
+            if nums[mid] < nums[mid + 1]:
+                left = mid + 1
+            else:
+                right = mid
+
+        return left
+```

docs/(01-linear-structures)/binary-search/(problems)/33_search-in-rotated-sorted-array.mdx

@@ -1,13 +1,17 @@
 ---
 title: '33. Search in Rotated Sorted Array'
 description: There is an integer array nums sorted in ascending order (with distinct values)
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "U8XENwh8Oy8"
+issue: "https://github.com/prdlk/leetcode/issues/60"
 sidebar:
   label: 'Search in Rotated Sorted Array'
   badge: 'Medium'
 ---
 
-<Badge variant="accent">Array</Badge>
-
 ::::warning
 You must write an algorithm with O(log n) runtime complexity.
 ::::
@@ -92,7 +96,3 @@ var search = function(nums, target) {
   return -1;
 };
 ```
-
-## Explanation
-
-<YouTube id="U8XENwh8Oy8" title="Search in rotated sorted array - Leetcode 33 - Python" />

docs/(01-linear-structures)/binary-search/(problems)/34_find-first-and-last-position-of-element-in-sorted-array.mdx

@@ -0,0 +1,60 @@
+---
+title: '34. Find First and Last Position of Element in Sorted Array'
+description: Given an array of integers nums sorted in non-decreasing order, find the starting and ending position of a given target value
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+issue: "https://github.com/prdlk/leetcode/issues/65"
+sidebar:
+  label: 'Find First and Last Position of Element in Sorted Array'
+  badge: 'Medium'
+---
+
+::::warning
+You must write an algorithm with O(log n) runtime complexity.
+::::
+
+### Example 1:
+- Input: `nums = [5,7,7,8,8,10], target = 8`
+- Output: `[3,4]`
+
+### Example 2:
+- Input: `nums = [5,7,7,8,8,10], target = 6`
+- Output: `[-1,-1]`
+
+### Example 3:
+- Input: `nums = [], target = 0`
+- Output: `[-1,-1]`
+
+### Constraints:
+
+- `0 <= nums.length <= 10^5`
+- `-10^9 <= nums[i] <= 10^9`
+- `nums` is a non-decreasing array.
+- `-10^9 <= target <= 10^9`
+
+## Solution
+
+```py
+class Solution:
+    def searchRange(self, nums: list[int], target: int) -> list[int]:
+        def find(first):
+            result = -1
+            left, right = 0, len(nums) - 1
+            while left <= right:
+                mid = (left + right) // 2
+                if nums[mid] == target:
+                    result = mid
+                    if first:
+                        right = mid - 1
+                    else:
+                        left = mid + 1
+                elif nums[mid] < target:
+                    left = mid + 1
+                else:
+                    right = mid - 1
+            return result
+
+        return [find(True), find(False)]
+```

docs/(01-linear-structures)/binary-search/(problems)/35_search-insert-position.mdx

@@ -1,13 +1,17 @@
 ---
 title: '35. Search Insert Position'
 description: Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "K-RYzDZkzCI"
+issue: "https://github.com/prdlk/leetcode/issues/63"
 sidebar:
   label: 'Search Insert Position'
   badge: 'Easy'
 ---
 
-<Badge variant="accent">Array</Badge>
-
 ::::warning
 You must write an algorithm with O(log n) runtime complexity.
 ::::
@@ -65,7 +69,3 @@ class Solution:
 
         return (l + r) // 2 + 1
 ```
-
-## Explanation
-
-<YouTube id="K-RYzDZkzCI" title="Search Insert Position - Binary Search - Leetcode 35 - Python" />

docs/(01-linear-structures)/binary-search/(problems)/704_binary-search.mdx

@@ -1,13 +1,17 @@
 ---
 title: '704. Binary Search'
 description: Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "s4DPM8ct1pI"
+issue: "https://github.com/prdlk/leetcode/issues/58"
 sidebar:
   label: 'Binary Search'
   badge: 'Easy'
 ---
 
-<Badge variant="accent">Array</Badge>
-
 ::::warning
 You must write an algorithm with O(log n) runtime complexity.
 ::::
@@ -70,7 +74,3 @@ var search = function(nums, target) {
     return -1;
 };
 ```
-
-## Explanation
-
-<YouTube id="s4DPM8ct1pI" title="Binary Search - Leetcode 704 - Python" />

docs/(01-linear-structures)/binary-search/(problems)/74_search-a-2d-matrix.mdx

@@ -1,13 +1,18 @@
 ---
 title: '74. Search a 2D Matrix'
 description: 'You are given an m x n integer matrix matrix with the following two properties:'
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+  - { name: "Matrix", slug: "matrix" }
+video: "Ber2pi2C0j0"
+issue: "https://github.com/prdlk/leetcode/issues/61"
 sidebar:
   label: 'Search a 2D Matrix'
   badge: 'Medium'
 ---
 
-<Badge variant="accent">Array</Badge>
-
 ::::warning
 You must write a solution in O(log(m * n)) time complexity.
 ::::
@@ -85,7 +90,3 @@ class Solution:
                 return True
         return False
 ```
-
-## Explanation
-
-<YouTube id="Ber2pi2C0j0" title="Search a 2D Matrix - Leetcode 74 - Python" />

docs/(01-linear-structures)/binary-search/(problems)/875_koko-eating-bananas.mdx

@@ -1,13 +1,17 @@
 ---
 title: '875. Koko Eating Bananas'
 description: Koko loves to eat bananas. There are n piles of bananas, the i^th pile has piles[i] bananas. The guards have gone and will come back in h hours
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Binary Search", slug: "binary-search" }
+video: "U2SozAs9RzA"
+issue: "https://github.com/prdlk/leetcode/issues/59"
 sidebar:
   label: 'Koko Eating Bananas'
   badge: 'Medium'
 ---
 
-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `piles = [3,6,7,11], h = 8`
 - Output: `4`
@@ -76,7 +80,3 @@ var minEatingSpeed = function(piles, h) {
   return l;
 };
 ```
-
-## Explanation
-
-<YouTube id="U2SozAs9RzA" title="Koko Eating Bananas - Binary Search - Leetcode 875 - Python" />

docs/(01-linear-structures)/binary-search/index.mdx

@@ -0,0 +1,86 @@
+---
+title: Binary Search
+description: 'Half of a sorted range is removed at each step until the target is found.'
+hidden: true
+---
+
+Binary search is an efficient array search algorithm. It works by narrowing down the search range by half each time. If you have looked up a word in a physical dictionary, you've already used binary search in real life. Let's look at a simple example:
+
+*Given a sorted array of integers and an integer called target, find the element that equals the target and return its index. If the element is not found, return -1.*
+
+The key observation here is that the array is sorted. We pick a random element in the array and compare it to the target.
+
+- If we happen to pick the element that equals the target (how lucky!), then bingo. We don't need to do any more work; we return its index.
+- If the element is smaller than the target, then we know the target cannot be found in the section to the left of the current element, since everything to the left is even smaller. So, we discard the current element and everything on the left from the search range.
+- If the element is larger than the target, then we know the target cannot be found in the section to the right of the current element, since everything to the right is even larger. So, we discard the current element and everything on the right from the search range.
+
+We repeat this process until we find the target. Instead of picking a random element, we always pick the **middle** element in the current search range. This way, we can discard half of the options and shrink the search range by half each time. This gives us `O(log(N))` runtime.
+
+This idea can be implemented both iteratively and recursively. However, the major difference is that the iterative version of binary search uses `O(1)` memory while the recursive version uses `O(log(N))` memory.
+
+## Implementation
+
+The search range is represented by the `left` and `right` indices that start from both ends of the array and move towards each other as we search. When moving the index, we discard elements and shrink the search range.
+
+Time Complexity: `O(log(n))`
+
+
+<Carousel>
+<CarouselImage src='/binary_search.001.png' />
+<CarouselImage src='/binary_search.002.png' />
+<CarouselImage src='/binary_search.003.png' />
+<CarouselImage src='/binary_search.004.png' />
+<CarouselImage src='/binary_search.005.png' />
+<CarouselImage src='/binary_search.006.png' />
+<CarouselImage src='/binary_search.007.png' />
+<CarouselImage src='/binary_search.008.png' />
+</Carousel>
+
+```python
+def binary_search(arr: list[int], target: int) -> int:
+    left, right = 0, len(arr) - 1
+    # <= because left and right could point to the same element, < would miss it
+    while left <= right:
+        # double slash for integer division in python 3,
+        # we don't have to worry about integer `left + right` overflow
+        # since python integers can be arbitrarily large
+        mid = (left + right) // 2
+        # found target, return its index
+        if arr[mid] == target:
+            return mid
+        # middle less than target, discard left half by making left search boundary `mid + 1`
+        if arr[mid] < target:
+            left = mid + 1
+        # middle greater than target, discard right half by making right search boundary `mid - 1`
+        else:
+            right = mid - 1
+    return -1  # if we get here we didn't hit above return so we didn't find target
+```
+
+### Calculating `mid`
+
+Note that when calculating `mid`, if the number of elements is even, there are two elements in the middle. We usually follow the convention of picking the first one, equivalent to doing integer division `(left + right) / 2`.
+
+In most programming languages, we calculate `mid` with `left + floor((right-left) / 2)` to avoid potential integer overflow. However, in Python, we do not need to worry about integer overflow with `left + right` because Python3 integers can be arbitrarily large.
+
+## Deduction
+
+It's essential to understand and deduce the algorithm yourself instead of memorizing it. In an actual interview, interviewers may ask you additional questions to test your understanding, so simply memorizing the algorithm may not be enough to convince the interviewer.
+
+Key elements in writing a correct binary search:
+
+### 1. When to terminate the loop
+
+Make sure the `while` loop includes an equality comparison; otherwise, we might skip the loop and miss the potential match for the edge case of a one-element array.
+
+### 2. Whether/how to update `left` and `right` boundary in the `if` conditions
+
+Consider which side to discard. If `arr[mid]` is smaller than the `target`, we should discard everything on the left by making `left = mid + 1`.
+
+### 3. Should I discard the current element?
+
+For vanilla binary search, we can discard it since it cannot be the final answer if it is not equal to the target. There might be situations where you would want to think twice before discarding the current element. We'll discuss this in the next module.
+
+## When to use binary search
+
+Interestingly, binary search works beyond sorted arrays. **You can use binary search whenever you make a binary decision to shrink the search range.**

docs/(01-linear-structures)/hash-table/(problems)/128_longest-consecutive-sequence.mdx

@@ -0,0 +1,56 @@
+---
+title: '128. Longest Consecutive Sequence'
+description: Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Union-Find", slug: "union-find" }
+issue: "https://github.com/prdlk/leetcode/issues/34"
+sidebar:
+  label: 'Longest Consecutive Sequence'
+  badge: 'Medium'
+---
+
+::::warning
+You must write an algorithm that runs in O(n) time.
+::::
+
+### Example 1:
+- Input: `nums = [100,4,200,1,3,2]`
+- Output: `4`
+- Explanation: The longest consecutive elements sequence is [1, `2`, `3`, 4]. Therefore its length is `4`.
+
+### Example 2:
+- Input: `nums = [0,3,7,2,5,8,4,6,0,1]`
+- Output: `9`
+
+### Example 3:
+- Input: `nums = [1,0,1,2]`
+- Output: `3`
+
+### Constraints:
+
+- `0 <= nums.length <= 10^5`
+- `-10^9 <= nums[i] <= 10^9`
+
+## Solution
+
+```py
+class Solution:
+    def longestConsecutive(self, nums: list[int]) -> int:
+        seen = set(nums)
+        best = 0
+
+        for n in seen:
+            if n - 1 in seen:
+                continue
+
+            length = 1
+            while length + n in seen:
+                length += 1
+
+            best = max(length, best)
+
+        return best
+```

docs/(01-linear-structures)/hash-table/(problems)/1832_check-if-the-sentence-is-pangram.mdx

@@ -1,13 +1,15 @@
 ---
 title: '1832. Check if the Sentence Is Pangram'
 description: A pangram is a sentence where every letter of the English alphabet appears at least once
+icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
 sidebar:
   label: 'Check if the Sentence Is Pangram'
   badge: 'Easy'
 ---
 
-<Badge variant="accent">Hash Table</Badge>
-
 ### Example 1:
 - Input: `sentence = "thequickbrownfoxjumpsoverthelazydog"`
 - Output: `true`

docs/(01-linear-structures)/hash-table/(problems)/1_two-sum.mdx

@@ -1,13 +1,17 @@
 ---
 title: '1. Two Sum'
 description: You are given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+video: "KLlXCFG5TnA"
+issue: "https://github.com/prdlk/leetcode/issues/29"
 sidebar:
   label: 'Two Sum'
   badge: 'Easy'
 ---
 
-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Can you come up with an algorithm that is less than O(n^2) time complexity?
 ::::
@@ -59,7 +63,3 @@ class Solution:
             seen[num] = i
         return []
 ```
-
-## Explanation
-
-<YouTube id="KLlXCFG5TnA" title="Two Sum - Leetcode 1 - HashMap - Python" />

docs/(01-linear-structures)/hash-table/(problems)/205_isomorphic-strings.mdx

@@ -0,0 +1,52 @@
+---
+title: '205. Isomorphic Strings'
+description: Given two strings s and t, determine if they are isomorphic
+icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+issue: "https://github.com/prdlk/leetcode/issues/33"
+sidebar:
+  label: 'Isomorphic Strings'
+  badge: 'Easy'
+---
+
+### Example 1:
+- Input: `s = "egg", t = "add"`
+- Output: `true`
+- Explanation: The strings `s` and `t` can be made identical by: • Mapping 'e' to 'a'. • Mapping 'g' to 'd'.
+
+### Example 2:
+- Input: `s = "f11", t = "b23"`
+- Output: `false`
+- Explanation: The strings `s` and `t` can not be made identical as `'1`' needs to be mapped to both `'2`' and `'3`'.
+
+### Example 3:
+- Input: `s = "paper", t = "title"`
+- Output: `true`
+
+### Constraints:
+
+- `1 <= s.length <= 5 * 10^4`
+- `t.length == s.length`
+- `s` and `t` consist of any valid ascii character.
+
+## Solution
+
+```py
+class Solution:
+    def isIsomorphic(self, s: str, t: str) -> bool:
+        N = len(t)
+        seen = {}
+
+        for i in range(N):
+            c1, c2 = s[i], t[i]
+            if c1 in seen and seen[c1] != c2:
+                return False
+            elif c1 in seen and seen[c1] == c2:
+                continue
+            else:
+                seen[c1] = c2
+
+        return len(set(s)) == len(set(t))
+```

docs/(01-linear-structures)/hash-table/(problems)/217_contains-duplicate.mdx

@@ -1,13 +1,18 @@
 ---
 title: '217. Contains Duplicate'
 description: Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Sorting", slug: "sorting" }
+video: "3OamzN90kPg"
+issue: "https://github.com/prdlk/leetcode/issues/27"
 sidebar:
   label: 'Contains Duplicate'
   badge: 'Easy'
 ---
 
-<Badge variant="accent">Array</Badge>
-
 ### Example 1:
 - Input: `nums = [1,2,3,1]`
 - Output: `true`
@@ -42,32 +47,8 @@ flowchart TD
 
 ## Solution
 
-<CodeGroup>
-
-```py Python
+```py
 class Solution:
     def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) != len(nums)
 ```
-
-```js JavaScript
-/**
- * @param {number[]} nums
- * @return {boolean}
- */
-var containsDuplicate = function(nums) {
-  const freq = {};
-  for (let n of nums) {
-    freq[n] = (freq[n] || 0) + 1;
-    if (freq[n] >= 2) {
-      return true;
-    }
-  } 
-  return false;
-};
-```
-
-</CodeGroup>
-
-## Explanation
-
-<YouTube id="3OamzN90kPg" title="Contains Duplicate - Leetcode 217 - Python" />

docs/(01-linear-structures)/hash-table/(problems)/242_valid-anagram.mdx

@@ -1,13 +1,18 @@
 ---
 title: '242. Valid Anagram'
 description: Given two strings s and t, return true if t is an anagram of s, and false otherwise
+icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Sorting", slug: "sorting" }
+video: "9UtInBqnCgA"
+issue: "https://github.com/prdlk/leetcode/issues/28"
 sidebar:
   label: 'Valid Anagram'
   badge: 'Easy'
 ---
 
-<Badge variant="accent">Hash Table</Badge>
-
 ::::warning
 What if the inputs contain Unicode characters? How would you adapt your solution to such a case?
 ::::
@@ -59,7 +64,3 @@ var isAnagram = function(s, t) {
   return true;
 };
 ```
-
-## Explanation
-
-<YouTube id="9UtInBqnCgA" title="Valid Anagram - Leetcode 242 - Python" />

docs/(01-linear-structures)/hash-table/(problems)/290_word-pattern.mdx

@@ -0,0 +1,57 @@
+---
+title: '290. Word Pattern'
+description: Given a pattern and a string s, find if s follows the same pattern
+icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+issue: "https://github.com/prdlk/leetcode/issues/35"
+sidebar:
+  label: 'Word Pattern'
+  badge: 'Easy'
+---
+
+### Example 1:
+- Input: `pattern = "abba", s = "dog cat cat dog"`
+- Output: `true`
+- Explanation: The bijection can be established as: • 'a' maps to "dog". • 'b' maps to "cat".
+
+### Example 2:
+- Input: `pattern = "abba", s = "dog cat cat fish"`
+- Output: `false`
+
+### Example 3:
+- Input: `pattern = "aaaa", s = "dog cat cat dog"`
+- Output: `false`
+
+### Constraints:
+
+- `1 <= pattern.length <= 300`
+- `pattern` contains only lower-case English letters.
+- `1 <= s.length <= 3000`
+- `s` contains only lowercase English letters and spaces ' '.
+- `s` does not contain any leading or trailing spaces.
+- All the words in `s` are separated by a single space.
+
+## Solution
+
+```py
+class Solution:
+    def wordPattern(self, pattern: str, s: str) -> bool:
+        if len(pattern) != len(s.split()):
+            return False
+
+        words = s.split()
+        map = {}
+
+        for i in range(len(pattern)):
+            c = pattern[i]
+            w = words[i]
+
+            if c in map and map[c] != w:
+                return False
+            else:
+                map[c] = w
+
+        return len(set(pattern)) == len(set(words))
+```

docs/(01-linear-structures)/hash-table/(problems)/347_top-k-frequent-elements.mdx

@@ -1,13 +1,23 @@
 ---
 title: '347. Top K Frequent Elements'
 description: Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Divide and Conquer", slug: "divide-and-conquer" }
+  - { name: "Sorting", slug: "sorting" }
+  - { name: "Heap (Priority Queue)", slug: "heap-priority-queue" }
+  - { name: "Bucket Sort", slug: "bucket-sort" }
+  - { name: "Counting", slug: "counting" }
+  - { name: "Quickselect", slug: "quickselect" }
+video: "YPTqKIgVk-k"
+issue: "https://github.com/prdlk/leetcode/issues/31"
 sidebar:
   label: 'Top K Frequent Elements'
   badge: 'Medium'
 ---
 
-<Badge variant="accent">Array</Badge>
-
 ::::warning
 Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
 ::::
@@ -59,7 +69,3 @@ var topKFrequent = function (nums, k) {
     .slice(0, k);
 };
 ```
-
-## Explanation
-
-<YouTube id="YPTqKIgVk-k" title="Top K Frequent Elements - Bucket Sort - Leetcode 347 - Python" />

docs/(01-linear-structures)/hash-table/(problems)/387_first-unique-character-in-a-string.mdx

@@ -1,13 +1,18 @@
 ---
 title: '387. First Unique Character in a String'
 description: Given a string s, find the first non-repeating character in it and return its index. If it does not exist, return -1
+icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Queue", slug: "queue" }
+  - { name: "Counting", slug: "counting" }
+video: "rBENYgWy3xU"
 sidebar:
   label: 'First Unique Character in a String'
   badge: 'Easy'
 ---
 
-<Badge variant="accent">Hash Table</Badge>
-
 ### Example 1:
 - Input: `s = "leetcode"`
 - Output: `0`
@@ -57,7 +62,3 @@ var firstUniqChar = function (s) {
   return -1;
 };
 ```
-
-## Explanation
-
-<YouTube id="rBENYgWy3xU" title="First Unique Character in a String - Leetcode 387 - Python" />

docs/(01-linear-structures)/hash-table/(problems)/451_sort-characters-by-frequency.mdx

@@ -1,13 +1,20 @@
 ---
 title: '451. Sort Characters By Frequency'
 description: Given a string s, sort it in decreasing order based on the frequency of the characters. The frequency of a character is the number of times it appears in the string
+icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Sorting", slug: "sorting" }
+  - { name: "Heap (Priority Queue)", slug: "heap-priority-queue" }
+  - { name: "Bucket Sort", slug: "bucket-sort" }
+  - { name: "Counting", slug: "counting" }
+video: "OXdXc9HTrIg"
 sidebar:
   label: 'Sort Characters By Frequency'
   badge: 'Medium'
 ---
 
-<Badge variant="accent">Hash Table</Badge>
-
 ### Example 1:
 - Input: `s = "tree"`
 - Output: `"eert"`
@@ -59,7 +66,3 @@ var frequencySort = function (s) {
     .join("");
 };
 ```
-
-## Explanation
-
-<YouTube id="OXdXc9HTrIg" title="Sort Characters By Frequency - Leetcode 451 - Python" />