@bongos/core 1.19.488 → 1.19.490

package/modules/hall-ui/public/profile.states.json

@@ -1,15 +1,116 @@
 {
-  "_": "The hall's PROFILE page through modules/ui-design/kit/render.js (task 1003308). The identity band, the shelf and the three activity ledgers only exist once a profile has LOADED, so the floors run against the hall-preview harness (see settings.states.json for the two commands; pass --base-in/--base-out at it). `out` is a real state here rather than a redirect: a signed-out visitor with no ?id= gets the empty state, not a bounce — under the harness's --fixture-me the /me read still answers, so `out` renders the own profile there and the empty state only under the kit's own stub.",
+  "_": "The hall's PROFILE page through modules/ui-design/kit/render.js (task 1003308; four screens behind the section rail since task 1003489 — overview, works, activity, connections). The identity band, the charts, the works ledger and the activity ledgers only exist once a profile has LOADED, so the floors run against the hall-preview harness (see settings.states.json for the two commands; pass --base-in/--base-out at it). One rail key renders at a time, so each key is its own state. `out` is a real state here rather than a redirect: a signed-out visitor with no ?id= gets the empty state, not a bounce — under the harness's --fixture-me the /me read still answers, so `out` renders the own profile there and the empty state only under the kit's own stub.",
   "page": "/profile",
   "surface": "hall-ui",
-  "stub": { "prefix": "/builders/" },
+  "stub": {
+    "prefix": "/builders/"
+  },
   "modeQuery": false,
-  "ignoreRequests": ["/api/(gds|bongos)/"],
-  "ignoreConsole": ["/api/(gds|bongos)/", "\b401\b", "\b404\b", "Unauthorized", "Not Found", "load failed"],
+  "ignoreRequests": [
+    "/api/(gds|bongos)/"
+  ],
+  "ignoreConsole": [
+    "/api/(gds|bongos)/",
+    "\\b401\\b",
+    "\\b404\\b",
+    "Unauthorized",
+    "Not Found",
+    "load failed"
+  ],
   "states": {
-    "own": { "auth": true, "actions": [["wait", 900]], "expect": { "visible": ["#profile-h1", "#profile-head", "#numbers-body", "#works-table", "#activity-tabs"] } },
-    "other": { "auth": true, "url": "/profile?id=1000025", "actions": [["wait", 900]], "expect": { "visible": ["#profile-head", "#ach-grid"] } },
-    "out": { "auth": false, "actions": [["wait", 600]], "expect": { "visible": ["#profile-h1", "#profile-head"] } }
+    "own": {
+      "auth": true,
+      "actions": [
+        [
+          "wait",
+          1200
+        ]
+      ],
+      "expect": {
+        "visible": [
+          "#profile-h1",
+          "#profile-rail",
+          "#profile-head",
+          "#numbers-body",
+          "#charts-controls",
+          "#charts-grid",
+          "#ach-grid"
+        ]
+      }
+    },
+    "works": {
+      "auth": true,
+      "url": "/profile#works",
+      "actions": [
+        [
+          "wait",
+          1200
+        ]
+      ],
+      "expect": {
+        "visible": [
+          "#profile-rail",
+          "#works-table"
+        ]
+      }
+    },
+    "activity": {
+      "auth": true,
+      "url": "/profile#activity",
+      "actions": [
+        [
+          "wait",
+          1200
+        ]
+      ],
+      "expect": {
+        "visible": [
+          "#profile-rail",
+          "#activity-tabs",
+          "#activity-tasks"
+        ]
+      }
+    },
+    "other": {
+      "auth": true,
+      "url": "/profile?id=1000025",
+      "actions": [
+        [
+          "wait",
+          1200
+        ]
+      ],
+      "expect": {
+        "visible": [
+          "#profile-head",
+          "#charts-grid",
+          "#ach-grid"
+        ]
+      }
+    },
+    "out": {
+      "auth": false,
+      "actions": [
+        [
+          "wait",
+          600
+        ]
+      ],
+      "expect": {
+        "visible": [
+          "#profile-h1",
+          "#profile-head"
+        ]
+      }
+    }
   },
-  "reducedMotion": { "auth": true, "actions": [["wait", 900]] }
+  "reducedMotion": {
+    "auth": true,
+    "actions": [
+      [
+        "wait",
+        1200
+      ]
+    ]
+  }
 }

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.488",
+  "version": "1.19.490",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.488",
+      "version": "1.19.490",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.488",
+  "version": "1.19.490",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/scripts/hall-preview/refresh-fixtures.js

