@bongos/core 1.19.113 → 1.19.114

package/.bongos-core.json

@@ -2,11 +2,11 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.113",
-  "core_contract": "1.19.113",
-  "source_commit": "4f04a88c84292c94616306d95392485737ed1737",
+  "core_version": "1.19.114",
+  "core_contract": "1.19.114",
+  "source_commit": "0de67d2652248283befaf1c2ee7ecbf83fa50346",
   "source_ref": "HEAD",
-  "built_at": "2026-08-14T15:48:22.422Z",
+  "built_at": "2026-08-14T15:52:55.624Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 302,
@@ -17,7 +17,7 @@
     "gate": "passed"
   },
   "file_count": 1559,
-  "tree_sha256": "52d268079196d1b135c13eab10c51c87c9b1424cad1079ec595591824b0a0daf",
+  "tree_sha256": "f530c12a47c766a901cbfd537e9aa4cdaa95663cfda270bbc25c8575fee0bede",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -4152,12 +4152,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "2c8ecaac1dcae43c85fa2b642e470908f69dfdd6190e0986e06e120220ebe6d2"
+      "sha256": "de51e915b8cf14b11d3cc68cc6106a2baed1bf351da2c94be74ff65b42c2ac09"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "4a7a150717c7a3336a9f72ed5ce773a229850b90cce8314de632067305371394"
+      "sha256": "2fdb7573bd5efafc25771e96ce4a3fc790a8d5e83483dac1c3d3bcd3f1b513fe"
     },
     {
       "path": "public-docs/index.html",
@@ -4397,7 +4397,7 @@
     {
       "path": "public-landing/assets/cosmos.css",
       "mode": "0000644",
-      "sha256": "4b549b012f7e736ee81e54ed35a65c96acf9cd6a223c3e9fac369d9328426a88"
+      "sha256": "ad327f42773674cc3a6deb3f65e0f9da89fd1c4c47947c513a958a0b8d37ff5f"
     },
     {
       "path": "public-landing/buddha.png",
@@ -4417,7 +4417,7 @@
     {
       "path": "public-landing/projects.html",
       "mode": "0000644",
-      "sha256": "264e6f7cb1273b24208b3063bec53f544d86f9174a4bd854a57c784722427583"
+      "sha256": "1a58ca91bed5e4658599b1290465ee83b5845b7465376e13d19bd79ab6ac3dc1"
     },
     {
       "path": "public-landing/world/assets/clouds/cloud-island-large.png",
@@ -5732,7 +5732,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "c19adbd125efe46fba720abdecef683027e607275543b65e971630304d686b75"
+      "sha256": "766abd484728dd8ceb692aa3a4e5a1c4e68f9767503af3982ba69bc6deabe0c6"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -7257,7 +7257,7 @@
     {
       "path": "tests/projects_hub.mjs",
       "mode": "0000644",
-      "sha256": "5b23c369288ebdfd4a35ad76faa5ac5fbf9ff7b55de2a283b184977ba5513abe"
+      "sha256": "dc915f8d09f97eb4a359bf4627a4e4dddb77daf2cd438084bae1b4abbe04963d"
     },
     {
       "path": "tests/provision.mjs",

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.113",
+  "version": "1.19.114",
   "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/public-landing/assets/cosmos.css

@@ -577,6 +577,28 @@ p.sec-p{font-size:var(--fs-lede);font-weight:500;color:var(--ink-soft);line-heig
 .tbl .colName{width:auto;}
 @media (max-width:780px){.tbl .colTags{display:none;}}
 
+/* ── the living sky (task 1002762): camera, spotlight, hover card ──
+   The camera is ONE transform on .skyCam; orbs carry only their own physics
+   delta. transform-origin 0 0 is load-bearing — the pan/zoom algebra assumes
+   the layer scales about its origin. */
+.field .skyCam{position:absolute;inset:0;transform-origin:0 0;will-change:transform;}
+.fieldWrap{cursor:grab;touch-action:pan-y pinch-zoom;user-select:none;-webkit-user-select:none;}
+.fieldWrap.panning,.fieldWrap.panning .worldOrb{cursor:grabbing;}
+.worldOrb{transition:opacity .25s ease;}
+/* a dimmed orb is backdrop — no pointer, no focus (the JS drops it from the
+   tab order); at .25 opacity its label could not carry interaction honestly */
+.worldOrb.dim{opacity:.25;filter:saturate(.35);pointer-events:none;}
+/* the spotlight glow is an OUTLINE + drop-shadow, never box-shadow: the owned
+   ring already lives on the disc's box-shadow, and a same-specificity
+   box-shadow here would silently delete it by source order */
+.worldOrb.match .disc{outline:3px solid color-mix(in srgb,var(--acc,var(--accent)) 55%,transparent);
+  outline-offset:3px;filter:drop-shadow(0 0 16px color-mix(in srgb,var(--acc,var(--accent)) 60%,transparent));}
+.field .hoverCard{position:absolute;z-index:6;pointer-events:none;display:flex;flex-direction:column;gap:2px;
+  background:var(--bg-card);border:1.5px solid var(--line);border-radius:12px;box-shadow:var(--shadow-card);
+  padding:9px 13px;max-width:240px;}
+.field .hoverCard .hn{font-family:var(--font-display);font-weight:700;font-size:13.5px;color:var(--ink);white-space:nowrap;}
+.field .hoverCard .ht{font-size:12px;color:var(--ink-faint);font-weight:600;}
+
 /* ── the project card ──
    An overlay INSIDE the map, not a destination: opening a project must not cost
    you the sky you were reading (direction §9). It sits above .shell (z-index 40)

package/public-landing/projects.html

@@ -147,6 +147,13 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
     <div class="field" id="orbField">
       <div class="ground"></div>
       <div class="stars" id="mapStars" aria-hidden="true"></div>
+      <!-- The camera (task 1002762). Pan and zoom are ONE transform on this
+           layer; orbs write only their own physics delta, so the two compose
+           for free and the ground, stars, empty state and hintbar stay put.
+           It opens BEFORE the apex sentinel: stripApexOnly() deletes whole
+           sentinel spans, and a tag opened inside one would leave the child
+           instance an unbalanced tree. -->
+      <div class="skyCam" id="skyCam">
       <!-- The platform's own orb. Static markup, not JS-built, precisely so the
            apex-only sentinels can remove it: a child instance has no "this
            platform" to point at, and stripApexOnly() is a string transform that
@@ -158,12 +165,17 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
         <span class="sub">this platform</span>
       </a>
       <!--apex-only:end-->
+      </div>
       <div class="fieldEmpty">
         <p id="emptyMsg">You don’t own or build on anything here yet.</p>
         <span class="sub">Turn the filter off to see what everyone else is building — or start your own.</span>
         <a class="btn small" href="?view=new" data-nav-to="new">Start a project</a>
       </div>
-      <div class="hintbar"><span><kbd>click a project</kbd> open it</span></div>
+      <div class="hintbar"><span><kbd>drag</kbd> pan</span><span><kbd>scroll</kbd> zoom</span><span><kbd>click a project</kbd> open it</span></div>
+      <!-- The hover card: a glance, not a dialog. Outside the camera so it
+           never scales, aria-hidden because the orb itself is the accessible
+           link, and chip-free — the orb's own chip is the ONE liveness site. -->
+      <div class="hoverCard" id="hoverCard" hidden aria-hidden="true"></div>
     </div>
   </div>
 
@@ -474,6 +486,12 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
     if (v === 'mine' && me) refreshList();
     /* owned chips refresh on re-entry, never on a timer — C8 keeps the map quiet */
     if (v === 'map' && me) loadOwnedInstances().then(applyMapFilter);
+    /* the living sky runs only on stage (C8) — start and stop with the view;
+       anchors that went unreadable while the map was hidden re-adopt first */
+    if (v === 'map') {
+      if (skyNeedsRebuild) rebuildSkyBodies();
+      startSky();
+    } else { stopSky(); hideHover(); }
     /* focus the name field only on a deliberate move into the view — never on
        boot, where it would steal focus from whatever the visitor arrived at */
     if (v === 'new' && focus) $('newName').focus();
@@ -651,16 +669,24 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
     return hay.toLowerCase().indexOf(q) !== -1;
   }
 
-  function renderOrbs(list) {
-    var field = $('orbField');
+  function renderOrbs(list, dimmed) {
+    var layer = $('skyCam');
     /* replace only the generated orbs — the platform's own orb is static
        apex-only markup and must survive every re-render */
-    field.querySelectorAll('.worldOrb[data-generated]').forEach(function (n) { n.remove(); });
-    var hint = field.querySelector('.hintbar');
-    list.forEach(function (p, i) {
+    layer.querySelectorAll('.worldOrb[data-generated]').forEach(function (n) { n.remove(); });
+    /* the spotlight (task 1002762): while a query is live the sky DIMS what
+       does not match instead of removing it — the cluster keeps its shape and
+       the matches glow. The table still filters, and the count counts matches. */
+    var spot = !!(dimmed && dimmed.length);
+    (spot ? list.concat(dimmed) : list).forEach(function (p, i) {
       var slot = ORB_SLOTS[i % ORB_SLOTS.length];
+      var isDim = spot && i >= list.length;
       var a = document.createElement('a');
-      a.className = 'worldOrb';
+      a.className = 'worldOrb' + (spot ? (isDim ? ' dim' : ' match') : '');
+      /* a dimmed orb is BACKDROP: at .25 opacity its label cannot carry
+         interaction honestly, so it leaves the tab order and the pointer
+         (pointer-events:none in css) — the matches and the table do the work */
+      if (isDim) { a.setAttribute('aria-hidden', 'true'); a.tabIndex = -1; }
       a.setAttribute('data-generated', '');
       var rel = relOf(p);
       a.setAttribute('data-rel', rel);
@@ -695,7 +721,7 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
            project can never look alive in the sky and unreachable in the list
            (C6: two views of one truth) */
         (inst ? chipFor(inst) : '');
-      field.insertBefore(a, hint);
+      layer.appendChild(a);
     });
   }
 
@@ -766,6 +792,11 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
     var list = browse.filter(function (p) {
       return matchesMapQuery(p, q) && (!onlyMine || relOf(p) !== 'none');
     });
+    /* what the query rules OUT still exists — the sky dims it (spotlight);
+       the "only mine" switch is a filter, not a search, and stays a removal */
+    var dimmedOrbs = q ? browse.filter(function (p) {
+      return !matchesMapQuery(p, q) && (!onlyMine || relOf(p) !== 'none');
+    }) : [];
     list.sort(function (x, y) {
       if (mapSort.key === 'name') return String(x.name || '').localeCompare(String(y.name || '')) * mapSort.dir;
       /* unknown (null) sorts to the BOTTOM in both directions — it is not a low
@@ -779,7 +810,7 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
       }
       return 0;
     });
-    renderOrbs(list);
+    renderOrbs(list, dimmedOrbs);
     renderRows(list);
 
     /* The platform's own entry, in BOTH views from one predicate — it used to
@@ -788,11 +819,19 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
        It is somebody's: see selfRel(). It still answers the search box, and it
        still vanishes for a signed-out visitor, who owns nothing here. */
     var rel = selfRel();
-    var selfShown = (rel !== 'none' || !onlyMine) && matchesMapQuery(SELF_PROJECT, q);
+    var selfPass = (rel !== 'none' || !onlyMine);
+    var selfShown = selfPass && matchesMapQuery(SELF_PROJECT, q);
     var badge = rel === 'owner' ? 'yours' : rel === 'builder' ? 'you build here' : '';
     var orb = $('selfOrb'), row = $('selfRow');
     if (orb) {
-      orb.hidden = !selfShown;
+      /* in the sky a query DIMS the platform like everyone else; the "only
+         mine" filter still removes it for a signed-out visitor. Dimmed = pure
+         backdrop, same as a generated dim: no focus, no pointer. */
+      var selfDim = selfPass && !selfShown;
+      orb.hidden = !selfPass;
+      orb.classList.toggle('dim', selfDim);
+      if (selfDim) { orb.setAttribute('aria-hidden', 'true'); orb.tabIndex = -1; }
+      else { orb.removeAttribute('aria-hidden'); orb.removeAttribute('tabindex'); }
       orb.setAttribute('data-rel', rel);
       var b = orb.querySelector('.badge');
       if (badge && !b) { b = document.createElement('span'); b.className = 'badge'; orb.insertBefore(b, orb.firstChild); }
@@ -804,11 +843,18 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
     }
 
     var shown = list.length + (selfShown ? 1 : 0);
-    $('orbField').classList.toggle('isEmpty', shown === 0 && (onlyMine || !!q));
+    /* a sky full of DIMMED orbs is not empty — the message would paint over
+       them and eat their pointer events; it shows only when nothing renders */
+    $('orbField').classList.toggle('isEmpty', shown === 0 && !dimmedOrbs.length && (onlyMine || !!q));
     $('emptyMsg').textContent = onlyMine
       ? 'You don’t own or build on anything here yet.'
       : 'Nothing here matches that.';
     $('mapCount').textContent = shown + (shown === 1 ? ' project' : ' projects');
+
+    /* every re-render replaces the orb nodes — the sim re-adopts them,
+       carrying position + velocity for orbs that persisted (see the sky) */
+    rebuildSkyBodies();
+    startSky();
   }
 
   /* ══ THE PROJECT CARD ══════════════════════════════════════════════════════
@@ -904,6 +950,9 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
   $('orbField').addEventListener('click', function (ev) {
     var a = ev.target.closest && ev.target.closest('.worldOrb');
     if (!a || !isPlainClick(ev)) return;
+    /* a drag that ended on an orb is a pan, not a click (task 1002762) —
+       and the link underneath must not fire either */
+    if (skyPanned) { ev.preventDefault(); return; }
     ev.preventDefault();
     if (a.id === 'selfOrb') return openCard(SELF_PROJECT, selfRel(), a);
     /* an owned orb's job is MANAGE (direction §5) — before the card path */
@@ -1049,11 +1098,439 @@ try{var _m=localStorage.getItem('cb-color-mode');if(_m==='light'||_m==='dark')do
     });
   });
 
+  /* ══ THE LIVING SKY (task 1002762) ═════════════════════════════════════════
+     The retired gate's cluster, rewritten for the hub. Physics is the gate's
+     verified core (core-v1.19.93 space.js: softened Newtonian pairs, fixed-dt
+     kick-drift-kick leapfrog, soft collisions, a KE band thermostat, per-step
+     drift removal — stable over a 60-min headless run), re-tuned for this
+     roster: the containment well's radius derives from the actual spread
+     instead of the gate's 520px constant, and mass comes from disc size.
+
+     Layers: the CAMERA is one transform on #skyCam (pan + zoom-toward-cursor,
+     the gate's exact algebra); each orb writes only its own physics delta over
+     its slot anchor, so the two compose for free. The loop is C8-guarded —
+     it stops DEAD off the map view, on the table sub-view, in a hidden tab —
+     and never starts under prefers-reduced-motion (C9): reduced and no-JS
+     both get the mock's static field. Zero requests anywhere in the loop. ══ */
+
+  var SKY_GRAV = {
+    R_REF: 50,          /* mass = (radius / R_REF)^3 — size IS gravity */
+    G: 5200,            /* px^3 / mass·s^2 */
+    SOFTEN: 48,         /* Plummer softening ~ a typical orb radius here */
+    SWIRL: 0.09,        /* initial solid-body swirl (rad/s) */
+    SWIRL_JITTER: 0.15,
+    REST: 0.92,         /* near-elastic contacts (rare) */
+    CONTAIN_K: 6.0,     /* inward accel per px beyond the well */
+    MAXV: 260,          /* last-resort speed cap (px/s) */
+    THERMO_LO: 0.55, THERMO_HI: 1.9, THERMO_MAX: 0.01,
+    PHYS_HZ: 120
+  };
+  var skyBodies = [], keTarget = 0, containR = 460, containAspect = 1;
+  var skyView = { x: 0, y: 0, z: 1 };
+  var SKY_ZMIN = 0.55, SKY_ZMAX = 2.4;
+  var SKY_DEADZONE = 5;   /* px of movement before a press becomes a pan */
+  var skyPanned = false;  /* consumed by the delegated click handler */
+  var skyPtr = { x: 0, y: 0 };
+
+  function skyBarycenter() {
+    var M = 0, x = 0, y = 0;
+    for (var i = 0; i < skyBodies.length; i++) { var b = skyBodies[i]; M += b.m; x += b.m * b.x; y += b.m * b.y; }
+    return M > 0 ? { x: x / M, y: y / M } : { x: 0, y: 0 };
+  }
+  function skyKE() {
+    var e = 0;
+    for (var i = 0; i < skyBodies.length; i++) { var b = skyBodies[i]; e += 0.5 * b.m * (b.vx * b.vx + b.vy * b.vy); }
+    return e;
+  }
+  function killSkyDrift() {
+    var M = 0, px = 0, py = 0;
+    for (var i = 0; i < skyBodies.length; i++) { var b = skyBodies[i]; M += b.m; px += b.m * b.vx; py += b.m * b.vy; }
+    if (M <= 0) return;
+    var dvx = px / M, dvy = py / M;
+    for (var j = 0; j < skyBodies.length; j++) { skyBodies[j].vx -= dvx; skyBodies[j].vy -= dvy; }
+  }
+  function computeSkyForces(c) {
+    var n = skyBodies.length, soft2 = SKY_GRAV.SOFTEN * SKY_GRAV.SOFTEN, i, j;
+    for (i = 0; i < n; i++) { skyBodies[i].fx = 0; skyBodies[i].fy = 0; }
+    for (i = 0; i < n; i++) {
+      for (j = i + 1; j < n; j++) {
+        var a = skyBodies[i], b = skyBodies[j];
+        var dx = b.x - a.x, dy = b.y - a.y;
+        var d2 = dx * dx + dy * dy + soft2;
+        var f = SKY_GRAV.G / (d2 * Math.sqrt(d2));
+        a.fx += f * b.m * dx; a.fy += f * b.m * dy;
+        b.fx -= f * a.m * dx; b.fy -= f * a.m * dy;
+      }
+    }
+    /* soft containment well — a gentle inward pull only beyond containR.
+       ELLIPTICAL, matched to the field: the gate's circular well lived in an
+       unbounded camera world, but this field clips, and it is much wider than
+       it is tall — a circular well sized to the x-spread would let vertical
+       orbits sail past the clipped edge. y-distance is scaled by the aspect,
+       so the well's shape is the field's shape. */
+    var a2 = containAspect * containAspect;
+    for (i = 0; i < n; i++) {
+      var it = skyBodies[i], ex = it.x - c.x, ey = it.y - c.y;
+      var d = Math.hypot(ex, ey * containAspect);
+      if (d > containR && d > 1e-6) {
+        var k = -SKY_GRAV.CONTAIN_K * (d - containR) / d;
+        it.fx += k * ex; it.fy += k * ey * a2;
+      }
+    }
+  }
+  function resolveSkyCollisions() {
+    for (var i = 0; i < skyBodies.length; i++) {
+      for (var j = i + 1; j < skyBodies.length; j++) {
+        var a = skyBodies[i], b = skyBodies[j];
+        var dx = b.x - a.x, dy = (b.y + b.discOff) - (a.y + a.discOff);
+        var dist = Math.hypot(dx, dy) || 1e-6, min = a.r + b.r;
+        if (dist >= min) continue;
+        var nx = dx / dist, ny = dy / dist;
+        var ima = 1 / a.m, imb = 1 / b.m;
+        var corr = (min - dist) / (ima + imb);
+        a.x -= nx * corr * ima; a.y -= ny * corr * ima;
+        b.x += nx * corr * imb; b.y += ny * corr * imb;
+        var vn = (b.vx - a.vx) * nx + (b.vy - a.vy) * ny;
+        if (vn < 0) {
+          var imp = -(1 + SKY_GRAV.REST) * vn / (ima + imb);
+          a.vx -= nx * imp * ima; a.vy -= ny * imp * ima;
+          b.vx += nx * imp * imb; b.vy += ny * imp * imb;
+        }
+      }
+    }
+  }
+  function skyThermostat() {
+    var lo = keTarget * SKY_GRAV.THERMO_LO, hi = keTarget * SKY_GRAV.THERMO_HI, ke = skyKE();
+    if (ke < 1e-6) return;
+    var target = ke < lo ? lo : (ke > hi ? hi : 0);
+    if (!target) return;   /* inside the band: pure physics */
+    var f = Math.sqrt(target / ke);
+    f = Math.max(1 - SKY_GRAV.THERMO_MAX, Math.min(1 + SKY_GRAV.THERMO_MAX, f));
+    for (var i = 0; i < skyBodies.length; i++) { skyBodies[i].vx *= f; skyBodies[i].vy *= f; }
+  }
+  function clampSkyVelocities() {
+    for (var i = 0; i < skyBodies.length; i++) {
+      var b = skyBodies[i], v = Math.hypot(b.vx, b.vy);
+      if (v > SKY_GRAV.MAXV) { var s = SKY_GRAV.MAXV / v; b.vx *= s; b.vy *= s; }
+    }
+  }
+  function physStep(dt) {
+    var i, it, c = skyBarycenter();
+    for (i = 0; i < skyBodies.length; i++) { it = skyBodies[i]; it.px = it.x; it.py = it.y; }
+    computeSkyForces(c);   /* leapfrog kick-drift-kick — the order is load-bearing */
+    for (i = 0; i < skyBodies.length; i++) { it = skyBodies[i]; it.vx += 0.5 * it.fx * dt; it.vy += 0.5 * it.fy * dt; }
+    for (i = 0; i < skyBodies.length; i++) { it = skyBodies[i]; it.x += it.vx * dt; it.y += it.vy * dt; }
+    computeSkyForces(c);
+    for (i = 0; i < skyBodies.length; i++) { it = skyBodies[i]; it.vx += 0.5 * it.fx * dt; it.vy += 0.5 * it.fy * dt; }
+    resolveSkyCollisions();
+    skyThermostat();
+    killSkyDrift();
+    clampSkyVelocities();
+  }
+
+  /* bodies re-adopt the DOM after every render: an orb that persisted keeps
+     its position AND momentum across filter keystrokes (visual position is
+     x/y itself — the anchor is only the subtraction base for the transform) */
+  var skyNeedsRebuild = false;
+  function rebuildSkyBodies() {
+    var layer = $('skyCam'), fieldEl = $('orbField');
+    if (!layer) { skyBodies = []; return; }
+    /* display:none zeroes offsetLeft/Top AND clientWidth: anchoring to zeros
+       paints every orb at slot + physics position on return, degrades the
+       elliptical well to circular, and breaks the camera clamp (review
+       CRITICAL — reachable from the Table view's own sort/search controls).
+       Defer instead: the fresh orb nodes sit at their CSS slots — the static
+       mock — until the sky is back on stage and the anchors are real. */
+    if (!fieldEl || !fieldEl.clientWidth) { skyNeedsRebuild = true; return; }
+    skyNeedsRebuild = false;
+    var prev = {};
+    skyBodies.forEach(function (b) { prev[b.key] = b; });
+    var next = [];
+    layer.querySelectorAll('.worldOrb').forEach(function (el) {
+      if (el.hidden) return;
+      var d = parseFloat(getComputedStyle(el).getPropertyValue('--d')) || 60;
+      var r = d / 2;
+      /* identity must survive re-sorts: an origin-less orb keys on its NAME,
+         never its list index (an index key hands its momentum to whichever
+         orb lands on that index after the next sort) */
+      var nmEl = el.querySelector('.nm');
+      var key = el.id === 'selfOrb' ? 'self'
+        : (el.getAttribute('data-origin') || 'nm:' + (nmEl ? nmEl.textContent : String(next.length)));
+      var ax = el.offsetLeft, ay = el.offsetTop;
+      /* the body's anchor is the label-stack CENTER, but the disc — the thing
+         that must not interpenetrate — sits above it; collisions measure from
+         the disc's own center */
+      var disc = el.querySelector('.disc');
+      var discOff = disc ? (disc.offsetTop + r) - el.offsetHeight / 2 : 0;
+      /* reduced motion IS the mock: no carry-over, every orb sits exactly on
+         its slot (C9) — carrying frozen positions across a re-sort would
+         leave zero-motion orbs parked off their own anchors forever */
+      var old = REDUCED ? null : prev[key];
+      next.push({
+        key: key, el: el, r: r, ax: ax, ay: ay, discOff: discOff,
+        m: Math.pow(r / SKY_GRAV.R_REF, 3),
+        x: old ? old.x : ax, y: old ? old.y : ay,
+        px: old ? old.x : ax, py: old ? old.y : ay,
+        vx: old ? old.vx : 0, vy: old ? old.vy : 0,
+        fx: 0, fy: 0, seeded: !!old
+      });
+    });
+    skyBodies = next;
+    /* new arrivals join the field swirl at their own position */
+    var c = skyBarycenter();
+    var jit = SKY_GRAV.SWIRL * 60 * SKY_GRAV.SWIRL_JITTER;
+    skyBodies.forEach(function (b) {
+      if (b.seeded) return;
+      var dx = b.x - c.x, dy = b.y - c.y;
+      b.vx = -dy * SKY_GRAV.SWIRL + (Math.random() - 0.5) * 2 * jit;
+      b.vy = dx * SKY_GRAV.SWIRL + (Math.random() - 0.5) * 2 * jit;
+    });
+    killSkyDrift();
+    keTarget = skyKE();
+    /* the well hugs the roster: sized from the real spread in ASPECT-SCALED
+       space (the gate's 520px assumed its own scatter; ours is the slot
+       layout in THIS viewport, which is wide and short) */
+    var fieldEl = $('orbField');
+    containAspect = fieldEl
+      ? Math.min(3, Math.max(1, fieldEl.clientWidth / Math.max(1, fieldEl.clientHeight)))
+      : 1;
+    var maxD = 0;
+    skyBodies.forEach(function (b) {
+      maxD = Math.max(maxD, Math.hypot(b.x - c.x, (b.y - c.y) * containAspect));
+    });
+    containR = Math.max(380, maxD * 1.15);
+    /* the camera may still be aimed at a cluster that no longer exists */
+    clampSkyCam();
+    applySkyCam();
+    renderSky(1);
+  }
+
+  function renderSky(alpha) {
+    var dpr = window.devicePixelRatio || 1;
+    for (var k = 0; k < skyBodies.length; k++) {
+      var b = skyBodies[k];
+      var ix = b.px + (b.x - b.px) * alpha, iy = b.py + (b.y - b.py) * alpha;
+      /* snap the offset to the device-pixel grid: motion stays smooth but
+         glyphs rasterize identically each frame, so labels never shimmer */
+      var tx = Math.round((ix - b.ax) * dpr) / dpr, ty = Math.round((iy - b.ay) * dpr) / dpr;
+      b.el.style.transform = 'translate(-50%,-50%) translate(' + tx.toFixed(2) + 'px,' + ty.toFixed(2) + 'px)';
+    }
+    followHover();
+  }
+
+  /* the loop: fixed 120Hz physics under an accumulator, interpolated render.
+     The 250ms frame clamp + 8-substep guard + drop-on-overrun keep a slow
+     machine in slow motion rather than a spiral. */
+  var SKY_DT = 1000 / SKY_GRAV.PHYS_HZ, skyAcc = 0, skyLast = 0, skyRaf = 0;
+  function skyActive() {
+    return !REDUCED && !document.hidden && currentView === 'map' &&
+      !$('sub-sky-body').hidden && skyBodies.length > 1;
+  }
+  function skyTick(now) {
+    skyRaf = 0;
+    if (!skyActive()) return;
+    var ft = now - skyLast; skyLast = now; if (ft > 250) ft = 250;
+    skyAcc += ft;
+    var guard = 0;
+    while (skyAcc >= SKY_DT && guard < 8) { physStep(SKY_DT / 1000); skyAcc -= SKY_DT; guard++; }
+    if (guard >= 8) skyAcc = 0;
+    renderSky(Math.max(0, Math.min(1, skyAcc / SKY_DT)));
+    skyRaf = requestAnimationFrame(skyTick);
+  }
+  function startSky() {
+    if (skyRaf || !skyActive()) return;
+    skyLast = performance.now(); skyAcc = 0;
+    skyRaf = requestAnimationFrame(skyTick);
+  }
+  function stopSky() { if (skyRaf) { cancelAnimationFrame(skyRaf); skyRaf = 0; } }
+  document.addEventListener('visibilitychange', function () { if (!document.hidden) startSky(); });
+  window.addEventListener('resize', function () {
+    clearTimeout(skyResizeT);
+    skyResizeT = setTimeout(function () {
+      /* percent anchors moved with the field — re-seed rather than let stale
+         pixel anchors shear the cluster */
+      skyBodies = [];
+      rebuildSkyBodies();
+      startSky();
+    }, 200);
+  });
+  var skyResizeT = 0;
+
+  /* ── the camera: the gate's exact pan/zoom algebra on one layer ── */
+  function applySkyCam() {
+    var el = $('skyCam');
+    if (el) el.style.transform = 'translate(' + skyView.x.toFixed(2) + 'px,' + skyView.y.toFixed(2) + 'px) scale(' + skyView.z.toFixed(4) + ')';
+  }
+  function clampSkyCam() {
+    var wrap = $('sub-sky-body');
+    if (!wrap || !skyBodies.length) return;
+    var W = wrap.clientWidth, H = wrap.clientHeight, m = 160;
+    var minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    skyBodies.forEach(function (b) {
+      if (b.x < minX) minX = b.x; if (b.x > maxX) maxX = b.x;
+      if (b.y < minY) minY = b.y; if (b.y > maxY) maxY = b.y;
+    });
+    var sxMin = skyView.x + minX * skyView.z, sxMax = skyView.x + maxX * skyView.z;
+    var syMin = skyView.y + minY * skyView.z, syMax = skyView.y + maxY * skyView.z;
+    if (sxMax < m) skyView.x += m - sxMax; else if (sxMin > W - m) skyView.x -= sxMin - (W - m);
+    if (syMax < m) skyView.y += m - syMax; else if (syMin > H - m) skyView.y -= syMin - (H - m);
+  }
+  (function skyPanZoom() {
+    var wrap = $('sub-sky-body');
+    if (!wrap) return;
+    var down = false, moved = false, middle = false, sx = 0, sy = 0, startX = 0, startY = 0;
+    var panId = null;   /* the ONE pointer that owns the drag — a second finger
+                           (pinch, a stray touch) must never hijack the camera */
+    wrap.addEventListener('mousedown', function (e) { if (e.button === 1) e.preventDefault(); });
+    wrap.addEventListener('pointerdown', function (e) {
+      if (down) return;
+      if (e.button !== 0 && e.button !== 1) return;
+      /* middle-press on an orb belongs to the browser (open in a new tab);
+         middle on empty sky is pan-anywhere, like the gate */
+      middle = e.button === 1 && !(e.target.closest && e.target.closest('.worldOrb'));
+      if (e.button === 1 && !middle) return;
+      down = true; moved = false; skyPanned = false; panId = e.pointerId;
+      sx = e.clientX; sy = e.clientY; startX = skyView.x; startY = skyView.y;
+      if (middle) { moved = true; skyPanned = true; wrap.classList.add('panning'); hideHover(); e.preventDefault(); }
+    });
+    window.addEventListener('pointermove', function (e) {
+      skyPtr.x = e.clientX; skyPtr.y = e.clientY;
+      if (!down || (panId !== null && e.pointerId !== panId)) return;
+      if (!moved && Math.hypot(e.clientX - sx, e.clientY - sy) < SKY_DEADZONE) return;
+      if (!moved) { moved = true; skyPanned = true; wrap.classList.add('panning'); hideHover(); }
+      skyView.x = startX + (e.clientX - sx);
+      skyView.y = startY + (e.clientY - sy);
+      clampSkyCam(); applySkyCam();
+    });
+    function endPan(e) {
+      if (!down || (panId !== null && e && e.pointerId !== undefined && e.pointerId !== panId)) return;
+      down = false; middle = false; panId = null; wrap.classList.remove('panning');
+      /* the click this pan suppresses fires synchronously after pointerup —
+         clear the flag a tick later, so a keyboard Enter is never eaten */
+      setTimeout(function () { skyPanned = false; }, 0);
+    }
+    window.addEventListener('pointerup', endPan);
+    window.addEventListener('pointercancel', endPan);
+    wrap.addEventListener('wheel', function (e) {
+      var d = e.deltaY;
+      /* line-mode wheels (Firefox) report ~3 lines, not ~100 px */
+      if (e.deltaMode === 1) d *= 16; else if (e.deltaMode === 2) d *= 300;
+      var factor = Math.exp(-d * 0.0016);
+      var z = Math.max(SKY_ZMIN, Math.min(SKY_ZMAX, skyView.z * factor));
+      /* at the clamp the wheel would do nothing — hand it back to the page
+         instead of trapping scroll over the sky */
+      if (z === skyView.z) return;
+      e.preventDefault();
+      var rect = wrap.getBoundingClientRect();
+      var cx = e.clientX - rect.left, cy = e.clientY - rect.top;
+      /* un-project the cursor at the old zoom, re-pin it at the new — the
+         world point under the wheel never moves */
+      var vx = (cx - skyView.x) / skyView.z, vy = (cy - skyView.y) / skyView.z;
+      skyView.z = z;
+      skyView.x = cx - vx * z;
+      skyView.y = cy - vy * z;
+      clampSkyCam(); applySkyCam(); hideHover();
+    }, { passive: false });
+  })();
+
+  /* ── the hover card: a glance under the cursor, never a second chip ── */
+  var hoverOrb = null, hoverFrames = 0;
+  function showHover(a) {
+    if (a === hoverOrb) return;
+    hoverOrb = a;
+    var card = $('hoverCard');
+    if (!card) return;
+    card.textContent = '';
+    var nm = document.createElement('span');
+    nm.className = 'hn';
+    var n = a.querySelector('.nm');
+    nm.textContent = n ? n.textContent : '';
+    card.appendChild(nm);
+    var tag = a.title || (a.querySelector('.sub') ? a.querySelector('.sub').textContent : '');
+    if (tag && tag !== nm.textContent) {
+      var ht = document.createElement('span');
+      ht.className = 'ht';
+      ht.textContent = tag;
+      card.appendChild(ht);
+    }
+    card.hidden = false;
+    placeHover();
+  }
+  function hideHover() {
+    hoverOrb = null;
+    var c = $('hoverCard');
+    if (c) c.hidden = true;
+  }
+  function placeHover() {
+    if (!hoverOrb) return;
+    var card = $('hoverCard'), field = $('orbField');
+    var fr = field.getBoundingClientRect(), or = hoverOrb.getBoundingClientRect();
+    var x = or.left + or.width / 2 - fr.left, y = or.top - fr.top;
+    card.style.left = Math.max(8, Math.min(fr.width - card.offsetWidth - 8, x - card.offsetWidth / 2)) + 'px';
+    var top = y - card.offsetHeight - 10;
+    card.style.top = (top < 8 ? y + or.height + 10 : top) + 'px';
+  }
+  function followHover() {
+    if (!hoverOrb) return;
+    placeHover();
+    /* the sim can slide an orb out from under a stationary cursor and the
+       browser never fires the leave — re-check what is under the pointer
+       every few frames (a gate lesson, not optional polish) */
+    if (++hoverFrames % 4 === 0) {
+      var under = document.elementFromPoint(skyPtr.x, skyPtr.y);
+      var overOrb = under && under.closest ? under.closest('.worldOrb') : null;
+      if (overOrb !== hoverOrb) hideHover();
+    }
+  }
+  $('orbField').addEventListener('pointerover', function (ev) {
+    /* keep the pointer sample fresh from here too: a hover can arrive before
+       any move (a touch tap, a page-load hover) and the frame check would
+       otherwise measure a stale point and hide the card it just showed */
+    skyPtr.x = ev.clientX; skyPtr.y = ev.clientY;
+    var a = ev.target.closest && ev.target.closest('.worldOrb');
+    if (a && !$('sub-sky-body').classList.contains('panning')) showHover(a);
+  });
+  $('orbField').addEventListener('pointerout', function (ev) {
+    if (!hoverOrb) return;
+    var to = ev.relatedTarget;
+    if (!to || !(to.closest && to.closest('.worldOrb') === hoverOrb)) hideHover();
+  });
+
+  /* a tapped Shift lights the search — the gate's spotlight key, kept: a tap
+     with no other key while held focuses the query box in map view */
+  (function shiftSpot() {
+    var solo = false;
+    document.addEventListener('keydown', function (e) {
+      if (e.key === 'Shift') { solo = !e.repeat; return; }
+      solo = false;
+    });
+    /* Shift used as a MOUSE modifier is not a tap: a shift-click or
+       shift-drag between the keydown and keyup must not light the search */
+    document.addEventListener('pointerdown', function () { solo = false; });
+    document.addEventListener('wheel', function () { solo = false; }, { passive: true });
+    document.addEventListener('keyup', function (e) {
+      if (e.key !== 'Shift' || !solo) return;
+      solo = false;
+      /* never steal focus out of the open project card (it is aria-modal) */
+      if (currentView !== 'map' || !$('cardScrim').hidden) return;
+      var t = document.activeElement;
+      if (t && /^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName)) return;
+      var q = $('mapQ');
+      if (q) q.focus();
+    });
+  })();
+
   function setSub(which) {
     $('sub-sky').setAttribute('aria-pressed', String(which === 'sky'));
     $('sub-table').setAttribute('aria-pressed', String(which === 'table'));
     $('sub-sky-body').hidden = which !== 'sky';
     $('sub-table-body').hidden = which !== 'table';
+    /* the sim runs only while the sky is on stage (C8); anchors that were
+       unreadable while hidden are re-adopted before the first frame */
+    if (which === 'sky') {
+      if (skyNeedsRebuild) rebuildSkyBodies();
+      startSky();
+    } else { stopSky(); hideHover(); }
   }
   $('sub-sky').addEventListener('click', function () { setSub('sky'); });
   $('sub-table').addEventListener('click', function () { setSub('table'); });

package/src/module-api.js

@@ -653,8 +653,10 @@ 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)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.113'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.114'; // 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/tests/projects_hub.mjs

@@ -702,3 +702,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');
+});