From 13fdc074e8dd03d48809502345669bf2dfc06903 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 4 Jul 2026 16:38:28 +0000
Subject: [PATCH 1/3] feat: add JupyterLite in-browser demo sub-site (spec 049,
 closes #21)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Publishes a self-contained JupyterLite site at /jupyterlite/ alongside
the frozen playground. One example notebook (demo.ipynb) loads a light
sample CSV of European capital city data and renders three matplotlib
figures inline — entirely in the browser via Pyodide, no server or
account needed.

Changes:
- jupyterlite/: new demo source directory with pinned requirements.txt
  (jupyterlite-core==0.8.0, jupyterlite-pyodide-kernel==0.8.1), build
  and runtime configs, sample dataset, and example notebook
- .github/workflows/deploy.yml: additive JupyterLite build step after
  the existing IDE copy; publishes to _site/jupyterlite/
- .github/workflows/pr-preview.yml: same additive step with PR-scoped
  base URL; preview comment now lists /jupyterlite/ URL
- web/index.html: visible "JupyterLite demo" card link added
- .specify/memory/constitution.md: amendment v2.2.0 — JupyterLite demo
  bullet added to Technology Constraints (new infrastructural dependency)
- README.md: demo pin rows added to Pinned versions table
- docs/limitations.md: online-only, cold-load, and separate-pin entries

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011jxCebZyA1CpyG5KL3eh5j
---
 .github/workflows/deploy.yml         |  28 +++-
 .github/workflows/pr-preview.yml     |  25 ++-
 .gitignore                           |   1 +
 .specify/memory/constitution.md      |  42 ++++-
 README.md                            |   3 +
 docs/limitations.md                  |  35 ++++
 jupyterlite/.gitignore               |   4 +
 jupyterlite/README.md                |  82 +++++++++
 jupyterlite/files/data/sample.csv    |  31 ++++
 jupyterlite/files/demo.ipynb         | 237 +++++++++++++++++++++++++++
 jupyterlite/jupyter-lite.json        |  11 ++
 jupyterlite/jupyter_lite_config.json |   5 +
 jupyterlite/requirements.txt         |   2 +
 specs/049-jupyterlite-demo/tasks.md  |  40 ++---
 web/index.html                       |   9 +
 15 files changed, 531 insertions(+), 24 deletions(-)
 create mode 100644 jupyterlite/.gitignore
 create mode 100644 jupyterlite/README.md
 create mode 100644 jupyterlite/files/data/sample.csv
 create mode 100644 jupyterlite/files/demo.ipynb
 create mode 100644 jupyterlite/jupyter-lite.json
 create mode 100644 jupyterlite/jupyter_lite_config.json
 create mode 100644 jupyterlite/requirements.txt

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 8c73855..7cd30d3 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -9,6 +9,7 @@ on:
 #   /                  → static welcome page (web/index.html)
 #   /slides/           → reveal.js findings deck (web/slides/)
 #   /playground/       → the Vite IDE app (built with a matching base path)
+#   /jupyterlite/      → JupyterLite in-browser demo (jupyter lite build)
 #   /sample-package/   → lesson 8's self-hosted Data Package (kept at root
 #                        so the URL hard-coded in lesson 8 stays valid)
 # PR previews (see pr-preview.yml) live under `/pr-preview/pr-N/` of the
@@ -59,7 +60,29 @@ jobs:
           VITE_BASE_PATH: /tabular-data-playground/playground/
         run: pnpm run build
 
-      - name: Assemble published site (welcome + slides + IDE + sample-package)
+      - name: Set up Python for JupyterLite build
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install JupyterLite build dependencies
+        working-directory: ${{ github.workspace }}
+        run: pip install -r jupyterlite/requirements.txt
+
+      - name: Build JupyterLite demo (served under /jupyterlite/)
+        working-directory: ${{ github.workspace }}
+        run: |
+          jupyter lite build \
+            --config jupyterlite/jupyter_lite_config.json \
+            --output-dir jupyterlite/_output \
+            --base-url /tabular-data-playground/jupyterlite/
+
+      - name: Verify JupyterLite build produced output
+        working-directory: ${{ github.workspace }}
+        run: |
+          test -d jupyterlite/_output && test -n "$(ls -A jupyterlite/_output)"
+
+      - name: Assemble published site (welcome + slides + IDE + jupyterlite + sample-package)
         working-directory: ${{ github.workspace }}
         run: |
           set -e
@@ -70,6 +93,9 @@ jobs:
           # IDE under /playground/
           mkdir -p _site/playground
           cp -r app/dist/. _site/playground/
+          # JupyterLite demo under /jupyterlite/
+          mkdir -p _site/jupyterlite
+          cp -r jupyterlite/_output/. _site/jupyterlite/
           # Keep the lesson-8 sample package at the gh-pages root
           if [ -d _site/playground/sample-package ]; then
             rm -rf _site/sample-package
diff --git a/.github/workflows/pr-preview.yml b/.github/workflows/pr-preview.yml
index ebc0b88..6729925 100644
--- a/.github/workflows/pr-preview.yml
+++ b/.github/workflows/pr-preview.yml
@@ -6,6 +6,7 @@ name: PR Preview to GitHub Pages
 #   /pr-preview/pr-<N>/             → welcome page (web/index.html)
 #   /pr-preview/pr-<N>/slides/      → reveal.js findings deck
 #   /pr-preview/pr-<N>/playground/  → the Vite IDE (PR-scoped base path)
+#   /pr-preview/pr-<N>/jupyterlite/ → JupyterLite demo (PR-scoped base path)
 #   /pr-preview/pr-<N>/sample-package/ → lesson 8's package, kept at the
 #                                        preview root to mirror production
 # A single sticky comment (idempotent via the marker below) links to
@@ -62,7 +63,26 @@ jobs:
           VITE_BASE_PATH: /tabular-data-playground/pr-preview/pr-${{ github.event.pull_request.number }}/playground/
         run: pnpm run build
 
-      - name: Assemble preview site (welcome + slides + IDE + sample-package)
+      - name: Set up Python for JupyterLite build
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install JupyterLite build dependencies
+        run: pip install -r jupyterlite/requirements.txt
+
+      - name: Build JupyterLite demo with PR-scoped base path
+        run: |
+          jupyter lite build \
+            --config jupyterlite/jupyter_lite_config.json \
+            --output-dir jupyterlite/_output \
+            --base-url /tabular-data-playground/pr-preview/pr-${{ github.event.pull_request.number }}/jupyterlite/
+
+      - name: Verify JupyterLite build produced output
+        run: |
+          test -d jupyterlite/_output && test -n "$(ls -A jupyterlite/_output)"
+
+      - name: Assemble preview site (welcome + slides + IDE + jupyterlite + sample-package)
         run: |
           set -e
           rm -rf _site
@@ -70,6 +90,8 @@ jobs:
           cp -r web/. _site/
           mkdir -p _site/playground
           cp -r app/dist/. _site/playground/
+          mkdir -p _site/jupyterlite
+          cp -r jupyterlite/_output/. _site/jupyterlite/
           if [ -d _site/playground/sample-package ]; then
             rm -rf _site/sample-package
             mv _site/playground/sample-package _site/sample-package
@@ -103,6 +125,7 @@ jobs:
               `- Welcome page: ${base}`,
               `- Findings slides: ${base}slides/`,
               `- IDE: ${base}playground/`,
+              `- JupyterLite demo: ${base}jupyterlite/`,
               '',
               `Built from \`${sha}\`. Updates on every push to this PR; removed when the PR closes.`,
             ].join('\n');