@@ -17,8 +17,14 @@ const FIXTURES = path.join(__dirname, 'fixtures');
 
 // [api path (no /api prefix, no query), fixture name, optional trim fn]
 const trimList = (key, n) => (d) => (Array.isArray(d?.[key]) ? { ...d, [key]: d[key].slice(0, n) } : d);
+// A paged ledger is one page of a longer record, and the harness ignores query
+// strings — so a fixture whose page.total exceeds its rows would send the
+// profile charts' pager back for the same page until "total". Pin total to
+// what the snapshot holds.
+const selfPaged = (d) => (Array.isArray(d?.rows) && d.page ? { ...d, page: { ...d.page, total: d.rows.length } } : d);
 const SNAPSHOTS = [
   ['me', 'me'],
+  ['me/credits?limit=200', 'me__credits', selfPaged],
   ['me/recent-ships?limit=30', 'me__recent-ships'],
   ['achievements', 'achievements'],
   ['versions', 'versions'],

package/scripts/hall-preview/server.js

@@ -111,6 +111,9 @@ const FIXTURE_FALLBACKS = [
   [/^analytics\/builder\/\d+$/, 'analytics__builder'],
   [/^builders\/\d+\/active-claims$/, 'builders__active-claims'],
   [/^builders\/\d+\/profile$/, 'builders__profile'],
+  // the profile's drachmae chart reads the credits ledger (task 1003491): one
+  // ledger fixture serves your own (/me/credits, exact match) and any other id.
+  [/^builders\/\d+\/credits$/, 'me__credits'],
   // the profile's per-craft activity log (task 1003281). One fixture per SECTION
   // rather than per id, because the section is what changes the row shape; the
   // craft and the page window are query string, which fixture matching ignores.

package/src/module-api.js

@@ -45,7 +45,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.488'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.490'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/hall_profile_world.mjs

@@ -0,0 +1,437 @@
+// tests/hall_profile_world.mjs — the profile page reorganised behind the
+// settings-style section rail, with charts of the record over time
+// (task 1003489, goal 1000081).
+//
+// tests/hall_settings_world.mjs pins the PANEL family's archetype; this pins
+// what this task added to one page of it. Everything here is a fact that is
+// silent in a browser: the page still renders, it just renders long again, or
+// a chart draws a number nobody can reach without the picture.
+//
+// What it locks:
+//   * THE RAIL AND THE GROUPS. profile.html keeps ONE group of sections visible
+//     behind a left rail in switch mode (OTBKit.makeSectionRail — settings'
+//     idiom, not a second tab row over the craft tabs). Every section carries
+//     a data-group; the keys are overview / activity / connections; the sheet
+//     shows exactly the active group and a section's own [hidden] still wins.
+//   * THE OVERVIEW IS THE PORTFOLIO. Identity, figures, charts, shelf, the
+//     public latest-works strip and the cross-project record; the craft
+//     ledgers are one key over, so the first screen is a screen.
+//   * THE CHARTS ARE ARITHMETIC FIRST. cumulativeByDay folds two ships on one
+//     day into one point and accumulates, over whichever timestamp the caller
+//     names; craftMix folds the tail past seven into "other" rather than
+//     minting an eighth hue; weeklyBuckets is a time axis (every week present,
+//     empty or not).
+//   * DRACHMAE COME FROM THE LEDGER (task 1003491). The earned line is the
+//     credits ledger — /me/credits on your own profile, /builders/:id/credits
+//     on another's — `delta` cumulated by `recorded_at`, so it ends at the
+//     balance. Per-task credits_awarded is 0 on a cost-plus instance and is no
+//     longer read at all (the owner's chart had flatlined since July on it).
+//     A viewer the ledger refuses gets the credits_reward estimate, labelled.
+//   * NO NUMBER IS PICTURE-ONLY. Every time chart carries a table twin with a
+//     row per plotted day; the readout is written with textContent.
+//   * OWN-ONLY MEANS OWN-ONLY. /analytics/builder/:id is asked for only when
+//     the viewer is the builder; signed out, the section says why and asks the
+//     server for nothing more.
+//
+// Reproduce the renders these came from:
+//   node scripts/hall-preview/server.js --port 4621 --fixture-me
+//   node modules/ui-design/kit/render.js --states modules/hall-ui/public/profile.states.json \
+//     --base-in http://builders.localhost:4621 --base-out http://builders.localhost:4621
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8').replace(/\r\n/g, '\n');
+const stripComments = (css) => css.replace(/\/\*[\s\S]*?\*\//g, '');
+
+const html = read('profile.html');
+const profileJs = read('profile.js');
+const chartsJs = read('profile-charts.js');
+const profileCss = stripComments(read('profile.css'));
+
+const GROUPS = ['overview', 'works', 'activity', 'connections'];
+
+// ---- the rail and the groups ---------------------------------------------------
+
+test('the profile has a section rail in switch mode and one group container', () => {
+  assert.match(html, /<nav class="section-rail" id="profile-rail" aria-label="[^"]+"><\/nav>/, 'the rail mount is a nav the kit fills');
+  assert.match(html, /<div class="profile-groups" id="profile-groups" data-active="overview">/, 'the groups open on the overview');
+  assert.match(profileJs, /makeSectionRail\(\{[\s\S]*?mode: 'switch'/, 'profile.js builds the rail in switch mode');
+  assert.doesNotMatch(profileJs, /makeTabs\(\{\s*mount: \$\('#profile-/, 'no page-level tab row — the craft tabs stay the only tablist');
+});
+
+test('every section in the groups carries a known data-group, and the keys are the owner\'s four', () => {
+  const sections = [...html.matchAll(/<section class="scroll[^"]*" id="([a-z-]+)"[^>]*>/g)];
+  assert.ok(sections.length >= 7, `expected the page's sections, saw ${sections.length}`);
+  for (const m of sections) {
+    const g = m[0].match(/data-group="([a-z]+)"/);
+    assert.ok(g, `section #${m[1]} has no data-group`);
+    assert.ok(GROUPS.includes(g[1]), `section #${m[1]} names an unknown group "${g[1]}"`);
+  }
+  const groupOf = (id) => html.match(new RegExp(`id="${id}"[^>]*data-group="([a-z]+)"`))[1];
+  for (const id of ['standing-scroll', 'numbers-scroll', 'charts-scroll', 'ach-scroll', 'xp-scroll']) {
+    assert.equal(groupOf(id), 'overview', `#${id} belongs to the overview`);
+  }
+  assert.equal(groupOf('works-scroll'), 'works', 'the works ledger is its own key');
+  assert.equal(groupOf('activity-scroll'), 'activity');
+  assert.equal(groupOf('conn-scroll'), 'connections');
+  const railKeys = profileJs.match(/const RAIL_ITEMS = \[([\s\S]*?)\];/)[1].match(/id: '([a-z]+)'/g).map((s) => s.slice(5, -1));
+  assert.deepEqual(railKeys, GROUPS, 'the rail lists the four keys in reading order');
+});
+
+test('the sheet shows exactly the active group, and a hidden section stays hidden', () => {
+  assert.match(profileCss, /\.profile-groups > \[data-group\] \{ display: none; \}/);
+  for (const g of GROUPS) {
+    assert.match(profileCss, new RegExp(`\\.profile-groups\\[data-active="${g}"\\] > \\[data-group="${g}"\\]`), `a rule reveals the ${g} group`);
+  }
+  assert.match(profileCss, /\.profile-groups > \[data-group\]\[hidden\] \{ display: none !important; \}/, 'a section\'s own [hidden] wins over the group reveal');
+  assert.match(profileCss, /@media \(max-width: 860px\) \{[\s\S]*?\.profile-layout \{ grid-template-columns: minmax\(0, 1fr\)/, 'the rail column collapses where settings\' does');
+});
+
+test('the connections key follows its section: the rail refreshes when #conn-scroll reveals', () => {
+  assert.match(profileJs, /new MutationObserver\([\s\S]*?attributeFilter: \['hidden'\]/, 'a MutationObserver watches the hidden attribute');
+  assert.match(profileJs, /rail\.refresh\(/, 'and refreshes the rail\'s items from it');
+});
+
+test('the Works key is the full server-paged ledger, with a public recent-ships fallback', () => {
+  assert.match(html, /id="works-scroll"[^>]*data-group="works"[\s\S]*?id="works-pager"/, 'the works section has the ledger table and a pager mount');
+  assert.match(html, /id="works-lede"[^>]*>[\s\S]*?<a href="#activity">/, 'the lede points at the activity key for the by-craft view');
+  assert.match(profileJs, /buildWorksLedger\(builder\.id, selfId != null, data\.recent_ships\)/, 'renderProfile builds the works ledger');
+  assert.match(profileJs, /makePager\('works'[\s\S]*?section=tasks&limit=\$\{pager\.perPage\}&offset=\$\{kit\.pageOffset\(pager\)\}/, 'signed in: the whole record, server-paged from the activity route');
+  assert.match(profileJs, /if \(!signedIn\)[\s\S]*?recentShips[\s\S]*?Sign in<\/a> to see the full record/, 'signed out: the public recent_ships stand in with a sign-in line');
+  assert.doesNotMatch(html, /data-group="overview"[^>]*id="works-scroll"|id="works-scroll"[^>]*data-group="overview"/, 'the works ledger no longer sits on overview — no duplicate of the record');
+  assert.match(profileCss, /#works-scroll \.ledger td a,\n#activity-scroll \.ledger td a,\n#charts-scroll a,/, 'links in the works ledger, the activity ledgers and the charts take the 24px prose-link recipe');
+});
+
+// ---- the charts: script order and the section --------------------------------
+
+test('profile-charts.js loads before profile.js, and profile.js hands it the page\'s client', () => {
+  const a = html.indexOf('/builders/profile-charts.js');
+  const b = html.indexOf('/builders/profile.js');
+  assert.ok(a > 0 && a < b, 'the charts script is in the page, ahead of profile.js');
+  assert.match(profileJs, /window\.OTBProfileCharts\.render\(\{ api, API, builderId: builder\.id, selfId, signedIn: selfId != null \}\)/);
+  assert.match(html, /<section class="scroll" id="charts-scroll"[^>]*>[\s\S]*?<div class="pcharts" id="charts-grid">/, 'the charts section is a .pcharts grid');
+});
+
+test('the marks keep the dataviz specs: 2px accent line, 10% wash, hairline solid axis, an 8px end dot with a surface ring', () => {
+  assert.match(profileCss, /\.pchart__line \{ fill: none; stroke: var\(--accent\); stroke-width: 2;/);
+  assert.match(profileCss, /\.pchart__area \{ fill: color-mix\(in srgb, var\(--accent\) 10%, transparent\)/);
+  assert.match(profileCss, /\.pchart__axis, \.pchart__hair \{ stroke: var\(--rule-soft\); stroke-width: 1; \}/);
+  assert.match(profileCss, /\.pchart__dot \{ fill: var\(--accent\); stroke: var\(--bg-card\); stroke-width: 2; \}/);
+  assert.match(chartsJs, /r="4"/, 'the end dot is r=4 — an 8px marker');
+  assert.match(profileCss, /\.pchart__end \{[^}]*fill: var\(--ink\)/, 'the end label wears ink, not the series colour');
+  assert.doesNotMatch(profileCss, /var\(--(surface|surface-2|border|border-strong|accent-weak|accent-text)\)/, 'no compat alias spent');
+});
+
+// ---- the charts: arithmetic, in a sandbox --------------------------------------
+
+function bootCharts() {
+  const sandbox = {
+    window: {
+      __BRANDING__: { currency: { label: 'drachmae' } },
+      OTB: {
+        escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+        $: () => null,
+        fmtNum: (n) => String(n ?? 0),
+        fmtDate: (iso) => String(iso ?? '').slice(0, 10),
+      },
+    },
+    console, Date, Map, Set, Math, Number, String, Array, Infinity, URLSearchParams,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(chartsJs, sandbox, { filename: 'profile-charts.js' });
+  return sandbox.window.OTBProfileCharts;
+}
+
+const NOW = Date.parse('2026-09-02T12:00:00Z');
+const day = (s) => Date.parse(`${s}T00:00:00Z`);
+// Objects born in the sandbox have the sandbox's Object prototype, so a strict
+// deep-equal against a literal here fails on identity alone; compare the data.
+const plain = (v) => JSON.parse(JSON.stringify(v));
+
+test('cumulativeByDay folds a day\'s ships into one point and accumulates, skipping a row with no date', () => {
+  const C = bootCharts();
+  const rows = [
+    { shipped_at: '2026-08-10T09:00:00Z' },
+    { shipped_at: '2026-08-10T17:00:00Z' },
+    { shipped_at: '2026-08-01T01:00:00Z' },
+    { shipped_at: null },
+  ];
+  assert.deepEqual(plain(C.cumulativeByDay(rows, () => 1)), [
+    { day: day('2026-08-01'), value: 1 },
+    { day: day('2026-08-10'), value: 3 },
+  ]);
+  assert.deepEqual(plain(C.cumulativeByDay([], () => 1)), []);
+  // the ledger's rows are stamped recorded_at, not shipped_at — the caller names the timestamp
+  const ledger = [
+    { delta: 12, recorded_at: '2026-08-02T22:17:01Z' },
+    { delta: 39, recorded_at: '2026-08-01T21:52:51Z' },
+    { delta: 19, recorded_at: '2026-08-01T22:05:00Z' },
+  ];
+  assert.deepEqual(plain(C.cumulativeByDay(ledger, (r) => r.delta, (r) => r.recorded_at)), [
+    { day: day('2026-08-01'), value: 58 },
+    { day: day('2026-08-02'), value: 70 },
+  ], 'newest-first ledger rows still accumulate oldest-first, by their own timestamp');
+});
+
+test('estimateOf is the credits_reward figure and nothing else — the per-task award column is not read anywhere', () => {
+  const C = bootCharts();
+  assert.equal(C.estimateOf({ credits_awarded: 58, credits_reward: 60 }), 60, 'the estimate ignores what was awarded');
+  assert.equal(C.estimateOf({ credits_awarded: 0, credits_reward: 45 }), 45, 'a cost-plus 0 award does not zero the estimate');
+  assert.equal(C.estimateOf({}), 0);
+  assert.equal(C.estimateOf(null), 0);
+  assert.equal(C.creditsOf, undefined, 'the old ledger-or-estimate picker is gone');
+  // The whole reason for task 1003491: on a cost-plus instance every task's
+  // credits_awarded is 0, so a drachmae series summed from it flatlines the day
+  // per-task payout stops. The column must not be read by the charts at all.
+  assert.ok(!chartsJs.includes('credits_awarded'), 'profile-charts.js never mentions credits_awarded');
+});
+
+test('craftMix sorts by count and folds the tail past seven into "other" — never an eighth hue', () => {
+  const C = bootCharts();
+  const rows = ['a', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', null].map((d) => ({ discipline: d }));
+  const mix = plain(C.craftMix(rows));
+  assert.equal(mix.length, 7);
+  assert.deepEqual(mix[0], { label: 'a', n: 2 });
+  assert.equal(mix[6].label, 'other');
+  assert.equal(mix.reduce((s, k) => s + k.n, 0), rows.length, 'nothing is lost in the fold');
+  assert.ok(C.craftMix([{ discipline: null }]).some((k) => k.label === 'unclassified'), 'a missing craft reads as unclassified');
+  assert.equal(C.craftMix(rows.slice(0, 3)).length, 2, 'under the cap there is no fold');
+});
+
+test('weeklyBuckets is a time axis: every week present, ships summed into theirs, outside the window dropped', () => {
+  const C = bootCharts();
+  const b = C.weeklyBuckets([
+    { day: '2026-09-01', n: 2 }, { day: '2026-08-30', n: 1 }, { day: '2026-06-01', n: 9 },
+  ], 28, NOW);
+  assert.equal(b.length, 4);
+  assert.equal(b[3].n, 3, 'the current week holds both recent ships');
+  assert.equal(b.reduce((s, w) => s + w.n, 0), 3, 'the June ship is outside 28 days');
+  assert.ok(b.every((w, i) => i === 0 || w.start - b[i - 1].start === 7 * 86400000), 'weeks are contiguous');
+});
+
+test('clipToWindow (the lookback) enters the window at the running height, not at zero', () => {
+  const C = bootCharts();
+  const pts = [
+    { day: day('2026-06-01'), value: 3 },
+    { day: day('2026-08-20'), value: 4 },
+    { day: day('2026-08-28'), value: 6 },
+  ];
+  // null window = the whole record, untouched
+  assert.equal(C.clipToWindow(pts, null), pts);
+  // a window that starts after the first point: the synthetic baseline carries
+  // the total accumulated BEFORE the window (3), so the line does not restart at 0
+  const clipped = plain(C.clipToWindow(pts, day('2026-08-01')));
+  assert.deepEqual(clipped[0], { day: day('2026-08-01'), value: 3 }, 'the line enters at the running total');
+  assert.equal(clipped[clipped.length - 1].value, 6, 'and still ends at the all-time total');
+  // a window with no points inside is one flat baseline at the pre-window total
+  assert.deepEqual(plain(C.clipToWindow(pts, day('2026-09-01'))), [{ day: day('2026-09-01'), value: 6 }]);
+});
+
+// ---- the charts: what render asks for and draws ---------------------------------
+
+// `ledger` is what the credits routes answer: an array of rows (paged by the
+// route's 200 in the real shape, { rows, page: { total } }), or 'denied' for the
+// 403 a viewer without builder.roster.read gets on someone else's ledger.
+function bootRender({ rows, status = 200, analytics = null, ledger = [] }) {
+  const requests = [];
+  const mount = { innerHTML: '', querySelector: () => null };
+  const controls = { innerHTML: '', addEventListener() {}, querySelectorAll: () => [] };
+  const store = new Map();
+  const api = {
+    request: async (method, url) => {
+      requests.push(url);
+      if (url.includes('/activity')) {
+        if (status !== 200) return { status, ok: false, data: null };
+        const offset = Number(new URL(`http://x${url}`).searchParams.get('offset')) || 0;
+        return { status: 200, ok: true, data: { total: rows.length, rows: rows.slice(offset, offset + 100) } };
+      }
+      if (url.includes('/credits')) {
+        if (ledger === 'denied') return { status: 403, ok: false, data: null };
+        const offset = Number(new URL(`http://x${url}`).searchParams.get('offset')) || 0;
+        return { status: 200, ok: true, data: { rows: ledger.slice(offset, offset + 200), page: { limit: 200, offset, total: ledger.length } } };
+      }
+      if (url.includes('/analytics/')) return analytics ? { status: 200, ok: true, data: analytics } : { status: 403, ok: false, data: null };
+      return { status: 404, ok: false, data: null };
+    },
+  };
+  const sandbox = {
+    window: {
+      __BRANDING__: { currency: { label: 'drachmae' } },
+      localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) },
+      OTB: {
+        escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+        $: (sel) => (sel === '#charts-grid' ? mount : sel === '#charts-controls' ? controls : null),
+        fmtNum: (n) => String(n ?? 0),
+        fmtDate: (iso) => String(iso ?? '').slice(0, 10),
+      },
+    },
+    console, Date, Map, Set, Math, Number, String, Array, Infinity, URLSearchParams, Promise,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(chartsJs, sandbox, { filename: 'profile-charts.js' });
+  return { C: sandbox.window.OTBProfileCharts, api, requests, mount, controls };
+}
+
+const ship = (d, extra = {}) => ({ shipped_at: `${d}T10:00:00Z`, discipline: 'engineer', credits_awarded: 10, credits_reward: 12, ...extra });
+// a credits-ledger row: what the instance actually paid, when
+const pay = (d, delta, extra = {}) => ({ delta, reason: 'session.token_reward', recorded_at: `${d}T22:00:00Z`, ...extra });
+
+test('render draws three public figures with a table twin per time chart, and no own-only one for another builder', async () => {
+  const b = bootRender({
+    rows: [ship('2026-08-01'), ship('2026-08-01'), ship('2026-08-20', { discipline: 'ui' })],
+    ledger: [pay('2026-08-01', 20), pay('2026-08-20', 30)],
+  });
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 7, signedIn: true, now: NOW });
+  const out = b.mount.innerHTML;
+  assert.ok(out.includes('id="chart-works"') && out.includes('id="chart-drachmae"') && out.includes('id="chart-mix"'), 'the three public charts');
+  assert.ok(out.includes('<td>2026-08-20</td><td class="ledger__num">50 drachmae</td>'), 'the drachmae twin reads the ledger, not the 30 of per-task awards');
+  assert.ok(!out.includes('id="chart-rate"'), 'no pace chart on someone else\'s profile');
+  assert.ok(!b.requests.some((u) => u.includes('/analytics/')), 'and /analytics was never asked for');
+  assert.equal((out.match(/<details class="pchart__twin">/g) || []).length, 2, 'a table twin under each time chart');
+  assert.ok(out.includes('<td>2026-08-01</td><td class="ledger__num">2 works</td>'), 'the twin holds the plotted day and its value');
+  assert.ok(out.includes('>3 works</text>'), 'only the endpoint is direct-labelled');
+  assert.ok(out.includes('Drachmae earned'), 'the currency label comes from branding at render');
+});
+
+test('render asks for the pace chart on the viewer\'s own profile only', async () => {
+  const analytics = { window_days: 28, ship_rate: [{ day: '2026-09-01', n: 2 }] };
+  const own = bootRender({ rows: [ship('2026-08-01')], analytics });
+  await own.C.render({ api: own.api, API: '/api/bongos', builderId: 95, selfId: '95', signedIn: true, now: NOW });
+  assert.ok(own.requests.some((u) => u.includes('/analytics/builder/95')), 'own profile: the analytics read');
+  assert.ok(own.requests.some((u) => u.includes('/me/credits?')), 'own profile: your own ledger');
+  assert.ok(!own.requests.some((u) => u.includes('/builders/95/credits')), 'never through the roster route for yourself');
+  assert.ok(own.mount.innerHTML.includes('id="chart-rate"'), 'and the pace chart draws');
+  assert.ok(own.mount.innerHTML.includes('only you see this one'), 'saying plainly that it is private');
+});
+
+test('signed out, the section says why and asks the server for nothing', async () => {
+  const b = bootRender({ rows: [] });
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: null, signedIn: false, now: NOW });
+  assert.equal(b.requests.length, 0);
+  assert.match(b.mount.innerHTML, /visible to signed-in builders/);
+  const gone = bootRender({ rows: [], status: 401 });
+  await gone.C.render({ api: gone.api, API: '/api/bongos', builderId: 95, selfId: 1, signedIn: true, now: NOW });
+  assert.match(gone.mount.innerHTML, /visible to signed-in builders/, 'a 401 mid-way reads the same');
+});
+
+test('an empty record is one honest line, not three empty cards', async () => {
+  const b = bootRender({ rows: [] });
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 95, signedIn: true, now: NOW });
+  assert.match(b.mount.innerHTML, /No works shipped yet/);
+  assert.ok(!b.mount.innerHTML.includes('<figure'), 'no figure drew');
+  assert.ok(!b.requests.some((u) => u.includes('/analytics/')), 'and nothing else was asked for');
+});
+
+test('the record is followed past the first page, bounded', async () => {
+  const many = Array.from({ length: 230 }, (_, i) => ship(`2026-0${1 + (i % 8)}-${String(1 + (i % 28)).padStart(2, '0')}`));
+  const b = bootRender({ rows: many });
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 1, signedIn: true, now: NOW });
+  const pages = b.requests.filter((u) => u.includes('section=tasks'));
+  assert.equal(pages.length, 3, 'three pages of 100 for 230 rows');
+  assert.match(b.mount.innerHTML, /230 total/);
+});
+
+test('the lookback control renders one row of ranges above the grid, defaulting to all time', async () => {
+  const b = bootRender({ rows: [ship('2026-08-01')] });
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 7, signedIn: true, now: NOW });
+  const c = b.controls.innerHTML;
+  assert.match(c, /class="pchart-range"/, 'the control is one segmented row');
+  for (const label of ['30 days', '90 days', '1 year', 'All time']) assert.ok(c.includes(label), `it offers ${label}`);
+  assert.match(c, /data-range="all"[^>]*aria-pressed="true"|is-active[^>]*data-range="all"|data-range="all"[^>]*is-active/, 'all time is the default');
+});
+
+test('a 30-day window drops the older ships from the craft mix and clips the axis', async () => {
+  // one recent ship, one long before the 30-day window
+  const rows = [ship('2026-08-30'), ship('2026-06-01', { discipline: 'ui' })];
+  const b = bootRender({ rows });
+  // seed the remembered range to 30 days so the first draw is windowed
+  b.C && (await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 7, signedIn: true, now: NOW }));
+  // the default is all time, so both crafts show; assert the arithmetic path
+  // that the window uses instead (the render wiring is covered above)
+  const C = bootCharts();
+  const within = rows.filter((r) => Date.parse(r.shipped_at) >= day('2026-08-03'));
+  assert.equal(C.craftMix(within).length, 1, 'only the recent craft survives a 30-day window');
+});
+
+test('the drachmae line is the credits ledger: /me/credits on your own profile, cumulated by recorded_at, ending at the balance', async () => {
+  const rows = [ship('2026-08-01'), ship('2026-08-20')]; // per-task awards would sum to 20
+  const ledger = [pay('2026-09-01', 12), pay('2026-08-20', 39), pay('2026-08-20', 19), pay('2026-07-05', 30)]; // balance 100
+  const b = bootRender({ rows, ledger });
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 95, signedIn: true, now: NOW });
+  assert.ok(b.requests.some((u) => u.includes('/me/credits?limit=200&offset=0')), 'own profile: /me/credits, paged');
+  assert.ok(!b.requests.some((u) => u.includes('/builders/95/credits')), 'not the roster route');
+  const out = b.mount.innerHTML;
+  const fig = out.slice(out.indexOf('id="chart-drachmae"'), out.indexOf('id="chart-mix"'));
+  assert.ok(fig.includes('>100 drachmae</text>'), 'the endpoint is the ledger balance, not the 20 of per-task awards');
+  assert.ok(fig.includes('<td>2026-07-05</td><td class="ledger__num">30 drachmae</td>'), 'a paid day with no ship is still a point');
+  assert.ok(fig.includes('<td>2026-08-20</td><td class="ledger__num">88 drachmae</td>'), 'two payments on one day fold into one point');
+  assert.match(fig, /100 paid, from the credits ledger/);
+  assert.doesNotMatch(fig, /estimated/);
+});
+
+test('another builder\'s ledger is read from /builders/:id/credits, paged by 200 to total', async () => {
+  const ledger = Array.from({ length: 450 }, (_, i) => pay(`2026-08-${String(1 + (i % 28)).padStart(2, '0')}`, 1));
+  const b = bootRender({ rows: [ship('2026-08-01')], ledger });
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 7, signedIn: true, now: NOW });
+  const pages = b.requests.filter((u) => u.includes('/builders/95/credits'));
+  assert.equal(pages.length, 3, 'three pages of 200 for 450 rows');
+  assert.ok(!b.requests.some((u) => u.includes('/me/credits')), 'never your own ledger for someone else\'s chart');
+  assert.ok(b.mount.innerHTML.includes('>450 drachmae</text>'), 'and every row counted once');
+});
+
+test('a viewer the ledger refuses gets the credits_reward estimate, cumulated and labelled estimated', async () => {
+  // the cost-plus shape: every award 0, the estimate is all there is to show
+  const rows = [ship('2026-08-01', { credits_awarded: 0, credits_reward: 45 }), ship('2026-08-20', { credits_awarded: 0, credits_reward: 55 })];
+  const b = bootRender({ rows, ledger: 'denied' });
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 7, signedIn: true, now: NOW });
+  const out = b.mount.innerHTML;
+  const fig = out.slice(out.indexOf('id="chart-drachmae"'), out.indexOf('id="chart-mix"'));
+  assert.ok(fig.includes('>100 drachmae</text>'), 'the estimate climbs where the 0 awards would have flatlined');
+  assert.match(fig, /estimated from shipped work, not the ledger/);
+  assert.ok(!out.includes('id="chart-rate"'), 'the pace chart stays own-only');
+  assert.ok(!out.includes('Could not load'), 'a 403 on the ledger is a fallback, not a failure');
+});
+
+test('a readable ledger with nothing in it draws one honest line, not a crash', async () => {
+  const b = bootRender({ rows: [ship('2026-08-01')], ledger: [] });
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 95, selfId: 95, signedIn: true, now: NOW });
+  const out = b.mount.innerHTML;
+  const fig = out.slice(out.indexOf('id="chart-drachmae"'), out.indexOf('id="chart-mix"'));
+  assert.match(fig, /nothing recorded yet/);
+  assert.ok(out.includes('id="chart-works"') && out.includes('id="chart-mix"'), 'the other charts are untouched');
+});
+
+test('the harness carries a credits-ledger fixture the chart can climb on, self-paged, serving both routes', () => {
+  const fx = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'me__credits.json'), 'utf8'));
+  assert.ok(Array.isArray(fx.rows) && fx.rows.length > 1, 'rows to draw');
+  assert.equal(fx.page.total, fx.rows.length, 'total pinned to the rows here, or the pager would loop on the same page');
+  assert.ok(fx.rows.every((r) => Number.isFinite(r.delta) && Number.isFinite(Date.parse(r.recorded_at))), 'every row is a delta at a time');
+  assert.ok(new Set(fx.rows.map((r) => r.recorded_at.slice(0, 10))).size > 1, 'across more than one day, so the line is not flat');
+  const server = fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'server.js'), 'utf8');
+  assert.ok(server.includes("[/^builders\\/\\d+\\/credits$/, 'me__credits']"), 'the roster route falls back to the same ledger');
+});
+
+test('the readout is written with textContent — the hover layer never builds markup from data', () => {
+  const fn = chartsJs.slice(chartsJs.indexOf('function wireReadout'), chartsJs.indexOf('function twinHtml'));
+  assert.match(fn, /read\.textContent = /);
+  assert.doesNotMatch(fn, /innerHTML/);
+});
+
+// ---- the states file ---------------------------------------------------------------
+
+test('the profile states file renders each rail key, so the floors cover every screen', () => {
+  const states = JSON.parse(read('profile.states.json'));
+  assert.ok(states.states.own.expect.visible.includes('#profile-rail'), 'own: the rail');
+  assert.ok(states.states.own.expect.visible.includes('#charts-grid'), 'own: the charts');
+  assert.equal(states.states.activity.url, '/profile#activity');
+  assert.ok(states.states.activity.expect.visible.includes('#activity-tabs'));
+});