chore: decline release-notes prompts for this repo

fix: prod-bundle boot, cloud-existence leak, observation gating (final review)
- Wrap main.js body in async main() to eliminate top-level await deadlock in Rollup - Add npc.lastPlan so clouds persist after hidden arrival/destruction until analytic envelope expires - Add maxEnvelopeArrival() helper; rewrite playerClouds() to use lastPlan for envelope-gated clouds - Block markSeen() while player is mid-lane (no observation from hyperspace) - Pass obsSys=null to playerClouds when player is in a lane (don't exclude visible band from hyperspace) - Galaxy map clicks now select-only (intel); jumps via Nav buttons / gate diamonds only - Add preview script, favicon no-op, .playwright-mcp/ and *.png to .gitignore, update README controls text
2026-06-12 15:42:23 +00:00 · 2026-06-12 15:35:20 +00:00 · 2026-06-12 15:18:48 +00:00 · 2026-06-12 15:16:59 +00:00 · 2026-06-12 15:13:58 +00:00 · 2026-06-12 14:56:06 +00:00
16 changed files with 850 additions and 2 deletions
@@ -1,2 +1,4 @@
 node_modules/
 dist/
+.playwright-mcp/
+*.png
@@ -0,0 +1,3 @@
+<!-- release-notes-config
+declined: true
+-->
@@ -0,0 +1,30 @@
+# Probability
+
+A neon space-trading sim where unobserved ships are probability waves.
+
+Inspired by Space Rangers. Every NPC trader plans real routes and real trades,
+but between observations its position is a probability cloud smeared along the
+jump lanes — and so is your knowledge of every market more than a news-day away.
+Observation collapses the cloud: enter a system and ships condense out of the
+static; dock at a planet and its prices become real.
+
+Under the hood the universe is deterministic ("hidden variables" drawn lazily
+from per-ship seeds) — the probability is *yours*, not the universe's.
+
+## Run
+
+    npm install
+    npm run dev        # play at http://localhost:5173 (add ?seed=anything for a new galaxy)
+    npm test           # headless sim test suite
+
+## How to play
+
+- You start docked. Buy what a planet produces cheap, sell where it's consumed.
+- Sidebar: navigation, market (when docked), cargo, intel, log. Space = pause,
+  Tab = map/system view. Move by clicking planets and gate diamonds in the
+  system view, or use the Navigation buttons. Click systems on the galaxy map
+  for price intel — note the age tag, old news lies.
+- Lanes are tinted by pirate danger. Dangerous shortcuts are profitable until
+  they aren't.
+- Orange smears on the map are ships you've met: where they probably are now.
+- Reach 100,000 credits to win. Lose your ship and it's over.
@@ -4,6 +4,7 @@
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>Probability</title>
+  <link rel="icon" href="data:," />
  <link rel="stylesheet" href="/src/styles.css" />
 </head>
 <body>
@@ -6,6 +6,7 @@
  "scripts": {
    "dev": "vite",
    "build": "vite build",
+    "preview": "vite preview",
    "test": "vitest run"
  },
  "dependencies": {
@@ -1 +1,77 @@
-console.log('Probability — boot ok');
+import { createWorld, advance } from './sim/world.js';
+import { createRenderer } from './render/app.js';
+import { GalaxyView } from './render/galaxyView.js';
+import { SystemView } from './render/systemView.js';
+import { Panel } from './ui/panel.js';
+import { goTo, playerSystem } from './sim/player.js';
+
+async function main() {
+  const world = createWorld(new URLSearchParams(location.search).get('seed') ?? 'neon-1');
+  const renderer = await createRenderer(document.getElementById('stage'));
+
+  let view = 'system';
+  let speed = 1;
+  const controls = {
+    getSpeed: () => speed,
+    setSpeed: (v) => { speed = v; },
+    getView: () => view,
+    setView: (name) => setView(name),
+  };
+
+  const panel = new Panel(document.getElementById('panel'), world, controls);
+  const handlers = {
+    onSelectSystem: (id) => { panel.selectSystem(id); panel.update(); },
+    onJump: (laneId) => goTo(world, { laneId }),
+    onGotoPlanet: (planetId) => goTo(world, { planetId }),
+  };
+  const galaxyView = new GalaxyView(renderer, world, handlers);
+  const systemView = new SystemView(renderer, world, handlers);
+
+  // Rebuild static geometry when the canvas resizes (review: cached transforms went stale).
+  renderer.app.renderer.on('resize', () => {
+    galaxyView.buildStatic();
+    systemView.builtFor = null;
+  });
+
+  function setView(name) {
+    view = name;
+    galaxyView.setVisible(name === 'galaxy');
+    systemView.setVisible(name === 'system');
+  }
+  setView('system');
+  window.addEventListener('keydown', (e) => {
+    if (e.target !== document.body) return; // don't hijack keys from panel buttons (review)
+    if (e.key === 'Tab') {
+      e.preventDefault();
+      setView(view === 'galaxy' ? 'system' : 'galaxy');
+    }
+    if (e.key === ' ') {
+      e.preventDefault();
+      speed = speed === 0 ? 1 : 0;
+    }
+  });
+
+  const DAYS_PER_SEC = 0.25;
+  let banner = null;
+  let uiClock = 0;
+  renderer.app.ticker.add(() => {
+    const dt = renderer.app.ticker.deltaMS / 1000;
+    if (speed > 0 && world.player.alive && !world.player.won) {
+      advance(world, world.t + dt * DAYS_PER_SEC * speed);
+    }
+    // Switch to system view automatically when arriving somewhere new.
+    if (view === 'galaxy') galaxyView.update();
+    else if (playerSystem(world) != null) systemView.update();
+
+    uiClock += dt;
+    if (uiClock > 0.25) { uiClock = 0; panel.update(); } // 4 Hz DOM refresh
+
+    if (!banner && (world.player.won || !world.player.alive)) {
+      banner = document.createElement('div');
+      banner.className = 'banner';
+      banner.textContent = world.player.won ? 'VICTORY' : 'SHIP LOST';
+      document.getElementById('stage').appendChild(banner);
+    }
+  });
+}
+main();
@@ -0,0 +1,33 @@
+import { Application, Container } from 'pixi.js';
+import { AdvancedBloomFilter } from 'pixi-filters/advanced-bloom';
+
+export async function createRenderer(stageEl) {
+  const app = new Application();
+  await app.init({ resizeTo: stageEl, background: '#05070d', antialias: true });
+  stageEl.appendChild(app.canvas);
+
+  // Bloomed world geometry; crisp labels above it, outside the filter.
+  const world = new Container();
+  world.filters = [new AdvancedBloomFilter({ threshold: 0.18, bloomScale: 1.4, blur: 6, quality: 4 })];
+  const labels = new Container();
+  app.stage.addChild(world, labels);
+
+  return { app, world, labels };
+}
+
+// Map sim hazard [0, 0.7] to a cyan->red neon tint.
+export function hazardColor(h) {
+  const t = Math.min(1, h / 0.7);
+  const r = Math.round(0 + t * 255);
+  const g = Math.round(229 - t * 170);
+  const b = Math.round(255 - t * 175);
+  return (r << 16) | (g << 8) | b;
+}
+
+// Fit sim coords (1000x700 layout space) into the canvas with padding.
+export function makeViewTransform(app) {
+  const w = app.renderer.width, h = app.renderer.height;
+  const scale = Math.min(w / 1060, h / 740);
+  const ox = (w - 1000 * scale) / 2, oy = (h - 700 * scale) / 2;
+  return { x: (sx) => ox + sx * scale, y: (sy) => oy + sy * scale, scale };
+}
@@ -0,0 +1,123 @@
+import { Container, Graphics, Text } from 'pixi.js';
+import { hazardColor, makeViewTransform } from './app.js';
+import { playerClouds } from '../sim/clouds.js';
+import { playerSystem } from '../sim/player.js';
+import { otherEnd } from '../sim/galaxy.js';
+
+export class GalaxyView {
+  // onSelectSystem(systemId) -> UI intel panel
+  constructor(renderer, world, { onSelectSystem, onJump }) {
+    this.renderer = renderer;
+    this.world = world;
+    this.onSelectSystem = onSelectSystem;
+    this.onJump = onJump;
+    this.container = new Container();
+    this.labelContainer = new Container();
+    renderer.world.addChild(this.container);
+    renderer.labels.addChild(this.labelContainer);
+
+    this.staticG = new Graphics();
+    this.cloudG = new Graphics();
+    this.dynamicG = new Graphics();
+    this.container.addChild(this.staticG, this.cloudG, this.dynamicG);
+    this.hitNodes = new Container();
+    this.container.addChild(this.hitNodes);
+    this.buildStatic();
+  }
+
+  buildStatic() {
+    const { galaxy } = this.world;
+    const v = makeViewTransform(this.renderer.app);
+    this.v = v;
+    const g = this.staticG;
+    g.clear();
+    for (const lane of galaxy.lanes) {
+      const a = galaxy.systems[lane.a], b = galaxy.systems[lane.b];
+      g.moveTo(v.x(a.x), v.y(a.y)).lineTo(v.x(b.x), v.y(b.y))
+        .stroke({ width: 2, color: hazardColor(lane.hazard), alpha: 0.55 });
+    }
+    for (const s of galaxy.systems) {
+      g.circle(v.x(s.x), v.y(s.y), 7).fill({ color: 0xcfeeff });
+    }
+    this.labelContainer.removeChildren();
+    this.hitNodes.removeChildren();
+    for (const s of galaxy.systems) {
+      const label = new Text({ text: s.name, style: { fill: '#7fa8c9', fontSize: 11, fontFamily: 'system-ui' } });
+      label.position.set(v.x(s.x) + 10, v.y(s.y) - 6);
+      this.labelContainer.addChild(label);
+
+      const hit = new Graphics().circle(0, 0, 16).fill({ color: 0xffffff, alpha: 0.001 });
+      hit.position.set(v.x(s.x), v.y(s.y));
+      hit.eventMode = 'static';
+      hit.cursor = 'pointer';
+      hit.on('pointertap', () => this.handleSystemTap(s.id));
+      this.hitNodes.addChild(hit);
+    }
+  }
+
+  handleSystemTap(systemId) {
+    this.onSelectSystem(systemId);
+  }
+
+  lanePoint(lane, fromSys, f) {
+    const { galaxy } = this.world;
+    const a = galaxy.systems[fromSys];
+    const b = galaxy.systems[otherEnd(lane, fromSys)];
+    return { x: this.v.x(a.x + (b.x - a.x) * f), y: this.v.y(a.y + (b.y - a.y) * f) };
+  }
+
+  update() {
+    const sim = this.world;
+    const v = this.v;
+    const cur = playerSystem(sim);
+    // Mid-lane the player observes nothing; don't exclude any visible band.
+    const obsSys = sim.player.loc.kind === 'lane' ? null : cur;
+
+    // Probability clouds: glowing strokes along lane segments, alpha ~ weight.
+    const cg = this.cloudG;
+    cg.clear();
+    for (const cloud of playerClouds(sim, obsSys)) {
+      for (const seg of cloud.segs) {
+        const lane = sim.galaxy.lanes[seg.laneId];
+        const p0 = this.lanePoint(lane, seg.fromSys, seg.f0);
+        const p1 = this.lanePoint(lane, seg.fromSys, seg.f1);
+        const alpha = Math.min(0.85, 0.18 + seg.w * 0.9);
+        cg.moveTo(p0.x, p0.y).lineTo(p1.x, p1.y)
+          .stroke({ width: 7, color: 0xffa94d, alpha });
+      }
+    }
+
+    // Player marker: bright cyan triangle at current position.
+    const dg = this.dynamicG;
+    dg.clear();
+    const pos = this.playerXY();
+    if (pos) {
+      dg.poly([pos.x, pos.y - 8, pos.x + 6, pos.y + 6, pos.x - 6, pos.y + 6]).fill({ color: 0x4dffd2 });
+    }
+    // Halo on the player's current system.
+    if (cur != null) {
+      const s = sim.galaxy.systems[cur];
+      dg.circle(v.x(s.x), v.y(s.y), 12).stroke({ width: 2, color: 0x4dffd2, alpha: 0.8 });
+    }
+  }
+
+  playerXY() {
+    const sim = this.world;
+    const loc = sim.player.loc;
+    const v = this.v;
+    if (loc.kind === 'lane') {
+      const lane = sim.galaxy.lanes[loc.laneId];
+      const f = Math.min(1, (sim.t - loc.departT) / (loc.arriveT - loc.departT));
+      return this.lanePoint(lane, loc.fromSys, f);
+    }
+    const sysId = playerSystem(sim);
+    if (sysId == null) return null;
+    const s = sim.galaxy.systems[sysId];
+    return { x: v.x(s.x), y: v.y(s.y) };
+  }
+
+  setVisible(on) {
+    this.container.visible = on;
+    this.labelContainer.visible = on;
+  }
+}
@@ -0,0 +1,161 @@
+import { Container, Graphics, Text } from 'pixi.js';
+import { shipsIn } from '../sim/npc.js';
+import { playerSystem } from '../sim/player.js';
+import { otherEnd } from '../sim/galaxy.js';
+
+const GATE_RADIUS = 290;
+
+export class SystemView {
+  constructor(renderer, world, { onGotoPlanet, onJump }) {
+    this.renderer = renderer;
+    this.world = world;
+    this.onGotoPlanet = onGotoPlanet;
+    this.onJump = onJump;
+    this.container = new Container();
+    this.labelContainer = new Container();
+    renderer.world.addChild(this.container);
+    renderer.labels.addChild(this.labelContainer);
+    this.staticG = new Graphics();
+    this.shipG = new Graphics();
+    this.container.addChild(this.staticG, this.shipG);
+    this.hitNodes = new Container();
+    this.container.addChild(this.hitNodes);
+    this.builtFor = null;
+  }
+
+  center() {
+    return { x: this.renderer.app.renderer.width / 2, y: this.renderer.app.renderer.height / 2 };
+  }
+
+  planetXY(planet) {
+    const c = this.center();
+    return { x: c.x + Math.cos(planet.orbit.a) * planet.orbit.r, y: c.y + Math.sin(planet.orbit.a) * planet.orbit.r };
+  }
+
+  gateXY(lane, systemId) {
+    const { galaxy } = this.world;
+    const here = galaxy.systems[systemId];
+    const there = galaxy.systems[otherEnd(lane, systemId)];
+    const ang = Math.atan2(there.y - here.y, there.x - here.x);
+    const c = this.center();
+    // Keep gates on-screen on small canvases (review: fixed 290 clipped hit targets).
+    const r = Math.max(60, Math.min(GATE_RADIUS, Math.min(c.x, c.y) - 40));
+    return { x: c.x + Math.cos(ang) * r, y: c.y + Math.sin(ang) * r, ang };
+  }
+
+  build(systemId) {
+    this.builtFor = systemId;
+    const { galaxy } = this.world;
+    const sys = galaxy.systems[systemId];
+    const c = this.center();
+    const g = this.staticG;
+    g.clear();
+    this.labelContainer.removeChildren();
+    this.hitNodes.removeChildren();
+
+    g.circle(c.x, c.y, 30).fill({ color: 0xffe9a8 }); // the star, brightest thing on screen
+
+    for (const planetId of sys.planets) {
+      const planet = galaxy.planets[planetId];
+      const p = this.planetXY(planet);
+      g.circle(c.x, c.y, planet.orbit.r).stroke({ width: 1, color: 0x1b3a55, alpha: 0.6 });
+      g.circle(p.x, p.y, 10).fill({ color: 0x7fb4ff });
+      const label = new Text({
+        text: `${planet.name} (${planet.kind})`,
+        style: { fill: '#7fa8c9', fontSize: 11, fontFamily: 'system-ui' },
+      });
+      label.position.set(p.x + 14, p.y - 6);
+      this.labelContainer.addChild(label);
+      const hit = new Graphics().circle(0, 0, 18).fill({ color: 0xffffff, alpha: 0.001 });
+      hit.position.set(p.x, p.y);
+      hit.eventMode = 'static';
+      hit.cursor = 'pointer';
+      hit.on('pointertap', () => this.onGotoPlanet(planetId));
+      this.hitNodes.addChild(hit);
+    }
+
+    for (const laneId of sys.lanes) {
+      const lane = galaxy.lanes[laneId];
+      const gp = this.gateXY(lane, systemId);
+      g.poly([gp.x, gp.y - 8, gp.x + 8, gp.y, gp.x, gp.y + 8, gp.x - 8, gp.y]).fill({ color: 0x9fd8ff });
+      const name = galaxy.systems[otherEnd(lane, systemId)].name;
+      const label = new Text({ text: `→ ${name}`, style: { fill: '#7fa8c9', fontSize: 11, fontFamily: 'system-ui' } });
+      label.position.set(gp.x + 10, gp.y - 6);
+      this.labelContainer.addChild(label);
+      const hit = new Graphics().circle(0, 0, 16).fill({ color: 0xffffff, alpha: 0.001 });
+      hit.position.set(gp.x, gp.y);
+      hit.eventMode = 'static';
+      hit.cursor = 'pointer';
+      hit.on('pointertap', () => this.onJump(laneId));
+      this.hitNodes.addChild(hit);
+    }
+  }
+
+  // A ship triangle pointing along its heading.
+  drawShip(g, x, y, ang, color) {
+    const cos = Math.cos(ang), sin = Math.sin(ang);
+    const pt = (dx, dy) => [x + dx * cos - dy * sin, y + dx * sin + dy * cos];
+    g.poly([...pt(10, 0), ...pt(-7, 6), ...pt(-7, -6)]).fill({ color });
+  }
+
+  update() {
+    const sim = this.world;
+    const sysId = playerSystem(sim);
+    if (sysId == null) return;
+    if (this.builtFor !== sysId) this.build(sysId);
+    const { galaxy } = sim;
+    const c = this.center();
+    const g = this.shipG;
+    g.clear();
+
+    // Concrete NPC ships.
+    for (const entry of shipsIn(sim, sysId)) {
+      if (entry.kind === 'docked') {
+        const p = this.planetXY(galaxy.planets[entry.planetId]);
+        this.drawShip(g, p.x + 18, p.y - 14, -Math.PI / 2, 0xffa94d);
+      } else if (entry.kind === 'arriving' || entry.kind === 'departing') {
+        const lane = galaxy.lanes[entry.laneId];
+        const gp = this.gateXY(lane, sysId);
+        const dest = entry.npc.plan ? galaxy.planets[entry.npc.plan.destPlanet] : null;
+        const target = dest && dest.systemId === sysId ? this.planetXY(dest) : c;
+        const f = entry.kind === 'arriving' ? entry.progress : 1 - entry.progress;
+        const x = gp.x + (target.x - gp.x) * f * 0.5;
+        const y = gp.y + (target.y - gp.y) * f * 0.5;
+        const ang = entry.kind === 'arriving'
+          ? Math.atan2(target.y - gp.y, target.x - gp.x)
+          : Math.atan2(gp.y - target.y, gp.x - target.x);
+        this.drawShip(g, x, y, ang, 0xffa94d);
+      } else if (entry.kind === 'local-hop') {
+        const from = this.planetXY(galaxy.planets[entry.npc.plan.originPlanet]);
+        const to = this.planetXY(galaxy.planets[entry.npc.plan.destPlanet]);
+        const x = from.x + (to.x - from.x) * entry.progress;
+        const y = from.y + (to.y - from.y) * entry.progress;
+        this.drawShip(g, x, y, Math.atan2(to.y - from.y, to.x - from.x), 0xffa94d);
+      }
+    }
+
+    // The player.
+    const loc = sim.player.loc;
+    if (loc.kind === 'docked') {
+      const p = this.planetXY(galaxy.planets[loc.planetId]);
+      this.drawShip(g, p.x - 18, p.y - 14, -Math.PI / 2, 0x4dffd2);
+    } else if (loc.kind === 'at-gate') {
+      const gp = this.gateXY(galaxy.lanes[loc.laneId], sysId);
+      this.drawShip(g, gp.x, gp.y - 16, -Math.PI / 2, 0x4dffd2);
+    } else if (loc.kind === 'insys-leg') {
+      const resolve = (d) => d.type === 'planet'
+        ? this.planetXY(galaxy.planets[d.id])
+        : this.gateXY(galaxy.lanes[d.laneId], sysId);
+      const from = resolve(loc.from), to = resolve(loc.to);
+      const f = Math.min(1, (sim.t - loc.departT) / (loc.arriveT - loc.departT));
+      const x = from.x + (to.x - from.x) * f;
+      const y = from.y + (to.y - from.y) * f;
+      this.drawShip(g, x, y, Math.atan2(to.y - from.y, to.x - from.x), 0x4dffd2);
+    }
+  }
+
+  setVisible(on) {
+    this.container.visible = on;
+    this.labelContainer.visible = on;
+  }
+}
@@ -0,0 +1,115 @@
+import { VIS_BAND } from './constants.js';
+import { JIT_MIN, JIT_SPAN, DELAY_MULT, hazardProbs } from './npc.js';
+import { otherEnd } from './galaxy.js';
+
+export function totalMass(segs) {
+  return segs.reduce((sum, s) => sum + s.w, 0);
+}
+
+// The cloud is computed from the ANALYTIC envelope of the plan — possible
+// durations per leg — never from the hidden seed rolls. For each leg we
+// compute the feasible progress interval [f0, f1] at time t:
+//   f1: progress if everything so far ran fastest (earliest entry, fastest leg)
+//   f0: progress if everything ran slowest (latest entry, slowest leg)
+// Weight ~ feasible track-days on that leg x survival probability, normalized.
+export function cloudFor(galaxy, plan, t) {
+  if (!plan) return [];
+  // Walk the PLANNED route, not the resolved legs: a destroyed itinerary has
+  // truncated legs, and using them would leak the hidden outcome via the
+  // cloud's shape. Synthetic plans without routeLanes fall back to legs.
+  const laneIds = plan.routeLanes ?? plan.legs.map((l) => l.laneId);
+  if (laneIds.length === 0) return [];
+  const e = t - plan.startTime;
+  if (e <= 0) return [];
+
+  let sys = plan.startSys ?? (plan.legs.length > 0 ? plan.legs[0].fromSys : null);
+  if (sys == null) return [];
+  let minStart = 0, maxStart = 0, survival = 1;
+  const raw = [];
+  for (const laneId of laneIds) {
+    const lane = galaxy.lanes[laneId];
+    const toSys = otherEnd(lane, sys);
+    const minD = lane.days * JIT_MIN;
+    const maxD = lane.days * (JIT_MIN + JIT_SPAN) * DELAY_MULT;
+    // fastest possible progress: entered at minStart, moving at max speed
+    const f1 = (e - minStart) / minD;
+    // slowest possible progress: entered at maxStart, moving at min speed
+    const f0 = (e - maxStart) / maxD;
+    const cf0 = Math.min(1, Math.max(0, f0));
+    const cf1 = Math.min(1, Math.max(0, f1));
+    if (cf1 > cf0) {
+      raw.push({ laneId, fromSys: sys, toSys, f0: cf0, f1: cf1, w: (cf1 - cf0) * lane.days * survival });
+    }
+    const p = hazardProbs(lane.hazard);
+    survival *= 1 - p.destroyed;
+    minStart += minD;
+    maxStart += maxD;
+    sys = toSys;
+  }
+  return normalize(raw);
+}
+
+// Player observes the VIS_BAND ends of every lane touching their system.
+// A ship not concretely visible there cannot be there: cut those intervals
+// out of the cloud and renormalize the rest.
+export function excludeVisibleBand(galaxy, segs, observedSystemId) {
+  const out = [];
+  for (const seg of segs) {
+    const lane = galaxy.lanes[seg.laneId];
+    if (lane.a !== observedSystemId && lane.b !== observedSystemId) {
+      out.push({ ...seg });
+      continue;
+    }
+    // Band near the observed system, in this segment's fromSys->toSys orientation.
+    const nearFrom = seg.fromSys === observedSystemId;
+    const bandLo = nearFrom ? 0 : 1 - VIS_BAND;
+    const bandHi = nearFrom ? VIS_BAND : 1;
+    const den = seg.f1 - seg.f0;
+    if (den <= 0) continue; // degenerate segment: drop rather than NaN-poison
+    // keep the part below the band
+    if (seg.f0 < bandLo) {
+      const f1 = Math.min(seg.f1, bandLo);
+      out.push({ ...seg, f1, w: seg.w * ((f1 - seg.f0) / den) });
+    }
+    // keep the part above the band
+    if (seg.f1 > bandHi) {
+      const f0 = Math.max(seg.f0, bandHi);
+      out.push({ ...seg, f0, w: seg.w * ((seg.f1 - f0) / den) });
+    }
+  }
+  return normalize(out);
+}
+
+function normalize(segs) {
+  const m = totalMass(segs);
+  if (m <= 0) return [];
+  return segs.map((s) => ({ ...s, w: s.w / m }));
+}
+
+// Latest possible arrival under the analytic envelope (slowest legal journey).
+export function maxEnvelopeArrival(galaxy, plan) {
+  const laneIds = plan.routeLanes ?? plan.legs.map((l) => l.laneId);
+  let t = plan.startTime;
+  for (const laneId of laneIds) t += galaxy.lanes[laneId].days * (JIT_MIN + JIT_SPAN) * DELAY_MULT;
+  return t;
+}
+
+// All player-visible clouds: seen NPCs whose cloud envelope hasn't yet expired.
+export function playerClouds(world, observedSystemId) {
+  const out = [];
+  for (const npcId of world.player.seenNpcs) {
+    const npc = world.npcs[npcId];
+    // Active journey, or a finished/doomed one whose envelope hasn't expired:
+    // cloud EXISTENCE must not reveal the hidden outcome either.
+    let plan = null;
+    if (npc.alive && npc.state === 'transit' && npc.plan) plan = npc.plan;
+    else if (npc.lastPlan && world.t < maxEnvelopeArrival(world.galaxy, npc.lastPlan)) plan = npc.lastPlan;
+    if (!plan) continue;
+    // A ship the player can concretely see right now has no cloud.
+    if (npc.alive && npc.state === 'docked' && npc.systemId === observedSystemId) continue;
+    let segs = cloudFor(world.galaxy, plan, world.t);
+    if (observedSystemId != null) segs = excludeVisibleBand(world.galaxy, segs, observedSystemId);
+    if (segs.length > 0) out.push({ npcId, name: npc.name, segs });
+  }
+  return out;
+}
@@ -13,7 +13,8 @@ export function playerKnownPrices(world, planetId) {
  const book = p.priceBook[planetId] ?? null;
  let best = book;
  if (news && (!best || news.time > best.time)) best = news;
-  if (best && (!book || best.time > book.time)) p.priceBook[planetId] = best;
+  // Copy the envelope so the price book never aliases NewsLedger's stored snapshots.
+  if (best && (!book || best.time > book.time)) p.priceBook[planetId] = { time: best.time, prices: best.prices };
  return best ? { time: best.time, prices: best.prices, ageDays: world.t - best.time } : null;
 }

@@ -21,6 +22,7 @@ export function playerKnownPrices(world, planetId) {
 // the player's system becomes "seen" — its cloud is now player-visible forever.
 export function markSeen(world) {
  if (!world.player.alive) return;
+  if (world.player.loc.kind === 'lane') return; // no observation from hyperspace
  const sys = playerSystem(world);
  if (sys == null) return;
  for (const { npc } of shipsIn(world, sys)) world.player.seenNpcs.add(npc.id);
@@ -97,8 +97,12 @@ export function planNpc(world, npc) {
  npc.plan = {
    id: planId, good: best.good, qty: best.qty,
    originPlanet: origin.id, destPlanet: best.dest.id,
+    // Planned route (public knowledge for clouds) — unlike legs, never
+    // truncated by a hidden 'destroyed' roll.
+    routeLanes: best.route.lanes, startSys: origin.systemId,
    startTime: t, ...itin,
  };
+  npc.lastPlan = null; // superseded; v1 simplification: a fresh cloud implies the previous run ended
  npc.state = 'transit';
  world.queue.push(itin.arriveTime, 'npc-arrive', { npcId: npc.id, planId });
 }
@@ -110,6 +114,7 @@ export function onNpcArrive(world, { npcId, planId }) {
  const plan = npc.plan;
  if (plan.finalOutcome === 'destroyed') {
    npc.alive = false;
+    npc.lastPlan = plan; // cloud persists from the envelope until observed/expired
    npc.plan = null;
    npc.cargo = null;
    npc.state = 'destroyed';
@@ -125,6 +130,7 @@ export function onNpcArrive(world, { npcId, planId }) {
    npc.credits = Math.round((npc.credits + price * npc.cargo.qty) * 100) / 100;
    world.stats.trades++;
  }
+  npc.lastPlan = plan; // unobserved arrival: the player's cloud persists a while
  npc.cargo = null;
  npc.plan = null;
  world.queue.push(world.t + DOCK_DELAY, 'npc-replan', { npcId });
@@ -0,0 +1,152 @@
+import { GOODS } from '../sim/constants.js';
+import { goTo, buyGood, sellGood, playerSystem, playerMarket, cargoUsed } from '../sim/player.js';
+import { playerKnownPrices } from '../sim/knowledge.js';
+import { otherEnd } from '../sim/galaxy.js';
+
+export class Panel {
+  constructor(el, world, controls) {
+    this.el = el;
+    this.world = world;
+    this.controls = controls; // { getSpeed, setSpeed, getView, setView }
+    this.selectedSystem = null;
+    el.innerHTML = `
+      <h2>Probability</h2>
+      <div id="status"></div>
+      <div id="timeCtl"></div>
+      <h2>Navigation</h2>
+      <div id="nav"></div>
+      <h2>Market</h2>
+      <div id="market" class="muted">Dock at a planet to trade.</div>
+      <h2>Cargo</h2>
+      <div id="cargo"></div>
+      <h2>Intel</h2>
+      <div id="intel" class="muted">Click a system on the galaxy map.</div>
+      <h2>Log</h2>
+      <div id="log"></div>
+    `;
+    this.refs = Object.fromEntries(
+      ['status', 'timeCtl', 'nav', 'market', 'cargo', 'intel', 'log'].map((id) => [id, el.querySelector('#' + id)])
+    );
+    this.renderTimeControls();
+  }
+
+  renderTimeControls() {
+    const c = this.refs.timeCtl;
+    c.innerHTML = '';
+    for (const [label, value] of [['⏸', 0], ['1×', 1], ['4×', 4], ['16×', 16]]) {
+      const b = document.createElement('button');
+      b.textContent = label;
+      b.onclick = () => { this.controls.setSpeed(value); this.update(); };
+      b.dataset.speed = value;
+      c.appendChild(b);
+    }
+    const v = document.createElement('button');
+    v.textContent = 'Map / System';
+    v.onclick = () => this.controls.setView(this.controls.getView() === 'galaxy' ? 'system' : 'galaxy');
+    c.appendChild(v);
+  }
+
+  selectSystem(systemId) {
+    this.selectedSystem = systemId;
+  }
+
+  update() {
+    const w = this.world;
+    const p = w.player;
+    const sys = playerSystem(w);
+
+    let place = 'in hyperspace';
+    if (p.loc.kind === 'docked') place = w.galaxy.planets[p.loc.planetId].name;
+    else if (sys != null) place = `${w.galaxy.systems[sys].name} space`;
+    this.refs.status.innerHTML =
+      `Day ${w.t.toFixed(1)} — <b>${Math.floor(p.credits)} cr</b><br>` +
+      `${place} — cargo ${cargoUsed(p)}/${p.capacity}` +
+      (p.won ? '<br><b>VICTORY</b>' : '') + (!p.alive ? '<br><b>SHIP LOST</b>' : '');
+
+    for (const b of this.refs.timeCtl.querySelectorAll('button[data-speed]')) {
+      b.classList.toggle('active', Number(b.dataset.speed) === this.controls.getSpeed());
+    }
+
+    this.updateNav(sys);
+    this.updateMarket();
+    this.updateCargo();
+    this.updateIntel();
+    this.refs.log.innerHTML = w.log.slice(-10).reverse().map((l) => `<div>${l}</div>`).join('');
+  }
+
+  updateNav(sys) {
+    const w = this.world;
+    const nav = this.refs.nav;
+    nav.innerHTML = '';
+    if (sys == null || w.player.loc.kind === 'insys-leg' || w.player.loc.kind === 'lane') {
+      nav.innerHTML = '<span class="muted">In transit…</span>';
+      return;
+    }
+    for (const planetId of w.galaxy.systems[sys].planets) {
+      const b = document.createElement('button');
+      b.textContent = `Fly to ${w.galaxy.planets[planetId].name}`;
+      b.onclick = () => goTo(w, { planetId });
+      nav.appendChild(b);
+    }
+    for (const laneId of w.galaxy.systems[sys].lanes) {
+      const lane = w.galaxy.lanes[laneId];
+      const name = w.galaxy.systems[otherEnd(lane, sys)].name;
+      const b = document.createElement('button');
+      b.textContent = `Jump → ${name} (${lane.days}d, danger ${(lane.hazard * 100).toFixed(0)}%)`;
+      b.onclick = () => goTo(w, { laneId });
+      nav.appendChild(b);
+    }
+  }
+
+  updateMarket() {
+    const w = this.world;
+    const market = playerMarket(w);
+    if (!market) {
+      this.refs.market.innerHTML = '<span class="muted">Dock at a planet to trade.</span>';
+      return;
+    }
+    const rows = market.map((r) => `
+      <tr>
+        <td>${r.good}</td><td>${r.stock}</td><td>${r.price}</td>
+        <td>
+          <button data-act="buy" data-good="${r.good}" data-qty="1">+1</button>
+          <button data-act="buy" data-good="${r.good}" data-qty="10">+10</button>
+          <button data-act="sell" data-good="${r.good}" data-qty="1">-1</button>
+          <button data-act="sell" data-good="${r.good}" data-qty="10">-10</button>
+        </td>
+      </tr>`).join('');
+    this.refs.market.innerHTML =
+      `<table><tr><th>good</th><th>stock</th><th>price</th><th></th></tr>${rows}</table>`;
+    for (const b of this.refs.market.querySelectorAll('button')) {
+      b.onclick = () => {
+        const fn = b.dataset.act === 'buy' ? buyGood : sellGood;
+        fn(w, b.dataset.good, Number(b.dataset.qty));
+        this.update();
+      };
+    }
+  }
+
+  updateCargo() {
+    const entries = Object.entries(this.world.player.cargo);
+    this.refs.cargo.innerHTML = entries.length
+      ? entries.map(([g, q]) => `${g}: ${q}`).join('<br>')
+      : '<span class="muted">empty</span>';
+  }
+
+  updateIntel() {
+    const w = this.world;
+    if (this.selectedSystem == null) return;
+    const sys = w.galaxy.systems[this.selectedSystem];
+    let html = `<b>${sys.name}</b>`;
+    for (const planetId of sys.planets) {
+      const planet = w.galaxy.planets[planetId];
+      const known = playerKnownPrices(w, planetId);
+      html += `<br><b>${planet.name}</b> <span class="muted">(${planet.kind})</span>`;
+      if (!known) { html += '<br><span class="muted">no data</span>'; continue; }
+      const age = known.ageDays < 0.5 ? 'live' : `${known.ageDays.toFixed(0)}d old`;
+      html += ` <span class="muted">[${age}]</span><br>` +
+        GOODS.map((g) => `${g} ${known.prices[g]}`).join(', ');
+    }
+    this.refs.intel.innerHTML = html;
+  }
+}
@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { createWorld, advance } from '../src/sim/world.js';
+import { priceOf, advancePlanet } from '../src/sim/economy.js';
+import { GOODS, BASE_PRICE } from '../src/sim/constants.js';
+
+describe('balance', () => {
+  it('the NPC economy stays alive over a long horizon', () => {
+    const w = createWorld('balance-1');
+    advance(w, 120);
+    const alive = w.npcs.filter((n) => n.alive);
+    expect(alive.length).toBeGreaterThan(w.npcs.length * 0.5);
+    expect(w.stats.trades).toBeGreaterThan(w.npcs.length * 3);
+  });
+
+  it('price gradients survive NPC arbitrage (the player can still profit)', () => {
+    const w = createWorld('balance-1');
+    advance(w, 60);
+    let bestSpread = 0;
+    for (const good of GOODS) {
+      let lo = Infinity, hi = 0;
+      for (const planet of w.galaxy.planets) {
+        advancePlanet(planet, w.t);
+        const price = priceOf(good, planet.stock[good]);
+        lo = Math.min(lo, price);
+        hi = Math.max(hi, price);
+      }
+      bestSpread = Math.max(bestSpread, (hi - lo) / BASE_PRICE[good]);
+    }
+    expect(bestSpread).toBeGreaterThan(0.5); // at least one good still has a fat margin somewhere
+  });
+});
@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import { cloudFor, excludeVisibleBand, totalMass, playerClouds } from '../src/sim/clouds.js';
+
+// Synthetic 3-lane chain: systems 0-1-2-3, each lane 2 days.
+function chainGalaxy() {
+  return {
+    lanes: [
+      { id: 0, a: 0, b: 1, days: 2, hazard: 0.1 },
+      { id: 1, a: 1, b: 2, days: 2, hazard: 0.1 },
+      { id: 2, a: 2, b: 3, days: 2, hazard: 0.1 },
+    ],
+  };
+}
+
+function chainPlan() {
+  return {
+    id: 'p1', startTime: 0, arriveTime: 6, finalOutcome: 'ok',
+    originPlanet: 0, destPlanet: 1,
+    legs: [
+      { laneId: 0, fromSys: 0, toSys: 1, depart: 0, arrive: 2, outcome: 'safe' },
+      { laneId: 1, fromSys: 1, toSys: 2, depart: 2, arrive: 4, outcome: 'safe' },
+      { laneId: 2, fromSys: 2, toSys: 3, depart: 4, arrive: 6, outcome: 'safe' },
+    ],
+  };
+}
+
+const trackLength = (segs, galaxy) =>
+  segs.reduce((sum, s) => sum + (s.f1 - s.f0) * galaxy.lanes[s.laneId].days, 0);
+
+describe('clouds', () => {
+  it('total mass is 1 while the journey is plausibly in progress', () => {
+    const g = chainGalaxy();
+    const plan = chainPlan();
+    for (const t of [0.5, 1.7, 3, 4.5]) {
+      const segs = cloudFor(g, plan, t);
+      expect(segs.length).toBeGreaterThan(0);
+      expect(totalMass(segs)).toBeCloseTo(1, 5);
+      for (const s of segs) {
+        expect(s.f0).toBeGreaterThanOrEqual(0);
+        expect(s.f1).toBeLessThanOrEqual(1);
+        expect(s.f1).toBeGreaterThan(s.f0);
+      }
+    }
+  });
+
+  it('uncertainty grows with elapsed legs (cloud covers more track later)', () => {
+    const g = chainGalaxy();
+    const plan = chainPlan();
+    const early = trackLength(cloudFor(g, plan, 1.0), g);
+    const late = trackLength(cloudFor(g, plan, 4.2), g);
+    expect(late).toBeGreaterThan(early);
+  });
+
+  it('mid-journey, mass spans more than one lane', () => {
+    const g = chainGalaxy();
+    const segs = cloudFor(g, chainPlan(), 3.5);
+    expect(new Set(segs.map((s) => s.laneId)).size).toBeGreaterThanOrEqual(2);
+  });
+
+  it('excludeVisibleBand removes the observed band and renormalizes', () => {
+    const segs = [
+      { laneId: 0, fromSys: 0, toSys: 1, f0: 0.0, f1: 0.5, w: 0.5 },
+      { laneId: 0, fromSys: 0, toSys: 1, f0: 0.5, f1: 1.0, w: 0.5 },
+    ];
+    // Player sits in system 1: the band f > 0.85 on this lane is visible.
+    const out = excludeVisibleBand({ lanes: [{ id: 0, a: 0, b: 1, days: 2 }] }, segs, 1);
+    expect(totalMass(out)).toBeCloseTo(1, 5);
+    for (const s of out) expect(s.f1).toBeLessThanOrEqual(0.85 + 1e-9);
+  });
+
+  it('returns empty for finished or empty plans', () => {
+    const g = chainGalaxy();
+    expect(cloudFor(g, chainPlan(), 99)).toEqual([]);
+    expect(cloudFor(g, { ...chainPlan(), legs: [] }, 1)).toEqual([]);
+  });
+
+  it('a hidden destroyed outcome does not change the cloud shape', () => {
+    const g = chainGalaxy();
+    const intact = chainPlan();
+    intact.routeLanes = [0, 1, 2];
+    intact.startSys = 0;
+    const doomed = chainPlan();
+    doomed.routeLanes = [0, 1, 2];
+    doomed.startSys = 0;
+    doomed.finalOutcome = 'destroyed';
+    doomed.legs = doomed.legs.slice(0, 1); // itinerary truncated at the hidden destruction
+    for (const t of [1, 3, 4.5]) {
+      expect(JSON.stringify(cloudFor(g, doomed, t))).toBe(JSON.stringify(cloudFor(g, intact, t)));
+    }
+  });
+
+  it('a cloud persists after a hidden early arrival or destruction until the envelope expires', () => {
+    const g = chainGalaxy();
+    const lastPlan = chainPlan();
+    lastPlan.routeLanes = [0, 1, 2];
+    lastPlan.startSys = 0;
+    const world = {
+      t: 4.5, // past a truncated arrival, inside the envelope (max = 6 * 1.15 * 1.6 = 11.04)
+      galaxy: g,
+      npcs: [{ id: 0, name: 'Ghost', alive: false, state: 'destroyed', plan: null, lastPlan }],
+      player: { seenNpcs: new Set([0]) },
+    };
+    expect(playerClouds(world, null).length).toBe(1);
+    world.t = 12; // envelope exhausted: cloud finally gone
+    expect(playerClouds(world, null)).toEqual([]);
+  });
+});
@@ -0,0 +1,5 @@
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  build: { target: 'esnext' }, // modern output target
+});
Author	SHA1	Message	Date
tes	36838efa73	chore: decline release-notes prompts for this repo	2026-06-12 15:42:23 +00:00
tes	051a111855	fix: prod-bundle boot, cloud-existence leak, observation gating (final review) - Wrap main.js body in async main() to eliminate top-level await deadlock in Rollup - Add npc.lastPlan so clouds persist after hidden arrival/destruction until analytic envelope expires - Add maxEnvelopeArrival() helper; rewrite playerClouds() to use lastPlan for envelope-gated clouds - Block markSeen() while player is mid-lane (no observation from hyperspace) - Pass obsSys=null to playerClouds when player is in a lane (don't exclude visible band from hyperspace) - Galaxy map clicks now select-only (intel); jumps via Nav buttons / gate diamonds only - Add preview script, favicon no-op, .playwright-mcp/ and *.png to .gitignore, update README controls text	2026-06-12 15:35:20 +00:00
tes	395c0e851d	feat: balance checks and README - v1 complete	2026-06-12 15:18:48 +00:00
tes	a32749c14a	fix: floor gate ring radius for tiny canvases (review)	2026-06-12 15:16:59 +00:00
tes	7726651c69	feat: UI panel, time controls, full playable trading loop - Add src/ui/panel.js: sidebar with status, time controls (⏸/1×/4×/16×/Map-System toggle), navigation buttons, market table with buy/sell, cargo display, intel panel with price age tags, and a 10-entry log (newest first). - Replace src/main.js: wires Panel + GalaxyView + SystemView together; game clock driven by PixiJS ticker at configurable DAYS_PER_SEC; panel DOM refresh at 4 Hz; VICTORY/SHIP LOST banner on end state; speed/view state via controls closure. - Amendment A (systemView.js): gateXY uses canvas-proportional radius (min(GATE_RADIUS, min(c.x,c.y)-40)) so gates stay on-screen on small canvases. - Amendment B (main.js): keydown handler guards e.target !== document.body to avoid hijacking keys from focused panel buttons. - Amendment C (main.js): renderer resize event rebuilds GalaxyView static geometry and clears SystemView cache so cached transforms don't go stale.	2026-06-12 15:13:58 +00:00
tes	881518417a	feat: system view with star, planets, gates, concrete ships	2026-06-12 14:56:06 +00:00
tes	61244453e3	feat: neon galaxy view with bloom, hazard tints, clouds	2026-06-12 14:47:51 +00:00
tes	ca32407c43	fix: compute clouds from planned route so destruction cannot leak (review)	2026-06-12 14:44:24 +00:00
tes	f563934314	feat: probability clouds with envelope math and band exclusion	2026-06-12 14:38:50 +00:00
tes	2da0bee712	fix: decouple price book entries from news ledger snapshots (review)	2026-06-12 14:36:39 +00:00