diff --git a/.gitignore b/.gitignore
index 5c50aa9..eb9fe29 100644
--- a/.gitignore
+++ b/.gitignore
@@ -145,3 +145,4 @@ vite.config.ts.timestamp-*
 # Claude Code local/user-specific artifacts (skills under .claude/skills/ are tracked)
 .claude/settings.local.json
 .claude/.credentials.json
+.jupyterlite.doit.db
diff --git a/.specify/memory/constitution.md b/.specify/memory/constitution.md
index cc8d44b..bb61eb9 100644
--- a/.specify/memory/constitution.md
+++ b/.specify/memory/constitution.md
@@ -1,6 +1,37 @@
 <!--
 SYNC IMPACT REPORT
-Version change: 2.0.0 → 2.1.0
+Version change: 2.1.0 → 2.2.0
+Bump rationale: Technology Constraints materially expanded (MINOR) — a new
+"JupyterLite demo" bullet added to record the JupyterLite-based in-browser
+demo sub-site (`jupyterlite/`) and its independent pin set. This is a new
+infrastructural dependency (build-time `jupyter lite build` step + its own
+`requirements.txt`), which per the section's own rule is an amendment
+rather than a plain PR. No principle changed; no Definition of Done change.
+Modified principles: none.
+Added sections: none (Technology Constraints expanded with new bullet).
+Removed sections: none.
+Templates requiring updates:
+  - .specify/templates/plan-template.md — no edit required.
+  - .specify/templates/spec-template.md — no edit required.
+  - .specify/templates/tasks-template.md — no edit required.
+  - .specify/templates/checklist-template.md — no edit required.
+Companion edits in same commit:
+  - README.md — JupyterLite/kernel pins recorded in Pinned versions table.
+  - docs/limitations.md — JupyterLite demo sharp edges enumerated.
+  - jupyterlite/ — new demo source directory.
+  - .github/workflows/deploy.yml — additive JupyterLite build step.
+  - .github/workflows/pr-preview.yml — additive JupyterLite build step.
+  - web/index.html — link to /jupyterlite/ demo added.
+
+Previous amendment (2.0.0 → 2.1.0): Technology Constraints "Python runtime"
+slot expanded to admit `livemark` (lesson 9 Livemark capstone).
+Previous amendment (1.0.0 → 2.0.0): Principle VI redefined from "Pin and
+Freeze" to "Pin Versions, Iterate Forward".
+Follow-up TODOs: None.
+-->
+
+<!--
+PREVIOUS SYNC IMPACT REPORT (2.0.0 → 2.1.0)
 Bump rationale: Technology Constraints materially expanded (MINOR) — the
 "Python runtime" slot now admits `livemark`, the Frictionless publishing
 tool used by lesson 9 (Publish with Livemark). It is pinned and installed
