Files
pplus-web/tests/bridge.test.mjs
T
alexmandClaude 82e18f7966 Move the engine core into core/, a project of its own (pplus-core)
What programs mean (the languages, translators, Mojo checker and
interpreter, prover, fuzzer, machine model, catalog problems and the Mojo
corpus with godbolt's stored answers) was mixed into the site's tree, so a
change to the prover and a change to a button went through the same gate
and the same docs. This moves all of it under core/, laid out as its own
repository, ready to be extracted with its history and pinned here as a
git submodule.

- core/: src/{engines,services,sync,mojo,exercises,curriculum,common},
  mojo/, syntax/mojo.xml, its tests (with Workspace and workForProblem in
  place of the site's Session), scripts (corpus pipeline, play, the
  exercise and probe starters, engines export/diff), and its docs
  (engines, trust, mojo-corpus, exercises, coverage). Its own pixi.toml,
  package.json, README, AGENTS.md and CI workflow.
- core/tests/boundary.test.mjs: library modules use no DOM, import no
  page widget, and import nothing outside src/.
- core/scripts/cli.mjs: pixi run cli check|run|prove|fuzz|translate.
- core/scripts/dafny.py: Dafny 4.11.0 pinned by version and SHA-256 per
  platform, fetched into .tools/ (pixi run dafny-fetch, pixi run dafny).
- The site imports core only as #core/<path>.js: an import map in
  index.html, "imports" in package.json for node, core's declarations for
  tsc. The site's TypeScript builds core first (npm run build).
- assemble.sh, the Quarto engine copy, the render cache key, check-pages,
  quarto-export and quarto-css read core/dist and core/mojo; quarto-css
  copies core's syntax/mojo.xml into the extension.
- Site tests that covered engines moved to core; the rest keep Session.
- README, AGENTS.md, docs/app.md, docs/deploy.md and the CI workflow
  describe the split (checkout with submodules; core's tests and corpus
  status run against the pinned commit).

Gate: site 110 pass; core 307 pass; corpus status --strict passes.
Manual check: the assembled site opens Bridge (count-base-proved),
Developer and Hardware (count-base) with the editor, the stepper and the
board, and no module errors.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FgvbRdoEheAHqsRmr2WuKZ
2026-10-05 05:43:58 +00:00

133 lines
7.3 KiB
JavaScript

// Stage 10 (and the part of stage 11 it needs): the Bridge's session behavior, without a DOM. In the Bridge the
// Mojo pane is the literal translation of the pseudo, computed and never stored; the views that read a program
// (trace, checker, tests, proof) work on the hub's pseudo; a pane that is not in step is not stepped; "Edit in
// Developer" copies the generated Mojo out and records that it was generated.
import test from 'node:test';
import assert from 'node:assert/strict';
import { Session } from '../dist/core/session.js';
import { PROBLEMS, stateForProblem, problemById } from '../dist/core/catalog.js';
import { SyncHub } from '../core/dist/sync/hub.js';
import { normalize } from '../dist/core/state.js';
import { GENERATED_HEADER } from '../core/dist/sync/header.js';
globalThis.localStorage = { getItem() { return null; }, setItem() { }, removeItem() { } };
const open = (id, area = 'bridge') => new Session(stateForProblem(problemById(id)), { area, storageId: null });
test('in the Bridge the Mojo pane is the generated Mojo, not the stored Mojo; elsewhere it is the state\'s own', () => {
const own = stateForProblem(problemById('count-base')).sources.mojo;
assert.ok(own && !own.startsWith('# Generated'), 'the exercise has its own Mojo');
const bridge = open('count-base', 'bridge');
assert.ok(bridge.source('mojo').startsWith(GENERATED_HEADER), 'the Bridge shows the literal translation, header first');
assert.equal(bridge.source('mojo'), bridge.derivedMojo().source);
assert.equal(bridge.state.sources.mojo, own, 'the stored Mojo is untouched');
assert.equal(open('count-base', 'dev').source('mojo'), own);
assert.equal(open('count-base', 'hw').source('mojo'), own);
assert.equal(new Session(stateForProblem(problemById('count-base')), { storageId: null }).source('mojo'), own, 'a session with no area (an embed of one pane) shows the state\'s own Mojo');
});
test('the Bridge\'s Mojo follows an edit in any linked pane, and every view of it reads the generated source', () => {
const s = open('count-base');
const before = s.source('mojo');
s.setSource('pseudo', s.source('pseudo').replace('Total <- 0', 'Total <- 3'));
assert.notEqual(s.source('mojo'), before);
assert.match(s.source('mojo'), /total = 3/);
// the checker, the stepper and the tests read it
s.setLang('mojo');
assert.equal(s.parsedMojo().program.source ?? s.source('mojo'), s.source('mojo'));
assert.deepEqual(s.parsedMojo().diagnostics.filter((d) => d.severity === 'error'), []);
const tr = s.trace();
assert.ok(tr && !tr.error, 'the generated Mojo steps in the interpreter');
assert.ok(tr.output.some((l) => /3|4|5|6|7|8|9/.test(l)), 'and prints a count that includes the changed start');
assert.ok(s.tests().length >= 0);
// an edit in lingo reaches it too
const lingo = s.source('lingo');
assert.match(lingo, /Start with Total at 3\./, 'the English was regenerated from the pseudo');
s.setSource('lingo', lingo.replace('Start with Total at 3.', 'Start with Total at 10.'));
assert.match(s.source('mojo'), /total = 10/);
});
test('trace steps the pseudo, not a stale pane', () => {
const s = open('count-base');
s.setLang('lingo');
assert.equal(s.traceLang(), 'lingo', 'an in-step lingo pane is stepped as English');
s.setSource('pseudo', 'FUNCTION BROKEN(\nRETURN'); // pseudo has errors: lingo is now stale
assert.equal(s.linkState('lingo').kind, 'stale');
assert.equal(s.traceLang(), 'pseudo', 'lingo holds text the pseudo has moved on from');
});
test('prove and tests work on the hub\'s pseudo, with the speco woven', () => {
const s = open('count-base-proved');
s.setLang('lingo');
s.setSource('lingo', s.source('lingo').replace('Add 1 to Total.', 'Add 1 to Total.')); // no change: nothing to do
const lingo = s.source('lingo');
s.setSource('lingo', lingo + '\n'); // an edit in English
assert.equal(s.state.sync.authority, 'lingo');
assert.match(s.source('pseudo'), /ENSURE/, 'the contracts are in the pseudo the English lowered to');
const proof = s.proof();
assert.ok(proof && proof.report.counts.total > 0, 'there is something to prove');
assert.equal(proof.report.counts.broken, 0);
assert.ok(s.tests().length > 0, 'tests are generated from the pseudo');
});
test('Edit in Developer copies the generated Mojo into the state and records that it was generated', () => {
const s = open('count-base');
const generated = s.derivedMojo().source;
assert.ok(s.wouldReplaceMojo(), 'the exercise\'s own Mojo would be replaced: the shell asks first');
assert.equal(s.state.mojoOrigin, undefined);
assert.ok(s.adoptGeneratedMojo());
assert.equal(s.state.sources.mojo, generated);
assert.equal(s.state.mojoOrigin, 'generated');
assert.equal(s.state.lang, 'mojo');
assert.equal(s.wouldReplaceMojo(), false, 'it already holds this program');
// the Developer area shows it, and the first edit makes it theirs
const dev = new Session(s.state, { area: 'dev', storageId: null });
assert.equal(dev.source('mojo'), generated);
dev.setSource('mojo', generated + '\n# mine\n');
assert.equal(dev.state.mojoOrigin, 'generated-edited');
dev.setSource('mojo', generated + '\n# mine again\n');
assert.equal(dev.state.mojoOrigin, 'generated-edited');
// a state with no pseudo has nothing to adopt
const empty = new Session(normalize({ v: 3 }), { area: 'bridge', storageId: null });
assert.equal(empty.adoptGeneratedMojo(), false);
assert.equal(empty.state.mojoOrigin, undefined);
});
test('mojoOrigin is validated, and is only ever set on Mojo the student did not write', () => {
assert.equal(normalize({ v: 3, mojoOrigin: 'generated' }).mojoOrigin, 'generated');
assert.equal(normalize({ v: 3, mojoOrigin: 'generated-edited' }).mojoOrigin, 'generated-edited');
assert.equal(normalize({ v: 3, mojoOrigin: 'hand-written' }).mojoOrigin, undefined);
const s = open('count-base', 'dev');
s.setSource('mojo', s.source('mojo') + '\n# note\n');
assert.equal(s.state.mojoOrigin, undefined, 'editing the exercise\'s own Mojo does not make it generated');
});
test('line maps reach the Mojo: a pseudo line finds its Mojo lines and back', () => {
const s = open('count-base');
const maps = s.lineMaps();
const pseudo = s.source('pseudo').split('\n');
const at = pseudo.findIndex((l) => /Total <- Total \+ 1/.test(l)) + 1;
const mojoLines = SyncHub.relate(maps, 'pseudo', at, 'mojo');
assert.ok(mojoLines.length, 'the line has a Mojo line');
assert.match(s.source('mojo').split('\n')[mojoLines[0] - 1], /total = total \+ 1/);
assert.ok(SyncHub.relate(maps, 'mojo', mojoLines[0], 'pseudo').includes(at));
// lingo line -> pseudo line, for a problem whose lingo was authored
const lingo = s.source('lingo').split('\n');
const l = lingo.findIndex((t) => /add 1 to Count/.test(t)) + 1;
const p = SyncHub.relate(maps, 'lingo', l, 'pseudo');
assert.ok(Array.isArray(p));
});
test('every Bridge problem opens with generated Mojo that names itself and checks clean', () => {
let n = 0;
for (const p of PROBLEMS) {
if (p.area !== 'bridge') continue;
const s = new Session(stateForProblem(p), { area: 'bridge', storageId: null });
if (!s.source('pseudo').trim()) continue;
const m = s.source('mojo');
if (!m) continue; // pseudo that does not read (five-bugs, by design)
assert.ok(m.startsWith(GENERATED_HEADER), p.id);
n++;
}
assert.ok(n >= 12, `${n} problems`);
});