@bongos/core 1.19.113 → 1.19.115

package/scripts/gds/audit-authorship.sh

@@ -202,10 +202,6 @@ ALLOWLIST=(
   'tests/auth_anthropic_identity.mjs'
   'modules/dev-box/app/test/unit.mjs'
 
-  # The public landing page links the open-source repo by URL — repo-hosting
-  # identity (the provision-staging.sh class), not a builder identity.
-  'public-landing/create.html'
-
   # The mirror-redaction floor: PRIOR_INSTANCE_FLOOR carries the prior
   # instance's owner literal precisely so packaging can SCRUB it from every
   # published core — the anti-leak spec, not a runtime hardcode (task 1002640).

package/scripts/gds/onboard.js

@@ -23,7 +23,7 @@ const oauth = require(path.join(__dirname, 'oauth-secret.js'));     // validateC
 // ── PURE core (exported for tests) ───────────────────────────────────────────
 
 // The canonical step sequence now lives in ONE place — the provisioning module — so the
-// CLI (here), the branded /create page, and the hall wizard can't drift (task 2085; goal
+// CLI (here) and the hub's ?view=new wizard can't drift (task 2085; goal
 // 35 / criterion 165: "the canonical step sequence is the source of truth; skill/CLI/hall
 // are forms over it"). The web forms read it over GET /provisioning/onboard-plan; the CLI
 // requires it directly. Re-exported below so `bongos onboard` + tests keep the same API.

package/src/module-api.js

@@ -653,8 +653,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.111 with no explicit bump. run 31814245230. (task 1002620)
 //   1.19.113 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.112 with no explicit bump. run 31816239246. (task 1002620)
+//   1.19.114 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.113 with no explicit bump. run 31816599678. (task 1002620)
+//   1.19.115 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.114 with no explicit bump. run 31825824596. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.113'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.115'; // CI auto-patch carrier (ADR 0161); see changelog above
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/src/platform-server.js

@@ -184,13 +184,21 @@ function buildPlatformApp() {
     if (!html) return next();
     res.type('html').send(html);
   });
-  // The branded project-creation experience (goal 35, task 2081) — a sibling
-  // landing page at a clean /create URL, branding-injected like the landing.
+  // The create wizard was absorbed into the hub's ?view=new view (task 1002763;
+  // direction §4 — "/create redirects to ?view=new"). This route only carries
+  // visitors — and any ?name= seed the old links still send — into it. 302, not
+  // 301: /create is an OAuth return target in the wild, and a browser-cached
+  // permanent redirect would outlive any future change of shape.
   app.get('/create', (req, res, next) => {
     if (!isApexHost(req)) return next();
-    const html = landingPage('create.html');
-    if (!html) return next();
-    res.type('html').send(html);
+    // rebuilt, not spliced: an inbound ?view= must not ride along (the hub
+    // reads the FIRST view param — a duplicate would bet the route on that
+    // parser detail), and an empty query must not leave a bare trailing '&'
+    const qi = req.url.indexOf('?');
+    const rest = new URLSearchParams(qi >= 0 ? req.url.slice(qi + 1) : '');
+    rest.delete('view');
+    const tail = rest.toString();
+    res.redirect(302, '/projects?view=new' + (tail ? '&' + tail : ''));
   });
   // THE PROJECT HUB (task 1002743) — one surface holding every project-shaped
   // action: the map of what exists (the orb sky the gate used to own, plus the

package/tests/cosmos_token_contrast.mjs

