A complete machine learning lab that runs entirely in your browser. Drop a CSV, audit and clean it, train and compare models, understand where they fail, and score new data — your dataset never leaves your machine.
Live at app.dominicdapice.com · MIT licensed · Built by Dominic D'Apice
More about this project → LabML — ML in Your Browser: a Complete Machine Learning Lab With No Backend — an 11-minute write-up of the bet behind the project and how each section works. Available in English and French.
LIMITATION: The ideal dataset size is between 1MB and 30MB; beyond 30 MB, the browser response time may take longer to return the results.
Drop titanic.csv, pick a column to predict, press train. Eight model families train in your
own browser — the naive baseline among them — and an ensemble of the top three joins the
ranking for free, since its members are already fitted. Every model is selected on a
validation split and reported on a third split it never touched, with the gap between the two
spelled out: here the winner is picked at 0.818 and scores 0.792, and the page says so.
Past the ranking, the run answers two more questions. How sure is the model of one row? It can answer with a set of classes or a value with a margin, at a coverage you choose, and the coverage actually measured on the test split is shown beside that target. Did every step of the run succeed? When one fell back (an ensemble that could not be built, a helper worker that gave up), a run journal says which and why, instead of leaving a result one row short.
LabML is a privacy-first, offline-capable web application covering the full tabular ML workflow — data quality, training, evaluation, explanation, and reuse — with no backend, no accounts, and no uploads. Every computation (parsing, cleaning, training, inference) runs in Web Workers on the user's own machine.
The project follows three non-negotiable principles:
- Privacy by architecture. A strict Content-Security-Policy allows zero third-party
calls. Data lives in worker memory; persistence (run history, opted-in datasets) uses
IndexedDB locally; share links carry metrics in the URL fragment, which browsers never
send to any server.
/privacystates this in plain language and hands the reader a four-step protocol to verify it in their own DevTools — the policy quoted there is pinned to the served header by a unit test, so the page cannot claim a protection the site stopped shipping. If a screen fails, the recovery view can copy a bounded technical report on request; it excludes error messages, URL parameters, file names, and dataset content, and is never sent automatically. - Honest evaluation. Every run is scored against a naive baseline on a held-out test set. Models are selected on a validation split and reported on a third, never-selected test split, with the gap between the two shown — crowning the best of nine on the reporting set is what makes a headline figure optimistic. Metrics ship with 95% bootstrap intervals, per-segment breakdowns, calibration curves, and explicit refusals when a number would be noise (tiny slices, tiny test sets, a model whose probabilities are saturated). The ranking metric is yours to pick — accuracy rewards always answering the majority class, so on an imbalanced target you rank on F1 or recall instead, and the order changes.
- Hand-written, deterministic ML. The model zoo, search, explanations, and statistics are implemented from scratch in TypeScript, seeded end to end — the same seed always reproduces the same run. Core metrics plus compatible ridge and k-NN predictions are checked against committed scikit-learn references generated outside the TypeScript implementation, including the edge where a class is missing from the rows being scored: macro averages run over the classes present, as scikit-learn computes them.
| Area | What it does |
|---|---|
| Data in | Drag & drop CSV/Excel (parsed in a worker), demo datasets, per-column profiling, automatic task detection, smart exclusions and target-leakage detection; a French export reads correctly — encoding settled by decoding and failing (not sniffing), delimiter and decimal separator detected per column and announced with the count that proved them; free-text columns join the pipeline as hand-written TF-IDF (FR/EN tokenization, capped vocabulary, fitted on the training split only); the same reader and the same 20-million-cell memory budget serve the ML Lab, the Data Studio, the data assistant and batch scoring, so a file is never refused by name in one section and left to exhaust the tab in another |
| Models | 8 classifiers / 7 regressors trained live: naive baseline, linear/logistic regression, k-NN, Gaussian Naive Bayes, decision tree, random forest, hand-written histogram gradient boosting (LightGBM-style) and MLP (seeded He init, Adam) |
| Leaderboard | Accuracy/F1/ROC-AUC/log-loss or RMSE/MAE/R², delta vs baseline, train time, inference latency p50/p95, 95% bootstrap intervals with a paired winner-vs-baseline verdict |
| Prediction sets | Split conformal prediction for the inspected model: a set of classes or a value with a margin, at an 80, 90 or 95 % coverage target, with the coverage measured on the test split shown beside the target and its interval. The threshold is calibrated on one half of the test split and measured on the other, both ways, never on validation: validation chose the winner, and a threshold calibrated there covered 77.4 % for a target of 80 on the mpg sample. A level the split cannot carry is refused with the numbers |
| Understanding | Confusion matrix, ROC, permutation importance, partial dependence, live what-if with exact Shapley explanations, signed word effects for text columns (which words push the answer up or down), plain-language read (FR/EN, rule-generated) |
| Where it fails | Per-segment analysis: the test set sliced by every categorical column — including excluded ones, where proxy effects hide — worst gaps first |
| Group audit | Does the model treat groups differently? On one column the user names (the lab never picks it), each group gets its selection rate, recall and false-alarm rate with a Wilson interval, and every gap to the largest group carries its own interval: real, or inside the noise, which the panel refuses to read as equal treatment. Groups under 20 test rows are listed, not compared. A finding, not a verdict: no legal threshold, no correction |
| Test-set ledger | Has this test set been used too much? Comparing runs on one test set and keeping the best is choosing with it. The ledger counts the distinct configurations a test set has scored (retraining the same one counts for nothing), per file and target, in a table that survives deleted runs. Marks measured on the demos: the best of 5 runs sits 0.2 to 0.8 times the split-to-split noise above its real level, up to that noise from 10. From the first mark it offers a fresh split (the next seed), says it is the same rows redealt and not new data, and refuses the draw on a chronological split, which has one test set. |
| Production check | Is this model still good on the file that just arrived? Every scored batch gets one verdict (stable, watch, retrain) from three signals: the columns, the model's answers, and the performance when the file carries labels. The reference travels inside the model export (format 5: bin edges, shares and counts, never a row), so a re-imported model checks a batch months later. A drift counts only above its own simulated noise ceiling: the usual fixed PSI thresholds raised a strong alert on 8 to 78 % of 100-row batches in which nothing had moved, the ceiling on 1.5 to 6 %. And only a measured drop on labelled rows says « retrain »: a drift alone stops at « watch ». |
| Imbalance | Precision-recall curve (AP), calibration curve (Brier), cost-priced decision threshold with the optimal cut computed by exhaustive sweep, and a multiclass decision policy — one threshold per class, normalized-margin tie-break, explicit abstention instead of a silent argmax fallback, tuned on validation and frozen before the test reveal. The cost-optimal cut is suggested on validation and measured on test: picked on the test set it was fitted to it, and the cost shown read 33 to 60 % below the honest one on the fraud sample |
| Tuning | Seeded random search scored by stratified 3-fold cross-validation, pipeline refitted inside each fold — the test set is scored exactly once |
| More data? | Learning curve on demand: one model retrained on growing seeded nested fractions, 95% bootstrap band, plain verdict — still climbing (collect more rows) or flattened (work on features) — including whether an announced training cap costs accuracy |
| No target? | Seeded k-means (k chosen by silhouette) + power-iteration PCA projection, groups described in plain language; date column? Holt-Winters forecasting validated by rolling-origin backtest |
| MLOps loop | Score a new batch with honest test-vs-batch metrics; compare two runs side by side with cross-run uncertainty verdicts, or up to six at once read against the oldest of the selection; export a model as JSON and re-import it later — the exact predictor is rebuilt (byte-identical predictions) and scores any CSV without retraining |
| Python bridge | A run, redone with scikit-learn. One readable script carries the row numbers of each split and the preprocessing, and translates each model to its nearest estimator. It does not promise the lab's figures: it prints them next to its own, with the gap. Measured on 30 runs: the encoded matrix is equal to within 2.9e-14, the baseline, the linear regression and the naive Bayes agree to the last digit, k-NN agrees until two neighbours tie, and the hand-written families differ by up to several test rows on one split. A column name is never code: the run travels as one JSON block. |
| Competition path | An unlabelled file becomes a submission. Under a scored batch, one block writes an identifier and a prediction under the names the platform expects: a class, a probability or a value, every row kept in its order, missing and repeated identifiers counted. The lab guesses neither the identifier nor the names. The same family can be fitted again on every labelled row, announced as a model nobody measured: on the demos, against rows kept away from both models, it gained 5 accuracy points on the smallest text file, 0.8 on titanic, 2 to 3 % of RMSE on two regressions, nothing on two others, and lost one time in five to one in three even where it paid |
| Glass box | One row, replayed through the model. Beside the Shapley explanation (what weighed), a replay tells what happened: the questions a decision tree asked, in the units of the file, and the training rows that share its leaf; the count of a forest's 40 trees; the five rows of the file a k-NN compared it to, with its ties flagged; the prediction a boosting builds round after round, and its error on the validation rows. The replay walks the model itself: measured on 2,560 test rows of the demos, its last step is the model's answer on every one. The replay showed the boosting's validation error turning well before its last round; early stopping was then measured on rows kept away from everything and not built: fewer rounds improved the probabilities, not the predictions |
| Counterfactuals | What would have to change. For one row of a classification, the smallest change, one column or two, that makes the inspected model answer another class: only values the training rows hold, the columns the user locks left alone, free text never edited, and a plain « nothing found » with what was tried. Each change carries two readings the measure made necessary: whether the changed row still looks like a training row (8 to 60 % of the nearest changes did not), and how many of the other trained models follow it (14 to 54 % did). A counterfactual speaks of the model, not of the world |
| Twin columns | Two columns that say the same thing are flagged, not removed. As soon as a file is read, a column that maps one to one onto another (class and pclass), or can be read off another (adult_male off who), says so on its card. Twins split the importance between them and let a counterfactual change one without the other: on titanic 43 % of the first counterfactuals did. Removing them moves no score, so the lab leaves the choice to the user |
| Filled cells | What stood in for a missing cell is counted. A missing number has always become the training median and a missing category the most frequent one, in silence. The run, the report, the model card and a scored file now say, per column, how many cells were empty, how many could not be read as a number, and what replaced them. On titanic deck is 77 % filled: past one half the run says the column is mostly its fill value. Keeping it, dropping it or recoding it moved no score, so the lab reports and leaves the choice to the user |
| Speed | Heavy families train on helper cores (announced on the leaderboard, split by measured cost, never silent), and a model crosses back as JSON so it is rebuilt through the same path an imported model uses. Measured on a 60 000-row run: 74 s → 9.5 s, with every leaderboard number identical. Every best-effort step that gives up is recorded in a run journal shown with the leaderboard and in the report: which step, which family, how many times, and the error it met |
| Persistence | Local run history with attached artifacts, opted-in dataset storage (compressed, explicit 50 MB budget), self-contained HTML reports, data-free share links (a damaged link is refused, never half-rendered) |
| Model card | A page for whoever must decide to use the model, in HTML or Markdown: intended use, data, performance with its interval, the selection gap, prediction-set coverage, the decision rule, where it fails, the run journal, and limits. The intended use is typed by the user; left empty the card says « not stated » and calls itself incomplete rather than guessing. Every analysis the run does not carry is listed under « Not assessed », and each section names the model it describes when that is not the winner |
What the run gives you, past the ranking:
Every figure above was produced by the app itself, on the titanic.csv sample, seed 42 —
reproducible by pressing train.
- Quality report with a deterministic 0–100 score: missing cells, duplicates, case/whitespace variants, Tukey-fence outliers, constant/near-empty/id columns.
- Replayable cleaning recipe — trim, merge variants, deduplicate, impute, clamp outliers, force column types, expand dates — exportable as JSON and re-runnable on new files, with a seeded isolation-forest anomaly step for multivariate outliers.
- Per-column steps: the file-wide settings are defaults a column may override —
median, mean, most-frequent, a constant, or a « MANQUANT » category. Every imputed
column can add a
<column>_absentmissing indicator, written before anything is filled; columns filled without one are named out loud, because a blank field is rarely blank at random and filling it silently erases that. - Validity rules: a value can be present, correctly typed and still impossible — an age of 200, a date in the future, a percentage at 130, a malformed postcode. Plus cross-column consistency: an end date before its start, a total that is not quantity × price. Every rule fires on evidence rather than on a column's name, and reports without ever repairing — the recipe is where data changes.
- The quality score, broken into its parts: each with its weight, what it found and what it cost, instead of a number asserted without explanation.
- An auditable before/after diff of what the recipe did — which rows, which columns, which values — and a replayable reference profile (bin edges and shares, never rows) so a new file can be checked for drift against a snapshot you no longer hold.
- Left-join a second file on a shared key: match rate, duplicates and orphans are named, never silent; the joined result becomes the working dataset.
- Drift check: compare a new batch against the reference — schema diff, PSI per column, new/vanished categories, and a severity given only to a PSI above its noise ceiling. Two halves of one 120-row file « drifted » in every report under the fixed thresholds (0.1 and 0.25), which read a small file as a drift; with the ceiling, simulated at the real sizes of the two files, they do in 3 to 9.5 %.
- Data contract: freeze what a reference file looks like (columns and how they read, missing values, the rules that applied, each distribution) and read the next file against it, clause by clause. A fact breaks a clause outright, an estimate counts only beyond its noise, a drift is a warning. It says what the quality report cannot: the report's rules stop applying once a fifth of a column is impossible, so 178 ages of 999 go unreported where 134 are flagged. Names, bounds, shares and counts; never a row.
- One reader for every section: a drift or join file is read exactly like the main one, decimals included, and the Studio stops at the same named memory budget as the ML Lab instead of letting the tab die.
- One-click hand-off to the ML Lab.
- Markdown committed to the repository (
src/content/docs/<lang>/*.md) and compiled at build time on the Diátaxis split, with a local search index — no parser and no third-party documentation host ever reaches the browser. Every figure a page quotes is asserted against the running app (e2e/docs.spec.ts): a page that drifts breaks the build. Quoting a wall-clock duration is forbidden by its own test, because two identical runs agree on every metric and disagree on every timing. « Try it » links are deep links (/ml?demo=titanic&target=survived) rather than screenshots, so they cannot go stale unnoticed. - The table of refusals (
/docs/refus): every named refusal the app can raise — what triggers it, what it means, what to do — extracted from the source, not written from memory. A test re-extracts it on every run in both directions: a code thrown but undocumented fails the build, and so does a documented code the app no longer throws. Refusing well is this project's distinguishing feature; a refusal nobody can decode reads as a bug instead of the decision it is. - What LabML does not do (
/docs/limites): the features set aside, the ones dropped after measurement, and the predictions measurement refuted — extracted from the engineering log rather than recalled, because memory flatters. A guard traces each figure back to the entry that recorded it. Twelve pages per language span all four Diátaxis quadrants, and a test asserts every one of them ends with a working next step: documentation without one is a dead end.
The index is built at compile time and queried in the tab — typing here sends nothing.
- Vision (
/ai/vision): on-device image analysis on ONNX Runtime Web (WebAssembly) with three self-hosted models — EfficientNet-Lite4 classification (1,000 ImageNet classes, 77.6% top-1), YOLOX-Nano object detection (80 COCO classes) and UltraFace face detection — boxes drawn on the image, hand-written and unit-tested box decoding (grids, IoU, NMS), webcam supported; the photo never leaves the browser. It also says when it cannot answer: ImageNet-1k has 1,000 labels, 118 of them dog breeds and none for a human being, so a photo of someone comes back as « football helmet » at 86.6% — confidently, because a softmax cannot abstain. When the two detectors agree a person is in frame, or when the top class falls below 50%, the page says so and keeps the label visible rather than presenting it as the answer. Measured on a 14-image bench replayed in the real browser (e2e/vision-bench.spec.ts): all four images ImageNet cannot name are refused, the one wrong label is announced as wrong, and no correct answer is lost. - Analytical SQL (
/data): a real OLAP engine — DuckDB-Wasm, MIT, self-hosted and single-threaded — queries the loaded file in the browser, plus any CSV, Parquet or JSON attached in the session. A result exports to CSV or Parquet, or moves to the ML Lab, in one click, written by the engine itself: every row of it, not the 200 the console paints; SQL errors show DuckDB's own message. The engine is pinned to 1.28.0 for a measured reason: from 1.29 its binaries exceed Cloudflare's 25 MiB per-file limit. - Data assistant (
/ai/chat): plain French or English questions about a loaded dataset (averages, counts, top-N, correlations…) answered by a deterministic local interpreter — when it does not understand, it says so. The file is read by the same reader as the ML Lab, so a French export (semicolons, decimal commas, windows-1252) gives numeric columns here too, under the same memory budget. It only claims to understand once it has read the whole question: a word it cannot account for is a refusal, not an answer to a shorter question. A real local language model (Qwen3-0.6B, 355 MB, Apache-2.0, self-hosted and split into 24 MiB parts to clear Cloudflare's limit) can be downloaded on explicit consent to read free-form phrasings: it only translates the question into a query — the deterministic engine still computes every number, and a badge under each answer names which engine produced it. The translation is decoded inside the query grammar: a hand-written logits processor masks, at every token, everything that would leave the grammar, so an invented column, an operator that does not exist or a category the column does not hold cannot be written in the first place. One shape stays reachable on purpose —{"kind":"none"}, the model's way of saying it cannot express the question — because forcing a valid answer turns a refusal into a wrong number. The reading of all 55 reference questions is measured, not asserted: see Measuring the assistant below. WebGPU required; without it the refusal is named and the deterministic interpreter stays fully available.
Both photos ship with the repository's vision bench: the school bus is CC BY 2.0 (Fahim Fadz., Wikimedia Commons), the portrait is NASA, public domain.
- Everything off the main thread. Parsing, cleaning, training, scoring and analysis run in dedicated Web Workers behind typed message protocols. Every answer a worker can send has exactly one handler, checked by the compiler, and an answer that arrives for a state already thrown away is dropped: the target and the features are locked while a computation that depends on them runs, so a result can never be filed under a question it did not answer. A worker that crashes is replaced rather than left holding the page, and the DuckDB engine is closed when its panel goes away.
- From-scratch algorithms, unit-tested against known results: gradient boosting (quantile bins, second-order gains, Newton leaves), MLP, k-means++, PCA, Holt-Winters, isolation forest, PSI, Shapley values, bootstrap intervals, PR/ROC/calibration curves, TF-IDF (bilingual tokenizer, smoothed IDF, L2-normalized vectors), and detection post-processing (YOLOX grid decode, IoU, non-maximum suppression).
- Leakage discipline. Preprocessing (imputation, one-hot/ordinal encoding, standardization) is fitted on the training split only; cross-validation refits the pipeline inside each fold; forecast backtests never peek at the future. Dated files can be split chronologically and grouped files by group, both announced — a random split puts the future in training. A one-column stump flags any lone column that predicts the target at 99%: that is a leak warning, never a victory.
- Validation chooses, the test measures. A figure shown beside a choice is never computed on the rows that made the choice: the winner is picked on validation and reported on test, the cost-optimal threshold likewise, and a conformal threshold is calibrated on one half of the test split and judged on the other. Each of those rules was adopted after measuring what its absence cost.
- No silent fallback. A step that is allowed to give up says so: the fallback stays, and a bounded run journal records it. Twenty-one other silent handlers were reviewed and left as they are, each for a stated reason.
- Determinism. A single seed drives splits, model initialization, search, sampling and resampling — runs are exactly reproducible, and the test suite depends on it.
- Scale, honestly. 100k–1M-row files train comfortably: past 100 000 usable rows an announced seeded stratified sample takes over (never silent — the leaderboard says so), slow model families train on measured, announced caps scored against the same full test set, and parsing refuses past a named 20M-cell memory budget instead of letting the tab die, in every section and for a batch to score.
- Performance. Every page — the sections, the home page and each of the fifteen
documentation URLs — serves a prerendered static shell (hero paints before JavaScript;
a doc page carries its whole article, in English until the app mounts); Lighthouse
mobile ≈ 0.99 on
/mlunder real throttling. Heavy dependencies (Dexie, SheetJS, ONNX Runtime) load lazily. - Quality bar. 1355 unit tests and 136 Playwright end-to-end tests across five
projects — desktop, a phone viewport in English and in French, dark mode, and
Cloudflare Pages' own routing emulated by
wrangler pages dev(a real 404, the security headers as served) — covering offline PWA, a fake webcam, a horizontal-overflow guard on every route, and axe-core WCAG A/AA checks on every page including the twenty-four documentation pages. Plus strict TypeScript, ESLint, Prettier, Lighthouse budgets and a coverage floor set from the measured baseline (statements, branches, functions, lines), all enforced in CI. - Supply-chain checks. Dependabot reviews npm and GitHub Actions weekly, CodeQL
analyzes JavaScript and TypeScript on pull requests and
main, and CI blocks critical advisories anywhere plus high advisories in dependencies shipped to production. Every GitHub Action is pinned to a full commit SHA, no checkout leaves the git token on the runner, no pull-request value is expanded inside a script, and zizmor audits the workflows on every pull request. A test holds each of those rules per workflow file. The local language model is fetched at a pinned Hugging Face revision, notmain, and every file is verified by size and SHA-256; the three vision models committed here are pinned by SHA-256 too. Every job has a time limit, the browser install retries on a network error, and no step forgives a failure wholesale. The lint reads type information for the rules that catch a promise nobody awaits, and covers the build scripts as well as the source. - One dependency does not come from npm. SheetJS left the registry, and the copy
still published there (
xlsx@0.18.5) carries two unfixable high advisories. The dependency points at the project's official tarball instead, which fixes both;package-lock.jsonpins its integrity hash, so a tampered download failsnpm cirather than shipping. It is still fetched at install time and bundled — the browser calls nobody.
React 19 · TypeScript (strict) · Vite · Tailwind CSS v4 · react-router · zustand · i18next (bilingual EN/FR) · Dexie (IndexedDB) · Papa Parse · SheetJS · ONNX Runtime Web · DuckDB-Wasm · Transformers.js · Vitest + Testing Library · Playwright · GitHub Actions · Cloudflare Pages
Requires Node 22.12+ (the floor Vitest 5 sets; CI runs Node 22).
npm ci # install dependencies
npm run dev # start the dev server| Script | Purpose |
|---|---|
npm run test |
Unit tests (Vitest) |
npm run test:coverage |
Unit tests with the coverage floor CI enforces |
npm run e2e |
End-to-end tests (Playwright) |
npm run typecheck |
TypeScript, strict mode |
npm run lint / npm run format:check |
ESLint / Prettier |
npm run build |
Production build to dist/ |
npm run preview |
Serve the production build locally |
npm run llm:prepare |
Fetch and split the local LLM |
npm run changelog |
Regenerate CHANGELOG.md from PLAN.md and align the version |
The language model behind the data assistant is not committed (355 MB). npm run llm:prepare downloads it into public/llm/ and splits it into parts under Cloudflare's
25 MiB per-file limit; CI runs it before the production build. Skip it and everything
else works — the assistant simply falls back to its deterministic interpreter, which is
the default in any case.
src/features/ai/llm/corpus.ts holds 55 reference questions, French and English,
across every shape of the query grammar plus three that no query can answer — where
refusing is the only correct outcome. Two harnesses run the same corpus:
| Command | Needs | Measures |
|---|---|---|
npm run test (corpus.test.ts) |
nothing | the deterministic parser, the grammar automaton, the token mask |
npm run llm:fetch && npm run llm:bench:node |
355 MB on disk, a few CPU minutes | the real model, end to end |
V27_BENCH=1 npm run build && node scripts/run-llm-bench.mjs |
a GPU with shader-f16 |
the same, on the shipped WebGPU runtime |
The CI half runs on every commit and asserts the number that matters most: the
deterministic parser produces zero wrong answers on the corpus. The model half is a
separate on-demand workflow (.github/workflows/llm-bench.yml) — it downloads 355 MB and
takes minutes, which is not a cost worth adding to every pull request.
The bench takes the model as a parameter, which is how « would a bigger model read better? » stops being an opinion:
LABML_LLM_REPO=onnx-community/Qwen3-1.7B-ONNX npm run llm:bench:node
Measured on the same 55 questions: Qwen3-1.7B (1.43 GB, four times the download) scores worse — 40 right / 12 wrong against 42 / 7 for the 355 MB model that ships. It reads the grouped comparisons a small model refuses, and misreads simple counts. The prompt was tuned against the small model, so that number is a property of the pair, not of the model; see PLAN.md § N for the full result and its limits.
CI builds, tests and deploys on every push: pull requests get a Cloudflare Pages preview,
main deploys to production. Required repository secrets: CLOUDFLARE_API_TOKEN and
CLOUDFLARE_ACCOUNT_ID — see docs/guide-cloudflare.md.
Development proceeds in planned "caps" of feature waves; seven caps have shipped and an eighth is under way. The first six took it from the MVP to the lab meeting the real world (real photos, real text, real file sizes). Cap 7 made what already ships hold up under pressure: worker lifecycle, damaged share links, CI hardening, metric edge cases, a store refactor, and major upgrades taken one at a time (Vitest 5 and vite-plugin-pwa 2 shipped; TypeScript 7 typechecks this code with no error in 1.5 s instead of about 11, and waits for typescript-eslint to support it).
Cap 8 takes the lab from an honest score to a model one can defend and watch. Delivered so
far: the decision threshold suggested where it is not graded (V53), one ingestion and one
memory budget for every section (V54), a run journal for the fallbacks that used to be
silent (V55), CI and supply-chain guards (V56), prediction sets with a measured
coverage (V57), a model card that lists what was never assessed (V58), a group audit
on a column the user names (V59), a test-set ledger that counts the runs a test set
has arbitrated (V60), a production check that reads a new batch against a reference
carried by the model export (V61), and a noise ceiling under the Data Studio's drift
report, which had been calling small files drifted (V62), a data contract that
requires of the next file what was found on a reference (V63), and a scikit-learn script
that redoes a run outside the browser and measures its own gap (V64), a submission file
for a competition (V65), a step-by-step replay of one row through the model (V66), early
stopping for the boosting, measured and not built (V67), counterfactuals (V68), and a SQL
result that reaches the lab whole instead of its first 200 rows (V69), and twin columns
flagged before training (V70), and a count of the cells the lab fills in (V71). Proposed,
none scheduled: seven items from a new reading of the repository, listed in PLAN.md (ranking on probabilities, an honest forecast band, and
others). The consented generative chat (V12) stays
postponed by product decision. No wave starts without an explicit launch command. The full plan, delivery log and design decisions live in
PLAN.md; CHANGELOG.md is extracted from it — one entry per
wave, newest first — by npm run changelog, and a test fails when the two disagree.
MIT © Dominic D'Apice
Redistributed third-party material — the vision and language models, the self-hosted WebAssembly runtimes, and the demo datasets — is attributed in NOTICE.