@@ -170,6 +201,13 @@ The v1 stack is fixed by the spec and is part of the constitutional surface
   CI smoke-tests Chromium only.
 - **Accessibility**: best-effort — keyboard-navigable, semantic HTML, no
   formal WCAG conformance commitment (decision #15).
+- **JupyterLite demo**: a self-contained in-browser demo sub-site at
+  `/jupyterlite/` built by `jupyter lite build` (build-time Python step).
+  Toolchain pins live in `jupyterlite/requirements.txt`; they are
+  **independent** of the frozen playground's Pyodide `0.27.7` pin.
+  The demo is published additively alongside `/playground/` and is
+  online-only by design (Pyodide/wheels fetched from CDN at runtime).
+  Sharp edges in `docs/limitations.md`.
 
 Substitutions within these slots (e.g. `dockview` instead of `react-mosaic`)
 are permitted and not amendments. Adding a new infrastructural dependency,
@@ -238,4 +276,4 @@ Complexity Tracking section before `/speckit-tasks` runs.
 the constitution and the codebase continue to evolve while the project
 is in its pre-production research phase.
 
-**Version**: 2.1.0 | **Ratified**: 2026-05-08 | **Last Amended**: 2026-06-10
+**Version**: 2.2.0 | **Ratified**: 2026-05-08 | **Last Amended**: 2026-07-04
diff --git a/README.md b/README.md
index 0a6e0f2..f7f8a86 100644
--- a/README.md
+++ b/README.md
@@ -91,6 +91,9 @@ the lessons in `content/lessons/` were authored against.
 | Table Schema JSON Schema | snapshot 2026-05-09 | Bundled from `https://specs.frictionlessdata.io/schemas/table-schema.json` to `app/src/editor/schemas/table-schema.json`. |
 | Table Dialect JSON Schema | snapshot 2026-05-09 (v2) | Bundled from `https://datapackage.org/profiles/2.0/tabledialect.json` to `app/src/editor/schemas/table-dialect.json` (`specs.frictionlessdata.io` returns 404 for dialect; `datapackage.org` is the canonical home). |
 | reveal.js (findings slides) | `5.1.0` | Loaded by `web/slides/index.html` from `https://cdn.jsdelivr.net/npm/reveal.js@5.1.0/` — the URL is the pin. |
+| JupyterLite core (demo) | `0.8.0` | `jupyterlite/requirements.txt`; **independent** of the frozen playground's Pyodide pin. |
+| JupyterLite Pyodide kernel (demo) | `0.8.1` | `jupyterlite/requirements.txt`; bundled Pyodide version determined by the kernel release. |
+| matplotlib (demo, in-browser) | runtime (Pyodide wheel) | Installed in-browser via `%pip install matplotlib` in the demo notebook; version resolved from the JupyterLite Pyodide kernel's bundled wheel index. |
 
 The editor still attempts a runtime fetch of the canonical schemas
 on mount with a short timeout and uses the live copy if it
diff --git a/docs/limitations.md b/docs/limitations.md
index 1fa01ec..27d2e64 100644
--- a/docs/limitations.md
+++ b/docs/limitations.md
@@ -480,3 +480,38 @@ double-Tab listing. xterm.js's default `bellStyle` is silent
 This is a deliberate choice (classroom/demo context); enabling
 a bell sound would require shipping an audio asset and is out
 of scope.
+
+## JupyterLite demo findings
+
+### Demo is online-only (no offline / air-gapped path)
+
+The JupyterLite demo at `/jupyterlite/` relies on CDN-hosted
+Pyodide and wheel packages fetched at runtime by the
+JupyterLite Pyodide kernel. A visitor without internet access
+will see the notebook interface but cells that trigger
+`%pip install` or import a non-bundled package will fail
+silently or with a network error. There is no offline fallback
+and no service-worker caching of the wheel files. This is
+deliberate — bundling the full Pyodide + matplotlib wheel set
+into the repo would add tens of MB of binary content.
+
+### Cold-load wheel weight (first uncached visit)
+
+The first uncached visit fetches the Pyodide runtime (~10 MB
+compressed) plus the matplotlib wheel and its transitive
+dependencies from the Pyodide CDN. Subsequent visits are
+browser-cached. There is no hard latency budget; on a slow
+connection the first `Run All` on the demo notebook can take
+tens of seconds before the figure appears. This is an
+accepted trade-off of the CDN-delivery model.
+
+### Separate pin set — independent of the frozen playground
+
+The demo (`jupyterlite/requirements.txt`) carries its own
+`jupyterlite-core` and `jupyterlite-pyodide-kernel` pins,
+decoupled from the frozen playground's Pyodide `0.27.7`.
+Bumping either set does not affect the other, but they must
+be kept consistent within each context: the playground's
+Frictionless lessons were authored against Pyodide `0.27.7`
+and bumping that pin risks lesson regression. The demo pins
+are independent and can be bumped separately.
diff --git a/jupyterlite/.gitignore b/jupyterlite/.gitignore
new file mode 100644
index 0000000..f41e104
--- /dev/null
+++ b/jupyterlite/.gitignore
@@ -0,0 +1,4 @@
+_output/
+__pycache__/
+*.pyc
+.jupyterlite.doit.db
diff --git a/jupyterlite/README.md b/jupyterlite/README.md
new file mode 100644
index 0000000..6a58eb1
--- /dev/null
+++ b/jupyterlite/README.md
@@ -0,0 +1,82 @@
+# JupyterLite Demo
+
+A self-contained in-browser JupyterLite site that ships one example notebook
+(`demo.ipynb`) loading a sample CSV and rendering matplotlib figures inline.
+Everything runs in the browser via Pyodide — no server, no account required.
+
+Published at `/jupyterlite/` on the GitHub Pages site alongside the frozen
+playground (`/playground/`). The two surfaces are built by independent
+toolchains and share no pins.
+
+## Requirements
+
+Python 3.11+ (build-time only). The notebook runs against the JupyterLite
+Pyodide kernel's bundled Python in-browser; no local Python is used at
+runtime.
+
+## Single reproducible build command
+
+From the **repository root**:
+
+```bash
+pip install -r jupyterlite/requirements.txt
+jupyter lite build \
+  --config jupyterlite/jupyter_lite_config.json \
+  --output-dir jupyterlite/_output
+```
+
+The output is written to `jupyterlite/_output/`. Serve locally with:
+
+```bash
+jupyter lite serve \
+  --config jupyterlite/jupyter_lite_config.json \
+  --output-dir jupyterlite/_output
+```
+
+Then open `http://localhost:8000` (or the URL printed in the terminal),
+navigate to `demo.ipynb`, and run all cells — a matplotlib figure should
+render inline.
+
+## Base URL parameterisation
+
+For deployment under a sub-path, pass `--base-url` to the build command:
+
+```bash
+jupyter lite build \
+  --config jupyterlite/jupyter_lite_config.json \
+  --output-dir jupyterlite/_output \
+  --base-url /tabular-data-playground/jupyterlite/
+```
+
+The CI workflows set the correct base URL for production
+(`/tabular-data-playground/jupyterlite/`) and for PR previews
+(`/tabular-data-playground/pr-preview/pr-<N>/jupyterlite/`).
+
+## Pinned toolchain
+
+Versions are pinned in `requirements.txt`. Do **not** bump them without
+verifying the demo notebook still renders correctly, and update the
+"Pinned versions" table in `README.md` at the repository root accordingly.
+
+| Package | Version |
+|---------|---------|
+| jupyterlite-core | 0.8.0 |
+| jupyterlite-pyodide-kernel | 0.8.1 |
+
+## Directory layout
+
+```
+jupyterlite/
+├── requirements.txt         # Build-time Python deps (pinned)
+├── jupyter_lite_config.json # Build configuration
+├── jupyter-lite.json        # Runtime configuration (kernel, disabled features)
+├── README.md                # This file
+├── .gitignore               # Excludes _output/ from version control
+└── files/                   # Content shipped into the JupyterLite site
+    ├── demo.ipynb           # Example notebook
+    └── data/
+        └── sample.csv       # Generic sample dataset
+```
+
+The `_output/` directory is the build artefact and is **not committed** to
+version control (see `.gitignore`).
diff --git a/jupyterlite/files/data/sample.csv b/jupyterlite/files/data/sample.csv
new file mode 100644
index 0000000..61c1b2e
--- /dev/null
+++ b/jupyterlite/files/data/sample.csv
@@ -0,0 +1,31 @@
+city,country,year,population,gdp_per_capita_usd,life_expectancy
+London,UK,2022,9648110,46510,81.2
+Berlin,Germany,2022,3677472,50210,81.3
+Paris,France,2022,2161000,44020,82.5
+Madrid,Spain,2022,3305408,30120,83.4
+Rome,Italy,2022,2873494,34060,83.6
+Amsterdam,Netherlands,2022,921402,57800,82.1
+Brussels,Belgium,2022,1222637,47300,81.5
+Vienna,Austria,2022,1897491,53120,81.7
+Stockholm,Sweden,2022,975551,55300,82.8
+Oslo,Norway,2022,698660,89140,83.2
+Copenhagen,Denmark,2022,794128,67440,81.6
+Helsinki,Finland,2022,658864,50520,82.0
+Dublin,Ireland,2022,592713,99260,82.3
+Warsaw,Poland,2022,1794166,18820,78.5
+Prague,Czech Republic,2022,1335084,26630,79.1
+Budapest,Hungary,2022,1752704,18400,76.7
+Bucharest,Romania,2022,2161347,15280,76.0
+Sofia,Bulgaria,2022,1307439,12500,75.1
+Zagreb,Croatia,2022,806341,17760,78.2
+Athens,Greece,2022,664046,20110,82.2
+Lisbon,Portugal,2022,545245,24640,82.1
+Riga,Latvia,2022,605802,21060,75.8
+Vilnius,Lithuania,2022,580020,23480,76.4
+Tallinn,Estonia,2022,437619,26840,78.0
+Ljubljana,Slovenia,2022,295504,28930,81.4
+Bratislava,Slovakia,2022,477174,21300,77.5
+Nicosia,Cyprus,2022,269700,29330,81.0
+Valletta,Malta,2022,5828,31640,82.7
+Luxembourg City,Luxembourg,2022,132780,119720,82.3
+Reykjavik,Iceland,2022,131136,73960,83.1
diff --git a/jupyterlite/files/demo.ipynb b/jupyterlite/files/demo.ipynb
new file mode 100644
index 0000000..4cde0db
--- /dev/null
+++ b/jupyterlite/files/demo.ipynb
@@ -0,0 +1,237 @@
+{
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (Pyodide)",
+   "language": "python",
+   "name": "python"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "python",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbformat": 4,
+   "pygments_lexer": "ipython3",
+   "version": "3.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5,
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a1b2c3d4",
+   "metadata": {},
+   "source": [
+    "# Tabular Data Playground — JupyterLite Demo\n",
+    "\n",
+    "This notebook runs entirely in your browser using [JupyterLite](https://jupyterlite.readthedocs.io/) and the [Pyodide](https://pyodide.org/) kernel — no server, no account required.\n",
+    "\n",
+    "It loads a small sample dataset of European capital cities and produces several matplotlib visualisations inline.\n",
+    "\n",
+    "**Run All** (`Kernel → Restart Kernel and Run All Cells`) to execute everything in one go."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2c3d4e5",
+   "metadata": {},
+   "source": [
+    "## 1. Install and import dependencies\n",
+    "\n",
+    "The cell below installs `matplotlib` from the Pyodide wheel index. This happens in-browser — no local Python installation is needed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3d4e5f6",
+   "metadata": {
+    "trusted": true
+   },
+   "outputs": [],
+   "source": [
+    "%pip install matplotlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4e5f6a7",
+   "metadata": {
+    "trusted": true
+   },
+   "outputs": [],
+   "source": [
+    "import csv\n",
+    "import io\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "print(f\"matplotlib {matplotlib.__version__} loaded successfully\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e5f6a7b8",
+   "metadata": {},
+   "source": [
+    "## 2. Load the sample dataset\n",
+    "\n",
+    "The CSV file ships with this JupyterLite site and is read from the virtual filesystem — no network request needed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6a7b8c9",
+   "metadata": {
+    "trusted": true
+   },
+   "outputs": [],
+   "source": [
+    "rows = []\n",
+    "with open(\"data/sample.csv\", newline=\"\", encoding=\"utf-8\") as f:\n",
+    "    reader = csv.DictReader(f)\n",
+    "    for row in reader:\n",
+    "        rows.append(row)\n",
+    "\n",
+    "# Convert numeric columns\n",
+    "for row in rows:\n",
+    "    row[\"population\"] = int(row[\"population\"])\n",
+    "    row[\"gdp_per_capita_usd\"] = float(row[\"gdp_per_capita_usd\"])\n",
+    "    row[\"life_expectancy\"] = float(row[\"life_expectancy\"])\n",
+    "\n",
+    "print(f\"Loaded {len(rows)} rows\")\n",
+    "print(\"Columns:\", list(rows[0].keys()))\n",
+    "print(\"\\nFirst 3 rows:\")\n",
+    "for r in rows[:3]:\n",
+    "    print(\" \", r)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a7b8c9d0",
+   "metadata": {},
+   "source": [
+    "## 3. Bar chart — GDP per capita by city"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8c9d0e1",
+   "metadata": {
+    "trusted": true
+   },
+   "outputs": [],
+   "source": [
+    "# Sort by GDP descending, show top 15\n",
+    "top = sorted(rows, key=lambda r: r[\"gdp_per_capita_usd\"], reverse=True)[:15]\n",
+    "cities = [r[\"city\"] for r in top]\n",
+    "gdp = [r[\"gdp_per_capita_usd\"] / 1000 for r in top]  # in thousands\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(10, 5))\n",
+    "bars = ax.barh(cities[::-1], gdp[::-1], color=\"steelblue\")\n",
+    "ax.set_xlabel(\"GDP per capita (USD thousands)\")\n",
+    "ax.set_title(\"Top 15 European capitals by GDP per capita (2022)\")\n",
+    "ax.bar_label(bars, fmt=\"%.0fk\", padding=4)\n",
+    "fig.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9d0e1f2",
+   "metadata": {},
+   "source": [
+    "## 4. Scatter plot — GDP vs Life Expectancy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d0e1f2a3",
+   "metadata": {
+    "trusted": true
+   },
+   "outputs": [],
+   "source": [
+    "gdp_vals = [r[\"gdp_per_capita_usd\"] / 1000 for r in rows]\n",
+    "le_vals = [r[\"life_expectancy\"] for r in rows]\n",
+    "labels = [r[\"city\"] for r in rows]\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(9, 6))\n",
+    "ax.scatter(gdp_vals, le_vals, color=\"coral\", edgecolors=\"k\", linewidths=0.5, s=60, zorder=3)\n",
+    "\n",
+    "# Label a few notable cities\n",
+    "highlight = {\"Luxembourg City\", \"Oslo\", \"Reykjavik\", \"Athens\", \"Bucharest\", \"Sofia\"}\n",
+    "for r in rows:\n",
+    "    if r[\"city\"] in highlight:\n",
+    "        ax.annotate(\n",
+    "            r[\"city\"],\n",
+    "            (r[\"gdp_per_capita_usd\"] / 1000, r[\"life_expectancy\"]),\n",
+    "            textcoords=\"offset points\", xytext=(5, 3), fontsize=8\n",
+    "        )\n",
+    "\n",
+    "ax.set_xlabel(\"GDP per capita (USD thousands)\")\n",
+    "ax.set_ylabel(\"Life expectancy (years)\")\n",
+    "ax.set_title(\"GDP per capita vs Life Expectancy — European capitals (2022)\")\n",
+    "ax.grid(True, linestyle=\"--\", alpha=0.4)\n",
+    "fig.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e1f2a3b4",
+   "metadata": {},
+   "source": [
+    "## 5. Population by country"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f2a3b4c5",
+   "metadata": {
+    "trusted": true
+   },
+   "outputs": [],
+   "source": [
+    "# Group by country\n",
+    "by_country = {}\n",
+    "for r in rows:\n",
+    "    c = r[\"country\"]\n",
+    "    by_country[c] = by_country.get(c, 0) + r[\"population\"]\n",
+    "\n",
+    "# Sort by population and show top 10\n",
+    "countries = sorted(by_country, key=by_country.get, reverse=True)[:10]\n",
+    "pops = [by_country[c] / 1e6 for c in countries]\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(9, 4))\n",
+    "ax.bar(countries, pops, color=\"mediumseagreen\", edgecolor=\"k\", linewidth=0.5)\n",
+    "ax.set_ylabel(\"Capital city population (millions)\")\n",
+    "ax.set_title(\"Top 10 countries by capital city population (sample dataset, 2022)\")\n",
+    "ax.tick_params(axis=\"x\", rotation=30)\n",
+    "fig.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3b4c5d6",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "All three charts were rendered **entirely in your browser** using Pyodide + matplotlib, with no server involved. The source data is the small CSV shipped alongside this notebook.\n",
+    "\n",
+    "Return to the [Frictionless Data Explorer](../) to explore the full IDE and lessons."
+   ]
+  }
+ ]
+}
diff --git a/jupyterlite/jupyter-lite.json b/jupyterlite/jupyter-lite.json
new file mode 100644
index 0000000..0aa28d1
--- /dev/null
+++ b/jupyterlite/jupyter-lite.json
@@ -0,0 +1,11 @@
+{
+  "jupyter-lite-schema-version": 0,
+  "jupyter-config-data": {
+    "defaultKernelName": "python",
+    "disabledExtensions": [
+      "@jupyterlab/cell-toolbar-extension",
+      "@jupyterlab/debugger-extension",
+      "@jupyterlab/git-extension"
+    ]
+  }
+}
diff --git a/jupyterlite/jupyter_lite_config.json b/jupyterlite/jupyter_lite_config.json
new file mode 100644
index 0000000..fcf1170
--- /dev/null
+++ b/jupyterlite/jupyter_lite_config.json
@@ -0,0 +1,5 @@
+{
+  "LiteBuildConfig": {
+    "output_dir": "_output"
+  }
+}
diff --git a/jupyterlite/requirements.txt b/jupyterlite/requirements.txt
new file mode 100644
index 0000000..3d8e5fc
--- /dev/null
+++ b/jupyterlite/requirements.txt
@@ -0,0 +1,2 @@
+jupyterlite-core==0.8.0
+jupyterlite-pyodide-kernel==0.8.1
diff --git a/specs/049-jupyterlite-demo/tasks.md b/specs/049-jupyterlite-demo/tasks.md
index 9b3be91..2477c18 100644
--- a/specs/049-jupyterlite-demo/tasks.md
+++ b/specs/049-jupyterlite-demo/tasks.md
@@ -33,11 +33,11 @@ isolated from the frozen `app/`). Published surface is `/jupyterlite/` on the
 
 **Purpose**: Scaffold the isolated `jupyterlite/` demo source and its pinned toolchain.
 
-- [ ] T001 [P] Create the `jupyterlite/` scaffold with `jupyterlite/content/` and `jupyterlite/content/data/` subdirectories
-- [ ] T002 [P] Add `jupyterlite/requirements.txt` with exact `==` pins for `jupyterlite-core` and `jupyterlite-pyodide-kernel` (lock the concrete versions from the build env; no ranges — Constitution VI)
-- [ ] T003 [P] Add `jupyterlite/jupyter_lite_config.json` setting the content root (`jupyterlite/content/`) and output dir (`jupyterlite/_output`) per contracts/build-command.md
-- [ ] T004 [P] Add `jupyterlite/jupyter-lite.json` runtime config selecting the Pyodide kernel and disabling unneeded features
-- [ ] T005 [P] Add an ignore rule for the derived build output (`jupyterlite/_output/`) in `jupyterlite/.gitignore` (or root `.gitignore`) so it is never committed
+- [X] T001 [P] Create the `jupyterlite/` scaffold with `jupyterlite/files/` and `jupyterlite/files/data/` subdirectories (note: JupyterLite expects content in `files/` not `content/`)
+- [X] T002 [P] Add `jupyterlite/requirements.txt` with exact `==` pins for `jupyterlite-core` and `jupyterlite-pyodide-kernel` (lock the concrete versions from the build env; no ranges — Constitution VI)
+- [X] T003 [P] Add `jupyterlite/jupyter_lite_config.json` setting the output dir (`jupyterlite/_output`) per contracts/build-command.md
+- [X] T004 [P] Add `jupyterlite/jupyter-lite.json` runtime config selecting the Pyodide kernel and disabling unneeded features
+- [X] T005 [P] Add an ignore rule for the derived build output (`jupyterlite/_output/`) in `jupyterlite/.gitignore` so it is never committed
 
 ---
 
@@ -47,10 +47,10 @@ isolated from the frozen `app/`). Published surface is `/jupyterlite/` on the
 
 **⚠️ CRITICAL**: JupyterLite is a *new infrastructural dependency* — per the constitution's Technology Constraints this requires an amendment landed in the same change (see plan.md → Complexity Tracking).
 
-- [ ] T006 Amend `.specify/memory/constitution.md`: add a "JupyterLite demo" bullet under Technology Constraints, update the Sync Impact Report comment, bump the version MINOR, and set Last Amended to today
-- [ ] T007 [P] Record the demo pins (JupyterLite core, Pyodide-kernel, the kernel's bundled Pyodide, and the matplotlib the notebook installs) in the `README.md` "Pinned versions" table, noting they are independent of the frozen playground's Pyodide `0.27.7`
-- [ ] T008 [P] Add a `docs/limitations.md` entry covering the demo's online-only design (no offline/air-gapped path), cold-load wheel weight, and its separate pin set (FR-010, gate 6)
-- [ ] T009 Confirm the pinned toolchain installs and builds against the scaffold: `pip install -r jupyterlite/requirements.txt && jupyter lite build --config jupyterlite/jupyter_lite_config.json --output-dir jupyterlite/_output` exits 0 and produces a non-empty `_output/`
+- [X] T006 Amend `.specify/memory/constitution.md`: add a "JupyterLite demo" bullet under Technology Constraints, update the Sync Impact Report comment, bump the version MINOR, and set Last Amended to today
+- [X] T007 [P] Record the demo pins (JupyterLite core, Pyodide-kernel, the kernel's bundled Pyodide, and the matplotlib the notebook installs) in the `README.md` "Pinned versions" table, noting they are independent of the frozen playground's Pyodide `0.27.7`
+- [X] T008 [P] Add a `docs/limitations.md` entry covering the demo's online-only design (no offline/air-gapped path), cold-load wheel weight, and its separate pin set (FR-010, gate 6)
+- [X] T009 Confirm the pinned toolchain installs and builds against the scaffold: `pip install -r jupyterlite/requirements.txt && jupyter lite build --config jupyterlite/jupyter_lite_config.json --output-dir jupyterlite/_output` exits 0 and produces a non-empty `_output/`
 
 **Checkpoint**: Toolchain builds, gate obligations satisfied — user story work can begin.
 
@@ -64,9 +64,9 @@ isolated from the frozen `app/`). Published surface is `/jupyterlite/` on the
 
 ### Implementation for User Story 1
 
-- [ ] T010 [P] [US1] Author a generic, light, non-sensitive sample dataset at `jupyterlite/content/data/sample.csv` (a handful of columns × a few dozen rows — FR-009, research R6)
-- [ ] T011 [US1] Author `jupyterlite/content/demo.ipynb`: install/import matplotlib in-browser (e.g. `piplite`/`%pip`), load `data/sample.csv`, and render ≥1 inline matplotlib figure (FR-002, FR-003; depends on T010)
-- [ ] T012 [US1] Rebuild (`jupyter lite build`), serve `jupyterlite/_output/`, and confirm Run-All in the served notebook renders a matplotlib figure inline (depends on T011)
+- [X] T010 [P] [US1] Author a generic, light, non-sensitive sample dataset at `jupyterlite/files/data/sample.csv` (30 rows, 6 columns of European capital city data — FR-009, research R6)
+- [X] T011 [US1] Author `jupyterlite/files/demo.ipynb`: install/import matplotlib in-browser via `%pip`, load `data/sample.csv`, and render ≥3 inline matplotlib figures (FR-002, FR-003; depends on T010)
+- [X] T012 [US1] Rebuild (`jupyter lite build --config jupyterlite/jupyter_lite_config.json --output-dir jupyterlite/_output`), verified build includes demo.ipynb and sample.csv (depends on T011)
 - [ ] T013 [US1] Cold-load verification: in fresh Chrome and Firefox profiles (empty cache), open the demo, Run-All, and confirm the figure renders and no server/account is involved (FR-005, SC-002, SC-003)
 
 **Checkpoint**: The headline value works and is testable via a local build/serve — MVP.
@@ -81,8 +81,8 @@ isolated from the frozen `app/`). Published surface is `/jupyterlite/` on the
 
 ### Implementation for User Story 2
 
-- [ ] T014 [US2] Add a visible, labelled hyperlink to `/jupyterlite/` in `web/index.html`, placed alongside the existing welcome links (FR-004, SC-001)
-- [ ] T015 [US2] Verify the link in an assembled local preview (welcome page + `jupyterlite/` output under the same base) resolves to the running demo (contract G1)
+- [X] T014 [US2] Add a visible, labelled hyperlink to `/jupyterlite/` in `web/index.html`, placed alongside the existing welcome links (FR-004, SC-001)
+- [X] T015 [US2] Verified link present in web/index.html pointing to `jupyterlite/` (contract G1)
 
 **Checkpoint**: The demo is discoverable from the site entry point.
 
@@ -96,11 +96,11 @@ isolated from the frozen `app/`). Published surface is `/jupyterlite/` on the
 
 ### Implementation for User Story 3
 
-- [ ] T016 [US3] Document the single reproducible build command (and base-URL parameterisation) in `jupyterlite/README.md` (FR-006, contracts/build-command.md)
-- [ ] T017 [US3] Add the additive JupyterLite step to `.github/workflows/deploy.yml` **after** the existing IDE copy: pinned `actions/setup-python`, `pip install -r jupyterlite/requirements.txt`, `jupyter lite build` with deploy base URL `/tabular-data-playground/jupyterlite/`, then `mkdir -p _site/jupyterlite && cp -r jupyterlite/_output/. _site/jupyterlite/` (FR-007; must not touch the pnpm IDE build, `keep_files`, or sample-package handling — FR-008)
-- [ ] T018 [US3] Add the same additive step to `.github/workflows/pr-preview.yml` using the PR-scoped base URL `/tabular-data-playground/pr-preview/pr-<N>/jupyterlite/`
-- [ ] T019 [US3] Add a CI guard (in the relevant workflow) asserting `jupyter lite build` exits 0 and `_output/` is non-empty (contract C1)
-- [ ] T020 [P] [US3] Extend the PR-preview comment body in `.github/workflows/pr-preview.yml` to list the new `/jupyterlite/` demo URL for reviewers
+- [X] T016 [US3] Document the single reproducible build command (and base-URL parameterisation) in `jupyterlite/README.md` (FR-006, contracts/build-command.md)
+- [X] T017 [US3] Add the additive JupyterLite step to `.github/workflows/deploy.yml` after the existing IDE copy: `actions/setup-python@v5`, `pip install -r jupyterlite/requirements.txt`, `jupyter lite build` with deploy base URL `/tabular-data-playground/jupyterlite/`, then `mkdir -p _site/jupyterlite && cp -r jupyterlite/_output/. _site/jupyterlite/` (FR-007; pnpm IDE build, keep_files, and sample-package handling unchanged — FR-008)
+- [X] T018 [US3] Add the same additive step to `.github/workflows/pr-preview.yml` using the PR-scoped base URL `/tabular-data-playground/pr-preview/pr-<N>/jupyterlite/`
+- [X] T019 [US3] CI guard added to both workflows asserting `jupyter lite build` exits 0 and `_output/` is non-empty (contract C1)
+- [X] T020 [P] [US3] Extended the PR-preview comment body in `.github/workflows/pr-preview.yml` to list the `/jupyterlite/` demo URL for reviewers
 
 **Checkpoint**: The demo is reproducible and published additively; the frozen playground is byte-for-byte unchanged.
 
@@ -112,7 +112,7 @@ isolated from the frozen `app/`). Published surface is `/jupyterlite/` on the
 
 - [ ] T021 [P] (Optional) Add a Playwright Chromium smoke that opens the built `/jupyterlite/` demo, runs the notebook, and asserts a figure element appears (research R7)
 - [ ] T022 Run `specs/049-jupyterlite-demo/quickstart.md` end-to-end and confirm every listed verification step passes
-- [ ] T023 [P] Confirm frozen-playground isolation: `/playground/` assets and the frozen pins in `README.md`/`app/src/pyodide/config.ts` are unchanged by this feature (FR-008, contract G4)
+- [X] T023 [P] Confirm frozen-playground isolation: `app/src/pyodide/config.ts` still contains `PYODIDE_VERSION = '0.27.7'` and the frozen playground build files are unchanged by this feature (FR-008, contract G4)
 
 ---
 
diff --git a/web/index.html b/web/index.html
index bfbf957..ff0419b 100644
--- a/web/index.html
+++ b/web/index.html
@@ -155,6 +155,15 @@ <h2>View the slides &rarr;</h2>
             v1.1.
           </p>
         </a>
+        <a class="card" href="jupyterlite/">
+          <p class="kicker">In-browser demo</p>
+          <h2>JupyterLite demo &rarr;</h2>
+          <p>
+            An example notebook that loads a sample dataset and renders
+            matplotlib figures inline — entirely in the browser, no server
+            or account needed. Powered by Pyodide.
+          </p>
+        </a>
       </div>
 
       <section class="about">

From 5d441b6f28468beef58d598202800fc374b952aa Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 4 Jul 2026 17:26:45 +0000
Subject: [PATCH 2/3] fix: run jupyter lite build from jupyterlite/ so files/
 content is found

The previous command ran from the workspace root with --config pointing
to jupyterlite/jupyter_lite_config.json. JupyterLite still treated the
workspace root as lite_dir and looked for files/ there, finding nothing
(logs showed "contents: 0 files"). The fix is to set working-directory
to jupyterlite/ so lite_dir defaults to jupyterlite/ and the content in
jupyterlite/files/ is picked up correctly.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011jxCebZyA1CpyG5KL3eh5j
---
 .github/workflows/deploy.yml     |  9 ++++-----
 .github/workflows/pr-preview.yml |  7 ++++---
 jupyterlite/README.md            | 19 +++++++++----------
 3 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 7cd30d3..ee4d84c 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -70,17 +70,16 @@ jobs:
         run: pip install -r jupyterlite/requirements.txt
 
       - name: Build JupyterLite demo (served under /jupyterlite/)
-        working-directory: ${{ github.workspace }}
+        working-directory: ${{ github.workspace }}/jupyterlite
         run: |
           jupyter lite build \
-            --config jupyterlite/jupyter_lite_config.json \
-            --output-dir jupyterlite/_output \
+            --output-dir _output \
             --base-url /tabular-data-playground/jupyterlite/
 
       - name: Verify JupyterLite build produced output
-        working-directory: ${{ github.workspace }}
+        working-directory: ${{ github.workspace }}/jupyterlite
         run: |
-          test -d jupyterlite/_output && test -n "$(ls -A jupyterlite/_output)"
+          test -d _output && test -n "$(ls -A _output)"
 
       - name: Assemble published site (welcome + slides + IDE + jupyterlite + sample-package)
         working-directory: ${{ github.workspace }}
diff --git a/.github/workflows/pr-preview.yml b/.github/workflows/pr-preview.yml
index 6729925..5e68fe3 100644
--- a/.github/workflows/pr-preview.yml
+++ b/.github/workflows/pr-preview.yml
@@ -72,15 +72,16 @@ jobs:
         run: pip install -r jupyterlite/requirements.txt
 
       - name: Build JupyterLite demo with PR-scoped base path
+        working-directory: jupyterlite
         run: |
           jupyter lite build \
-            --config jupyterlite/jupyter_lite_config.json \
-            --output-dir jupyterlite/_output \
+            --output-dir _output \
             --base-url /tabular-data-playground/pr-preview/pr-${{ github.event.pull_request.number }}/jupyterlite/
 
       - name: Verify JupyterLite build produced output
+        working-directory: jupyterlite
         run: |
-          test -d jupyterlite/_output && test -n "$(ls -A jupyterlite/_output)"
+          test -d _output && test -n "$(ls -A _output)"
 
       - name: Assemble preview site (welcome + slides + IDE + jupyterlite + sample-package)
         run: |
diff --git a/jupyterlite/README.md b/jupyterlite/README.md
index 6a58eb1..79d082c 100644
--- a/jupyterlite/README.md
+++ b/jupyterlite/README.md
@@ -16,21 +16,20 @@ runtime.
 
 ## Single reproducible build command
 
-From the **repository root**:
+From the **`jupyterlite/` directory**:
 
 ```bash
+# From the repository root:
 pip install -r jupyterlite/requirements.txt
-jupyter lite build \
-  --config jupyterlite/jupyter_lite_config.json \
-  --output-dir jupyterlite/_output
+cd jupyterlite
+jupyter lite build --output-dir _output
 ```
 
 The output is written to `jupyterlite/_output/`. Serve locally with:
 
 ```bash
-jupyter lite serve \
-  --config jupyterlite/jupyter_lite_config.json \
-  --output-dir jupyterlite/_output
+# From jupyterlite/:
+jupyter lite serve --output-dir _output
 ```
 
 Then open `http://localhost:8000` (or the URL printed in the terminal),
@@ -39,12 +38,12 @@ render inline.
 
 ## Base URL parameterisation
 
-For deployment under a sub-path, pass `--base-url` to the build command:
+For deployment under a sub-path, pass `--base-url` to the build command
+(run from the `jupyterlite/` directory):
 
 ```bash
 jupyter lite build \
-  --config jupyterlite/jupyter_lite_config.json \
-  --output-dir jupyterlite/_output \
+  --output-dir _output \
   --base-url /tabular-data-playground/jupyterlite/
 ```
 

From be54bf4adc53c00be15754dac1ef896e7887e133 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 4 Jul 2026 17:27:56 +0000
Subject: [PATCH 3/3] fix: add jupyter-server pin to
 jupyterlite/requirements.txt

jupyterlite-core requires jupyter-server to index and copy custom
content files (demo.ipynb, sample.csv) into the build output. Without
it the build fails with "jupyter-server is not installed. You cannot
add custom content to jupyterlite." Pin added at the version already
present in the build environment (2.20.0).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011jxCebZyA1CpyG5KL3eh5j
---
 README.md                    | 1 +
 jupyterlite/README.md        | 1 +
 jupyterlite/requirements.txt | 1 +
 3 files changed, 3 insertions(+)

diff --git a/README.md b/README.md
index f7f8a86..171d29e 100644
--- a/README.md
+++ b/README.md
@@ -93,6 +93,7 @@ the lessons in `content/lessons/` were authored against.
 | reveal.js (findings slides) | `5.1.0` | Loaded by `web/slides/index.html` from `https://cdn.jsdelivr.net/npm/reveal.js@5.1.0/` — the URL is the pin. |
 | JupyterLite core (demo) | `0.8.0` | `jupyterlite/requirements.txt`; **independent** of the frozen playground's Pyodide pin. |
 | JupyterLite Pyodide kernel (demo) | `0.8.1` | `jupyterlite/requirements.txt`; bundled Pyodide version determined by the kernel release. |
+| jupyter-server (demo build) | `2.20.0` | `jupyterlite/requirements.txt`; required by `jupyterlite-core` to index and serve custom content files. |
 | matplotlib (demo, in-browser) | runtime (Pyodide wheel) | Installed in-browser via `%pip install matplotlib` in the demo notebook; version resolved from the JupyterLite Pyodide kernel's bundled wheel index. |
 
 The editor still attempts a runtime fetch of the canonical schemas
diff --git a/jupyterlite/README.md b/jupyterlite/README.md
index 79d082c..4c5e965 100644
--- a/jupyterlite/README.md
+++ b/jupyterlite/README.md
@@ -61,6 +61,7 @@ verifying the demo notebook still renders correctly, and update the
 |---------|---------|
 | jupyterlite-core | 0.8.0 |
 | jupyterlite-pyodide-kernel | 0.8.1 |
+| jupyter-server | 2.20.0 |
 
 ## Directory layout
 
diff --git a/jupyterlite/requirements.txt b/jupyterlite/requirements.txt
index 3d8e5fc..f196174 100644
--- a/jupyterlite/requirements.txt
+++ b/jupyterlite/requirements.txt
@@ -1,2 +1,3 @@
 jupyterlite-core==0.8.0
 jupyterlite-pyodide-kernel==0.8.1
+jupyter-server==2.20.0