@@ -144,8 +144,9 @@ const PAIRS = [
   ['.btn.ghost:hover label',            'var(--accent-deep)',   CARD,                   4.5],
   ['.btn.danger label',                 'var(--err)',           CARD,                   4.5],
   // Inline links: cosmos.css recolors its own to --sun-lit in dark (:179-262), but
-  // create.html has ELEVEN --accent-deep consumers and zero dark CSS rules (its only
-  // data-mode hits are the JS toggle), so there the token itself must carry dark.
+  // the ?view=new wizard styles (absorbed from create.html, task 1002763) carry
+  // eleven --accent-deep consumers and zero dark rules of their own, so there the
+  // token itself must carry dark.
   ['inline link on a card',             'var(--accent-deep)',   CARD,                   4.5],
   ['inline link on the page ground',    'var(--accent-deep)',   'var(--bg)',            4.5],
   ['code chip on --bg-deep',            'var(--accent-deep)',   'var(--bg-deep)',       4.5],
@@ -172,11 +173,13 @@ const PAIRS = [
   ['.projMsg.ok',                       'var(--ok)',            CARD,                   4.5],
   ['.projMsg.err / .confirmRow',        'var(--err)',           CARD,                   4.5],
   // chrome: wordmark + footer sit on the page ground, not on a card
-  // create.html page-local grounds — it carries its own <style> and its own
-  // darkest tints, so cosmos.css's pairs alone do not cover /create
-  ['create.html .ghrow .priv 11px',     'var(--ink-soft)',      'color-mix(in srgb,var(--ink) 8%,var(--bg-deep))', 4.5],
-  ['create.html ::placeholder',         'var(--ink-faint)',     CARD,                   4.5],
-  ['create.html .ghlist .hint on deep', 'var(--ink-faint)',     'var(--bg-deep)',       4.5],
+  // wizard grounds (projects.html ?view=new, absorbed from create.html in task
+  // 1002763) — its panels carry their own darkest tints, so cosmos.css's pairs
+  // alone do not cover them
+  ['?view=new .ghrow .priv 11px',       'var(--ink-soft)',      'color-mix(in srgb,var(--ink) 8%,var(--bg-deep))', 4.5],
+  ['--on-ok on an --ok fill',           'var(--on-ok)',         'var(--ok)',            4.5],
+  ['?view=new input ::placeholder',     'var(--ink-faint)',     CARD,                   4.5],
+  ['?view=new .ghlist .hint on deep',   'var(--ink-faint)',     'var(--bg-deep)',       4.5],
   ['--chrome-accent wordmark',          'var(--chrome-accent)', 'var(--page-bg)',       4.5],
   ['--chrome-ink',                      'var(--chrome-ink)',    'var(--page-bg)',       4.5],
   ['--foot-ink footer copy',            'var(--foot-ink)',      'var(--page-bg)',       4.5],

package/tests/module-scope-map.mjs

@@ -127,7 +127,7 @@ test('platform-identity joined the roster (task 1002322) — the catalog territo
     'modules/platform-identity/routes/projects.js',     // the feed + invite routes
     'modules/status-ui/public/explore.js',              // orb render-type surface
     'modules/hall-ui/public/my-projects.js',            // owner settings / applications queue
-    'public-landing/create.html',                       // the project-detail creation step
+    'public-landing/projects.html',                     // the creation step, ?view=new since task 1002763
     'modules/provisioning/',                            // module-bundle selection at provision time
   ]) {
     assert.equal(covers(touch), true, `wall does not cover ${touch}`);

package/tests/onboard.mjs

@@ -86,18 +86,19 @@ test('every render surface carries the terminal hall step (task 1002703)', () =>
   const cli = read('scripts/gds/onboard.js');
   assert.match(cli, /builders hall/i, 'the CLI walkthrough ends at the hall');
   assert.match(cli, /bongos dev/, 'the CLI offers the local-hall one-liner when no domain');
-  const createHtml = read('public-landing/create.html');
-  const enterHall = createHtml.match(/data-onboard-step="enter-hall"[^]*?<\/li>/g) || [];
-  assert.ok(enterHall.length >= 1, '/create tags the enter-hall step');
-  assert.match(enterHall.join(''), /\/builders/, '/create points at the hall address');
-  assert.match(enterHall.join(''), /bongos dev/, '/create offers the local hall when no domain');
+  const hubHtml = read('public-landing/projects.html');
+  const enterHall = hubHtml.match(/data-onboard-step="enter-hall"[^]*?<\/li>/g) || [];
+  assert.ok(enterHall.length >= 1, 'the ?view=new wizard tags the enter-hall step');
+  assert.match(enterHall.join(''), /\/builders/, 'the wizard points at the hall address');
+  assert.match(enterHall.join(''), /bongos dev/, 'the wizard offers the local hall when no domain');
 });
 
-test('the /create done panel is plan-driven, manifest-driven, and owner-honest (task 1002694)', () => {
+test('the wizard done panel is plan-driven, manifest-driven, and owner-honest (task 1002694)', () => {
   // Gaps 2/3/4/14 of the project-creation audit (docs/audits/project-creation-gap-list.md).
+  // The wizard lives inside the hub page since task 1002763.
   const { readFileSync } = require('node:fs');
   const path = require('node:path');
-  const src = readFileSync(path.join(import.meta.dirname, '..', 'public-landing/create.html'), 'utf8');
+  const src = readFileSync(path.join(import.meta.dirname, '..', 'public-landing/projects.html'), 'utf8');
   // gap 2 (idea 1000675): the checklist renders FROM the canonical plan endpoint
   assert.match(src, /provisioning\/onboard-plan/, 'the done panel fetches the canonical plan');
   // gap 3 (idea 1000676): the ADR 0133 one-click manifest flow has a UI caller again
@@ -105,12 +106,14 @@ test('the /create done panel is plan-driven, manifest-driven, and owner-honest (
   assert.match(src, /github-app\/status/, 'and polls its progress to reflect live state');
   // gap 4: the operator-only control-plane command never reaches a new owner
   assert.doesNotMatch(src, /oauth-secret place/, 'owners are never handed the control-plane placement command');
-  // gap 14 (idea 1000684): repo visibility is stated, with the private path named
-  assert.match(src, /public/, 'visibility is stated');
-  assert.match(src, /adopt/i, 'the private path (adopt your own private repo) is named');
+  // gap 14 (idea 1000684): repo visibility is stated, with the private path named.
+  // Landmarks unique to the wizard — bare /public/ and /adopt/i match hub copy
+  // that has nothing to do with it, which would leave this guard vacuous.
+  assert.match(src, /public stays public, private stays private/, 'visibility is stated');
+  assert.match(src, /id="c-adopt"/, 'the private path (adopt your own private repo) is named');
 });
 
-test('the /create gate trust link points at a live artifact, not the dead private-repo URL (task 1002705)', () => {
+test('the wizard gate trust link points at a live artifact, not the dead private-repo URL (task 1002705)', () => {
   // Gap 1 of the project-creation audit: the gate linked a nonexistent private repo
   // (404 even authenticated — ADR 0167 names it). No public code artifact exists yet
   // (the ADR 0099 mirror is dormant until ~2026-11, and both npm scopes 404 anonymously
@@ -118,7 +121,7 @@ test('the /create gate trust link points at a live artifact, not the dead privat
   // "open source" is the license itself.
   const { readFileSync } = require('node:fs');
   const path = require('node:path');
-  const src = readFileSync(path.join(import.meta.dirname, '..', 'public-landing/create.html'), 'utf8');
+  const src = readFileSync(path.join(import.meta.dirname, '..', 'public-landing/projects.html'), 'utf8');
   assert.doesNotMatch(src, /Claude-OTB/, 'the dead repo link is gone');
   assert.match(src, /https:\/\/www\.gnu\.org\/licenses\/agpl-3\.0/, 'the trust link resolves (the AGPL-3.0 license text)');
 });
@@ -168,19 +171,20 @@ test('onboardPlan is the SAME function the provisioning module owns (single sour
   assert.equal(ob.onboardPlan, canonical, 'scripts/gds/onboard.js must re-export the module’s onboardPlan');
 });
 
-test('the web form (/create) declares EXACTLY the canonical human steps — drift guard', () => {
+test('the web form (?view=new) declares EXACTLY the canonical human steps — drift guard', () => {
   // goal 35 / criterion 165: "the canonical step sequence is the source of truth;
   // skill/CLI/web are forms over it." The web form tags its human-step <li>s with
   // data-onboard-step="<key>"; this asserts that set equals the plan's human-step keys,
   // so adding/removing/renaming a human step in the single source fails CI until every
   // form is updated (and vice-versa) — the sequence can no longer drift between forms.
-  // (The hall new-project wizard was removed in task 1002675 — project creation lives
-  // on the apex /create flow; the skill + CLI + /create remain the canonical forms.)
+  // (The hall new-project wizard was removed in task 1002675, and the apex /create
+  // page was absorbed into the hub's ?view=new view in task 1002763; the skill +
+  // CLI + the hub wizard remain the canonical forms.)
   const { readFileSync } = require('node:fs');
   const path = require('node:path');
   const humanKeys = ob.onboardPlan().filter((s) => s.kind === 'human').map((s) => s.key).sort();
   const surfaces = {
-    '/create landing page': 'public-landing/create.html',
+    '/projects?view=new wizard': 'public-landing/projects.html',
   };
   for (const [name, rel] of Object.entries(surfaces)) {
     const src = readFileSync(path.join(import.meta.dirname, '..', rel), 'utf8');

package/tests/platform_boot.mjs

@@ -121,16 +121,29 @@ test('the apex host serves the landing page — not the game — on a game-less
   assert.doesNotMatch(res.body, /Create a project/);
 });
 
-test('the apex host serves the branded /create page (goal 35, task 2081)', async () => {
-  // The project-creation experience is a platform-level page on the apex,
-  // branding-injected exactly like the landing (same landingPage memo).
+test('/create redirects into the hub wizard, seed intact (task 1002763)', async () => {
+  // The wizard was absorbed into /projects?view=new (direction §4); /create
+  // survives only as a 302 so old links and OAuth returns keep working. The
+  // query string rides along — /create?name= was the seeding entry point.
   const res = await request('/create', 'game.test.local');
-  assert.equal(res.status, 200);
-  assert.match(res.headers['content-type'] || '', /text\/html/);
-  assert.match(res.body, /window\.__BRANDING__=/);
-  assert.match(res.body, /Create a project/);
+  assert.equal(res.status, 302);
+  assert.equal(res.headers.location, '/projects?view=new');
+  // the query is rebuilt (URLSearchParams re-encodes space as '+', which the
+  // hub's URLSearchParams reading decodes right back), and an inbound view=
+  // never rides along to fight the one this route asserts
+  const seeded = await request('/create?name=Sky%20Farm&view=mine', 'game.test.local');
+  assert.equal(seeded.status, 302);
+  assert.equal(seeded.headers.location, '/projects?view=new&name=Sky+Farm');
+  const empty = await request('/create?', 'game.test.local');
+  assert.equal(empty.headers.location, '/projects?view=new');
+  // the branded wizard itself now ships inside the hub page
+  const hub = await request('/projects', 'game.test.local');
+  assert.equal(hub.status, 200);
+  assert.match(hub.headers['content-type'] || '', /text\/html/);
+  assert.match(hub.body, /window\.__BRANDING__=/);
+  assert.match(hub.body, /Create a project/);
   // the wizard files the request against the provisioning API, nothing else
-  assert.match(res.body, /provisioning\/instances/);
+  assert.match(hub.body, /provisioning\/instances/);
 });
 
 test('R51: an API-shaped 404 still gets a self-describing JSON body', async () => {

package/tests/projects_hub.mjs

@@ -212,17 +212,85 @@ test('the gate is retired — no route, no files, no links into it', () => {
   assert.doesNotMatch(HUB, /href="\/gate/);
 });
 
-test('/create still answers — the hub links it rather than absorbing it', () => {
-  // Task 1002743's Part 3 was AMENDED by the owner on 2026-08-13 to move the
-  // "/create redirects into the hub" clause to task 1002763, which carries the
-  // port that makes it safe. ?view=new is step 1 of the four-beat rail, so
-  // redirecting /create here before the wizard lives in the hub would let a
-  // visitor name a project and then go nowhere — creation would break. The
-  // wizard also has four id collisions with this page and a replaceState that
-  // strips the query string. Until 1002763 lands, /create must keep answering.
-  assert.ok(fs.existsSync(path.join(ROOT, 'public-landing', 'create.html')));
-  assert.match(SCRIPT, /location\.assign\('\/create'/);
-  assert.match(HUB, /href="\/create"/, 'the empty state must still point at the wizard');
+test('/create is absorbed — the wizard lives here and the route only redirects (task 1002763)', () => {
+  // Task 1002743 stopped at step 1: the hub named a project and navigated to
+  // /create?name=. This task carries the absorption the owner amended into it
+  // (direction §4: "/create redirects to ?view=new"): the wizard's six panels
+  // are real markup inside the new view (C7), create.html is deleted — the
+  // gate precedent above: express.static would keep serving the raw file —
+  // and the name handoff became an in-page step advance.
+  assert.equal(fs.existsSync(path.join(ROOT, 'public-landing', 'create.html')), false,
+    'create.html must be gone: express.static would keep serving it raw and unbranded');
+  assert.doesNotMatch(SCRIPT, /location\.assign\('\/create'/,
+    'naming a project advances the wizard in place — no navigation');
+  assert.doesNotMatch(HUB, /href="\/create"/, 'no link may point at the retired route');
+  assert.match(HUB, /href="\?view=new"/, 'in-page links carry the view query instead');
+  const server = fs.readFileSync(path.join(ROOT, 'src', 'platform-server.js'), 'utf8');
+  assert.match(server, /res\.redirect\(302, '\/projects\?view=new'/,
+    '/create must 302 into the hub (302, not 301: the URL is an OAuth return target in the wild)');
+  for (const id of ['panel-gate', 'panel-name', 'panel-home', 'panel-address', 'panel-review', 'panel-done']) {
+    assert.match(HUB, new RegExp(`id="${id}"`), `the wizard's ${id} ships as real markup (C7)`);
+  }
+});
+
+test('the absorbed wizard sheds its two URL landmines — /gate/ and the whole-query strip', () => {
+  // create.html carried a document-level Escape that navigated to the retired
+  // /gate/ (a 404 the href-only guard above cannot see: it was a
+  // location.assign, not an href) and a replaceState that rewrote the URL to
+  // location.pathname — which on this page would destroy ?view=new on load.
+  assert.doesNotMatch(SCRIPT, /['"]\/gate\//,
+    'no code path may navigate into the retired gate');
+  assert.doesNotMatch(SCRIPT, /history\.replaceState\(null, '', location\.pathname\)/,
+    "the hub's '?view=' + v rewrite is the only URL writer on this page");
+});
+
+test('no id is declared twice — the wizard merge had four collisions to clear', () => {
+  // modeToggle, who, signin, gateAlert all existed on BOTH pages; a duplicate
+  // id makes the second node unreachable by getElementById and the first
+  // silently wins. Scan the real markup only (JS builds ids like `dom-<iid>`
+  // from fragments that would false-positive here).
+  const afterHead = HUB.slice(HUB.indexOf('</script>') + '</script>'.length);
+  const markup = afterHead.slice(0, afterHead.indexOf('<script>'));
+  assert.ok(markup.includes('id="view-new"'), 'the markup slice must span the views');
+  const ids = [...markup.matchAll(/\sid="([^"]+)"/g)].map((m) => m[1]);
+  const seen = new Set();
+  const dupes = ids.filter((id) => (seen.has(id) ? true : (seen.add(id), false)));
+  assert.deepEqual(dupes, [], `duplicate ids in the hub markup: ${dupes}`);
+});
+
+test('the new view balances its own tree — the map-only walkers never covered it', () => {
+  // div-balance (:535) counts view-map only, and every openAncestorsAt needle
+  // lives there too; a lopsided div in the wizard block would be caught by
+  // nothing else while silently reparenting the footer.
+  const start = HUB.indexOf('<section id="view-new"');
+  const end = HUB.indexOf('<div class="foot"');
+  assert.ok(start !== -1 && end > start, 'need the view-new span');
+  const wiz = HUB.slice(start, end);
+  assert.equal((wiz.match(/<div\b/g) || []).length, (wiz.match(/<\/div>/g) || []).length,
+    'every div opened in #view-new closes in #view-new');
+  assert.equal((wiz.match(/<section\b/g) || []).length, (wiz.match(/<\/section>/g) || []).length,
+    'every section opened in #view-new closes in #view-new');
+});
+
+test('C8 — the wizard polls stop dead off the new view, like the sky off the map', () => {
+  // create.html's progress watch (5s) and manifest poll (4s/8s) had NO view
+  // guard — merged unguarded they would poll a hidden view for up to 33
+  // minutes. Both ticks must consult the same gate the sky consults.
+  assert.match(SCRIPT, /function wizPollActive\(\)/, 'the wizard needs its own stage guard');
+  assert.match(SCRIPT, /!document\.hidden && currentView === 'new'/,
+    'the guard is hidden-tab aware and view-scoped');
+  const gatedTicks = (SCRIPT.match(/if \(!wizPollActive\(\)\)/g) || []).length;
+  assert.ok(gatedTicks >= 2, `both wizard ticks (progress + manifest) must check the guard, found ${gatedTicks}`);
+  assert.match(SCRIPT, /if \(v === 'new'\) wizard\.enter\(focus\); else wizard\.leave\(\);/,
+    'setView hands the view to the wizard exactly like it starts/stops the sky');
+});
+
+test('the wizard never steals focus on boot — focus moves only on deliberate steps', () => {
+  // create.html's show() unconditionally focused each panel's h1, and its boot
+  // always called show() — merged as-is, every hub load would rip focus into a
+  // hidden view. The hub rule (setView's `focus` flag) now reaches show() too.
+  assert.match(SCRIPT, /function show\(step, moveFocus\)/, 'show() must carry the focus flag');
+  assert.match(SCRIPT, /if \(moveFocus\)/, 'and only focus when it is set');
 });
 
 /* ── The platform's own entry (task 1002760) ────────────────────────────────
@@ -702,3 +770,72 @@ test('the chip-freshness tick spends no requests — it re-renders what it has (
   assert.match(fn, /document\.hidden/, 'and does nothing in a hidden tab');
   assert.doesNotMatch(fn, /fetch\(/, 'zero requests — the re-fetch belongs to entry and tab return only');
 });
+
+/* ── The living sky (task 1002762) ──────────────────────────────────────────
+   The retired gate's n-body cluster + pan/zoom/hover/spotlight, rewritten for
+   the hub: one camera layer, physics in ~110 guarded lines, and the mock's
+   static field as the reduced-motion and no-JS state. These pin the C8/C9
+   contract and the structural topology the camera depends on. ── */
+
+test('the sky camera is one layer inside the field, outside the sentinels', () => {
+  const stack = openAncestorsAt(HUB, 'id="skyCam"');
+  assert.ok(stack.includes('view-map') && stack.includes('orbField'),
+    'the camera lives in the orb field. open: ' + stack.join(' > '));
+  assert.ok(!stack.includes('sub-table-body'), 'and never inside the table');
+  const selfStack = openAncestorsAt(HUB, 'id="selfOrb"');
+  assert.ok(selfStack.includes('skyCam'), 'the platform orb pans and zooms with everyone else');
+  const camAt = HUB.indexOf('id="skyCam"');
+  const selfAt = HUB.indexOf('id="selfOrb"');
+  const sentinelAt = HUB.lastIndexOf('<!--apex-only:start-->', selfAt);
+  assert.ok(camAt !== -1 && camAt < sentinelAt && sentinelAt < selfAt,
+    'the camera opens BEFORE the orb sentinel — stripApexOnly() must never eat its open tag');
+  const hoverStack = openAncestorsAt(HUB, 'id="hoverCard"');
+  assert.ok(hoverStack.includes('orbField') && !hoverStack.includes('skyCam'),
+    'the hover card sits outside the camera so it never scales or pans');
+});
+
+test('the sim stops dead when the sky is not on stage (C8, C9)', () => {
+  const active = (SCRIPT.match(/function skyActive\(\)\s*\{([\s\S]*?)\n  \}/) || [, ''])[1];
+  assert.ok(active, 'skyActive() must exist');
+  for (const guard of ['REDUCED', 'document.hidden', "currentView === 'map'", 'sub-sky-body']) {
+    assert.ok(active.includes(guard), `skyActive must check ${guard}`);
+  }
+  const tick = (SCRIPT.match(/function skyTick\(now\)\s*\{([\s\S]*?)\n  \}/) || [, ''])[1];
+  assert.ok(tick, 'skyTick() must exist');
+  assert.match(tick, /if \(!skyActive\(\)\) return/, 'a tick on a hidden sky ends the loop, not just the work');
+  assert.doesNotMatch(tick, /fetch\(/, 'the sky spends no requests (C6+C8)');
+  const step = (SCRIPT.match(/function physStep\(dt\)\s*\{([\s\S]*?)\n  \}/) || [, ''])[1];
+  assert.ok(step, 'physStep() must exist');
+  assert.doesNotMatch(step, /fetch\(/);
+});
+
+test('a drag is a pan and a click is a click — the two never blur', () => {
+  assert.match(SCRIPT, /var SKY_DEADZONE = 5/, 'the 5px Euclidean deadzone from the gate');
+  // mutation-found gap: a bare /skyPanned/ match was satisfied by the flag's
+  // declaration alone — pin the CONSUME site and the deferred clear instead
+  assert.match(SCRIPT, /if \(skyPanned\) \{ ev\.preventDefault\(\); return; \}/,
+    'the delegated click handler consumes the pan flag AND still cancels the link');
+  assert.match(SCRIPT, /setTimeout\(function \(\) \{ skyPanned = false; \}, 0\)/,
+    'the flag clears a tick after the pan ends, so a keyboard Enter is never eaten');
+  assert.match(SCRIPT, /pointercancel/, 'an interrupted touch must not strand the grab state');
+  assert.match(SCRIPT, /panId/, 'one pointer owns the drag — a second finger cannot hijack it');
+});
+
+test('anchors are never read from a hidden field', () => {
+  // review CRITICAL: offsetLeft/Top and clientWidth all read 0 under
+  // [hidden]{display:none} — anchoring to zeros paints every orb at
+  // slot + physics position when the sky returns. The rebuild must defer.
+  const fn = (SCRIPT.match(/function rebuildSkyBodies\(\)\s*\{([\s\S]*?)\n  \}/) || [, ''])[1];
+  assert.ok(fn, 'rebuildSkyBodies() must exist');
+  assert.match(fn, /clientWidth\) \{ skyNeedsRebuild = true; return; \}/,
+    'an unlaid-out field defers the rebuild instead of anchoring to zeros');
+  assert.match(SCRIPT, /if \(skyNeedsRebuild\) rebuildSkyBodies\(\);/,
+    'the deferred rebuild is consumed when the sky comes back on stage');
+});
+
+test('zoom heads for the cursor and survives line-mode wheels', () => {
+  assert.match(SCRIPT, /deltaMode/, 'Firefox line-mode deltas must be normalized');
+  assert.match(SCRIPT, /Math\.exp\(/, 'exponential zoom — symmetric in and out');
+  assert.ok(COSMOS.includes('transform-origin:0 0'),
+    'the camera algebra assumes the layer scales about its origin');
+});

package/tests/public_landing_projects.mjs

@@ -14,8 +14,9 @@
 //     intent_conflict, not_teardownable, bad_domain, domain_taken,
 //     domain_already_set, domain_not_attachable are all SAID, never swallowed)
 //   • an instance with no domain gets an HONEST no-address state, not a blank
-//   • create.html's poll give-up now points at /projects — the false "the hall
-//     has it" stop (the hall my-projects card was removed in task 1002675) is gone
+//   • the wizard's poll give-up points at the projects view — the false "the
+//     hall has it" stop (the hall card was removed in task 1002675) is gone.
+//     (create.html itself was absorbed into ?view=new in task 1002763.)
 //
 // Run:  node --test tests/public_landing_projects.mjs
 
@@ -106,17 +107,20 @@ test('a domainless instance gets an honest no-address state', async () => {
   assert.match(body, /[Nn]o address yet/);
 });
 
-test('the empty state points a new owner at /create — never at a hall', async () => {
+test('the empty state points a new owner at the wizard view — never at a hall', async () => {
   const { body } = await request('/projects', 'game.test.local');
-  assert.match(body, /href="\/create"/);
+  // /create was absorbed into ?view=new (task 1002763); the CTA moves in-page
+  assert.match(body, /href="\?view=new"/);
+  assert.doesNotMatch(body, /href="\/create"/, 'no link may point at the retired route');
   // the hall my-projects card was REMOVED (task 1002675; hall my-projects is
   // federation-only) — this page must not send an owner there
   assert.doesNotMatch(body, /Enter the Hall/i);
 });
 
-test('create.html: the poll give-up points at /projects — "the hall has it" is dead', async () => {
-  const { body } = await request('/create', 'game.test.local');
-  assert.match(body, /\/projects/, 'the give-up path must hand the owner the projects page');
+test('the watch give-up hands the owner their projects view — "the hall has it" is dead', async () => {
+  // the wizard (and its 33-minute watch cap) lives on /projects now
+  const { body } = await request('/projects', 'game.test.local');
+  assert.match(body, /your projects page/, 'the give-up path must hand the owner the projects view');
   assert.doesNotMatch(body, /the hall has it/, 'the false poll-stop copy must be gone');
 });
 
@@ -151,7 +155,8 @@ test('the stamp is derived from CONTENT, so it changes only when the file does',
 });
 
 test('every landing surface is stamped, not just the one that broke', async () => {
-  for (const p of ['/', '/projects', '/create']) {
+  // /create dropped from the loop: it 302s since task 1002763 (no body to stamp)
+  for (const p of ['/', '/projects']) {
     const res = await request(p);
     if (res.status !== 200) continue;
     assert.doesNotMatch(res.body, /(href|src)="\/assets\/[^"?]+"/,
@@ -163,8 +168,8 @@ test('routes and API paths are never mistaken for assets', async () => {
   // stamping resolves the URL against public-landing/ — a route names no file,
   // so it must come back untouched rather than acquiring a meaningless ?v=
   const res = await request('/projects');
-  assert.match(res.body, /href="\/create"/, '/create is a route, not an asset');
-  assert.doesNotMatch(res.body, /href="\/create\?v=/);
+  assert.match(res.body, /href="\/"/, "'/' is a route, not an asset");
+  assert.doesNotMatch(res.body, /href="\/\?v=/);
   assert.doesNotMatch(res.body, /href="\/projects\?v=/);
   assert.doesNotMatch(res.body, /\/api\/bongos\/[^"]*\?v=[0-9a-f]{8}/,
     'API paths must never be stamped');